diff --git a/.dockerignore b/.dockerignore
index f9bc435f..5ae987fb 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -4,6 +4,7 @@
 *.env.local
 **/__pycache__/
 **/*.pyc
+**/.coverage
 .venv/
 venv/
 # Docker patterns are anchored at the context root with NO implicit `**/` (unlike .gitignore, where
diff --git a/.gitea/workflows/check.yml b/.gitea/workflows/check.yml
index 017d6393..7bd1487a 100644
--- a/.gitea/workflows/check.yml
+++ b/.gitea/workflows/check.yml
@@ -1,7 +1,9 @@
 # Server-side mirror of the local `siftlode check` gate (E1 S3 / DX-1), so `main` is always green
 # independent of any one machine. Two jobs match the two local lanes:
-#   frontend — tsc (3 projects) + eslint + prettier --check + knip + vitest
-#   backend  — ruff + the full pytest suite (pure-logic + the DB-backed lane) against a real Postgres
+#   frontend — tsc (3 projects) + eslint + prettier --check + knip (both modes) + vitest + vite build
+#              + npm audit of the production dependencies
+#   backend  — ruff + basedpyright + the full pytest suite (pure-logic + the DB-backed lane) against
+#              a real Postgres + pip-audit of the lock
 #
 # They are declared side by side but they DO NOT run in parallel: the lab has a single act_runner
 # with one slot, so they queue. Measured across runs #86-#91 — the backend job starts at the exact
@@ -56,6 +58,12 @@ jobs:
       - run: npm run format:check
       - run: npm run knip
       - run: npm run test
+      # The production bundle (E32): before this, `vite build` — and devOnlyGuard, which fails it if
+      # dev-only code reaches the bundle — first ran inside the image build, after main was pushed.
+      - run: npx vite build
+      # What ships to the browser: a known CVE at high or above in a production dependency fails.
+      # (The dev tooling's own advisories are burned down by hand; see docs/gates.md.)
+      - run: npm audit --omit=dev --audit-level=high
 
   backend:
     runs-on: ubuntu-latest
@@ -112,8 +120,9 @@ jobs:
       - name: pytest
         run: python -m pytest
         working-directory: backend
-      # Dependency CVE audit over the pinned lock. Non-blocking for now (informational) — a real CVE
-      # shows up in the run without failing the gate; tighten to a hard fail once the noise is known.
-      - name: pip-audit (advisory)
+      # Dependency CVE audit over the pinned lock. BLOCKING since E32: it ran advisory-only, and when
+      # it was finally read it had three urllib3 advisories with a fix available (bumped in the same
+      # change). An advisory without a fix is answered with `--ignore-vuln <id>` here, a reason and a
+      # date in the comment, and a line in docs/gates.md.
+      - name: pip-audit
         run: pip install --no-cache-dir pip-audit && pip-audit -r backend/requirements.lock
-        continue-on-error: true
diff --git a/.gitignore b/.gitignore
index d5349a1d..d034f201 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,7 @@ __pycache__/
 venv/
 .mypy_cache/
 .pytest_cache/
+.coverage
 .ruff_cache/
 
 # Node / frontend
diff --git a/.trivyignore.yaml b/.trivyignore.yaml
new file mode 100644
index 00000000..79dbc1c5
--- /dev/null
+++ b/.trivyignore.yaml
@@ -0,0 +1,15 @@
+# The CVE gate's allowlist (E32). The publish gate scans the built image and the committed tree with
+# Trivy and fails on any HIGH or CRITICAL finding that has a fix available. A finding that cannot be
+# fixed yet is let through ONLY by an entry here, and every entry carries both:
+#   statement   — why it is acceptable for now (what is exposed, what is not)
+#   expired_at  — the date it stops being accepted; after it, the gate fails again on its own
+# A contract test (frontend/src/lib/gates.contract.test.ts) refuses an entry without either, and
+# docs/gates.md lists them.
+#
+# Example:
+#   vulnerabilities:
+#     - id: CVE-2026-00000
+#       statement: in libfoo's XML path, which nothing in the image calls; no fixed Debian build yet
+#       expired_at: 2026-12-31
+vulnerabilities: []
+secrets: []
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 216079a2..e1772831 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,25 @@ edit the release notes and re-run the generator.
 
 Upgrading, pinning a version and rolling back: [docs/self-hosting.md](docs/self-hosting.md#upgrading).
 
+## 0.99.0 — 2026-10-04
+
+### New
+
+- Nearly every screen is now compiled by the React Compiler, so lists and menus re-render less.
+- The channel list's row menu opens and closes without redrawing the table.
+
+### Fixed
+
+- A failed or empty answer from YouTube or Plex no longer empties a playlist, a mirror or your Plex watch history: Siftlode keeps what it had until a complete answer arrives.
+- Plex watch states un-watched on Plex now sync for each library on its own, even if another library is briefly unreachable.
+- A channel with no uploads no longer fails its backfill on every run.
+- “This playlist no longer exists” appears only for a list you picked yourself.
+- A filter on a deleted tag matches nothing and its chip says so, and the tag cleanup keeps tags a saved view filters on.
+- A channel filter names its channels from the first moment, and a playlist reopened from the cache keeps its rows.
+- The bug report opens on its title, and a dialog whose form loads late gives the form the focus once.
+- The Plex backdrop crossfade setting is respected even with reduced motion on.
+- Smaller fixes to keyboard focus, undo and loading states.
+
 ## 0.98.0 — 2026-10-03
 
 ### New
diff --git a/CLAUDE.md b/CLAUDE.md
index 5a0f01ea..4eb2e8ee 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -12,12 +12,15 @@ router-free navigation provider.
 
 ## The gate — never merge or ship red
 
-The local gate is **ruff (`check` + `format --check`) + basedpyright (backend) + typecheck (3 tsc projects) + eslint + prettier
---check + knip + vitest + pytest**. It runs on every `publish`, which **refuses to build on failure — there is deliberately no
-`--skip` flag.** Run it and get it green **before** any merge, release, or handing work to review.
+The local gate is **ruff (`check` + `format --check`) + basedpyright (backend) + the lock check + typecheck (3 tsc projects) +
+eslint + prettier --check + knip (both modes) + vitest + vite build + pytest**, then a coverage report (no threshold). It runs
+before every `release` merges and on every `publish`, which **refuses to build on failure — there is deliberately no `--skip`
+flag**; a release also requires the Playwright suite, and the image must pass a Trivy scan before it is pushed. Run it and get it
+green **before** any merge, release, or handing work to review.
 
 - Full gate (agents with the private ops dispatcher): `siftlode check`.
-- Directly, without the dispatcher: `cd frontend && npm run typecheck && npm run lint && npm run knip && npm run test`, plus backend `ruff check backend` + `ruff format --check backend` and `pytest` (the DB-lane needs Postgres).
+- Directly, without the dispatcher: the commands in [`docs/development.md`](docs/development.md) § The gate (frontend lanes, `ruff` over `backend scripts`, basedpyright in the test image, and `pytest` — the DB-lane needs Postgres).
+- **A gate with any real hit is never switched off or narrowed** — not a lint rule, a compiler flag, a lane or a release step. Fix the sites, or suppress each one inline naming its invariant (`-- why`, lint-enforced). What stays narrowed is in [`docs/gates.md`](docs/gates.md), and a contract test fails when a narrowing is missing from it. The effective ESLint config of every file and the CI/lane lines are pinned in `frontend/src/lib/gates.snapshot.json`: a new code file or any gate change fails until you regenerate it (`GATE_SNAPSHOT=update`, see gates.md) — then read that diff as a gate change. A comment saying "X is enforced by Y" is checked by running Y (E32: one such comment hid 95 functions the React Compiler skipped).
 - **The backend type lane runs in the test image, not on the host** — `requirements.lock` cannot be installed on Windows (uvloop), and a type checker without the real packages reports nonsense. It fails on NEW errors only; the pre-existing ones sit in `backend/.basedpyright/baseline.json` and burn down epic by epic. Fixed some? Regenerate with `--writebaseline`.
 - New DB-backed test? It must actually run, not silently skip — assume `SIFTLODE_TEST_REQUIRE_DB=1`.
 
@@ -77,37 +80,39 @@ CQRS, a repository/DI framework, a router library, a generic CRUD-router factory
 
 ## Canonical patterns — when you have a choice, pick THIS
 
-| Area                                 | Use                                                                                                                     | Not                                                                                  |
-| ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
-| ORM                                  | SQLAlchemy 2.0 `select()`                                                                                               | `db.query(...)`                                                                      |
-| Request body                         | a Pydantic model                                                                                                        | `payload: dict`                                                                      |
-| Request SIZE                         | nothing — `bodylimit` caps every route (SEC-20); need more? add a ceiling to `ROUTE_MAX_BODY_BYTES`                     | `capped_body` on a route that does not read raw bytes itself                         |
-| Ownership check                      | `owned_or_404` / `get_or_404`                                                                                           | ad-hoc `_own_playlist`/`_owned`/`_own_job`                                           |
-| Admin gate import                    | `app.auth`                                                                                                              | the `app.routes.admin` re-export                                                     |
-| Upstream failure status              | `422` with JSON detail                                                                                                  | `502` (reserve 502 for raw byte-proxies)                                             |
-| User-facing error                    | structured `detail` (`{code, reason}`)                                                                                  | a bare English string under a bilingual UI                                           |
-| Mutation response                    | `{"ok": true, …}` (`{"deleted": id}`), test-held                                                                        | a bare `{"unsubscribed"}`/`{"cleared": n}`, no `ok`                                  |
-| Transaction commit                   | the handler commits; helpers `flush` (test-held list)                                                                   | helpers that commit (only `quota` owns its session)                                  |
-| Admin knob storage                   | `sysconfig` (values)                                                                                                    | env / `app_state` / `scheduler_settings` scatter                                     |
-| Job status word                      | the `downloads/status.py` StrEnum                                                                                       | loose `"canceled"`/`"cancelled"` literals                                            |
-| Current time                         | inline `datetime.now(timezone.utc)`                                                                                     | new `now_utc`/`_now` helpers                                                         |
-| FE per-account state                 | `usePref`                                                                                                               | raw `readAccount`/`writeAccount` or bespoke hooks                                    |
-| FE button                            | `ui/Button` (a `SIZES` rung) · `IconButton` · `Pressable` (a clickable card/row) · `Chip` · `DragHandle`                | a raw `<button>` or `FocusSafeButton` outside the control primitives (lint-enforced) |
-| FE keyboard shortcut                 | a row in `lib/keymap.ts` + `dispatch()`                                                                                 | a private `keydown` listener with its own key literals                               |
-| FE list/grid keys                    | `NavGrid`/`keyboardNav` + `navItemAttrs` + `data-nav-open`                                                              | a private arrow-key / roving-tabindex handler                                        |
-| FE view push (history)               | `rememberNavPosition()` right before `history.pushState`                                                                | a push that forgets: Back strands focus on `<body>`                                  |
-| FE text field / checkbox / slider    | `ui/Input` · `Textarea` · `InnerInput` in a `fieldClass` frame · `Checkbox`/`CheckRow` · `Slider`                       | a raw `<input>`/`<textarea>` anywhere but those primitives (lint-enforced)           |
-| FE glass surface                     | a role: `SURFACE.panel` / `card` / `menu` / `popover` / `tooltip` (`ui/surfaces.ts`)                                    | a bare `glass`/`glass-card`/`glass-menu` beside a hand-picked radius (lint-enforced) |
-| FE static label / button-like link   | `Badge` (flat, no edge) · `LinkButton` / `IconLink`                                                                     | a glass pill that reads as a chip; an `<a>` hand-painted like a button               |
-| FE control                           | `SegmentedToggle`; a long or user's list: `FilterSelect`                                                                | a native `<select>` (lint-enforced)                                                  |
-| FE loading/empty/error               | `QueryState` / `StateMessage`                                                                                           | ad-hoc conditionals                                                                  |
-| FE failed write                      | `meta.failTitle`, else `notifyActionError(err, title)`                                                                  | a bare `catch {}` or `notify()` with no error attached                               |
-| FE network call                      | `req`/`uploadReq`/`beacon`, or `lib/http.ts` `send` (public pages)                                                      | a bare `fetch`/`XMLHttpRequest`/`WebSocket` (lint-enforced)                          |
-| FE diagnostics                       | `lib/log.ts` (`log.info("event.code", msg, attrs)`); a filter change → `lib/filterLog.ts`, a player → `lib/mediaLog.ts` | `console.*` (lint-enforced); a value only a higher level may carry, logged unguarded |
-| FE state that MIRRORS a prop/query   | derive it, or hold a draft (`draft ?? server`)                                                                          | a copy an effect re-syncs — that paints the stale value first                        |
-| FE state reset on a key change       | adjust it DURING render against a remembered key                                                                        | `useEffect(() => setX(init), [key])`                                                 |
-| FE effect that must not re-subscribe | `useEffectEvent` (React 19.2+), else a latest-value ref                                                                 | an excused dep list asserting the same thing in prose                                |
-| FE hook suppression                  | an inline `eslint-disable-next-line` NAMING the invariant                                                               | `eslint-suppressions.json` (deliberately absent — E27 S2)                            |
+| Area                                 | Use                                                                                                                                                                                               | Not                                                                                                                                                     |
+| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ORM                                  | SQLAlchemy 2.0 `select()`                                                                                                                                                                         | `db.query(...)`                                                                                                                                         |
+| Request body                         | a Pydantic model                                                                                                                                                                                  | `payload: dict`                                                                                                                                         |
+| Request SIZE                         | nothing — `bodylimit` caps every route (SEC-20); need more? add a ceiling to `ROUTE_MAX_BODY_BYTES`                                                                                               | `capped_body` on a route that does not read raw bytes itself                                                                                            |
+| Ownership check                      | `owned_or_404` / `get_or_404`                                                                                                                                                                     | ad-hoc `_own_playlist`/`_owned`/`_own_job`                                                                                                              |
+| Admin gate import                    | `app.auth`                                                                                                                                                                                        | the `app.routes.admin` re-export                                                                                                                        |
+| Upstream failure status              | `422` with JSON detail                                                                                                                                                                            | `502` (reserve 502 for raw byte-proxies)                                                                                                                |
+| User-facing error                    | structured `detail` (`{code, reason}`)                                                                                                                                                            | a bare English string under a bilingual UI                                                                                                              |
+| Mutation response                    | `{"ok": true, …}` (`{"deleted": id}`), test-held                                                                                                                                                  | a bare `{"unsubscribed"}`/`{"cleared": n}`, no `ok`                                                                                                     |
+| Transaction commit                   | the handler commits; helpers `flush` (test-held list)                                                                                                                                             | helpers that commit (only `quota` owns its session)                                                                                                     |
+| Admin knob storage                   | `sysconfig` (values)                                                                                                                                                                              | env / `app_state` / `scheduler_settings` scatter                                                                                                        |
+| Job status word                      | the `downloads/status.py` StrEnum                                                                                                                                                                 | loose `"canceled"`/`"cancelled"` literals                                                                                                               |
+| Current time                         | inline `datetime.now(timezone.utc)`                                                                                                                                                               | new `now_utc`/`_now` helpers                                                                                                                            |
+| FE per-account state                 | `usePref`                                                                                                                                                                                         | raw `readAccount`/`writeAccount` or bespoke hooks                                                                                                       |
+| FE button                            | `ui/Button` (a `SIZES` rung) · `IconButton` · `Pressable` (a clickable card/row) · `Chip` · `DragHandle`                                                                                          | a raw `<button>` or `FocusSafeButton` outside the control primitives (lint-enforced)                                                                    |
+| FE keyboard shortcut                 | a row in `lib/keymap.ts` + `dispatch()`                                                                                                                                                           | a private `keydown` listener with its own key literals                                                                                                  |
+| FE list/grid keys                    | `NavGrid`/`keyboardNav` + `navItemAttrs` + `data-nav-open`                                                                                                                                        | a private arrow-key / roving-tabindex handler                                                                                                           |
+| FE view push (history)               | `rememberNavPosition()` right before `history.pushState`                                                                                                                                          | a push that forgets: Back strands focus on `<body>`                                                                                                     |
+| FE text field / checkbox / slider    | `ui/Input` · `Textarea` · `InnerInput` in a `fieldClass` frame · `Checkbox`/`CheckRow` · `Slider`                                                                                                 | a raw `<input>`/`<textarea>` anywhere but those primitives (lint-enforced)                                                                              |
+| FE glass surface                     | a role: `SURFACE.panel` / `card` / `menu` / `popover` / `tooltip` (`ui/surfaces.ts`)                                                                                                              | a bare `glass`/`glass-card`/`glass-menu` beside a hand-picked radius (lint-enforced)                                                                    |
+| FE static label / button-like link   | `Badge` (flat, no edge) · `LinkButton` / `IconLink`                                                                                                                                               | a glass pill that reads as a chip; an `<a>` hand-painted like a button                                                                                  |
+| FE control                           | `SegmentedToggle`; a long or user's list: `FilterSelect`                                                                                                                                          | a native `<select>` (lint-enforced)                                                                                                                     |
+| FE loading/empty/error               | `QueryState` / `StateMessage`                                                                                                                                                                     | ad-hoc conditionals                                                                                                                                     |
+| FE failed write                      | `meta.failTitle`, else `notifyActionError(err, title)`                                                                                                                                            | a bare `catch {}` or `notify()` with no error attached                                                                                                  |
+| FE network call                      | `req`/`uploadReq`/`beacon`, or `lib/http.ts` `send` (public pages)                                                                                                                                | a bare `fetch`/`XMLHttpRequest`/`WebSocket` (lint-enforced)                                                                                             |
+| FE diagnostics                       | `lib/log.ts` (`log.info("event.code", msg, attrs)`); a filter change → `lib/filterLog.ts`, a player → `lib/mediaLog.ts`                                                                           | `console.*` (lint-enforced); a value only a higher level may carry, logged unguarded                                                                    |
+| FE state that MIRRORS a prop/query   | derive it, or hold a draft (`draft ?? server`)                                                                                                                                                    | a copy an effect re-syncs — that paints the stale value first                                                                                           |
+| FE state reset on a key change       | adjust it DURING render against a remembered key                                                                                                                                                  | `useEffect(() => setX(init), [key])`                                                                                                                    |
+| FE effect that must not re-subscribe | `useEffectEvent` (React 19.2+); a handler or timer: `useLatest` / `useStableCallback`                                                                                                             | a render-phase `ref.current = x` — the React Compiler skips the component                                                                               |
+| FE hook suppression                  | an inline `eslint-disable-next-line` NAMING the invariant                                                                                                                                         | `eslint-suppressions.json` (deliberately absent — E27 S2)                                                                                               |
+| FE popover / scroll-fade ref         | destructure it: `const { setReference } = pop.refs`, then `ref={setReference}`                                                                                                                    | `ref={pop.refs.setReference}` / `ref={fade.ref}` — the compiler then treats the whole object as a ref and skips                                         |
+| FE async handler with cleanup        | `try { … } catch { … }`, then the cleanup after it (steps that `return` early go in their own function); a conditional, loop or `?.` the `try` needs goes before it or into a module-level helper | `try/finally`, or a `?:` / `??` / loop / `?.` inside `try` — the React Compiler skips the whole component (and `react-hooks/todo` misses most of these) |
 
 ## House rules that bite (learned from real bugs)
 
diff --git a/Dockerfile b/Dockerfile
index d6b362c5..c1c69b2a 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -53,8 +53,11 @@ RUN adduser --disabled-password --gecos "" appuser \
 # Harmless on hosts with no /dev/dri (the driver just goes unused). Deno: the JavaScript runtime yt-dlp
 # uses to solve YouTube's "n" signature challenge for the web player clients (required alongside the PO
 # token, else only storyboards are offered). yt-dlp auto-detects deno on PATH.
+# `apt-get upgrade` (E32): the base image is a snapshot, and the Debian security fixes released since it
+# was cut are only in the archive — the first Trivy scan found one (pcre2) fixed upstream but not in it.
 ARG DENO_VERSION=v2.9.1
 RUN apt-get update \
+    && apt-get upgrade -y --no-install-recommends \
     && apt-get install -y --no-install-recommends ffmpeg intel-media-va-driver unzip curl ca-certificates \
     && curl -fsSL "https://github.com/denoland/deno/releases/download/${DENO_VERSION}/deno-x86_64-unknown-linux-gnu.zip" -o /tmp/deno.zip \
     && unzip -o /tmp/deno.zip -d /usr/local/bin \
@@ -78,9 +81,12 @@ RUN printf 'Types: deb\nURIs: http://deb.debian.org/debian\nSuites: bookworm\nCo
 # Install from the PINNED lock (requirements.lock, generated from requirements.txt) so the image is
 # byte-reproducible and the exact versions are the ones pip-audit scanned in CI — not whatever floats
 # up from the floor ranges on build day. Regenerate the lock when requirements.txt changes (see its header).
+# pip itself is removed once it has installed the lock (E32): nothing runs it at runtime, and it carries
+# its own VENDORED copies of urllib3, msgpack and setuptools, which Trivy reports as the image's own —
+# an attack surface and a CVE stream for a tool the running app never calls.
 COPY backend/requirements.lock .
 RUN --mount=type=cache,target=/root/.cache/pip \
-    pip install --upgrade pip && pip install -r requirements.lock
+    pip install --upgrade pip && pip install -r requirements.lock && pip uninstall -y pip
 
 COPY --chown=appuser backend/ .
 # Read at runtime by config.py as the app_version (a committed single source of truth).
diff --git a/VERSION b/VERSION
index 95fce8ca..01781720 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.98.0
+0.99.0
diff --git a/backend/.basedpyright/baseline.json b/backend/.basedpyright/baseline.json
index a438d546..2a942acc 100644
--- a/backend/.basedpyright/baseline.json
+++ b/backend/.basedpyright/baseline.json
@@ -548,64 +548,6 @@
                 }
             }
         ],
-        "./app/plex/stream.py": [
-            {
-                "code": "reportOptionalMemberAccess",
-                "range": {
-                    "startColumn": 51,
-                    "endColumn": 55,
-                    "lineCount": 1
-                }
-            },
-            {
-                "code": "reportOptionalMemberAccess",
-                "range": {
-                    "startColumn": 23,
-                    "endColumn": 25,
-                    "lineCount": 1
-                }
-            },
-            {
-                "code": "reportOptionalMemberAccess",
-                "range": {
-                    "startColumn": 18,
-                    "endColumn": 31,
-                    "lineCount": 1
-                }
-            },
-            {
-                "code": "reportOptionalMemberAccess",
-                "range": {
-                    "startColumn": 75,
-                    "endColumn": 79,
-                    "lineCount": 1
-                }
-            },
-            {
-                "code": "reportOptionalMemberAccess",
-                "range": {
-                    "startColumn": 10,
-                    "endColumn": 23,
-                    "lineCount": 1
-                }
-            },
-            {
-                "code": "reportOptionalMemberAccess",
-                "range": {
-                    "startColumn": 10,
-                    "endColumn": 12,
-                    "lineCount": 1
-                }
-            },
-            {
-                "code": "reportOptionalMemberAccess",
-                "range": {
-                    "startColumn": 10,
-                    "endColumn": 17,
-                    "lineCount": 1
-                }
-            }
-        ],
         "./app/plex/sync.py": [
             {
                 "code": "reportArgumentType",
@@ -638,14 +580,6 @@
                     "endColumn": 89,
                     "lineCount": 1
                 }
-            },
-            {
-                "code": "reportArgumentType",
-                "range": {
-                    "startColumn": 17,
-                    "endColumn": 18,
-                    "lineCount": 1
-                }
             }
         ],
         "./app/plex/tmdb.py": [
@@ -1650,24 +1584,6 @@
                     "endColumn": 36,
                     "lineCount": 1
                 }
-            },
-            {
-                "code": "reportArgumentType",
-                "range": {
-                    "startColumn": 46,
-                    "endColumn": 52,
-                    "lineCount": 1
-                }
-            }
-        ],
-        "./app/youtube/rss.py": [
-            {
-                "code": "reportGeneralTypeIssues",
-                "range": {
-                    "startColumn": 10,
-                    "endColumn": 15,
-                    "lineCount": 1
-                }
             }
         ]
     }
diff --git a/backend/app/README.md b/backend/app/README.md
index ec7ba9ef..b7c885c5 100644
--- a/backend/app/README.md
+++ b/backend/app/README.md
@@ -72,7 +72,9 @@ mutation it records, so an audit entry can never exist without its change (or vi
 ## The gate
 
 Everything below must be green before a change is done (run via `siftlode check`):
-`ruff` (backend) · `tsc` ×3 + `eslint` + `prettier` + `knip` (frontend) · `vitest` · `pytest`. The
-pytest lane runs in `backend/docker-compose.test.yml` — an ephemeral Postgres + the backend tree
-bind-mounted — so the DB-backed integration tests (the `db` fixture) actually run; `SIFTLODE_TEST_
-REQUIRE_DB=1` there turns a would-be silent skip into a hard failure. See `docs/development.md`.
+`ruff` + `basedpyright` (backend) · the lock check + `tsc` ×3 + `eslint` + `prettier` + `knip` +
+`vite build` (frontend) · `vitest` · `pytest`. The pytest lane runs in `backend/docker-compose.test.yml`
+— an ephemeral Postgres + the backend tree bind-mounted — so the DB-backed integration tests (the `db`
+fixture) actually run; a missing database is a hard failure, not a silent skip, unless a hand run asks
+for pure-logic only with `SIFTLODE_TEST_REQUIRE_DB=0`. See `docs/development.md`, and `docs/gates.md`
+for what each gate deliberately leaves out.
diff --git a/backend/app/bodylimit.py b/backend/app/bodylimit.py
index d2847387..5b4dc3a5 100644
--- a/backend/app/bodylimit.py
+++ b/backend/app/bodylimit.py
@@ -219,7 +219,7 @@ class BodyLimitMiddleware:
 
         try:
             await self.app(scope, counting_receive, guarded_send)
-        except Exception:  # noqa: BLE001 — only swallowed when WE caused it, see below
+        except Exception:  # only swallowed when WE caused it, see below
             # ClientDisconnect (or whatever a handler raises on a truncated read) is the expected
             # consequence of the disconnect we just faked, and the caller must get the 413 rather
             # than a 500. Anything raised when we did NOT refuse is a real failure and is re-raised
diff --git a/backend/app/downloads/edit.py b/backend/app/downloads/edit.py
index d4967169..24498872 100644
--- a/backend/app/downloads/edit.py
+++ b/backend/app/downloads/edit.py
@@ -400,7 +400,7 @@ def escalate_kill(proc: subprocess.Popen, terminate, kill, grace_s: float, label
     try:
         proc.wait(timeout=grace_s)
     except subprocess.TimeoutExpired:
-        # noqa TRY400: the exception IS the message here. A TimeoutExpired's traceback is this
+        # TRY400: the exception IS the message here. A TimeoutExpired's traceback is this
         # `wait` call and nothing else — it would add three frames and no fact the line lacks.
         log.error("%s pid %s survived SIGKILL", label, proc.pid)  # noqa: TRY400
 
@@ -456,7 +456,7 @@ def run_ffmpeg(
         try:
             ret = proc.wait(timeout=_FFMPEG_EXIT_GRACE_S)
         except subprocess.TimeoutExpired:  # pipes closed but the process lingers
-            raise StatedFailure("ffmpeg did not exit after closing its output")
+            raise StatedFailure("ffmpeg did not exit after closing its output") from None
     except BaseException:
         # ONE exit path stops the process, so the invariant is unconditional: nothing leaves this
         # function with ffmpeg still running. Not just our own EditAborted/stall — `on_progress`
diff --git a/backend/app/downloads/runner.py b/backend/app/downloads/runner.py
index ac87b6c1..b609e32e 100644
--- a/backend/app/downloads/runner.py
+++ b/backend/app/downloads/runner.py
@@ -57,7 +57,7 @@ def main() -> None:
     logs.configure_logging("runner")
     _deprioritize()
     if len(sys.argv) != 2:
-        # noqa T201: a usage line is for the person who typed the command. Logging is already
+        # T201: a usage line is for the person who typed the command. Logging is already
         # configured here, and in a deployment it writes JSON records — the one reader of this
         # line wants the bare sentence, not a record with a request id they do not have.
         print(  # noqa: T201
@@ -104,7 +104,7 @@ def _run(job_id, asset_id, job_kind, source_kind, source_ref, spec, user_id) ->
             else:
                 _download(job_id, asset_id, source_kind, source_ref, spec, user_id)
         except Exception as exc:  # noqa: BLE001 — whatever it is, it is reported here or raw
-            # noqa TRY400: the stack goes with it scrubbed (`scrubbed_stack`); `exc_info` is raw.
+            # TRY400: the stack goes with it scrubbed (`scrubbed_stack`); `exc_info` is raw.
             log.error(  # noqa: TRY400
                 "the download child for job %s failed",
                 job_id,
diff --git a/backend/app/feedquery.py b/backend/app/feedquery.py
index f612b8ca..aa84af0e 100644
--- a/backend/app/feedquery.py
+++ b/backend/app/feedquery.py
@@ -106,15 +106,30 @@ def _tag_visible(user: User):
     return or_(ChannelTag.user_id.is_(None), ChannelTag.user_id == user.id)
 
 
-def tags_by_category(db: Session, tag_ids: list[int]) -> dict[str, list[int]]:
+# The pseudo-category of a selected tag id no Tag row answers (a saved view or the feed state outlives
+# a deleted tag). It filters like a category whose tags no channel carries — to nothing, in the SQL and
+# in feed_summary's mirror alike — instead of the id being dropped, which showed the WHOLE feed under
+# the view's old name (E32 S2). No real category is called this (language/topic/other).
+MISSING_TAG_CATEGORY = "missing"
+
+
+def tags_by_category(db: Session, user: User, tag_ids: list[int]) -> dict[str, list[int]]:
     """Group tag ids by their category (language/topic/other). The single source for the category split
     shared by the feed's tag WHERE (filtered_query) and the facet/count summary (feed_summary), so the
-    two can't disagree on which selected tag belongs to which category."""
+    two can't disagree on which selected tag belongs to which category. An unknown id lands in
+    MISSING_TAG_CATEGORY — and so does another user's private tag: resolving it to its real category
+    told the caller which foreign ids exist (E32 review)."""
     if not tag_ids:
         return {}  # skip the pointless `WHERE id IN ()` round-trip on the no-tag-filter hot path
     out: dict[str, list[int]] = {}
-    for tid, cat in db.execute(select(Tag.id, Tag.category).where(Tag.id.in_(tag_ids))).all():
+    visible = or_(Tag.user_id.is_(None), Tag.user_id == user.id)
+    for tid, cat in db.execute(
+        select(Tag.id, Tag.category).where(Tag.id.in_(tag_ids), visible)
+    ).all():
         out.setdefault(cat, []).append(tid)
+    known = {tid for ids in out.values() for tid in ids}
+    if missing := [tid for tid in tag_ids if tid not in known]:
+        out[MISSING_TAG_CATEGORY] = missing
     return out
 
 
@@ -304,7 +319,7 @@ def filtered_query(
         # ALL its selected tags. ⚠️ feed_summary.passes() reimplements this exact rule in Python for the
         # sidebar count/facets — keep the two in lockstep (equivalence-tested by
         # test_feed_summary_matches_count_plus_facets).
-        by_category = tags_by_category(db, tags)
+        by_category = tags_by_category(db, user, tags)
         # Facet counting drops the category being counted so its own chips don't zero each
         # other out (standard drill-down faceting: a category's count ignores its own
         # selections but still honours the other categories' filters).
@@ -395,7 +410,7 @@ def feed_summary(db: Session, user: User, **params) -> dict:
         return {"count": 0, "facets": {}}
 
     # channel -> its visible tag ids, plus each tag's category (for grouping the facet output).
-    visible = or_(ChannelTag.user_id.is_(None), ChannelTag.user_id == user.id)
+    visible = _tag_visible(user)
     channel_tags: dict[str, set[int]] = {}
     tag_category: dict[int, str] = {}
     for cid, tid, cat in db.execute(
@@ -410,7 +425,7 @@ def feed_summary(db: Session, user: User, **params) -> dict:
     # base channel carries still filters everything out for its category — matching the SQL `IN (empty)`
     # behaviour).
     selected_by_cat: dict[str, set[int]] = {
-        cat: set(ids) for cat, ids in tags_by_category(db, params.get("tags") or []).items()
+        cat: set(ids) for cat, ids in tags_by_category(db, user, params.get("tags") or []).items()
     }
 
     def passes(ch_tags: set[int], exclude_cat: str | None) -> bool:
@@ -438,7 +453,7 @@ def feed_summary(db: Session, user: User, **params) -> dict:
         # Drop this category's own selections so its chips keep independent counts; a conjunctive
         # topic-AND keeps them (each remaining chip narrows to channels that ALSO have the selected).
         exclude = None if tag_modes.get(category, "or") == "and" else category
-        for cid, ch_tags in channel_tags.items():
+        for ch_tags in channel_tags.values():
             if not passes(ch_tags, exclude):
                 continue
             for tid in ch_tags:
@@ -671,8 +686,8 @@ def decode_cursor(keys: list[dict], cursor: str) -> tuple[list, str, datetime |
         raw = payload["k"]
         if len(raw) != len(keys):
             raise ValueError("key arity mismatch")
-        vals = [_cursor_dt(v) if k["kind"] == "dt" else v for k, v in zip(keys, raw)]
-        for k, v in zip(keys, vals):
+        vals = [_cursor_dt(v) if k["kind"] == "dt" else v for k, v in zip(keys, raw, strict=True)]
+        for k, v in zip(keys, vals, strict=True):
             if v is None and not k["nullable"]:
                 raise ValueError("null value for a non-nullable key")
         window = payload.get("w")
diff --git a/backend/app/issues/gitea.py b/backend/app/issues/gitea.py
index 6d462296..b492de71 100644
--- a/backend/app/issues/gitea.py
+++ b/backend/app/issues/gitea.py
@@ -239,7 +239,7 @@ def deliver(
                 # already open on the tracker and this is what would have recorded its link. We
                 # still must not write — another send owns the row and is opening its own issue —
                 # so say which issue was left behind, because nothing else will.
-                # noqa TRY400: the traceback is one SendClaimLost carrying the session id and
+                # TRY400: the traceback is one SendClaimLost carrying the session id and
                 # nothing else; the issue number below is the whole news.
                 log.error(  # noqa: TRY400
                     "an issue was created by a send that had already lost its claim",
diff --git a/backend/app/logs.py b/backend/app/logs.py
index 64746cf5..d25d5380 100644
--- a/backend/app/logs.py
+++ b/backend/app/logs.py
@@ -166,7 +166,7 @@ def bind(**fields: Any):
     try:
         yield
     finally:
-        for key, token in zip(keys, tokens):
+        for key, token in zip(keys, tokens, strict=True):
             _CONTEXT_VARS[key].reset(token)
 
 
diff --git a/backend/app/main.py b/backend/app/main.py
index 8f52f23f..1376e980 100644
--- a/backend/app/main.py
+++ b/backend/app/main.py
@@ -1,38 +1,36 @@
 import asyncio
 import math
+import mimetypes
 from contextlib import asynccontextmanager, suppress
 from pathlib import Path
 
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.encoders import jsonable_encoder
 from fastapi.exceptions import RequestValidationError
-
-# Logging is configured HERE, before the route modules are imported, so every logger they create at
-# import time is already covered. ONE format for the api, the worker, the download child and alembic
-# alike (app/logs.py) — this replaces the old uvicorn --log-config + the hand-rolled fallback that
-# used to live here, and uvicorn's access log is replaced by the `http.request` middleware below.
-from app import logs
-from app.logs import configure_logging, current_level, log_requests, set_level
-
-configure_logging("api")
-
-log = logs.get_logger(__name__)
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from sqlalchemy.exc import DataError
 from starlette.middleware.sessions import SessionMiddleware
 
-from app import bodylimit
-from app import collation
-from app import logsink
-from app import state
-from app import sysconfig
-from app.config import settings
-from app.db import SessionLocal, engine
-from app.plex import stream as plex_stream
-from app.plex import subtitles as plex_subtitles
-from app.routes import (
+# Logging is configured HERE, before the app's own modules are imported, so a line one of them logs
+# WHILE importing already has the format (a logger is configured whenever it is created —
+# app/logs.py — but a line emitted before `configure_logging` goes out raw). ONE format for the api,
+# the worker, the download child and alembic alike — this replaces the old uvicorn --log-config +
+# the hand-rolled fallback that used to live here, and uvicorn's access log is replaced by the
+# `http.request` middleware below. The imports after it are E402 on purpose, each one marked.
+from app import logs
+from app.logs import configure_logging, current_level, log_requests, set_level
+
+configure_logging("api")
+
+log = logs.get_logger(__name__)
+from app import bodylimit, collation, logsink, state, sysconfig  # noqa: E402 — logging is configured first
+from app.config import settings  # noqa: E402 — logging is configured first
+from app.db import SessionLocal, engine  # noqa: E402 — logging is configured first
+from app.plex import stream as plex_stream  # noqa: E402 — logging is configured first
+from app.plex import subtitles as plex_subtitles  # noqa: E402 — logging is configured first
+from app.routes import (  # noqa: E402 — logging is configured first
     admin,
     admin_logs as admin_logs_routes,
     audit as audit_routes,
@@ -60,7 +58,7 @@ from app.routes import (
     tags,
     version,
 )
-from app.scheduler import shutdown_scheduler, start_scheduler
+from app.scheduler import shutdown_scheduler, start_scheduler  # noqa: E402 — logging is configured first
 
 
 @asynccontextmanager
@@ -77,7 +75,7 @@ async def lifespan(app: FastAPI):
         # booting — an unreachable or not-yet-migrated database has to start into the env level.
         try:
             set_level(sysconfig.get_str(db, "log_level"))
-        except Exception:  # noqa: BLE001 — any DB/config failure keeps the bootstrap level
+        except Exception:  # any DB/config failure keeps the bootstrap level
             # With the traceback: this catch spans a connection, a query and a coercion at boot,
             # and `%s` of the exception does not say which of them raised.
             log.exception("could not read the stored log level; staying at %s", current_level())
@@ -332,8 +330,6 @@ app.include_router(setup_routes.router)
 
 # Ensure modern image types resolve to the right Content-Type when FileResponse guesses from the
 # filename (the runtime's mimetypes db doesn't always know .webp → it'd fall back to octet-stream).
-import mimetypes
-
 mimetypes.add_type("image/webp", ".webp")
 mimetypes.add_type("image/avif", ".avif")
 
diff --git a/backend/app/models.py b/backend/app/models.py
index 2c958085..2e406a39 100644
--- a/backend/app/models.py
+++ b/backend/app/models.py
@@ -23,6 +23,7 @@ from sqlalchemy.dialects.postgresql import JSONB, TSVECTOR
 from sqlalchemy.orm import Mapped, mapped_column, relationship, validates
 
 from app.db import Base
+from app.utils import canonical_email
 
 # Every user-supplied display string in this schema shares one width, and it lives HERE so the
 # columns below are declared with it rather than with a literal: a name a person typed goes into
@@ -51,9 +52,6 @@ def display_text(raw: str | None) -> str | None:
     return (raw or "").strip()[:DISPLAY_TEXT_MAX] or None
 
 
-from app.utils import canonical_email
-
-
 # The resume-position columns (VideoState / PlexState.position_seconds) are int4. The checkpoint
 # routes bound their bodies by this, so an out-of-range position is a 422 rather than a 500.
 POSITION_MAX_S = 2**31 - 1
diff --git a/backend/app/plex/client.py b/backend/app/plex/client.py
index 8701b6ce..ff83019e 100644
--- a/backend/app/plex/client.py
+++ b/backend/app/plex/client.py
@@ -78,9 +78,10 @@ class PlexClient:
     # --- Catalog mirror (P1) ---
     def section_items(
         self, key: str, item_type: int, start: int = 0, size: int = 200
-    ) -> tuple[list[dict], int]:
+    ) -> tuple[list[dict], int | None]:
         """A page of a section's top-level items. type 1 = movie, 2 = show. Returns
-        (items, total_size)."""
+        (items, total_size); the total is None when the answer carries none, so a container that
+        says "0" (a genuinely empty section) stays distinguishable from one that says nothing."""
         mc = self._get(
             f"/library/sections/{key}/all",
             params={
@@ -93,7 +94,10 @@ class PlexClient:
                 "X-Plex-Container-Size": size,
             },
         )
-        return mc.get("Metadata", []) or [], int(mc.get("totalSize", mc.get("size", 0)) or 0)
+        # `totalSize` only: `size` is THIS page's count, and read as the total it made a single
+        # page look like the whole section — "complete" to a prune or a reconcile (E32 review).
+        total = mc.get("totalSize")
+        return mc.get("Metadata", []) or [], None if total is None else int(total)
 
     def children(self, rating_key: str) -> list[dict]:
         """Direct children (show → seasons, season → episodes)."""
@@ -136,9 +140,14 @@ class PlexClient:
     # --- Collection editing (P2 — write-back to Plex; all shared/global, admin-gated in the routes) ---
     @property
     def machine_id(self) -> str:
-        """Server machineIdentifier — needed in the `uri` of collection add/create calls. Cached."""
+        """Server machineIdentifier — needed in the `uri` of collection add/create calls. Cached.
+        Without one the uri would read `server:///…`, a malformed write Plex answers in its own way;
+        it is refused here, by name (E32 S2)."""
         if not getattr(self, "_machine_id", None):
-            self._machine_id = self._get("/identity").get("machineIdentifier") or ""
+            mid = self._get("/identity").get("machineIdentifier")
+            if not mid:
+                raise PlexError("Plex did not report its machine identifier")
+            self._machine_id = mid
         return self._machine_id
 
     def _write(self, method: str, path: str) -> dict:
diff --git a/backend/app/plex/overlay.py b/backend/app/plex/overlay.py
new file mode 100644
index 00000000..7676a118
--- /dev/null
+++ b/backend/app/plex/overlay.py
@@ -0,0 +1,150 @@
+"""The HU overlay: a Hungarian Plex section written onto its English twin's rows (E30), split out of
+`plex/sync.py` (E32 S2), which runs it once per paired section during the full sync.
+
+The pairing is admin-configured (`plex_overlay_map`, ``huKey:enKey,...``). An overlay section creates
+no browsable rows of its own; it only fills the `*_hu` columns of the EN rows it matches by guid.
+`plex/sync.py` and this module import each other as MODULES (attribute access at call time), which is
+what lets either be imported first.
+"""
+
+from collections.abc import Iterable
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app import logs, sysconfig
+from app.models import PlexItem, PlexLibrary, PlexShow
+from app.plex import sync as plex_sync
+from app.plex.client import PlexClient
+from app.plex.genres import hu_genres
+
+log = logs.get_logger(__name__)
+
+
+def overlay_map(db: Session) -> dict[str, str]:
+    """The configured HU-overlay pairing: {huSectionKey: enSectionKey} from `plex_overlay_map`
+    ('huKey:enKey,...'). Each HU section is synced as a non-browsable overlay onto its EN twin.
+    Malformed pairs are skipped."""
+    raw = sysconfig.get_str(db, "plex_overlay_map")
+    out: dict[str, str] = {}
+    for pair in raw.split(","):
+        hu, sep, en = pair.partition(":")
+        hu, en = hu.strip(), en.strip()
+        if sep and hu and en:
+            out[hu] = en
+    return out
+
+
+def sync_overlay(
+    db: Session, plex: PlexClient, lib: PlexLibrary, en_lib_id: int, stats: dict
+) -> None:
+    """Write an overlay section's Hungarian metadata onto its EN twin's rows, matched by guid. Creates
+    NO browsable rows — an overlay library is never listed on its own. Only title/summary/tagline/genres
+    differ by language; the language-neutral people_text feeds both search vectors. A show section's
+    episodes are overlaid too (E30): the HU section lists every episode with its Hungarian title and
+    summary, and the episode rows live in the EN show library.
+
+    This is a full RECONCILE: after a COMPLETE HU listing every guid-bearing EN row's HU fields are
+    cleared, then the matches are repopulated — so an EN row whose HU twin vanished (or was re-guid'd)
+    falls back to EN instead of keeping stale Hungarian metadata. A listing cut short only adds. HU
+    items with no EN match are skipped."""
+    if lib.kind == "movie":
+        passes = [
+            (
+                plex_sync._TYPE_MOVIE,
+                select(PlexItem).where(
+                    PlexItem.library_id == en_lib_id,
+                    PlexItem.kind == "movie",
+                    PlexItem.guid.is_not(None),
+                ),
+            )
+        ]
+    else:
+        passes = [
+            (
+                plex_sync._TYPE_SHOW,
+                select(PlexShow).where(
+                    PlexShow.library_id == en_lib_id, PlexShow.guid.is_not(None)
+                ),
+            ),
+            (
+                plex_sync._TYPE_EPISODE,
+                select(PlexItem).where(
+                    PlexItem.library_id == en_lib_id,
+                    PlexItem.kind == "episode",
+                    PlexItem.guid.is_not(None),
+                ),
+            ),
+        ]
+    for item_type, rows_q in passes:
+        _overlay_pass(db, plex, lib, item_type, db.execute(rows_q).scalars(), stats)
+    db.flush()
+
+
+def _overlay_pass(
+    db: Session,
+    plex: PlexClient,
+    lib: PlexLibrary,
+    item_type: int,
+    rows: Iterable[PlexItem] | Iterable[PlexShow],
+    stats: dict,
+) -> None:
+    """One kind of the overlay (movies, shows or episodes) — see `sync_overlay`."""
+    # guid -> the EN rows carrying it (a list: two editions of one film can share a guid; both overlay).
+    by_guid: dict[str, list[PlexItem | PlexShow]] = {}
+    for r in rows:
+        if r.guid:  # the passes select guid-bearing rows only
+            by_guid.setdefault(r.guid, []).append(r)
+    # The HU listing is read first and applied after, so the clear can wait for its verdict.
+    hu_by_guid, complete = _read_hu_listing(plex, lib, item_type, by_guid)
+    episodes = item_type == plex_sync._TYPE_EPISODE
+    if complete:
+        _clear_hu(by_guid, episodes)
+    else:
+        stats["overlay_incomplete"] = stats.get("overlay_incomplete", 0) + 1
+        log.warning(
+            "the HU listing ended before the server's total; existing HU text is kept",
+            extra=logs.event("plex.sync.overlay_incomplete", library=lib.plex_key),
+        )
+    for g, meta in hu_by_guid.items():
+        targets = by_guid[g]
+        title_hu = (meta.get("title") or "").strip() or None
+        summary_hu = meta.get("summary")
+        tagline_hu = (meta.get("tagline") or "").strip() or None
+        genres_hu = hu_genres(plex_sync._tags(meta, "Genre"))
+        for row in targets:
+            row.title_hu = title_hu
+            row.summary_hu = summary_hu
+            if not episodes:
+                row.tagline_hu = tagline_hu
+                row.genres_hu = genres_hu or row.genres_hu
+        stats["overlaid"] = stats.get("overlaid", 0) + 1
+
+
+def _read_hu_listing(
+    plex: PlexClient, lib: PlexLibrary, item_type: int, by_guid: dict
+) -> tuple[dict[str, dict], bool]:
+    """The HU section's entries for the guids the EN side carries, and whether the walk reached the
+    server's total. The first HU entry for a guid wins; a dup HU item can't overwrite or double-count."""
+    progress: dict = {}
+    hu_by_guid: dict[str, dict] = {}
+    for meta in plex_sync._paginate(plex, lib.plex_key, item_type, progress):
+        g = plex_sync._canonical_guid(meta)
+        if g and g in by_guid and g not in hu_by_guid:
+            hu_by_guid[g] = meta
+    return hu_by_guid, bool(progress.get("complete"))
+
+
+def _clear_hu(by_guid: dict, episodes: bool) -> None:
+    """Reconcile step: clear HU fields on all guid-bearing rows; the matches are re-set after. Only
+    rows that actually held HU data become dirty (SQLAlchemy skips a no-net-change UPDATE), so this is
+    cheap. The genres are the exception: every row gets Hungarian ones, from its HU twin or, lacking
+    one, from its own English list — otherwise the HU genre list mixed "Drama" (no twin) with "Dráma".
+    Only after a COMPLETE listing: one a Plex hiccup cut short would clear the HU text of every title
+    it failed to reach, until the next full sync (E32 S2, the watch reconcile's twin)."""
+    for group in by_guid.values():
+        for row in group:
+            row.title_hu = row.summary_hu = None
+            if not episodes:
+                row.tagline_hu = None
+                row.genres_hu = hu_genres(row.genres)
diff --git a/backend/app/plex/stream.py b/backend/app/plex/stream.py
index 656dabd9..f9ac6caa 100644
--- a/backend/app/plex/stream.py
+++ b/backend/app/plex/stream.py
@@ -245,6 +245,9 @@ def _probe_video_kind(src: Path) -> str:
             capture_output=True,
             text=True,
             timeout=10,
+            # A non-zero exit is a failed probe (CalledProcessError, a SubprocessError → the branch
+            # below), not an answer: whatever it printed before refusing is not the file's truth.
+            check=True,
         )
     except (subprocess.SubprocessError, OSError) as exc:
         # The safe kind is a real answer, but it is the answer for an 8-bit SDR source — a blind
@@ -502,6 +505,9 @@ def _probe_audio_langs(src: Path) -> list[str]:
             capture_output=True,
             text=True,
             timeout=10,
+            # A non-zero exit is a failed probe (CalledProcessError, a SubprocessError → the branch
+            # below), not an answer: whatever it printed before refusing is not the file's truth.
+            check=True,
         )
         return [ln.strip() for ln in out.stdout.splitlines()]
     except (subprocess.SubprocessError, OSError) as exc:
@@ -615,6 +621,9 @@ def _probe_first_pts(seg: Path) -> float | None:
             capture_output=True,
             text=True,
             timeout=10,
+            # A non-zero exit is a failed probe (CalledProcessError, a SubprocessError → the branch
+            # below), not an answer: whatever it printed before refusing is not the file's truth.
+            check=True,
         )
         for line in out.stdout.splitlines():
             tok = line.strip().strip(",")
@@ -736,8 +745,7 @@ def start_session(
         # check-and-replace happens under ONE _lock, so a newer same-key session (a concurrent
         # seek-restart) installed between the fallback's decision and here is never clobbered. When the
         # registered session is no longer `replace_only`, we abort and return None (the caller yields to
-        # whoever is registered now). The INITIAL spawn passes replace_only=None and always supersedes —
-        # that is the seek-restart's intended last-writer-wins.
+        # whoever is registered now). The INITIAL spawn never gets None — see its call site.
         # Software-fallback encode tuning — read only on the SW transcode path (the VAAPI path and
         # remux ignore preset/crf/max_height, and remux must not touch the DB for them).
         preset, crf, max_height = "veryfast", 20, 0
@@ -814,6 +822,7 @@ def start_session(
         return s
 
     s = _spawn(*_select_encode(db, item, transcode, src))
+    assert s is not None  # replace_only=None always supersedes: a seek-restart's last-writer-wins
     # Wait for the first video segment outside the lock (this blocks on ffmpeg, and we must not hold up
     # other sessions). Pass the proc so a HW session that dies at VAAPI init fails fast (not after 25s).
     ready = wait_for(_seg(0), timeout=25.0, proc=s.proc)
diff --git a/backend/app/plex/subtitles.py b/backend/app/plex/subtitles.py
index 22f2a3ce..29059f94 100644
--- a/backend/app/plex/subtitles.py
+++ b/backend/app/plex/subtitles.py
@@ -162,7 +162,8 @@ def ffmpeg_to_vtt(src: str, sub_ord: int | None) -> str:
         "webvtt",
         "pipe:1",
     ]
-    r = subprocess.run(cmd, capture_output=True, timeout=EXTRACT_TIMEOUT_S)
+    # check=False: the exit status is read on the next line, with ffmpeg's own stderr as the reason.
+    r = subprocess.run(cmd, capture_output=True, timeout=EXTRACT_TIMEOUT_S, check=False)
     if r.returncode != 0 or not r.stdout:
         raise PlexError(
             (r.stderr or b"").decode("utf-8", "replace")[:200] or "ffmpeg subtitle convert failed"
diff --git a/backend/app/plex/sync.py b/backend/app/plex/sync.py
index 90f358b9..c7712cad 100644
--- a/backend/app/plex/sync.py
+++ b/backend/app/plex/sync.py
@@ -15,7 +15,6 @@ dead `enabled` column) is a separate follow-up. Cast + intro/credit markers are
 item-detail/player path (P2), not here.
 """
 
-from collections.abc import Iterable
 from datetime import datetime, timezone
 
 from sqlalchemy import func, select
@@ -23,7 +22,7 @@ from sqlalchemy.orm import Session
 
 from app import logs, sysconfig
 from app.models import PlexCollection, PlexItem, PlexLibrary, PlexSeason, PlexShow
-from app.plex import detail, people
+from app.plex import detail, overlay, people
 from app.plex.client import PlexClient, PlexError, PlexNotConfigured
 from app.plex.genres import hu_genres
 from app.plex.lookups import by_rating_key
@@ -194,20 +193,6 @@ def _enabled_section_keys(db: Session) -> set[str] | None:
     return keys or None
 
 
-def _overlay_map(db: Session) -> dict[str, str]:
-    """The configured HU-overlay pairing: {huSectionKey: enSectionKey} from `plex_overlay_map`
-    ('huKey:enKey,...'). Each HU section is synced as a non-browsable overlay onto its EN twin.
-    Malformed pairs are skipped."""
-    raw = sysconfig.get_str(db, "plex_overlay_map")
-    out: dict[str, str] = {}
-    for pair in raw.split(","):
-        hu, sep, en = pair.partition(":")
-        hu, en = hu.strip(), en.strip()
-        if sep and hu and en:
-            out[hu] = en
-    return out
-
-
 def sync(db: Session) -> dict:
     """Full reconcile of the enabled movie/show sections. Returns a small stats dict."""
     if not sysconfig.get_bool(db, "plex_enabled"):
@@ -223,7 +208,7 @@ def sync(db: Session) -> dict:
         "pruned": 0,
     }
     wanted = _enabled_section_keys(db)
-    overlay_map = _overlay_map(db)  # {huKey: enKey}
+    overlay_map = overlay.overlay_map(db)  # {huKey: enKey}
     overlay_keys = set(overlay_map)
     try:
         with PlexClient(db) as plex:
@@ -267,13 +252,13 @@ def sync(db: Session) -> dict:
                 lib.metadata_lang = "hu"
                 lib.overlay_of = en_lib.id
                 db.flush()
-                _sync_overlay(db, plex, lib, en_lib.id, stats)
+                overlay.sync_overlay(db, plex, lib, en_lib.id, stats)
                 db.commit()
             # Rich-fetch a bounded batch of not-yet-enriched titles' FULL cast, so the whole library
             # becomes filterable over successive runs (the cheap listing above only stored the top ~3).
             try:
                 stats["people_enriched"] = _enrich_people_batch(db, plex)
-            except Exception:  # noqa: BLE001 — best-effort; never fail the sync over a backfill
+            except Exception:  # best-effort; never fail the sync over a backfill
                 # With the traceback: a blind catch over a batch that fetches AND writes can be
                 # a Plex shape change, a DB error or our own bug, and `%s` told them apart badly.
                 log.exception("the Plex people-enrich batch failed")
@@ -282,7 +267,7 @@ def sync(db: Session) -> dict:
             # successive runs. Only HW-decodable-codec transcodes are probed — the rest are SW by codec.
             try:
                 stats["media_probed"] = _probe_media_batch(db, plex)
-            except Exception:  # noqa: BLE001 — best-effort; never fail the sync over a backfill
+            except Exception:  # best-effort; never fail the sync over a backfill
                 log.exception("the Plex media-probe batch failed")
     # silent-ok: the return value IS the report. `{"skipped": …}` goes to the scheduler, which
     # logs the job result, and to the admin route, which answers it to the caller.
@@ -296,7 +281,7 @@ def sync(db: Session) -> dict:
     # appear in ANY item's cast/directors — drop those rows, mirroring how Plex drops orphaned metadata.
     try:
         stats["people_pruned"] = people.prune_orphan_people(db)
-    except Exception:  # noqa: BLE001 — best-effort housekeeping; never fail the sync over it
+    except Exception:  # best-effort housekeeping; never fail the sync over it
         log.exception("the Plex people prune failed")
     log.info("Plex sync done: %s", stats)
     return stats
@@ -433,7 +418,10 @@ def _paginate(plex: PlexClient, key: str, item_type: int, progress: dict | None
     if progress is not None:
         # A truthy `total` we reached = a trustworthy complete listing. `total` unknown/zero-with-rows
         # (a Plex that doesn't report totalSize) is treated as NOT complete, so prune stays conservative.
+        # `total` itself is kept for a caller to whom a server that SAID 0 is news it can trust (the
+        # watch reconcile); an empty mirror or overlay must not read it so (E32 S2).
         progress["complete"] = bool(total) and start >= total
+        progress["total"] = total
 
 
 # The section listing exposes at most the top ~20 cast (Plex's own cap); a stored cast longer than this
@@ -661,98 +649,6 @@ def _sync_shows(db: Session, plex: PlexClient, lib: PlexLibrary, stats: dict) ->
     _prune_stale(db, shows, shows_seen, stats, complete=shows_progress.get("complete", False))
 
 
-def _sync_overlay(
-    db: Session, plex: PlexClient, lib: PlexLibrary, en_lib_id: int, stats: dict
-) -> None:
-    """Write an overlay section's Hungarian metadata onto its EN twin's rows, matched by guid. Creates
-    NO browsable rows — an overlay library is never listed on its own. Only title/summary/tagline/genres
-    differ by language; the language-neutral people_text feeds both search vectors. A show section's
-    episodes are overlaid too (E30): the HU section lists every episode with its Hungarian title and
-    summary, and the episode rows live in the EN show library.
-
-    This is a full RECONCILE: every guid-bearing EN row's HU fields are cleared first, then the HU
-    section repopulates the matches — so an EN row whose HU twin vanished (or was re-guid'd) falls back
-    to EN instead of keeping stale Hungarian metadata. HU items with no EN match are skipped."""
-    if lib.kind == "movie":
-        passes = [
-            (
-                _TYPE_MOVIE,
-                select(PlexItem).where(
-                    PlexItem.library_id == en_lib_id,
-                    PlexItem.kind == "movie",
-                    PlexItem.guid.is_not(None),
-                ),
-            )
-        ]
-    else:
-        passes = [
-            (
-                _TYPE_SHOW,
-                select(PlexShow).where(
-                    PlexShow.library_id == en_lib_id, PlexShow.guid.is_not(None)
-                ),
-            ),
-            (
-                _TYPE_EPISODE,
-                select(PlexItem).where(
-                    PlexItem.library_id == en_lib_id,
-                    PlexItem.kind == "episode",
-                    PlexItem.guid.is_not(None),
-                ),
-            ),
-        ]
-    for item_type, rows_q in passes:
-        _overlay_pass(db, plex, lib, item_type, db.execute(rows_q).scalars(), stats)
-    db.flush()
-
-
-def _overlay_pass(
-    db: Session,
-    plex: PlexClient,
-    lib: PlexLibrary,
-    item_type: int,
-    rows: Iterable[PlexItem] | Iterable[PlexShow],
-    stats: dict,
-) -> None:
-    """One kind of the overlay (movies, shows or episodes) — see `_sync_overlay`."""
-    # guid -> the EN rows carrying it (a list: two editions of one film can share a guid; both overlay).
-    by_guid: dict[str, list[PlexItem | PlexShow]] = {}
-    for r in rows:
-        if r.guid:  # the passes select guid-bearing rows only
-            by_guid.setdefault(r.guid, []).append(r)
-    # Reconcile step: clear HU fields on all guid-bearing rows. Only rows that actually held HU data
-    # become dirty (SQLAlchemy skips a no-net-change UPDATE), so this is cheap; matches are re-set below.
-    # The genres are the exception: every row gets Hungarian ones, from its HU twin or, lacking one, from
-    # its own English list — otherwise the HU genre list mixed "Drama" (no twin) with "Dráma".
-    episodes = item_type == _TYPE_EPISODE
-    for group in by_guid.values():
-        for row in group:
-            row.title_hu = row.summary_hu = None
-            if not episodes:
-                row.tagline_hu = None
-                row.genres_hu = hu_genres(row.genres)
-    seen: set[str] = (
-        set()
-    )  # first HU entry for a guid wins; a dup HU item can't overwrite or double-count
-    for meta in _paginate(plex, lib.plex_key, item_type):
-        g = _canonical_guid(meta)
-        targets = by_guid.get(g) if g else None
-        if not targets or g in seen:
-            continue
-        seen.add(g)
-        title_hu = (meta.get("title") or "").strip() or None
-        summary_hu = meta.get("summary")
-        tagline_hu = (meta.get("tagline") or "").strip() or None
-        genres_hu = hu_genres(_tags(meta, "Genre"))
-        for row in targets:
-            row.title_hu = title_hu
-            row.summary_hu = summary_hu
-            if not episodes:
-                row.tagline_hu = tagline_hu
-                row.genres_hu = genres_hu or row.genres_hu
-        stats["overlaid"] = stats.get("overlaid", 0) + 1
-
-
 def _upsert_collection(
     db: Session, existing: PlexCollection | None, rk: str, lib_id: int, meta: dict
 ) -> PlexCollection:
@@ -778,9 +674,11 @@ def resync_collection(db: Session, plex: PlexClient, lib: PlexLibrary, rk: str)
     meta = plex.metadata(rk) or {}
     col = _upsert_collection(db, by_rating_key(db, PlexCollection, rk), rk, lib.id, meta)
     Model = PlexItem if lib.kind == "movie" else PlexShow
-    new_members = {
-        str(c.get("ratingKey")) for c in plex.collection_children(rk) if c.get("ratingKey")
-    }
+    children = _believed_children(plex, rk, meta)
+    if children is None:
+        db.flush()
+        return col
+    new_members = {str(c.get("ratingKey")) for c in children if c.get("ratingKey")}
     current = db.execute(select(Model).where(Model.collection_keys.contains([rk]))).scalars().all()
     for row in current:  # drop rk from rows that are no longer members
         if row.rating_key not in new_members:
@@ -793,6 +691,22 @@ def resync_collection(db: Session, plex: PlexClient, lib: PlexLibrary, rk: str)
     return col
 
 
+def _believed_children(plex: PlexClient, rk: str, meta: dict) -> list[dict] | None:
+    """A collection's members, or None when the answer is not believed: no members from a collection
+    whose own listing counts some (`childCount`) is a glitch, not a collection emptied — the same
+    empty-answer rule as the collection listing's (E32 review). Rebuilding on it showed the
+    collection empty until the next sync."""
+    children = plex.collection_children(rk)
+    count = str(meta.get("childCount") or "0")
+    if children or not count.isdigit() or int(count) == 0:
+        return children
+    log.warning(
+        "Plex listed no members for a non-empty collection; keeping its membership",
+        extra=logs.event("plex.sync.collection_children_empty", collection=rk),
+    )
+    return None
+
+
 def delete_collection_local(db: Session, lib: PlexLibrary, rk: str) -> None:
     """Local cleanup after a collection is deleted from Plex: strip rk from members + drop the row."""
     Model = PlexItem if lib.kind == "movie" else PlexShow
@@ -804,6 +718,19 @@ def delete_collection_local(db: Session, lib: PlexLibrary, rk: str) -> None:
     db.flush()
 
 
+def _rebuild_membership(
+    db: Session, lib: PlexLibrary, membership: dict[str, list[str]], kept: set[str]
+) -> None:
+    """Rebuild collection_keys on every member row of this library (clear + set), carrying over the
+    keys of a collection whose empty answer was not believed (`_believed_children`)."""
+    for Model in (PlexItem, PlexShow):
+        for row in db.execute(select(Model).where(Model.library_id == lib.id)).scalars():
+            held = [k for k in (row.collection_keys or []) if k in kept]
+            keys = [*membership.get(row.rating_key, []), *held]
+            row.collection_keys = list(dict.fromkeys(keys)) or None
+    db.flush()
+
+
 def _sync_collections(db: Session, plex: PlexClient, lib: PlexLibrary, stats: dict) -> None:
     """Mirror a library's collections + membership. Reads never touch Plex afterwards. Membership is
     written as `collection_keys` on member movies (plex_items) / shows (plex_shows). A full reconcile:
@@ -815,7 +742,17 @@ def _sync_collections(db: Session, plex: PlexClient, lib: PlexLibrary, stats: di
             select(PlexCollection).where(PlexCollection.library_id == lib.id)
         ).scalars()
     }
+    if not cols and existing:
+        # The catalog's own rule (see the module doc): an empty listing while we hold rows is a Plex
+        # glitch, not a library emptied of collections. Reconciling on it dropped every collection
+        # (its user-set `editable` flag with it) and every member's keys (E32 S2).
+        log.warning(
+            "Plex listed no collections for a library that has some; keeping them this run",
+            extra=logs.event("plex.sync.collections_empty", library=lib.plex_key),
+        )
+        return
     seen: set[str] = set()
+    kept: set[str] = set()  # collections whose empty children answer is not believed
     membership: dict[str, list[str]] = {}  # member rating_key -> [collection rating_key, ...]
     for meta in cols:
         rk = str(meta.get("ratingKey") or "")
@@ -823,7 +760,10 @@ def _sync_collections(db: Session, plex: PlexClient, lib: PlexLibrary, stats: di
             continue
         _upsert_collection(db, existing.get(rk), rk, lib.id, meta)
         seen.add(rk)
-        for child in plex.collection_children(rk):
+        children = _believed_children(plex, rk, meta)
+        if children is None:
+            kept.add(rk)
+        for child in children or []:
             crk = str(child.get("ratingKey") or "")
             if crk:
                 membership.setdefault(crk, []).append(rk)
@@ -832,9 +772,4 @@ def _sync_collections(db: Session, plex: PlexClient, lib: PlexLibrary, stats: di
     for rk, col in existing.items():
         if rk not in seen:
             db.delete(col)
-    # Rebuild collection_keys on every member row of this library (clear + set).
-    for row in db.execute(select(PlexItem).where(PlexItem.library_id == lib.id)).scalars():
-        row.collection_keys = membership.get(row.rating_key) or None
-    for row in db.execute(select(PlexShow).where(PlexShow.library_id == lib.id)).scalars():
-        row.collection_keys = membership.get(row.rating_key) or None
-    db.flush()
+    _rebuild_membership(db, lib, membership, kept)
diff --git a/backend/app/plex/watch_sync.py b/backend/app/plex/watch_sync.py
index 47c014d3..a632b3bb 100644
--- a/backend/app/plex/watch_sync.py
+++ b/backend/app/plex/watch_sync.py
@@ -29,7 +29,7 @@ from sqlalchemy.orm import Session
 
 from app import logs, sysconfig
 from app.db import SessionLocal
-from app.models import PlexItem, PlexLink, PlexState
+from app.models import PlexItem, PlexLibrary, PlexLink, PlexState
 from app.plex.client import PlexClient, PlexError, PlexNotConfigured
 from app.plex.sync import (
     _TYPE_EPISODE,
@@ -72,13 +72,27 @@ def _rk_to_id(db: Session) -> dict[str, int]:
 
 def _scan_plex_states(
     db: Session, plex: PlexClient
-) -> tuple[dict[int, tuple[str, int, datetime | None, datetime | None]], int]:
+) -> tuple[dict[int, tuple[str, int, datetime | None, datetime | None]], int, set[str], set[str]]:
     """Scan the enabled movie/show sections and return ``{item_id: (status, pos, watched_at,
-    prog_at)}`` for every mirrored leaf Plex holds a watch signal for, plus the scanned-leaf count.
-    Shared by the one-time import and the full reconcile (both need Plex's whole current picture)."""
+    prog_at)}`` for every mirrored leaf Plex holds a watch signal for, the scanned-leaf count, the
+    keys of the sections SETTLED — walked to the server's total (or said empty by a server we mirror
+    nothing from) — and the keys of every section walked.
+    Shared by the one-time import and the full reconcile (both need Plex's whole current picture).
+    The settled keys matter to the reconcile alone: it reads "absent from the scan" as "Plex
+    un-watched it", which a walk cut short by a Plex hiccup does not mean (see `_paginate`). Settled
+    is decided PER SECTION: one section that never settles (a library emptied on Plex while its
+    mirrored items are kept) must not stop un-watches syncing in all the others (E32 review)."""
     item_id_by_rk = _rk_to_id(db)
     wanted = _enabled_section_keys(db)
+    # The sections we mirror something from: a total of 0 from one of those contradicts the mirror.
+    mirrored = set(
+        db.execute(
+            select(PlexLibrary.plex_key).join(PlexItem, PlexItem.library_id == PlexLibrary.id)
+        ).scalars()
+    )
     scanned = 0
+    settled: set[str] = set()
+    walked: set[str] = set()
     out: dict[int, tuple[str, int, datetime | None, datetime | None]] = {}
     for s in plex.sections():
         stype = s.get("type")
@@ -88,7 +102,10 @@ def _scan_plex_states(
         if wanted is not None and key not in wanted:
             continue
         item_type = _TYPE_MOVIE if stype == "movie" else _TYPE_EPISODE
-        for meta in _paginate(plex, key, item_type):
+        walked.add(key)
+        progress: dict = {}
+        before = scanned
+        for meta in _paginate(plex, key, item_type, progress):
             scanned += 1
             item_id = item_id_by_rk.get(str(meta.get("ratingKey") or ""))
             if item_id is None:
@@ -98,7 +115,15 @@ def _scan_plex_states(
             )
             if res is not None:
                 out[item_id] = res
-    return out, scanned
+        # A section the server SAYS is empty (total 0, nothing listed) settles too. Believed only for
+        # a section we mirror nothing from: one whose items we hold answering 0 is a Plex that lost
+        # the library for a moment, not one that un-watched all of it (E32 review) — so it is left
+        # unsettled, and its rows are not cleared.
+        listed = scanned > before
+        said_empty = progress.get("total") == 0 and not listed and key not in mirrored
+        if (progress.get("complete") and listed) or said_empty:
+            settled.add(key)
+    return out, scanned, settled, walked
 
 
 def import_owner_watch_state(db: Session, link: PlexLink) -> dict:
@@ -111,7 +136,8 @@ def import_owner_watch_state(db: Session, link: PlexLink) -> dict:
     stats = {"watched": 0, "in_progress": 0, "scanned": 0}
     try:
         with PlexClient(db) as plex:
-            scanned_states, stats["scanned"] = _scan_plex_states(db, plex)
+            # A partial scan is still safe here: the import only ever ADDS what Plex reports.
+            scanned_states, stats["scanned"], _settled, _walked = _scan_plex_states(db, plex)
             # One row per item (keyed by item_id → inherently de-duped) then bulk-UPSERT. An upsert is
             # idempotent AND concurrency-safe: a repeated/overlapping enable (the toggle firing twice
             # while the multi-second import runs) can't raise a duplicate-key error — it re-updates.
@@ -590,6 +616,28 @@ def run_plex_watch_sync(db: Session) -> dict:
     return total
 
 
+def _clear_unwatched(db: Session, user_id: int, plex_states: dict, settled: set[str]) -> int:
+    """Clear the user's rows Plex no longer has a record for — the mirrored ones (Plex un-watched
+    them); hidden and dirty rows stay (a dirty one is re-pushed by `_repush_dirty`). Only rows of the
+    sections the scan SETTLED: a walk a Plex hiccup cut short leaves out rows it merely failed to
+    reach, and clearing those un-watched them here until the next complete run (E32 S2); an item of
+    a library the allowlist leaves out is absent from every scan, and was cleared on every run (E32
+    review)."""
+    n = 0
+    rows = db.execute(
+        select(PlexState)
+        .join(PlexItem, PlexItem.id == PlexState.item_id)
+        .join(PlexLibrary, PlexLibrary.id == PlexItem.library_id)
+        .where(PlexState.user_id == user_id, PlexLibrary.plex_key.in_(settled))
+    )
+    for st in rows.scalars().all():
+        if st.item_id in plex_states or st.status == "hidden" or not st.synced_to_plex:
+            continue
+        db.delete(st)
+        n += 1
+    return n
+
+
 def run_plex_watch_reconcile(db: Session) -> dict:
     """Scheduler job (default daily) — the authoritative full reconcile. Rescans every section and,
     per item, uses `synced_to_plex` to settle what the incremental feed can't:
@@ -608,7 +656,7 @@ def run_plex_watch_reconcile(db: Session) -> dict:
         try:
             with PlexClient(db) as plex:
                 _resolve_account_id(db, plex, link)
-                plex_states, scanned = _scan_plex_states(db, plex)
+                plex_states, scanned, settled, walked = _scan_plex_states(db, plex)
                 total["scanned"] += scanned
 
                 for item_id, (status, pos, watched_at, prog_at) in plex_states.items():
@@ -616,18 +664,19 @@ def run_plex_watch_reconcile(db: Session) -> dict:
                     if ch:
                         total["applied"] += 1
 
-                # Siftlode rows Plex no longer has a record for: clear the ones that were mirrored
-                # (Plex un-watched them); leave hidden + dirty (dirty gets re-pushed just below).
-                for st in (
-                    db.execute(select(PlexState).where(PlexState.user_id == link.user_id))
-                    .scalars()
-                    .all()
-                ):
-                    if st.item_id in plex_states or st.status == "hidden":
-                        continue
-                    if st.synced_to_plex:
-                        db.delete(st)
-                        total["cleared"] += 1
+                total["cleared"] += _clear_unwatched(db, link.user_id, plex_states, settled)
+                if unsettled := sorted(walked - settled):
+                    total["incomplete"] = total.get("incomplete", 0) + 1
+                    log.warning(
+                        "Plex sections %s were cut short or answered empty; their rows are not cleared"
+                        " this run",
+                        ", ".join(unsettled),
+                        extra=logs.event(
+                            "plex.watch.reconcile_incomplete",
+                            user_id=link.user_id,
+                            sections=unsettled,
+                        ),
+                    )
 
                 total["repushed"] += _repush_dirty(db, plex, link)
                 link.last_watch_sync_at = datetime.now(timezone.utc)
diff --git a/backend/app/progress.py b/backend/app/progress.py
index b6e3f900..98126e7b 100644
--- a/backend/app/progress.py
+++ b/backend/app/progress.py
@@ -8,7 +8,7 @@ its own thread/context) never cross wires. When no sink is bound (e.g. a manual
 """
 
 import contextvars
-from typing import Callable, Optional
+from typing import Callable, Literal, Optional
 
 Sink = Callable[[int, Optional[int], Optional[str]], None]
 
@@ -48,7 +48,9 @@ class bind:
         self._token = _sink.set(self._sink)
         return self
 
-    def __exit__(self, *exc) -> bool:
+    # Literal[False], not bool: this never swallows the job's exception, and saying so is what lets
+    # a type checker know a name assigned inside `with bind(...)` is bound after it.
+    def __exit__(self, *exc) -> Literal[False]:
         if self._token is not None:
             _sink.reset(self._token)
         return False
diff --git a/backend/app/routes/_common.py b/backend/app/routes/_common.py
index f4105db3..0fe3ff64 100644
--- a/backend/app/routes/_common.py
+++ b/backend/app/routes/_common.py
@@ -60,14 +60,17 @@ def owned_or_404(
     return obj
 
 
-def youtube_refusal(exc: Exception) -> HTTPException:
+def youtube_refusal(exc: Exception, *, playlist: bool = False) -> HTTPException:
     """The answer to an action YouTube refused: a 422 whose reason the UI translates
     (`errors.youtube.<reason>`). One definition, because the routes had grown three shapes of it —
     a bare English string quoting the upstream message, a playlist-scoped reason, and nothing at
     all (a raw 500 from the manual syncs). The upstream failure is already logged where it
     happened (`youtube.api.error`). A failure that is not the Data API's (the search scraper's) is
-    YouTube being unavailable to us — the retryable answer."""
-    reason = refusal_reason(exc) if isinstance(exc, YouTubeError) else "unavailable"
+    YouTube being unavailable to us — the retryable answer. `playlist`: the route acts on one
+    playlist the user picked, so a missing playlist is THAT one, gone (`refusal_reason`)."""
+    reason = (
+        refusal_reason(exc, playlist=playlist) if isinstance(exc, YouTubeError) else "unavailable"
+    )
     return HTTPException(status_code=422, detail={"code": "youtube", "reason": reason})
 
 
diff --git a/backend/app/routes/channels.py b/backend/app/routes/channels.py
index 3f63dfa9..31147bf5 100644
--- a/backend/app/routes/channels.py
+++ b/backend/app/routes/channels.py
@@ -436,7 +436,7 @@ def explore_channel(
                 channel = db.get(Channel, channel_id)
             result = explore_ingest_page(db, yt, channel, page_token)
     except YouTubeError as exc:
-        raise youtube_refusal(exc)
+        raise youtube_refusal(exc) from exc
     return {
         "ok": True,
         "channel_id": channel_id,
@@ -597,7 +597,7 @@ def subscribe(
             if "subscriptionDuplicate" in exc.reason.split(","):
                 yt_sub_id = ""
             else:
-                raise youtube_refusal(exc)
+                raise youtube_refusal(exc) from exc
         # Enrich a stub channel (title/thumbnail/subscriber count) so it shows up properly right
         # away, on BOTH the normal and the desync path — a resurfaced stub still needs metadata to
         # render. Keep the client open (we're still inside the `with`); a metadata failure here
@@ -658,7 +658,7 @@ def unsubscribe(
     except YouTubeError as exc:
         # 422 (a real, explainable error → speaking modal), not 502 which the client treats as
         # a transient "connection lost" gateway blip.
-        raise youtube_refusal(exc)
+        raise youtube_refusal(exc) from exc
     db.delete(sub)
     db.commit()
     return {"ok": True, "unsubscribed": channel_id}
diff --git a/backend/app/routes/discover.py b/backend/app/routes/discover.py
index 2de01fc8..0d61f99e 100644
--- a/backend/app/routes/discover.py
+++ b/backend/app/routes/discover.py
@@ -170,7 +170,7 @@ def add_pin(
             # between `resolve_ref` confirming it and this INSERT (a Plex sync dropping a removed
             # item), which trips the FK. Semantically that is the same "no such thing" the pre-check
             # returns above — re-raising handed the user a 500 they could do nothing with.
-            raise not_found("item")
+            raise not_found("item") from None
         return {"ok": True, "id": winner.id, "created": False}
     return {"ok": True, "id": pin.id, "created": True}
 
diff --git a/backend/app/routes/downloads.py b/backend/app/routes/downloads.py
index af75086e..d9a11554 100644
--- a/backend/app/routes/downloads.py
+++ b/backend/app/routes/downloads.py
@@ -322,7 +322,7 @@ def set_credential(
     try:
         cleaned = dlcreds.validate_cookies(body.cookies)
     except dlcreds.InvalidCookies as e:
-        raise HTTPException(status_code=400, detail={"code": "cookies", "reason": str(e)})
+        raise HTTPException(status_code=400, detail={"code": "cookies", "reason": str(e)}) from e
     dlcreds.upsert_credential(db, user.id, host_key, cleaned)
     audit.record(
         db,
@@ -407,7 +407,7 @@ def enqueue_download(
     try:
         job = service.enqueue(db, user.id, source_kind, source_ref, spec, profile_id, display_name)
     except quota.QuotaExceeded as e:
-        raise HTTPException(status_code=422, detail=_quota_detail(e))
+        raise HTTPException(status_code=422, detail=_quota_detail(e)) from e
     return _serialize_job(db, job)
 
 
@@ -520,7 +520,7 @@ def upload_download(
             display_name=upload.display_name,
         )
     except quota.QuotaExceeded as e:
-        raise HTTPException(status_code=422, detail=_quota_detail(e))
+        raise HTTPException(status_code=422, detail=_quota_detail(e)) from e
     return _serialize_job(db, job)
 
 
@@ -547,9 +547,9 @@ def enqueue_edit(
     try:
         job = service.enqueue_edit(db, user.id, source_job, spec, display_name)
     except quota.QuotaExceeded as e:
-        raise HTTPException(status_code=422, detail=_quota_detail(e))
+        raise HTTPException(status_code=422, detail=_quota_detail(e)) from e
     except service.EditError as e:
-        raise HTTPException(status_code=400, detail={"code": "edit", "reason": e.reason})
+        raise HTTPException(status_code=400, detail={"code": "edit", "reason": e.reason}) from e
     return _serialize_job(db, job)
 
 
diff --git a/backend/app/routes/feed.py b/backend/app/routes/feed.py
index 4e905e0c..46c62601 100644
--- a/backend/app/routes/feed.py
+++ b/backend/app/routes/feed.py
@@ -133,7 +133,7 @@ def get_feed(
     # Expose each key column on the row so we can build the next cursor from the last item.
     query = query.add_columns(*[k["expr"].label(f"_k{i}") for i, k in enumerate(keys)])
     if vals is not None:
-        for k, v in zip(keys, vals):
+        for k, v in zip(keys, vals, strict=True):
             k["value"] = v
     if ranked and window is not None:
         rows = windowed_relevance_rows(db, query, keys, window, cursor_id, limit + 1)
@@ -431,7 +431,7 @@ def get_video_detail(
         ):
             items = yt.get_videos([video_id])
     except YouTubeError as exc:
-        raise youtube_refusal(exc)
+        raise youtube_refusal(exc) from exc
     if not items:
         raise not_found("video")
 
diff --git a/backend/app/routes/playlists.py b/backend/app/routes/playlists.py
index b2e33b51..bc2f79cb 100644
--- a/backend/app/routes/playlists.py
+++ b/backend/app/routes/playlists.py
@@ -342,7 +342,7 @@ def sync_youtube(
                 return {"ok": True, **pull_user_playlists(db, user)}
         except YouTubeError as exc:
             db.rollback()
-            raise youtube_refusal(exc)
+            raise youtube_refusal(exc) from exc
 
 
 @router.post("/{playlist_id}/revert-youtube")
@@ -369,10 +369,10 @@ def revert_youtube(
             with quota.attribute(user.id, quota.QuotaAction.PLAYLISTS_PULL):
                 return {"ok": True, **repull_playlist(db, user, pl)}
         except PlaylistGone:
-            raise not_found("playlist")
+            raise not_found("playlist") from None
         except YouTubeError as exc:
             db.rollback()
-            raise youtube_refusal(exc)
+            raise youtube_refusal(exc, playlist=True) from exc
 
 
 def _pushable(db: Session, user: User, playlist_id: int) -> Playlist:
@@ -398,7 +398,7 @@ def push_plan(
         with quota.attribute(user.id, quota.QuotaAction.PLAYLISTS_PUSH):
             plan = plan_merge(db, user, pl)
     except YouTubeError as exc:
-        raise youtube_refusal(exc)
+        raise youtube_refusal(exc, playlist=True) from exc
     plan["remaining_today"] = quota.remaining_today(db)
     plan["affordable"] = plan["units_estimate"] <= plan["remaining_today"]
     return plan
@@ -436,10 +436,10 @@ def push(
                     raise _refused(429, "quota_exceeded")
                 return {"ok": True, **merge_playlist(db, user, pl, live=live)}
         except PlaylistGone:
-            raise not_found("playlist")
+            raise not_found("playlist") from None
         except YouTubeError as exc:
             db.rollback()
-            raise youtube_refusal(exc)
+            raise youtube_refusal(exc, playlist=True) from exc
 
 
 @router.get("/{playlist_id}")
@@ -539,7 +539,7 @@ def delete_playlist(
                     with YouTubeClient(db, user) as yt:
                         yt.delete_playlist(pl.yt_playlist_id)
             except YouTubeError as exc:
-                raise youtube_refusal(exc)
+                raise youtube_refusal(exc, playlist=True) from exc
         # The playlist first, as every item write: the cascade deletes the items before the list row.
         lock_playlists(db, pl.id)
         db.delete(pl)  # items cascade
diff --git a/backend/app/routes/plex/collections.py b/backend/app/routes/plex/collections.py
index 239c2ed3..0dfdde83 100644
--- a/backend/app/routes/plex/collections.py
+++ b/backend/app/routes/plex/collections.py
@@ -428,7 +428,7 @@ def create_collection(
         db.commit()
     except (PlexError, PlexNotConfigured) as e:
         db.rollback()
-        raise _write_or_pending_error(wrote, e)
+        raise _write_or_pending_error(wrote, e) from e
     return _collection_card(col)
 
 
@@ -450,7 +450,7 @@ def collection_add_item(
         db.commit()
     except (PlexError, PlexNotConfigured) as e:
         db.rollback()
-        raise _write_or_pending_error(wrote, e)
+        raise _write_or_pending_error(wrote, e) from e
     return _collection_card(col)
 
 
@@ -472,7 +472,7 @@ def collection_remove_item(
         db.commit()
     except (PlexError, PlexNotConfigured) as e:
         db.rollback()
-        raise _write_or_pending_error(wrote, e)
+        raise _write_or_pending_error(wrote, e) from e
     return _collection_card(col)
 
 
@@ -502,7 +502,7 @@ def collection_rename(
         db.commit()
     except (PlexError, PlexNotConfigured) as e:
         db.rollback()
-        raise _write_or_pending_error(wrote, e)
+        raise _write_or_pending_error(wrote, e) from e
     return _collection_card(col)
 
 
diff --git a/backend/app/routes/plex/discover.py b/backend/app/routes/plex/discover.py
index 05d6936b..84c79c96 100644
--- a/backend/app/routes/plex/discover.py
+++ b/backend/app/routes/plex/discover.py
@@ -124,8 +124,14 @@ def _recently_added(
     # share one), so the merge doesn't depend on object identity staying alive.
     top_movies = [o for _, kind, o in top if kind == "movie"]
     top_shows = [o for _, kind, o in top if kind == "show"]
-    mcards = {m.rating_key: c for m, c in zip(top_movies, _movie_cards(db, uid, top_movies, lang))}
-    scards = {s.rating_key: c for s, c in zip(top_shows, _show_cards(db, uid, top_shows, lang))}
+    mcards = {
+        m.rating_key: c
+        for m, c in zip(top_movies, _movie_cards(db, uid, top_movies, lang), strict=True)
+    }
+    scards = {
+        s.rating_key: c
+        for s, c in zip(top_shows, _show_cards(db, uid, top_shows, lang), strict=True)
+    }
     return [mcards[o.rating_key] if kind == "movie" else scards[o.rating_key] for _, kind, o in top]
 
 
@@ -351,10 +357,12 @@ def _because_you_watched(
     ordered_shows = [shows[rk] for rk in rks if rk in shows]
     # rating_key is globally unique in Plex, so it keys the serialized cards back safely (no id()).
     mcards = {
-        m.rating_key: c for m, c in zip(ordered_movies, _movie_cards(db, uid, ordered_movies, lang))
+        m.rating_key: c
+        for m, c in zip(ordered_movies, _movie_cards(db, uid, ordered_movies, lang), strict=True)
     }
     scards = {
-        s.rating_key: c for s, c in zip(ordered_shows, _show_cards(db, uid, ordered_shows, lang))
+        s.rating_key: c
+        for s, c in zip(ordered_shows, _show_cards(db, uid, ordered_shows, lang), strict=True)
     }
     items: list[dict] = []
     for rk in rks:
diff --git a/backend/app/routes/saved_views.py b/backend/app/routes/saved_views.py
index 6add2507..c4691d73 100644
--- a/backend/app/routes/saved_views.py
+++ b/backend/app/routes/saved_views.py
@@ -1,5 +1,5 @@
 from fastapi import APIRouter, Depends
-from pydantic import BaseModel
+from pydantic import BaseModel, field_validator
 from sqlalchemy import func, select, update
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import Session
@@ -53,11 +53,30 @@ def list_views(
     return [_serialize(v) for v in rows]
 
 
+# A feed view's tag pick is read by more than the feed: the autotag job keeps every tag a view names
+# (sync/autotag.py). Held here to the shape the feed sends — a list of tag ids, at most this many — so
+# a hand-made body (`"tags": 5`, or 60k ids) can't break that job for every user (E32 review).
+_MAX_VIEW_TAGS = 500
+
+
+def _check_filters(filters: dict | None) -> dict | None:
+    tags = (filters or {}).get("tags")
+    if tags is None:
+        return filters
+    if not isinstance(tags, list) or len(tags) > _MAX_VIEW_TAGS:
+        raise ValueError(f"filters.tags must be a list of at most {_MAX_VIEW_TAGS} tag ids")
+    if any(type(t) is not int for t in tags):  # `type`, not isinstance: True is not a tag id
+        raise ValueError("filters.tags must hold tag ids")
+    return filters
+
+
 class CreateViewIn(BaseModel):
     name: str
     filters: dict
     source: str = "feed"
 
+    _filters = field_validator("filters")(_check_filters)
+
 
 @router.post("")
 def create_view(
@@ -87,7 +106,7 @@ def create_view(
         db.commit()
     except IntegrityError:
         db.rollback()
-        raise refused(409, "view_name_taken", name=name)
+        raise refused(409, "view_name_taken", name=name) from None
     return _serialize(view)
 
 
@@ -98,6 +117,8 @@ class UpdateViewIn(BaseModel):
     filters: dict | None = None
     is_default: bool | None = None
 
+    _filters = field_validator("filters")(_check_filters)
+
 
 @router.patch("/{view_id}")
 def update_view(
@@ -135,7 +156,7 @@ def update_view(
         db.commit()
     except IntegrityError:
         db.rollback()
-        raise refused(409, "view_name_taken", name=view.name)
+        raise refused(409, "view_name_taken", name=view.name) from None
     return _serialize(view)
 
 
diff --git a/backend/app/routes/scheduler.py b/backend/app/routes/scheduler.py
index 2a84dddc..579a691f 100644
--- a/backend/app/routes/scheduler.py
+++ b/backend/app/routes/scheduler.py
@@ -74,7 +74,7 @@ def run_job_now(
     try:
         result = trigger_job(job_id, actor_id=user.id)
     except KeyError:
-        raise not_found("job")
+        raise not_found("job") from None
     if result == "already_running":
         raise refused(409, "job_running")
     return {"ok": True, "id": job_id, "started": True}
diff --git a/backend/app/routes/search.py b/backend/app/routes/search.py
index 31bc2fce..50d284f0 100644
--- a/backend/app/routes/search.py
+++ b/backend/app/routes/search.py
@@ -331,7 +331,7 @@ def search_youtube(
             # bare 500 hidden behind the FE's generic "search failed" (same rationale as B-core-1).
             try:
                 collected.extend(_ingest_candidates(db, yt, user, candidates))
-            except Exception as exc:  # noqa: BLE001 — any ingest failure, not just YouTubeError
+            except Exception as exc:  # any ingest failure, not just YouTubeError
                 db.rollback()
                 # The term is NOT in this line. A search string is exactly what the privacy
                 # policy keeps out of the log unless the user turned Teljes/TRACE on for
diff --git a/backend/app/routes/sync.py b/backend/app/routes/sync.py
index 998d658b..e413c484 100644
--- a/backend/app/routes/sync.py
+++ b/backend/app/routes/sync.py
@@ -39,7 +39,7 @@ def sync_subscriptions(user: User = Depends(require_human), db: Session = Depend
         # The onboarding wizard's first call: an unguarded failure here was a raw 500 and the
         # blocking "Server error" dialog, with nothing the user could act on (E9 F1).
         db.rollback()
-        raise youtube_refusal(exc)
+        raise youtube_refusal(exc) from exc
     result["quota_used_estimate"] = m.used
     result["quota_remaining_today"] = m.remaining
     return {"ok": True, **result}
diff --git a/backend/app/routes/tags.py b/backend/app/routes/tags.py
index 7e2c23c9..8228e912 100644
--- a/backend/app/routes/tags.py
+++ b/backend/app/routes/tags.py
@@ -75,7 +75,7 @@ def create_tag(
         db.commit()
     except IntegrityError:
         db.rollback()
-        raise refused(409, "tag_name_taken", name=name)
+        raise refused(409, "tag_name_taken", name=name) from None
     return {
         "ok": True,
         "id": tag.id,
@@ -113,7 +113,7 @@ def update_tag(
         db.commit()
     except IntegrityError:
         db.rollback()
-        raise refused(409, "tag_name_taken", name=tag.name)
+        raise refused(409, "tag_name_taken", name=tag.name) from None
     return {
         "ok": True,
         "id": tag.id,
diff --git a/backend/app/sync/autotag.py b/backend/app/sync/autotag.py
index 39ce4ac9..7f3aa788 100644
--- a/backend/app/sync/autotag.py
+++ b/backend/app/sync/autotag.py
@@ -12,7 +12,7 @@ from sqlalchemy import and_, exists, func, select
 from sqlalchemy.orm import Session
 
 from app import logs, progress, sysconfig
-from app.models import Channel, ChannelTag, Tag, Video
+from app.models import Channel, ChannelTag, SavedView, Tag, Video
 
 log = logs.get_logger(__name__)
 
@@ -288,18 +288,35 @@ def run_autotag_all(db: Session, only_missing: bool = False) -> dict:
     return {"channels_tagged": tagged, "orphan_tags_removed": removed}
 
 
+def _view_tag_ids(filters: object) -> list[int]:
+    """The tag ids a stored view's filters name; anything else in that slot names none."""
+    tags = filters.get("tags") if isinstance(filters, dict) else None
+    if not isinstance(tags, list):
+        return []
+    return [t for t in tags if type(t) is int]  # `type`, not isinstance: True is not a tag id
+
+
 def _cleanup_orphan_system_tags(db: Session) -> int:
-    """Delete system tags that no longer link to any channel (e.g. after a mapping change)."""
-    orphans = (
-        db.execute(
-            select(Tag).where(
-                Tag.user_id.is_(None),
-                ~exists().where(ChannelTag.tag_id == Tag.id),
-            )
-        )
-        .scalars()
-        .all()
-    )
+    """Delete system tags that no longer link to any channel (e.g. after a mapping change) — but not
+    one a saved feed view filters on. Views hold tag IDS, and a deleted tag comes back under a new id
+    when a channel earns it again, so the view's filter would point at nothing; the feed drops an
+    unknown id, and the view showed the whole feed under its old name (E32 S2).
+
+    The views are read defensively, and the kept ids are filtered here rather than in SQL: a view
+    stored before its route checked the shape (or written around it) must not raise for everyone's
+    job, nor push a `NOT IN` past the driver's bind-parameter limit (E32 review)."""
+    in_views = {
+        t
+        for (filters,) in db.execute(select(SavedView.filters).where(SavedView.source == "feed"))
+        for t in _view_tag_ids(filters)
+    }
+    orphans = [
+        tag
+        for tag in db.execute(
+            select(Tag).where(Tag.user_id.is_(None), ~exists().where(ChannelTag.tag_id == Tag.id))
+        ).scalars()
+        if tag.id not in in_views
+    ]
     for tag in orphans:
         db.delete(tag)
     db.commit()
diff --git a/backend/app/sync/explore.py b/backend/app/sync/explore.py
index 75b2aa45..f9bcc0b6 100644
--- a/backend/app/sync/explore.py
+++ b/backend/app/sync/explore.py
@@ -25,7 +25,7 @@ from app.models import (
 )
 from app.sync.videos import insert_stubs, stub_from_playlist_item, apply_video_details
 from app.utils import now_utc as _now
-from app.youtube.client import YouTubeClient
+from app.youtube.client import YouTubeClient, YouTubeError, is_playlist_gone
 
 log = logs.get_logger(__name__)
 
@@ -81,7 +81,15 @@ def explore_ingest_page(
     the organic deep backfill) is never touched."""
     if not channel.uploads_playlist_id:
         return {"ingested": 0, "next_page_token": None}
-    data = yt.get_playlist_items(channel.uploads_playlist_id, page_token)
+    try:
+        data = yt.get_playlist_items(channel.uploads_playlist_id, page_token)
+    except YouTubeError as exc:
+        # A channel with no uploads has an uploads id that YouTube answers as not found: an empty
+        # back-catalogue, not a failure (and not a "playlist gone" — the user picked a channel).
+        if not is_playlist_gone(exc):
+            raise
+        log.info("explore ingest channel=%s has no uploads playlist", channel.id)
+        return {"ingested": 0, "next_page_token": None}
     stubs: list[dict] = []
     for item in data.get("items", []):
         stub = stub_from_playlist_item(item, channel.id)
diff --git a/backend/app/sync/maintenance.py b/backend/app/sync/maintenance.py
index 680a63cc..caebde45 100644
--- a/backend/app/sync/maintenance.py
+++ b/backend/app/sync/maintenance.py
@@ -20,9 +20,9 @@ Quota: phase 1 costs ~(flagged / 50) units, phase 2 ~(batch / 50). Both respect
 backfill reserve as the other jobs so interactive syncs never starve.
 """
 
-from datetime import timedelta
+from datetime import datetime, timedelta
 
-from sqlalchemy import select
+from sqlalchemy import or_, select
 from sqlalchemy.orm import Session
 
 from app import logs, progress, quota, sysconfig
@@ -129,14 +129,14 @@ def _notify_removed(db: Session, impact: dict[int, list[dict]]) -> int:
     return len(impact)
 
 
-def _recheck_flagged(db: Session, yt: YouTubeClient) -> dict:
-    """Phase 1: recover or hard-delete videos already flagged unavailable."""
+def _recheck_flagged(db: Session, yt: YouTubeClient, now: datetime) -> dict:
+    """Phase 1: recover or hard-delete videos already flagged unavailable. `now` is the run's:
+    phase 2 skips a video stamped with it, so one recovered here is not fetched again."""
     flagged = db.execute(select(Video).where(Video.unavailable_since.is_not(None))).scalars().all()
     if not flagged:
         return {"checked": 0, "recovered": 0, "deleted": 0, "notified": 0}
     progress.report(0, len(flagged), "recheck")
     items = {it["id"]: it for it in yt.get_videos([v.id for v in flagged])}
-    now = _now()
     recovered = 0
     to_delete: list[Video] = []
     for video in flagged:
@@ -173,7 +173,7 @@ def _recheck_flagged(db: Session, yt: YouTubeClient) -> dict:
     }
 
 
-def _revalidate_rolling(db: Session, yt: YouTubeClient) -> dict:
+def _revalidate_rolling(db: Session, yt: YouTubeClient, now: datetime) -> dict:
     """Phase 2: re-check the least-recently-checked currently-available videos and flag any
     that have become unplayable (hidden immediately; deleted later if they don't recover)."""
     batch = sysconfig.get_int(
@@ -181,7 +181,6 @@ def _revalidate_rolling(db: Session, yt: YouTubeClient) -> dict:
     )  # admin override, else config default
     flagged_new = 0
     checked = 0
-    now = _now()
     # Process in videos.list-sized pages so we commit incrementally and stop on low quota.
     while checked < batch:
         if quota.backfill_reserve_reached():
@@ -190,6 +189,10 @@ def _revalidate_rolling(db: Session, yt: YouTubeClient) -> dict:
             db.execute(
                 select(Video)
                 .where(Video.unavailable_since.is_(None))
+                # Not one this run already checked: with fewer available videos than the batch, the
+                # loop used to wrap around and re-fetch the same ones until `checked` reached the
+                # batch, spending quota on answers it already had (E32 S2).
+                .where(or_(Video.last_checked_at.is_(None), Video.last_checked_at < now))
                 # NULLS FIRST = never-checked first, then least-recently-checked; equivalent to the old
                 # `(last_checked_at IS NULL) DESC, last_checked_at ASC` but in the exact shape of the
                 # partial ix_videos_recheck_order (migration 0069, PERF-18) so it rides that index.
@@ -220,10 +223,13 @@ def run_maintenance(db: Session) -> dict:
     user = get_service_user(db)
     if user is None:
         return {"reason": "no service user"}
+    # One `now` for the whole run: each phase taking its own let a video phase 1 had just recovered
+    # (stamped with phase 1's) pass phase 2's "not checked this run" test and be fetched twice.
+    now = _now()
     with YouTubeClient(db, user) as yt:
-        phase1 = _recheck_flagged(db, yt)
+        phase1 = _recheck_flagged(db, yt, now)
         phase2 = (
-            _revalidate_rolling(db, yt)
+            _revalidate_rolling(db, yt, now)
             if not quota.backfill_reserve_reached()
             else {"checked": 0, "flagged": 0, "skipped": "low quota"}
         )
diff --git a/backend/app/sync/playlist_merge.py b/backend/app/sync/playlist_merge.py
new file mode 100644
index 00000000..7d530055
--- /dev/null
+++ b/backend/app/sync/playlist_merge.py
@@ -0,0 +1,89 @@
+"""The 3-way merge of a YouTube-linked playlist, as a pure function: what each side gains and loses
+so neither loses an item, the merged order, and the reorder moves YouTube needs to reach it. No I/O —
+`sync/playlists.py` reads both sides, calls `merge_plan`, and writes the outcome."""
+
+from dataclasses import dataclass
+
+
+def _reorder_moves(current: list[str], desired: list[str]) -> int:
+    """Count the playlistItems.update moves an insertion-sort would need to turn
+    `current` order into `desired` order (both already the same set of video ids).
+    Items already in place are skipped; this matches what apply_push actually executes."""
+    model = list(current)
+    moves = 0
+    for i, want in enumerate(desired):
+        if i < len(model) and model[i] == want:
+            continue
+        j = model.index(want, i)
+        model.pop(j)
+        model.insert(i, want)
+        moves += 1
+    return moves
+
+
+@dataclass
+class MergePlan:
+    """The 3-way merge of a linked playlist: what each side gains and loses so neither side
+    loses an item, plus the merged order. `final` is the id set both sides end up with."""
+
+    final: list[str]  # merged order (local order, YouTube-only adds appended)
+    add_to_yt: list[str]  # local-adds to push out to YouTube
+    add_to_local: list[str]  # YouTube-adds to pull into Siftlode
+    remove_from_yt: list[str]  # items deleted locally that are still on YouTube
+    remove_from_local: list[str]  # items deleted on YouTube that are still local
+    reorders: int  # estimated YouTube playlistItems.update moves to reach `final`
+    baseline_known: bool
+
+
+def merge_plan(
+    baseline: list[str] | None,
+    local: list[str],
+    youtube: list[str],
+    unavailable: set[str] | None = None,
+) -> MergePlan:
+    """Pure 3-way merge. Classify each id against the last-synced `baseline`:
+    - in local but not youtube, not deleted → add to YouTube (a local-add)
+    - in youtube but not local, not deleted → add to Siftlode (a YouTube-add)
+    - in baseline but gone from local → a genuine local delete → propagate to YouTube
+    - in baseline but gone from youtube → a genuine YouTube delete → propagate to Siftlode
+    With NO baseline (first-ever merge) we can't tell an add from a delete, so we UNION both
+    sides (never delete) — the lossless default. Merged order: local order first, YouTube-only
+    additions appended in their YouTube order.
+    `unavailable` = known un-ingestable-but-live YouTube ids: dropped from the YouTube side up
+    front so they're never re-classified as a YouTube-add (they can't ingest) nor as a local
+    delete (they were never local) — otherwise such a video would make the playlist never
+    converge. They stay in place on YouTube, untouched by this merge."""
+    un = set(unavailable or ())
+    L = list(dict.fromkeys(local))
+    Y = [v for v in dict.fromkeys(youtube) if v not in un]
+    Lset, Yset = set(L), set(Y)
+    if baseline is None:
+        add_to_yt = [v for v in L if v not in Yset]
+        add_to_local = [v for v in Y if v not in Lset]
+        remove_from_yt: list[str] = []
+        remove_from_local: list[str] = []
+        final = L + [v for v in Y if v not in Lset]
+    else:
+        B = set(baseline)
+        deleted_local = B - Lset  # was synced, removed on our side
+        deleted_yt = B - Yset  # was synced, removed on YouTube's side
+        gone = deleted_local | deleted_yt
+        remove_from_yt = [v for v in Y if v in deleted_local]
+        remove_from_local = [v for v in L if v in deleted_yt]
+        add_to_yt = [v for v in L if v not in Yset and v not in gone]
+        add_to_local = [v for v in Y if v not in Lset and v not in gone]
+        final = [v for v in L if v not in gone] + [v for v in Y if v not in Lset and v not in gone]
+    final_set = set(final)
+    # On YouTube, after membership reconciliation the order is current-kept + inserts appended;
+    # the reorder pass then moves items into `final`.
+    after_membership = [v for v in Y if v in final_set] + add_to_yt
+    reorders = _reorder_moves(after_membership, final)
+    return MergePlan(
+        final=final,
+        add_to_yt=add_to_yt,
+        add_to_local=add_to_local,
+        remove_from_yt=remove_from_yt,
+        remove_from_local=remove_from_local,
+        reorders=reorders,
+        baseline_known=baseline is not None,
+    )
diff --git a/backend/app/sync/playlists.py b/backend/app/sync/playlists.py
index 4c16e8e8..eff61053 100644
--- a/backend/app/sync/playlists.py
+++ b/backend/app/sync/playlists.py
@@ -1,6 +1,7 @@
 """YouTube playlist sync, both directions. Read: mirror each user's own YouTube playlists
 into local `source='youtube'` playlists (kept fresh by the scheduler). Write-back: two-way sync
-local edits with YouTube (`plan_merge` / `merge_playlist`), behind the optional write scope.
+local edits with YouTube (`plan_merge` / `merge_playlist`), behind the optional write scope; the
+pure 3-way merge they run is `sync/playlist_merge.py`.
 
 YouTube's special Watch Later / History playlists are not exposed by the Data API and are
 never synced. Videos in a playlist that aren't in our shared catalog yet are fetched and
@@ -10,7 +11,7 @@ import hashlib
 import json
 from collections.abc import Callable, Iterator
 from contextlib import AbstractContextManager, contextmanager
-from dataclasses import dataclass
+
 from datetime import datetime, timezone
 from typing import TypeVar
 
@@ -21,9 +22,11 @@ from sqlalchemy.pool import NullPool
 from app import logs, progress, quota
 from app.auth import has_read_scope
 from app.models import Channel, Playlist, PlaylistItem, User, Video
+from app.sync.playlist_merge import merge_plan
 from app.sync.runner import token_users
+from app.sync.subscriptions import blank_listing, refuse_blank_listing, vanished
 from app.sync.videos import apply_video_details, parse_dt
-from app.youtube.client import YouTubeClient, YouTubeError
+from app.youtube.client import YouTubeClient, YouTubeError, is_playlist_gone
 
 log = logs.get_logger(__name__)
 # Cost of a single YouTube write op (playlists/playlistItems insert/update/delete).
@@ -316,6 +319,24 @@ def user_sync_claim(db: Session, user_id: int) -> AbstractContextManager[bool]:
     return _advisory_claim(db, _USER_SYNC_LOCK_NS, user_id)
 
 
+def _mirror_listing(yt: YouTubeClient, ytid: str, count: object, pl_id: int) -> list[str] | None:
+    """A mirror's video ids from YouTube, or None when there is nothing to believe: the list was
+    deleted between the pull's listing and this read (the next pull drops the mirror as vanished —
+    not a reason to fail every other list, E32 review round 2), or YouTube listed no items for a
+    list it counts as non-empty (`blank_listing`)."""
+    try:
+        ids = list(yt.iter_my_playlist_video_ids(ytid))
+    except YouTubeError as exc:
+        if not is_playlist_gone(exc):
+            raise
+        log.info("YouTube playlist of %s vanished mid-pull; skipped", pl_id)
+        return None
+    if blank_listing(ids, count):
+        log.warning("YouTube listed no items for non-empty playlist %s; kept", pl_id)
+        return None
+    return ids
+
+
 def pull_user_playlists(db: Session, user: User) -> dict:
     """The mirror pull itself; the caller holds `user_sync_claim`."""
     synced = 0
@@ -337,12 +358,10 @@ def pull_user_playlists(db: Session, user: User) -> dict:
                     Playlist.source == "local",
                     Playlist.yt_playlist_id.is_not(None),
                 )
-            )
-            .scalars()
-            .all()
+            ).scalars()
         )
-        # Drop mirrors whose YouTube playlist no longer exists — locked first, as every item write.
-        gone = [pl for ytid, pl in existing.items() if ytid not in yt_ids]
+        # Drop vanished mirrors (none on an empty answer) — locked first, as every item write.
+        gone = vanished(existing, yt_ids)
         if gone:
             lock_playlists(db, *(pl.id for pl in gone))
         for pl in gone:
@@ -376,7 +395,10 @@ def pull_user_playlists(db: Session, user: User) -> dict:
                     # The user is pushing or re-pulling this very list: it writes the same rows.
                     # The next scheduled run refreshes it.
                     continue
-                ids = list(yt.iter_my_playlist_video_ids(ytid))
+                ids = _mirror_listing(yt, ytid, p.get("item_count"), pl.id)
+                if ids is None:
+                    db.rollback()  # a mirror this run just created is not kept empty either
+                    continue
                 # Ingest first — it commits — so the row lock below is held from the dirty check
                 # to the commit that replaces the items.
                 _ensure_videos(db, yt, ids)
@@ -408,90 +430,6 @@ def _local_video_ids(db: Session, pl: Playlist) -> list[str]:
     )
 
 
-def _reorder_moves(current: list[str], desired: list[str]) -> int:
-    """Count the playlistItems.update moves an insertion-sort would need to turn
-    `current` order into `desired` order (both already the same set of video ids).
-    Items already in place are skipped; this matches what apply_push actually executes."""
-    model = list(current)
-    moves = 0
-    for i, want in enumerate(desired):
-        if i < len(model) and model[i] == want:
-            continue
-        j = model.index(want, i)
-        model.pop(j)
-        model.insert(i, want)
-        moves += 1
-    return moves
-
-
-@dataclass
-class MergePlan:
-    """The 3-way merge of a linked playlist: what each side gains and loses so neither side
-    loses an item, plus the merged order. `final` is the id set both sides end up with."""
-
-    final: list[str]  # merged order (local order, YouTube-only adds appended)
-    add_to_yt: list[str]  # local-adds to push out to YouTube
-    add_to_local: list[str]  # YouTube-adds to pull into Siftlode
-    remove_from_yt: list[str]  # items deleted locally that are still on YouTube
-    remove_from_local: list[str]  # items deleted on YouTube that are still local
-    reorders: int  # estimated YouTube playlistItems.update moves to reach `final`
-    baseline_known: bool
-
-
-def merge_plan(
-    baseline: list[str] | None,
-    local: list[str],
-    youtube: list[str],
-    unavailable: set[str] | None = None,
-) -> MergePlan:
-    """Pure 3-way merge. Classify each id against the last-synced `baseline`:
-    - in local but not youtube, not deleted → add to YouTube (a local-add)
-    - in youtube but not local, not deleted → add to Siftlode (a YouTube-add)
-    - in baseline but gone from local → a genuine local delete → propagate to YouTube
-    - in baseline but gone from youtube → a genuine YouTube delete → propagate to Siftlode
-    With NO baseline (first-ever merge) we can't tell an add from a delete, so we UNION both
-    sides (never delete) — the lossless default. Merged order: local order first, YouTube-only
-    additions appended in their YouTube order.
-    `unavailable` = known un-ingestable-but-live YouTube ids: dropped from the YouTube side up
-    front so they're never re-classified as a YouTube-add (they can't ingest) nor as a local
-    delete (they were never local) — otherwise such a video would make the playlist never
-    converge. They stay in place on YouTube, untouched by this merge."""
-    un = set(unavailable or ())
-    L = list(dict.fromkeys(local))
-    Y = [v for v in dict.fromkeys(youtube) if v not in un]
-    Lset, Yset = set(L), set(Y)
-    if baseline is None:
-        add_to_yt = [v for v in L if v not in Yset]
-        add_to_local = [v for v in Y if v not in Lset]
-        remove_from_yt: list[str] = []
-        remove_from_local: list[str] = []
-        final = L + [v for v in Y if v not in Lset]
-    else:
-        B = set(baseline)
-        deleted_local = B - Lset  # was synced, removed on our side
-        deleted_yt = B - Yset  # was synced, removed on YouTube's side
-        gone = deleted_local | deleted_yt
-        remove_from_yt = [v for v in Y if v in deleted_local]
-        remove_from_local = [v for v in L if v in deleted_yt]
-        add_to_yt = [v for v in L if v not in Yset and v not in gone]
-        add_to_local = [v for v in Y if v not in Lset and v not in gone]
-        final = [v for v in L if v not in gone] + [v for v in Y if v not in Lset and v not in gone]
-    final_set = set(final)
-    # On YouTube, after membership reconciliation the order is current-kept + inserts appended;
-    # the reorder pass then moves items into `final`.
-    after_membership = [v for v in Y if v in final_set] + add_to_yt
-    reorders = _reorder_moves(after_membership, final)
-    return MergePlan(
-        final=final,
-        add_to_yt=add_to_yt,
-        add_to_local=add_to_local,
-        remove_from_yt=remove_from_yt,
-        remove_from_local=remove_from_local,
-        reorders=reorders,
-        baseline_known=baseline is not None,
-    )
-
-
 def plan_merge(db: Session, user: User, pl: Playlist, *, live=None) -> dict:
     """Compute (without writing) what a two-way sync of this playlist would do: create vs
     update, how many items each side gains/loses, reorders, and the quota estimate (YouTube
@@ -519,6 +457,7 @@ def plan_merge(db: Session, user: User, pl: Playlist, *, live=None) -> dict:
             snippet = yt.get_playlist_snippet(pl.yt_playlist_id)
     rename = bool(snippet) and (snippet.get("title") or "") != pl.name
     yt_ids = [it["video_id"] for it in current]
+    refuse_blank_listing(yt_ids, (snippet or {}).get("item_count"))
     mp = merge_plan(parse_baseline(pl), local, yt_ids, parse_unavailable(pl))
     ops = len(mp.add_to_yt) + len(mp.remove_from_yt) + mp.reorders + (1 if rename else 0)
     return {
@@ -665,6 +604,8 @@ def merge_playlist(db: Session, user: User, pl: Playlist, *, live=None) -> dict:
             current = list(yt.iter_playlist_items_with_ids(pl.yt_playlist_id))
         item_id_by_vid = {it["video_id"]: it["item_id"] for it in current}
         yt_ids = [it["video_id"] for it in current]
+        # A merge would read "YouTube lists none of them" as "YouTube deleted them all".
+        refuse_blank_listing(yt_ids, (snippet or {}).get("item_count"))
         # Re-attempt ingestion of ids previously marked un-ingestable that are still on YouTube: a
         # video that has since become available (e.g. private→public) should re-enter the merge, not
         # stay skipped forever. Those that still won't ingest remain filtered (`effective_unavailable`).
@@ -803,8 +744,11 @@ def repull_playlist(db: Session, user: User, pl: Playlist) -> dict:
     with YouTubeClient(db, user) as yt:
         snippet = yt.get_playlist_snippet(pl.yt_playlist_id)
         if snippet is None:
-            raise YouTubeError("Playlist no longer exists on YouTube")
+            raise YouTubeError(
+                "Playlist no longer exists on YouTube", reason="playlistNotFound", path="playlists"
+            )
         ids = list(yt.iter_my_playlist_video_ids(pl.yt_playlist_id))
+        refuse_blank_listing(ids, snippet.get("item_count"))
         _ensure_videos(db, yt, ids)
         _lock_or_gone(db, pl)
         pl.name = snippet.get("title") or pl.name
diff --git a/backend/app/sync/runner.py b/backend/app/sync/runner.py
index b495fbdf..19292ad1 100644
--- a/backend/app/sync/runner.py
+++ b/backend/app/sync/runner.py
@@ -15,8 +15,6 @@ from sqlalchemy import func, or_, select, update
 from sqlalchemy.orm import Session
 
 from app import logs, progress, quota, sysconfig
-
-log = logs.get_logger(__name__)
 from app.db import SessionLocal
 from app.models import Channel, OAuthToken, Subscription, User
 from app.sync.explore import followed_channel
@@ -35,6 +33,8 @@ from app.sync.videos import (
 from app.youtube.client import YouTubeClient, YouTubeError, is_quota_refusal
 from app.youtube.rss import RssError, fetch_channel_feed
 
+log = logs.get_logger(__name__)
+
 # RSS feeds are free and network-bound, so fetch many at once; DB writes stay single-threaded.
 RSS_POLL_WORKERS = 16
 # Failed channels named in a poll's summary warning; the rest are counted by reason.
@@ -267,7 +267,7 @@ def run_feed_fallback(db: Session, channel_ids: list[str]) -> dict[str, int]:
                 channel.feed_fallback_at = datetime.now(timezone.utc)
                 db.add(channel)
                 db.commit()
-            except Exception:  # noqa: BLE001 — one channel must not stop the rest
+            except Exception:  # one channel must not stop the rest
                 db.rollback()
                 log.exception(
                     "Feed fallback could not store channel %s",
diff --git a/backend/app/sync/subscriptions.py b/backend/app/sync/subscriptions.py
index ae3cbe92..b950566e 100644
--- a/backend/app/sync/subscriptions.py
+++ b/backend/app/sync/subscriptions.py
@@ -1,6 +1,6 @@
 """Import the authenticated user's YouTube subscriptions and channel metadata."""
 
-from collections.abc import Iterable
+from collections.abc import Collection, Iterable
 from datetime import datetime, timedelta, timezone
 
 from sqlalchemy import or_, select
@@ -9,7 +9,7 @@ from sqlalchemy.orm import Session
 from app import logs
 from app.models import Channel, Subscription, User
 from app.utils import normalize_description
-from app.youtube.client import YouTubeClient, best_thumbnail
+from app.youtube.client import YouTubeClient, YouTubeError, best_thumbnail
 
 log = logs.get_logger(__name__)
 
@@ -115,10 +115,37 @@ def should_prune(fetched_count: int, existing_count: int) -> bool:
     has — taking each row's `deep_requested` flag with it — in a single run. Someone who genuinely
     unsubscribed from everything simply keeps their rows until a sync that returns something.
 
-    Pure so it can be tested without a database; `import_subscriptions` is the only caller."""
+    Pure so it can be tested without a database; its callers are `import_subscriptions` and, through
+    `vanished`, every mirror that drops what the remote no longer lists."""
     return fetched_count > 0 or existing_count == 0
 
 
+def vanished[K, V](existing: dict[K, V], listed: Collection[K]) -> list[V]:
+    """The local mirrors whose key the remote listing no longer has — none at all when the listing
+    is an empty answer that contradicts them (`should_prune`). The YouTube playlist mirrors use it:
+    without it, one blip dropped every mirror (E32 S2)."""
+    if not should_prune(len(listed), len(existing)):
+        return []
+    return [row for key, row in existing.items() if key not in listed]
+
+
+def blank_listing(listed: Collection, count: object) -> bool:
+    """The same rule one level down: no members from a container whose own listing counts some (a
+    playlist's `itemCount`) is a blip, not a list emptied. Replacing or merging on it deleted every
+    mirrored item and reset the merge baseline (E32 review)."""
+    return not listed and isinstance(count, int) and count > 0
+
+
+def refuse_blank_listing(listed: Collection, count: object) -> None:
+    """`blank_listing` for a user-started pull or push: refused as retryable ("try again")."""
+    if blank_listing(listed, count):
+        raise YouTubeError(
+            "YouTube listed no items for a playlist it counts as non-empty",
+            reason="emptyAnswer",
+            path="playlistItems",
+        )
+
+
 def import_subscriptions(db: Session, user: User) -> dict:
     """Pull all subscriptions for `user`, upsert channels + subscription links, prune
     channels the user has unsubscribed from on YouTube, and fetch channel details for
diff --git a/backend/app/sync/videos.py b/backend/app/sync/videos.py
index a257c92a..d725df3f 100644
--- a/backend/app/sync/videos.py
+++ b/backend/app/sync/videos.py
@@ -11,12 +11,14 @@ from sqlalchemy import and_, func, or_, select, update
 from sqlalchemy.dialects.postgresql import insert as pg_insert
 from sqlalchemy.orm import Session
 
-from app import progress, quota, sysconfig
+from app import logs, progress, quota, sysconfig
 from app.models import LIVE_OR_UPCOMING, Channel, Video
 from app.titles import normalize_title
-from app.youtube.client import YouTubeClient, best_thumbnail
+from app.youtube.client import YouTubeClient, YouTubeError, best_thumbnail, is_playlist_gone
 from app.youtube.shorts import make_client, probe_is_short
 
+log = logs.get_logger(__name__)
+
 _DURATION_RE = re.compile(r"P(?:(\d+)D)?T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?", re.IGNORECASE)
 
 
@@ -104,6 +106,20 @@ def stub_from_playlist_item(item: dict, channel_id: str) -> dict | None:
     }
 
 
+def _uploads_page(yt: YouTubeClient, channel_id: str, uploads: str, page_token: str | None) -> dict:
+    """One page of the channel's uploads. YouTube answers the uploads list of a channel with no
+    uploads at all as not found: an empty back-catalogue, so an empty last page — not a failure
+    that left `recent_synced_at` unstamped and charged the channel again on every run (E32 review).
+    Any other failure raises."""
+    try:
+        return yt.get_playlist_items(uploads, page_token)
+    except YouTubeError as exc:
+        if not is_playlist_gone(exc):
+            raise
+        log.info("backfill channel=%s has no uploads playlist", channel_id)
+        return {}
+
+
 def backfill_channel_recent(db: Session, yt: YouTubeClient, channel: Channel) -> int:
     """First pass: newest videos up to the configured count or age cutoff. Records a
     resume cursor for the later deep backfill."""
@@ -121,7 +137,7 @@ def backfill_channel_recent(db: Session, yt: YouTubeClient, channel: Channel) ->
 
     while True:
         page_start = page_token  # token that fetched THIS page (None = first page)
-        data = yt.get_playlist_items(channel.uploads_playlist_id, page_token)
+        data = _uploads_page(yt, channel.id, channel.uploads_playlist_id, page_token)
         stopped_mid_page = False
         for item in data.get("items", []):
             stub = stub_from_playlist_item(item, channel.id)
@@ -175,7 +191,7 @@ def backfill_channel_deep(
     for _ in range(max_pages):
         if quota.backfill_reserve_reached():
             break
-        data = yt.get_playlist_items(channel.uploads_playlist_id, page_token)
+        data = _uploads_page(yt, channel.id, channel.uploads_playlist_id, page_token)
         rows = [
             s
             for s in (stub_from_playlist_item(it, channel.id) for it in data.get("items", []))
diff --git a/backend/app/titles.py b/backend/app/titles.py
index b1e8553f..3e3330cc 100644
--- a/backend/app/titles.py
+++ b/backend/app/titles.py
@@ -60,7 +60,6 @@ _SHORT_LOWER = {
     "for",
     "or",
     "vs",
-    "the",
     "és",
     "az",
     "egy",
@@ -120,7 +119,6 @@ _ACRONYMS = {
     "nfl",
     "asmr",
     "pov",
-    "diy",
     "wtf",
     "lol",
     "rtx",
diff --git a/backend/app/worker.py b/backend/app/worker.py
index c5bd2ced..e2006bc9 100644
--- a/backend/app/worker.py
+++ b/backend/app/worker.py
@@ -25,6 +25,7 @@ import threading
 import time
 from collections.abc import Callable
 from datetime import datetime, timezone
+from functools import partial
 
 from sqlalchemy import text
 
@@ -72,7 +73,7 @@ def _wait_for_schema(timeout: float = 300.0) -> bool:
             with SessionLocal() as db:
                 db.execute(text("SELECT 1 FROM download_jobs LIMIT 1"))
             return True
-        except Exception:  # noqa: BLE001 — table not migrated yet / DB not up yet
+        except Exception:  # table not migrated yet / DB not up yet
             if time.monotonic() > deadline:
                 # The traceback, not `str(exc)[:120]`: this is the last thing the worker says
                 # before it exits, and which driver call failed is the whole question.
@@ -366,7 +367,7 @@ def _run_supervised(job_id: int, asset_id: int) -> None:
 
     try:
         proc = _spawn_download_child(job_id)
-    except Exception:  # noqa: BLE001 — spawn failed; don't leave the asset stuck 'downloading'
+    except Exception:  # spawn failed; don't leave the asset stuck 'downloading'
         log.exception("failed to spawn download child for job %s", job_id)
         _reset_asset_pending(asset_id)
         _requeue_if_running(job_id, None)
@@ -438,7 +439,7 @@ def _run_supervised(job_id: int, asset_id: int) -> None:
                         cause="child_exit",
                         exit_code=proc.returncode,
                     )
-        except Exception:  # noqa: BLE001 — boot recovery is the backstop for a stuck 'running' job
+        except Exception:  # boot recovery is the backstop for a stuck 'running' job
             log.exception("post-exit reconciliation failed for job %s", job_id)
         return
 
@@ -501,6 +502,7 @@ def _process_job(job_id: int) -> None:
     then run in a supervised CHILD PROCESS (`_run_supervised`) so a wedged yt-dlp/ffmpeg can be
     hard-killed — a worker THREAD cannot be killed, nor (when it spins in a C call) even
     cooperatively cancelled, and one such thread starves the others via the GIL."""
+    diagnosis = None  # set exactly when the asset has already failed (asset_status == "error")
     with SessionLocal() as db:
         job = db.get(DownloadJob, job_id)
         if job is None:
@@ -528,7 +530,7 @@ def _process_job(job_id: int) -> None:
     if asset_status == "ready":
         _finish_from_cache(job_id, asset_id)
         return
-    if asset_status == "error":
+    if diagnosis is not None:
         _fail_running(
             job_id,
             error=asset_error or "Download failed",
@@ -577,7 +579,7 @@ def _worker_loop(idx: int) -> None:
     while not _stop.is_set():
         try:
             job_id = _claim_job()
-        except Exception:  # noqa: BLE001
+        except Exception:
             log.exception("claim failed")
             _stop.wait(settings.download_poll_seconds)
             continue
@@ -597,12 +599,12 @@ def _worker_loop(idx: int) -> None:
                         job_id,
                         exc,
                         "crash",
-                        lambda: _fail_running(job_id, error="Worker error", error_code=None),
+                        partial(_fail_running, job_id, error="Worker error", error_code=None),
                     )
                 # silent-ok: not silent — `_report_worker_error` logged the crash before this
                 # re-raise. Failing the job hit the database, and letting that out would end this
                 # worker thread for good; boot recovery settles a job left `running`.
-                except Exception:  # noqa: BLE001
+                except Exception:
                     log.exception(
                         "could not fail job %s after its crash",
                         job_id,
diff --git a/backend/app/youtube/client.py b/backend/app/youtube/client.py
index 3439ca5b..400ea78c 100644
--- a/backend/app/youtube/client.py
+++ b/backend/app/youtube/client.py
@@ -114,18 +114,32 @@ _DEAD_GRANT = "invalid_grant"
 
 # What a refused YouTube action means to the person who asked for it — the three things they can
 # act on differently: wait for tomorrow's budget, reconnect the account, or try again later.
-YouTubeRefusal = Literal["quota", "reconnect", "unavailable"]
+YouTubeRefusal = Literal["quota", "reconnect", "unavailable", "gone"]
 
 
-def refusal_reason(exc: YouTubeError) -> YouTubeRefusal:
+def is_playlist_gone(exc: YouTubeError) -> bool:
+    """Whether YouTube answered that the playlist read or written does not exist. Only the caller
+    knows which playlist that was: a user's list deleted on YouTube, or a channel's uploads list,
+    which YouTube also answers so for a channel with no uploads at all."""
+    return "playlistNotFound" in exc.reason.split(",")
+
+
+def refusal_reason(exc: YouTubeError, *, playlist: bool = False) -> YouTubeRefusal:
     """Sort a failure by what the user can do about it. A dead grant (Google refused the refresh
     with `invalid_grant`, which also drops the grant — see `_drop_dead_grant`) or no usable token at
     all (raised before any endpoint answered, so with no path and no transport reason) means the
     account must be reconnected; retrying cannot help. Any other token-endpoint failure — a 5xx, a
     429, a misconfigured client — leaves the grant as it was: reconnecting would not fix it, and
-    the account would still read as connected, with no connect button to press."""
+    the account would still read as connected, with no connect button to press.
+
+    `playlist`: the action was on ONE playlist the user picked, so a missing playlist is that list,
+    gone (deleted on YouTube) — neither a retry nor a reconnect helps. Anywhere else the playlist
+    is one the user never named (a channel's uploads, one list of a bulk pull), and "this playlist
+    no longer exists" would describe nothing on their screen (E32 review round 2)."""
     if is_quota_refusal(exc):
         return "quota"
+    if playlist and is_playlist_gone(exc):
+        return "gone"
     if exc.path == "oauth2/token":
         return "reconnect" if exc.reason == _DEAD_GRANT else "unavailable"
     if not exc.path and exc.reason != "transport":
@@ -189,7 +203,7 @@ class YouTubeClient:
             return cached
         try:
             refresh = decrypt(tok.refresh_token_enc)
-        except Exception as exc:  # noqa: BLE001 — Fernet InvalidToken (TOKEN_ENCRYPTION_KEY changed)
+        except Exception as exc:  # Fernet InvalidToken (TOKEN_ENCRYPTION_KEY changed)
             # A key mismatch must degrade like any other token problem (caller handles YouTubeError),
             # not surface as a raw 500 on every scheduler job / connect check. (B-core-2)
             raise YouTubeError("Stored OAuth token is unreadable — reconnect your account") from exc
@@ -423,16 +437,22 @@ class YouTubeClient:
         return resp.json() if resp.content else {}
 
     def get_playlist_snippet(self, playlist_id: str) -> dict | None:
-        """The snippet (title/description) of one playlist, or None if it no longer
-        exists. 1 unit (OAuth, so private playlists work)."""
+        """The snippet (title/description) of one playlist plus its `item_count` (what an empty
+        item listing is checked against), or None if it no longer exists. 1 unit (OAuth, so
+        private playlists work)."""
         data = self._get(
             "playlists",
-            {"part": "snippet", "id": playlist_id, "maxResults": 1},
+            {"part": "snippet,contentDetails", "id": playlist_id, "maxResults": 1},
             cost=1,
             allow_key=False,
         )
         items = data.get("items", [])
-        return items[0].get("snippet") if items else None
+        if not items:
+            return None
+        return {
+            **(items[0].get("snippet") or {}),
+            "item_count": items[0].get("contentDetails", {}).get("itemCount"),
+        }
 
     def update_playlist_title(self, playlist_id: str, title: str) -> None:
         """Rename a playlist on YouTube. 50 units."""
diff --git a/backend/app/youtube/rss.py b/backend/app/youtube/rss.py
index 510bc13d..c8502f89 100644
--- a/backend/app/youtube/rss.py
+++ b/backend/app/youtube/rss.py
@@ -40,6 +40,7 @@ class RssError(Exception):
 def _get_feed(channel_id: str) -> bytes:
     """The feed's body, after up to `1 + len(RETRY_DELAYS)` tries; the LAST failure is raised."""
     url = RSS_URL.format(channel_id=channel_id)
+    error: RssError | None = None
     for attempt in range(len(RETRY_DELAYS) + 1):
         if attempt:
             time.sleep(RETRY_DELAYS[attempt - 1])
@@ -60,6 +61,8 @@ def _get_feed(channel_id: str) -> bytes:
         )
         if resp.status_code not in _RETRYABLE_STATUS:
             break
+    if error is None:  # cannot happen: the range above is never empty, and every try records one
+        raise RssError(f"RSS fetch for {channel_id} made no attempt", "transport")
     raise error
 
 
diff --git a/backend/app/youtube/search_scrape.py b/backend/app/youtube/search_scrape.py
index cfdbc95e..391416c8 100644
--- a/backend/app/youtube/search_scrape.py
+++ b/backend/app/youtube/search_scrape.py
@@ -42,6 +42,9 @@ _HEADERS = {
     "Accept-Language": "en-US,en;q=0.9",
 }
 
+# The top-level keys a first page (contents) and a continuation page (onResponseReceivedCommands)
+# put their result list under.
+_RESULT_FRAMES = {"contents", "onResponseReceivedCommands"}
 _KEY_RE = re.compile(r'"INNERTUBE_API_KEY":"([^"]+)"')
 _VER_RE = re.compile(r'"INNERTUBE_CLIENT_VERSION":"([^"]+)"')
 
@@ -65,29 +68,36 @@ def _runs_text(node: dict | None) -> str | None:
 
 
 def _get_config(client: httpx.Client) -> tuple[str, str]:
-    """The current InnerTube (api_key, client_version), cached after the first fetch."""
+    """The current InnerTube (api_key, client_version), cached after the first fetch that FOUND them.
+
+    The fallback pair is never cached: it used to be, so one failed fetch (or a consent page with no
+    keys on it) at the wrong moment pinned every later search to a hard-coded key and version for
+    the life of the process — and when those went stale, search returned nothing, with no error
+    anywhere (E32 S2). Now the next search simply tries the live pair again."""
     global _config
     if _config is not None:
         return _config
     try:
-        resp = client.get(_RESULTS_URL, params={"search_query": "music"})
-        html = resp.text
-        key = _KEY_RE.search(html)
-        ver = _VER_RE.search(html)
-        _config = (
-            key.group(1) if key else _FALLBACK_KEY,
-            ver.group(1) if ver else _FALLBACK_CLIENT_VERSION,
-        )
+        html = client.get(_RESULTS_URL, params={"search_query": "music"}).text
     except httpx.HTTPError as exc:
-        # The fallback pair is CACHED in `_config` for the life of the process, so one failed
-        # fetch at the wrong moment pins every later search to a hard-coded key and version —
-        # and when those go stale, search returns nothing at all, with no error anywhere.
         log.warning(
             "the InnerTube config could not be fetched; falling back to the pinned key",
             extra=logs.event("youtube.scrape.config_fallback", reason=type(exc).__name__),
         )
-        _config = (_FALLBACK_KEY, _FALLBACK_CLIENT_VERSION)
-    return _config
+        return (_FALLBACK_KEY, _FALLBACK_CLIENT_VERSION)
+    key = _KEY_RE.search(html)
+    ver = _VER_RE.search(html)
+    if key and ver:
+        _config = (key.group(1), ver.group(1))
+        return _config
+    log.warning(
+        "the results page carried no InnerTube config; falling back to the pinned key",
+        extra=logs.event("youtube.scrape.config_fallback", reason="not_on_page"),
+    )
+    return (
+        key.group(1) if key else _FALLBACK_KEY,
+        ver.group(1) if ver else _FALLBACK_CLIENT_VERSION,
+    )
 
 
 def _video_item(vr: dict) -> dict | None:
@@ -182,6 +192,10 @@ def search(q: str, continuation: str | None = None) -> dict:
         except ValueError as exc:  # non-JSON body (blocked / consent / captcha)
             raise ScrapeError("InnerTube returned a non-JSON response") from exc
 
+    # Even a search with no results carries its result list's frame. Without one this is not "no
+    # results" but a shape we do not know (YouTube moved, or a block page in JSON) — say so.
+    if not isinstance(data, dict) or not _RESULT_FRAMES & data.keys():
+        raise ScrapeError("InnerTube returned an unexpected shape")
     items: list[dict] = []
     _collect_videos(data, items, set())
     return {"items": items, "next_page_token": _find_continuation(data)}
diff --git a/backend/docker-compose.test.yml b/backend/docker-compose.test.yml
index 95d6ee95..4ce8ae39 100644
--- a/backend/docker-compose.test.yml
+++ b/backend/docker-compose.test.yml
@@ -35,4 +35,9 @@ services:
     volumes:
       - ./:/app
     working_dir: /app
-    command: python -m pytest
+    # The suite, then the coverage total (E32 D4: reported, no threshold). pytest's exit code is the
+    # lane's — the report is printed either way and never decides it.
+    command:
+      - sh
+      - -c
+      - 'python -m pytest --cov=app --cov-report= ; rc=$$?; echo ">> backend coverage (app/) $$(python -m coverage report --format=total)% of lines"; exit $$rc'
diff --git a/backend/pyrightconfig.json b/backend/pyrightconfig.json
index 6e32135f..e034ee46 100644
--- a/backend/pyrightconfig.json
+++ b/backend/pyrightconfig.json
@@ -25,7 +25,7 @@
 {
   "include": ["app", "alembic"],
   "extraPaths": ["."],
-  "typeCheckingMode": "basic",
+  "typeCheckingMode": "standard",
   "pythonVersion": "3.12",
   "pythonPlatform": "Linux"
 }
diff --git a/backend/pytest.ini b/backend/pytest.ini
index 6692f5b6..f92aa790 100644
--- a/backend/pytest.ini
+++ b/backend/pytest.ini
@@ -2,7 +2,9 @@
 # Run from backend/ (the image's /app). `pythonpath = .` puts the app package on sys.path so tests
 # import it as `app.*`, matching runtime. Most of the suite is pure-logic; the DB-backed lane opts in
 # via the `db` fixture and runs in the compose test image. `-rs` reports skip REASONS so a silently
-# skipped lane is visible (the compose lane sets SIFTLODE_TEST_REQUIRE_DB=1 to make skips a hard error).
+# skipped lane is visible (and conftest makes a missing DB/ffmpeg a hard error unless
+# SIFTLODE_TEST_REQUIRE_DB=0). `--strict-markers` (E32): a misspelt `@pytest.mark.skipiff` is an error,
+# not an unknown marker that quietly does nothing.
 testpaths = tests
 pythonpath = .
-addopts = -q -rs
+addopts = -q -rs --strict-markers
diff --git a/backend/requirements-dev.txt b/backend/requirements-dev.txt
index 311a35bd..b82f6104 100644
--- a/backend/requirements-dev.txt
+++ b/backend/requirements-dev.txt
@@ -7,7 +7,10 @@
 # basedpyright: the backend type-check lane (E27 S3). Pinned like everything else here — a type
 # checker whose version floats silently changes what "clean" means, and the ratchet baseline it
 # writes is keyed to the diagnostics THIS version produces.
+# pytest-cov: the coverage REPORT the gate prints (E32 D4) — a number to read, deliberately with no
+# threshold; "every regression test seen red" is the bar, not a percentage.
 basedpyright==1.40.1
 pytest==8.4.2
+pytest-cov==7.1.0
 ruff==0.15.21
 httpx2==2.13.0
diff --git a/backend/requirements.lock b/backend/requirements.lock
index 91c17790..eb3457d1 100644
--- a/backend/requirements.lock
+++ b/backend/requirements.lock
@@ -1,7 +1,10 @@
 # Pinned dependency lock for reproducible builds (SEC-5). GENERATED — do not hand-edit.
 # Source of truth is requirements.txt (the floor ranges); regenerate after editing it with:
 #   docker run --rm -v "$PWD":/b python:3.12-slim sh -c 'pip install -q -r /b/requirements.txt && pip freeze --exclude pip --exclude setuptools --exclude wheel' | sort
-# The prod Dockerfile + Dockerfile.test + CI install THIS file; pip-audit scans it in CI.
+# The prod Dockerfile + Dockerfile.test + CI install THIS file; pip-audit scans it in CI (blocking
+# since E32). A security fix may be ONE pin bumped in place instead of a full regeneration, which
+# would move every other package too — then `pip install -r requirements.lock && pip check` must
+# pass. In place so far: urllib3 2.7.0 -> 2.8.0 (PYSEC-2026-4175/4176/4177, E32).
 APScheduler==3.11.3
 Authlib==1.7.2
 Mako==1.4.1
@@ -53,7 +56,7 @@ starlette==1.6.0
 typing-inspection==0.4.4
 typing_extensions==4.16.0
 tzlocal==5.4.4
-urllib3==2.7.0
+urllib3==2.8.0
 uvicorn==0.52.3
 uvloop==0.22.1
 watchfiles==1.2.0
diff --git a/backend/ruff.toml b/backend/ruff.toml
index f69ce16c..57145a40 100644
--- a/backend/ruff.toml
+++ b/backend/ruff.toml
@@ -1,7 +1,8 @@
 # Ruff config for the Siftlode backend. Keeps ruff's default rule set (E4/E7/E9 + F = the
-# high-signal pyflakes/pycodestyle checks that catch real dead code + bugs), but ignores E402:
-# a handful of modules (e.g. main.py) deliberately run setup — logging config, sys.path — before
-# importing route modules, so "module import not at top of file" is intentional there, not cruft.
+# high-signal pyflakes/pycodestyle checks that catch real dead code + bugs), all of it on. E402 was
+# ignored for main.py's logging setup; the ignore had let 11 incidental late imports in elsewhere
+# (E32 review), so it is on now and main.py marks each deliberate one (`# noqa: E402 — <why>`).
+# `scripts/e2e_seed.py` edits `sys.path` before its imports, which E402 itself allows.
 #
 # line-length 100 (ruff's default is 88): matches the frontend prettier printWidth so both halves of
 # the repo wrap at the same width, and it's the width `ruff format` enforces (gated via
@@ -17,9 +18,10 @@ target-version = "py312"
 #   LOG     — stdlib logging misuse (`.warn()`, a logger built by hand, `exc_info` on `.exception`)
 #   G       — the call's shape: %-style args, never an f-string the level filter cannot skip, and
 #             never `str(exc)` where `exc_info` would carry the traceback
-#   T20     — `print` instead of a log line. Two deliberate ones remain, each with its `# noqa`
-#             and a why: `downloads/runner.py`'s usage line is for whoever typed it, and
-#             `logsink.py` reports the SINK's own failure, which cannot be logged into the sink.
+#   T20     — `print` instead of a log line. Three deliberate ones remain, each with its `# noqa`
+#             and a why: `downloads/runner.py`'s usage line is for whoever typed it, `logsink.py`
+#             reports the SINK's own failure, which cannot be logged into the sink, and
+#             `scripts/e2e_seed.py` prints the seeded ids for the e2e run that reads them.
 #   TRY400  — `.error()` in an `except` where `.exception()` would keep the traceback
 #   TRY401  — the exception spelled into the message AND passed as `exc_info` (it is in both)
 #   S112    — `except: continue`, the silent swallow inside a loop
@@ -29,5 +31,22 @@ target-version = "py312"
 #             nobody to raise to, a best-effort backfill inside a sync) and always worth a sentence.
 # The wider rule these two enforce lives in tests/test_swallowed_exceptions.py: a handler that
 # neither logs nor re-raises says `# silent-ok: <why>`. Ruff sees only the two narrow shapes.
-extend-select = ["LOG", "G", "T20", "TRY400", "TRY401", "S110", "S112", "BLE001"]
-ignore = ["E402"]
+#
+# E32 (gate integrity) added three more, each measured before it went on and with every hit fixed:
+#   RUF100  — a `# noqa` that suppresses nothing. A stale one is a claim with no rule behind it, and
+#             it stays armed for the day the line changes (24 were removed). A comment that merely
+#             explains a noqa below it names the rule as `# TRY400: …`, never `# noqa TRY400`.
+#   PLW1510 — `subprocess.run` without an explicit `check=`. Found the real E32 bug: three ffprobe
+#             probes read the output of a probe that had FAILED and took it for the file's truth.
+#   B       — flake8-bugbear: loop-variable capture, `raise` without `from` inside `except`, a
+#             `zip` that silently truncates (each one is `strict=True` now — the lengths are an
+#             invariant, so a mismatch should be loud). B008 (a call in a default argument) stays ON:
+#             FastAPI's `Depends(...)` / `Query(...)` ARE that shape by design (474 hits, all of
+#             them), so those two are declared immutable below instead of switching the rule off —
+#             any other call in a default still fails.
+extend-select = [
+  "LOG", "G", "T20", "TRY400", "TRY401", "S110", "S112", "BLE001", "RUF100", "PLW1510", "B",
+]
+
+[lint.flake8-bugbear]
+extend-immutable-calls = ["fastapi.Depends", "fastapi.Query"]
diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py
index c25be444..3c25394f 100644
--- a/backend/tests/conftest.py
+++ b/backend/tests/conftest.py
@@ -25,7 +25,7 @@ from fastapi.testclient import TestClient
 from sqlalchemy import create_engine, event, text
 from starlette.requests import HTTPConnection
 
-import app.models  # noqa: F401 — register every model on Base.metadata
+import app.models  # register every model on Base.metadata
 import app.state as app_state
 from app import security
 from app.auth import current_user
@@ -37,9 +37,11 @@ from app.models import User
 # Sentinel for "this dependency had no override before the fixture set one" (see override_dep).
 _MISSING = object()
 
-# The compose test lane sets this so a would-be silent skip (no DB, or no ffmpeg) becomes a hard error
-# — the gate must not print green while the DB-backed / ffmpeg tests were quietly not run.
-_REQUIRE_FULL = os.getenv("SIFTLODE_TEST_REQUIRE_DB") == "1"
+# A would-be silent skip (no DB, or no ffmpeg) is a hard error unless the run says otherwise — the
+# suite must not print green while the DB-backed / ffmpeg tests were quietly not run. ON by default
+# since E32: as an opt-in only the compose lane and CI set, a hand-run `pytest` skipped ~60 DB tests
+# and still passed. `SIFTLODE_TEST_REQUIRE_DB=0` is the explicit "pure-logic only" run.
+_REQUIRE_FULL = os.getenv("SIFTLODE_TEST_REQUIRE_DB", "1") != "0"
 
 
 def _db_reachable() -> bool:
@@ -86,19 +88,20 @@ def _truncate_all():
 
 
 def pytest_configure(config):
-    """Fail the whole run — loudly, once — when SIFTLODE_TEST_REQUIRE_DB=1 but the environment can't
-    actually run the full suite. Without this, an unreachable DATABASE_URL or a missing ffmpeg turns
+    """Fail the whole run — loudly, once — when the full suite is required (the default) but the
+    environment can't actually run it. Without this, an unreachable DATABASE_URL or a missing ffmpeg turns
     ~60 DB tests + the poster tests into silent skips and the gate still exits green."""
     if not _REQUIRE_FULL:
         return
     if not _DB_REACHABLE:
         raise pytest.UsageError(
-            "SIFTLODE_TEST_REQUIRE_DB=1 but no Postgres is reachable at the test DATABASE_URL — the "
-            "DB-backed lane would silently skip. Fix the DB wiring or unset the flag."
+            "no Postgres is reachable at the test DATABASE_URL — the DB-backed lane would silently "
+            "skip. Fix the DB wiring, or run the pure-logic tests only with SIFTLODE_TEST_REQUIRE_DB=0."
         )
     if shutil.which("ffmpeg") is None:
         raise pytest.UsageError(
-            "SIFTLODE_TEST_REQUIRE_DB=1 but ffmpeg is missing — the thumbnail/poster tests would skip."
+            "ffmpeg is missing — the thumbnail/poster tests would skip. Install it, or run the "
+            "pure-logic tests only with SIFTLODE_TEST_REQUIRE_DB=0."
         )
 
 
diff --git a/backend/tests/test_abuse_limits.py b/backend/tests/test_abuse_limits.py
index 6ff1ca84..0593cacb 100644
--- a/backend/tests/test_abuse_limits.py
+++ b/backend/tests/test_abuse_limits.py
@@ -36,9 +36,14 @@ def test_a_public_url_gets_past_the_guard(db, as_user, make_user, monkeypatch):
         "getaddrinfo",
         lambda *a, **kw: [(None, None, None, "", ("93.184.216.34", 0))],
     )
-    r = as_user(user).post("/api/downloads", json={"source": "https://example.com/v"})
-    detail = r.json().get("detail") if r.status_code >= 400 else None
-    assert not (isinstance(detail, dict) and detail.get("code") == "url_blocked")
+    # An inline spec, so nothing ELSE refuses it: without one the request stopped at the
+    # profile lookup (400 no_profile) and "not url_blocked" held for a request the guard never
+    # had to wave through (E32 S2).
+    r = as_user(user).post(
+        "/api/downloads", json={"source": "https://example.com/v", "spec": {"format": "best"}}
+    )
+    assert r.status_code == 200, r.text
+    assert r.json()["status"] == "queued"
 
 
 def test_youtube_sources_never_consult_the_guard(db, as_user, make_user, monkeypatch):
@@ -50,7 +55,13 @@ def test_youtube_sources_never_consult_the_guard(db, as_user, make_user, monkeyp
     user = make_user()
     db.commit()
     monkeypatch.setattr(urlguard.socket, "getaddrinfo", boom)
-    as_user(user).post("/api/downloads", json={"source": "dQw4w9WgXcQ"})
+    # The job must actually be created: a request refused for any other reason would never reach
+    # the guard either, and the test would pass without proving anything (E32 S2).
+    r = as_user(user).post(
+        "/api/downloads", json={"source": "dQw4w9WgXcQ", "spec": {"format": "best"}}
+    )
+    assert r.status_code == 200, r.text
+    assert r.json()["source_kind"] == "youtube"
 
 
 def test_manual_subscription_sync_goes_on_cooldown(db, as_user, make_user, monkeypatch):
@@ -81,8 +92,12 @@ def test_the_cooldown_is_per_user_not_global(db, as_user, make_user, monkeypatch
     monkeypatch.setattr(syncroutes, "import_subscriptions", lambda d, u: {"imported": 0})
 
     ca = as_user(a)
-    for _ in range(4):
-        ca.post("/api/sync/subscriptions")
+    assert [ca.post("/api/sync/subscriptions").status_code for _ in range(4)] == [
+        200,
+        200,
+        200,
+        429,
+    ]
     assert ca.post("/api/sync/subscriptions").status_code == 429
     assert as_user(b).post("/api/sync/subscriptions").status_code == 200
 
diff --git a/backend/tests/test_autotag_orphans.py b/backend/tests/test_autotag_orphans.py
new file mode 100644
index 00000000..a9eb5605
--- /dev/null
+++ b/backend/tests/test_autotag_orphans.py
@@ -0,0 +1,64 @@
+"""sync/autotag's orphan cleanup (E32 S2: the module was 32% covered).
+
+A system tag no channel carries any more is deleted — unless a saved feed view filters on it. The
+views hold tag ids; a deleted tag returns under a NEW id when a channel earns it again, and the feed
+drops an unknown id, so the view silently showed the whole feed under its old name.
+"""
+
+from sqlalchemy import select
+
+from app.models import Channel, ChannelTag, SavedView, Tag
+from app.sync import autotag
+
+
+def test_an_orphan_system_tag_goes_but_one_a_saved_view_filters_on_stays(db, make_user):
+    user = make_user()
+    used = Tag(user_id=None, name="Gaming", category="topic")
+    orphan = Tag(user_id=None, name="Cooking", category="topic")
+    in_view = Tag(user_id=None, name="Music", category="topic")
+    own = Tag(user_id=user.id, name="Mine", category="other")
+    ch = Channel(id="UC_tags", title="T")
+    db.add_all([used, orphan, in_view, own, ch])
+    db.flush()
+    db.add(ChannelTag(channel_id=ch.id, tag_id=used.id, user_id=None, source="auto"))
+    db.add(
+        SavedView(
+            user_id=user.id, source="feed", name="Music", filters={"tags": [in_view.id], "q": ""}
+        )
+    )
+    # A Plex view's filters are another vocabulary; they must not break the scan.
+    db.add(SavedView(user_id=user.id, source="plex", name="P", filters={"genres": ["Drama"]}))
+    db.commit()
+
+    assert autotag._cleanup_orphan_system_tags(db) == 1
+    db.expire_all()
+    names = set(db.execute(select(Tag.name)).scalars())
+    assert names == {"Gaming", "Music", "Mine"}  # only the unreferenced system orphan went
+
+
+def test_a_malformed_saved_view_cannot_break_the_cleanup(db, make_user):
+    """A view stored around the route's shape check (or before it) must not raise for everyone's job
+    — `"tags": 5` raised TypeError — and `True` is not tag id 1 (E32 review)."""
+    user = make_user()
+    orphan = Tag(user_id=None, name="Cooking", category="topic")
+    db.add(orphan)
+    db.flush()
+    for i, filters in enumerate(
+        ({"tags": 5}, {"tags": [True]}, ["not", "a", "dict"], {"tags": None})
+    ):
+        db.add(SavedView(user_id=user.id, source="feed", name=f"bad{i}", filters=filters))
+    db.commit()
+    assert autotag._cleanup_orphan_system_tags(db) == 1
+    db.expire_all()
+    assert db.execute(select(Tag).where(Tag.name == "Cooking")).first() is None
+
+
+def test_a_view_kept_tag_list_larger_than_a_bind_parameter_limit_still_cleans_up(db, make_user):
+    user = make_user()
+    orphan = Tag(user_id=None, name="Cooking", category="topic")
+    db.add(orphan)
+    db.flush()
+    huge = list(range(10_000_000, 10_070_000))  # past psycopg's 65535 bind parameters
+    db.add(SavedView(user_id=user.id, source="feed", name="huge", filters={"tags": huge}))
+    db.commit()
+    assert autotag._cleanup_orphan_system_tags(db) == 1
diff --git a/backend/tests/test_body_limit.py b/backend/tests/test_body_limit.py
index d967643d..905537e7 100644
--- a/backend/tests/test_body_limit.py
+++ b/backend/tests/test_body_limit.py
@@ -321,7 +321,7 @@ def _body_reading_functions() -> dict[tuple[str, str], dict]:
                 continue
             names = [name for _, name in calls]
             limits = []
-            for node, name in zip([n for n, _ in calls], names):
+            for node, name in zip([n for n, _ in calls], names, strict=True):
                 if name.startswith("request."):
                     limits.append("<no ceiling declared>")
                     continue
diff --git a/backend/tests/test_debug_sessions.py b/backend/tests/test_debug_sessions.py
index 6a791922..30f20bc8 100644
--- a/backend/tests/test_debug_sessions.py
+++ b/backend/tests/test_debug_sessions.py
@@ -151,7 +151,7 @@ def test_nobody_reaches_another_users_session(db, make_user, as_user):
 def test_the_list_is_the_users_own_newest_first(db, make_user, as_user):
     client = as_user(make_user())
     first = _start(client)["id"]
-    client.post(f"/api/debug-sessions/{first}/stop")
+    assert client.post(f"/api/debug-sessions/{first}/stop").status_code == 200
     second = _start(client)["id"]
     assert [s["id"] for s in client.get("/api/debug-sessions").json()["items"]] == [second, first]
 
@@ -199,10 +199,13 @@ def test_an_erased_account_takes_its_sessions_with_it(db, make_user, as_user):
     user = make_user()
     client = as_user(user)
     sid = _start(client)["id"]
-    client.post(
-        f"/api/debug-sessions/{sid}/screenshots",
-        content=_PNG,
-        headers={"content-type": "image/png"},
+    assert (
+        client.post(
+            f"/api/debug-sessions/{sid}/screenshots",
+            content=_PNG,
+            headers={"content-type": "image/png"},
+        ).status_code
+        == 200
     )
     purge_user(db, user, BackgroundTasks())
     assert db.get(DebugSession, sid) is None
@@ -250,7 +253,7 @@ def test_a_request_naming_the_own_open_session_is_tagged_and_raised(gated, db, c
     _signed_in(client, make_user)
     sid = _start(client, "DEBUG")["id"]
     gated.records.clear()
-    client.get("/api/debug-sessions", headers={"x-debug-session": sid})
+    assert client.get("/api/debug-sessions", headers={"x-debug-session": sid}).status_code == 200
     (line,) = _request_lines(gated)
     assert getattr(line, "debug_session_id", None) == sid
     # Raised to the session's level: the line is kept for storage though the user's own is Alap.
@@ -263,7 +266,7 @@ def test_a_header_naming_anything_else_is_ignored_not_refused(gated, db, client,
     db.commit()
     _signed_in(client, make_user)
     own = _start(client)["id"]
-    client.post(f"/api/debug-sessions/{own}/stop")
+    assert client.post(f"/api/debug-sessions/{own}/stop").status_code == 200
     for value in (foreign, own, "not-a-session", "f" * 16, "A" * 16):
         gated.records.clear()
         # Not `/api/me`: a polled route logs at DEBUG, and an un-raised request would drop the very
@@ -280,7 +283,7 @@ def test_a_header_naming_the_own_session_past_its_cap_is_ignored(gated, db, clie
     sid = _start(client)["id"]
     _expire(db, sid)  # past its cap, not yet swept: still open in the table
     gated.records.clear()
-    client.get("/api/debug-sessions", headers={"x-debug-session": sid})
+    assert client.get("/api/debug-sessions", headers={"x-debug-session": sid}).status_code == 200
     (line,) = _request_lines(gated)
     assert getattr(line, "debug_session_id", None) is None
     assert getattr(line, "elevated", False) is False
@@ -616,7 +619,7 @@ def test_a_users_screenshots_are_capped_across_their_sessions(recording, monkeyp
     client, sid = recording
     monkeypatch.setattr(debugsession, "SCREENSHOT_USER_MAX_BYTES", len(_PNG) * 2)
     assert _upload(client, sid, _PNG).status_code == 200
-    client.post(f"/api/debug-sessions/{sid}/stop")
+    assert client.post(f"/api/debug-sessions/{sid}/stop").status_code == 200
     other = _start(client)["id"]
     assert _upload(client, other, _PNG).status_code == 200
     r = _upload(client, other, _PNG)
@@ -631,7 +634,7 @@ def test_new_sessions_are_paced_but_joining_one_is_not(db, make_user, as_user, m
     client = as_user(make_user())
     sid = _start(client)["id"]
     assert _start(client)["id"] == sid  # another tab joining
-    client.post(f"/api/debug-sessions/{sid}/stop")
+    assert client.post(f"/api/debug-sessions/{sid}/stop").status_code == 200
     r = client.post("/api/debug-sessions", json={"level": "DEBUG"})
     assert r.status_code == 429 and r.json()["detail"]["reason"] == "debug_session_rate_limited"
 
@@ -745,9 +748,16 @@ def test_the_export_is_the_saved_draft_the_evidence_and_the_screenshots(db, make
     db.commit()
     _upload(client, sid, _PNG)
     _upload(client, sid, _JPEG)
-    client.put(
-        f"/api/debug-sessions/{sid}/draft",
-        json={"title": "Spinner stays", "body": "It spins.", "excluded": [dropped_web.id, 999999]},
+    assert (
+        client.put(
+            f"/api/debug-sessions/{sid}/draft",
+            json={
+                "title": "Spinner stays",
+                "body": "It spins.",
+                "excluded": [dropped_web.id, 999999],
+            },
+        ).status_code
+        == 200
     )
 
     r = client.get(f"/api/debug-sessions/{sid}/export")
@@ -1144,7 +1154,7 @@ def test_new_issues_are_paced_per_user(gitea_fake, db, make_user, as_user, monke
     first = _start(client)["id"]
     _ready(client, first)
     assert client.post(f"/api/debug-sessions/{first}/issue").status_code == 200
-    client.post(f"/api/debug-sessions/{first}/stop")
+    assert client.post(f"/api/debug-sessions/{first}/stop").status_code == 200
     second = _start(client)["id"]
     _ready(client, second)
     r = client.post(f"/api/debug-sessions/{second}/issue")
diff --git a/backend/tests/test_diagnostics.py b/backend/tests/test_diagnostics.py
index a64b4712..93ea40ce 100644
--- a/backend/tests/test_diagnostics.py
+++ b/backend/tests/test_diagnostics.py
@@ -212,7 +212,12 @@ def test_a_timestamp_outside_the_consent_window_is_clamped(elevated):
     now = datetime.now(timezone.utc)
     future = (now + timedelta(days=365)).isoformat()
     past = (now - timedelta(days=30)).isoformat()
-    client.post("/api/diagnostics/events", json={"events": [_event(ts=future), _event(ts=past)]})
+    assert (
+        client.post(
+            "/api/diagnostics/events", json={"events": [_event(ts=future), _event(ts=past)]}
+        ).status_code
+        == 200
+    )
     late, early = rows()
     assert late.ts <= datetime.now(timezone.utc)
     assert early.ts >= now - timedelta(hours=diagnostics.ELEVATION_HOURS, minutes=1)
@@ -342,15 +347,15 @@ def _app() -> TestClient:
 
 
 def test_the_account_reaches_the_handlers_own_lines(gated):
-    _app().get("/api/thing/41")
+    assert _app().get("/api/thing/41").status_code == 200
     line = next(r for r in gated.records if r.getMessage() == "an ordinary line")
     assert getattr(line, "user_id", None) == 41
 
 
 def test_one_users_elevation_logs_their_requests_in_detail_and_nobody_elses(gated):
     client = _app()
-    client.get("/api/thing/7", params={"level": "DEBUG"})
-    client.get("/api/thing/8")
+    assert client.get("/api/thing/7", params={"level": "DEBUG"}).status_code == 200
+    assert client.get("/api/thing/8").status_code == 200
     detail = [r for r in gated.records if r.getMessage().startswith("detail only")]
     assert [r.user_id for r in detail] == [7]
     assert getattr(detail[0], "elevated", False) is True
@@ -363,9 +368,9 @@ def test_one_users_elevation_logs_their_requests_in_detail_and_nobody_elses(gate
 
 def test_the_root_level_returns_to_the_base_when_the_elevation_ends(gated):
     client = _app()
-    client.get("/api/thing/7", params={"level": "TRACE"})
+    assert client.get("/api/thing/7", params={"level": "TRACE"}).status_code == 200
     assert logging.getLogger().level == logs.TRACE
-    client.get("/api/thing/7")  # the same user, back at the base
+    assert client.get("/api/thing/7").status_code == 200  # the same user, back at the base
     assert logging.getLogger().level == logging.INFO
     logs._track_elevation(9, logging.DEBUG, datetime.now(timezone.utc) - timedelta(seconds=1))
     assert logging.getLogger().level == logging.INFO  # an already-expired one is pruned at once
@@ -373,15 +378,25 @@ def test_the_root_level_returns_to_the_base_when_the_elevation_ends(gated):
 
 def test_the_query_string_is_logged_only_for_a_traced_request_and_redacted(gated):
     client = _app()
-    client.get("/api/thing/7", params={"level": "DEBUG", "q": "lofi"})
-    client.get("/api/thing/7", params={"level": "TRACE", "q": "lofi", "token": "SECRET"})
+    assert client.get("/api/thing/7", params={"level": "DEBUG", "q": "lofi"}).status_code == 200
+    assert (
+        client.get(
+            "/api/thing/7", params={"level": "TRACE", "q": "lofi", "token": "SECRET"}
+        ).status_code
+        == 200
+    )
     lines = [r for r in gated.records if getattr(r, "event", None) == "http.request"]
     assert "query" not in lines[0].attrs
     assert "q=lofi" in lines[1].attrs["query"] and "SECRET" not in lines[1].attrs["query"]
 
 
 def test_an_address_typed_into_a_search_is_redacted_though_the_browser_encodes_it(gated):
-    _app().get("/api/thing/7?level=TRACE&q=someone%40example.com&new_password=hunter2")
+    assert (
+        _app()
+        .get("/api/thing/7?level=TRACE&q=someone%40example.com&new_password=hunter2")
+        .status_code
+        == 200
+    )
     (line,) = [r for r in gated.records if getattr(r, "event", None) == "http.request"]
     assert line.attrs["query"] == "level=TRACE&q=[email]&new_password=[redacted]"
 
@@ -400,7 +415,7 @@ def test_a_credential_param_goes_whole_however_its_value_decodes(raw):
 
 def test_an_admin_level_of_trace_does_not_log_other_users_query_strings(gated):
     logs.set_level("TRACE")
-    _app().get("/api/thing/7", params={"q": "something private"})
+    assert _app().get("/api/thing/7", params={"q": "something private"}).status_code == 200
     (line,) = [r for r in gated.records if getattr(r, "event", None) == "http.request"]
     assert "query" not in line.attrs
 
@@ -488,7 +503,7 @@ def test_a_real_sign_in_carries_the_consented_level_into_the_process(gated, clie
     user = _signed_in(client, make_user)
     assert client.put("/api/me/diagnostics", json={"level": "DEBUG"}).status_code == 200
     logs._elevations.clear()  # only a request resolving the account through auth may put it back
-    client.get("/api/me")
+    assert client.get("/api/me").status_code == 200
     assert logs._elevations[user.id][0] == logging.DEBUG
     assert client.put("/api/me/diagnostics", json={"level": "INFO"}).status_code == 200
     assert user.id not in logs._elevations
diff --git a/backend/tests/test_email_canonical.py b/backend/tests/test_email_canonical.py
index 1fd45233..4b3fed24 100644
--- a/backend/tests/test_email_canonical.py
+++ b/backend/tests/test_email_canonical.py
@@ -13,12 +13,12 @@ hold for Google Workspace custom domains unless their admin enabled it.
 import pytest
 from sqlalchemy import select, text
 
-_UAT_PW = "correct horse battery"
-
 from app.auth import is_allowed
 from app.models import Invite, User
 from app.utils import canonical_email
 
+_UAT_PW = "correct horse battery"
+
 # (input, expected canonical) — the matrix the sprint promised, plus the shapes that must NOT fold.
 CASES = [
     # Gmail: dots and +tags are noise…
@@ -334,7 +334,7 @@ def test_me_reports_the_google_address_only_when_it_differs(client, db, make_use
     )
     assert client.get("/api/me").json()["google_email"] is None
 
-    client.post("/auth/logout")
+    assert client.post("/auth/logout").status_code == 200
     tagged = make_user(email="me+siftlode@gmail.com", password=_UAT_PW)
     tagged.google_email = "me@gmail.com"
     db.commit()
diff --git a/backend/tests/test_empty_listing_guards.py b/backend/tests/test_empty_listing_guards.py
new file mode 100644
index 00000000..57a2c92d
--- /dev/null
+++ b/backend/tests/test_empty_listing_guards.py
@@ -0,0 +1,259 @@
+"""An empty answer is not an emptied library (E32 S2).
+
+Every mirror here reconciles: what the remote no longer lists is removed locally. The catalog
+(`_prune_stale`) and the subscriptions (`should_prune`) had long refused to do that on an empty
+listing that contradicts what we hold — a 200 with no items is a blip far more often than a user
+who removed everything. Two mirrors did not: the Plex collections (a row carries the user-set
+`editable` flag, and every member its keys) and the YouTube playlist mirrors. These hold both — and,
+one level down (E32 review), a collection's members and a playlist's items: an empty answer that
+contradicts the remote's own count is not believed either.
+"""
+
+import pytest
+from sqlalchemy import select
+
+from app.models import (
+    Channel,
+    Playlist,
+    PlaylistItem,
+    PlexCollection,
+    PlexItem,
+    PlexLibrary,
+    Video,
+)
+from app.plex import sync as plex_sync
+from app.sync import playlists as plsync
+from app.youtube.client import YouTubeError
+
+
+class _Plex:
+    def __init__(self, collections: list[dict], children: dict[str, list[dict]]):
+        self._collections = collections
+        self._children = children
+
+    def collections(self, section_key):
+        return self._collections
+
+    def collection_children(self, rk):
+        return self._children.get(rk, [])
+
+    def metadata(self, rk):
+        return next((c for c in self._collections if c.get("ratingKey") == rk), {})
+
+
+def _library_with_a_collection(db):
+    lib = PlexLibrary(plex_key="4", title="Movies", kind="movie")
+    db.add(lib)
+    db.flush()
+    db.add(PlexCollection(rating_key="c1", library_id=lib.id, title="Bond", editable=True))
+    movie = PlexItem(
+        rating_key="m1", library_id=lib.id, kind="movie", title="Dr. No", collection_keys=["c1"]
+    )
+    db.add(movie)
+    db.commit()
+    return lib, movie
+
+
+def test_an_empty_collection_listing_keeps_the_collections_and_their_members(db):
+    lib, movie = _library_with_a_collection(db)
+    stats = {"collections": 0}
+    plex_sync._sync_collections(db, _Plex([], {}), lib, stats)
+    db.commit()
+    db.expire_all()
+    col = db.execute(select(PlexCollection).where(PlexCollection.rating_key == "c1")).scalar_one()
+    assert col.editable is True
+    assert db.get(PlexItem, movie.id).collection_keys == ["c1"]
+
+
+def test_a_listing_with_something_in_it_still_prunes_what_it_no_longer_has(db):
+    lib, movie = _library_with_a_collection(db)
+    stats = {"collections": 0}
+    other = {"ratingKey": "c2", "title": "Alien"}
+    plex_sync._sync_collections(db, _Plex([other], {"c2": []}), lib, stats)
+    db.commit()
+    db.expire_all()
+    keys = set(db.execute(select(PlexCollection.rating_key)).scalars())
+    assert keys == {"c2"}
+    assert db.get(PlexItem, movie.id).collection_keys is None
+
+
+def test_no_members_from_a_collection_plex_counts_as_non_empty_keeps_its_members(db):
+    lib, movie = _library_with_a_collection(db)
+    stats = {"collections": 0}
+    bond = {"ratingKey": "c1", "title": "Bond", "childCount": 2}
+    plex_sync._sync_collections(db, _Plex([bond], {"c1": []}), lib, stats)
+    db.commit()
+    db.expire_all()
+    assert db.get(PlexItem, movie.id).collection_keys == ["c1"]
+
+
+def test_a_collection_plex_counts_as_empty_does_lose_its_members(db):
+    lib, movie = _library_with_a_collection(db)
+    stats = {"collections": 0}
+    bond = {"ratingKey": "c1", "title": "Bond", "childCount": 0}
+    plex_sync._sync_collections(db, _Plex([bond], {"c1": []}), lib, stats)
+    db.commit()
+    db.expire_all()
+    assert db.get(PlexItem, movie.id).collection_keys is None
+
+
+@pytest.mark.parametrize(("count", "kept"), [(2, ["c1"]), (0, None)])
+def test_a_collection_resync_believes_an_empty_member_list_only_with_a_zero_count(db, count, kept):
+    lib, movie = _library_with_a_collection(db)
+    bond = {"ratingKey": "c1", "title": "Bond", "childCount": count}
+    plex_sync.resync_collection(db, _Plex([bond], {"c1": []}), lib, "c1")
+    db.commit()
+    db.expire_all()
+    assert db.get(PlexItem, movie.id).collection_keys == kept
+
+
+class _YT:
+    def __init__(self, playlists: list[dict], snippet: dict | None = None):
+        self._playlists = playlists
+        self._snippet = snippet
+
+    def __call__(self, *_):
+        return self
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        return False
+
+    def iter_my_playlists(self):
+        return self._playlists
+
+    def iter_playlist_items_with_ids(self, _ytid):
+        return []
+
+    def iter_my_playlist_video_ids(self, _ytid):
+        return []
+
+    def get_playlist_snippet(self, _ytid):
+        return self._snippet
+
+    def get_videos(self, _ids):
+        return []
+
+
+def test_an_empty_playlist_answer_keeps_the_youtube_mirrors(db, make_user, monkeypatch):
+    user = make_user()
+    db.add(Playlist(user_id=user.id, name="Mixes", source="youtube", yt_playlist_id="PL1"))
+    db.commit()
+    monkeypatch.setattr(plsync, "YouTubeClient", _YT([]))
+    plsync.pull_user_playlists(db, user)
+    db.expire_all()
+    names = db.execute(select(Playlist.name).where(Playlist.user_id == user.id)).scalars().all()
+    assert "Mixes" in names
+
+
+def test_a_playlist_answer_with_something_in_it_still_drops_a_vanished_mirror(
+    db, make_user, monkeypatch
+):
+    user = make_user()
+    db.add(Playlist(user_id=user.id, name="Mixes", source="youtube", yt_playlist_id="PL1"))
+    db.commit()
+    monkeypatch.setattr(plsync, "YouTubeClient", _YT([{"id": "PL2", "title": "New"}]))
+    plsync.pull_user_playlists(db, user)
+    db.expire_all()
+    ytids = set(
+        db.execute(select(Playlist.yt_playlist_id).where(Playlist.source == "youtube")).scalars()
+    )
+    assert "PL1" not in ytids
+
+
+class _YTOneGone(_YT):
+    """A list deleted on YouTube between the listing and the read of its items."""
+
+    def iter_my_playlist_video_ids(self, ytid):
+        if ytid == "PLgone":
+            raise YouTubeError("m", reason="playlistNotFound", path="playlistItems")
+        return []
+
+
+def test_a_list_deleted_mid_pull_is_skipped_and_the_rest_still_sync(db, make_user, monkeypatch):
+    # Not "this playlist no longer exists" for a bulk pull the user never named a list in, and not
+    # a failure for every other list either (E32 review round 2): the next pull drops the mirror.
+    user = make_user()
+    db.commit()
+    listing = [
+        {"id": "PLgone", "title": "Gone", "item_count": 3},
+        {"id": "PL2", "title": "Kept", "item_count": 0},
+    ]
+    monkeypatch.setattr(plsync, "YouTubeClient", _YTOneGone(listing))
+    assert plsync.pull_user_playlists(db, user) == {"synced": 1}
+    db.expire_all()
+    ytids = set(
+        db.execute(select(Playlist.yt_playlist_id).where(Playlist.user_id == user.id)).scalars()
+    )
+    assert ytids == {"PL2"}
+
+
+def _mirror_with_an_item(db, user, **kw):
+    db.add(Channel(id="UC_pl", title="C"))
+    db.flush()
+    db.add(Video(id="v1", channel_id="UC_pl", title="One"))
+    pl = Playlist(user_id=user.id, name="Mixes", yt_playlist_id="PL1", **kw)
+    db.add(pl)
+    db.flush()
+    db.add(PlaylistItem(playlist_id=pl.id, video_id="v1", position=0))
+    db.commit()
+    return pl
+
+
+def _items(db, pl):
+    db.expire_all()
+    return (
+        db.execute(select(PlaylistItem.video_id).where(PlaylistItem.playlist_id == pl.id))
+        .scalars()
+        .all()
+    )
+
+
+def test_no_items_from_a_playlist_youtube_counts_as_non_empty_keeps_the_mirror_items(
+    db, make_user, monkeypatch
+):
+    user = make_user()
+    pl = _mirror_with_an_item(db, user, source="youtube")
+    listing = [{"id": "PL1", "title": "Mixes", "item_count": 1}]
+    monkeypatch.setattr(plsync, "YouTubeClient", _YT(listing))
+    plsync.pull_user_playlists(db, user)
+    assert _items(db, pl) == ["v1"]
+
+
+def test_a_playlist_youtube_counts_as_empty_is_emptied(db, make_user, monkeypatch):
+    user = make_user()
+    pl = _mirror_with_an_item(db, user, source="youtube")
+    listing = [{"id": "PL1", "title": "Mixes", "item_count": 0}]
+    monkeypatch.setattr(plsync, "YouTubeClient", _YT(listing))
+    plsync.pull_user_playlists(db, user)
+    assert _items(db, pl) == []
+
+
+def test_a_reset_to_youtube_refuses_a_blank_listing_and_keeps_the_items(db, make_user, monkeypatch):
+    user = make_user()
+    pl = _mirror_with_an_item(db, user, source="youtube")
+    monkeypatch.setattr(plsync, "YouTubeClient", _YT([], {"title": "Mixes", "item_count": 1}))
+    with pytest.raises(YouTubeError) as err:
+        plsync.repull_playlist(db, user, pl)
+    db.rollback()
+    assert err.value.reason == "emptyAnswer"
+    assert _items(db, pl) == ["v1"]
+
+
+def test_a_reset_of_a_deleted_playlist_says_it_is_gone(db, make_user, monkeypatch):
+    user = make_user()
+    pl = _mirror_with_an_item(db, user, source="youtube")
+    monkeypatch.setattr(plsync, "YouTubeClient", _YT([], None))
+    with pytest.raises(YouTubeError) as err:
+        plsync.repull_playlist(db, user, pl)
+    assert err.value.reason == "playlistNotFound"
+
+
+def test_a_push_plan_refuses_a_blank_listing_rather_than_reading_it_as_all_deleted(db, make_user):
+    user = make_user()
+    pl = _mirror_with_an_item(db, user, source="local")
+    with pytest.raises(YouTubeError) as err:
+        plsync.plan_merge(db, user, pl, live=([], {"title": "Mixes", "item_count": 1}))
+    assert err.value.reason == "emptyAnswer"
diff --git a/backend/tests/test_feed_views.py b/backend/tests/test_feed_views.py
index af190e8c..ec8d8c78 100644
--- a/backend/tests/test_feed_views.py
+++ b/backend/tests/test_feed_views.py
@@ -12,6 +12,8 @@ from datetime import datetime, timezone
 
 import pytest
 
+from app import feedquery
+
 from app.models import Channel, ChannelTag, Subscription, Tag, Video, VideoState
 
 
@@ -168,9 +170,50 @@ _SUMMARY_CASES = [
     "show=all&untagged=true&tags={L1}",
     "show=all&q=clip",
     "show=unwatched",
+    # A deleted tag's id (a saved view or the feed state still holds it) matches nothing.
+    "show=all&tags=987654",
+    "show=all&tags={L1}&tags=987654",
 ]
 
 
+def test_a_deleted_tags_id_filters_to_nothing_not_to_everything(db, as_user, make_user):
+    """A saved view or the feed's filter state keeps a tag id after the tag is deleted. The feed used
+    to drop an unknown id, so that view silently showed the WHOLE feed under its old name (E32 S2).
+    A filter on a tag that no longer exists matches nothing; the chip says the tag is gone."""
+    user, tag_ids = _seed_tagged(db, make_user)
+    client = as_user(user)
+    everything = client.get("/api/feed/count?show=all")
+    assert everything.status_code == 200
+    assert everything.json()["count"] == 8
+    for qs in ("show=all&tags=987654", f"show=all&tags={tag_ids['L1']}&tags=987654"):
+        r = client.get(f"/api/feed/count?{qs}")
+        assert r.status_code == 200
+        assert r.json()["count"] == 0, qs
+        r = client.get(f"/api/feed?{qs}")
+        assert r.status_code == 200
+        assert r.json()["items"] == [], qs
+
+
+def test_another_users_private_tag_answers_like_one_that_does_not_exist(db, as_user, make_user):
+    """The category split resolved any tag id, so a foreign PRIVATE tag landed in its real category
+    and the summary's facets differed from a non-existent id's: an oracle for which foreign ids exist
+    (E32 review). Both must now read as "missing"."""
+    user, tag_ids = _seed_tagged(db, make_user)
+    stranger = make_user(email="stranger@example.com")
+    private = Tag(user_id=stranger.id, name="Secret", category="language")
+    db.add(private)
+    db.commit()
+    assert feedquery.tags_by_category(db, user, [tag_ids["L1"], private.id]) == {
+        "language": [tag_ids["L1"]],
+        feedquery.MISSING_TAG_CATEGORY: [private.id],
+    }
+    client = as_user(user)
+    foreign = client.get(f"/api/feed/summary?show=all&tags={tag_ids['T1']}&tags={private.id}")
+    absent = client.get(f"/api/feed/summary?show=all&tags={tag_ids['T1']}&tags=987654")
+    assert foreign.status_code == absent.status_code == 200
+    assert foreign.json() == absent.json()
+
+
 def test_untagged_filter_keeps_only_channels_the_user_has_not_tagged(db, as_user, make_user):
     """The "No tag" filter (item B): `untagged=true` keeps only channels with NO tag the USER personally
     attached (no user-owned ChannelTag). System/auto tags (user_id NULL) don't count, and another user's
diff --git a/backend/tests/test_last_login.py b/backend/tests/test_last_login.py
index 02256d04..9b27aaff 100644
--- a/backend/tests/test_last_login.py
+++ b/backend/tests/test_last_login.py
@@ -100,7 +100,12 @@ def test_the_admin_user_list_carries_last_login(as_user, db, make_user):
 def test_the_account_sees_its_own_last_sign_in(client, db, make_user):
     # Settings → Account shows it (prod UAT 2026-09-19: only the admin's user list did).
     make_user(email="me@example.com", password=_PW)
-    client.post("/auth/password-login", json={"email": "me@example.com", "password": _PW})
+    assert (
+        client.post(
+            "/auth/password-login", json={"email": "me@example.com", "password": _PW}
+        ).status_code
+        == 200
+    )
 
     stamp = client.get("/api/me").json()["last_login_at"]
 
diff --git a/backend/tests/test_logs.py b/backend/tests/test_logs.py
index 86363f67..0d77f296 100644
--- a/backend/tests/test_logs.py
+++ b/backend/tests/test_logs.py
@@ -277,7 +277,7 @@ def test_a_signed_in_request_is_never_capped_and_names_its_account(sink):
 
     client = TestClient(app)
     for _ in range(logs.ANONYMOUS_LINES_PER_MINUTE + 3):
-        client.get("/api/me")
+        assert client.get("/api/me").status_code == 200
     records = sink.records[-(logs.ANONYMOUS_LINES_PER_MINUTE + 3) :]
     assert all(getattr(r, logs.PERSIST, True) for r in records)
     assert sink.objects()[-1]["user_id"] == 42 and "user_id" not in sink.objects()[-1]["attrs"]
@@ -325,9 +325,9 @@ def test_the_log_consoles_own_reads_are_debug_but_its_failures_are_not(sink):
     http = logging.getLogger("siftlode.http")
     http.setLevel(logs.TRACE)
     client = _client()
-    client.get("/api/admin/logs/facets")
+    assert client.get("/api/admin/logs/facets").status_code == 200
     assert sink.objects()[-1]["level"] == "DEBUG"
-    client.get("/api/admin/logs/facets?fail=1")
+    assert client.get("/api/admin/logs/facets?fail=1").status_code == 400
     assert sink.objects()[-1]["level"] == "WARNING"
 
 
@@ -344,7 +344,7 @@ def test_a_polled_read_is_debug_a_write_to_the_same_route_is_not(sink):
     r = client.post("/api/messages/unread_count")
     assert sink.objects()[-1]["level"] == "INFO"
     assert "X-Log-Quiet" not in r.headers
-    client.get("/api/videos/abc")
+    assert client.get("/api/videos/abc").status_code == 200
     assert sink.objects()[-1]["level"] == "INFO"
 
 
@@ -360,7 +360,7 @@ def test_every_polled_route_is_a_route_the_app_has():
 
 def test_a_failing_request_is_logged_by_status_and_an_unhandled_error_is_logged_at_all(sink):
     client = _client()
-    client.get("/api/videos/missing/deeper")  # 404 from the router
+    assert client.get("/api/videos/missing/deeper").status_code == 404  # 404 from the router
     assert sink.objects()[-1]["level"] == "WARNING"
     client.get("/boom")
     payload = sink.objects()[-1]
diff --git a/backend/tests/test_logsink.py b/backend/tests/test_logsink.py
index 7b9eb7cf..f0965c9f 100644
--- a/backend/tests/test_logsink.py
+++ b/backend/tests/test_logsink.py
@@ -259,7 +259,7 @@ def test_the_writer_drains_what_was_queued_when_it_is_stopped(db):
     log.addHandler(sink)
     try:
         for i in range(logsink.BATCH_MAX + 5):
-            # noqa G004: the f-string is the POINT — a distinct rendered message per line is
+            # G004: the f-string is the POINT — a distinct rendered message per line is
             # what keeps the flood limiter (which groups by template) out of this case.
             log.warning(f"line {i}")  # noqa: G004
     finally:
diff --git a/backend/tests/test_mail_language.py b/backend/tests/test_mail_language.py
index ce1c38df..f5ef1b7d 100644
--- a/backend/tests/test_mail_language.py
+++ b/backend/tests/test_mail_language.py
@@ -154,8 +154,18 @@ def test_an_access_request_records_the_language_it_was_made_in(db, client):
 
 
 def test_asking_again_from_another_language_updates_the_row(db, client):
-    client.post("/auth/request-access", json={"email": "asking@example.com", "lang": "en"})
-    client.post("/auth/request-access", json={"email": "asking@example.com", "lang": "hu"})
+    assert (
+        client.post(
+            "/auth/request-access", json={"email": "asking@example.com", "lang": "en"}
+        ).status_code
+        == 200
+    )
+    assert (
+        client.post(
+            "/auth/request-access", json={"email": "asking@example.com", "lang": "hu"}
+        ).status_code
+        == 200
+    )
 
     db.expire_all()
     inv = db.execute(select(Invite).where(Invite.email == "asking@example.com")).scalar_one()
@@ -165,7 +175,12 @@ def test_asking_again_from_another_language_updates_the_row(db, client):
 
 
 def test_an_unsupported_language_is_ignored_rather_than_stored(db, client):
-    client.post("/auth/request-access", json={"email": "asking@example.com", "lang": "../../etc"})
+    assert (
+        client.post(
+            "/auth/request-access", json={"email": "asking@example.com", "lang": "../../etc"}
+        ).status_code
+        == 200
+    )
 
     inv = db.execute(select(Invite).where(Invite.email == "asking@example.com")).scalar_one()
     assert inv.lang is None
@@ -194,7 +209,12 @@ def test_the_confirmation_mail_is_written_in_the_accounts_language(db, client, m
     monkeypatch.setattr(email_mod, "email_enabled", lambda db=None: True)
     sent = _bodies(monkeypatch)
 
-    client.post("/auth/register", json={"email": "hu@example.com", "password": _PW, "lang": "hu"})
+    assert (
+        client.post(
+            "/auth/register", json={"email": "hu@example.com", "password": _PW, "lang": "hu"}
+        ).status_code
+        == 200
+    )
 
     (_, subject, body) = sent[0]
     assert subject == mailtext.MAIL_TEXT["verify_email.subject"]["hu"]
@@ -209,7 +229,12 @@ def test_the_approval_mail_answers_in_the_language_the_request_was_made_in(
     monkeypatch.setattr(email_mod, "email_enabled", lambda db=None: True)
     sent = _bodies(monkeypatch)
     admin = make_user(email="admin@example.com", role="admin")
-    client.post("/auth/request-access", json={"email": "asking@example.com", "lang": "hu"})
+    assert (
+        client.post(
+            "/auth/request-access", json={"email": "asking@example.com", "lang": "hu"}
+        ).status_code
+        == 200
+    )
     inv = db.execute(select(Invite).where(Invite.email == "asking@example.com")).scalar_one()
     sent.clear()  # drop the admin notification; this test is about the reply to the requester
 
@@ -227,11 +252,16 @@ def test_a_denial_answers_in_that_language_too(db, client, make_user, as_user, m
     monkeypatch.setattr(email_mod, "email_enabled", lambda db=None: True)
     sent = _bodies(monkeypatch)
     admin = make_user(email="admin@example.com", role="admin")
-    client.post("/auth/request-access", json={"email": "asking@example.com", "lang": "hu"})
+    assert (
+        client.post(
+            "/auth/request-access", json={"email": "asking@example.com", "lang": "hu"}
+        ).status_code
+        == 200
+    )
     inv = db.execute(select(Invite).where(Invite.email == "asking@example.com")).scalar_one()
     sent.clear()
 
-    as_user(admin).post(f"/api/admin/invites/{inv.id}/deny")
+    assert as_user(admin).post(f"/api/admin/invites/{inv.id}/deny").status_code == 200
 
     assert sent[0][1] == mailtext.MAIL_TEXT["access_denied.subject"]["hu"]
 
diff --git a/backend/tests/test_maintenance_lifecycle.py b/backend/tests/test_maintenance_lifecycle.py
new file mode 100644
index 00000000..5973065e
--- /dev/null
+++ b/backend/tests/test_maintenance_lifecycle.py
@@ -0,0 +1,182 @@
+"""sync/maintenance — the job that HARD-DELETES videos (E32 S2: 19% covered).
+
+Its lifecycle: a video missing from videos.list is flagged and hidden; after the grace period a
+still-missing one is deleted (cascading to every playlist that held it) and each affected user
+gets one notification; a video that answers again is unhidden. A live broadcast is never a delete
+trigger, and an upcoming premiere that never went live is. YouTube is a fake that answers
+videos.list from a dict.
+"""
+
+from datetime import timedelta
+
+import pytest
+from sqlalchemy import select
+
+from app.models import Channel, Notification, Playlist, PlaylistItem, Video
+from app.sync import maintenance
+from app.utils import now_utc
+
+
+class _YT:
+    def __init__(self, items: dict[str, dict]):
+        self.items = items
+        self.asked: list[list[str]] = []
+
+    def get_videos(self, ids):
+        self.asked.append(list(ids))
+        return [self.items[i] for i in ids if i in self.items]
+
+
+def _item(vid: str, **snippet) -> dict:
+    return {"id": vid, "snippet": {"title": vid, **snippet}}
+
+
+@pytest.fixture
+def channel(db):
+    ch = Channel(id="UC_maint", title="Maint")
+    db.add(ch)
+    db.flush()
+    return ch
+
+
+def test_a_flagged_video_that_answers_again_is_unhidden(db, channel):
+    v = Video(
+        id="v1", channel_id=channel.id, unavailable_since=now_utc(), unavailable_reason="removed"
+    )
+    db.add(v)
+    db.commit()
+    out = maintenance._recheck_flagged(db, _YT({"v1": _item("v1")}), now_utc())
+    db.refresh(v)
+    assert v.unavailable_since is None and v.unavailable_reason is None
+    assert out == {"checked": 1, "recovered": 1, "deleted": 0, "notified": 0}
+
+
+def test_a_video_still_missing_inside_its_grace_period_is_kept_hidden(db, channel):
+    v = Video(
+        id="v1",
+        channel_id=channel.id,
+        unavailable_since=now_utc() - timedelta(days=maintenance.DEFAULT_GRACE_DAYS - 1),
+        unavailable_reason="removed",
+    )
+    db.add(v)
+    db.commit()
+    out = maintenance._recheck_flagged(db, _YT({}), now_utc())
+    assert db.get(Video, "v1") is not None
+    assert out["deleted"] == 0
+
+
+def test_past_the_grace_period_it_is_deleted_and_each_user_who_kept_it_told_once(
+    db, channel, make_user
+):
+    a, b = make_user(), make_user()
+    gone_since = now_utc() - timedelta(days=maintenance.DEFAULT_GRACE_DAYS + 1)
+    for vid in ("v1", "v2"):
+        db.add(
+            Video(
+                id=vid,
+                channel_id=channel.id,
+                title=f"T {vid}",
+                unavailable_since=gone_since,
+                unavailable_reason="removed",
+            )
+        )
+    pa = Playlist(user_id=a.id, name="A")
+    pb = Playlist(user_id=b.id, name="B")
+    db.add_all([pa, pb])
+    db.flush()
+    db.add_all(
+        [
+            PlaylistItem(playlist_id=pa.id, video_id="v1", position=0),
+            PlaylistItem(playlist_id=pa.id, video_id="v2", position=1),
+            PlaylistItem(playlist_id=pb.id, video_id="v2", position=0),
+        ]
+    )
+    db.commit()
+    out = maintenance._recheck_flagged(db, _YT({}), now_utc())
+    db.expire_all()
+    assert db.get(Video, "v1") is None and db.get(Video, "v2") is None
+    assert db.execute(select(PlaylistItem)).scalars().all() == []  # the cascade
+    notes = {
+        n.user_id: n.data["count"]
+        for n in db.execute(select(Notification).where(Notification.type == "maintenance"))
+        .scalars()
+        .all()
+    }
+    assert notes == {a.id: 2, b.id: 1}  # one per user, not one per video
+    assert out == {"checked": 2, "recovered": 0, "deleted": 2, "notified": 2}
+
+
+def test_rolling_revalidation_flags_the_missing_and_keeps_a_live_stream(db, channel, monkeypatch):
+    monkeypatch.setattr(maintenance.sysconfig, "get_int", lambda db, key: 10)
+    monkeypatch.setattr(maintenance.quota, "backfill_reserve_reached", lambda: False)
+    db.add_all(
+        [
+            Video(id="ok", channel_id=channel.id),
+            Video(id="gone", channel_id=channel.id),
+            Video(id="live", channel_id=channel.id),
+        ]
+    )
+    db.commit()
+    yt = _YT({"ok": _item("ok"), "live": _item("live", liveBroadcastContent="live")})
+    out = maintenance._revalidate_rolling(db, yt, now_utc())
+    db.expire_all()
+    assert db.get(Video, "gone").unavailable_reason == "removed"
+    assert db.get(Video, "ok").unavailable_since is None
+    assert db.get(Video, "live").unavailable_since is None
+    assert out == {"checked": 3, "flagged": 1}
+    assert all(db.get(Video, v).last_checked_at is not None for v in ("ok", "gone", "live"))
+
+
+def test_a_run_asks_youtube_about_each_video_once(db, channel, monkeypatch, make_user):
+    # Phase 1 recovers v1; phase 2 must not take it as "not checked this run" and fetch it again.
+    monkeypatch.setattr(maintenance.sysconfig, "get_int", lambda db, key: 10)
+    monkeypatch.setattr(maintenance.quota, "backfill_reserve_reached", lambda: False)
+    yt = _YT({"v1": _item("v1"), "v2": _item("v2")})
+
+    class _Client:
+        def __init__(self, *_):
+            pass
+
+        def __enter__(self):
+            return yt
+
+        def __exit__(self, *_):
+            return False
+
+    monkeypatch.setattr(maintenance, "YouTubeClient", _Client)
+    monkeypatch.setattr(maintenance, "get_service_user", lambda db: make_user())
+    db.add_all(
+        [
+            Video(
+                id="v1",
+                channel_id=channel.id,
+                unavailable_since=now_utc(),
+                unavailable_reason="removed",
+            ),
+            Video(id="v2", channel_id=channel.id),
+        ]
+    )
+    db.commit()
+    maintenance.run_maintenance(db)
+    asked = [vid for batch in yt.asked for vid in batch]
+    assert sorted(asked) == ["v1", "v2"]
+
+
+def test_an_upcoming_premiere_counts_as_abandoned_only_when_it_never_went_live():
+    past = (now_utc() - timedelta(days=3)).isoformat()
+    soon = (now_utc() - timedelta(days=1)).isoformat()
+
+    def item(**live):
+        return {"snippet": {"liveBroadcastContent": "upcoming"}, "liveStreamingDetails": live}
+
+    assert maintenance._is_abandoned_upcoming(item(scheduledStartTime=past)) is True
+    assert maintenance._is_abandoned_upcoming(item(scheduledStartTime=soon)) is False
+    assert (
+        maintenance._is_abandoned_upcoming(item(scheduledStartTime=past, actualStartTime=past))
+        is False
+    )
+    assert (
+        maintenance._is_abandoned_upcoming({"snippet": {"liveBroadcastContent": "none"}}) is False
+    )
+    # …and an abandoned premiere has no grace period: the confirming sweep deletes it.
+    assert maintenance._grace_days("abandoned") == 0
diff --git a/backend/tests/test_playlist_add_position.py b/backend/tests/test_playlist_add_position.py
index 994774cb..d351b0f2 100644
--- a/backend/tests/test_playlist_add_position.py
+++ b/backend/tests/test_playlist_add_position.py
@@ -97,7 +97,7 @@ def test_putting_a_removed_video_back_leaves_a_linked_list_clean(db, make_user,
     pl.synced_fingerprint = current_fingerprint(db, pl)
     pl.dirty = False
     db.commit()
-    client.delete(f"/api/playlists/{pl.id}/items/b")
+    assert client.delete(f"/api/playlists/{pl.id}/items/b").status_code == 200
     db.expire_all()
     assert db.get(Playlist, pl.id).dirty is True
     _add(client, pl.id, {"video_id": "b", "position": 1})
diff --git a/backend/tests/test_playlist_merge.py b/backend/tests/test_playlist_merge.py
index f4061664..8059e320 100644
--- a/backend/tests/test_playlist_merge.py
+++ b/backend/tests/test_playlist_merge.py
@@ -12,8 +12,8 @@ import pytest
 
 from app.models import Channel, Playlist, PlaylistItem, Video
 from app.sync import playlists as pl_mod
+from app.sync.playlist_merge import merge_plan
 from app.sync.playlists import (
-    merge_plan,
     merge_playlist,
     parse_baseline,
     parse_unavailable,
diff --git a/backend/tests/test_plex_admin_routes.py b/backend/tests/test_plex_admin_routes.py
new file mode 100644
index 00000000..6de5f0aa
--- /dev/null
+++ b/backend/tests/test_plex_admin_routes.py
@@ -0,0 +1,154 @@
+"""routes/plex/admin — the connection test and the owner's watch-sync link (E32 S2: 37% covered).
+
+The connection test is the admin's one early warning that the media mount or path map is wrong, and
+it must not quote the server's URL back in a toast. The watch link runs the one-time "Plex is master"
+import exactly once. Plex itself is a stub.
+"""
+
+from sqlalchemy import select
+
+import app.routes.plex.admin as admin_routes
+from app import sysconfig
+from app.models import PlexLink
+from app.plex.client import PlexError, PlexNotConfigured
+
+
+class _Plex:
+    def __init__(self, *, sections=None, leaf=None, fail=None):
+        self._sections = sections or []
+        self._leaf = leaf
+        self._fail = fail
+        self.section_items_calls: list[str] = []
+
+    def __enter__(self):
+        if self._fail:
+            raise self._fail
+        return self
+
+    def __exit__(self, *exc):
+        return False
+
+    def server_info(self):
+        return {"friendlyName": "Basement", "version": "1.40"}
+
+    def sections(self):
+        return self._sections
+
+    def section_items(self, key, *_args):
+        self.section_items_calls.append(key)
+        return ([self._leaf] if self._leaf else []), 1
+
+
+SECTIONS = [
+    {"key": 1, "title": "Movies", "type": "movie", "count": 10},
+    {"key": 2, "title": "Shows", "type": "show", "count": 3},
+    {"key": 3, "title": "Music", "type": "artist", "count": 99},
+]
+LEAF = {"Media": [{"Part": [{"file": "/data/movies/a.mkv"}]}]}
+
+
+def _use(monkeypatch, plex):
+    monkeypatch.setattr(admin_routes, "PlexClient", lambda db: plex)
+
+
+def test_the_connection_test_lists_movie_and_show_sections_and_probes_one_file(
+    db, as_user, make_user, monkeypatch, tmp_path
+):
+    (tmp_path / "a.mkv").write_bytes(b"x")
+    sysconfig.set_value(db, "plex_path_map", f"/data/movies={tmp_path}")
+    sysconfig.set_value(db, "plex_libraries", "4")
+    db.commit()
+    # Only section 4 is enabled; the movie section listed first (1) must not be the one sampled.
+    other = {"key": 4, "title": "Kids", "type": "movie", "count": 2}
+    plex = _Plex(sections=[*SECTIONS, other], leaf=LEAF)
+    _use(monkeypatch, plex)
+    r = as_user(make_user(role="admin")).post("/api/plex/test")
+    assert r.status_code == 200, r.text
+    body = r.json()
+    assert body["server_name"] == "Basement"
+    assert [s["key"] for s in body["sections"]] == ["1", "2", "4"]  # music is not ours
+    assert body["media_check"] == {
+        "checked": True,
+        "ok": True,
+        "plex_path": "/data/movies/a.mkv",
+        "local_path": str(tmp_path / "a.mkv"),
+    }
+    assert plex.section_items_calls == ["4"]  # only an enabled movie section is sampled
+
+
+def test_a_wrong_mount_is_reported_and_an_empty_library_is_not_checked(
+    db, as_user, make_user, monkeypatch, tmp_path
+):
+    sysconfig.set_value(db, "plex_path_map", f"/data/movies={tmp_path}")
+    db.commit()
+    client = as_user(make_user(role="admin"))
+    _use(monkeypatch, _Plex(sections=SECTIONS, leaf=LEAF))  # the file is not on the mount
+    check = client.post("/api/plex/test").json()["media_check"]
+    assert check["checked"] is True and check["ok"] is False
+
+    _use(monkeypatch, _Plex(sections=SECTIONS))
+    assert client.post("/api/plex/test").json()["media_check"] == {"checked": False}
+
+
+def test_a_failed_connection_says_so_without_quoting_the_server(
+    db, as_user, make_user, monkeypatch
+):
+    client = as_user(make_user(role="admin"))
+    _use(monkeypatch, _Plex(fail=PlexNotConfigured()))
+    r = client.post("/api/plex/test")
+    assert r.status_code == 400
+    assert r.json()["detail"]["reason"] == "plex_not_configured"
+
+    _use(monkeypatch, _Plex(fail=PlexError("GET http://10.0.0.5:32400/secret refused")))
+    r = client.post("/api/plex/test")
+    assert r.status_code == 422
+    assert r.json()["detail"]["reason"] == "plex_unreachable"
+    assert "10.0.0.5" not in r.text
+
+
+def test_plex_admin_routes_refuse_a_regular_user(db, as_user, make_user, monkeypatch):
+    _use(monkeypatch, _Plex(sections=SECTIONS))
+    client = as_user(make_user())
+    for path in ("/api/plex/test", "/api/plex/sync", "/api/plex/watch/import"):
+        assert client.post(path).status_code == 403, path
+    assert client.post("/api/plex/watch/link", json={"enabled": True}).status_code == 403
+
+
+def test_the_watch_link_imports_once_and_needs_plex_on(db, as_user, make_user, monkeypatch):
+    imports: list[int] = []
+
+    def fake_import(db_, link):
+        imports.append(link.user_id)
+        link.initial_import_done = True
+        db_.commit()
+        return {"imported": 7}
+
+    monkeypatch.setattr(admin_routes.plex_watch, "import_owner_watch_state", fake_import)
+    owner = make_user(role="admin")
+    client = as_user(owner)
+
+    r = client.post("/api/plex/watch/link", json={"enabled": True})
+    assert r.status_code == 409 and r.json()["detail"]["reason"] == "plex_disabled"
+    assert client.post("/api/plex/watch/import").json()["detail"]["reason"] == "watch_sync_off"
+
+    sysconfig.set_value(db, "plex_enabled", True)
+    db.commit()
+    first = client.post("/api/plex/watch/link", json={"enabled": True})
+    assert first.status_code == 200
+    assert first.json()["import"] == {"imported": 7}
+    assert first.json()["linked"] and first.json()["sync_enabled"] and first.json()["uses_admin"]
+
+    assert client.post("/api/plex/watch/link", json={"enabled": False}).json()["import"] is None
+    again = client.post("/api/plex/watch/link", json={"enabled": True})
+    assert again.json()["import"] is None  # the one-time import does not run twice
+    assert imports == [owner.id]
+
+    status = client.get("/api/plex/watch/link")
+    assert status.status_code == 200
+    assert status.json()["initial_import_done"] is True
+    links = db.execute(select(PlexLink).where(PlexLink.user_id == owner.id)).scalars().all()
+    assert len(links) == 1  # toggling never creates a second link
+
+    rerun = client.post("/api/plex/watch/import")
+    assert rerun.status_code == 200 and rerun.json()["import"] == {"imported": 7}
+    assert imports == [owner.id, owner.id]
diff --git a/backend/tests/test_plex_client.py b/backend/tests/test_plex_client.py
new file mode 100644
index 00000000..a2be2326
--- /dev/null
+++ b/backend/tests/test_plex_client.py
@@ -0,0 +1,204 @@
+"""plex/client — the one door to the Plex server (E32 S2: 31% covered).
+
+What matters here is what the callers cannot see: a failure must surface as PlexError (never as an
+empty answer), the paged reads must stop where they should, and the write URIs must be well formed.
+The network is an httpx MockTransport; the configuration is stubbed.
+"""
+
+import httpx
+import pytest
+
+from app.plex import client as plex_client
+from app.plex.client import PlexClient, PlexError, PlexNotConfigured
+
+
+@pytest.fixture
+def plex(monkeypatch):
+    """A PlexClient on a stub server; set `routes[path] = handler-or-json` per test."""
+    routes: dict = {}
+    seen: list[httpx.Request] = []
+
+    def transport(request: httpx.Request) -> httpx.Response:
+        seen.append(request)
+        answer = routes.get(request.url.path)
+        if answer is None:
+            return httpx.Response(404)
+        if callable(answer):
+            return answer(request)
+        return httpx.Response(200, json={"MediaContainer": answer})
+
+    real = httpx.Client
+    monkeypatch.setattr(
+        plex_client.httpx,
+        "Client",
+        lambda **kw: real(transport=httpx.MockTransport(transport), **kw),
+    )
+    conf = {"plex_server_url": "http://plex.test:32400/", "plex_server_token": "tok"}
+    monkeypatch.setattr(plex_client.sysconfig, "get_str", lambda db, key: conf[key])
+    c = PlexClient(None)  # type: ignore[arg-type]  # the stubbed config never reads the session
+    c.routes, c.seen = routes, seen  # type: ignore[attr-defined]
+    yield c
+    c.close()
+
+
+def test_an_unconfigured_server_is_refused_up_front(monkeypatch):
+    monkeypatch.setattr(plex_client.sysconfig, "get_str", lambda db, key: "")
+    with pytest.raises(PlexNotConfigured):
+        PlexClient(None)  # type: ignore[arg-type]
+
+
+def test_reads_carry_the_token_and_unwrap_the_container(plex):
+    plex.routes["/library/sections"] = {"Directory": [{"key": "1", "type": "movie"}]}
+    assert plex.sections() == [{"key": "1", "type": "movie"}]
+    req = plex.seen[-1]
+    assert str(req.url) == "http://plex.test:32400/library/sections"
+    assert req.headers["x-plex-token"] == "tok"
+    assert req.headers["accept"] == "application/json"
+
+
+@pytest.mark.parametrize(
+    "answer",
+    [
+        lambda r: httpx.Response(500),
+        lambda r: httpx.Response(200, text="<html>login</html>"),
+        lambda r: (_ for _ in ()).throw(httpx.ConnectError("down", request=r)),
+    ],
+    ids=["http-500", "not-json", "unreachable"],
+)
+def test_a_failed_read_is_a_plex_error_never_an_empty_answer(plex, answer):
+    plex.routes["/library/sections"] = answer
+    with pytest.raises(PlexError):
+        plex.sections()
+
+
+def test_a_section_page_asks_for_guids_and_reports_the_server_total(plex):
+    plex.routes["/library/sections/7/all"] = {"Metadata": [{"ratingKey": "1"}], "totalSize": 250}
+    items, total = plex.section_items("7", 1, 200, 50)
+    assert items == [{"ratingKey": "1"}] and total == 250
+    params = plex.seen[-1].url.params
+    assert params["includeGuids"] == "1" and params["type"] == "1"
+    assert params["X-Plex-Container-Start"] == "200" and params["X-Plex-Container-Size"] == "50"
+
+    # Measured on the real server (E32 review): a paged request carries `totalSize` even when the
+    # page is empty, past the end, or the section holds nothing — `size: 0, totalSize: 0`.
+    plex.routes["/library/sections/7/all"] = {"Metadata": [], "size": 0, "totalSize": 0}
+    assert plex.section_items("7", 2) == ([], 0)
+    # No total at all is not "0": the caller must not read it as a complete, empty section.
+    plex.routes["/library/sections/7/all"] = {"Metadata": []}
+    assert plex.section_items("7", 2) == ([], None)
+    # …and `size` is THIS page's count, never the section's: one full page is not the whole section.
+    plex.routes["/library/sections/7/all"] = {"Metadata": [{"ratingKey": "1"}], "size": 1}
+    assert plex.section_items("7", 2) == ([{"ratingKey": "1"}], None)
+
+
+def test_related_flattens_the_hubs_and_degrades_to_empty(plex):
+    plex.routes["/library/metadata/5/related"] = {
+        "Hub": [{"Metadata": [{"ratingKey": "a"}]}, {"Metadata": [{"ratingKey": "b"}]}, {}]
+    }
+    assert [m["ratingKey"] for m in plex.related("5")] == ["a", "b"]
+    plex.routes["/library/metadata/5/related"] = lambda r: httpx.Response(500)
+    assert plex.related("5") == []
+
+
+def test_metadata_is_the_first_item_or_none(plex):
+    plex.routes["/library/metadata/9"] = {"Metadata": [{"ratingKey": "9", "title": "X"}]}
+    assert plex.metadata("9", markers=True) == {"ratingKey": "9", "title": "X"}
+    assert plex.seen[-1].url.params["includeMarkers"] == "1"
+    plex.routes["/library/metadata/9"] = {}
+    assert plex.metadata("9") is None
+
+
+def _history(rows_by_start: dict[int, list[dict]]):
+    def answer(request: httpx.Request) -> httpx.Response:
+        start = int(request.url.params["X-Plex-Container-Start"])
+        return httpx.Response(
+            200, json={"MediaContainer": {"Metadata": rows_by_start.get(start, [])}}
+        )
+
+    return answer
+
+
+def test_watch_history_pages_until_the_cutoff_and_keeps_only_the_owner(plex):
+    plex.routes["/status/sessions/history/all"] = _history(
+        {
+            0: [
+                {"ratingKey": "1", "viewedAt": 500, "accountID": 2},
+                {"ratingKey": "2", "viewedAt": 400, "accountID": 1},
+            ],
+            2: [
+                {"ratingKey": "3", "viewedAt": 300, "accountID": 1},
+                {"ratingKey": "4", "viewedAt": 100, "accountID": 1},
+            ],
+            4: [{"ratingKey": "never", "viewedAt": 50, "accountID": 1}],
+        }
+    )
+    rows = plex.watch_history(min_viewed_at=200, account_id=1, size=2)
+    assert [r["ratingKey"] for r in rows] == ["2", "3"]  # page 2 reached, the cutoff stops it
+    assert [int(r.url.params["X-Plex-Container-Start"]) for r in plex.seen] == [0, 2]
+
+
+def test_watch_history_stops_on_a_short_page_and_at_the_page_cap(plex):
+    plex.routes["/status/sessions/history/all"] = _history({0: [{"ratingKey": "1", "viewedAt": 9}]})
+    assert [r["ratingKey"] for r in plex.watch_history(size=2)] == ["1"]
+    assert len(plex.seen) == 1
+
+    full = [{"ratingKey": "r", "viewedAt": 9}, {"ratingKey": "r", "viewedAt": 9}]
+    plex.routes["/status/sessions/history/all"] = lambda r: httpx.Response(
+        200, json={"MediaContainer": {"Metadata": full}}
+    )
+    plex.seen.clear()
+    assert len(plex.watch_history(size=2, max_pages=3)) == 6
+    assert len(plex.seen) == 3
+
+
+def test_a_collection_is_created_with_a_well_formed_uri(plex):
+    plex.routes["/identity"] = {"machineIdentifier": "abc"}
+    plex.routes["/library/collections"] = {"Metadata": [{"ratingKey": "c1"}]}
+    assert plex.create_collection("3", "Best of: 90s", "42") == {"ratingKey": "c1"}
+    params = plex.seen[-1].url.params
+    assert plex.seen[-1].method == "POST"
+    assert params["title"] == "Best of: 90s" and params["sectionId"] == "3"
+    assert params["uri"] == "server://abc/com.plexapp.plugins.library/library/metadata/42"
+
+    plex.routes["/library/collections"] = {}
+    with pytest.raises(PlexError):
+        plex.create_collection("3", "Empty", "42")
+    assert [r.url.path for r in plex.seen].count("/identity") == 1  # cached
+
+
+def test_a_server_without_a_machine_id_refuses_the_write(plex):
+    """No machineIdentifier used to become `server:///…` in the write URI — a malformed request
+    Plex answers in its own way. It is refused here, named (E32 S2)."""
+    plex.routes["/identity"] = {}
+    plex.routes["/library/collections"] = {"Metadata": [{"ratingKey": "c1"}]}
+    with pytest.raises(PlexError, match="machine"):
+        plex.create_collection("3", "T", "42")
+    assert all(r.url.path == "/identity" for r in plex.seen)
+
+
+def test_watch_state_writes_target_the_library_item(plex):
+    for path in ("/:/scrobble", "/:/unscrobble", "/:/timeline"):
+        plex.routes[path] = lambda r: httpx.Response(200)  # Plex answers with an empty body
+    plex.scrobble("42")
+    assert plex.seen[-1].url.params["key"] == "42"
+    plex.unscrobble("42")
+    assert plex.seen[-1].url.path == "/:/unscrobble"
+    plex.set_timeline("42", 61_500.7, 120_000)  # type: ignore[arg-type]
+    p = plex.seen[-1].url.params
+    assert p["key"] == "/library/metadata/42" and p["time"] == "61500" and p["state"] == "stopped"
+    plex.routes["/:/scrobble"] = lambda r: httpx.Response(401)
+    with pytest.raises(PlexError):
+        plex.scrobble("42")
+
+
+def test_an_image_is_resized_by_plex_when_a_box_is_given(plex):
+    plex.routes["/photo/:/transcode"] = lambda r: httpx.Response(
+        200, content=b"small", headers={"Content-Type": "image/webp"}
+    )
+    plex.routes["/library/metadata/1/thumb/2"] = lambda r: httpx.Response(200, content=b"full")
+    assert plex.image_bytes("/library/metadata/1/thumb/2", 300, 450) == (b"small", "image/webp")
+    assert plex.seen[-1].url.params["url"] == "/library/metadata/1/thumb/2"
+    body, ctype = plex.image_bytes("/library/metadata/1/thumb/2")
+    assert body == b"full" and ctype == "image/jpeg"
+    with pytest.raises(PlexError):
+        plex.raw_get("/library/streams/404")
diff --git a/backend/tests/test_plex_image_sizes.py b/backend/tests/test_plex_image_sizes.py
index 6e3cdaad..3c250296 100644
--- a/backend/tests/test_plex_image_sizes.py
+++ b/backend/tests/test_plex_image_sizes.py
@@ -67,7 +67,7 @@ def test_each_variant_is_cut_at_its_own_size(db, make_user, monkeypatch, tmp_pat
     ]
     # Each cut is cached under its own name: asking again reaches Plex no more.
     for variant in ("thumb", "thumb_sm", "art", "art_sm"):
-        client.get(f"/api/plex/image/pm1?variant={variant}")
+        assert client.get(f"/api/plex/image/pm1?variant={variant}").status_code == 200
     assert len(_FakePlex.calls) == 4
 
 
diff --git a/backend/tests/test_plex_overlay.py b/backend/tests/test_plex_overlay.py
index bf70ca34..3497da53 100644
--- a/backend/tests/test_plex_overlay.py
+++ b/backend/tests/test_plex_overlay.py
@@ -16,18 +16,21 @@ from app import sysconfig
 from app.db import engine
 from app.models import PlexItem, PlexLibrary, PlexShow
 from app.plex.genres import hu_genre, hu_genres
-from app.plex.sync import _apply_item, _canonical_guid, _sync_overlay
+from app.plex.overlay import sync_overlay
+from app.plex.sync import _apply_item, _canonical_guid
 from app.plex.query import content_libs
 
 
 class _StubPlex:
-    """Minimal PlexClient stand-in: _sync_overlay only calls section_items via _paginate."""
+    """Minimal PlexClient stand-in: sync_overlay only calls section_items via _paginate. `total`
+    over the item count is a listing cut short (the server said more than it handed over)."""
 
-    def __init__(self, items: list[dict]):
+    def __init__(self, items: list[dict], total: int | None = None):
         self._items = items
+        self._total = len(items) if total is None else total
 
     def section_items(self, key, item_type, start, size):
-        return self._items[start : start + size], len(self._items)
+        return self._items[start : start + size], self._total
 
 
 def _hu_movie(rk: str, title: str, summary: str, genres: list[str], guid: str | None) -> dict:
@@ -71,7 +74,7 @@ def test_sync_overlay_writes_hu_onto_matched_en_rows(db):
         ]
     )
     stats = {"overlaid": 0}
-    _sync_overlay(db, stub, hu_lib, en_lib.id, stats)
+    sync_overlay(db, stub, hu_lib, en_lib.id, stats)
     db.commit()
 
     db.refresh(matched)
@@ -185,13 +188,51 @@ def test_overlay_reconcile_clears_stale_hu_when_twin_vanishes(db):
     )
     db.add(row)
     db.commit()
-    # The HU section no longer lists this film (empty overlay).
-    _sync_overlay(db, _StubPlex([]), hu_lib, en_lib.id, {"overlaid": 0})
+    # The HU section, read in full, no longer lists this film (only another one).
+    other = _hu_movie("h9", "Más", "más", [], "tmdb://99")
+    sync_overlay(db, _StubPlex([other]), hu_lib, en_lib.id, {"overlaid": 0})
     db.commit()
     db.refresh(row)
     assert row.title_hu is None and row.summary_hu is None and row.genres_hu is None
 
 
+def test_a_listing_cut_short_keeps_the_hungarian_text_it_did_not_reach(db):
+    """E32 S2: the reconcile clears HU text only after a COMPLETE listing. A walk a Plex hiccup cut
+    short (an empty page before the server's total), or an empty section, says nothing about the
+    titles it did not reach — clearing them dropped their Hungarian text until the next full sync."""
+    en_lib = PlexLibrary(plex_key="4", title="Movies", kind="movie")
+    hu_lib = PlexLibrary(plex_key="9", title="Filmek", kind="movie", metadata_lang="hu")
+    db.add_all([en_lib, hu_lib])
+    db.flush()
+    hu_lib.overlay_of = en_lib.id
+    kept = PlexItem(
+        rating_key="m1",
+        library_id=en_lib.id,
+        kind="movie",
+        title="Heat",
+        guid="tmdb:1",
+        title_hu="Szemtől szemben",
+        summary_hu="régi",
+        genres_hu=["Akció"],
+    )
+    fresh = PlexItem(rating_key="m2", library_id=en_lib.id, kind="movie", title="Up", guid="tmdb:2")
+    db.add_all([kept, fresh])
+    db.commit()
+    stats: dict = {}
+    reached = _hu_movie("h2", "Fel", "fel", [], "tmdb://2")
+    sync_overlay(db, _StubPlex([reached], total=2), hu_lib, en_lib.id, stats)
+    db.commit()
+    db.refresh(kept)
+    db.refresh(fresh)
+    assert kept.title_hu == "Szemtől szemben" and kept.summary_hu == "régi"
+    assert fresh.title_hu == "Fel"  # what the listing did reach is still applied
+    assert stats["overlay_incomplete"] == 1
+    sync_overlay(db, _StubPlex([]), hu_lib, en_lib.id, {})  # an empty section: the same answer
+    db.commit()
+    db.refresh(kept)
+    assert kept.title_hu == "Szemtől szemben"
+
+
 def test_apply_item_keeps_prior_guid_when_listing_lacks_guid():
     row = PlexItem(rating_key="m1", kind="movie", guid="tmdb:1")
     _apply_item(row, lib_id=7, kind="movie", meta={"title": "Heat"})  # no Guid array
@@ -225,7 +266,7 @@ def test_overlay_applies_to_all_editions_sharing_a_guid(db):
         ]
     )
     stats = {"overlaid": 0}
-    _sync_overlay(db, stub, hu_lib, en_lib.id, stats)
+    sync_overlay(db, stub, hu_lib, en_lib.id, stats)
     db.commit()
     db.refresh(ed1)
     db.refresh(ed2)
@@ -291,7 +332,7 @@ def test_a_show_overlay_writes_hungarian_episode_titles_and_summaries(db):
             ],
         }
     )
-    _sync_overlay(db, stub, hu_lib, en_lib.id, {})
+    sync_overlay(db, stub, hu_lib, en_lib.id, {})
     db.commit()
     db.refresh(ep)
     db.refresh(show)
@@ -328,7 +369,7 @@ def test_the_overlay_gives_every_row_one_hungarian_word_per_genre(db):
         "h1", "Szemtől szemben", "HU.", ["Action", "Bűnügyi", "Drama", "Dráma"], "tmdb://1"
     )
     meta["tagline"] = "Magyar mottó."
-    _sync_overlay(db, _StubPlex([meta]), hu_lib, en_lib.id, {})
+    sync_overlay(db, _StubPlex([meta]), hu_lib, en_lib.id, {})
     db.commit()
     db.refresh(twin)
     db.refresh(lone)
@@ -353,7 +394,7 @@ def test_a_twin_without_genres_keeps_the_rows_own_hungarian_list(db):
     )
     db.add(row)
     db.commit()
-    _sync_overlay(
+    sync_overlay(
         db,
         _StubPlex([_hu_movie("h1", "Szemtől szemben", "HU.", [], "tmdb://1")]),
         hu_lib,
diff --git a/backend/tests/test_plex_paths.py b/backend/tests/test_plex_paths.py
new file mode 100644
index 00000000..446e8bd7
--- /dev/null
+++ b/backend/tests/test_plex_paths.py
@@ -0,0 +1,82 @@
+"""plex/paths — the Plex-side path → local mount translation (E32 S2: 23% covered, and a wrong answer
+here reads as "media file not found" for a whole library at once, with nothing else failing).
+
+Pure logic: the admin map is read through sysconfig, stubbed per test.
+"""
+
+from pathlib import Path
+
+import pytest
+
+from app.plex import paths
+
+
+@pytest.fixture
+def path_map(monkeypatch):
+    def use(raw: str) -> None:
+        monkeypatch.setattr(paths.sysconfig, "get_str", lambda db, key: raw)
+
+    return use
+
+
+def test_the_map_parses_both_separators_drops_junk_and_puts_the_longest_prefix_first():
+    raw = " /data=/mnt/a ,\n/data/movies = /mnt/m\nnot-a-pair,=/x,/y=, /data/tv=/mnt/tv "
+    assert paths.parse_map(raw) == [
+        ("/data/movies", "/mnt/m"),
+        ("/data/tv", "/mnt/tv"),
+        ("/data", "/mnt/a"),
+    ]
+    assert paths.parse_map("") == []
+
+
+def test_the_longest_matching_prefix_wins(path_map):
+    path_map("/data=/mnt/a,/data/movies=/mnt/m")
+    assert paths.map_path(None, "/data/movies/Foo.mkv") == str(Path("/mnt/m") / "Foo.mkv")
+    assert paths.map_path(None, "/data/tv/Bar.mkv") == str(Path("/mnt/a") / "tv/Bar.mkv")
+
+
+def test_a_prefix_matches_only_at_a_path_boundary(path_map):
+    # "/data/movies2" shares the characters of "/data/movies" but is another folder.
+    path_map("/data/movies=/mnt/m")
+    assert paths.map_path(None, "/data/movies2/Foo.mkv") == "/data/movies2/Foo.mkv"
+
+
+def test_the_prefix_itself_and_a_trailing_slash_in_the_map(path_map):
+    path_map("/data/movies/=/mnt/m")
+    assert paths.map_path(None, "/data/movies/Foo.mkv") == str(Path("/mnt/m") / "Foo.mkv")
+    path_map("/data/movies=/mnt/m")
+    assert paths.map_path(None, "/data/movies") == "/mnt/m"
+
+
+def test_no_map_leaves_the_path_as_plex_sees_it(path_map):
+    path_map("")
+    assert paths.map_path(None, "/data/movies/Foo.mkv") == "/data/movies/Foo.mkv"
+
+
+def test_the_local_file_must_exist(path_map, tmp_path):
+    (tmp_path / "movies").mkdir()
+    (tmp_path / "movies" / "Foo.mkv").write_bytes(b"x")
+    path_map(f"/data={tmp_path}")
+    assert (
+        paths.local_media_path(None, "/data/movies/Foo.mkv")
+        == (tmp_path / "movies" / "Foo.mkv").resolve()
+    )
+    assert paths.local_media_path(None, "/data/movies/Missing.mkv") is None
+    assert paths.local_media_path(None, "/data/movies") is None  # a folder is not a file
+    assert paths.local_media_path(None, None) is None
+    assert paths.local_media_path(None, "") is None
+
+
+def test_a_path_that_cannot_be_resolved_is_logged_and_answered_none(path_map, monkeypatch, caplog):
+    path_map("")
+
+    def broken(self, strict=False):
+        raise OSError("dead mount")
+
+    monkeypatch.setattr(paths.Path, "resolve", broken)
+    assert paths.local_media_path(None, "/data/movies/Foo.mkv") is None
+    rec = next(
+        r for r in caplog.records if getattr(r, "event", None) == "plex.paths.resolve_failed"
+    )
+    # The title stays out of the log line: the path carries it.
+    assert "Foo" not in rec.getMessage() and rec.attrs == {"reason": "OSError"}
diff --git a/backend/tests/test_plex_playlist_add_positions.py b/backend/tests/test_plex_playlist_add_positions.py
index 4da18967..3d8f970a 100644
--- a/backend/tests/test_plex_playlist_add_positions.py
+++ b/backend/tests/test_plex_playlist_add_positions.py
@@ -105,8 +105,11 @@ def test_remove_then_put_back_is_no_change(db, make_user, as_user):
     user = make_user()
     pl = _seed(db, user, ["a", "b", "c", "d"], extra=())
     client = as_user(user)
-    client.post(
-        f"/api/plex/playlists/{pl.id}/items/remove-bulk", json={"item_rating_keys": ["b", "d"]}
+    assert (
+        client.post(
+            f"/api/plex/playlists/{pl.id}/items/remove-bulk", json={"item_rating_keys": ["b", "d"]}
+        ).status_code
+        == 200
     )
     assert _order(db, pl.id)[0] == ["a", "c"]
     _add(client, pl.id, ["b", "d"], [1, 3])
diff --git a/backend/tests/test_plex_stream.py b/backend/tests/test_plex_stream.py
index 143f3eb5..22859570 100644
--- a/backend/tests/test_plex_stream.py
+++ b/backend/tests/test_plex_stream.py
@@ -8,6 +8,7 @@ Since the sweep stopped being awaited at startup it also runs CONCURRENTLY with
 second half of this file pins what keeps it off a LIVE session's segments."""
 
 import os
+import sys
 from pathlib import Path
 
 import pytest
@@ -830,6 +831,46 @@ class TestProbeVideoKind:
         assert stream._probe_video_kind(Path("/x")) == stream._VK_HWSAFE
 
 
+class TestProbeExitStatus:
+    """A probe whose ffprobe EXITS NON-ZERO is a failed probe, not an answer (E32). Each probe used to
+    read stdout without looking at the exit status, so a refusing ffprobe silently picked the fallback
+    — HW-safe, single audio, the requested offset — and skipped the warning its except branch promises.
+    Drives the REAL subprocess.run with the probe's own kwargs against a stand-in command that prints a
+    plausible answer and then fails, so the test fails whenever the exit status is ignored."""
+
+    @staticmethod
+    def _failing_ffprobe(monkeypatch, stdout: str):
+        real_run = stream.subprocess.run
+        script = f"import sys; sys.stdout.write({stdout!r}); sys.exit(1)"
+        monkeypatch.setattr(
+            stream.subprocess,
+            "run",
+            lambda _cmd, **kw: real_run([sys.executable, "-c", script], **kw),
+        )
+
+    @staticmethod
+    def _events(caplog) -> list[str]:
+        return [getattr(r, "event", "") for r in caplog.records]
+
+    def test_video_kind(self, monkeypatch, caplog):
+        self._failing_ffprobe(monkeypatch, "pix_fmt=yuv420p10le\ncolor_transfer=smpte2084\n")
+        with caplog.at_level("INFO"):
+            assert stream._probe_video_kind(Path("/x")) == stream._VK_HWSAFE
+        assert "plex.stream.probe_kind_failed" in self._events(caplog)
+
+    def test_audio_langs(self, monkeypatch, caplog):
+        self._failing_ffprobe(monkeypatch, "hun\neng\n")
+        with caplog.at_level("INFO"):
+            assert stream._probe_audio_langs(Path("/x")) == []
+        assert "plex.stream.probe_audio_failed" in self._events(caplog)
+
+    def test_first_pts(self, monkeypatch, caplog):
+        self._failing_ffprobe(monkeypatch, "12.5\n")
+        with caplog.at_level("INFO"):
+            assert stream._probe_first_pts(Path("/x")) is None
+        assert "plex.stream.first_pts_probe_failed" in self._events(caplog)
+
+
 class TestOpenclPresent:
     """The OpenCL-runtime probe (_opencl_present) — the precondition for the HW HDR tonemap graph. Drives
     the REAL glob against a temp ICD dir instead of monkeypatching the function, so a regression to the
diff --git a/backend/tests/test_plex_subtitle_prepare.py b/backend/tests/test_plex_subtitle_prepare.py
index f0a7c50a..87677ab8 100644
--- a/backend/tests/test_plex_subtitle_prepare.py
+++ b/backend/tests/test_plex_subtitle_prepare.py
@@ -208,7 +208,7 @@ def test_an_unshowable_track_says_why_and_maps_to_a_status(client, monkeypatch):
         raise subtitles.SubtitleUnavailable("bitmap")
 
     monkeypatch.setattr(subtitles, "_extract_and_publish", _bitmap)
-    client.get("/api/plex/subtitle/98614/0/status")
+    assert client.get("/api/plex/subtitle/98614/0/status").status_code == 200
     pool.run_all()
     st = client.get("/api/plex/subtitle/98614/0/status").json()
     assert st["state"] == "failed" and st["code"] == "bitmap"
diff --git a/backend/tests/test_plex_watch_reconcile.py b/backend/tests/test_plex_watch_reconcile.py
new file mode 100644
index 00000000..ce50368c
--- /dev/null
+++ b/backend/tests/test_plex_watch_reconcile.py
@@ -0,0 +1,277 @@
+"""The daily full watch reconcile (`run_plex_watch_reconcile`) — the one pass that DELETES watch state:
+a mirrored row Plex no longer has a record for is read as "Plex un-watched it" and cleared. E32 S2
+found it trusting a scan a Plex hiccup had cut short; these hold what it may and may not clear.
+"""
+
+import pytest
+from sqlalchemy import select
+
+from app import sysconfig
+from app.models import PlexItem, PlexLibrary, PlexLink, PlexState, User
+from app.plex import watch_sync
+
+
+class _FakePlex:
+    """A PlexClient stand-in: one movie section whose listing reports `total` (more than it hands
+    over = a walk cut short), plus any `more` sections as `(type, leaves, total)` — listed AFTER
+    the movies — and a record of every write the reconcile sends back to Plex."""
+
+    def __init__(self, leaves: list[dict], total: int | None = None, more=()):
+        self.listings = {"1": ("movie", leaves, len(leaves) if total is None else total)}
+        for i, (stype, extra, extra_total) in enumerate(more, start=2):
+            self.listings[str(i)] = (stype, extra, extra_total)
+        self.calls: list[tuple] = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        return False
+
+    def sections(self):
+        return [{"type": stype, "key": key} for key, (stype, _l, _t) in self.listings.items()]
+
+    def section_items(self, key, item_type, start, size):
+        _stype, leaves, total = self.listings[key]
+        return leaves[start : start + size], total
+
+    def scrobble(self, rk):
+        self.calls.append(("scrobble", rk))
+
+    def unscrobble(self, rk):
+        self.calls.append(("unscrobble", rk))
+
+    def set_timeline(self, rk, time_ms, duration_ms):
+        self.calls.append(("timeline", rk, time_ms))
+
+
+@pytest.fixture
+def world(db):
+    """Five mirrored movies and the owner's link; each test sets the local states it needs."""
+    sysconfig.set_value(db, "plex_enabled", True)
+    lib = PlexLibrary(plex_key="1", title="Movies", kind="movie", enabled=True)
+    user = User(email="reconcile@example.com")
+    db.add_all([lib, user])
+    db.flush()
+    items = {}
+    for rk in ("m1", "m2", "m3", "m4", "m5"):
+        items[rk] = PlexItem(
+            rating_key=rk, library_id=lib.id, kind="movie", title=rk, duration_s=6000
+        )
+        db.add(items[rk])
+    db.add(
+        PlexLink(
+            user_id=user.id,
+            uses_admin=True,
+            sync_enabled=True,
+            initial_import_done=True,
+            plex_account_id=1,
+        )
+    )
+    db.flush()
+
+    def state(rk, **kw):
+        db.add(PlexState(user_id=user.id, item_id=items[rk].id, **kw))
+
+    def rows():
+        db.expire_all()
+        by_id = {i.id: rk for rk, i in items.items()}
+        return {
+            by_id[s.item_id]: (s.status, s.position_seconds, s.synced_to_plex)
+            for s in db.execute(select(PlexState).where(PlexState.user_id == user.id)).scalars()
+            if s.item_id in by_id  # the five movies; a test's own extra items it reads itself
+        }
+
+    return state, rows
+
+
+def _run(db, monkeypatch, plex):
+    monkeypatch.setattr(watch_sync, "PlexClient", lambda _db: plex)
+    return watch_sync.run_plex_watch_reconcile(db)
+
+
+def _local_states(state):
+    state("m1", status="watched", synced_to_plex=True)  # mirrored; Plex has no record now
+    state("m2", status="watched", synced_to_plex=False)  # local change that never reached Plex
+    state("m3", status="hidden", synced_to_plex=True)  # Siftlode-only, never cleared
+    state("m5", status="new", position_seconds=300, synced_to_plex=True)  # Plex says otherwise
+
+
+def test_a_complete_scan_clears_what_plex_unwatched_and_keeps_the_rest(db, monkeypatch, world):
+    state, rows = world
+    _local_states(state)
+    db.commit()
+    plex = _FakePlex(
+        [
+            {"ratingKey": "m3"},  # listed, no watch signal
+            {"ratingKey": "m4", "viewCount": 1, "lastViewedAt": 1_700_000_000},
+            {"ratingKey": "m5", "viewOffset": 120_000, "lastViewedAt": 1_700_000_000},
+        ]
+    )
+    out = _run(db, monkeypatch, plex)
+    assert rows() == {
+        "m2": ("watched", 0, True),  # re-pushed, then settled
+        "m3": ("hidden", 0, True),
+        "m4": ("watched", 0, True),  # pulled in
+        "m5": ("new", 120, True),  # Plex's position wins
+    }
+    assert ("scrobble", "m2") in plex.calls
+    assert out["cleared"] == 1 and out["repushed"] == 1 and "incomplete" not in out
+
+
+def test_a_scan_cut_short_clears_nothing(db, monkeypatch, world):
+    state, rows = world
+    _local_states(state)
+    db.commit()
+    # The server said 5, the walk got 3: m1 may simply not have been reached.
+    plex = _FakePlex(
+        [
+            {"ratingKey": "m3"},
+            {"ratingKey": "m4", "viewCount": 1, "lastViewedAt": 1_700_000_000},
+            {"ratingKey": "m5", "viewOffset": 120_000, "lastViewedAt": 1_700_000_000},
+        ],
+        total=5,
+    )
+    out = _run(db, monkeypatch, plex)
+    after = rows()
+    assert after["m1"] == ("watched", 0, True)  # NOT un-watched on a partial picture
+    assert after["m4"] == ("watched", 0, True) and after["m5"] == ("new", 120, True)  # pulls stand
+    assert after["m2"] == ("watched", 0, True)  # the dirty row is still pushed up
+    assert out["cleared"] == 0 and out["incomplete"] == 1
+
+
+_LISTED = [
+    {"ratingKey": "m3"},
+    {"ratingKey": "m4", "viewCount": 1, "lastViewedAt": 1_700_000_000},
+    {"ratingKey": "m5", "viewOffset": 120_000, "lastViewedAt": 1_700_000_000},
+]
+
+
+def test_a_genuinely_empty_second_section_still_lets_the_reconcile_clear(db, monkeypatch, world):
+    # The server SAYS the shows section holds 0: that is a complete listing, not a hiccup — before
+    # the E32 review it read as "incomplete" forever and un-watches never synced again.
+    state, rows = world
+    _local_states(state)
+    db.commit()
+    out = _run(db, monkeypatch, _FakePlex(_LISTED, more=[("show", [], 0)]))
+    assert "m1" not in rows()
+    assert out["cleared"] == 1 and "incomplete" not in out
+
+
+def _watched_episode_in_a_shows_section(db) -> int:
+    """A second mirrored section (key "2") holding one episode the owner has watched, synced."""
+    shows = PlexLibrary(plex_key="2", title="Shows", kind="show", enabled=True)
+    db.add(shows)
+    db.flush()
+    ep = PlexItem(rating_key="e1", library_id=shows.id, kind="episode", title="e1")
+    db.add(ep)
+    db.flush()
+    user_id = db.execute(select(PlexLink.user_id)).scalar_one()
+    db.add(PlexState(user_id=user_id, item_id=ep.id, status="watched", synced_to_plex=True))
+    return ep.id
+
+
+def _state_of(db, item_id: int) -> str | None:
+    db.expire_all()
+    st = db.execute(select(PlexState).where(PlexState.item_id == item_id)).scalar_one_or_none()
+    return st.status if st else None
+
+
+def test_a_section_we_mirror_that_says_0_keeps_its_rows_and_does_not_hold_up_the_rest(
+    db, monkeypatch, world
+):
+    # A total of 0 from a section our items come from is a Plex that lost the library for a moment,
+    # not one that un-watched all of it (E32 review round 2): its rows stay. And it is decided per
+    # section: before round 3 one such section (a library emptied on Plex, its mirrored items kept)
+    # made EVERY run incomplete, and un-watches in every other section never synced again.
+    state, rows = world
+    _local_states(state)
+    ep_id = _watched_episode_in_a_shows_section(db)
+    db.commit()
+    out = _run(db, monkeypatch, _FakePlex(_LISTED, more=[("show", [], 0)]))
+    assert _state_of(db, ep_id) == "watched"
+    assert "m1" not in rows()  # the movies section was walked whole: Plex un-watched m1
+    assert out["cleared"] == 1 and out["incomplete"] == 1
+
+
+def test_a_library_the_allowlist_leaves_out_keeps_its_watch_states(db, monkeypatch, world):
+    # Its items are absent from every scan because the scan never walks it — not because Plex
+    # un-watched them. It cleared them on every run (E32 review round 2).
+    state, _rows = world
+    other = PlexLibrary(plex_key="2", title="Shows", kind="show", enabled=True)
+    db.add(other)
+    db.flush()
+    ep = PlexItem(rating_key="e1", library_id=other.id, kind="episode", title="e1")
+    db.add(ep)
+    db.flush()
+    user_id = db.execute(select(PlexLink.user_id)).scalar_one()
+    db.add(PlexState(user_id=user_id, item_id=ep.id, status="watched", synced_to_plex=True))
+    _local_states(state)
+    sysconfig.set_value(db, "plex_libraries", "1")
+    db.commit()
+    out = _run(db, monkeypatch, _FakePlex(_LISTED, more=[("show", [], 0)]))
+    db.expire_all()
+    left = {
+        rk
+        for rk in db.execute(
+            select(PlexItem.rating_key).join(PlexState, PlexState.item_id == PlexItem.id)
+        ).scalars()
+    }
+    assert "m1" not in left  # the walked section still clears
+    kept = db.execute(select(PlexState).where(PlexState.item_id == ep.id)).scalar_one_or_none()
+    assert kept is not None and kept.status == "watched"
+    assert out["cleared"] == 1
+
+
+def test_a_cut_short_section_is_not_rescued_by_a_complete_one_after_it(db, monkeypatch, world):
+    # Each section settles on its own walk: movies cut short (5 said, 3 handed), then a complete
+    # shows listing — m1 may simply not have been reached.
+    state, rows = world
+    _local_states(state)
+    db.commit()
+    shows = [{"ratingKey": "s1"}]
+    out = _run(db, monkeypatch, _FakePlex(_LISTED, total=5, more=[("show", shows, 1)]))
+    assert rows()["m1"] == ("watched", 0, True)
+    assert out["cleared"] == 0 and out["incomplete"] == 1
+
+
+def test_a_listing_without_a_total_is_never_complete(db, monkeypatch, world):
+    state, rows = world
+    _local_states(state)
+    ep_id = _watched_episode_in_a_shows_section(db)
+    db.commit()
+    out = _run(db, monkeypatch, _FakePlex(_LISTED, more=[("show", [], None)]))
+    assert _state_of(db, ep_id) == "watched"  # its section never said how much it holds
+    assert "m1" not in rows()
+    assert out["cleared"] == 1 and out["incomplete"] == 1
+
+
+def test_an_empty_listing_is_not_a_library_of_unwatched_titles(db, monkeypatch, world):
+    state, rows = world
+    state("m1", status="watched", synced_to_plex=True)
+    db.commit()
+    out = _run(db, monkeypatch, _FakePlex([]))
+    assert rows() == {"m1": ("watched", 0, True)}
+    assert out["cleared"] == 0
+
+
+def test_a_dirty_resume_is_re_pushed_as_a_timeline_and_a_dirty_reset_as_an_unscrobble(
+    db, monkeypatch, world
+):
+    state, rows = world
+    state("m1", status="new", position_seconds=300, synced_to_plex=False)
+    state("m2", status="new", position_seconds=2, synced_to_plex=False)  # under the 5 s floor
+    db.commit()
+    plex = _FakePlex([{"ratingKey": rk} for rk in ("m1", "m2", "m3", "m4", "m5")])
+    _run(db, monkeypatch, plex)
+    assert ("timeline", "m1", 300_000) in plex.calls
+    assert ("unscrobble", "m2") in plex.calls
+    assert {rk: synced for rk, (_s, _p, synced) in rows().items()} == {"m1": True, "m2": True}
+
+
+def test_watch_fields_map_to_a_state_only_when_plex_holds_a_signal():
+    to = watch_sync._plex_watch_to_state
+    assert to(None, None, None) is None
+    assert to(0, 4_000, None) is None  # a stray few seconds is not "in progress"
+    assert to(0, 90_000, 1_700_000_000)[:2] == ("new", 90)
+    assert to("2", 90_000, 1_700_000_000)[:2] == ("watched", 0)  # watched wins over an offset
diff --git a/backend/tests/test_reset_link_states.py b/backend/tests/test_reset_link_states.py
index a11c03d4..30f0e7c7 100644
--- a/backend/tests/test_reset_link_states.py
+++ b/backend/tests/test_reset_link_states.py
@@ -51,7 +51,12 @@ def test_a_link_whose_account_was_deleted_is_reported_dead(client, db, make_user
 
 def test_a_spent_link_is_reported_dead(client, db, make_user):
     raw = _issue(db, make_user(email="spent@example.com", password=_PW))
-    client.post("/auth/password-reset/confirm", json={"token": raw, "password": _NEW})
+    assert (
+        client.post(
+            "/auth/password-reset/confirm", json={"token": raw, "password": _NEW}
+        ).status_code
+        == 200
+    )
 
     assert client.post("/auth/password-reset/check", json={"token": raw}).json() == {"ok": False}
 
diff --git a/backend/tests/test_response_checked.py b/backend/tests/test_response_checked.py
new file mode 100644
index 00000000..655c8a23
--- /dev/null
+++ b/backend/tests/test_response_checked.py
@@ -0,0 +1,58 @@
+"""No test sends a request and throws the response away (E32 S2).
+
+A discarded `client.post(...)` passes whatever it got back. As a SETUP step, a failure leaves the
+test asserting on a state it never reached; as the step UNDER test, the test proves nothing. E32
+found `test_youtube_sources_never_consult_the_guard` passing on a 400 that stopped the request
+before the code it meant to exercise, and 53 more discarded responses across the suite. Each one
+now states the status it expects; this keeps it that way.
+"""
+
+import ast
+from pathlib import Path
+
+TESTS = Path(__file__).resolve().parent
+VERBS = {"get", "post", "put", "patch", "delete", "head", "options", "request"}
+
+
+def discarded_requests(source: str) -> list[int]:
+    """Line numbers of the statements that are a bare request call on an app path."""
+    hits = []
+    for node in ast.walk(ast.parse(source)):
+        if not (isinstance(node, ast.Expr) and isinstance(node.value, ast.Call)):
+            continue
+        func = node.value.func
+        if not (isinstance(func, ast.Attribute) and func.attr in VERBS):
+            continue
+        path = node.value.args[0] if node.value.args else None
+        literal = path.value if isinstance(path, ast.Constant) else None
+        if isinstance(path, ast.JoinedStr):
+            first = path.values[0] if path.values else None
+            literal = first.value if isinstance(first, ast.Constant) else None
+        if isinstance(literal, str) and literal.startswith(("/api", "/auth")):
+            hits.append(node.lineno)
+    return hits
+
+
+def test_the_detector_sees_a_discarded_request_and_passes_a_checked_one():
+    src = (
+        "client.post('/api/x')\n"
+        "client.get(f'/auth/{u}')\n"
+        "assert client.post('/api/x').status_code == 200\n"
+        "r = client.get('/api/y')\n"
+        "items.get('/api/not-a-request-but-a-key')\n"
+    )
+    # The last line is a false positive by design: a dict keyed by an app path is not a thing the
+    # suite does, and a narrower match would miss a client held under any other name.
+    assert discarded_requests(src) == [1, 2, 5]
+
+
+def test_no_test_discards_a_response():
+    offenders = [
+        f"{p.name}:{line}"
+        for p in sorted(TESTS.rglob("test_*.py"))
+        for line in discarded_requests(p.read_text(encoding="utf-8"))
+    ]
+    assert offenders == [], (
+        "assert the status these requests expect (`assert client.post(...).status_code == 200`), "
+        f"or keep the response and check it: {offenders}"
+    )
diff --git a/backend/tests/test_review_round.py b/backend/tests/test_review_round.py
index 5f1e6f39..6574e296 100644
--- a/backend/tests/test_review_round.py
+++ b/backend/tests/test_review_round.py
@@ -100,15 +100,22 @@ def test_a_later_registration_never_touches_an_existing_password(db, client, smt
     have installed a password where the whole point is that there is none. Reverted; the owner's
     recourse is password-reset, which proves the mailbox. Residual logged as SEC-16.
     """
-    client.post(
-        "/auth/register", json={"email": "victim@example.com", "password": "the first password"}
+    assert (
+        client.post(
+            "/auth/register", json={"email": "victim@example.com", "password": "the first password"}
+        ).status_code
+        == 200
     )
     db.expire_all()
     user = db.execute(select(User).where(User.email == "victim@example.com")).scalar_one()
     before = user.password_hash
 
-    client.post(
-        "/auth/register", json={"email": "victim@example.com", "password": "the second password"}
+    assert (
+        client.post(
+            "/auth/register",
+            json={"email": "victim@example.com", "password": "the second password"},
+        ).status_code
+        == 200
     )
 
     db.expire_all()
@@ -116,8 +123,11 @@ def test_a_later_registration_never_touches_an_existing_password(db, client, smt
 
 
 def test_a_later_registration_leaves_a_link_already_in_flight_alive(db, client, smtp_on, wire):
-    client.post(
-        "/auth/register", json={"email": "victim@example.com", "password": "the first password"}
+    assert (
+        client.post(
+            "/auth/register", json={"email": "victim@example.com", "password": "the first password"}
+        ).status_code
+        == 200
     )
     db.expire_all()
     user = db.execute(select(User).where(User.email == "victim@example.com")).scalar_one()
@@ -126,8 +136,12 @@ def test_a_later_registration_leaves_a_link_already_in_flight_alive(db, client,
     # would go green while asserting nothing the day registration stops issuing a token.
     assert len(first) == 1
 
-    client.post(
-        "/auth/register", json={"email": "victim@example.com", "password": "the second password"}
+    assert (
+        client.post(
+            "/auth/register",
+            json={"email": "victim@example.com", "password": "the second password"},
+        ).status_code
+        == 200
     )
 
     db.expire_all()
@@ -148,8 +162,12 @@ def test_a_stripped_account_keeps_its_recovery_stamp(db, client, smtp_on, make_u
         password_revoked_at=datetime.now(timezone.utc),
     )
 
-    client.post(
-        "/auth/register", json={"email": "stripped@example.com", "password": "an attacker password"}
+    assert (
+        client.post(
+            "/auth/register",
+            json={"email": "stripped@example.com", "password": "an attacker password"},
+        ).status_code
+        == 200
     )
 
     db.expire_all()
@@ -169,7 +187,9 @@ def test_a_denied_sibling_is_not_reopened_while_a_pending_row_exists(db, client)
     )
     db.commit()
 
-    client.post("/auth/request-access", json={"email": "pairone@gmail.com"})
+    assert (
+        client.post("/auth/request-access", json={"email": "pairone@gmail.com"}).status_code == 200
+    )
 
     db.expire_all()
     rows = {i.email: i.status for i in db.execute(select(Invite)).scalars().all()}
@@ -195,7 +215,7 @@ def test_an_env_granted_address_cannot_be_shadowed_by_a_stranger(db, client, mon
     # env grant. With the env list matched canonically the request never opens a row.
     monkeypatch.setattr(settings, "allowed_emails", "bob@gmail.com")
 
-    client.post("/auth/request-access", json={"email": "b.ob@gmail.com"})
+    assert client.post("/auth/request-access", json={"email": "b.ob@gmail.com"}).status_code == 200
 
     assert db.execute(select(Invite)).scalars().all() == []
     assert auth_core.is_allowed(db, "bob@gmail.com") is True
@@ -331,7 +351,12 @@ def test_two_admins_two_languages_two_mails(db, client, make_user, smtp_on, wire
     make_user(email="hu.admin@example.com", role="admin", preferences={"language": "hu"})
     make_user(email="en.admin@example.com", role="admin", preferences={"language": "en"})
 
-    client.post("/auth/request-access", json={"email": "asking@example.com", "lang": "en"})
+    assert (
+        client.post(
+            "/auth/request-access", json={"email": "asking@example.com", "lang": "en"}
+        ).status_code
+        == 200
+    )
 
     notices = [w for w in wire if "asking@example.com" in w[1]]
     assert len(notices) == 2
diff --git a/backend/tests/test_saved_views_source.py b/backend/tests/test_saved_views_source.py
index 215c2642..a45938b5 100644
--- a/backend/tests/test_saved_views_source.py
+++ b/backend/tests/test_saved_views_source.py
@@ -53,8 +53,8 @@ def test_default_is_per_source(db, monkeypatch, override_dep):
     pid = c.post("/api/saved-views", json={"name": "P", "filters": {}, "source": "plex"}).json()[
         "id"
     ]
-    c.patch(f"/api/saved-views/{fid}", json={"is_default": True})
-    c.patch(f"/api/saved-views/{pid}", json={"is_default": True})
+    assert c.patch(f"/api/saved-views/{fid}", json={"is_default": True}).status_code == 200
+    assert c.patch(f"/api/saved-views/{pid}", json={"is_default": True}).status_code == 200
     # Making the Plex view default must NOT clear the feed view's default (different source).
     assert c.get("/api/saved-views?source=feed").json()[0]["is_default"] is True
     assert c.get("/api/saved-views?source=plex").json()[0]["is_default"] is True
@@ -67,3 +67,18 @@ def test_duplicate_name_within_a_source_conflicts(db, monkeypatch, override_dep)
     b = c.post("/api/saved-views", json={"name": "Dup", "filters": {}, "source": "plex"})
     assert a.status_code == 200
     assert b.status_code == 409  # same (user, source, name)
+
+
+def test_a_feed_views_tag_pick_must_be_a_short_list_of_ids(db, monkeypatch, override_dep):
+    """The autotag job reads every view's tag pick (E32 review): the route holds it to the shape the
+    feed sends, on create and on update."""
+    user = _user(db)
+    c = _client(db, user, monkeypatch, override_dep)
+    for bad in (5, "1", [1, "2"], [True], list(range(501))):
+        r = c.post("/api/saved-views", json={"name": "Bad", "filters": {"tags": bad}})
+        assert r.status_code == 422, (bad, r.text)
+    ok = c.post("/api/saved-views", json={"name": "Ok", "filters": {"tags": [1, 2]}})
+    assert ok.status_code == 200, ok.text
+    vid = ok.json()["id"]
+    assert c.patch(f"/api/saved-views/{vid}", json={"filters": {"tags": 5}}).status_code == 422
+    assert c.patch(f"/api/saved-views/{vid}", json={"filters": {"tags": []}}).status_code == 200
diff --git a/backend/tests/test_search_scrape.py b/backend/tests/test_search_scrape.py
new file mode 100644
index 00000000..b2dc0d79
--- /dev/null
+++ b/backend/tests/test_search_scrape.py
@@ -0,0 +1,178 @@
+"""youtube/search_scrape — the zero-quota InnerTube search (E32 S2: the module was 20% covered).
+
+Everything here breaks silently when YouTube moves: a parser that stops finding videos, a cursor that
+stops paging, a fallback key that outlives its usefulness. The network is an httpx MockTransport.
+"""
+
+import json
+
+import httpx
+import pytest
+
+from app.youtube import search_scrape
+
+RESULTS_HTML = (
+    '<script>{"INNERTUBE_API_KEY":"live-key","INNERTUBE_CLIENT_VERSION":"2.20261001"}</script>'
+)
+
+
+def _video(vid: str, title: str, *, simple: bool = False) -> dict:
+    return {
+        "videoRenderer": {
+            "videoId": vid,
+            "title": {"simpleText": title}
+            if simple
+            else {"runs": [{"text": title[:3]}, {"text": title[3:]}]},
+            "ownerText": {
+                "runs": [
+                    {
+                        "text": "Chan",
+                        "navigationEndpoint": {"browseEndpoint": {"browseId": "UCchan"}},
+                    }
+                ]
+            },
+            "thumbnail": {"thumbnails": [{"url": "small.jpg"}, {"url": "big.jpg"}]},
+        }
+    }
+
+
+PAGE = {
+    "contents": {
+        "sectionListRenderer": {
+            "contents": [
+                {
+                    "itemSectionRenderer": {
+                        "contents": [
+                            _video("v1", "First video"),
+                            {"channelRenderer": {"channelId": "UCx"}},  # not a video: skipped
+                            {
+                                "reelShelfRenderer": {
+                                    "items": [{"reelItemRenderer": {"videoId": "s1"}}]
+                                }
+                            },
+                            _video("v2", "Second", simple=True),
+                            _video("v1", "First video"),  # a repeat in another shelf: once
+                            {"videoRenderer": {"title": {"simpleText": "no id"}}},
+                        ]
+                    }
+                },
+                {
+                    "continuationItemRenderer": {
+                        "continuationEndpoint": {"continuationCommand": {"token": "NEXT"}}
+                    }
+                },
+            ]
+        }
+    }
+}
+
+
+@pytest.fixture
+def net(monkeypatch):
+    """Route every httpx.Client the module opens through a handler the test sets."""
+    calls: list[httpx.Request] = []
+    state: dict = {"handler": None}
+
+    def transport(request: httpx.Request) -> httpx.Response:
+        calls.append(request)
+        return state["handler"](request)
+
+    real = httpx.Client
+    monkeypatch.setattr(
+        search_scrape.httpx,
+        "Client",
+        lambda **kw: real(transport=httpx.MockTransport(transport), **kw),
+    )
+    monkeypatch.setattr(search_scrape, "_config", None)
+    state["calls"] = calls
+    return state
+
+
+def _serve(results_html=RESULTS_HTML, search=PAGE, status=200):
+    def handler(request: httpx.Request) -> httpx.Response:
+        if request.url.path == "/results":
+            if isinstance(results_html, Exception):
+                raise results_html
+            return httpx.Response(200, text=results_html)
+        if isinstance(search, str):
+            return httpx.Response(status, text=search)
+        return httpx.Response(status, json=search)
+
+    return handler
+
+
+def test_a_page_flattens_its_videos_in_order_and_hands_back_the_cursor(net):
+    net["handler"] = _serve()
+    page = search_scrape.search("cats")
+    assert page["next_page_token"] == "NEXT"
+    assert [i["id"] for i in page["items"]] == ["v1", "v2"]
+    assert page["items"][0] == {
+        "id": "v1",
+        "channel_id": "UCchan",
+        "channel_title": "Chan",
+        "title": "First video",
+        "published_at": None,
+        "thumbnail_url": "big.jpg",
+        "live_broadcast": "none",
+    }
+    assert page["items"][1]["title"] == "Second"
+    post = net["calls"][-1]
+    assert post.url.params["key"] == "live-key"
+    body = json.loads(post.content)
+    assert body["query"] == "cats" and body["params"] == search_scrape._TYPE_VIDEO
+    assert body["context"]["client"]["clientVersion"] == "2.20261001"
+
+
+def test_the_next_page_sends_the_cursor_not_the_query_and_the_end_has_none(net):
+    net["handler"] = _serve(search={"onResponseReceivedCommands": [_video("v9", "Last")]})
+    page = search_scrape.search("cats", continuation="NEXT")
+    body = json.loads(net["calls"][-1].content)
+    assert body["continuation"] == "NEXT" and "query" not in body
+    assert [i["id"] for i in page["items"]] == ["v9"]
+    assert page["next_page_token"] is None
+
+
+@pytest.mark.parametrize(
+    ("search", "status"),
+    [
+        ("<html>consent</html>", 200),
+        ({"error": "blocked"}, 429),
+        ({"responseContext": {}, "alerts": ["unusual traffic"]}, 200),
+        ([], 200),
+    ],
+    ids=["not-json", "http-error", "unknown-shape", "not-an-object"],
+)
+def test_a_blocked_or_garbled_answer_is_an_error_not_an_empty_page(net, search, status):
+    net["handler"] = _serve(search=search, status=status)
+    with pytest.raises(search_scrape.ScrapeError):
+        search_scrape.search("cats")
+
+
+def test_a_search_with_no_results_is_an_empty_page_not_an_error(net):
+    net["handler"] = _serve(search={"contents": {"sectionListRenderer": {"contents": []}}})
+    assert search_scrape.search("zzzzqqq") == {"items": [], "next_page_token": None}
+
+
+def test_the_live_key_is_fetched_once_and_cached(net):
+    net["handler"] = _serve()
+    search_scrape.search("a")
+    search_scrape.search("b")
+    assert [c.url.path for c in net["calls"]].count("/results") == 1
+
+
+@pytest.mark.parametrize(
+    "results_html",
+    [httpx.ConnectError("down"), "<html>a consent page, no keys</html>"],
+    ids=["fetch-failed", "no-key-on-page"],
+)
+def test_a_failed_key_fetch_falls_back_for_now_and_tries_again_next_time(net, results_html):
+    """The fallback pair used to be CACHED for the life of the process: one failed fetch pinned
+    every later search to a hard-coded key, and once that went stale search returned nothing,
+    with no error anywhere (E32 S2)."""
+    net["handler"] = _serve(results_html=results_html)
+    search_scrape.search("a")
+    assert net["calls"][-1].url.params["key"] == search_scrape._FALLBACK_KEY
+
+    net["handler"] = _serve()
+    search_scrape.search("b")
+    assert net["calls"][-1].url.params["key"] == "live-key"
diff --git a/backend/tests/test_set_password_link.py b/backend/tests/test_set_password_link.py
index 2e7f196f..2c037e24 100644
--- a/backend/tests/test_set_password_link.py
+++ b/backend/tests/test_set_password_link.py
@@ -68,8 +68,12 @@ def test_using_the_link_evicts_whoever_held_the_old_password(db, as_user, make_u
     admin = make_user(role="admin")
     db.commit()
     token = _link(as_user(admin), target.id)
-    client.post(
-        "/auth/password-reset/confirm", json={"token": token, "password": "the owner's own choice"}
+    assert (
+        client.post(
+            "/auth/password-reset/confirm",
+            json={"token": token, "password": "the owner's own choice"},
+        ).status_code
+        == 200
     )
 
     db.refresh(target)
diff --git a/backend/tests/test_shorts_probe.py b/backend/tests/test_shorts_probe.py
new file mode 100644
index 00000000..a05cc7b1
--- /dev/null
+++ b/backend/tests/test_shorts_probe.py
@@ -0,0 +1,44 @@
+"""youtube/shorts.probe_is_short — three answers, and the third is not the second (E32 S2: 33% covered).
+
+A Short answers 200 at /shorts/<id>; a regular video redirects to /watch. Anything else — an error
+page, a network failure — is "undetermined, ask again", never "not a Short": that would file a Short
+in the normal feed for good.
+"""
+
+import httpx
+import pytest
+
+from app.youtube import shorts
+
+
+def _client(respond) -> httpx.Client:
+    return httpx.Client(transport=httpx.MockTransport(respond))
+
+
+@pytest.mark.parametrize(
+    ("status", "expected"),
+    [(200, True), (301, False), (302, False), (303, False), (307, False), (308, False)]
+    + [(404, None), (429, None), (500, None)],
+)
+def test_the_status_decides_short_regular_or_undetermined(status, expected):
+    seen: list[httpx.Request] = []
+
+    def respond(request: httpx.Request) -> httpx.Response:
+        seen.append(request)
+        return httpx.Response(status, headers={"location": "https://www.youtube.com/watch?v=x"})
+
+    assert shorts.probe_is_short(_client(respond), "abc123") is expected
+    assert str(seen[0].url) == "https://www.youtube.com/shorts/abc123"
+    assert len(seen) == 1  # a redirect is the answer, never followed
+
+
+def test_a_network_failure_is_undetermined_not_regular():
+    def respond(request: httpx.Request) -> httpx.Response:
+        raise httpx.ConnectTimeout("slow", request=request)
+
+    assert shorts.probe_is_short(_client(respond), "abc123") is None
+
+
+def test_the_client_skips_the_consent_interstitial():
+    with shorts.make_client() as c:
+        assert "SOCS=" in c.headers["cookie"]
diff --git a/backend/tests/test_source_size.py b/backend/tests/test_source_size.py
new file mode 100644
index 00000000..373a1f84
--- /dev/null
+++ b/backend/tests/test_source_size.py
@@ -0,0 +1,145 @@
+"""The size / complexity RATCHET for the backend (E32, owner 2026-10-03 — "class size" from the quality
+checklist, measured rather than argued). The frontend's twin is src/lib/sourceSize.contract.test.ts.
+
+Two limits, each with today's offenders as a CEILING:
+  * a module over MAX_LINES lines — a listed one may not grow past its line count; any other module
+    may not cross the limit;
+  * a function over ruff's C901 limit (cyclomatic complexity, MAX_COMPLEXITY) — a listed one, by its
+    NAME (`module::function`), may not rise; no other function may cross the limit. (Ranked per
+    module until the E32 review: one function could grow by what another in the same module lost.)
+    A rename reads as a new offender plus a stale entry: move its row.
+Shrinking is free; a module or function that drops UNDER the limit must be taken off its list (red
+until it is), so the lists only get shorter. Raising a ceiling is a decision for the owner, with the
+reason in docs/gates.md.
+
+C901 is measured here rather than switched on in ruff.toml because ruff has no per-function
+baseline: on, it would need a `noqa` on each of today's offenders, and a `noqa` lets the function
+grow without limit. This keeps the ceiling on the number.
+"""
+
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+BACKEND = Path(__file__).resolve().parent.parent
+MAX_LINES = 800
+MAX_COMPLEXITY = 10  # ruff's C901 default (mccabe max-complexity)
+
+BIG_MODULES: dict[str, int] = {
+    "app/downloads/edit.py": 833,
+    "app/downloads/pipeline.py": 870,
+    "app/logs.py": 839,
+    "app/models.py": 1607,
+    "app/plex/stream.py": 1128,
+    "app/plex/subtitles.py": 1092,
+    "app/routes/admin.py": 864,
+    "app/routes/auth.py": 1353,
+    "app/routes/downloads.py": 1237,
+}
+
+COMPLEX: dict[str, int] = {
+    "app/bodylimit.py::__call__": 11,
+    "app/discover/hero.py::pick": 14,
+    "app/discover/pins.py::_shelf_card": 12,
+    "app/downloads/edit.py::normalize_edit_spec": 16,
+    "app/downloads/edit.py::run_ffmpeg": 15,
+    "app/downloads/formats.py::build_ydl_opts": 11,
+    "app/downloads/gc.py::_sweep_orphan_files": 15,
+    "app/downloads/gc.py::run_download_gc": 11,
+    "app/downloads/og.py::_jpeg_size": 12,
+    "app/downloads/og.py::_watch_tags": 11,
+    "app/downloads/pipeline.py::_download": 14,
+    "app/downloads/pipeline.py::_process_edit": 12,
+    "app/feedquery.py::feed_summary": 14,
+    "app/feedquery.py::filtered_query": 28,
+    "app/plex/query.py::meta_filter_conds": 13,
+    "app/plex/stream.py::start_session": 14,
+    "app/plex/subtitles.py::_ffmpeg_extract": 12,
+    "app/plex/sync.py::sync": 13,
+    "app/plex/tmdb.py::parse_tmdb": 11,
+    "app/plex/watch_sync.py::run_plex_watch_sync": 12,
+    "app/routes/auth.py::callback": 19,
+    "app/routes/debug_sessions.py::send_issue": 12,
+    "app/routes/downloads.py::resolve_source": 11,
+    "app/routes/plex/browse.py::facets": 25,
+    "app/routes/plex/browse.py::per_table": 13,
+    "app/routes/plex/browse.py::unified_library": 18,
+    "app/routes/plex/detail.py::item_detail": 13,
+    "app/routes/search.py::search_youtube": 15,
+    "app/sync/playlists.py::merge_playlist": 19,
+    "app/sync/runner.py::run_rss_poll": 13,
+    "app/sync/tagsuggest.py::compute_tag_suggestions": 14,
+    "app/worker.py::_run_supervised": 18,
+}
+
+
+def _line_counts() -> dict[str, int]:
+    return {
+        p.relative_to(BACKEND).as_posix(): len(p.read_text(encoding="utf-8").split("\n"))
+        for p in sorted((BACKEND / "app").rglob("*.py"))
+    }
+
+
+def _complexity() -> dict[str, int]:
+    """`module::function` -> its complexity; a name taken twice in a module gets ` 2`, ` 3` in
+    source order."""
+    out = subprocess.run(
+        [
+            sys.executable,
+            "-m",
+            "ruff",
+            "check",
+            "--config",
+            str(BACKEND / "ruff.toml"),
+            "--select",
+            "C901",
+            "--output-format",
+            "json",
+            "--exit-zero",
+            str(BACKEND / "app"),
+        ],
+        capture_output=True,
+        text=True,
+        check=True,
+    ).stdout
+    found: dict[str, int] = {}
+    for m in sorted(json.loads(out), key=lambda m: (m["filename"], m["location"]["row"])):
+        value = re.search(r"\((\d+) > \d+\)", m["message"])
+        name = re.search(r"`([^`]+)`", m["message"])
+        assert value and name, m["message"]
+        rel = Path(m["filename"]).resolve().relative_to(BACKEND).as_posix()
+        key, n = f"{rel}::{name.group(1)}", 2
+        while key in found:
+            key, n = f"{rel}::{name.group(1)} {n}", n + 1
+        found[key] = int(value.group(1))
+    return found
+
+
+def test_no_module_crosses_the_line_limit_and_a_listed_one_does_not_grow():
+    over = [
+        f"{f}: {n} lines (ceiling {BIG_MODULES.get(f, MAX_LINES)})"
+        for f, n in _line_counts().items()
+        if n > BIG_MODULES.get(f, MAX_LINES)
+    ]
+    assert over == []
+
+
+def test_lists_no_module_that_is_back_under_the_limit():
+    lines = _line_counts()
+    assert [f for f in BIG_MODULES if lines.get(f, 0) <= MAX_LINES] == []
+
+
+def test_no_function_crosses_the_complexity_limit_and_a_listed_one_does_not_rise():
+    worse = [
+        f"{fn}: {v} (ceiling {COMPLEX.get(fn, MAX_COMPLEXITY)})"
+        for fn, v in _complexity().items()
+        if v > COMPLEX.get(fn, MAX_COMPLEXITY)
+    ]
+    assert worse == []
+
+
+def test_lists_no_function_that_is_back_under_the_limit_or_gone():
+    actual = _complexity()
+    assert [fn for fn in COMPLEX if fn not in actual] == []
diff --git a/backend/tests/test_welcome_mail.py b/backend/tests/test_welcome_mail.py
index 4d92acfe..4ce4f99d 100644
--- a/backend/tests/test_welcome_mail.py
+++ b/backend/tests/test_welcome_mail.py
@@ -229,7 +229,12 @@ def test_registering_again_does_not_create_a_second_account(db, client, monkeypa
     _smtp_on(monkeypatch)
     _capture(monkeypatch, "send_verify_email")
     for _ in range(2):
-        client.post("/auth/register", json={"email": "twice@example.com", "password": _PW})
+        assert (
+            client.post(
+                "/auth/register", json={"email": "twice@example.com", "password": _PW}
+            ).status_code
+            == 200
+        )
 
     db.expire_all()
     rows = db.execute(select(User).where(User.email == "twice@example.com")).scalars().all()
diff --git a/backend/tests/test_youtube_refusals.py b/backend/tests/test_youtube_refusals.py
index b4043757..c41b9765 100644
--- a/backend/tests/test_youtube_refusals.py
+++ b/backend/tests/test_youtube_refusals.py
@@ -8,7 +8,9 @@ import httpx
 import pytest
 
 from app.auth import has_read_scope
-from app.models import OAuthToken
+from app.models import Channel, OAuthToken
+from app.sync.explore import explore_ingest_page
+from app.sync.videos import backfill_channel_deep, backfill_channel_recent
 from app.youtube import client as yt
 from app.youtube.client import YouTubeError, refusal_reason
 
@@ -27,12 +29,91 @@ from app.youtube.client import YouTubeError, refusal_reason
         (YouTubeError("No refresh token; user must re-authenticate"), "reconnect"),
         (YouTubeError("m", reason="transport"), "unavailable"),
         (YouTubeError("m", reason="backendError", path="subscriptions"), "unavailable"),
+        # A missing playlist the user never named (a channel's uploads): nothing they can act on.
+        (YouTubeError("m", reason="playlistNotFound", path="playlistItems"), "unavailable"),
+        (YouTubeError("m", reason="emptyAnswer", path="playlistItems"), "unavailable"),
     ],
 )
 def test_a_failure_is_sorted_by_what_the_user_can_do(exc, reason):
     assert refusal_reason(exc) == reason
 
 
+def test_a_missing_playlist_is_gone_only_on_a_route_about_that_playlist():
+    # A playlist deleted on YouTube: neither a retry nor a reconnect helps (it said "reconnect").
+    # Said only where the user picked that one list — anywhere else "this playlist no longer
+    # exists" names nothing on their screen (E32 review round 2).
+    exc = YouTubeError("m", reason="playlistNotFound", path="playlists")
+    assert refusal_reason(exc, playlist=True) == "gone"
+    assert refusal_reason(exc) == "unavailable"
+    assert refusal_reason(YouTubeError("m", reason="quotaExceeded"), playlist=True) == "quota"
+
+
+def test_a_channel_without_uploads_explores_as_an_empty_page():
+    # YouTube answers a channel's uploads playlist as not found when the channel has no uploads.
+    class _Yt:
+        def get_playlist_items(self, *_):
+            raise YouTubeError("m", reason="playlistNotFound", path="playlistItems")
+
+    channel = SimpleNamespace(id="UCempty", uploads_playlist_id="UUempty")
+    assert explore_ingest_page(None, _Yt(), channel) == {"ingested": 0, "next_page_token": None}
+
+
+class _NoUploads:
+    """A client whose every uploads read answers "playlist not found" (a channel with no uploads)."""
+
+    def __init__(self):
+        self.calls = 0
+
+    def get_playlist_items(self, *_):
+        self.calls += 1
+        raise YouTubeError("m", reason="playlistNotFound", path="playlistItems")
+
+
+def test_a_channel_without_uploads_backfills_as_done_and_is_not_charged_again(db):
+    # The recent pass stamped nothing on this answer, so the channel was picked — and charged a
+    # quota unit, with an ERROR traceback — on every backfill run, forever (E32 review round 3).
+    ch = Channel(id="UCempty", title="Empty", uploads_playlist_id="UUempty")
+    db.add(ch)
+    db.commit()
+    yt = _NoUploads()
+    assert backfill_channel_recent(db, yt, ch) == 0
+    db.refresh(ch)
+    assert ch.recent_synced_at is not None and ch.backfill_done and ch.backfill_cursor is None
+    assert backfill_channel_deep(db, yt, ch) == 0
+    assert yt.calls == 1  # the deep pass has nothing left to ask
+
+
+def test_a_deep_backfill_whose_uploads_vanish_ends_instead_of_failing(db):
+    ch = Channel(id="UCgone", title="Gone", uploads_playlist_id="UUgone", backfill_cursor="page2")
+    db.add(ch)
+    db.commit()
+    assert backfill_channel_deep(db, _NoUploads(), ch) == 0
+    db.refresh(ch)
+    assert ch.backfill_done and ch.backfill_cursor is None
+
+
+def test_any_other_backfill_failure_still_raises(db):
+    class _Yt:
+        def get_playlist_items(self, *_):
+            raise YouTubeError("m", reason="quotaExceeded", path="playlistItems")
+
+    ch = Channel(id="UCq", title="Q", uploads_playlist_id="UUq")
+    db.add(ch)
+    db.commit()
+    with pytest.raises(YouTubeError):
+        backfill_channel_recent(db, _Yt(), ch)
+
+
+def test_any_other_explore_failure_still_raises():
+    class _Yt:
+        def get_playlist_items(self, *_):
+            raise YouTubeError("m", reason="quotaExceeded", path="playlistItems")
+
+    channel = SimpleNamespace(id="UCx", uploads_playlist_id="UUx")
+    with pytest.raises(YouTubeError):
+        explore_ingest_page(None, _Yt(), channel)
+
+
 @pytest.mark.parametrize(
     ("route", "target"),
     [
diff --git a/docs/DESIGN.md b/docs/DESIGN.md
index 606120b0..c4c48b5e 100644
--- a/docs/DESIGN.md
+++ b/docs/DESIGN.md
@@ -536,8 +536,10 @@ of a full-width panel and nothing on the right.
 ## Dialogs — _Decided_ (C4, built in S3f)
 
 - **Initial focus by purpose** (`Modal`'s required `initialFocus`, so no dialog inherits "the first
-  focusable", which is always the ✕): `field` — a form opens on the body's first control, and one that
-  loads after opening moves the focus there when it arrives, as long as the focus still rests on the ✕;
+  focusable", which is always the ✕): `field` — a form opens on its first field: the body's first
+  control, or the one marked `data-initial-focus` when a control above the form is not one of its
+  fields (the issue composer's Edit / Preview switch); one that loads after opening moves the focus
+  there when it arrives, as long as the focus still rests on the ✕;
   `action` — a confirm, where the least destructive button takes `autoFocus`; `close` — anything to read,
   browse or manage. [WAI-ARIA APG]
 - **The header and the footer are fixed; only the body scrolls,** with the B9 fade at each edge, so the
@@ -702,3 +704,4 @@ of a full-width panel and nothing on the right.
 | 2026-10-01 | E31 Nav rail rows are links                      | Each page row is a real link: a middle-click or Ctrl-click opens the page in a new tab                                                                                                                                                                                                                                 | A button                                                                                                                                                                                               | The owner: open a page in a tab of its own, as on any site                                                                                                                                    |
 | 2026-10-02 | E31 Plex detail second column (refined)          | The facts over the key crew beside the text; the keywords, chips that filter like the genres, under the text; the show page gets all three too                                                                                                                                                                         | All three in the column, as the mockup drew it                                                                                                                                                         | At 20 keywords and 12 crew the column ran to twice the text's height (849 vs ~400 px at 133%): a hole under the text instead of beside it                                                     |
 | 2026-10-02 | E31 Plex detail poster and crew                  | The movie and show poster keeps its 2:3 and grows a rung in a wide hero (w-56 at a 64rem panel); the crew shows its first 6 names and "Show N more" (a list of 8 or fewer shows whole)                                                                                                                                 | Poster stretched to the row; a "More" on the keywords                                                                                                                                                  | The row is as tall as the crew column, so the poster drew ~175×590 and cropped; the crew, not the keywords, set the hero's height                                                             |
+| 2026-10-04 | E32 `field` focus skips a mode switch | A form opens on its first field; a control above it that is not a field (the composer's Edit / Preview) is passed over by marking the field `data-initial-focus` | The first text field everywhere | That moved the focus in the download dialog off its profile choice and in the upload dialog off its drop zone; the mark changes only the form that needs it |
diff --git a/docs/development.md b/docs/development.md
index 4b4227a2..090f54ac 100644
--- a/docs/development.md
+++ b/docs/development.md
@@ -39,36 +39,49 @@ decisions and the chosen patterns, rendered with the app's real CSS. It never re
 ## The gate
 
 A change is done when all of this is green. CI runs the same checks server-side
-(`.gitea/workflows/check.yml`), so "main is always green".
+(`.gitea/workflows/check.yml`), so "main is always green". What each gate deliberately does NOT
+check — and why — is the [gate register](gates.md); a test fails when a narrowing is missing from it.
 
 **Backend**
 
 ```bash
-# lint + format check
+# lint + format check (ruff is pinned in backend/requirements-dev.txt)
 python -m ruff check --config backend/ruff.toml backend scripts
 python -m ruff format --check --config backend/ruff.toml backend scripts
 
-# tests — pure-logic + the DB-backed integration lane, against an ephemeral Postgres.
-# The backend tree is bind-mounted, so it always tests your working files.
+# type check — in the test image (requirements.lock does not install on Windows); new errors only,
+# the pre-existing ones are in backend/.basedpyright/baseline.json
+docker compose -f backend/docker-compose.test.yml run --rm --no-deps --build test \
+  python -m basedpyright --project pyrightconfig.json
+
+# tests — pure-logic + the DB-backed integration lane, against an ephemeral Postgres, ending with the
+# coverage total. The backend tree is bind-mounted, so it always tests your working files.
 docker compose -f backend/docker-compose.test.yml up --build --abort-on-container-exit --exit-code-from test
 docker compose -f backend/docker-compose.test.yml down -v
 ```
 
-The test compose sets `SIFTLODE_TEST_REQUIRE_DB=1`, which turns a would-be silent skip (no DB, or no
-ffmpeg) into a hard failure — so the gate can't print green while the DB-backed tests were quietly not
-run. Tests that need a database take the `db` fixture (`backend/tests/conftest.py`); the rest are
-pure-logic and run without one.
+A missing database or ffmpeg is a hard error, not a skip — so the gate can't print green while the
+DB-backed tests were quietly not run (`SIFTLODE_TEST_REQUIRE_DB=0` is the explicit "pure-logic only"
+run for a machine without Postgres). Tests that need a database take the `db` fixture
+(`backend/tests/conftest.py`); the rest are pure-logic and run without one.
 
 **Frontend** (from `frontend/`)
 
 ```bash
+node ../scripts/check-node-modules.mjs   # node_modules == package-lock.json (else: npm ci)
 npm run typecheck     # tsc x3 (app / node / e2e)
-npm run lint          # eslint
+npm run lint          # eslint (typed rules included; warnings fail)
 npm run format:check  # prettier
-npm run knip          # unused exports/deps
-npm run test          # vitest
+npm run knip          # unused files/exports/deps — and unused by what SHIPS (--production)
+npm run test          # vitest (incl. the compiler, size/complexity and gate-register contracts)
+npx vite build        # the production bundle (devOnlyGuard fails it on dev-only code)
 ```
 
+Coverage is reported, never enforced: `npm run test -- --coverage`, and the pytest lane's last line.
+The Playwright suite (`npm run e2e`) runs against the `:8080` stack built from your tree; the release
+requires it. Before an image is pushed, it is scanned with Trivy (HIGH/CRITICAL with a fix fails;
+exceptions in `.trivyignore.yaml`, each with a reason and an expiry).
+
 ## Branching
 
 Trunk-based: branch off `main`, keep the branch gate-green, and land the whole change back to `main`
diff --git a/docs/gates.md b/docs/gates.md
new file mode 100644
index 00000000..b1d7b907
--- /dev/null
+++ b/docs/gates.md
@@ -0,0 +1,136 @@
+# Gate register
+
+Every place a gate deliberately checks **less** than it could: a rule switched off or narrowed for a
+scope, a flag left off, a lane that does not run everywhere, an accepted finding. One row each, with
+the reason and the number measured when the row was written.
+
+**Why this file exists (E32).** The worst defect E32 found was not in any code a reviewer read: a lint
+rule had been switched off with 64 real hits counted in its own comment, and the "false positives"
+beside them were the React Compiler skipping 95 functions without a word. The rule since: **a gate
+with any real hit is never switched off or narrowed** — fix the sites, or suppress each one inline and
+name its invariant. Whatever is left narrowed is listed here, and
+[`frontend/src/lib/gates.contract.test.ts`](../frontend/src/lib/gates.contract.test.ts) reads the
+**effective** configuration and fails when a narrowing is not on this page. A row here is a decision,
+not an oversight; a narrowing missing from here is a test failure.
+
+**The snapshot.** ESLint's effective config for every code file `eslint .` reaches, and the lines
+that run the lanes (`.gitea/workflows/check.yml`, `backend/docker-compose.test.yml`,
+`backend/Dockerfile.test`, the npm scripts, `vitest.config.ts`, `.prettierignore`), are committed in
+[`frontend/src/lib/gates.snapshot.json`](../frontend/src/lib/gates.snapshot.json). The test fails on
+ANY difference — a rule, an option, a glob that moves one file to another config, a new ignore, a CI
+flag. So a change to a gate is always a diff of that file in review, never a shape a detector failed
+to model (E32 review: three rounds of a cleverer detector each found a bypass of the last one's
+fixes). Regenerate it with `GATE_SNAPSHOT=update npx vitest run src/lib/gates.contract.test.ts`
+(from `frontend/`), and read its diff as a gate change: a new file only adds its path; anything else
+needs a reason. A new code file is part of that diff by design.
+
+**How the register is matched:** each narrowing must appear in a table row below as its
+`code-quoted` id, in a row whose **Scope** cell names the scope exactly as the test reports it (a cell
+may list several, separated by ` · `). For ESLint the scopes are the snapshot's config names, and a
+narrowing is read off each config against `src`: a rule at off or warn, or one src applies that a
+scope does not (one id per plugin family), a `no-restricted-*` list that leaves out an entry src's
+declares, an option that lets something through (`allow…`, `ignore…`, `except…`), an unused-disable
+report that is not an error, and a file no config lints. Ruff's TOML is parsed and held to a
+whitelist of key paths, pytest.ini to a whitelist of whole lines.
+
+## ESLint (frontend)
+
+`npm run lint` is `eslint . --max-warnings 0`, so a rule at **warn** fails the lane exactly like an
+error (the test holds that exact script). The warn rows are listed so that claim stays checked.
+A core rule switched off because its typescript-eslint twin replaces it (`no-unused-vars` →
+`@typescript-eslint/no-unused-vars`) is not listed separately; neither are the core rules
+typescript-eslint's compatibility layer switches off for TS files because the type checker reports
+them itself (`no-undef`, `no-redeclare`, `no-dupe-keys`, …), nor the formatting rules
+`eslint-config-prettier` switches off (Prettier owns formatting and has its own lane).
+
+| Scope | Narrowed | Why | Measured |
+| --- | --- | --- | --- |
+| src | `@typescript-eslint/no-unused-vars` — off | tsc owns it (`noUnusedLocals` + `noUnusedParameters` in every project), so a finding is reported once, by one tool. | — |
+| src | `react-hooks/exhaustive-deps` — warn | Preset level; `--max-warnings 0` makes it fail. Every suppression names its invariant (`eslint-comments/require-description`). | 0 suppressions (E32 S4: a suppression of this rule drops the whole function from the React Compiler, so the two that were left went) |
+| src | `react-hooks/incompatible-library` — warn | Preset level; fails under `--max-warnings 0`. VirtualGrid (TanStack Virtual) is the one site, suppressed inline. | 1 |
+| src | `react-hooks/unsupported-syntax` — warn | Preset level; fails under `--max-warnings 0`. | 0 |
+| src | `react-refresh/only-export-components` — warn | Fails under `--max-warnings 0`; `allowConstantExport` lets a module export constants beside its component. | 0 |
+| src | `@typescript-eslint/no-unused-expressions` — narrowed | `allowShortCircuit` + `allowTernary`: `cond && f()` / `a ? f() : g()` side-effect statements are an idiom here. | — |
+| src | `@typescript-eslint/no-floating-promises` — narrowed | `allowForKnownSafeCalls`: React Query's `invalidateQueries`, `refetchQueries`, `cancelQueries`, `resetQueries`, `prefetchQuery`, `prefetchInfiniteQuery` never reject unless asked to (`throwOnError`), so a bare call is safe by name. | 6 names |
+| e2e | `@typescript-eslint/no-floating-promises` — narrowed | The same `allowForKnownSafeCalls` list (the typed rules are one object for both scopes). | 6 names |
+| lib/http.ts | `no-restricted-globals` — narrowed | A network owner (`NETWORK_OWNERS` in eslint.config.js): the one module that may call `fetch` (`send`, which `req` and the public pages go through). Every other network global stays restricted there. | 1 global |
+| lib/api/core.ts | `no-restricted-globals` — narrowed | A network owner: `uploadReq` is the one `XMLHttpRequest` (upload progress). | 1 global |
+| lib/messagesSocket.ts | `no-restricted-globals` — narrowed | A network owner: the chat socket is the one `WebSocket`. | 1 global |
+| src tests · ui tests · lib tests | `no-restricted-globals`, `no-restricted-properties` — off | A test stands a double in for the network (`vi.stubGlobal("fetch", …)`) and may reach it directly. | — |
+| src tests · ui tests · lib tests | `local/literal-a11y-text`, `local/button-primitive`, `local/input-primitive`, `local/surface-role`, `local/glyph-link` — off | A test renders throwaway markup (a raw button as a focus target, an untranslated label) that is not product UI. | — |
+| FocusSafeButton.tsx + AnchoredPopover.tsx | `local/focus-safe-disabled` — off | FocusSafeButton: it IS the focus-safe primitive the rule points everyone else to. | — |
+| FocusSafeButton.tsx + AnchoredPopover.tsx | `local/focus-safe-disabled` — off | AnchoredPopover: the popover's menu row: its native `disabled` is what floating-ui's roving focus reads to skip it. | — |
+| design-lab | `local/literal-a11y-text` — off | The dev-only design lab (never in the bundle — devOnlyGuard fails the build if it is) holds the owner's working copy, not product copy. | — |
+| e2e | `react-hooks/*`, `react-refresh/*`, `local/*`, `no-console`, `no-restricted-globals`, `no-restricted-properties`, `no-restricted-syntax` — not applied | Playwright specs drive a browser from Node: no React, no product UI, and they print to the console on purpose. They get the base + typed rules + the playwright rules. | — |
+| ts configs | `react-hooks/*`, `react-refresh/*`, `local/*`, `no-console`, `no-restricted-globals`, `no-restricted-properties`, `no-restricted-syntax` — not applied | The build configs (vite, vitest, playwright, reactPlugin, devOnlyGuard) run in Node at build time. | — |
+| js configs | `@typescript-eslint/*`, `react-hooks/*`, `react-refresh/*`, `local/*`, `no-console`, `no-restricted-globals`, `no-restricted-properties`, `no-restricted-syntax`, `no-var`, `prefer-const`, `prefer-rest-params`, `prefer-spread`, `no-array-constructor`, `no-unused-expressions` — not applied | `eslint.config.js` and `postcss.config.js`: plain-JS build config, linted with `js.configs.recommended` only. | — |
+| repo scripts | `scripts/*.mjs` — not in the eslint or prettier lane; `js.configs.recommended` + Prettier via `src/lib/repoScripts.contract.test.ts` | They sit at the repo root, and an ESLint config cannot reach past its own directory. The contract test lints and format-checks them from the repo root, to the same bar as the `js configs` row; no typed rules, as they are in no tsc project. | 0 lint hits; 2 files reformatted (E32 review) |
+| everywhere | ignored paths: `dist`, `node_modules`, `playwright-report`, `test-results`, `e2e/.auth` | Build output, installed packages, test artefacts, a live Playwright session. Generated, not written. | — |
+
+**Not enabled** (decided, not forgotten): `strictTypeChecked` — owner decision E32 D3, ~2000 hits with
+none real in the sample; the curated typed pair `no-floating-promises` + `no-deprecated` runs instead.
+
+## TypeScript
+
+| Scope | Narrowed | Why | Measured |
+| --- | --- | --- | --- |
+| config files | `eslint.config.js — not type-checked` | Linted (the `js configs` row) and executed by every lint run, but in no tsc project. Under the node project's `strict` + `checkJs` it reports 43 errors: 42 implicit-`any` parameters in the local rules' visitors (JSX nodes, which ESLint's own `Rule` typings do not model) and one inferred `string` severity. None is a defect; typing them means moving the local rules onto typescript-eslint's `TSESTree` types — a refactor of its own, not done in E32. | 43 (E32 review) |
+| all three projects | `skipLibCheck` | The `.d.ts` of installed packages are not type-checked (ours are). Standard for an app: a package's own types are its maintainers' gate, and checking them costs minutes and reports errors we cannot fix. | — |
+
+Every project has `strict`, `noUncheckedIndexedAccess`, `noUnusedLocals`, `noUnusedParameters` and
+`noFallthroughCasesInSwitch` on; the test fails if one goes off, if a `strict` sub-flag
+(`strictNullChecks`, `noImplicitAny`, …) is set false beside it, if a project gains an `extends`,
+`exclude` or `files`, or if its `include` changes — and a config file at the frontend root that no
+project checks needs a row.
+
+## Ruff (backend + scripts)
+
+| Scope | Narrowed | Why | Measured |
+| --- | --- | --- | --- |
+| backend + scripts | `B008` — narrowed: `fastapi.Depends`, `fastapi.Query` declared immutable | FastAPI's dependency injection IS a call in a default argument, on every route. Every other call in a default still fails. | 474 sites, all of them FastAPI |
+| backend/app | `C901` — not in ruff; measured by `tests/test_source_size.py` | Ruff has no per-function baseline, so turning it on would need a `noqa` per offender, and a `noqa` lets a function grow without limit. The test holds each offender, by name, at its current value. Tests and scripts are outside it: see the size / complexity rows under Lanes. | 32 functions over 10 |
+
+## basedpyright (backend)
+
+| Scope | Narrowed | Why | Measured |
+| --- | --- | --- | --- |
+| backend/app + alembic | `typeCheckingMode` — `standard` | Not `strict`/`all`: those report on every untyped third-party boundary (SQLAlchemy rows, yt-dlp dicts) — thousands of findings, near-zero real ones. `standard` was measured at 7 findings, all fixed (E32 S1). | — |
+| backend/app + alembic | `baseline.json` — pre-existing errors absorbed | The lane fails on NEW errors only; the baseline only shrinks (the lane fails when a run tightens it and it is not committed). Matching is per (file, rule, column span) + count, so burn the hot files first. | 195 entries (E32 S1) |
+| tests/ | not type-checked | A test's job is to fail loudly when wrong — the opposite of the silent runtime failure this lane catches — and annotating fixtures for a checker is churn. | — |
+
+## pytest (backend)
+
+| Scope | Narrowed | Why | Measured |
+| --- | --- | --- | --- |
+| a hand run | `SIFTLODE_TEST_REQUIRE_DB=0` — the DB-backed and ffmpeg tests skip | The explicit "pure-logic only" run for a machine without Postgres. Off by default since E32: without it a missing DB is a hard error; the gate and CI never set it. | — |
+
+## knip (frontend)
+
+| Scope | Narrowed | Why | Measured |
+| --- | --- | --- | --- |
+| --production | `!**/*.testkit.ts!`, `!e2e/**!` | Test kits and the e2e suite are test code: the production pass asks what the SHIPPED code uses. | — |
+| --production | `!reactPlugin.ts!`, `!devOnlyGuard.ts!` | Build tooling the vite config imports: it shapes the bundle but is not in it. | — |
+| --production | `@internal` exports | An export only its test imports says so with a JSDoc `@internal` tag naming the test; knip skips those in production mode. | 35 (E32 S1) |
+
+## Lanes and pipeline
+
+| Scope | Narrowed | Why | Measured |
+| --- | --- | --- | --- |
+| check | e2e (Playwright) not in `check` | It needs the :8080 stack built from the tree (minutes). It runs in `check-full`, and `release` rebuilds the stack and requires it (E32 D2) — nothing ships without it. | 5 specs × 3 engines |
+| CI | no e2e, no Trivy | The lab runner has no browser stack, and Trivy's DB download is not reachable from it. Both run in `release` / `publish` on the dev machine, before anything is pushed. | — |
+| coverage | no threshold | Owner decision E32 D4: reported on both sides, never enforced. "Every regression test seen red" is the bar; a percentage invites tests written to move it. | frontend 80% / backend 78% of lines (E32 S1) |
+| CVE gate | HIGH/CRITICAL with a fix available only | `--ignore-unfixed` + `--severity HIGH,CRITICAL`: a finding with no fix cannot be acted on by an upgrade; it shows in the scan output. A fixable one fails the publish, and the only way past it is `.trivyignore.yaml`. | 0 open (E32 S1) |
+| npm audit (CI) | `--omit=dev --audit-level=high` | What ships to the browser, at high or above. The dev toolchain's advisories were burned down by hand in E32 S1 (18 → 0). | 0 |
+| React Compiler | the functions it skips, pinned | `components/compilerCoverage.contract.test.ts` — the list may only shrink. End state: only VirtualGrid (TanStack Virtual, an IncompatibleLibrary) remains. | 93 (E32 S1) → 29 (E32 S3) → 1, VirtualGrid (E32 S4) |
+| size / complexity | today's offenders as ceilings | `src/lib/sourceSize.contract.test.ts`, `backend/tests/test_source_size.py`: listed files and functions may not grow, nothing new may cross the limit, an entry back under it must be deleted. A function is held by its name, not its rank in the file. | files >800 lines: 13 FE / 9 BE; functions over the limit: 64 FE / 32 BE (E32 review) |
+| size / complexity | shipped code only — not tests, test kits, e2e or `scripts/` | The ratchet guards what runs in production. A test file is long because it is a list of cases, and a test kit is test code; splitting either moves lines without making anything easier to change. `scripts/` is release and seed tooling, not in the image. | outside it: tests >800 lines 2 FE / 5 BE; functions over the limit 2 FE test code (`gates.contract.test.ts` `eslintNarrowings` 23, E32 review round 3; `compilerSkips.testkit.ts` 25), 1 BE test (11), 1 script (`e2e_seed.py` `main` 13) |
+
+## Accepted findings
+
+Entries in `.trivyignore.yaml` (CVE gate) and `--ignore-vuln` flags on CI's `pip-audit` step. Each
+must have a row here (Scope `accepted`) with its reason and its expiry; the test fails on an entry
+without one, and on a `.trivyignore.yaml` entry with no `statement` or no `expired_at`.
+
+| Scope | Finding | Why | Expires |
+| --- | --- | --- | --- |
+| — | none | — | — |
diff --git a/frontend/e2e/helpers.ts b/frontend/e2e/helpers.ts
index 0b1b3c6c..78dd0c80 100644
--- a/frontend/e2e/helpers.ts
+++ b/frontend/e2e/helpers.ts
@@ -13,19 +13,24 @@ export async function gotoPage(page: Page, id: string): Promise<void> {
 }
 
 /**
- * Click a channel link that is currently WITHIN the viewport — what a real user does. Never use
- * `.first()` for this after scrolling: the first rendered card lives in the virtualizer's overscan
- * ABOVE the viewport, so Playwright would scroll it into view to click it, moving the scroll
- * position — fatal to any test that then asserts on where the feed was. Returns false if none found.
+ * Click a channel link a real user can actually SEE and hit. Never use `.first()` for this after
+ * scrolling: the first rendered card lives in the virtualizer's overscan ABOVE the viewport, so
+ * Playwright would scroll it into view to click it, moving the scroll position — fatal to any test
+ * that then asserts on where the feed was. Being inside the viewport is not enough either: a card
+ * can sit under the page chrome above the scroller (the update banner, the toolbar band), and the
+ * covered click makes Playwright scroll and retry — the same move (E32 S2: webkit failed 3 in 24).
+ * So the link must be the element hit at its own centre. Returns false if none found.
  */
 export async function clickVisibleChannelLink(page: Page): Promise<boolean> {
   const links = page.getByTestId("video-card-channel").filter({ visible: true });
-  const viewport = page.viewportSize();
-  const height = viewport?.height ?? 800;
   const count = await links.count();
   for (let i = 0; i < count; i++) {
-    const box = await links.nth(i).boundingBox();
-    if (box && box.y >= 0 && box.y + box.height <= height) {
+    const hittable = await links.nth(i).evaluate((el) => {
+      const r = el.getBoundingClientRect();
+      const hit = document.elementFromPoint(r.left + r.width / 2, r.top + r.height / 2);
+      return hit !== null && el.contains(hit);
+    });
+    if (hittable) {
       await links.nth(i).click();
       return true;
     }
diff --git a/frontend/e2e/nav.spec.ts b/frontend/e2e/nav.spec.ts
index 4427e1bc..5637be7d 100644
--- a/frontend/e2e/nav.spec.ts
+++ b/frontend/e2e/nav.spec.ts
@@ -6,18 +6,12 @@ import { openApp } from "./helpers";
 // this exercises is precisely what the module-registry refactor replaces.
 test.describe("page switching", () => {
   // Core + admin modules (the E2E account is an admin, matching the real primary user), so this
-  // also exercises the render ternary's admin branches (scheduler / config / users / audit).
-  const RAIL = [
-    "channels",
-    "playlists",
-    "stats",
-    "scheduler",
-    "config",
-    "users",
-    "audit",
-    "settings",
-    "feed",
-  ];
+  // also exercises the admin pages. Since E31 those sit behind ONE rail row ("Administration",
+  // `nav-admin`) that opens a panel of them — the spec still listed them as rail rows of their own,
+  // and it failed on every run from E31 to E32 without anyone seeing it, because e2e was in no
+  // required gate (it is now part of `release`).
+  const RAIL = ["channels", "playlists", "stats", "settings", "feed"];
+  const ADMIN = ["scheduler", "config", "users", "audit"];
 
   test("each rail item activates its page", async ({ page }) => {
     await openApp(page);
@@ -27,6 +21,22 @@ test.describe("page switching", () => {
     }
   });
 
+  test("each admin page opens from the Administration panel and marks it current", async ({
+    page,
+  }) => {
+    await openApp(page);
+    for (const id of ADMIN) {
+      await page.getByTestId("nav-admin").click();
+      await page.getByTestId(`nav-admin-${id}`).click();
+      // The panel closes on a pick; the group row carries the current page…
+      await expect(page.getByTestId("nav-admin")).toHaveAttribute("aria-current", "page");
+      // …and, reopened, the panel marks which one.
+      await page.getByTestId("nav-admin").click();
+      await expect(page.getByTestId(`nav-admin-${id}`)).toHaveAttribute("aria-current", "page");
+      await page.keyboard.press("Escape");
+    }
+  });
+
   test("browser Back steps through visited pages", async ({ page }) => {
     await openApp(page);
 
diff --git a/frontend/e2e/tsconfig.json b/frontend/e2e/tsconfig.json
index 246d917f..81e33f9c 100644
--- a/frontend/e2e/tsconfig.json
+++ b/frontend/e2e/tsconfig.json
@@ -11,6 +11,8 @@
     "noUnusedLocals": true,
     "noUnusedParameters": true,
     "noFallthroughCasesInSwitch": true,
+    // E32: an index read is `T | undefined` here, as it really is (0 errors when switched on).
+    "noUncheckedIndexedAccess": true,
     "esModuleInterop": true,
     "resolveJsonModule": true
   },
diff --git a/frontend/eslint.config.js b/frontend/eslint.config.js
index 3d1b998a..77659e09 100644
--- a/frontend/eslint.config.js
+++ b/frontend/eslint.config.js
@@ -4,16 +4,25 @@ import reactHooks from "eslint-plugin-react-hooks";
 import reactRefresh from "eslint-plugin-react-refresh";
 import prettier from "eslint-config-prettier";
 import globals from "globals";
+import eslintComments from "@eslint-community/eslint-plugin-eslint-comments";
+import vitest from "@vitest/eslint-plugin";
+import playwright from "eslint-plugin-playwright";
 
-// Flat config (ESLint 9). Deliberately NARROW: the high-value rule here is
-// react-hooks/exhaustive-deps — 33 suppressions across the app exist for it, and until this
-// sprint nothing ran to make them mean anything. tsc already owns unused vars, undefined names
+// Flat config (ESLint 9). Deliberately NARROW: the high-value rules here are react-hooks' (the
+// hook rules and the React Compiler's diagnostics). The 33 inline `exhaustive-deps` suppressions this
+// config first met are all gone (0 left, E32 review); what is still suppressed is suppressed inline,
+// one site at a time, each naming its invariant. tsc already owns unused vars, undefined names
 // and types (noUnusedLocals/Parameters + strict), so typescript-eslint's non-type-checked
 // `recommended` is layered on but its overlap with tsc is turned off below to avoid double-reporting
 // and a churny diff. `eslint-config-prettier` is LAST so formatting rules never fight Prettier.
 //
 // reportUnusedDisableDirectives: a `// eslint-disable` that no longer suppresses anything is itself
 // an error — that is what keeps inert disable comments from re-accumulating (the S1b mandate).
+//
+// E32 (gate integrity): every switched-off or narrowed rule here is listed, with its reason and its
+// measured count, in docs/gates.md, and lib/gates.contract.test.ts fails when one is not. A rule
+// with a single real hit is never switched off — its sites are fixed, or each suppressed inline with
+// a `-- <the invariant>` description (eslint-comments/require-description makes that mandatory).
 
 // E22 S4: every way out of the browser goes through the one module that LOGS it — a request line
 // with a request id (lib/http.ts), the upload XHR (lib/api/core.ts), the messages socket
@@ -472,47 +481,103 @@ const SPLIT_CLASS = "/^([a-z][\\w-]*:[\\w\\[!-]|:[a-z\\[!])/";
 const SPLIT_CLASS_MESSAGE =
   "a class split by an interpolation (`${x}hover:…`): Tailwind never sees it whole and emits no CSS; write the class literally (a shared guard is the `act:` variant).";
 
+// Applies to EVERY linted file: a suppression says which rule and why. A bare
+// `eslint-disable-next-line rule` named nothing in four places the E32 audit found, against the
+// CLAUDE.md rule that each one names its invariant; a blanket `eslint-disable` names no rule at all.
+const suppressionRules = {
+  plugins: { "@eslint-community/eslint-comments": eslintComments },
+  linterOptions: { reportUnusedDisableDirectives: "error" },
+  rules: {
+    "@eslint-community/eslint-comments/require-description": ["error", { ignore: [] }],
+    "@eslint-community/eslint-comments/no-unlimited-disable": "error",
+  },
+};
+
+// The two type-aware rules (E32 D3: a curated pair, not strictTypeChecked — ~2000 hits there, none
+// real in the sample). A floating promise is a rejection nobody handles: the audit found two real
+// ones (ChatDock's device key store, VideoEditor's play()). `void` marks a deliberate fire-and-forget
+// whose callee reports its own failure. React Query's invalidate/refetch family never rejects
+// unless asked to (`throwOnError`), so those calls are known-safe by name.
+const typedRules = {
+  "@typescript-eslint/no-floating-promises": [
+    "error",
+    {
+      allowForKnownSafeCalls: [
+        {
+          from: "package",
+          package: "@tanstack/query-core",
+          name: [
+            "invalidateQueries",
+            "refetchQueries",
+            "cancelQueries",
+            "resetQueries",
+            "prefetchQuery",
+            "prefetchInfiniteQuery",
+          ],
+        },
+      ],
+    },
+  ],
+  "@typescript-eslint/no-deprecated": "error",
+};
+
 export default tseslint.config(
   { ignores: ["dist", "node_modules", "playwright-report", "test-results", "e2e/.auth"] },
+  suppressionRules,
   {
     files: ["src/**/*.{ts,tsx}"],
     extends: [js.configs.recommended, ...tseslint.configs.recommended],
     languageOptions: {
       ecmaVersion: 2022,
       globals: { ...globals.browser },
+      parserOptions: { projectService: true, tsconfigRootDir: import.meta.dirname },
     },
     plugins: {
       "react-hooks": reactHooks,
       "react-refresh": reactRefresh,
       local: localRules,
     },
-    linterOptions: {
-      reportUnusedDisableDirectives: "error",
-    },
     rules: {
       ...reactHooks.configs.recommended.rules,
+      ...typedRules,
+      // The React Compiler's own diagnostics that `recommended` leaves out (E32). Each is a function
+      // the compiler SKIPS, silently — `panicThreshold` is "none" and there is no logger, so a lint
+      // error is the only place the skip is said out loud. `todo` is the compiler's "cannot lower
+      // this shape yet" (E32 S4 rewrote all 31 try statements it found); the rest had 0 hits when
+      // switched on. Most are tripwires, but three cannot report anything under
+      // eslint-plugin-react-hooks 7.1.1 (E32 review, read in its source and probed):
+      // `exhaustive-effect-dependencies` (its validation is compiled off — a missing effect dependency
+      // is reported by the classic `exhaustive-deps` only), `memoized-effect-dependencies` (nothing
+      // emits its category) and `rule-suppression` (lint mode hands it no suppression rules, so an
+      // inline disable is never named). They stay on for the plugin version that wires them up; a
+      // function the compiler skips over a suppression is caught by the coverage ratchet below.
+      // `todo` does NOT see every such shape — a conditional, a loop
+      // or an optional call inside a try skips the function with no lint hit at all — so the full
+      // per-function picture is components/compilerCoverage.contract.test.ts.
+      "react-hooks/todo": "error",
+      "react-hooks/memo-dependencies": "error",
+      "react-hooks/rule-suppression": "error",
+      "react-hooks/invariant": "error",
+      "react-hooks/syntax": "error",
+      "react-hooks/void-use-memo": "error",
+      "react-hooks/component-hook-factories": "error",
+      "react-hooks/capitalized-calls": "error",
+      "react-hooks/hooks": "error",
+      "react-hooks/memoized-effect-dependencies": "error",
+      "react-hooks/exhaustive-effect-dependencies": "error",
+      "react-hooks/no-deriving-state-in-effects": "error",
       // eslint-plugin-react-hooks 7's `recommended` is no longer two rules — it carries the whole
-      // React Compiler rule set (E27 S1). On this codebase that landed 283 findings, and they were
-      // triaged rather than bulk-suppressed, because the two answers are different:
+      // React Compiler rule set (E27 S1). On this codebase that landed 283 findings. 66 were fixed or
+      // suppressed inline, each naming its invariant; there is DELIBERATELY no suppressions file — a
+      // bulk `--suppress-all` would hide the next violation instead of answering it.
       //
-      //   react-hooks/refs  217 — OFF, see below.
-      //   the other 66      — real. They went into eslint-suppressions.json as a ratchet for one
-      //                       sprint and E27 S2 burned the file down to nothing: what survives is
-      //                       an inline directive at the site, each naming the invariant it
-      //                       protects. There is DELIBERATELY no suppressions file any more — a
-      //                       bulk `--suppress-all` would hide the next violation instead of
-      //                       answering it, and it cannot hold a warning-level rule anyway.
-      //
-      // `refs` is off because it fires on this app's popover architecture, not on its history, so
-      // suppressing it would not help the next popover anyone writes. Measured over the 217:
-      // 79 are `pop.refs.setReference` / `getReferenceProps` — @floating-ui/react's callback-ref
-      // setters, which are the documented way to use it — and 74 more are passing the popover handle
-      // down as a prop (`popover={pop}`, `ref={fade.ref}`), which is what `components/ui`'s popover
-      // engine is FOR. That is 153 of 217 flagged for having the word `refs` in an object that is not
-      // a React ref. The remaining ~64 are genuine render-phase `someRef.current = x` writes and are
-      // real (E27 S2 answered the ones the other rules could see, at their sites).
-      // Re-evaluate when the rule can: it shipped in 1.0.0 and this looks like over-approximation.
-      "react-hooks/refs": "off",
+      // `refs` (the other 217) was switched OFF in E27 as mostly false positives, and that triage was
+      // wrong: the rule and the React Compiler share one analysis, so every hit was a function the
+      // compiler SKIPS — 21 popover components among them, and Channels' 0.9 s row menu was the bill
+      // (E32). E32 S3–S4 fixed every site (245 measured) instead of narrowing the rule: the popover
+      // engine is read through destructuring, render-phase ref writes became `useEffectEvent` /
+      // `useLatest`. It is on, at error, with no exception.
+      "react-hooks/refs": "error",
       "local/jsx-comment-text": "error",
       "local/focus-safe-disabled": "error",
       "local/button-primitive": "error",
@@ -709,7 +774,12 @@ export default tseslint.config(
     // Tests stand doubles in for the network (`vi.stubGlobal("fetch", …)`) and may reach it directly.
     // …and render throwaway markup whose labels no user ever hears.
     files: ["src/**/*.test.{ts,tsx}"],
+    plugins: { vitest },
     rules: {
+      // A focused test silently skips the rest of the suite; a skipped one is a test nobody runs
+      // (E32 — vitest's allowOnly is on outside CI, so nothing else catches a stray `.only` locally).
+      "vitest/no-focused-tests": "error",
+      "vitest/no-disabled-tests": "error",
       "no-restricted-globals": "off",
       "no-restricted-properties": "off",
       "local/literal-a11y-text": "off",
@@ -720,5 +790,38 @@ export default tseslint.config(
       "local/glyph-link": "off",
     },
   },
+  {
+    // Outside src (E32): the e2e suite and the TypeScript build-tool configs went unlinted — the
+    // flat config named only src/**, so `eslint .` skipped them without a word. The same base and
+    // typed rules as the app; Node globals, since none of it runs in the browser.
+    files: ["e2e/**/*.ts", "*.config.ts", "reactPlugin.ts", "devOnlyGuard.ts"],
+    extends: [js.configs.recommended, ...tseslint.configs.recommended],
+    languageOptions: {
+      ecmaVersion: 2022,
+      globals: { ...globals.node },
+      parserOptions: { projectService: true, tsconfigRootDir: import.meta.dirname },
+    },
+    rules: {
+      ...typedRules,
+      // tsc owns these here too (both tsconfig.node.json and e2e/tsconfig.json are strict +
+      // noUnusedLocals/Parameters).
+      "@typescript-eslint/no-unused-vars": "off",
+      "no-undef": "off",
+    },
+  },
+  {
+    files: ["e2e/**/*.ts"],
+    plugins: { playwright },
+    rules: {
+      "playwright/no-focused-test": "error",
+      "playwright/no-skipped-test": "error",
+    },
+  },
+  {
+    // The two plain-JS configs: this file and postcss's.
+    files: ["*.config.js"],
+    extends: [js.configs.recommended],
+    languageOptions: { ecmaVersion: 2022, sourceType: "module", globals: { ...globals.node } },
+  },
   prettier,
 );
diff --git a/frontend/knip.json b/frontend/knip.json
deleted file mode 100644
index 03dea5bc..00000000
--- a/frontend/knip.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-  "$schema": "https://unpkg.com/knip@6/schema.json",
-  "playwright": {
-    "config": ["playwright.config.ts"],
-    "entry": ["e2e/**/*.@(spec|setup).ts"]
-  }
-}
diff --git a/frontend/knip.jsonc b/frontend/knip.jsonc
new file mode 100644
index 00000000..7fa7cc10
--- /dev/null
+++ b/frontend/knip.jsonc
@@ -0,0 +1,20 @@
+{
+  "$schema": "https://unpkg.com/knip@6/schema.json",
+  // `--production` (E32) asks a second question besides "is this used?": "is it used by the code
+  // that SHIPS?" — an export only a test reaches is either dead in the bundle or exported for its
+  // test, which then says so with a JSDoc `@internal` tag (knip skips those in production mode).
+  // What is not production code at all is excluded from the production project with a `!…!`
+  // pattern: the test kits, the e2e suite, and the two build-tooling modules the vite config
+  // imports (they shape the bundle but are not in it).
+  "project": [
+    "**/*.{ts,tsx,js}!",
+    "!**/*.testkit.ts!",
+    "!e2e/**!",
+    "!reactPlugin.ts!",
+    "!devOnlyGuard.ts!",
+  ],
+  "playwright": {
+    "config": ["playwright.config.ts"],
+    "entry": ["e2e/**/*.@(spec|setup).ts"],
+  },
+}
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 3fa176cc..880bebdb 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -23,6 +23,8 @@
         "react-i18next": "^15.7.4"
       },
       "devDependencies": {
+        "@babel/core": "7.29.7",
+        "@eslint-community/eslint-plugin-eslint-comments": "4.8.1",
         "@eslint/js": "9.39.1",
         "@playwright/test": "^1.61.1",
         "@tailwindcss/postcss": "^4.3.3",
@@ -31,9 +33,12 @@
         "@types/react": "19.3.0",
         "@types/react-dom": "19.3.0",
         "@vitejs/plugin-react": "^4.3.1",
+        "@vitest/coverage-v8": "4.1.11",
+        "@vitest/eslint-plugin": "1.6.27",
         "babel-plugin-react-compiler": "1.0.0",
         "eslint": "9.39.1",
         "eslint-config-prettier": "10.1.8",
+        "eslint-plugin-playwright": "2.12.0",
         "eslint-plugin-react-hooks": "7.1.1",
         "eslint-plugin-react-refresh": "0.4.24",
         "globals": "16.5.0",
@@ -41,11 +46,12 @@
         "knip": "6.27.0",
         "postcss": "^8.4.39",
         "prettier": "3.6.2",
+        "smol-toml": "1.9.0",
         "tailwindcss": "^4.3.3",
         "typescript": "^5.5.3",
-        "typescript-eslint": "8.46.0",
-        "vite": "^5.3.4",
-        "vitest": "^3.2.7"
+        "typescript-eslint": "8.71.0",
+        "vite": "^6.4.3",
+        "vitest": "^4.1.11"
       },
       "engines": {
         "node": "24.x"
@@ -376,6 +382,16 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@bcoe/v8-coverage": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz",
+      "integrity": "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@csstools/color-helpers": {
       "version": "5.1.0",
       "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-5.1.0.tgz",
@@ -579,9 +595,9 @@
       }
     },
     "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",
+      "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==",
       "cpu": [
         "ppc64"
       ],
@@ -592,13 +608,13 @@
         "aix"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/android-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
-      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",
+      "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==",
       "cpu": [
         "arm"
       ],
@@ -609,13 +625,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/android-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
-      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",
+      "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==",
       "cpu": [
         "arm64"
       ],
@@ -626,13 +642,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/android-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
-      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",
+      "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==",
       "cpu": [
         "x64"
       ],
@@ -643,13 +659,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
-      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",
+      "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==",
       "cpu": [
         "arm64"
       ],
@@ -660,13 +676,13 @@
         "darwin"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/darwin-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
-      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",
+      "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==",
       "cpu": [
         "x64"
       ],
@@ -677,13 +693,13 @@
         "darwin"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
-      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==",
       "cpu": [
         "arm64"
       ],
@@ -694,13 +710,13 @@
         "freebsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
-      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",
+      "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==",
       "cpu": [
         "x64"
       ],
@@ -711,13 +727,13 @@
         "freebsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
-      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",
+      "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==",
       "cpu": [
         "arm"
       ],
@@ -728,13 +744,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
-      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",
+      "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==",
       "cpu": [
         "arm64"
       ],
@@ -745,13 +761,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
-      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",
+      "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==",
       "cpu": [
         "ia32"
       ],
@@ -762,13 +778,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-loong64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
-      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",
+      "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==",
       "cpu": [
         "loong64"
       ],
@@ -779,13 +795,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
-      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",
+      "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==",
       "cpu": [
         "mips64el"
       ],
@@ -796,13 +812,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",
+      "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==",
       "cpu": [
         "ppc64"
       ],
@@ -813,13 +829,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
-      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",
+      "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==",
       "cpu": [
         "riscv64"
       ],
@@ -830,13 +846,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-s390x": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
-      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",
+      "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==",
       "cpu": [
         "s390x"
       ],
@@ -847,13 +863,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
-      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",
+      "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==",
       "cpu": [
         "x64"
       ],
@@ -864,13 +880,30 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==",
       "cpu": [
         "x64"
       ],
@@ -881,13 +914,30 @@
         "netbsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==",
       "cpu": [
         "x64"
       ],
@@ -898,13 +948,30 @@
         "openbsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",
+      "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/sunos-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
-      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",
+      "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==",
       "cpu": [
         "x64"
       ],
@@ -915,13 +982,13 @@
         "sunos"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/win32-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
-      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",
+      "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==",
       "cpu": [
         "arm64"
       ],
@@ -932,13 +999,13 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/win32-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
-      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",
+      "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==",
       "cpu": [
         "ia32"
       ],
@@ -949,13 +1016,13 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/win32-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
-      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",
+      "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==",
       "cpu": [
         "x64"
       ],
@@ -966,7 +1033,37 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@eslint-community/eslint-plugin-eslint-comments": {
+      "version": "4.8.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-plugin-eslint-comments/-/eslint-plugin-eslint-comments-4.8.1.tgz",
+      "integrity": "sha512-vafrdi15JHBFh1qWOAucyJwlEEuhdoMof28jOdKdgnwZ7bXwd6v4wzHYSmAVLwnx0yc7bqAtfJ0EZQV1WAzV/Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "escape-string-regexp": "^4.0.0",
+        "ignore": "^7.0.5"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0 || ^10.0.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-plugin-eslint-comments/node_modules/ignore": {
+      "version": "7.0.12",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.12.tgz",
+      "integrity": "sha512-/8UvqAPU9DGTI9k4mxtf49U37Isfwr8Uts96+SBHIkFxPJnHS0Ew4f00sM4Scd8V8EjM0jUNtVDdv1kPdt35lg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
       }
     },
     "node_modules/@eslint-community/eslint-utils": {
@@ -1327,44 +1424,6 @@
         "@emnapi/runtime": "^1.7.1"
       }
     },
-    "node_modules/@nodelib/fs.scandir": {
-      "version": "2.1.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
-      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.stat": "2.0.5",
-        "run-parallel": "^1.1.9"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nodelib/fs.stat": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
-      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nodelib/fs.walk": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
-      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.scandir": "2.1.5",
-        "fastq": "^1.6.0"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
     "node_modules/@oxc-parser/binding-android-arm-eabi": {
       "version": "0.137.0",
       "resolved": "https://registry.npmjs.org/@oxc-parser/binding-android-arm-eabi/-/binding-android-arm-eabi-0.137.0.tgz",
@@ -2432,6 +2491,13 @@
         "win32"
       ]
     },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@tailwindcss/node": {
       "version": "4.3.3",
       "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.3.3.tgz",
@@ -2944,21 +3010,20 @@
       }
     },
     "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "8.46.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.46.0.tgz",
-      "integrity": "sha512-hA8gxBq4ukonVXPy0OKhiaUh/68D0E88GSmtC1iAEnGaieuDi38LhS7jdCHRLi6ErJBNDGCzvh5EnzdPwUc0DA==",
+      "version": "8.71.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.71.0.tgz",
+      "integrity": "sha512-pqcS9c1HxZTHt7End4nXqd0s5lJrrFzrgCkKFJrsbUnaL6M3+6oBFZaslg6Gjsl3argl2DDRFROnXARaZ2e4Nw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@eslint-community/regexpp": "^4.10.0",
-        "@typescript-eslint/scope-manager": "8.46.0",
-        "@typescript-eslint/type-utils": "8.46.0",
-        "@typescript-eslint/utils": "8.46.0",
-        "@typescript-eslint/visitor-keys": "8.46.0",
-        "graphemer": "^1.4.0",
-        "ignore": "^7.0.0",
+        "@eslint-community/regexpp": "^4.12.2",
+        "@typescript-eslint/scope-manager": "8.71.0",
+        "@typescript-eslint/type-utils": "8.71.0",
+        "@typescript-eslint/utils": "8.71.0",
+        "@typescript-eslint/visitor-keys": "8.71.0",
+        "ignore": "^7.0.5",
         "natural-compare": "^1.4.0",
-        "ts-api-utils": "^2.1.0"
+        "ts-api-utils": "^2.5.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2968,9 +3033,9 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "@typescript-eslint/parser": "^8.46.0",
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "@typescript-eslint/parser": "^8.71.0",
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": {
@@ -2984,17 +3049,17 @@
       }
     },
     "node_modules/@typescript-eslint/parser": {
-      "version": "8.46.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.46.0.tgz",
-      "integrity": "sha512-n1H6IcDhmmUEG7TNVSspGmiHHutt7iVKtZwRppD7e04wha5MrkV1h3pti9xQLcCMt6YWsncpoT0HMjkH1FNwWQ==",
+      "version": "8.71.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.71.0.tgz",
+      "integrity": "sha512-CG4nPk1f2zc8yw4pALqHsFYH2hdo+h1T9daSp21+Hnxi9LOE3GT9hAfTKJCBXVNM2GmYs1eMEP615wPoeOgk3A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/scope-manager": "8.46.0",
-        "@typescript-eslint/types": "8.46.0",
-        "@typescript-eslint/typescript-estree": "8.46.0",
-        "@typescript-eslint/visitor-keys": "8.46.0",
-        "debug": "^4.3.4"
+        "@typescript-eslint/scope-manager": "8.71.0",
+        "@typescript-eslint/types": "8.71.0",
+        "@typescript-eslint/typescript-estree": "8.71.0",
+        "@typescript-eslint/visitor-keys": "8.71.0",
+        "debug": "^4.4.3"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3004,20 +3069,20 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/@typescript-eslint/project-service": {
-      "version": "8.46.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.46.0.tgz",
-      "integrity": "sha512-OEhec0mH+U5Je2NZOeK1AbVCdm0ChyapAyTeXVIYTPXDJ3F07+cu87PPXcGoYqZ7M9YJVvFnfpGg1UmCIqM+QQ==",
+      "version": "8.71.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.71.0.tgz",
+      "integrity": "sha512-aABjw5rjBacYONVPaPiWOCjJu0vEF4a25iQuodlmQYL1trtLZ0X/y+2Vzl3BKI1odM4LnwLE1oUDXYp1wzx1TQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/tsconfig-utils": "^8.46.0",
-        "@typescript-eslint/types": "^8.46.0",
-        "debug": "^4.3.4"
+        "@typescript-eslint/tsconfig-utils": "^8.71.0",
+        "@typescript-eslint/types": "^8.71.0",
+        "debug": "^4.4.3"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3027,18 +3092,18 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "typescript": ">=4.8.4 <6.0.0"
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.46.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.46.0.tgz",
-      "integrity": "sha512-lWETPa9XGcBes4jqAMYD9fW0j4n6hrPtTJwWDmtqgFO/4HF4jmdH/Q6wggTw5qIT5TXjKzbt7GsZUBnWoO3dqw==",
+      "version": "8.71.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.71.0.tgz",
+      "integrity": "sha512-gWF0BhUcnjZxSpLE8ngS/59n2SB0J3YqRxvX1+2aoRJk9hNtHSLOV+TcarFiOr5ipXm3yc1QrI4c9YZc8zyCxw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.46.0",
-        "@typescript-eslint/visitor-keys": "8.46.0"
+        "@typescript-eslint/types": "8.71.0",
+        "@typescript-eslint/visitor-keys": "8.71.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3049,9 +3114,9 @@
       }
     },
     "node_modules/@typescript-eslint/tsconfig-utils": {
-      "version": "8.46.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.46.0.tgz",
-      "integrity": "sha512-WrYXKGAHY836/N7zoK/kzi6p8tXFhasHh8ocFL9VZSAkvH956gfeRfcnhs3xzRy8qQ/dq3q44v1jvQieMFg2cw==",
+      "version": "8.71.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.71.0.tgz",
+      "integrity": "sha512-Z1UlWHADEK2Mlb9NpWfDeSjqoZ5EyrOv4R3eQpbkzqn/EwaIdOpXXupEA1+0ZIOSJSZZDBHG0BrQyN8zUG6Pwg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -3062,21 +3127,21 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "typescript": ">=4.8.4 <6.0.0"
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/@typescript-eslint/type-utils": {
-      "version": "8.46.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.46.0.tgz",
-      "integrity": "sha512-hy+lvYV1lZpVs2jRaEYvgCblZxUoJiPyCemwbQZ+NGulWkQRy0HRPYAoef/CNSzaLt+MLvMptZsHXHlkEilaeg==",
+      "version": "8.71.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.71.0.tgz",
+      "integrity": "sha512-i8uO1qbdxeKgRnS5sCRt6On3/nfo2d2DwQe3Yvjx543zLy7r8ySqRuPPiIIXAhS03U0v5NfAFx+rUgxFzKKwNw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.46.0",
-        "@typescript-eslint/typescript-estree": "8.46.0",
-        "@typescript-eslint/utils": "8.46.0",
-        "debug": "^4.3.4",
-        "ts-api-utils": "^2.1.0"
+        "@typescript-eslint/types": "8.71.0",
+        "@typescript-eslint/typescript-estree": "8.71.0",
+        "@typescript-eslint/utils": "8.71.0",
+        "debug": "^4.4.3",
+        "ts-api-utils": "^2.5.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3086,14 +3151,14 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/@typescript-eslint/types": {
-      "version": "8.46.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.46.0.tgz",
-      "integrity": "sha512-bHGGJyVjSE4dJJIO5yyEWt/cHyNwga/zXGJbJJ8TiO01aVREK6gCTu3L+5wrkb1FbDkQ+TKjMNe9R/QQQP9+rA==",
+      "version": "8.71.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.71.0.tgz",
+      "integrity": "sha512-cJ4OoxPGWvFnBTnSZyaU+qJzGTqPTGJY+gDchj6cRyLRdmIdt4rcsE4twj+zPfrNiWuVi38wijHzShL++Z9atQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -3105,22 +3170,21 @@
       }
     },
     "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.46.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.46.0.tgz",
-      "integrity": "sha512-ekDCUfVpAKWJbRfm8T1YRrCot1KFxZn21oV76v5Fj4tr7ELyk84OS+ouvYdcDAwZL89WpEkEj2DKQ+qg//+ucg==",
+      "version": "8.71.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.71.0.tgz",
+      "integrity": "sha512-PEEF4G5sLLWAS5BpPrUvms4ySZkiBQQZM4z+3ReI46axK5Vqr/vXBQatJQIZZOYdGyPUAKTtsrWzpqKuU+3DEw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/project-service": "8.46.0",
-        "@typescript-eslint/tsconfig-utils": "8.46.0",
-        "@typescript-eslint/types": "8.46.0",
-        "@typescript-eslint/visitor-keys": "8.46.0",
-        "debug": "^4.3.4",
-        "fast-glob": "^3.3.2",
-        "is-glob": "^4.0.3",
-        "minimatch": "^9.0.4",
-        "semver": "^7.6.0",
-        "ts-api-utils": "^2.1.0"
+        "@typescript-eslint/project-service": "8.71.0",
+        "@typescript-eslint/tsconfig-utils": "8.71.0",
+        "@typescript-eslint/types": "8.71.0",
+        "@typescript-eslint/visitor-keys": "8.71.0",
+        "debug": "^4.4.3",
+        "minimatch": "^10.2.2",
+        "semver": "^7.7.3",
+        "tinyglobby": "^0.2.15",
+        "ts-api-utils": "^2.5.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3130,30 +3194,43 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "typescript": ">=4.8.4 <6.0.0"
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
       }
     },
     "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.2.tgz",
-      "integrity": "sha512-w5JZcKgdhDOgOwm8H+KgbosopHMuGcl6qbulwjtz3SM7I7P3yW1eAjzMPLrIE+NQ9vjgANKHWeMHnrT0OXW1oA==",
+      "version": "5.0.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.12.tgz",
+      "integrity": "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "balanced-match": "^1.0.0"
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "20 || >=22"
       }
     },
     "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": {
-      "version": "9.0.9",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
-      "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+      "version": "10.2.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.6.tgz",
+      "integrity": "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==",
       "dev": true,
-      "license": "ISC",
+      "license": "BlueOak-1.0.0",
       "dependencies": {
-        "brace-expansion": "^2.0.2"
+        "brace-expansion": "^5.0.8"
       },
       "engines": {
-        "node": ">=16 || 14 >=14.17"
+        "node": "18 || 20 || >=22"
       },
       "funding": {
         "url": "https://github.com/sponsors/isaacs"
@@ -3173,16 +3250,16 @@
       }
     },
     "node_modules/@typescript-eslint/utils": {
-      "version": "8.46.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.46.0.tgz",
-      "integrity": "sha512-nD6yGWPj1xiOm4Gk0k6hLSZz2XkNXhuYmyIrOWcHoPuAhjT9i5bAG+xbWPgFeNR8HPHHtpNKdYUXJl/D3x7f5g==",
+      "version": "8.71.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.71.0.tgz",
+      "integrity": "sha512-pKR/tEMVrXZG23UFKUn5BQf3zfmfk7KQceI2cGzywZ5nxM5Eu3hEJU1utjWzydtzBbcJAQhHN8iPCxobHpPcZQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@eslint-community/eslint-utils": "^4.7.0",
-        "@typescript-eslint/scope-manager": "8.46.0",
-        "@typescript-eslint/types": "8.46.0",
-        "@typescript-eslint/typescript-estree": "8.46.0"
+        "@eslint-community/eslint-utils": "^4.9.1",
+        "@typescript-eslint/scope-manager": "8.71.0",
+        "@typescript-eslint/types": "8.71.0",
+        "@typescript-eslint/typescript-estree": "8.71.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3192,19 +3269,19 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.46.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.46.0.tgz",
-      "integrity": "sha512-FrvMpAK+hTbFy7vH5j1+tMYHMSKLE6RzluFJlkFNKD0p9YsUT75JlBSmr5so3QRzvMwU5/bIEdeNrxm8du8l3Q==",
+      "version": "8.71.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.71.0.tgz",
+      "integrity": "sha512-8eQ9R218XORK+KLosnf4bu/QsUXvUyVwTbArg7/0NMB1Pu87OJKvj4nhFblkYE8gQV73mW1dx1ptlPCkwRGa7A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.46.0",
-        "eslint-visitor-keys": "^4.2.1"
+        "@typescript-eslint/types": "8.71.0",
+        "eslint-visitor-keys": "^5.0.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3214,6 +3291,19 @@
         "url": "https://opencollective.com/typescript-eslint"
       }
     },
+    "node_modules/@typescript-eslint/visitor-keys/node_modules/eslint-visitor-keys": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz",
+      "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
     "node_modules/@vitejs/plugin-react": {
       "version": "4.7.0",
       "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
@@ -3235,40 +3325,103 @@
         "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
       }
     },
-    "node_modules/@vitest/expect": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.7.tgz",
-      "integrity": "sha512-E8eBXaKibuvH2pSZErOjdVb5vF4PbKYcrnluBTYxEk1l/VhhwZg1kZQsdtjq+CsF5CFydf2Rdkz7jDHKSisi3w==",
+    "node_modules/@vitest/coverage-v8": {
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-4.1.11.tgz",
+      "integrity": "sha512-8MVGEFnJIcdGjcbfKmeq8z0pZHH0JlVtoVZH9Q/qwUp6wyFnEJUBMrw9DCaj+ra3vShGmhavjalMIhPNxZAUcw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
+        "@bcoe/v8-coverage": "^1.0.2",
+        "@vitest/utils": "4.1.11",
+        "ast-v8-to-istanbul": "^1.0.0",
+        "istanbul-lib-coverage": "^3.2.2",
+        "istanbul-lib-report": "^3.0.1",
+        "istanbul-reports": "^3.2.0",
+        "magicast": "^0.5.2",
+        "obug": "^2.1.1",
+        "std-env": "^4.0.0-rc.1",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@vitest/browser": "4.1.11",
+        "vitest": "4.1.11"
+      },
+      "peerDependenciesMeta": {
+        "@vitest/browser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/eslint-plugin": {
+      "version": "1.6.27",
+      "resolved": "https://registry.npmjs.org/@vitest/eslint-plugin/-/eslint-plugin-1.6.27.tgz",
+      "integrity": "sha512-X1RCAfwbatG4GFbJ/1PIHP9MSZMt0JJThqbYID+vS4L783k6QGlLPe421wQE8dHXuGCcenVLsydiM4qzsYWxhg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/scope-manager": "^8.58.0",
+        "@typescript-eslint/utils": "^8.58.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@typescript-eslint/eslint-plugin": "*",
+        "eslint": ">=8.57.0",
+        "typescript": ">=5.0.0",
+        "vitest": "*"
+      },
+      "peerDependenciesMeta": {
+        "@typescript-eslint/eslint-plugin": {
+          "optional": true
+        },
+        "typescript": {
+          "optional": true
+        },
+        "vitest": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/expect": {
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.11.tgz",
+      "integrity": "sha512-VX2x5vNJXET47KAFzwERI+KRMtTTCSWTfSMKsW7JsUsXV4psq++e3DvZpuTDOpHcxytiDs6p2nhVb2tVDiiUYw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.1.0",
         "@types/chai": "^5.2.2",
-        "@vitest/spy": "3.2.7",
-        "@vitest/utils": "3.2.7",
-        "chai": "^5.2.0",
-        "tinyrainbow": "^2.0.0"
+        "@vitest/spy": "4.1.11",
+        "@vitest/utils": "4.1.11",
+        "chai": "^6.2.2",
+        "tinyrainbow": "^3.1.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/mocker": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-3.2.7.tgz",
-      "integrity": "sha512-Trr0hYO9CM3Wj6ksWHRhK9IZpIY6wTMO5u/MqXurMxT57sWBaOPEtP3Oq60ihZuh5JsiagKfz95OcxdEP6dBrA==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.11.tgz",
+      "integrity": "sha512-2XJVD55d1o5AZous5CCGKS74g/riOj9odEt2bQpCVZeblHyHdnMeFl4jl0XjU21stf4mbjUkew2eXQZt65g5CQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/spy": "3.2.7",
+        "@vitest/spy": "4.1.11",
         "estree-walker": "^3.0.3",
-        "magic-string": "^0.30.17"
+        "magic-string": "^0.30.21"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       },
       "peerDependencies": {
         "msw": "^2.4.9",
-        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
       },
       "peerDependenciesMeta": {
         "msw": {
@@ -3280,42 +3433,42 @@
       }
     },
     "node_modules/@vitest/pretty-format": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.7.tgz",
-      "integrity": "sha512-KUHlwqVu0sRlhCdyPdQ/wBoTfRahjUky1MubOmYw9fWfIZy1gNoHpuaaQBPAaMaVYdQYHJLurzj8ECCj5OwTqA==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.11.tgz",
+      "integrity": "sha512-yiZzPbGTS9Sr/JpFl8zHrcIkAofNbFV6k21vIgQN/cY/oxZeXhJv5sc/MBJ5jFKWmWs+oJHw0UXLZjmf931+Vw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "tinyrainbow": "^2.0.0"
+        "tinyrainbow": "^3.1.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/runner": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-3.2.7.tgz",
-      "integrity": "sha512-sB9y4ovltoQP+WaUPwmSxO9WIg9Ig694Di5PalVPsYHklAdE027mehpWF2SQSVq+k6sFgaivbTjTJwZLSHbedA==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.11.tgz",
+      "integrity": "sha512-LztvUgdwMNJMIkj3hQnnxiC2Xy1zNxq928W/xhjCLaNCzqTZOudjwbQf6v9IntZGPw132i2Lq2rgTRZHD3JHNw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/utils": "3.2.7",
-        "pathe": "^2.0.3",
-        "strip-literal": "^3.0.0"
+        "@vitest/utils": "4.1.11",
+        "pathe": "^2.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/snapshot": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-3.2.7.tgz",
-      "integrity": "sha512-7C+MwShwtBSI5Buwoyg3s/iY1eHL9PKAf+O1wVh/TdnjXUtkoL/9YQtre90i4MtNXM6edP1wJ2zOBpfCyhIS7g==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.11.tgz",
+      "integrity": "sha512-pN7ikn1ON7h8ee4gIAp4AzyK+zBtJPzVbqOgu5LCEh4VaJVbPQcgYQYJIMGQPXVeJJq1fnfazis7a5pFNPahog==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/pretty-format": "3.2.7",
-        "magic-string": "^0.30.17",
+        "@vitest/pretty-format": "4.1.11",
+        "@vitest/utils": "4.1.11",
+        "magic-string": "^0.30.21",
         "pathe": "^2.0.3"
       },
       "funding": {
@@ -3323,28 +3476,25 @@
       }
     },
     "node_modules/@vitest/spy": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.7.tgz",
-      "integrity": "sha512-Q2eQGI6d2L/hBtZ0qNuKcAGid68XK6cv1xsoaIma6PaJhHPoqcEJhYpXZ/5myCMqkNgtP6UKuBhbc0nHKnrkuQ==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.11.tgz",
+      "integrity": "sha512-apNa/prQy2qCeywhnixOHPRCgGNhvg7T4Dapfl1GahLp/R+uhBm5cPyFoNVyqsNd2h1nJxL6BqqdIjiABL60YA==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "tinyspy": "^4.0.3"
-      },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/utils": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.2.7.tgz",
-      "integrity": "sha512-x6BDOd7dyo3PFLY3I9/HJ25X/6OurhGXk2/B9gOZNPF7XDVjeBK4k01lQE5uvDpbuheErh91qYuE1E2OEjK3Rw==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.11.tgz",
+      "integrity": "sha512-zTCVGpyFsGWBhllOyKlTw/vnr6D9qxsfSDyfbyZmTyjHw5N/VuvzHpHoQjm2ZJzn4RJgx5w4r7V0er69CmLgPQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/pretty-format": "3.2.7",
-        "loupe": "^3.1.4",
-        "tinyrainbow": "^2.0.0"
+        "@vitest/pretty-format": "4.1.11",
+        "convert-source-map": "^2.0.0",
+        "tinyrainbow": "^3.1.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
@@ -3455,6 +3605,25 @@
         "node": ">=12"
       }
     },
+    "node_modules/ast-v8-to-istanbul": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/ast-v8-to-istanbul/-/ast-v8-to-istanbul-1.0.7.tgz",
+      "integrity": "sha512-kFL68AG6ajd8fg248zwM9GQrUWEp79gsmjum34OEXjs4yHuUMZfYKwOLW9GMmB4oNvVrj+EAGxsP7ye2UR9UlA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.31",
+        "estree-walker": "^3.0.3",
+        "js-tokens": "^10.0.0"
+      }
+    },
+    "node_modules/ast-v8-to-istanbul/node_modules/js-tokens": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-10.0.0.tgz",
+      "integrity": "sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/asynckit": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
@@ -3480,9 +3649,9 @@
       "license": "MIT"
     },
     "node_modules/baseline-browser-mapping": {
-      "version": "2.10.35",
-      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.35.tgz",
-      "integrity": "sha512-honAfLBde0HAFLdNyBEfuuENkF6zR+ozxqxa/2zJKHBe1qzLqyTSeRKpdPEHAP03rlDGyQOPnCSxnVpVqQo9Mg==",
+      "version": "2.11.27",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.27.tgz",
+      "integrity": "sha512-ElY12DaROGuan+lMmZ8Cvo/ZUbXPe7Enc/9VU/b1T3Kp4dwytRcNdR8DoSJN5SNJT/CuvcCA0DHDVmMOCePdRQ==",
       "dev": true,
       "license": "Apache-2.0",
       "bin": {
@@ -3493,9 +3662,9 @@
       }
     },
     "node_modules/brace-expansion": {
-      "version": "1.1.16",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.16.tgz",
-      "integrity": "sha512-IDw48K2/2kRkg9LdJxurvq3lV3aBgq0REY89duEqFRthjlPdXHKMj7EnQOXVckxzgisinf3nHfrcE2FufFLXMw==",
+      "version": "1.1.21",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.21.tgz",
+      "integrity": "sha512-9zeA+KLZNNzglF2TPKRQEDyx6Yby7daAkuy8MiPzpXPsYDWi/DRM8jmwUDxokQjYqBpv5DgPiwD4h4ZZSy1Ujw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -3503,23 +3672,10 @@
         "concat-map": "0.0.1"
       }
     },
-    "node_modules/braces": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
-      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fill-range": "^7.1.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/browserslist": {
-      "version": "4.28.2",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
-      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
+      "version": "4.29.3",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.29.3.tgz",
+      "integrity": "sha512-1R4kiYKXGViqEN0CnoDrXc1StD9niAwu+j2dukWzrD4bJgsD4lDmEp0CRbc6E/vYJIfTHwPmwyaKtVSudICdPA==",
       "dev": true,
       "funding": [
         {
@@ -3537,11 +3693,11 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "baseline-browser-mapping": "^2.10.12",
-        "caniuse-lite": "^1.0.30001782",
-        "electron-to-chromium": "^1.5.328",
-        "node-releases": "^2.0.36",
-        "update-browserslist-db": "^1.2.3"
+        "baseline-browser-mapping": "^2.11.26",
+        "caniuse-lite": "^1.0.30001813",
+        "electron-to-chromium": "^1.5.439",
+        "node-releases": "^2.0.57",
+        "update-browserslist-db": "^1.3.3"
       },
       "bin": {
         "browserslist": "cli.js"
@@ -3550,16 +3706,6 @@
         "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
       }
     },
-    "node_modules/cac": {
-      "version": "6.7.14",
-      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
-      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/call-bind-apply-helpers": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
@@ -3585,9 +3731,9 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001799",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001799.tgz",
-      "integrity": "sha512-hG1bReV+OUU+MOqK4t/ZWI0tZOyz3rqS9XuhOUz1cIcbwBKjOyJEJuw9ER5JuNyqxNk8u/JUVbGibBOL1yrjFw==",
+      "version": "1.0.30001814",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001814.tgz",
+      "integrity": "sha512-/Uaf1lAzr59XcMpW0o96WoEfr+VXK2OX4U9AgFoiSHsVJ4HppnIFUjtYzsyDH2+tgANaQb2/oxYGwCPapN1FpA==",
       "dev": true,
       "funding": [
         {
@@ -3606,18 +3752,11 @@
       "license": "CC-BY-4.0"
     },
     "node_modules/chai": {
-      "version": "5.3.3",
-      "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
-      "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-6.3.0.tgz",
+      "integrity": "sha512-XWAtwJ6OHO+tj0EKCs0Y2UamnyOxseZWltU4x2U2wh8g4AigdjwvtUjvLP2tqkA/avxHEtzxNaqGq/YGNwckKg==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "assertion-error": "^2.0.1",
-        "check-error": "^2.1.1",
-        "deep-eql": "^5.0.1",
-        "loupe": "^3.1.0",
-        "pathval": "^2.0.0"
-      },
       "engines": {
         "node": ">=18"
       }
@@ -3639,16 +3778,6 @@
         "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
-    "node_modules/check-error": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz",
-      "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 16"
-      }
-    },
     "node_modules/clsx": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
@@ -3787,16 +3916,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/deep-eql": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
-      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -3859,9 +3978,9 @@
       }
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.371",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.371.tgz",
-      "integrity": "sha512-e9htk9mAYL6AzmkEhSvVVw7IWGSBJ/Bqdn2eRyRLrj1g6sncN4WbFt5qnILYoCktktr45pyjIrOiRvBThQ808w==",
+      "version": "1.5.444",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.444.tgz",
+      "integrity": "sha512-5ss/uJfoDYDHT0lfJzT6FbcskIzROIOPf0BbbFkGcvDzoJU7i//9GDrwwIHQVmIsrAGiF3ihpADBRIsrEFt1rQ==",
       "dev": true,
       "license": "ISC"
     },
@@ -3913,9 +4032,9 @@
       }
     },
     "node_modules/es-module-lexer": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
-      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.2.tgz",
+      "integrity": "sha512-poHGpORABojJJucnV9KbOavETW8lBVnphkW77ER5/BQ5Fz7oXSoCNek7IH3vR5nRjdsEz926ibFYX8KtLQmdyw==",
       "dev": true,
       "license": "MIT"
     },
@@ -3949,9 +4068,9 @@
       }
     },
     "node_modules/esbuild": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
-      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",
+      "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==",
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
@@ -3959,32 +4078,35 @@
         "esbuild": "bin/esbuild"
       },
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       },
       "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.21.5",
-        "@esbuild/android-arm": "0.21.5",
-        "@esbuild/android-arm64": "0.21.5",
-        "@esbuild/android-x64": "0.21.5",
-        "@esbuild/darwin-arm64": "0.21.5",
-        "@esbuild/darwin-x64": "0.21.5",
-        "@esbuild/freebsd-arm64": "0.21.5",
-        "@esbuild/freebsd-x64": "0.21.5",
-        "@esbuild/linux-arm": "0.21.5",
-        "@esbuild/linux-arm64": "0.21.5",
-        "@esbuild/linux-ia32": "0.21.5",
-        "@esbuild/linux-loong64": "0.21.5",
-        "@esbuild/linux-mips64el": "0.21.5",
-        "@esbuild/linux-ppc64": "0.21.5",
-        "@esbuild/linux-riscv64": "0.21.5",
-        "@esbuild/linux-s390x": "0.21.5",
-        "@esbuild/linux-x64": "0.21.5",
-        "@esbuild/netbsd-x64": "0.21.5",
-        "@esbuild/openbsd-x64": "0.21.5",
-        "@esbuild/sunos-x64": "0.21.5",
-        "@esbuild/win32-arm64": "0.21.5",
-        "@esbuild/win32-ia32": "0.21.5",
-        "@esbuild/win32-x64": "0.21.5"
+        "@esbuild/aix-ppc64": "0.25.12",
+        "@esbuild/android-arm": "0.25.12",
+        "@esbuild/android-arm64": "0.25.12",
+        "@esbuild/android-x64": "0.25.12",
+        "@esbuild/darwin-arm64": "0.25.12",
+        "@esbuild/darwin-x64": "0.25.12",
+        "@esbuild/freebsd-arm64": "0.25.12",
+        "@esbuild/freebsd-x64": "0.25.12",
+        "@esbuild/linux-arm": "0.25.12",
+        "@esbuild/linux-arm64": "0.25.12",
+        "@esbuild/linux-ia32": "0.25.12",
+        "@esbuild/linux-loong64": "0.25.12",
+        "@esbuild/linux-mips64el": "0.25.12",
+        "@esbuild/linux-ppc64": "0.25.12",
+        "@esbuild/linux-riscv64": "0.25.12",
+        "@esbuild/linux-s390x": "0.25.12",
+        "@esbuild/linux-x64": "0.25.12",
+        "@esbuild/netbsd-arm64": "0.25.12",
+        "@esbuild/netbsd-x64": "0.25.12",
+        "@esbuild/openbsd-arm64": "0.25.12",
+        "@esbuild/openbsd-x64": "0.25.12",
+        "@esbuild/openharmony-arm64": "0.25.12",
+        "@esbuild/sunos-x64": "0.25.12",
+        "@esbuild/win32-arm64": "0.25.12",
+        "@esbuild/win32-ia32": "0.25.12",
+        "@esbuild/win32-x64": "0.25.12"
       }
     },
     "node_modules/escalade": {
@@ -4086,6 +4208,35 @@
         "eslint": ">=7.0.0"
       }
     },
+    "node_modules/eslint-plugin-playwright": {
+      "version": "2.12.0",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-playwright/-/eslint-plugin-playwright-2.12.0.tgz",
+      "integrity": "sha512-7HpSKR/D2oCH4RKRauFskcrnDrHvLQKopW7Nen8lqrFZtx/SB+FgqVaH+zyQd32noZSZy9Lrsa+DsYrVUpn6hg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "globals": "^17.3.0"
+      },
+      "engines": {
+        "node": ">=16.9.0"
+      },
+      "peerDependencies": {
+        "eslint": ">=8.40.0"
+      }
+    },
+    "node_modules/eslint-plugin-playwright/node_modules/globals": {
+      "version": "17.13.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-17.13.0.tgz",
+      "integrity": "sha512-RwMTC61u7hrG3ZJMkZQOK4JLJrKS8QtoTii63EmWvFXHqycY9FObBJQCbsLxSO8kjKhWE5kV1GC+Vb1g3RI0Zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/eslint-plugin-react-hooks": {
       "version": "7.1.1",
       "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-7.1.1.tgz",
@@ -4237,36 +4388,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/fast-glob": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
-      "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.stat": "^2.0.2",
-        "@nodelib/fs.walk": "^1.2.3",
-        "glob-parent": "^5.1.2",
-        "merge2": "^1.3.0",
-        "micromatch": "^4.0.8"
-      },
-      "engines": {
-        "node": ">=8.6.0"
-      }
-    },
-    "node_modules/fast-glob/node_modules/glob-parent": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
-      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.1"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
     "node_modules/fast-json-stable-stringify": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
@@ -4281,16 +4402,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/fastq": {
-      "version": "1.20.1",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz",
-      "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "reusify": "^1.0.4"
-      }
-    },
     "node_modules/fd-package-json": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/fd-package-json/-/fd-package-json-2.0.0.tgz",
@@ -4301,6 +4412,24 @@
         "walk-up-path": "^4.0.0"
       }
     },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/file-entry-cache": {
       "version": "8.0.0",
       "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
@@ -4314,19 +4443,6 @@
         "node": ">=16.0.0"
       }
     },
-    "node_modules/fill-range": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
-      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "to-regex-range": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/find-up": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
@@ -4537,13 +4653,6 @@
       "dev": true,
       "license": "ISC"
     },
-    "node_modules/graphemer": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
-      "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/has-flag": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -4632,6 +4741,13 @@
         "node": ">=18"
       }
     },
+    "node_modules/html-escaper": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
+      "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/html-parse-stringify": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/html-parse-stringify/-/html-parse-stringify-3.0.1.tgz",
@@ -4765,16 +4881,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/is-number": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
-      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.12.0"
-      }
-    },
     "node_modules/is-potential-custom-element-name": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
@@ -4789,6 +4895,45 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/istanbul-lib-coverage": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",
+      "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/istanbul-lib-report": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",
+      "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "istanbul-lib-coverage": "^3.0.0",
+        "make-dir": "^4.0.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/istanbul-reports": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
+      "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "html-escaper": "^2.0.0",
+        "istanbul-lib-report": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/jiti": {
       "version": "2.7.0",
       "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.7.0.tgz",
@@ -4807,9 +4952,9 @@
       "license": "MIT"
     },
     "node_modules/js-yaml": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.0.tgz",
-      "integrity": "sha512-1td788aAnnZ5qs7V2QIRl1owjtYpbKt749Y3xauqQgwIIGF/xXWz1wMTEBx5O3LK3lXLVuqXPdPxj2BoFHaW9Q==",
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.2.tgz",
+      "integrity": "sha512-SFNOvSJ+Dgf/9An904Yx+CgSlIPCkIpao4qo51lpee25TIRejdH3rhR4EZMGoNx3/TP3O+wzWuiTFl4sqbltzA==",
       "dev": true,
       "funding": [
         {
@@ -4966,37 +5111,6 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/knip/node_modules/fdir": {
-      "version": "6.5.0",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
-      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.0.0"
-      },
-      "peerDependencies": {
-        "picomatch": "^3 || ^4"
-      },
-      "peerDependenciesMeta": {
-        "picomatch": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/knip/node_modules/picomatch": {
-      "version": "4.0.5",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",
-      "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
     "node_modules/levn": {
       "version": "0.4.1",
       "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
@@ -5307,13 +5421,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/loupe": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
-      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/lru-cache": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -5354,6 +5461,47 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
+    "node_modules/magicast": {
+      "version": "0.5.5",
+      "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.5.5.tgz",
+      "integrity": "sha512-UicdXN8zQ3JHlxVq+28afMXPr1z7WNY6+7EJnzTdQWkTAlMLF5fNCCKxJHBQwGaNGR11581EiQmQzx73+MvszA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/make-dir": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz",
+      "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/make-dir/node_modules/semver": {
+      "version": "7.8.5",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
+      "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/math-intrinsics": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
@@ -5364,30 +5512,6 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/merge2": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
-      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/micromatch": {
-      "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
-      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "braces": "^3.0.3",
-        "picomatch": "^2.3.1"
-      },
-      "engines": {
-        "node": ">=8.6"
-      }
-    },
     "node_modules/mime-db": {
       "version": "1.52.0",
       "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
@@ -5458,9 +5582,9 @@
       "license": "MIT"
     },
     "node_modules/node-releases": {
-      "version": "2.0.47",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.47.tgz",
-      "integrity": "sha512-Uzmd6LXpouKo8EUK68IjH4+E01w/hXyV3R3g/geCJo+rXLNfh1xucB+LOzYEOQPSiUK3h/xZf0cQGcSsmyL2Og==",
+      "version": "2.0.57",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.57.tgz",
+      "integrity": "sha512-kQK9LGGFiHtrWiNhZtA7Qbw17AQz+dmsEKODRIVTXA9+e5MS/2gZEBhYJt13GrAz5/IOZKddH/0Z3TP/Zgo+yw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -5474,6 +5598,20 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/obug": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.2.1.tgz",
+      "integrity": "sha512-XrsrhT5sybtKI6wakr2SPOlGZWWYbUXZ7a0jT8/QOeAPau+1X/bSegNe5YR75oJmEZQbKningirmGOEJCIk61Q==",
+      "dev": true,
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -5646,16 +5784,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/pathval": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
-      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14.16"
-      }
-    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -5664,13 +5792,13 @@
       "license": "ISC"
     },
     "node_modules/picomatch": {
-      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
-      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz",
+      "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=8.6"
+        "node": ">=12"
       },
       "funding": {
         "url": "https://github.com/sponsors/jonschlinkert"
@@ -5818,27 +5946,6 @@
         "node": ">=6"
       }
     },
-    "node_modules/queue-microtask": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
-      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT"
-    },
     "node_modules/react": {
       "version": "19.3.0",
       "resolved": "https://registry.npmjs.org/react/-/react-19.3.0.tgz",
@@ -5924,17 +6031,6 @@
         "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
       }
     },
-    "node_modules/reusify": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
-      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "iojs": ">=1.0.0",
-        "node": ">=0.10.0"
-      }
-    },
     "node_modules/rollup": {
       "version": "4.61.1",
       "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.61.1.tgz",
@@ -5987,30 +6083,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/run-parallel": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
-      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "queue-microtask": "^1.2.2"
-      }
-    },
     "node_modules/safer-buffer": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
@@ -6078,9 +6150,9 @@
       "license": "ISC"
     },
     "node_modules/smol-toml": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.7.0.tgz",
-      "integrity": "sha512-aqVvWoyO21L23mb+drl4RmMXbf6N7FdHjAhTRA9ZBL7apWBgfWC16KjrASI+1p9GAroljyMHj6fK67i0UiTNvQ==",
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.9.0.tgz",
+      "integrity": "sha512-hpd+HLON7HdZXqYchMM/+LaTTbdK0AU3NngIJ4KVyWbY9bfQqdL9cD+4yf6dUoU2Ap4VsU0JkQi6FxAI1B2mXQ==",
       "dev": true,
       "license": "BSD-3-Clause",
       "engines": {
@@ -6108,9 +6180,9 @@
       "license": "MIT"
     },
     "node_modules/std-env": {
-      "version": "3.10.0",
-      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
-      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.3.0.tgz",
+      "integrity": "sha512-OtU/EgQ1kIm5KwqQpBC6ZEMXrZRui11w8zgfTWp8cdO9B8OaPsbA8bTHO2P+HNo1VlUTGMVBwPhydu6poeXiag==",
       "dev": true,
       "license": "MIT"
     },
@@ -6127,26 +6199,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/strip-literal": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.1.0.tgz",
-      "integrity": "sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "js-tokens": "^9.0.1"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/antfu"
-      }
-    },
-    "node_modules/strip-literal/node_modules/js-tokens": {
-      "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz",
-      "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/supports-color": {
       "version": "7.2.0",
       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
@@ -6202,11 +6254,14 @@
       "license": "MIT"
     },
     "node_modules/tinyexec": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
-      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.3.1.tgz",
+      "integrity": "sha512-GCvB3aoys96IuDFBMcTB46JOR6mdMtAToqwiW8JlWhsoh1mhHi/xn9ss/Dg7N555GiJyEt2qzoG/NHCwM6h1EA==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
     },
     "node_modules/tinyglobby": {
       "version": "0.2.17",
@@ -6225,61 +6280,10 @@
         "url": "https://github.com/sponsors/SuperchupuDev"
       }
     },
-    "node_modules/tinyglobby/node_modules/fdir": {
-      "version": "6.5.0",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
-      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.0.0"
-      },
-      "peerDependencies": {
-        "picomatch": "^3 || ^4"
-      },
-      "peerDependenciesMeta": {
-        "picomatch": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/tinyglobby/node_modules/picomatch": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
-      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
-    "node_modules/tinypool": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
-      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      }
-    },
     "node_modules/tinyrainbow": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz",
-      "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.0.0"
-      }
-    },
-    "node_modules/tinyspy": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.4.tgz",
-      "integrity": "sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.2.0.tgz",
+      "integrity": "sha512-LgO3D9yZJjApUiuUfl9iFAwrtaX4+lok3wJIqttGoKCHlWUqHqbQpnxCf82L8FjgKsh4iGo78hqJwgL8F6To2A==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -6306,19 +6310,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/to-regex-range": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
-      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-number": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=8.0"
-      }
-    },
     "node_modules/tough-cookie": {
       "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-5.1.2.tgz",
@@ -6392,16 +6383,16 @@
       }
     },
     "node_modules/typescript-eslint": {
-      "version": "8.46.0",
-      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.46.0.tgz",
-      "integrity": "sha512-6+ZrB6y2bT2DX3K+Qd9vn7OFOJR+xSLDj+Aw/N3zBwUt27uTw2sw2TE2+UcY1RiyBZkaGbTkVg9SSdPNUG6aUw==",
+      "version": "8.71.0",
+      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.71.0.tgz",
+      "integrity": "sha512-fBdHYiqQ14RW6mOMXD14Svn82ZsCYAoQSzGRzyEjR59S5A2Krh/l7fGTOQ7iCr8gGy/mHVXtEF7s5fgjEdV0Pw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/eslint-plugin": "8.46.0",
-        "@typescript-eslint/parser": "8.46.0",
-        "@typescript-eslint/typescript-estree": "8.46.0",
-        "@typescript-eslint/utils": "8.46.0"
+        "@typescript-eslint/eslint-plugin": "8.71.0",
+        "@typescript-eslint/parser": "8.71.0",
+        "@typescript-eslint/typescript-estree": "8.71.0",
+        "@typescript-eslint/utils": "8.71.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -6411,8 +6402,8 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/unbash": {
@@ -6433,9 +6424,9 @@
       "license": "MIT"
     },
     "node_modules/update-browserslist-db": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
-      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.3.tgz",
+      "integrity": "sha512-pJ2sYawQS0R/WI928Gj5GlPhTGzbMelq0+4INtSYNDV9ErKJcX6xjGWkoG/VnB3dpUm00zALaqkrUD77pO5TDQ==",
       "dev": true,
       "funding": [
         {
@@ -6474,21 +6465,24 @@
       }
     },
     "node_modules/vite": {
-      "version": "5.4.21",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
-      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "version": "6.4.3",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.3.tgz",
+      "integrity": "sha512-NTKlcQjlAK7MlQoyb6LgaqHc8sso/pVyUJYWMws3jg21uTJw/LddqIFPcPqP6PzpgbIcZyKI85sFE4HBrQDA8A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "esbuild": "^0.21.3",
-        "postcss": "^8.4.43",
-        "rollup": "^4.20.0"
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2",
+        "postcss": "^8.5.3",
+        "rollup": "^4.34.9",
+        "tinyglobby": "^0.2.13"
       },
       "bin": {
         "vite": "bin/vite.js"
       },
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
       },
       "funding": {
         "url": "https://github.com/vitejs/vite?sponsor=1"
@@ -6497,19 +6491,25 @@
         "fsevents": "~2.3.3"
       },
       "peerDependencies": {
-        "@types/node": "^18.0.0 || >=20.0.0",
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "jiti": ">=1.21.0",
         "less": "*",
         "lightningcss": "^1.21.0",
         "sass": "*",
         "sass-embedded": "*",
         "stylus": "*",
         "sugarss": "*",
-        "terser": "^5.4.0"
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
       },
       "peerDependenciesMeta": {
         "@types/node": {
           "optional": true
         },
+        "jiti": {
+          "optional": true
+        },
         "less": {
           "optional": true
         },
@@ -6530,92 +6530,89 @@
         },
         "terser": {
           "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
         }
       }
     },
-    "node_modules/vite-node": {
-      "version": "3.2.4",
-      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.2.4.tgz",
-      "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cac": "^6.7.14",
-        "debug": "^4.4.1",
-        "es-module-lexer": "^1.7.0",
-        "pathe": "^2.0.3",
-        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
-      },
-      "bin": {
-        "vite-node": "vite-node.mjs"
-      },
-      "engines": {
-        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
-    },
     "node_modules/vitest": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.7.tgz",
-      "integrity": "sha512-KrxIJ62Fd89gfysR4WotlgZABiz2dqFPgqGzX7s+CwsqLFomRH7777ZcrOD6+WVAh7khPQP41A+BKbpcJFrdEg==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.11.tgz",
+      "integrity": "sha512-fhACrNXUidIbGSBr5FlbuBkO7VWC1ZyLl0DO4CU2DrQoAPxX84Ysxs+HeGQpii5lZWV1Q4gBZTTu49mF+A6Edw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@types/chai": "^5.2.2",
-        "@vitest/expect": "3.2.7",
-        "@vitest/mocker": "3.2.7",
-        "@vitest/pretty-format": "^3.2.7",
-        "@vitest/runner": "3.2.7",
-        "@vitest/snapshot": "3.2.7",
-        "@vitest/spy": "3.2.7",
-        "@vitest/utils": "3.2.7",
-        "chai": "^5.2.0",
-        "debug": "^4.4.1",
-        "expect-type": "^1.2.1",
-        "magic-string": "^0.30.17",
+        "@vitest/expect": "4.1.11",
+        "@vitest/mocker": "4.1.11",
+        "@vitest/pretty-format": "4.1.11",
+        "@vitest/runner": "4.1.11",
+        "@vitest/snapshot": "4.1.11",
+        "@vitest/spy": "4.1.11",
+        "@vitest/utils": "4.1.11",
+        "es-module-lexer": "^2.0.0",
+        "expect-type": "^1.3.0",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.1",
         "pathe": "^2.0.3",
-        "picomatch": "^4.0.2",
-        "std-env": "^3.9.0",
+        "picomatch": "^4.0.3",
+        "std-env": "^4.0.0-rc.1",
         "tinybench": "^2.9.0",
-        "tinyexec": "^0.3.2",
-        "tinyglobby": "^0.2.14",
-        "tinypool": "^1.1.1",
-        "tinyrainbow": "^2.0.0",
-        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0",
-        "vite-node": "3.2.4",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.1.0",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
         "why-is-node-running": "^2.3.0"
       },
       "bin": {
         "vitest": "vitest.mjs"
       },
       "engines": {
-        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       },
       "peerDependencies": {
         "@edge-runtime/vm": "*",
-        "@types/debug": "^4.1.12",
-        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
-        "@vitest/browser": "3.2.7",
-        "@vitest/ui": "3.2.7",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/browser-playwright": "4.1.11",
+        "@vitest/browser-preview": "4.1.11",
+        "@vitest/browser-webdriverio": "4.1.11",
+        "@vitest/coverage-istanbul": "4.1.11",
+        "@vitest/coverage-v8": "4.1.11",
+        "@vitest/ui": "4.1.11",
         "happy-dom": "*",
-        "jsdom": "*"
+        "jsdom": "*",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
       },
       "peerDependenciesMeta": {
         "@edge-runtime/vm": {
           "optional": true
         },
-        "@types/debug": {
+        "@opentelemetry/api": {
           "optional": true
         },
         "@types/node": {
           "optional": true
         },
-        "@vitest/browser": {
+        "@vitest/browser-playwright": {
+          "optional": true
+        },
+        "@vitest/browser-preview": {
+          "optional": true
+        },
+        "@vitest/browser-webdriverio": {
+          "optional": true
+        },
+        "@vitest/coverage-istanbul": {
+          "optional": true
+        },
+        "@vitest/coverage-v8": {
           "optional": true
         },
         "@vitest/ui": {
@@ -6626,22 +6623,12 @@
         },
         "jsdom": {
           "optional": true
+        },
+        "vite": {
+          "optional": false
         }
       }
     },
-    "node_modules/vitest/node_modules/picomatch": {
-      "version": "4.0.5",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",
-      "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
     "node_modules/void-elements": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/void-elements/-/void-elements-3.1.0.tgz",
diff --git a/frontend/package.json b/frontend/package.json
index fc8a554e..6cf9f47e 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -14,7 +14,7 @@
     "typecheck:e2e": "tsc --noEmit -p e2e/tsconfig.json",
     "build": "npm run typecheck:app && npm run typecheck:node && vite build",
     "preview": "vite preview",
-    "knip": "knip",
+    "knip": "knip && knip --production",
     "lint": "eslint . --max-warnings 0",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
@@ -39,6 +39,8 @@
     "react-i18next": "^15.7.4"
   },
   "devDependencies": {
+    "@babel/core": "7.29.7",
+    "@eslint-community/eslint-plugin-eslint-comments": "4.8.1",
     "@eslint/js": "9.39.1",
     "@playwright/test": "^1.61.1",
     "@tailwindcss/postcss": "^4.3.3",
@@ -47,9 +49,12 @@
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",
     "@vitejs/plugin-react": "^4.3.1",
+    "@vitest/coverage-v8": "4.1.11",
+    "@vitest/eslint-plugin": "1.6.27",
     "babel-plugin-react-compiler": "1.0.0",
     "eslint": "9.39.1",
     "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-playwright": "2.12.0",
     "eslint-plugin-react-hooks": "7.1.1",
     "eslint-plugin-react-refresh": "0.4.24",
     "globals": "16.5.0",
@@ -57,10 +62,11 @@
     "knip": "6.27.0",
     "postcss": "^8.4.39",
     "prettier": "3.6.2",
+    "smol-toml": "1.9.0",
     "tailwindcss": "^4.3.3",
     "typescript": "^5.5.3",
-    "typescript-eslint": "8.46.0",
-    "vite": "^5.3.4",
-    "vitest": "^3.2.7"
+    "typescript-eslint": "8.71.0",
+    "vite": "^6.4.3",
+    "vitest": "^4.1.11"
   }
 }
diff --git a/frontend/reactPlugin.ts b/frontend/reactPlugin.ts
index ce3ddc66..8d898a04 100644
--- a/frontend/reactPlugin.ts
+++ b/frontend/reactPlugin.ts
@@ -11,8 +11,16 @@ import reactCompiler from "babel-plugin-react-compiler";
 //
 // The React Compiler auto-memoises: it infers what `useCallback`/`useMemo` were being hand-written
 // for and applies the equivalent itself. It is enabled repo-wide with no opt-out list because it
-// bails out on its own for anything it cannot prove safe (its rules are also linted, via
-// eslint-plugin-react-hooks). `target` follows the installed React major and must move with it.
+// bails out on its own for anything it cannot prove safe — SILENTLY: `panicThreshold` is "none" and
+// there is no logger here, so a skipped component still works and simply re-renders everything under
+// it. This comment used to say "its rules are also linted"; it was false while `react-hooks/refs` was
+// off, and 95 functions sat uncompiled behind it (E32). What actually holds the line now is
+// src/components/compilerCoverage.contract.test.ts, which runs THIS compiler over the shipped source
+// and fails on any skip not on its list; the react-hooks lint rules are the early warning. None of
+// them is off (three run at the preset's warn, which `--max-warnings 0` fails — docs/gates.md), but
+// three of the compiler's diagnostics cannot report under the installed plugin (eslint.config.js
+// says which), so the ratchet is the line, not the lint. `target` follows the installed React major and
+// must move with it.
 //
 // The plugin is IMPORTED rather than named by the usual `"babel-plugin-react-compiler"` string. Two
 // reasons, both about the gate: a string is invisible to knip, which then reports the dependency as
diff --git a/frontend/src/components/AboutCell.tsx b/frontend/src/components/AboutCell.tsx
index 00895088..b4412c94 100644
--- a/frontend/src/components/AboutCell.tsx
+++ b/frontend/src/components/AboutCell.tsx
@@ -36,6 +36,8 @@ export default function AboutCell({ text, channelId }: { text: string | null; ch
     fitHeight: true,
   });
 
+  const { setReference } = pop.refs;
+
   const { data: ch } = useQuery({
     queryKey: qk.channel(channelId),
     queryFn: () => api.channelDetail(channelId),
@@ -48,7 +50,7 @@ export default function AboutCell({ text, channelId }: { text: string | null; ch
   return (
     <>
       <span
-        ref={pop.refs.setReference}
+        ref={setReference}
         {...pop.getReferenceProps()}
         tabIndex={0}
         className="block max-w-88 truncate text-muted cursor-help rounded-sm outline-hidden focus-visible:outline-2 focus-visible:outline-accent focus-visible:outline-offset-2"
diff --git a/frontend/src/components/ActiveFilterChips.tsx b/frontend/src/components/ActiveFilterChips.tsx
index 68baec50..15aeb6b7 100644
--- a/frontend/src/components/ActiveFilterChips.tsx
+++ b/frontend/src/components/ActiveFilterChips.tsx
@@ -9,6 +9,7 @@ import { useAnchoredPopover } from "./ui/anchoredPopoverHooks";
 import { Button } from "./ui/Button";
 import { Chip } from "./ui/Chip";
 import { chipClass } from "./ui/chipStyles";
+import { ChipLabelPending } from "./ui/Skeleton";
 import { SURFACE } from "./ui/surfaces";
 
 // The applied-filter row above the feed: every narrowing currently in force, each removable on its
@@ -26,6 +27,16 @@ import { SURFACE } from "./ui/surfaces";
 // the "fit some + N more" treatment used on wider lanes.
 const NARROW_PX = 420;
 
+// A chip's text: its name, or a placeholder while the name is on its way. The visible chip, the
+// overflow popover's row and the hidden measuring mirror all draw it, so the mirror measures what shows.
+function ChipText({ f, className }: { f: ActiveFilter; className: string }) {
+  return f.pending ? (
+    <ChipLabelPending value={f.label} />
+  ) : (
+    <span className={className}>{f.label}</span>
+  );
+}
+
 function ChipButton({ f, testId }: { f: ActiveFilter; testId?: string }) {
   const { t } = useTranslation();
   return (
@@ -37,7 +48,7 @@ function ChipButton({ f, testId }: { f: ActiveFilter; testId?: string }) {
       onClick={f.remove}
       removeLabel={t("feed.chips.remove", { name: f.label })}
     >
-      <span className="max-w-56 truncate">{f.label}</span>
+      <ChipText f={f} className="max-w-56 truncate" />
     </Chip>
   );
 }
@@ -66,13 +77,14 @@ function OverflowPopover({
     mode: "menu",
     placement: "bottom-end",
   });
+  const { setReference } = pop.refs;
   const name = ariaLabel ?? label;
   return (
     <>
       <Chip
         variant="token"
         size="md"
-        ref={pop.refs.setReference}
+        ref={setReference}
         {...pop.getReferenceProps()}
         aria-label={name}
         icon={icon ? <Filter className="size-3.5" aria-hidden="true" /> : undefined}
@@ -93,7 +105,7 @@ function OverflowPopover({
               label={f.label}
               className="group flex w-full items-center gap-2 rounded-lg px-2 py-1.5 text-left text-sm text-fg transition"
             >
-              <span className="flex-1 truncate">{f.label}</span>
+              <ChipText f={f} className="flex-1 truncate" />
               <X className="w-3.5 h-3.5 shrink-0 opacity-60 group-hover:opacity-100" />
             </PopoverItem>
           ))}
@@ -134,7 +146,7 @@ export default function ActiveFilterChips({
 
   const n = filters.length;
   // Re-measure whenever the chip set changes (labels or count) — captures both in one dep.
-  const chipsKey = filters.map((f) => f.key + f.label).join("|");
+  const chipsKey = filters.map((f) => f.key + f.label + (f.pending ? "…" : "")).join("|");
 
   // The shared measurement core hands over the chip right edges + gap + pill width + lane width; this
   // policy adds the feed row's own framing (the leading label's right edge, and the trailing "Clear
@@ -191,7 +203,7 @@ export default function ActiveFilterChips({
             }}
             className={chipClass("token", "md") + " pr-1.5"}
           >
-            <span className="max-w-56 truncate">{f.label}</span>
+            <ChipText f={f} className="max-w-56 truncate" />
             <X className="size-3" />
           </span>
         ))}
diff --git a/frontend/src/components/AddToPlaylist.tsx b/frontend/src/components/AddToPlaylist.tsx
index 6ece7882..4c055fb2 100644
--- a/frontend/src/components/AddToPlaylist.tsx
+++ b/frontend/src/components/AddToPlaylist.tsx
@@ -2,7 +2,8 @@ import { useLayoutEffect, useState } from "react";
 import { useTranslation } from "react-i18next";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { qk } from "../lib/queryKeys";
-import { ListPlus, Plus, Youtube } from "lucide-react";
+import { ListPlus, Plus } from "lucide-react";
+import { YouTubeIcon } from "../lib/brandIcons";
 import { MenuCheck } from "./ui/MenuCheck";
 import { api, type Playlist } from "../lib/api";
 import { notifyActionError } from "../lib/actionErrors";
@@ -30,10 +31,11 @@ export default function AddToPlaylist({
   const { t } = useTranslation();
   const [open, setOpen] = useState(false);
   const pop = useMembershipPopover(open, setOpen);
+  const { setReference } = pop.refs;
   return (
     <>
       <IconButton
-        ref={pop.refs.setReference}
+        ref={setReference}
         variant={variant}
         size={size}
         {...pop.getReferenceProps({
@@ -92,7 +94,7 @@ function MembershipPanel({
 }) {
   const { t } = useTranslation();
   const qc = useQueryClient();
-  const fade = useScrollFade();
+  const { ref: fadeRef, style: fadeStyle } = useScrollFade();
   const open = pop.open;
   const [newName, setNewName] = useState("");
   const [busy, setBusy] = useState(false);
@@ -122,10 +124,9 @@ function MembershipPanel({
       else await api.addToPlaylist(pl.id, videoId);
     } catch (e) {
       notifyActionError(e, t(pl.has_video ? "playlists.removeFailed" : "playlists.addFailed"));
-    } finally {
-      refresh();
-      setBusy(false);
     }
+    refresh();
+    setBusy(false);
   }
 
   async function createAndAdd() {
@@ -138,10 +139,9 @@ function MembershipPanel({
       setNewName("");
     } catch (e) {
       notifyActionError(e, t("playlists.addFailed"));
-    } finally {
-      refresh();
-      setBusy(false);
     }
+    refresh();
+    setBusy(false);
   }
 
   // All of the user's playlists are add targets, including YouTube-linked ones — adding
@@ -158,8 +158,8 @@ function MembershipPanel({
             {t("playlists.addToPlaylistTitle")}
           </div>
           <div
-            ref={fade.ref}
-            style={fade.style}
+            ref={fadeRef}
+            style={fadeStyle}
             aria-busy={busy}
             className="max-h-56 overflow-y-auto no-scrollbar"
           >
@@ -183,7 +183,7 @@ function MembershipPanel({
                 <MenuCheck kind="many" on={!!pl.has_video} />
                 <span className="truncate flex-1 text-left">{playlistName(pl, t)}</span>
                 {(pl.source === "youtube" || pl.yt_playlist_id) && (
-                  <Youtube className="w-3 h-3 shrink-0 text-muted" />
+                  <YouTubeIcon className="w-3 h-3 shrink-0 text-muted" />
                 )}
               </PopoverItem>
             ))}
diff --git a/frontend/src/components/BootGate.dom.test.tsx b/frontend/src/components/BootGate.dom.test.tsx
index a81f4c74..e436e12c 100644
--- a/frontend/src/components/BootGate.dom.test.tsx
+++ b/frontend/src/components/BootGate.dom.test.tsx
@@ -23,13 +23,14 @@ import i18n from "../i18n";
 
 const renders: { page: string; lang: string }[] = [];
 let mounts = 0;
+const countMount = () => {
+  mounts++; // outside the component: the compiler cannot lower `++` on a module variable in one
+};
 function Probe() {
   const { page } = useNavigation();
   const { i18n: inst } = useTranslation();
   renders.push({ page, lang: inst.language });
-  useEffect(() => {
-    mounts++;
-  }, []);
+  useEffect(countMount, []);
   return <div data-testid="app">{page}</div>;
 }
 
@@ -226,7 +227,9 @@ describe("BootGate", () => {
     const qc = mount();
     await screen.findByTestId("app");
     // Anything that re-renders the gate must leave it alone: a pref save, a background refetch.
-    act(() => qc.setQueryData(qk.me(), account({ preferences: { startup: "last" } })));
+    act(() => {
+      qc.setQueryData(qk.me(), account({ preferences: { startup: "last" } }));
+    });
     await act(() => new Promise((r) => setTimeout(r, 20)));
 
     expect(reload).not.toHaveBeenCalled();
@@ -241,7 +244,9 @@ describe("BootGate", () => {
     vi.stubGlobal("location", { ...window.location, reload });
 
     // What every pref save does to the cache (usePref's mergePrefsCache): a new `me` for the same account.
-    act(() => qc.setQueryData(qk.me(), account({ preferences: { language: "hu" } })));
+    act(() => {
+      qc.setQueryData(qk.me(), account({ preferences: { language: "hu" } }));
+    });
     await act(() => new Promise((r) => setTimeout(r, 20)));
 
     expect(reload).not.toHaveBeenCalled();
diff --git a/frontend/src/components/BootGate.tsx b/frontend/src/components/BootGate.tsx
index 5091975e..dd8562cb 100644
--- a/frontend/src/components/BootGate.tsx
+++ b/frontend/src/components/BootGate.tsx
@@ -1,4 +1,4 @@
-import { useLayoutEffect, useRef, useState, type ReactNode } from "react";
+import { useEffectEvent, useLayoutEffect, useState, type ReactNode } from "react";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { useTranslation } from "react-i18next";
 import { api, getActiveAccount, setActiveAccount } from "../lib/api";
@@ -89,12 +89,11 @@ export default function BootGate({ children }: { children: ReactNode }) {
   //     orders its lists and writes its mail in the stored one, else English, and a Hungarian screen
   //     over English-ordered lists breaks "A→Z in the UI language's alphabet".
   const [readyFor, setReadyFor] = useState<number | null | undefined>(undefined);
-  // `me` is read for the identity it produced, so it rides a ref: a background refetch of the same
+  // `me` is read for the identity it produced, so it is an effect event: a background refetch of the same
   // account must not re-run the adoption over a language the user has just changed. That rule used
   // to live in a dep list that excluded `me`, which made the dep list load-bearing for correctness —
   // and the failure mode of getting it wrong was a page-reload loop, not a stale value.
-  const meRef = useRef(me);
-  meRef.current = me;
+  const adoptedMe = useEffectEvent(() => me);
   useLayoutEffect(() => {
     if (identity === undefined) return;
     if (readyFor !== undefined) {
@@ -107,7 +106,7 @@ export default function BootGate({ children }: { children: ReactNode }) {
       if (readyFor !== identity) location.reload();
       return;
     }
-    const account = meRef.current;
+    const account = adoptedMe();
     if (account && getActiveAccount() !== account.id) setActiveAccount(account.id);
     const lang = account?.preferences?.language;
     if (typeof lang === "string" && isSupported(lang)) {
diff --git a/frontend/src/components/ChannelPage.backfill.dom.test.tsx b/frontend/src/components/ChannelPage.backfill.dom.test.tsx
index 673a714d..8f060b47 100644
--- a/frontend/src/components/ChannelPage.backfill.dom.test.tsx
+++ b/frontend/src/components/ChannelPage.backfill.dom.test.tsx
@@ -82,7 +82,9 @@ describe("ChannelPage — the grid follows a running backfill", () => {
     expect(qc.getQueryState(feedKey)?.isInvalidated).toBe(false);
 
     // The next poll tick: the background job has stored 60 more.
-    act(() => qc.setQueryData(qk.channel(CH), reading(79)));
+    act(() => {
+      qc.setQueryData(qk.channel(CH), reading(79));
+    });
 
     await waitFor(() => expect(qc.getQueryState(feedKey)?.isInvalidated).toBe(true));
   });
diff --git a/frontend/src/components/ChannelPicker.tsx b/frontend/src/components/ChannelPicker.tsx
index 495a5161..619fb7fe 100644
--- a/frontend/src/components/ChannelPicker.tsx
+++ b/frontend/src/components/ChannelPicker.tsx
@@ -1,7 +1,6 @@
 import { useTranslation } from "react-i18next";
-import { useQuery } from "@tanstack/react-query";
-import { qk } from "../lib/queryKeys";
-import { api, type FeedFilters } from "../lib/api";
+import type { FeedFilters } from "../lib/api";
+import { useChannelNames } from "../lib/useChannelNames";
 import Combobox, { type ComboboxOption } from "./ui/Combobox";
 
 // Pick channels to narrow the feed to — several OR together, so every other filter then applies
@@ -19,18 +18,13 @@ export default function ChannelPicker({
   setFilters: (f: FeedFilters) => void;
 }) {
   const { t } = useTranslation();
-  const channelsQuery = useQuery({
-    queryKey: qk.channels(),
-    queryFn: api.channels,
-    staleTime: 5 * 60_000,
-  });
+  const { query: channelsQuery, names, pending } = useChannelNames();
 
   const all = channelsQuery.data ?? [];
   // The list order isn't alphabetical — it's the user's channel priority — and Combobox preserves the
   // options order, so it stays meaningful. selectedLabels keeps a picked channel named even if a later
-  // narrowing ever drops it from the visible rows.
+  // narrowing ever drops it from the visible rows, and names a reloaded filter before the list lands.
   const options: ComboboxOption[] = all.map((c) => ({ value: c.id, label: c.title ?? c.id }));
-  const selectedLabels = Object.fromEntries(all.map((c) => [c.id, c.title ?? c.id]));
 
   return (
     <Combobox
@@ -43,7 +37,8 @@ export default function ChannelPicker({
       error={channelsQuery.isError && !channelsQuery.data ? t("common.loadError") : undefined}
       onRetry={() => void channelsQuery.refetch()}
       emptyText={t("sidebar.noChannelMatch")}
-      selectedLabels={selectedLabels}
+      selectedLabels={names}
+      labelsPending={pending}
     />
   );
 }
diff --git a/frontend/src/components/ChannelStatsPopover.tsx b/frontend/src/components/ChannelStatsPopover.tsx
index 0a280ab2..f0f26b10 100644
--- a/frontend/src/components/ChannelStatsPopover.tsx
+++ b/frontend/src/components/ChannelStatsPopover.tsx
@@ -32,6 +32,7 @@ export default function ChannelStatsPopover({ status }: { status: MyStatus }) {
     placement: "bottom-end",
     offset: 8,
   });
+  const { setReference } = pop.refs;
 
   // Each row keeps the per-stat explanation the old inline stats carried (as a native `title` on the
   // row), so hovering a figure still tells the user what it counts — the guidance is not lost.
@@ -84,7 +85,7 @@ export default function ChannelStatsPopover({ status }: { status: MyStatus }) {
         variant="glass"
         size="sm"
         icon={<BarChart3 aria-hidden="true" />}
-        ref={pop.refs.setReference}
+        ref={setReference}
         {...pop.getReferenceProps()}
       >
         {t("channels.stats.label")}
diff --git a/frontend/src/components/ChannelTags.tsx b/frontend/src/components/ChannelTags.tsx
index 5ef4023d..e8e545a9 100644
--- a/frontend/src/components/ChannelTags.tsx
+++ b/frontend/src/components/ChannelTags.tsx
@@ -128,6 +128,7 @@ function SuggestedChipsLane({
     mode: "hover",
     placement: "bottom",
   });
+  const { setReference: setOverflowAnchor } = overflowPop.refs;
 
   return (
     <div className={`${chipLaneClass} flex items-center gap-1 min-w-0 flex-1`}>
@@ -165,7 +166,7 @@ function SuggestedChipsLane({
           <Chip
             variant="suggest"
             size="xs"
-            ref={overflowPop.refs.setReference}
+            ref={setOverflowAnchor}
             aria-label={t("channels.tags.moreCount", { count: hidden })}
             {...overflowPop.getReferenceProps()}
           >
@@ -208,7 +209,7 @@ function TagEditorMenu({
 }) {
   const { t } = useTranslation();
   const [draft, setDraft] = useState("");
-  const fade = useScrollFade();
+  const { ref: fadeRef, style: fadeStyle } = useScrollFade();
   const attached = new Set(attachedIds);
   const submit = () => {
     const name = draft.trim();
@@ -218,7 +219,7 @@ function TagEditorMenu({
   };
   return (
     <div className="flex flex-col">
-      <div ref={fade.ref} style={fade.style} className="max-h-60 overflow-y-auto no-scrollbar">
+      <div ref={fadeRef} style={fadeStyle} className="max-h-60 overflow-y-auto no-scrollbar">
         {userTags.map((tg) => {
           const on = attached.has(tg.id);
           return (
@@ -349,6 +350,7 @@ export function ChannelTagsControl({
     // of the roving list so neither steals the field's caret.
     hostsInput: true,
   });
+  const { setReference: setEditAnchor } = editPop.refs;
 
   // Derived for the same reason as the suggestion row above: if tags change so nothing is collapsed
   // anymore, the "+N" trigger unmounts, and the popover must already be shut in that same render —
@@ -362,6 +364,7 @@ export function ChannelTagsControl({
     mode: "hover",
     placement: "bottom",
   });
+  const { setReference: setOverflowAnchor } = overflowPop.refs;
 
   // The "+N" is a filter-look chip (neutral): the tags themselves are the accent.
   const pillClass = chipClass("filter", "xs");
@@ -381,7 +384,7 @@ export function ChannelTagsControl({
       <Chip
         variant="ghost"
         size="xs"
-        ref={editPop.refs.setReference}
+        ref={setEditAnchor}
         title={t("channels.row.editTags")}
         aria-label={t("channels.row.editTags")}
         icon={<Plus className="size-3" />}
@@ -440,7 +443,7 @@ export function ChannelTagsControl({
             {hidden > 0 && (
               <Chip
                 size="xs"
-                ref={overflowPop.refs.setReference}
+                ref={setOverflowAnchor}
                 aria-label={t("channels.tags.moreCount", { count: hidden })}
                 {...overflowPop.getReferenceProps()}
               >
diff --git a/frontend/src/components/Channels.tsx b/frontend/src/components/Channels.tsx
index 59730f94..7bdf3749 100644
--- a/frontend/src/components/Channels.tsx
+++ b/frontend/src/components/Channels.tsx
@@ -1,6 +1,15 @@
-import { useEffect, useEffectEvent, useMemo, useRef, useState } from "react";
+import {
+  useCallback,
+  useEffect,
+  useEffectEvent,
+  useMemo,
+  useRef,
+  useState,
+  useSyncExternalStore,
+} from "react";
 import { useTranslation } from "react-i18next";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { createStore, type Store } from "../lib/store";
 import { qk } from "../lib/queryKeys";
 import { Ban, Eye, EyeOff, History, LayoutGrid, Pencil, RefreshCw, Table, X } from "lucide-react";
 import ExcludedChannelList from "./ExcludedChannelList";
@@ -8,7 +17,7 @@ import { api, NO_TAG_SENTINEL, type ManagedChannel } from "../lib/api";
 import { Sparkles } from "lucide-react";
 import { notifyYouTubeActionError } from "../lib/youtubeErrors";
 import { accountKey, LS } from "../lib/storage";
-import { buildChannelColumns, applySyncFilter } from "./channelColumns";
+import { buildChannelColumns, applySyncFilter, tagFilterChips } from "./channelColumns";
 import { notify } from "../lib/notifications";
 import { Badge } from "./ui/Badge";
 import { Button } from "./ui/Button";
@@ -31,7 +40,7 @@ import { focusNavItem } from "../lib/listNav";
 import ViewSwitcher, { type ViewOption } from "./ViewSwitcher";
 import ColumnSortControl from "./ui/ColumnSortControl";
 import FilterChipGroup from "./ui/FilterChipGroup";
-import TagFilterChips, { type FilterChip } from "./TagFilterChips";
+import TagFilterChips from "./TagFilterChips";
 import ActionMenu, { type ActionMenuItem } from "./ui/ActionMenu";
 import ChannelStatsPopover from "./ChannelStatsPopover";
 import Pager from "./ui/Pager";
@@ -76,6 +85,41 @@ const LAYOUT_ICON: Record<ChannelLayout, typeof Table> = {
   cards: LayoutGrid,
 };
 
+// The row menu's identity for a channel. Module scope, as useContextMenu asks: a fresh function per
+// render rebuilt its `buttonProps` on every render, and with them every column.
+const channelKey = (c: ManagedChannel) => c.id;
+
+// Which channel's row menu is open, for its "…" (`aria-expanded`, and staying shown while open). A
+// tiny store rather than a context: a context change walks the whole table to find its readers (~20
+// ms on 400 rows, each open and close), while a store calls its subscribers and re-renders only the
+// two buttons whose answer changed (each reads a boolean, so a change elsewhere renders nothing).
+type OpenRowStore = Store<string | null>;
+
+function RowMoreButton({
+  id,
+  label,
+  menuProps,
+  register,
+  openRow,
+}: {
+  id: string;
+  label: string;
+  menuProps: Record<string, unknown>;
+  register: (id: string, el: HTMLButtonElement | null) => void;
+  openRow: OpenRowStore;
+}) {
+  const mine = useSyncExternalStore(openRow.subscribe, () => openRow.get() === id);
+  return (
+    <MoreButton
+      ref={(el) => register(id, el)}
+      label={label}
+      expanded={mine}
+      menuProps={menuProps}
+      className={mine ? undefined : "reveal"}
+    />
+  );
+}
+
 export default function Channels() {
   const me = useMe();
   const panel = useTabPanel();
@@ -113,11 +157,16 @@ export default function Channels() {
 
   // Clicking a tag chip filters the feed by that tag and jumps there. Internalised (was an App
   // callback) now that Channels reads the feed filters + navigation straight from their providers.
-  const onFilterByTag = (tagId: number, name: string) => {
-    setFeedFilters({ ...feedFilters, tags: [tagId], channelIds: [] });
-    setPage("feed");
-    notify({ level: "info", message: t("channels.notify.filteredByTag", { name }) });
-  };
+  // useCallback (like `onView`): the column memo below names it, and the hook lint cannot see the
+  // compiler's memo of a plain closure.
+  const onFilterByTag = useCallback(
+    (tagId: number, name: string) => {
+      setFeedFilters({ ...feedFilters, tags: [tagId], channelIds: [] });
+      setPage("feed");
+      notify({ level: "info", message: t("channels.notify.filteredByTag", { name }) });
+    },
+    [setFeedFilters, feedFilters, setPage, t],
+  );
 
   const channelsQuery = useQuery({ queryKey: qk.channels(), queryFn: api.channels });
   const tagsQuery = useTags();
@@ -143,7 +192,9 @@ export default function Channels() {
     qc.invalidateQueries({ queryKey: qk.feedSummary() });
   };
 
-  const userTags = (tagsQuery.data ?? []).filter((t) => !t.system);
+  // A memo for the same reason as the tag actions below: the column memo names it.
+  const allTags = tagsQuery.data;
+  const userTags = useMemo(() => (allTags ?? []).filter((t) => !t.system), [allTags]);
 
   // The row's stepper updates priority optimistically in place and does NOT re-sort/refetch, so the
   // list doesn't jump under a press-and-hold (the server list is priority-sorted; refetching would
@@ -181,35 +232,41 @@ export default function Channels() {
   // Tagging is updated optimistically in place (no refetch of the whole channel list, which
   // made the toggle feel ~2s slow); only revert by refetching if the server call fails. The
   // attach/detach + create-and-attach flow is shared with the channel detail page.
-  const { toggleTag, createAndAttachTag } = useChannelTagActions({
-    optimisticToggle: (id, tagId, attach) =>
-      qc.setQueryData<ManagedChannel[]>(qk.channels(), (old) =>
-        (old ?? []).map((ch) =>
-          ch.id === id
-            ? {
-                ...ch,
-                tag_ids: attach ? [...ch.tag_ids, tagId] : ch.tag_ids.filter((x) => x !== tagId),
-              }
-            : ch,
+  const tagActionOpts = useMemo<Parameters<typeof useChannelTagActions>[0]>(
+    () => ({
+      optimisticToggle: (id, tagId, attach) =>
+        qc.setQueryData<ManagedChannel[]>(qk.channels(), (old) =>
+          (old ?? []).map((ch) =>
+            ch.id === id
+              ? {
+                  ...ch,
+                  tag_ids: attach ? [...ch.tag_ids, tagId] : ch.tag_ids.filter((x) => x !== tagId),
+                }
+              : ch,
+          ),
         ),
-      ),
-    // Keep the channel DETAIL cache in step with the manager list (the detail page reads its tags
-    // from qk.channel(id)); mirrors the detail page invalidating the manager list on its side. Also
-    // recompute suggestions: a channel that just gained/lost a user tag changes the untagged set and
-    // the learned pattern (E8·S4).
-    onSuccess: (id) => {
-      qc.invalidateQueries({ queryKey: qk.channel(id) });
-      qc.invalidateQueries({ queryKey: qk.tagSuggestions() });
-    },
-    // A failed attach/detach reverts the optimistic change by refetching the list. Also refetch
-    // suggestions: acceptSuggestion optimistically dropped the channel from that cache, and on
-    // failure the tag never actually attached — so the server still suggests it and the ghost chips
-    // must come back rather than leaving an empty cell (honest states). The hook reports the failure.
-    onError: () => {
-      qc.invalidateQueries({ queryKey: qk.channels() });
-      qc.invalidateQueries({ queryKey: qk.tagSuggestions() });
-    },
-  });
+      // Keep the channel DETAIL cache in step with the manager list (the detail page reads its tags
+      // from qk.channel(id)); mirrors the detail page invalidating the manager list on its side. Also
+      // recompute suggestions: a channel that just gained/lost a user tag changes the untagged set and
+      // the learned pattern (E8·S4).
+      onSuccess: (id) => {
+        qc.invalidateQueries({ queryKey: qk.channel(id) });
+        qc.invalidateQueries({ queryKey: qk.tagSuggestions() });
+      },
+      // A failed attach/detach reverts the optimistic change by refetching the list. Also refetch
+      // suggestions: acceptSuggestion optimistically dropped the channel from that cache, and on
+      // failure the tag never actually attached — so the server still suggests it and the ghost chips
+      // must come back rather than leaving an empty cell (honest states). The hook reports the failure.
+      onError: () => {
+        qc.invalidateQueries({ queryKey: qk.channels() });
+        qc.invalidateQueries({ queryKey: qk.tagSuggestions() });
+      },
+    }),
+    [qc],
+  );
+  // The options are a memo so the hook's toggleTag/createAndAttachTag stay the same functions: the
+  // column memo below names them (see `columns`).
+  const { toggleTag, createAndAttachTag } = useChannelTagActions(tagActionOpts);
   // --- Suggested tags (E8·S4): learned from the user's own manual-tag pattern, shown as accept/dismiss
   // ghost chips on untagged channels. Dismissal is session-only (an accepted suggestion self-clears —
   // the channel becomes tagged and the server drops it; a dismissed one just hides until reload). The
@@ -273,39 +330,32 @@ export default function Channels() {
   const noTagOn = tagFilter.includes(NO_TAG_SENTINEL);
   const toggleNoTagFilter = () =>
     setFilters({ ...filters, tags: noTagOn ? [] : [NO_TAG_SENTINEL] });
-  // The tag-filter chips (user tags + the "No tag" sentinel), fed to TagFilterChips which folds any
-  // overflow into a "+N" pill so the row stays one line and the trailing "…" actions can't wrap.
-  const tagFilterChips: FilterChip[] = [
-    ...userTags.map((tg) => ({
-      key: `t${tg.id}`,
-      label: tg.name,
-      active: tagFilter.includes(String(tg.id)),
-      onToggle: () => toggleTagFilter(tg.id),
-    })),
-    {
-      key: NO_TAG_SENTINEL,
-      label: t("channels.tags.noTag"),
-      active: noTagOn,
-      onToggle: toggleNoTagFilter,
-    },
-  ];
+  // The tag-filter chips, fed to TagFilterChips which folds any overflow into a "+N" pill so the row
+  // stays one line and the trailing "…" actions can't wrap.
+  const tagChips = tagFilterChips({
+    userTags,
+    tags: tagsQuery,
+    picked: tagFilter,
+    noTagOn,
+    toggle: toggleTagFilter,
+    toggleNoTag: toggleNoTagFilter,
+    t,
+  });
   // A focus-channel intent (header "without full history" / tag manager) seeds the search box.
   // The TOKEN is the intent (it advances even when the same channel is re-focused); the name is the
-  // payload, so it rides a ref. Naming it would re-seed the box on any render that changed it,
-  // overwriting whatever the user had since typed.
+  // payload, so it is read through an effect event. Naming it would re-seed the box on any render that
+  // changed it, overwriting whatever the user had since typed.
   //
   // `consumeFocus` is what stops this page's OWN remounts from re-applying it: this effect runs on
   // every mount, and this page unmounts on every navigation away — and on opening a channel page,
   // which does not even change `page`. The provider then reports `focusName` as null, so a later
   // visit leaves the box exactly as the user left it.
-  const focusChannelNameRef = useRef(focusChannelName);
-  focusChannelNameRef.current = focusChannelName;
-  useEffect(() => {
-    const name = focusChannelNameRef.current;
-    if (!name) return;
-    setSearch(name);
+  const applyFocus = useEffectEvent(() => {
+    if (!focusChannelName) return;
+    setSearch(focusChannelName);
     consumeFocus();
-  }, [focusChannelToken, setSearch, consumeFocus]);
+  });
+  useEffect(() => applyFocus(), [focusChannelToken]);
   // The header's reset intent clears the search box (skip the initial mount); the tag chips ride in
   // `filters.tags`, which goToFullHistory already clears by setting a fresh map.
   const resetRef = useRef(filtersResetToken);
@@ -315,34 +365,25 @@ export default function Channels() {
     setSearch("");
   }, [filtersResetToken, setSearch]);
 
-  // Tag/priority/text filters stay controlled COLUMN filters (`filters.tags` etc.) shared by the top
-  // chips, the column funnels and the cards. The sync-status filter (`filters.sync`) is no longer a
-  // column — R14 retired the Sync column and folded its status into a ✓ charm on Stored — so it's
-  // applied as a pre-filter (`applySyncFilter`) over the rows fed to BOTH the table and the cards,
-  // still driven by the same top chips. Hidden channels have their own tab (excluded here). Only the
-  // name search filters at this step; the remaining column funnels run in DataTable / filterRows below.
-  const hiddenChannels = (channelsQuery.data ?? []).filter((c) => c.hidden);
-  const channels = (channelsQuery.data ?? []).filter((c) => !c.hidden);
-  const q = search.trim().toLowerCase();
-  const visibleChannels = channels.filter(
-    (c) => !q || `${c.title ?? ""} ${c.handle ?? ""}`.toLowerCase().includes(q),
+  const onView = useCallback(
+    (c: ManagedChannel) => onViewChannel(c.id, c.title ?? t("channels.row.thisChannel")),
+    [onViewChannel, t],
   );
-  // Sync-status pre-filter (top chips → `filters.sync`), applied before the table/cards see the rows.
-  // (Inline, not memoised: `visibleChannels` is a fresh array each render, so a useMemo keyed on it
-  // could never hit its cache — and applySyncFilter is a cheap single pass anyway.)
-  const syncedChannels = applySyncFilter(visibleChannels, filters.sync);
-  const s = statusQuery.data;
-
-  const onView = (c: ManagedChannel) =>
-    onViewChannel(c.id, c.title ?? t("channels.row.thisChannel"));
   // The channel's ONE action list (E28 C1) — ONE menu for the list, shared by the table and the card
   // layout: they are two paints of the same rows, so a right-click, a long-press and the row's "…"
   // must mean the same thing in both. Only mounted under the SUBSCRIBED branch below: a discovery
   // result is not a `Channel` row yet, so pinning or hiding one could only 404.
   // Keyed by id: a tag toggled in the menu, a priority picked, a poll — each rebuilds the row object
   // under the open menu, and its "…" must still know the menu is its own.
-  const rowMenu = useContextMenu<ManagedChannel>({ keyOf: (c) => c.id });
+  const rowMenu = useContextMenu<ManagedChannel>({ keyOf: channelKey });
   const rowPin = useComfortPin(rowMenu.open);
+  // The columns read only the menu's STABLE handles. Which row's menu is open reaches each "…" through
+  // the open-row store instead: read in the columns, it rebuilt every column on each open, close and
+  // reposition, and so re-rendered the whole table — ~0.8 s to open the menu on 400 rows.
+  const { buttonProps: rowButtonProps, triggerProps: rowTriggerProps } = rowMenu;
+  const openRowId = rowMenu.open ? (rowMenu.target?.id ?? null) : null;
+  const [openRow] = useState(() => createStore<string | null>(null));
+  useEffect(() => openRow.set(openRowId), [openRow, openRowId]);
   const channelActions = useChannelActions({
     onView,
     onOpenWizard,
@@ -361,41 +402,86 @@ export default function Channels() {
         pin: rowPin.item(pinChannel(menuRow.id), menuRow.title ?? t("channels.row.thisChannel")),
       })
     : [];
-  // Distinct priority levels present in the catalog → the priority column's filter options.
-  const prioOptions = [...new Set((channelsQuery.data ?? []).map((c) => c.priority))]
-    .sort((a, b) => b - a)
-    .map((p) => ({ value: String(p), label: String(p) }));
 
-  const columns = buildChannelColumns({
+  // Tag/priority/text filters stay controlled COLUMN filters (`filters.tags` etc.) shared by the top
+  // chips, the column funnels and the cards. The sync-status filter (`filters.sync`) is no longer a
+  // column — R14 retired the Sync column and folded its status into a ✓ charm on Stored — so it's
+  // applied as a pre-filter (`applySyncFilter`) over the rows fed to BOTH the table and the cards,
+  // still driven by the same top chips. Hidden channels have their own tab (excluded here). Only the
+  // name search filters at this step; the remaining column funnels run in DataTable / filterRows below.
+  //
+  // The table's rows and columns are explicit memos, not inline. Both later reach calls the React
+  // Compiler must assume may mutate them (`filterRows`, `sortRows`, `optionsFromColumns`) past this
+  // page's hooks, and a compiler memo cannot span a hook call — so inline, the compiler dropped their
+  // memo without a word, and every render (each open, close and reposition of the row menu) handed
+  // DataTable new rows and columns: ~0.9 s to open the menu on 400 rows. A useMemo result is frozen.
+  const hiddenChannels = (channelsQuery.data ?? []).filter((c) => c.hidden);
+  const allChannels = channelsQuery.data;
+  const q = search.trim().toLowerCase();
+  const syncFilterValue = filters.sync;
+  const syncedChannels = useMemo(
+    () =>
+      // Sync-status pre-filter (top chips → `filters.sync`), applied before the table/cards see the rows.
+      applySyncFilter(
+        (allChannels ?? []).filter(
+          (c) =>
+            !c.hidden && (!q || `${c.title ?? ""} ${c.handle ?? ""}`.toLowerCase().includes(q)),
+        ),
+        syncFilterValue,
+      ),
+    [allChannels, q, syncFilterValue],
+  );
+  const s = statusQuery.data;
+
+  const columns = useMemo(() => {
+    const registerMore = (id: string, el: HTMLButtonElement | null) => {
+      if (el) moreRefs.current.set(id, el);
+      else moreRefs.current.delete(id);
+    };
+    return buildChannelColumns({
+      t,
+      lang,
+      // Distinct priority levels present in the catalog → the priority column's filter options.
+      prioOptions: [...new Set((allChannels ?? []).map((c) => c.priority))]
+        .sort((a, b) => b - a)
+        .map((p) => ({ value: String(p), label: String(p) })),
+      userTags,
+      bumpPriority,
+      setPriority,
+      more: (c) => (
+        <RowMoreButton
+          id={c.id}
+          label={t("channels.row.menu")}
+          menuProps={rowButtonProps(c)}
+          register={registerMore}
+          openRow={openRow}
+        />
+      ),
+      onView,
+      toggleTag,
+      createAndAttachTag,
+      onFilterByTag,
+      suggestionsFor,
+      onAcceptSuggestion: acceptSuggestion,
+      onDismissSuggestion: dismissSuggestion,
+    });
+  }, [
     t,
-    lang: i18n.language,
-    prioOptions,
+    lang,
+    allChannels,
     userTags,
     bumpPriority,
     setPriority,
-    more: (c) => {
-      const mine = rowMenu.open && rowMenu.target?.id === c.id;
-      return (
-        <MoreButton
-          ref={(el) => {
-            if (el) moreRefs.current.set(c.id, el);
-            else moreRefs.current.delete(c.id);
-          }}
-          label={t("channels.row.menu")}
-          expanded={mine}
-          menuProps={rowMenu.buttonProps(c)}
-          className={mine ? undefined : "reveal"}
-        />
-      );
-    },
+    rowButtonProps,
+    openRow,
     onView,
     toggleTag,
     createAndAttachTag,
     onFilterByTag,
     suggestionsFor,
-    onAcceptSuggestion: acceptSuggestion,
-    onDismissSuggestion: dismissSuggestion,
-  });
+    acceptSuggestion,
+    dismissSuggestion,
+  ]);
 
   // Status chips sit in the table's controls row (next to paging) — compact and close to
   // where they act.
@@ -629,7 +715,7 @@ export default function Channels() {
                 </Button>
               </Tooltip>
               <FilterFoldButton fold={fold} label={t("sidebar.filters")} count={foldCount} />
-              {!fold.folded && <TagFilterChips chips={tagFilterChips} className="flex-1" />}
+              {!fold.folded && <TagFilterChips chips={tagChips} className="flex-1" />}
               {!fold.folded && tagFilter.length > 0 && (
                 <Button
                   variant="link-muted"
@@ -748,7 +834,7 @@ export default function Channels() {
                 onFiltersChange={setFilters}
                 fixedLayout
                 emptyText={t("channels.empty")}
-                rowProps={rowMenu.triggerProps}
+                rowProps={rowTriggerProps}
                 // `group`: the row's "…" reveals on its hover or focus (`.reveal`), and stays on touch.
                 rowClassName={() => "group"}
                 keyboardNav
@@ -775,7 +861,7 @@ export default function Channels() {
                   aboutKey="about"
                   moreKey="actions"
                   emptyText={t("channels.empty")}
-                  rowProps={rowMenu.triggerProps}
+                  rowProps={rowTriggerProps}
                   rowClassName={() => "group"}
                 />
                 {/* Folded, the status / pager row leaves the band, as the table's does — and the
diff --git a/frontend/src/components/ChannelsProvider.dom.test.tsx b/frontend/src/components/ChannelsProvider.dom.test.tsx
index d6521c39..cdd36b56 100644
--- a/frontend/src/components/ChannelsProvider.dom.test.tsx
+++ b/frontend/src/components/ChannelsProvider.dom.test.tsx
@@ -9,7 +9,7 @@
 // navigationContext (the sole runtime dependency) is mocked, pinned to the channels page.
 import { describe, it, expect, beforeEach, vi } from "vitest";
 import { renderHook, act, render as renderRoot } from "@testing-library/react";
-import { useEffect, useRef, type ReactNode } from "react";
+import { useEffect, useEffectEvent, type ReactNode } from "react";
 
 vi.mock("./navigationContext", () => ({
   useNavigation: () => ({ page: "channels" }),
@@ -60,9 +60,9 @@ describe("ChannelsProvider tab history", () => {
     expect(result.current.view).toBe("blocked");
 
     // Browser Back to an entry stamped with a different tab.
-    act(() =>
-      window.dispatchEvent(new PopStateEvent("popstate", { state: { _chTab: "discovery" } })),
-    );
+    act(() => {
+      window.dispatchEvent(new PopStateEvent("popstate", { state: { _chTab: "discovery" } }));
+    });
 
     expect(result.current.view).toBe("discovery");
     expect(localStorage.getItem(VIEW_KEY)).toBe("discovery");
@@ -71,7 +71,9 @@ describe("ChannelsProvider tab history", () => {
   it("ignores a popstate for an entry outside the manager (no _chTab)", () => {
     const { result } = render();
     act(() => result.current.setView("hidden"));
-    act(() => window.dispatchEvent(new PopStateEvent("popstate", { state: { sfPage: "feed" } })));
+    act(() => {
+      window.dispatchEvent(new PopStateEvent("popstate", { state: { sfPage: "feed" } }));
+    });
     expect(result.current.view).toBe("hidden"); // unchanged
   });
 });
@@ -135,18 +137,16 @@ describe("ChannelsProvider — S8 shareable URL", () => {
 // has to live in the PROVIDER — inside the page it would reset with the page and re-apply an intent
 // from earlier in the session over whatever the user has typed into the search box since.
 describe("ChannelsProvider — the focus-a-channel intent", () => {
-  /** Stands in for Channels.tsx:287-297 — the same effect, the same consume call. */
+  /** Stands in for Channels.tsx's `applyFocus` — the same effect event, the same consume call. */
   function Manager() {
     const { focusName, focusToken } = useChannels();
     const { setSearch, consumeFocus } = useChannelsActions();
-    const nameRef = useRef(focusName);
-    nameRef.current = focusName;
-    useEffect(() => {
-      const name = nameRef.current;
-      if (!name) return;
-      setSearch(name);
+    const applyFocus = useEffectEvent(() => {
+      if (!focusName) return;
+      setSearch(focusName);
       consumeFocus();
-    }, [focusToken, setSearch, consumeFocus]);
+    });
+    useEffect(() => applyFocus(), [focusToken]);
     return null;
   }
 
diff --git a/frontend/src/components/ChannelsProvider.tsx b/frontend/src/components/ChannelsProvider.tsx
index a4d10373..6b6f79c7 100644
--- a/frontend/src/components/ChannelsProvider.tsx
+++ b/frontend/src/components/ChannelsProvider.tsx
@@ -10,6 +10,7 @@ import {
 import { getAccountRaw, LS, useAccountPersistedState } from "../lib/storage";
 import { parseChannelLayout } from "../lib/channelLayout";
 import { hydrateSort } from "../lib/columnSort";
+import { useLatest } from "../lib/useLatest";
 import { useSortState } from "../lib/useSortState";
 import { useFilterState } from "../lib/useFilterState";
 import { useUrlMirror } from "../lib/useUrlMirror";
@@ -135,9 +136,7 @@ export function ChannelsProvider({ children }: { children: ReactNode }) {
 
   // Latest-value ref so the STABLE setView can compare against the current tab without depending on
   // it (a dep would recreate the action on every switch and re-render every actions consumer).
-  // Written during render — the sanctioned pattern NavigationProvider uses for `pageRef`.
-  const viewRef = useRef(view);
-  viewRef.current = view;
+  const viewRef = useLatest(view);
 
   const setSearch = useCallback((q: string) => setSearchState(q), []);
   // The active tab rides in history.state (`_chTab`), the same way the channel page (`_chan`) and the
@@ -159,7 +158,7 @@ export function ChannelsProvider({ children }: { children: ReactNode }) {
         window.history.pushState({ sfPage: "channels", _chTab: v }, "");
       }
     },
-    [setViewRaw],
+    [setViewRaw, viewRef],
   );
   const focusChannel = useCallback(
     (name: string) => {
diff --git a/frontend/src/components/ChatDock.tsx b/frontend/src/components/ChatDock.tsx
index 957ffb9e..db984d3d 100644
--- a/frontend/src/components/ChatDock.tsx
+++ b/frontend/src/components/ChatDock.tsx
@@ -13,6 +13,7 @@ import {
 } from "../lib/chatDock";
 import { onMessage, onUnread } from "../lib/messagesSocket";
 import * as e2ee from "../lib/e2ee";
+import { errorAttrs, log } from "../lib/log";
 import Avatar from "./ui/Avatar";
 import ChatThread from "./ChatThread";
 import Overlay from "./ui/Overlay";
@@ -30,7 +31,17 @@ export default function ChatDock({ meId }: { meId: number }) {
   // Restore the per-device unlocked key and the persisted dock windows once, app-wide.
   useEffect(() => {
     initDock(meId);
-    e2ee.loadFromDevice(meId);
+    // The device key store can be unopenable (storage disabled, some private windows): messages then
+    // stay locked behind the passphrase, as on a new device — said in the log, not thrown at nobody.
+    e2ee
+      .loadFromDevice(meId)
+      .catch((err: unknown) =>
+        log.warn(
+          "ui.e2ee_device_key_unreadable",
+          "the device key store could not be read",
+          errorAttrs(err),
+        ),
+      );
   }, [meId]);
 
   // Live delivery: refresh the conversation list, unread badge, and the affected thread; and
diff --git a/frontend/src/components/ChatThread.tsx b/frontend/src/components/ChatThread.tsx
index f6249c5e..80b84671 100644
--- a/frontend/src/components/ChatThread.tsx
+++ b/frontend/src/components/ChatThread.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState } from "react";
+import { useEffect, useEffectEvent, useRef, useState } from "react";
 import { qk } from "../lib/queryKeys";
 import { useTranslation } from "react-i18next";
 import { useMutation, useQueryClient } from "@tanstack/react-query";
@@ -33,7 +33,7 @@ export default function ChatThread({
   const [draft, setDraft] = useState("");
   const [plain, setPlain] = useState<Record<number, string>>({});
   const bottomRef = useRef<HTMLDivElement>(null);
-  const fade = useScrollFade();
+  const { ref: fadeRef, style: fadeStyle } = useScrollFade();
   const ready = useKeyState() === "ready";
   const needsKey = !isSystem && !ready;
 
@@ -43,10 +43,10 @@ export default function ChatThread({
     { intervalMs: POLL_MS, enabled: !needsKey },
   );
   const items = q.data?.items ?? [];
-  // The two effects below take the FETCH as their trigger and read the payload through this ref, so
-  // their dep lists name everything they touch without making the identity of `q.data` a trigger.
-  const threadRef = useRef(q.data);
-  threadRef.current = q.data;
+  // The two effects below take the FETCH as their trigger and read the payload through this effect
+  // event, so their dep lists name everything they touch without making the identity of `q.data` a
+  // trigger.
+  const latestThread = useEffectEvent(() => q.data);
 
   // Decrypt the thread when fresh server data arrives. Keyed on dataUpdatedAt (not `items`): the
   // `?? []` fallback is a new array reference every render, which would otherwise re-run this
@@ -54,14 +54,16 @@ export default function ChatThread({
   useEffect(() => {
     if (isSystem || !ready) return;
     let cancelled = false;
-    (async () => {
+    const thread = latestThread();
+    // Every await inside is caught per message (a failure reads "can't decrypt"), so this never rejects.
+    void (async () => {
       const out: Record<number, string> = {};
       // Fetch the partner key lazily inside the try (only when there's a ciphertext message) and
       // once — so an empty thread never fetches, and a fetch failure (e.g. a partner who reset and
       // hasn't re-set-up, so has no key) degrades to "can't decrypt" instead of rejecting the pass.
       let pub: string | null = null;
       let refreshed = false;
-      for (const m of threadRef.current?.items ?? []) {
+      for (const m of thread?.items ?? []) {
         if (!m.ciphertext || !m.iv) continue;
         try {
           if (!pub) pub = await partnerPub(partnerId);
@@ -89,8 +91,8 @@ export default function ChatThread({
     return () => {
       cancelled = true;
     };
-    // `dataUpdatedAt` is the trigger and the payload is read through the ref above — see Messages,
-    // where keying this family on `q.data` itself produced a render loop.
+    // `dataUpdatedAt` is the trigger and the payload is read through the effect event above — see
+    // Messages, where keying this family on `q.data` itself produced a render loop.
   }, [q.dataUpdatedAt, ready, isSystem, partnerId, t]);
 
   // Opening the thread (or a new incoming message arriving) marks messages read server-side, so
@@ -107,7 +109,7 @@ export default function ChatThread({
       lastPartner.current = partnerId;
       lastIncoming.current = -1;
     }
-    const incoming = (threadRef.current?.items ?? []).filter((m) => m.recipient_id === meId).length;
+    const incoming = (latestThread()?.items ?? []).filter((m) => m.recipient_id === meId).length;
     if (incoming !== lastIncoming.current) {
       lastIncoming.current = incoming;
       qc.invalidateQueries({ queryKey: qk.conversations() });
@@ -166,8 +168,8 @@ export default function ChatThread({
   return (
     <>
       <div
-        ref={fade.ref}
-        style={fade.style}
+        ref={fadeRef}
+        style={fadeStyle}
         className="flex-1 overflow-y-auto no-scrollbar p-3 flex flex-col gap-2"
       >
         {q.isError && !q.data ? (
diff --git a/frontend/src/components/ConfigPanel.tsx b/frontend/src/components/ConfigPanel.tsx
index 57c8d81d..b6211445 100644
--- a/frontend/src/components/ConfigPanel.tsx
+++ b/frontend/src/components/ConfigPanel.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useId, useMemo, useRef, useState } from "react";
+import { useId, useMemo, useState } from "react";
 import { qk } from "../lib/queryKeys";
 import { useTranslation } from "react-i18next";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
@@ -28,6 +28,50 @@ import { SURFACE } from "./ui/surfaces";
 // registry's own order (`sysconfig.SPECS`), so a new group lands where the backend puts it instead of
 // needing a second, hand-kept order list here.
 
+/** The admin's draft, plus the secrets marked to reset-to-default on the next Save (that can't be
+ *  expressed by clearing the field: an empty secret field means "leave unchanged"). Re-seeded from
+ *  `baseline` DURING render when `seedKey` changes, never on every new baseline: an unchanged refetch
+ *  produces a new object, and re-seeding on that is exactly the clobbering of an in-progress draft
+ *  that CB2 was about. (It was an effect: the first frame after a load painted the empty draft.) */
+function useSeededDraft(baseline: Record<string, string>, seedKey: string) {
+  const [draft, setDraft] = useState<Record<string, string>>({});
+  const [secretReset, setSecretReset] = useState<Record<string, boolean>>({});
+  const [seededFor, setSeededFor] = useState<string | null>(null);
+  if (seededFor !== seedKey) {
+    setSeededFor(seedKey);
+    setDraft(baseline);
+    setSecretReset({});
+  }
+  return { draft, setDraft, secretReset, setSecretReset };
+}
+
+/** The dirty keys' writes, one after another. Apart from ConfigPanel's save() so the loop and its
+ *  branches sit outside the try (the React Compiler cannot lower either inside one yet, and skipped
+ *  the whole panel). */
+async function writeConfigItems(
+  dirty: ConfigItem[],
+  draft: Record<string, string>,
+  secretReset: Record<string, boolean>,
+) {
+  for (const it of dirty) {
+    const key = it.key;
+    const raw = draft[key] ?? "";
+    if (it.secret) {
+      if (secretReset[key] && !raw.trim()) await api.resetConfig(key);
+      else if (raw.trim()) await api.setConfig(key, raw);
+    } else if (it.type === "bool") {
+      await api.setConfig(key, raw === "true");
+    } else if (raw === "") {
+      // allow_empty keys treat a blank as an explicit empty value (e.g. disable smtp_user /
+      // youtube_api_proxy) rather than resetting to the env default (AB3).
+      if (it.allow_empty) await api.setConfig(key, "");
+      else if (it.is_set) await api.resetConfig(key); // cleared → fall back to default
+    } else {
+      await api.setConfig(key, it.type === "int" ? Number(raw) : raw);
+    }
+  }
+}
+
 export default function ConfigPanel() {
   const { t } = useTranslation();
   const panel = useTabPanel();
@@ -37,7 +81,6 @@ export default function ConfigPanel() {
   const data = q.data;
 
   const items = useMemo(() => (data ? Object.values(data.groups).flat() : []), [data]);
-  const byKey = useMemo(() => Object.fromEntries(items.map((i) => [i.key, i])), [items]);
   // Baseline draft from the server: non-secrets show their effective value; secrets start empty
   // (write-only — we never load them back).
   const baseline = useMemo(() => {
@@ -46,13 +89,9 @@ export default function ConfigPanel() {
     return m;
   }, [items]);
 
-  const [draft, setDraft] = useState<Record<string, string>>({});
-  // Secrets the admin marked to reset-to-default on the next Save (can't be expressed by
-  // clearing the field, since an empty secret field means "leave unchanged").
-  const [secretReset, setSecretReset] = useState<Record<string, boolean>>({});
   const [saveState, setSaveState] = useState<SaveState>("idle");
   // Bumped after our own save so the draft re-seeds from fresh server values; a plain mid-edit
-  // refetch does NOT (see the effect below).
+  // refetch does NOT (see the seed below).
   const [reseedToken, setReseedToken] = useState(0);
   // One tab per config group (persisted). Called before the loading guard so hook order is
   // stable; the active id is clamped to a real group at render time once data has loaded.
@@ -63,44 +102,22 @@ export default function ConfigPanel() {
   // load, registry change) or an explicit post-save bump — so a refetch that resolves mid-edit
   // (e.g. an invalidation) can no longer clobber the admin's in-progress draft (CB2).
   const dataVersion = useMemo(() => items.map((i) => i.key).join("|"), [items]);
-  // The baseline is read through a ref, not named as a dependency: an unchanged refetch produces a
-  // new object, and re-seeding on that is exactly the clobbering of an in-progress draft that CB2
-  // was about. `dataVersion` (the config SHAPE) and the post-save token are the real triggers.
-  const baselineRef = useRef(baseline);
-  baselineRef.current = baseline;
-  useEffect(() => {
-    setDraft(baselineRef.current);
-    setSecretReset({});
-  }, [dataVersion, reseedToken]);
+  const { draft, setDraft, secretReset, setSecretReset } = useSeededDraft(
+    baseline,
+    `${reseedToken}:${dataVersion}`,
+  );
 
   const isDirty = (it: ConfigItem): boolean => {
     if (it.secret) return (draft[it.key] ?? "").trim() !== "" || !!secretReset[it.key];
     return (draft[it.key] ?? "") !== (baseline[it.key] ?? "");
   };
-  const dirtyKeys = items.filter(isDirty).map((i) => i.key);
-  const dirty = dirtyKeys.length > 0;
+  const dirtyItems = items.filter(isDirty);
+  const dirty = dirtyItems.length > 0;
 
   async function save() {
     setSaveState("saving");
     try {
-      for (const key of dirtyKeys) {
-        const it = byKey[key];
-        if (!it) continue; // dirtyKeys are all config-item keys; skip if somehow not found
-        const raw = draft[key] ?? "";
-        if (it.secret) {
-          if (secretReset[key] && !raw.trim()) await api.resetConfig(key);
-          else if (raw.trim()) await api.setConfig(key, raw);
-        } else if (it.type === "bool") {
-          await api.setConfig(key, raw === "true");
-        } else if (raw === "") {
-          // allow_empty keys treat a blank as an explicit empty value (e.g. disable smtp_user /
-          // youtube_api_proxy) rather than resetting to the env default (AB3).
-          if (it.allow_empty) await api.setConfig(key, "");
-          else if (it.is_set) await api.resetConfig(key); // cleared → fall back to default
-        } else {
-          await api.setConfig(key, it.type === "int" ? Number(raw) : raw);
-        }
-      }
+      await writeConfigItems(dirtyItems, draft, secretReset);
       await qc.invalidateQueries({ queryKey: qk.adminConfig() });
       // The email-not-configured notice reads me.email_configured, which is otherwise only
       // refetched on its own 60s interval — without this it keeps warning about fields the admin
@@ -182,7 +199,7 @@ export default function ConfigPanel() {
   // tab pill carries a dot when that group has unsaved edits, so a draft in a hidden tab is
   // never silently lost behind the global Save bar.
   const activeGroup = groupKeys.includes(tab) ? tab : groupKeys[0];
-  const dirtyByGroup = new Set(dirtyKeys.map((k) => byKey[k]?.group).filter(Boolean));
+  const dirtyByGroup = new Set(dirtyItems.map((i) => i.group).filter(Boolean));
   const groupTabs = data.sections.flatMap((s) =>
     s.groups.map((g) => ({
       id: g,
diff --git a/frontend/src/components/DateFilterSelect.tsx b/frontend/src/components/DateFilterSelect.tsx
index 712411fd..cb93375c 100644
--- a/frontend/src/components/DateFilterSelect.tsx
+++ b/frontend/src/components/DateFilterSelect.tsx
@@ -92,6 +92,8 @@ export default function DateFilterSelect({
     hostsInput: true,
   });
 
+  const { setReference } = pop.refs;
+
   const pick = (value: string) => {
     const change = selectDateChip(value, filters);
     setCustomOpen(change.customOpen);
@@ -105,7 +107,7 @@ export default function DateFilterSelect({
         context="form"
         open={open}
         icon={<CalendarDays className="h-3.5 w-3.5 shrink-0 text-muted" aria-hidden="true" />}
-        ref={pop.refs.setReference}
+        ref={setReference}
         {...pop.getReferenceProps()}
         aria-label={`${t("sidebar.datePresetLabel")}: ${summary}`}
       >
diff --git a/frontend/src/components/DownloadCenter.tsx b/frontend/src/components/DownloadCenter.tsx
index 432ba064..21fd324a 100644
--- a/frontend/src/components/DownloadCenter.tsx
+++ b/frontend/src/components/DownloadCenter.tsx
@@ -45,6 +45,16 @@ import { useDownloadActions, type DownloadTab } from "./useDownloadActions";
 
 const jobKey = (job: DownloadJob) => job.id;
 
+/** The clipboard's text, or null where the browser refuses. Outside the component: the React
+ *  Compiler cannot lower an optional call inside a try yet, and skipped the whole page for it. */
+async function clipboardText(): Promise<string | null> {
+  try {
+    return (await navigator.clipboard?.readText())?.trim() ?? null;
+  } catch {
+    return null; // permission denied or unsupported — the manual paste button still works on a click
+  }
+}
+
 export default function DownloadCenter() {
   const me = useMe();
   const { t } = useTranslation();
@@ -115,12 +125,8 @@ export default function DownloadCenter() {
   // the browser refuses without a click). Only accept an http(s) URL, don't clobber existing text.
   const pasteFromClipboard = async (force = false) => {
     if (!force && addUrl.trim()) return;
-    try {
-      const text = (await navigator.clipboard?.readText())?.trim();
-      if (text && /^https?:\/\/\S+$/i.test(text)) setAddUrl(text);
-    } catch {
-      /* permission denied or unsupported — the manual paste button still works on a click */
-    }
+    const text = await clipboardText();
+    if (text && /^https?:\/\/\S+$/i.test(text)) setAddUrl(text);
   };
 
   const tabs = [
diff --git a/frontend/src/components/DownloadDialog.tsx b/frontend/src/components/DownloadDialog.tsx
index 8594101e..b748d631 100644
--- a/frontend/src/components/DownloadDialog.tsx
+++ b/frontend/src/components/DownloadDialog.tsx
@@ -41,11 +41,12 @@ export default function DownloadDialog({
   const submit = async () => {
     if (!chosen || busy) return;
     setBusy(true);
+    const displayName = name.trim() || undefined;
     try {
       await api.enqueueDownload({
         source,
         profile_id: chosen,
-        display_name: name.trim() || undefined,
+        display_name: displayName,
       });
       invalidateDownloads(qc);
       notify({
@@ -104,7 +105,7 @@ export default function DownloadDialog({
           <ProfileEditor
             onClose={() => {
               setManage(false);
-              profilesQ.refetch();
+              void profilesQ.refetch();
             }}
           />
         </Suspense>
diff --git a/frontend/src/components/Feed.tsx b/frontend/src/components/Feed.tsx
index bd10d7e1..c04ae797 100644
--- a/frontend/src/components/Feed.tsx
+++ b/frontend/src/components/Feed.tsx
@@ -1,4 +1,4 @@
-import { lazy, Suspense, useCallback, useEffect, useRef, useState } from "react";
+import { lazy, Suspense, useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
 import {
   keepPreviousData,
@@ -19,9 +19,9 @@ import {
   RefreshCw,
   Rows3,
   Trash2,
-  Youtube,
   type LucideIcon,
 } from "lucide-react";
+import { YouTubeIcon } from "../lib/brandIcons";
 import { api, HttpError, type FeedFilters, type Video, type VideoStatus } from "../lib/api";
 import i18n from "../i18n";
 import { notifyActionError } from "../lib/actionErrors";
@@ -280,6 +280,8 @@ export default function Feed({
   // onState lets memo(VideoCard) skip re-rendering existing cards on page append.
   const loadedRef = useRef<Video[]>([]);
 
+  // The toast's Undo re-enters onState, a forward reference: through this ref (set below).
+  const onStateRef = useRef<(id: string, status: VideoStatus) => void>(() => {});
   const onState = useCallback(
     (id: string, status: VideoStatus) => {
       setOverrides((o) => ({ ...o, [id]: status }));
@@ -349,11 +351,6 @@ export default function Feed({
     },
     [qc],
   );
-  // The toast's Undo action re-enters onState, which is a forward reference to the binding still
-  // being defined — the same shape PlexPlayer's session reclaim has, and answered the same way.
-  const onStateRef = useRef(onState);
-  // eslint-disable-next-line react-hooks/immutability
-  onStateRef.current = onState;
 
   const onResetState = useCallback(
     (id: string) => {
@@ -404,7 +401,12 @@ export default function Feed({
   );
 
   const loaded: Video[] = (query.data?.pages ?? []).flatMap((p) => p.items);
-  loadedRef.current = loaded;
+  const ytLoaded: Video[] = (ytQuery.data?.pages ?? []).flatMap((p) => p.items);
+  // onState's refs follow each commit: itself, and what the cards show (live search results if on).
+  useLayoutEffect(() => {
+    onStateRef.current = onState;
+    loadedRef.current = ytActive ? ytLoaded : loaded;
+  });
   const withOverrides = (list: Video[]): Video[] =>
     list
       .map((v) => {
@@ -435,8 +437,6 @@ export default function Feed({
   // A separate data source rendered in the same cards/player. No watch-state view filter (the
   // user explicitly searched, so show everything) and no auto-pagination (each page costs quota).
   if (ytActive) {
-    const ytLoaded: Video[] = (ytQuery.data?.pages ?? []).flatMap((p) => p.items);
-    loadedRef.current = ytLoaded;
     const ytItems: Video[] = sortYtResults(
       withOverrides(ytLoaded),
       ytSort.key as SortKey,
@@ -473,7 +473,7 @@ export default function Feed({
               {t("feed.yt.back")}
             </Button>
             <span className="mx-1 h-5 w-px bg-border" aria-hidden="true" />
-            <Youtube className="w-4 h-4 text-accent shrink-0" />
+            <YouTubeIcon className="w-4 h-4 text-accent shrink-0" />
             <span className="text-sm font-semibold truncate">
               {t("feed.yt.resultsFor", { query: ytSearch })}
             </span>
@@ -882,7 +882,7 @@ export default function Feed({
           {filters.q.trim() && !isDemo && (
             <Button
               className="mt-4"
-              icon={<Youtube />}
+              icon={<YouTubeIcon />}
               onClick={() => onYtSearch(filters.q.trim())}
             >
               {t("feed.yt.searchFor", { query: filters.q.trim() })}
diff --git a/frontend/src/components/Header.tsx b/frontend/src/components/Header.tsx
index 0c7e2016..8729df4a 100644
--- a/frontend/src/components/Header.tsx
+++ b/frontend/src/components/Header.tsx
@@ -1,6 +1,6 @@
 import { forwardRef, type ReactNode } from "react";
 import { useTranslation } from "react-i18next";
-import { Youtube } from "lucide-react";
+import { YouTubeIcon } from "../lib/brandIcons";
 import type { Me } from "../lib/api";
 import SearchBar from "./SearchBar";
 import PlexSearchBox from "./PlexSearchBox";
@@ -61,7 +61,7 @@ const Header = forwardRef<
         onGo={() => onYtSearch(trimmed)}
         goLabel={t("header.searchYoutube")}
         goTitle={t("header.searchYoutubeTip")}
-        goIcon={<Youtube className="w-4 h-4" />}
+        goIcon={<YouTubeIcon className="w-4 h-4" />}
         goDisabled={!trimmed || me.is_demo}
       />
     );
diff --git a/frontend/src/components/IssueComposer.dom.test.tsx b/frontend/src/components/IssueComposer.dom.test.tsx
index b1a0ec0a..0af536b4 100644
--- a/frontend/src/components/IssueComposer.dom.test.tsx
+++ b/frontend/src/components/IssueComposer.dom.test.tsx
@@ -153,6 +153,7 @@ beforeEach(() => {
 afterEach(() => {
   cleanup();
   vi.useRealTimers();
+  vi.restoreAllMocks();
 });
 
 let tracker: { repo: string } | null = null;
@@ -167,6 +168,9 @@ function mount() {
   );
 }
 
+/** jsdom lays nothing out, so every element reads as hidden to the dialog's focus rules. */
+const layOut = () =>
+  vi.spyOn(HTMLElement.prototype, "offsetParent", "get").mockReturnValue(document.body);
 const lastSaved = () => api.saved[api.saved.length - 1]!;
 const title = () => screen.getByLabelText("recorder.composer.fieldTitle") as HTMLInputElement;
 /** A button once it can be pressed: `loading` holds it while the draft's first save settles. */
@@ -489,6 +493,24 @@ describe("the issue composer", () => {
     expect(screen.queryByRole("button", { name: /recorder.composer.addStep/ })).toBeNull();
   });
 
+  it("opens on the title, not on the Edit / Preview switch above it", async () => {
+    // The form arrives after the dialog opens; its first control is the switch, and the focus
+    // landed there — typing went nowhere (E32 review round 3).
+    layOut();
+    mount();
+    await waitFor(() => expect(document.activeElement).toBe(title()));
+  });
+
+  it("moves to the title once a retried load brings the form", async () => {
+    layOut();
+    api.failSession = true;
+    mount();
+    const message = await screen.findByText("recorder.composer.loadFailed");
+    api.failSession = false;
+    fireEvent.click(within(message.closest('[role="alert"]')!).getByRole("button"));
+    await waitFor(() => expect(document.activeElement).toBe(title()));
+  });
+
   it("says so when the session cannot be loaded, with a retry", async () => {
     api.failSession = true;
     mount();
@@ -539,6 +561,22 @@ describe("the issue composer", () => {
     expect(api.saved).toHaveLength(0); // sent: nothing to save, only the rest to send
   });
 
+  it("returns the focus to a reviewed log once, not on every way back from the preview", async () => {
+    mount();
+    fireEvent.click(
+      (await screen.findAllByRole("button", { name: "recorder.composer.review" }))[0]!,
+    );
+    fireEvent.click(screen.getByRole("button", { name: "recorder.composer.reviewDone" }));
+    const review = screen.getAllByRole("button", { name: "recorder.composer.review" })[0];
+    expect(document.activeElement).toBe(review);
+    fireEvent.click(screen.getByRole("button", { name: "recorder.composer.preview" }));
+    const edit = screen.getByRole("button", { name: "recorder.composer.edit" });
+    edit.focus();
+    fireEvent.click(edit);
+    await screen.findAllByRole("button", { name: "recorder.composer.review" });
+    expect(document.activeElement).toBe(edit); // the toggle keeps it; the log's button does not take it
+  });
+
   it("previews through the tracker in a frame where no script runs", async () => {
     tracker = { repo: "o/r" };
     mount();
diff --git a/frontend/src/components/IssueComposer.tsx b/frontend/src/components/IssueComposer.tsx
index 09b3f1d0..baed165d 100644
--- a/frontend/src/components/IssueComposer.tsx
+++ b/frontend/src/components/IssueComposer.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useRef, useState, type DragEvent, type MutableRefObject } from "react";
+import { useEffect, useEffectEvent, useMemo, useRef, useState, type DragEvent } from "react";
 import { useTranslation } from "react-i18next";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { ExternalLink, FileText, Plus, Server, X } from "lucide-react";
@@ -132,8 +132,9 @@ function ComposerBody({
   const [reviewing, setReviewing] = useState<Source | null>(null);
   const issueLink = useRef<HTMLAnchorElement>(null);
   const retryButton = useRef<HTMLButtonElement>(null);
-  // The log whose review just closed: its Review button takes the focus back.
-  const reviewed = useRef<Source | null>(null);
+  // The log whose review just closed: its Review button takes the focus back when the attachments
+  // mount again (they unmount while a review is open).
+  const [reviewed, setReviewed] = useState<Source | null>(null);
   const sent = session.issue_url !== null;
 
   const shotsQ = useQuery({
@@ -231,19 +232,17 @@ function ComposerBody({
   });
   const locked = sent || send.isPending || sending;
 
-  const saveRef = useRef(save.mutate);
-  saveRef.current = save.mutate;
+  const saveNow = useEffectEvent(() => save.mutate());
   useEffect(() => {
     if (locked || !unsaved) return;
-    const timer = window.setTimeout(() => saveRef.current(), SAVE_DELAY_MS);
+    const timer = window.setTimeout(() => saveNow(), SAVE_DELAY_MS);
     return () => window.clearTimeout(timer);
   }, [body, form.title, locked, unsaved]);
   // Closed before the typing paused: save what is still waiting, now.
-  const flushRef = useRef(() => {});
-  flushRef.current = () => {
+  const flush = useEffectEvent(() => {
     if (unsaved && !locked) save.mutate();
-  };
-  useEffect(() => () => flushRef.current(), []);
+  });
+  useEffect(() => () => flush(), []);
 
   // Screenshots are added here, not in the attachments column: an image pasted ANYWHERE in the
   // composer is taken — while typing the description is exactly when one is pasted.
@@ -252,8 +251,7 @@ function ComposerBody({
     meta: { failTitle: "recorder.pill.shotFailed" },
     onSuccess: () => refreshShots(qc, session.id),
   });
-  const addRef = useRef(addShot.mutate);
-  addRef.current = addShot.mutate;
+  const addImage = useEffectEvent((image: Blob) => addShot.mutate(image));
   const root = useRef<HTMLDivElement>(null);
   useEffect(() => {
     if (locked) return;
@@ -265,7 +263,7 @@ function ComposerBody({
       const images = [...(e.clipboardData?.files ?? [])].filter(isImage);
       if (!images.length) return;
       e.preventDefault();
-      for (const image of images) addRef.current(image);
+      for (const image of images) addImage(image);
     };
     document.addEventListener("paste", onPaste);
     return () => document.removeEventListener("paste", onPaste);
@@ -393,7 +391,7 @@ function ComposerBody({
             }))
           }
           onDone={() => {
-            reviewed.current = reviewing;
+            setReviewed(reviewing);
             setReviewing(null);
           }}
         />
@@ -414,6 +412,7 @@ function ComposerBody({
             }}
             onReview={setReviewing}
             reviewed={reviewed}
+            setReviewed={setReviewed}
           />
         </div>
       )}
@@ -442,9 +441,8 @@ function ComposerBody({
           {t("recorder.composer.export")}
         </Button>
         {target && !sent && (
-          // `sending` is a send ALREADY under way — from a reload, or from the other tab this one
-          // is a copy of. The button would only earn an `issue_sending` refusal; the banner above
-          // says why it is out.
+          // `sending`: a send already under way (a reload's, or another tab's). The button would only
+          // earn an `issue_sending` refusal; the banner above says why it is out.
           <Button
             variant="primary"
             loading={send.isPending}
@@ -484,6 +482,7 @@ function DraftFields({
         <Input
           className="w-full"
           id="issue-title"
+          data-initial-focus
           value={form.title}
           readOnly={readOnly}
           maxLength={200}
@@ -598,6 +597,7 @@ function Attachments({
   onAdd,
   onReview,
   reviewed,
+  setReviewed,
 }: {
   session: DebugSession;
   shotsQ: { data?: { items: DebugScreenshot[] }; isError: boolean; refetch: () => unknown };
@@ -606,7 +606,8 @@ function Attachments({
   adding: boolean;
   onAdd: (files: Iterable<File>) => void;
   onReview: (source: Source) => void;
-  reviewed: MutableRefObject<Source | null>;
+  reviewed: Source | null;
+  setReviewed: (spent: null) => void;
 }) {
   const { t, i18n } = useTranslation();
   const lang = i18n.language;
@@ -615,14 +616,13 @@ function Attachments({
   // A removed screenshot's ✕ goes with it: the focus moves to the file picker, which stays.
   const pick = useRef<HTMLInputElement>(null);
   const reviewButtons = useRef<Partial<Record<Source, HTMLButtonElement | null>>>({});
-  // eslint-disable-next-line react-hooks/immutability
+  // On mount after a review closed (this list unmounts while one is open), that log's Review button
+  // takes the focus back — once: the spent token keeps a later remount (back from the preview) off it.
   useEffect(() => {
-    const source = reviewed.current;
-    if (!source) return;
-    // eslint-disable-next-line react-hooks/immutability -- a ONE-SHOT token, consumed: the parent sets it to say "give this source's review button the focus back when the list re-renders", and clearing it here is what stops the focus being stolen on every later render. The ref is the caller's, which is why it is a dependency rather than a local.
-    reviewed.current = null;
-    reviewButtons.current[source]?.focus();
-  }, [reviewed]);
+    if (!reviewed) return;
+    reviewButtons.current[reviewed]?.focus();
+    setReviewed(null);
+  }, [reviewed, setReviewed]);
   const remove = useMutation({
     mutationFn: (shotId: number) => api.removeDebugScreenshot(session.id, shotId),
     meta: { failTitle: "recorder.composer.removeShotFailed" },
diff --git a/frontend/src/components/KeyGate.tsx b/frontend/src/components/KeyGate.tsx
index d04b17dc..52716f21 100644
--- a/frontend/src/components/KeyGate.tsx
+++ b/frontend/src/components/KeyGate.tsx
@@ -54,9 +54,8 @@ export default function KeyGate({ meId, compact = false }: { meId: number; compa
       qc.invalidateQueries({ queryKey: qk.messageKey() });
     } catch {
       setErr(configured ? t("messages.wrongPass") : t("messages.setupFailed"));
-    } finally {
-      setBusy(false);
     }
+    setBusy(false);
   }
 
   function toReset() {
@@ -76,8 +75,9 @@ export default function KeyGate({ meId, compact = false }: { meId: number; compa
     setErr(null);
     if (hasPassword && !curPass) return setErr(t("messages.resetNeedPass"));
     setBusy(true);
+    const confirmPass = hasPassword ? curPass : undefined;
     try {
-      await api.resetMessageKey(hasPassword ? curPass : undefined);
+      await api.resetMessageKey(confirmPass);
       // Server key + dead history are gone; wipe this device's identity too so the gate re-appears
       // in setup mode. Invalidate last so the refetch sees configured:false.
       await e2ee.resetLocal(meId);
@@ -86,9 +86,8 @@ export default function KeyGate({ meId, compact = false }: { meId: number; compa
       qc.invalidateQueries({ queryKey: qk.messageKey() });
     } catch (e) {
       setErr(e instanceof HttpError && e.detail ? e.detail : t("messages.resetFailed"));
-    } finally {
-      setBusy(false);
     }
+    setBusy(false);
   }
 
   if (keyQ.isLoading)
diff --git a/frontend/src/components/LanguageSwitcher.tsx b/frontend/src/components/LanguageSwitcher.tsx
index b5c0f8e8..a7a1bebb 100644
--- a/frontend/src/components/LanguageSwitcher.tsx
+++ b/frontend/src/components/LanguageSwitcher.tsx
@@ -44,10 +44,12 @@ export default function LanguageSwitcher({
     selectedIndex: currentIdx,
   });
 
+  const { setReference } = pop.refs;
+
   return (
     <>
       <Pressable
-        ref={pop.refs.setReference}
+        ref={setReference}
         {...pop.getReferenceProps()}
         title={current.label}
         aria-label={current.label}
diff --git a/frontend/src/components/Messages.tsx b/frontend/src/components/Messages.tsx
index 1c1f0742..4b557b82 100644
--- a/frontend/src/components/Messages.tsx
+++ b/frontend/src/components/Messages.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState } from "react";
+import { useEffect, useEffectEvent, useState } from "react";
 import { qk } from "../lib/queryKeys";
 import { useTranslation } from "react-i18next";
 import { useQuery } from "@tanstack/react-query";
@@ -90,19 +90,20 @@ function ConversationList({
   const [previews, setPreviews] = useState<Record<number, string>>({});
 
   // Decrypt conversation previews when fresh data arrives. The TRIGGER is `dataUpdatedAt` and the
-  // payload is read through a ref, which is what makes the dep list below complete without making
-  // the identity of `q.data` a trigger. That distinction is load-bearing: the `?? []` fallback is a
+  // payload is read through an effect event, which is what makes the dep list below complete without
+  // making the identity of `q.data` a trigger. That distinction is load-bearing: the `?? []` fallback is a
   // new array every render, and anything handing back a fresh object per render (a stub, a caller
   // that rebuilds it) turns "re-run when the data changes" into a render loop through setPreviews.
   // Measured the hard way — E27 S2 keyed this on `q.data`, and Messages.keyboard.dom.test hung.
-  const conversationsRef = useRef(q.data);
-  conversationsRef.current = q.data;
+  const latestConversations = useEffectEvent(() => q.data);
   useEffect(() => {
     if (!ready) return;
     let cancelled = false;
-    (async () => {
+    const conversations = latestConversations();
+    // Each decrypt is caught (a failure previews as "⚠"), so this never rejects.
+    void (async () => {
       const out: Record<number, string> = {};
-      for (const c of conversationsRef.current?.items ?? []) {
+      for (const c of conversations?.items ?? []) {
         const m = c.last_message;
         if (m.kind === "user" && m.ciphertext && m.iv) {
           try {
diff --git a/frontend/src/components/NavSidebar.tsx b/frontend/src/components/NavSidebar.tsx
index 64453c31..0ddb0685 100644
--- a/frontend/src/components/NavSidebar.tsx
+++ b/frontend/src/components/NavSidebar.tsx
@@ -74,6 +74,7 @@ export default function NavSidebar({
     placement: "right-end",
     offset: 8,
   });
+  const { setReference: setAcctAnchor } = acctPop.refs;
 
   async function logout() {
     // Signs THIS tab's active account out of the browser wallet (server is per-tab aware); then
@@ -145,7 +146,7 @@ export default function NavSidebar({
 
   // Scroll-affordance for the module list: hidden scrollbar + top/bottom edge fade (shared hook,
   // also used by the side panels) so a high-zoom overflow scrolls without a scrollbar.
-  const listFade = useScrollFade();
+  const { ref: listFadeRef, style: listFadeStyle } = useScrollFade();
 
   type NavItem = { page: Page; icon: LucideIcon; label: string; badge?: number };
   // Per-page presentation (icon/label/badge). WHICH pages appear and in what order — and each
@@ -198,7 +199,7 @@ export default function NavSidebar({
     // against its right edge.
     <div className="relative shrink-0 w-15">
       <NavRail label={t("nav.primary")} className="absolute top-0 bottom-0 left-0 z-rail my-3">
-        <NavRailList ref={listFade.ref} style={listFade.style}>
+        <NavRailList ref={listFadeRef} style={listFadeStyle}>
           {userItems.map(renderItem)}
           {systemItems.length > 0 && (
             <>
@@ -243,7 +244,7 @@ export default function NavSidebar({
 
           <div>
             <Pressable
-              ref={acctPop.refs.setReference}
+              ref={setAcctAnchor}
               {...acctPop.getReferenceProps()}
               title={`${name} · ${roleLabel}`}
               aria-label={`${name} · ${roleLabel}`}
diff --git a/frontend/src/components/NavigationProvider.dom.test.tsx b/frontend/src/components/NavigationProvider.dom.test.tsx
index 764709d6..d7f36e40 100644
--- a/frontend/src/components/NavigationProvider.dom.test.tsx
+++ b/frontend/src/components/NavigationProvider.dom.test.tsx
@@ -84,7 +84,9 @@ describe("NavigationProvider · the tab title", () => {
     await settle();
     expect(document.title).toBe("Siftlode");
 
-    act(() => qc.setQueryData(qk.me(), { id: 1 }));
+    act(() => {
+      qc.setQueryData(qk.me(), { id: 1 });
+    });
     await settle();
     expect(document.title).not.toBe("Siftlode");
     expect(document.title.endsWith(" · Siftlode")).toBe(true);
diff --git a/frontend/src/components/NavigationProvider.tsx b/frontend/src/components/NavigationProvider.tsx
index c17cfc51..158de493 100644
--- a/frontend/src/components/NavigationProvider.tsx
+++ b/frontend/src/components/NavigationProvider.tsx
@@ -1,4 +1,5 @@
-import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
+import { useCallback, useEffect, useMemo, useState, type ReactNode } from "react";
+import { useLatest } from "../lib/useLatest";
 import { useTranslation } from "react-i18next";
 import { useMe } from "../lib/useMe";
 import { urlWithParams, type Page } from "../lib/urlState";
@@ -47,15 +48,11 @@ export function NavigationProvider({ children }: { children: ReactNode }) {
     channelViewFrom(window.history.state, window.location.search),
   );
 
-  // Refs so the STABLE action callbacks can read the latest state without depending on it — a dep
-  // would recreate them on every navigation and re-render every actions consumer (e.g. VideoCard).
-  // Written during render (the sanctioned "latest value" pattern): the ref is only READ in event
-  // handlers after commit, and this provider never suspends or renders in a transition, so no
-  // discarded render can leave it stale.
-  const pageRef = useRef(page);
-  pageRef.current = page;
-  const channelViewRef = useRef(channelView);
-  channelViewRef.current = channelView;
+  // Latest-value refs so the STABLE action callbacks can read the latest state without depending on
+  // it — a dep would recreate them on every navigation and re-render every actions consumer (e.g.
+  // VideoCard). Only READ in event handlers, after commit.
+  const pageRef = useLatest(page);
+  const channelViewRef = useLatest(channelView);
 
   const setPage = useCallback(
     (next: Page, then?: () => void) =>
@@ -101,7 +98,7 @@ export function NavigationProvider({ children }: { children: ReactNode }) {
         notifyNav();
         then?.();
       }),
-    [],
+    [pageRef, channelViewRef],
   );
 
   // A sub-view (channel / YT search) is an OVERLAY, not a page change. Like setPage it never lands
diff --git a/frontend/src/components/OnboardingWizard.tsx b/frontend/src/components/OnboardingWizard.tsx
index 5fb27379..a4db3b82 100644
--- a/frontend/src/components/OnboardingWizard.tsx
+++ b/frontend/src/components/OnboardingWizard.tsx
@@ -2,7 +2,8 @@ import { useEffect, useId, useRef } from "react";
 import { Trans, useTranslation } from "react-i18next";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { qk } from "../lib/queryKeys";
-import { AlertTriangle, Check, Loader2, RefreshCw, ShieldCheck, X, Youtube } from "lucide-react";
+import { AlertTriangle, Check, Loader2, RefreshCw, ShieldCheck, X } from "lucide-react";
+import { YouTubeIcon } from "../lib/brandIcons";
 import { api, type Me } from "../lib/api";
 import { beginGrant, endOnboarding } from "../lib/onboarding";
 import { Button } from "./ui/Button";
@@ -148,13 +149,13 @@ export default function OnboardingWizard({ me, onClose }: { me: Me; onClose: ()
   }, [layer]);
 
   // Are we currently importing (or about to)? Show a progress screen instead of the
-  // "you're connected" step until the first import settles.
+  // "you're connected" step until the first import settles. Once triggered, the mutation itself says
+  // which (pending / success / error) — the trigger ref is the effect's once-only latch, never read
+  // here (a ref read in render made the React Compiler skip the wizard, E32).
   const importing =
     me.can_read &&
     !importSubs.isError &&
-    (importSubs.isPending ||
-      (importTriggered.current && !importSubs.isSuccess) ||
-      (myStatus.data?.channels_total === 0 && !importSubs.isSuccess));
+    (importSubs.isPending || (myStatus.data?.channels_total === 0 && !importSubs.isSuccess));
 
   const step = !me.can_read ? "read" : !me.can_write ? "write" : "done";
   const stepIndex = step === "read" ? 0 : step === "write" ? 1 : 2;
@@ -186,7 +187,7 @@ export default function OnboardingWizard({ me, onClose }: { me: Me; onClose: ()
           {step === "read" && (
             <>
               <div className="mx-auto mb-4 grid place-items-center w-12 h-12 rounded-2xl bg-accent/15 text-accent">
-                <Youtube className="w-6 h-6" />
+                <YouTubeIcon className="w-6 h-6" />
               </div>
               <h2 id={titleId} className="text-lg font-semibold">
                 {t("onboarding.read.title")}
@@ -199,7 +200,7 @@ export default function OnboardingWizard({ me, onClose }: { me: Me; onClose: ()
               </p>
               <ConsentHeadsUp />
               <div className="mt-5 flex flex-col gap-2">
-                <Button size="lg" icon={<Youtube />} onClick={() => beginGrant("read")}>
+                <Button size="lg" icon={<YouTubeIcon />} onClick={() => beginGrant("read")}>
                   {t("onboarding.read.connect")}
                 </Button>
                 <Button variant="ghost" size="md" onClick={close}>
diff --git a/frontend/src/components/PersonalViewsModal.tsx b/frontend/src/components/PersonalViewsModal.tsx
index e4b415a6..8976ee66 100644
--- a/frontend/src/components/PersonalViewsModal.tsx
+++ b/frontend/src/components/PersonalViewsModal.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState } from "react";
+import { useState } from "react";
 import { useTranslation } from "react-i18next";
 import { BookmarkPlus, Check, Play, Save, Star, Trash2 } from "lucide-react";
 import {
@@ -80,6 +80,34 @@ function ViewRow({
   );
 }
 
+/** The SELECTED view's two drafts: its name (the rename field) and a local, undoable draft of its
+ *  captured filters. Removing a chip prunes the filter draft and — via onApply — writes the pruned set
+ *  straight back to the stored view; Undo/Redo re-persist the same way. The draft is the single
+ *  source of truth for the chip row, so a chip-prune refetch (which returns the value we just wrote)
+ *  never clobbers the undo history: both re-seed only when the SELECTION changes (and on Save-current,
+ *  by the caller). Adjusted DURING render against the remembered selection — an effect painted the
+ *  previous view's filters and name for a frame first. `selectedId` is the trigger, `selected` only
+ *  the data. */
+function useSelectedViewDrafts(
+  selected: SavedView | null,
+  selectedId: number | null,
+  updateFilters: (id: number, filters: Record<string, unknown>) => unknown,
+) {
+  const [nameDraft, setNameDraft] = useState("");
+  const filtersDraft = useUndoable<Record<string, unknown>>(selected?.filters ?? {}, {
+    onApply: (f) => {
+      if (selected) void updateFilters(selected.id, f);
+    },
+  });
+  const [seededFor, setSeededFor] = useState<number | null | undefined>(undefined);
+  if (seededFor !== selectedId) {
+    setSeededFor(selectedId);
+    filtersDraft.reset(selected?.filters ?? {});
+    setNameDraft(selected?.name ?? "");
+  }
+  return { filtersDraft, nameDraft, setNameDraft };
+}
+
 export default function PersonalViewsModal() {
   const { t } = useTranslation();
   const {
@@ -107,29 +135,11 @@ export default function PersonalViewsModal() {
   const selected = views.find((v) => v.id === selectedId) ?? null;
   // Two independent name fields: the left one names a NEW view; the right one renames the selected one.
   const [createName, setCreateName] = useState("");
-  const [nameDraft, setNameDraft] = useState("");
-
-  // A local, undoable draft of the SELECTED view's captured filters. Removing a chip prunes the draft
-  // and — via onApply — writes the pruned set straight back to the stored view; Undo/Redo re-persist
-  // the same way. The draft is the single source of truth for the chip row, so a chip-prune refetch
-  // (which returns the value we just wrote) never clobbers the undo history. We only re-seed it on an
-  // external change of the visible filters: switching the selection, or Save-current below.
-  const filtersDraft = useUndoable<Record<string, unknown>>(selected?.filters ?? {}, {
-    onApply: (f) => {
-      if (selected) void updateFilters(selected.id, f);
-    },
-  });
-  const resetDraft = filtersDraft.reset;
-  // Re-seed only when the SELECTION changes, not on every same-view refetch — a refetch returns the
-  // value we just wrote, and re-seeding on it would throw away the prune's undo history. The chosen
-  // view is therefore read through a ref: `selectedId` is the trigger, `selected` is only the data.
-  const selectedRef = useRef(selected);
-  selectedRef.current = selected;
-  useEffect(() => {
-    const view = selectedRef.current;
-    resetDraft(view?.filters ?? {});
-    setNameDraft(view?.name ?? "");
-  }, [selectedId, resetDraft]);
+  const { filtersDraft, nameDraft, setNameDraft } = useSelectedViewDrafts(
+    selected,
+    selectedId,
+    updateFilters,
+  );
 
   // The selected view's captured filters, as the same human labels its module's chip row shows, read
   // from the undoable draft. The feed hook runs unconditionally (fed empty filters off-feed); Plex
@@ -322,7 +332,7 @@ export default function PersonalViewsModal() {
                   const saved = await saveCurrent(selected.id);
                   // Re-seed the draft to what we just stored (the live filters) so the chip row
                   // reflects the save; clears the now-stale undo history.
-                  if (saved) resetDraft(saved);
+                  if (saved) filtersDraft.reset(saved);
                 }}
                 disabled={saveCurrentDisabled}
                 title={
diff --git a/frontend/src/components/PlayerModal.tsx b/frontend/src/components/PlayerModal.tsx
index c816dbac..94983305 100644
--- a/frontend/src/components/PlayerModal.tsx
+++ b/frontend/src/components/PlayerModal.tsx
@@ -6,7 +6,6 @@ import {
   useLayoutEffect,
   useRef,
   useState,
-  type ReactNode,
 } from "react";
 import { useTranslation } from "react-i18next";
 import { createPortal } from "react-dom";
@@ -14,7 +13,7 @@ import { useNavigationActions } from "./navigationContext";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { qk } from "../lib/queryKeys";
 import { usePref } from "../lib/usePref";
-import { PlayerTransportControls } from "./playerModalControls";
+import { PlayerDescription, PlayerTransportControls } from "./playerModalControls";
 import { AUTO_MODES, LOOP_MODES, type AutoMode, type LoopMode } from "../lib/playerModes";
 import {
   AlertTriangle,
@@ -35,6 +34,7 @@ import {
   X,
 } from "lucide-react";
 import Avatar from "./ui/Avatar";
+import { useLatest, useStableCallback } from "../lib/useLatest";
 import AddToPlaylist from "./AddToPlaylist";
 import { PopoverSurface } from "./ui/AnchoredPopover";
 import { useAnchoredPopover } from "./ui/anchoredPopoverHooks";
@@ -56,13 +56,11 @@ import {
   formatCompact,
   relativeTime,
 } from "../lib/format";
-import { renderDescription } from "./descriptionLinks";
 import { fullscreenElement } from "../lib/fullscreen";
 import { dispatch, isActivationTarget, useKeyScope } from "../lib/keymap";
 import { useBackToClose } from "../lib/history";
 import ChannelNameLink from "./ChannelNameLink";
 import Toaster from "./ui/Toaster";
-import { StateMessage } from "./ui/QueryState";
 import { useOverlayOrder } from "./ui/overlayOrder";
 import { afterRemoval } from "../lib/playerQueue";
 import {
@@ -70,6 +68,7 @@ import {
   useYtBigView,
   useYtProgress,
   useYtVolume,
+  YT_API_LOAD_FAILED,
 } from "../lib/playerModalHooks";
 import { useScrollFade } from "../lib/useScrollFade";
 import { Button } from "./ui/Button";
@@ -147,7 +146,7 @@ export default function PlayerModal({
   const lang = i18n.language;
   const { openChannel } = useNavigationActions();
   const qc = useQueryClient();
-  const descFade = useScrollFade();
+  const { ref: descFadeRef, style: descFadeStyle } = useScrollFade();
   // Browser/mouse Back closes the player instead of leaving the page.
   useBackToClose(onClose);
   // Freeze the launch queue: the player steps through the SAME filtered + sorted list it was
@@ -184,13 +183,12 @@ export default function PlayerModal({
   // The launch queue is frozen at mount, so its items keep the position they were snapshotted with;
   // without this map, stepping next→prev back to an item played earlier in the SAME session would
   // resume at that snapshot and then persist it over the newer position.
+  // A position this session already stored wins over `resumeAt` — it is the freshest truth we have —
+  // so the map is read where the player starts (useYtProgress, loadVideo), never during render.
   const sessionPosRef = useRef<Map<string, number>>(new Map());
-  const sessionPos = sessionPosRef.current.get(active.id);
-  // startAt only applies to the item we opened with; advanced items resume their own pos. A
-  // position this session already stored wins over both — it is the freshest truth we have.
+  // startAt only applies to the item we opened with; advanced items resume their own pos.
   const resumeAt =
-    sessionPos ??
-    (startAt != null && active.id === video.id ? startAt : active.position_seconds || 0);
+    startAt != null && active.id === video.id ? startAt : active.position_seconds || 0;
   const mountRef = useRef<HTMLDivElement | null>(null);
   const playerRef = useRef<YTPlayer | null>(null);
   // Keyboard/wheel controls. We keep focus on the modal card (not the cross-origin player
@@ -257,7 +255,6 @@ export default function PlayerModal({
   const {
     isFullscreen,
     maximized,
-    maximizedRef,
     isFullscreenRef,
     toggleFullscreen,
     toggleTrueFullscreen,
@@ -277,17 +274,20 @@ export default function PlayerModal({
   // 100). We overlay a friendly message + "Open on YouTube" instead of YouTube's bare error.
   const [playerError, setPlayerError] = useState<number | null>(null);
 
-  const loadVideo = (id: string, start: number | null) => {
+  // Stable callbacks, not plain closures: both reach the player through refs, and the description's
+  // links get them during render (see PlayerDescription).
+  const loadVideo = useStableCallback((id: string, start: number | null) => {
     const p = playerRef.current;
     if (!p || typeof p.loadVideoById !== "function") return;
     // Explicit start wins; otherwise resume the active item, start others at 0.
-    const startSeconds = start != null ? start : id === active.id ? resumeAt : 0;
+    const startSeconds =
+      start != null ? start : id === active.id ? (sessionPosRef.current.get(id) ?? resumeAt) : 0;
     setPlayerError(null);
     p.loadVideoById({ videoId: id, startSeconds: startSeconds || 0 });
     currentIdRef.current = id;
     setCurrentVideoId(id);
     setLiveData(null);
-  };
+  });
 
   // Local mirror of watch status so the toggle reacts instantly; changes are propagated to the feed
   // (and server) via onState. The mirror carries the id it DESCRIBES, and a write for any other id
@@ -336,19 +336,18 @@ export default function PlayerModal({
     currentIdRef.current = active.id;
   }, [active.id]);
 
-  const seekTo = (seconds: number) => {
+  const seekTo = useStableCallback((seconds: number) => {
     const p = playerRef.current;
     if (p && typeof p.seekTo === "function") {
       p.seekTo(seconds, true);
       p.playVideo?.();
     }
-  };
+  });
 
   // Prev/next stepping through the queue (the feed's order, or a playlist). Read the live
   // queue+index from a ref so the window keydown handler (bound once) always steps from the
   // current position, not a stale closure.
-  const navRef = useRef({ queue, index });
-  navRef.current = { queue, index };
+  const navRef = useLatest({ queue, index });
   const goPrev = () => {
     const { queue: q, index: i } = navRef.current;
     if (q && i > 0) setPlayingId(q[i - 1]!.id);
@@ -371,12 +370,9 @@ export default function PlayerModal({
     if (!onRemoveFromList || removingRef.current) return;
     const victim = active;
     removingRef.current = true;
-    let done = false;
-    try {
-      done = await onRemoveFromList(victim);
-    } finally {
+    const done = await onRemoveFromList(victim).finally(() => {
       removingRef.current = false;
-    }
+    });
     if (!done) return; // the request failed — leave playback alone
     // Decide from where the player is NOW, not where it was when the button was pressed: prev/next
     // and auto-advance keep working while the request runs, and a cursor from before the await
@@ -408,8 +404,7 @@ export default function PlayerModal({
   // so it seeds from the cache — no localStorage mirror. A ref feeds the (once-bound) end handler.
   const [autoMode, setAutoMode] = usePref<AutoMode>("playerAutoAdvance", "off");
   const [loopMode, setLoopMode] = usePref<LoopMode>("playerLoop", "off");
-  const modeRef = useRef({ autoMode, loopMode });
-  modeRef.current = { autoMode, loopMode };
+  const modeRef = useLatest({ autoMode, loopMode });
   const cycleAuto = () => {
     setAutoMode(AUTO_MODES[(AUTO_MODES.indexOf(autoMode) + 1) % AUTO_MODES.length]!);
   };
@@ -466,6 +461,7 @@ export default function PlayerModal({
     placement: "top-start",
     offset: 8,
   });
+  const { setReference: setDescAnchor } = descPop.refs;
   const detail = useQuery({
     queryKey: qk.videoDetail(currentVideoId),
     queryFn: () => api.videoDetail(currentVideoId),
@@ -512,7 +508,7 @@ export default function PlayerModal({
     // all. Both flags, not just fullscreen: since F stopped taking the browser's lock, maximise is the
     // common case and checking only `isFullscreen` made the keys dead exactly where they matter most.
     const volume = (e: KeyboardEvent, up: boolean) => {
-      const covered = isFullscreenRef.current || maximizedRef.current;
+      const covered = isFullscreenRef.current || maximized;
       if (!covered && canScrollBy(document.activeElement as HTMLElement | null, up ? -1 : 1))
         return;
       e.preventDefault();
@@ -542,7 +538,7 @@ export default function PlayerModal({
         // In fullscreen, let the browser's Esc exit fullscreen only — don't also close the modal.
         if (fullscreenElement()) return;
         // Same for our own maximise: Esc steps back out of it before it closes the player.
-        if (maximizedRef.current) {
+        if (maximized) {
           ev.preventDefault();
           setMaximized(false);
           return;
@@ -607,29 +603,13 @@ export default function PlayerModal({
     qc,
   });
 
-  // The description, said the same way in its two places (the popover under 1280 px, the panel
-  // beside the video above it): loading, failed with a retry, the text, or none. One ladder, so the
-  // two cannot drift (E31 review 2: the failed state was tested in the panel only). `wrap` is each
-  // place's own box for the text.
-  const description = (wrap: (body: ReactNode) => ReactNode) =>
-    detail.isLoading ? (
-      <div className="text-sm text-muted">{t("player.loading")}</div>
-    ) : detail.isError && !detail.data ? (
-      <StateMessage tone="error" compact onRetry={() => void detail.refetch()}>
-        {t("player.descriptionFailed")}
-      </StateMessage>
-    ) : detail.data?.description ? (
-      wrap(
-        renderDescription(detail.data.description, {
-          currentId: currentVideoId,
-          onSeek: seekTo,
-          onLoadVideo: loadVideo,
-          t,
-        }),
-      )
-    ) : (
-      <div className="text-sm text-muted">{t("player.noDescription")}</div>
-    );
+  // The description's two places share one ladder (PlayerDescription) and these props.
+  const descriptionProps = {
+    detail,
+    currentId: currentVideoId,
+    onSeek: seekTo,
+    onLoadVideo: loadVideo,
+  };
 
   // Portaled to <body>, like every other full-screen overlay here. A fixed, full-viewport modal
   // must not render inside the page scroller: once that scroller is a stacking context (its
@@ -831,9 +811,11 @@ export default function PlayerModal({
                   <AlertTriangle className="w-8 h-8 text-warn mx-auto mb-3" />
                   <h3 className="text-base font-semibold">{t("player.unavailableTitle")}</h3>
                   <p className="text-sm text-muted mt-1.5 mb-4">
-                    {playerError === 101 || playerError === 150
-                      ? t("player.embedDisabledBody")
-                      : t("player.unavailableBody")}
+                    {playerError === YT_API_LOAD_FAILED
+                      ? t("player.apiLoadFailedBody")
+                      : playerError === 101 || playerError === 150
+                        ? t("player.embedDisabledBody")
+                        : t("player.unavailableBody")}
                   </p>
                   <LinkButton
                     href={`https://www.youtube.com/watch?v=${currentVideoId}`}
@@ -885,7 +867,7 @@ export default function PlayerModal({
                   </h2>
                   {!wide && (
                     <IconButton
-                      ref={descPop.refs.setReference}
+                      ref={setDescAnchor}
                       {...descPop.getReferenceProps()}
                       variant="ghost"
                       aria-expanded={showDesc}
@@ -912,15 +894,12 @@ export default function PlayerModal({
                     <SectionLabel level={3} className="mb-2">
                       {t("player.description")}
                     </SectionLabel>
-                    {description((body) => (
-                      <div
-                        ref={descFade.ref}
-                        style={descFade.style}
-                        className="text-sm whitespace-pre-wrap wrap-break-word max-h-64 overflow-y-auto no-scrollbar leading-relaxed"
-                      >
-                        {body}
-                      </div>
-                    ))}
+                    <PlayerDescription
+                      ref={descFadeRef}
+                      style={descFadeStyle}
+                      className="text-sm whitespace-pre-wrap wrap-break-word max-h-64 overflow-y-auto no-scrollbar leading-relaxed"
+                      {...descriptionProps}
+                    />
                   </PopoverSurface>
                   <Button
                     variant="ghost"
@@ -1101,11 +1080,10 @@ export default function PlayerModal({
                     <SectionLabel level={3} className="mb-2">
                       {t("player.description")}
                     </SectionLabel>
-                    {description((body) => (
-                      <div className="text-sm whitespace-pre-wrap wrap-break-word leading-relaxed">
-                        {body}
-                      </div>
-                    ))}
+                    <PlayerDescription
+                      className="text-sm whitespace-pre-wrap wrap-break-word leading-relaxed"
+                      {...descriptionProps}
+                    />
                   </section>
                 )}
               </div>
diff --git a/frontend/src/components/PlaylistLimitsHint.tsx b/frontend/src/components/PlaylistLimitsHint.tsx
index 33449599..839cb2e9 100644
--- a/frontend/src/components/PlaylistLimitsHint.tsx
+++ b/frontend/src/components/PlaylistLimitsHint.tsx
@@ -22,16 +22,17 @@ export default function PlaylistLimitsHint() {
     placement: "right-end",
     offset: 8,
   });
+  const { setPositionReference, setReference } = pop.refs;
   return (
     // The panel is placed off the whole row, not the "Why?" button: off the button it opened
     // over the right third of the rail and covered the lists (measured on localdev).
     <div
-      ref={pop.refs.setPositionReference}
+      ref={setPositionReference}
       className="mt-2 flex items-center gap-1.5 border-t border-border/60 px-1 pt-2 text-2xs text-muted"
     >
       <Info className="h-3.5 w-3.5 shrink-0" aria-hidden="true" />
       <span>{t("playlists.limits.hint")}</span>
-      <Button variant="link" ref={pop.refs.setReference} {...pop.getReferenceProps()}>
+      <Button variant="link" ref={setReference} {...pop.getReferenceProps()}>
         {t("playlists.limits.why")}
       </Button>
       <PopoverSurface
diff --git a/frontend/src/components/Playlists.dom.test.tsx b/frontend/src/components/Playlists.dom.test.tsx
index eb1988aa..0254e75a 100644
--- a/frontend/src/components/Playlists.dom.test.tsx
+++ b/frontend/src/components/Playlists.dom.test.tsx
@@ -6,6 +6,7 @@
 import { describe, it, expect, vi, afterEach, beforeAll, beforeEach } from "vitest";
 import { render, screen, fireEvent, waitFor, cleanup, act } from "@testing-library/react";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { StrictMode } from "react";
 
 const h = vi.hoisted(() => ({
   notify: vi.fn(),
@@ -112,7 +113,11 @@ const list = (id: number, items: Video[]) => ({
 
 let qc: QueryClient;
 
-function mount(lists: Record<number, Video[]>, prefs: Record<string, unknown> = {}) {
+function mount(
+  lists: Record<number, Video[]>,
+  prefs: Record<string, unknown> = {},
+  { strictOverCache = false } = {},
+) {
   vi.spyOn(api, "playlists").mockResolvedValue(
     Object.entries(lists).map(([id, items]) => list(Number(id), items)) as never,
   );
@@ -121,17 +126,22 @@ function mount(lists: Record<number, Video[]>, prefs: Record<string, unknown> =
   );
   qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
   qc.setQueryData(qk.me(), { id: 1, can_write: true, prefs: {}, preferences: prefs });
+  // Coming back to the page: the selected list is already cached, and StrictMode (dev) runs its
+  // effects twice on that mount.
+  if (strictOverCache && h.selectedId != null)
+    qc.setQueryData(qk.playlist(h.selectedId), list(h.selectedId, lists[h.selectedId] ?? []));
   // The header portals into the shell's fixed toolbar band; without a slot it renders nothing, and
   // it went untested for exactly that reason.
   const slot = document.createElement("div");
   document.body.appendChild(slot);
-  const tree = () => (
+  const page = () => (
     <QueryClientProvider client={qc}>
       <PageToolbarSlot.Provider value={slot}>
         <Playlists />
       </PageToolbarSlot.Provider>
     </QueryClientProvider>
   );
+  const tree = () => (strictOverCache ? <StrictMode>{page()}</StrictMode> : page());
   const view = render(tree());
   return { rerender: () => view.rerender(tree()) };
 }
@@ -177,6 +187,17 @@ describe("Playlists — the row the player is launched with", () => {
   });
 });
 
+describe("Playlists — coming back to the page", () => {
+  it("shows the cached list's rows, not an empty list", async () => {
+    // The seeding effect ran twice over the cached list (StrictMode): reset, then — same membership —
+    // rebase, which rebased the empty list from before the reset and wrote it back. The header read
+    // "0 videos" and the page said the list was empty while the rail counted its rows.
+    mount({ 1: [vid("A", 0), vid("B", 0)] }, {}, { strictOverCache: true });
+    expect(await screen.findByRole("button", { name: "card.play — Video A" })).toBeTruthy();
+    expect(screen.queryByText("playlists.empty")).toBeNull();
+  });
+});
+
 describe("Playlists — removing a video from inside the player", () => {
   it("removes it from the list the player was launched from, even after the selection moved", async () => {
     // The selection can change under an open player (the command palette opens over it); the
diff --git a/frontend/src/components/Playlists.tsx b/frontend/src/components/Playlists.tsx
index 23e7e693..fbcfde4f 100644
--- a/frontend/src/components/Playlists.tsx
+++ b/frontend/src/components/Playlists.tsx
@@ -1,4 +1,5 @@
-import { lazy, Suspense, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { lazy, Suspense, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { useLatest, useStableCallback } from "../lib/useLatest";
 import { useTranslation } from "react-i18next";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { qk } from "../lib/queryKeys";
@@ -18,7 +19,8 @@ import {
   verticalListSortingStrategy,
 } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
-import { Check, FolderInput, History, ListPlus, Play, X, Youtube } from "lucide-react";
+import { Check, FolderInput, History, ListPlus, Play, X } from "lucide-react";
+import { YouTubeIcon } from "../lib/brandIcons";
 import { api, type Playlist, type PlaylistDetail, type Video } from "../lib/api";
 import { notify } from "../lib/notifications";
 import { notifyActionError } from "../lib/actionErrors";
@@ -166,7 +168,7 @@ export default function Playlists() {
   const qc = useQueryClient();
   const plActions = usePlaylistActions();
   const [renaming, setRenaming] = useState(false);
-  const renameFocus = useReturnFocus(renaming);
+  const { target: renameTarget, arm: armRenameReturn } = useReturnFocus(renaming);
   const [renameValue, setRenameValue] = useState("");
   // The stored order is undoable: drag and "save this order" both go through `order.set`, so each
   // is reversible (buttons + Ctrl+Z/Y). onApply persists the new order to the server.
@@ -214,8 +216,7 @@ export default function Playlists() {
   // the actual set of items changes (different playlist, or an add/remove).
   const lastSetRef = useRef<string>("");
   // The selection as of NOW, for code that runs after an await or on behalf of the open player.
-  const selectedRef = useRef(selectedId);
-  selectedRef.current = selectedId;
+  const selectedRef = useLatest(selectedId);
   // Put the rows back to what the CACHED detail says — the server's list as last fetched. A failed
   // reorder or move must not wait for the resync to do it: the server's list is unchanged, so the
   // refetch comes back deep-equal, react-query keeps the same `data` object, and the effect below
@@ -329,12 +330,15 @@ export default function Playlists() {
   // push/delete-on-YouTube paths (usePlaylistActions). Folding it in here would have taken drag and remove away from
   // every account without the scope, which they have always had.
   const canEdit = editable;
-  const canEditRef = useRef(canEdit);
-  canEditRef.current = canEdit;
+  const canEditRef = useLatest(canEdit);
+  // Forward refs to `shown` and `removeItem` (defined further down) for the stable callbacks here,
+  // pointed at the latest values after each commit (below).
+  const shownRef = useRef<Video[]>([]);
+  const removeRef = useRef<typeof removeItem>(async () => false);
 
   // Stable (the memoized row callbacks depend on it), so it reads `shown` through the ref rather
   // than closing over it.
-  const openPlayer = useCallback((id: string) => {
+  const openPlayer = useStableCallback((id: string) => {
     const queue = shownRef.current;
     const index = queue.findIndex((v) => v.id === id);
     if (index < 0) return;
@@ -345,18 +349,14 @@ export default function Playlists() {
       listId: selectedRef.current,
       editable: canEditRef.current,
     });
-  }, []);
-  const onPlay = useCallback((v: Video) => openPlayer(v.id), [openPlayer]);
+  });
   // The player's "remove from this playlist" goes through the SAME removeItem the row menu and the
   // Delete key use — one optimistic update, one undo toast, one undo-stack rebase, no second copy to
   // drift. It answers whether the removal actually happened, because the player has to decide
   // afterwards whether to step to the next item or close. It removes from the list the player was
   // launched from (see `playing.listId`), not from whatever is selected by now.
   const launchListId = playing?.listId ?? null;
-  const removeFromPlayer = useCallback(
-    (v: Video) => removeRef.current(v, launchListId),
-    [launchListId],
-  );
+  const removeFromPlayer = (v: Video) => removeRef.current(v, launchListId);
 
   const storedIndex = useMemo(() => {
     const m = new Map(items.map((v, i) => [v.id, i]));
@@ -378,7 +378,7 @@ export default function Playlists() {
       playlistColumns({
         t,
         indexOf: storedIndex,
-        onPlay,
+        onPlay: (v) => openPlayer(v.id),
         more: (v) => (
           <MoreButton
             label={t("playlists.rowMenu")}
@@ -388,7 +388,7 @@ export default function Playlists() {
           />
         ),
       }),
-    [t, storedIndex, onPlay, rowMenuButton, rowMenuOpen, rowMenuTarget],
+    [t, storedIndex, openPlayer, rowMenuButton, rowMenuOpen, rowMenuTarget],
   );
 
   const filterActive = Object.values(filters).some(isActive);
@@ -396,11 +396,6 @@ export default function Playlists() {
     () => applyView(filterRows(items, columns, filters), columns, viewSort, groupBy, lang),
     [items, columns, filters, viewSort, groupBy, lang],
   );
-  // Read by the drag announcements, which must report the CURRENT positions without making the
-  // announcement closures a render dependency of DndContext.
-  const shownRef = useRef(shown);
-  // eslint-disable-next-line react-hooks/immutability -- the house latest-value ref: the announcement closures must read the CURRENT list without the list becoming a render dependency of DndContext. A render-phase ref write is never part of the rendered output, which is what makes it safe; the checker is conservative about refs an effect also reads.
-  shownRef.current = shown;
 
   const viewActive = !isStoredSort(viewSort) || groupBy || filterActive;
   // Saving a FILTERED view would drop every hidden item from the playlist, so the button only
@@ -460,10 +455,10 @@ export default function Playlists() {
    *  the X column became the Delete key + this toast; no confirm, because nothing is lost).
    *  @returns whether the item was actually removed — the player needs to know, because it must
    *  step to the next item (or close) only when the removal really happened. */
-  async function removeItem(
-    video: Video,
-    listId: number | null = selectedRef.current,
-  ): Promise<boolean> {
+  async function removeItem(video: Video, listIdArg?: number | null): Promise<boolean> {
+    // Defaulted here, not as `listId = selectedRef.current` in the signature: the React Compiler
+    // cannot reorder a ref read in a default parameter and skipped the component for it.
+    const listId = listIdArg === undefined ? selectedRef.current : listIdArg;
     if (listId == null) return false;
     // Only the list ON SCREEN has rows to take the item out of optimistically — the open player can
     // be removing from the list it was launched from while another one is selected.
@@ -534,10 +529,12 @@ export default function Playlists() {
     });
     return true;
   }
-  // Kept in a ref so the memoized column callbacks don't rebuild on every state change.
-  const removeRef = useRef(removeItem);
-  // eslint-disable-next-line react-hooks/immutability -- same latest-value ref as shownRef above — it keeps the memoised column callbacks from rebuilding on every state change.
-  removeRef.current = removeItem;
+  // The drag announcements read `shownRef` too: the CURRENT positions, without making their closures
+  // a render dependency of DndContext; `removeRef` keeps the memoized column callbacks stable.
+  useLayoutEffect(() => {
+    shownRef.current = shown;
+    removeRef.current = removeItem;
+  });
 
   async function moveItemTo(video: Video, target: Playlist) {
     if (selectedId == null) return;
@@ -609,7 +606,7 @@ export default function Playlists() {
 
   // Stable identity: PlayerModal's keydown effect depends on it, so a fresh closure
   // every render re-subscribed those listeners and re-ran focusModal() under the open player.
-  const closePlayer = useCallback(() => setPlaying(null), []);
+  const closePlayer = () => setPlaying(null);
 
   // Name the current view in the user's terms: "Title ↑", "grouped by channel", or both.
   const sortLabel =
@@ -685,7 +682,7 @@ export default function Playlists() {
                       label: plName(pl),
                       icon:
                         pl.source === "youtube" || pl.yt_playlist_id ? (
-                          <Youtube className="w-4 h-4" />
+                          <YouTubeIcon className="w-4 h-4" />
                         ) : (
                           <ListPlus className="w-4 h-4" />
                         ),
@@ -865,11 +862,11 @@ export default function Playlists() {
                       onBlur={saveRename}
                       onKeyDown={(e) => {
                         if (e.key === "Enter") {
-                          renameFocus.arm(e);
-                          saveRename();
+                          armRenameReturn(e);
+                          void saveRename(); // plActions.rename reports its own failure
                         }
                         if (e.key === "Escape") {
-                          renameFocus.arm(e);
+                          armRenameReturn(e);
                           setRenaming(false);
                         }
                       }}
@@ -901,7 +898,7 @@ export default function Playlists() {
                     {/* Rename, the pin, YouTube (open / push / revert) and Delete: the list's ONE
                       menu (E28 C1), the same the rail row opens — the header keeps Play all. */}
                     <MoreButton
-                      ref={renameFocus.target}
+                      ref={renameTarget}
                       variant="outline"
                       label={t("playlists.railMenu")}
                       expanded={headerMenu.open}
diff --git a/frontend/src/components/PlaylistsRail.tsx b/frontend/src/components/PlaylistsRail.tsx
index ccc49e7f..b1983b77 100644
--- a/frontend/src/components/PlaylistsRail.tsx
+++ b/frontend/src/components/PlaylistsRail.tsx
@@ -2,7 +2,8 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { qk } from "../lib/queryKeys";
-import { ListVideo, Pin, Plus, RefreshCw, Youtube } from "lucide-react";
+import { ListVideo, Pin, Plus, RefreshCw } from "lucide-react";
+import { YouTubeIcon } from "../lib/brandIcons";
 import { api, type Playlist } from "../lib/api";
 import { compareText } from "../lib/collate";
 import { formatRuntime } from "../lib/format";
@@ -162,9 +163,8 @@ export default function PlaylistsRail({
       notify({ level: "success", message: t("playlists.syncedToast", { count: r.synced }) });
     } catch (e) {
       notifyYouTubeActionError(e, t("playlists.syncFailed"));
-    } finally {
-      setSyncing(false);
     }
+    setSyncing(false);
   }
 
   const createMut = useMutation({
@@ -360,7 +360,7 @@ export default function PlaylistsRail({
                       <div className="flex items-center gap-1 text-[0.8125rem] text-fg">
                         <span className="truncate">{plName(pl)}</span>
                         {(pl.source === "youtube" || pl.yt_playlist_id) && (
-                          <Youtube
+                          <YouTubeIcon
                             className={`w-3 h-3 shrink-0 ${pl.dirty ? "text-accent" : "text-muted"}`}
                           />
                         )}
diff --git a/frontend/src/components/PlexBrowse.tsx b/frontend/src/components/PlexBrowse.tsx
index 1259f6b8..9cf081ac 100644
--- a/frontend/src/components/PlexBrowse.tsx
+++ b/frontend/src/components/PlexBrowse.tsx
@@ -143,12 +143,22 @@ export default function PlexBrowse() {
     }
   }, [openPlaylist, sub, setPlaylistOpen]);
 
+  // Like the grid's scroll memory (below), for the info page: "Browse collection" (onFilter) leaves
+  // the info view for a filtered grid, and browser Back returns to this same info page — restore
+  // where the user had scrolled it (down to a collection strip) instead of snapping to the top. Reset
+  // on a fresh info open so a different title's info starts at the top.
+  const infoScrollRef = useRef(0);
+  // ONE writer for that memory, so "stash on the way out of an info page, reset on a fresh one" is a
+  // rule the code holds rather than one spread over the call sites. Declared above the effects that
+  // use it: an effect closing over the ref before its declaration made the compiler skip PlexBrowse.
+  const rememberInfoScroll = (px: number) => void (infoScrollRef.current = px);
+
   // The header search typeahead picked a title → open it the same way a card click would (a movie's
   // info page like the card menu's "Media info", a show's drill-down), then clear the hand-off so it
   // doesn't re-open.
   useEffect(() => {
     if (jumpTo != null) {
-      if (jumpTo.type !== "show") infoScrollRef.current = 0; // a jumped-to info page starts at the top
+      if (jumpTo.type !== "show") rememberInfoScroll(0); // a jumped-to info page starts at the top
       sub.open(
         jumpTo.type === "show"
           ? { kind: "show", id: jumpTo.id }
@@ -187,22 +197,6 @@ export default function PlexBrowse() {
   // restore it when we come back — so the browser/mouse Back from the player lands on the same card
   // instead of the top of the library. The scroller is App's <main> (the page's overflow-y-auto).
   const scrollRef = useRef(0);
-  // Same idea for the info page: "Browse collection" (onFilter) leaves the info view for a filtered
-  // grid, and browser Back returns to this same info page — restore where the user had scrolled it
-  // (down to a collection strip) instead of snapping to the top. Reset on a fresh info open so a
-  // different title's info starts at the top.
-  const infoScrollRef = useRef(0);
-  // ONE writer for that memory, so "stash on the way out of an info page, reset on a fresh one" is a
-  // rule the code holds rather than one spread over four call sites — and so the compiler's
-  // complaint about it is answered once, here, instead of at each of them.
-  //
-  // The complaint is a false positive of a conservative analysis, not a hazard: the rule objects to a
-  // ref being written outside the effect that reads it, but that IS the arrangement a scroll memory
-  // needs — the navigation handlers record where the page was, and the restore layout effect above
-  // reads it on the way back. React's own guarantee (a ref write is never part of rendering) is what
-  // makes it safe, and nothing here reads the value during render.
-  // eslint-disable-next-line react-hooks/immutability
-  const rememberInfoScroll = (px: number) => void (infoScrollRef.current = px);
   // One menu for the titles grid and one for the search's episodes (see ui/ContextMenu).
   const menu = useContextMenu<PlexCard>();
   const epMenu = useContextMenu<PlexCard>();
@@ -289,7 +283,7 @@ export default function PlexBrowse() {
       // belong: `setFilters` belongs to PlexProvider, and React only permits a render-phase setState
       // on the component's OWN state. The cascade the rule warns about is bounded to one extra pass
       // — the guard above is false immediately afterwards.
-      // eslint-disable-next-line react-hooks/set-state-in-effect
+      // eslint-disable-next-line react-hooks/set-state-in-effect -- setFilters is PlexProvider's state, so it cannot reset during render; the cascade is one bounded pass
       setCommittedLang(lang);
       if (filters.genres.length) setFilters({ ...filters, genres: [] });
     }
diff --git a/frontend/src/components/PlexCollectionEditor.tsx b/frontend/src/components/PlexCollectionEditor.tsx
index 0fa001e2..dea1eb37 100644
--- a/frontend/src/components/PlexCollectionEditor.tsx
+++ b/frontend/src/components/PlexCollectionEditor.tsx
@@ -34,8 +34,8 @@ export default function PlexCollectionEditor({
   const { t } = useTranslation();
   const qc = useQueryClient();
   const confirm = useConfirm();
-  const editableFade = useScrollFade();
-  const othersFade = useScrollFade();
+  const { ref: editableFadeRef, style: editableFadeStyle } = useScrollFade();
+  const { ref: othersFadeRef, style: othersFadeStyle } = useScrollFade();
   const [members, setMembers] = useState<Set<string>>(() => new Set(memberOf));
   const [q, setQ] = useState("");
   const [newName, setNewName] = useState("");
@@ -86,9 +86,8 @@ export default function PlexCollectionEditor({
       // simply never appeared and the user clicked again — a collection deleted on the Plex server
       // or flipped read-only failed in silence (deep-review round 5).
       notifyActionError(e, t("plex.collection.editFailed"));
-    } finally {
-      setBusy(null);
     }
+    setBusy(null);
   }
 
   async function markEditable(id: string) {
@@ -99,9 +98,8 @@ export default function PlexCollectionEditor({
       refresh();
     } catch (e) {
       notifyActionError(e, t("plex.collection.editFailed"));
-    } finally {
-      setBusy(null);
     }
+    setBusy(null);
   }
 
   async function createNew() {
@@ -117,9 +115,8 @@ export default function PlexCollectionEditor({
       // The backend rejects a duplicate name with 409 (Plex conflates same names), structured — so
       // it reads in the reader's language (see localizeDetail).
       notifyActionError(e, t("plex.collection.editFailed"));
-    } finally {
-      setBusy(null);
     }
+    setBusy(null);
   }
 
   async function removeCollection(id: string, title: string) {
@@ -138,9 +135,8 @@ export default function PlexCollectionEditor({
       // The worst of the three to lose: the user has just confirmed a destructive dialog, and the
       // row stayed where it was with nothing said.
       notifyActionError(e, t("plex.collection.deleteFailed"));
-    } finally {
-      setBusy(null);
     }
+    setBusy(null);
   }
 
   return (
@@ -182,8 +178,8 @@ export default function PlexCollectionEditor({
 
       {/* Editable collections with in/out toggle */}
       <div
-        ref={editableFade.ref}
-        style={editableFade.style}
+        ref={editableFadeRef}
+        style={editableFadeStyle}
         className="max-h-80 space-y-1 overflow-y-auto no-scrollbar"
       >
         {listQ.isLoading ? (
@@ -234,8 +230,8 @@ export default function PlexCollectionEditor({
             {t("plex.collEditor.others", { count: eligible.length })}
           </summary>
           <div
-            ref={othersFade.ref}
-            style={othersFade.style}
+            ref={othersFadeRef}
+            style={othersFadeStyle}
             className="mt-2 max-h-40 space-y-1 overflow-y-auto no-scrollbar"
           >
             {eligible.map((c) => (
diff --git a/frontend/src/components/PlexCollectionView.tsx b/frontend/src/components/PlexCollectionView.tsx
index eef531e0..59286276 100644
--- a/frontend/src/components/PlexCollectionView.tsx
+++ b/frontend/src/components/PlexCollectionView.tsx
@@ -101,7 +101,7 @@ export default function PlexCollectionView({
   const d = q.data;
 
   const [renaming, setRenaming] = useState(false);
-  const renameFocus = useReturnFocus(renaming);
+  const { target: renameTarget, arm: armRenameReturn } = useReturnFocus(renaming);
   const [name, setName] = useState("");
   const [adding, setAdding] = useState(false);
   const [busy, setBusy] = useState(false);
@@ -157,9 +157,8 @@ export default function PlexCollectionView({
       else notify({ level: "info", message: t("plex.collection.playEmpty") });
     } catch (e) {
       notifyActionError(e, t("plex.collection.playFailed"));
-    } finally {
-      setQueueBusy(false);
     }
+    setQueueBusy(false);
   }
 
   const canEdit = isAdmin && !!d?.can_edit;
@@ -213,9 +212,8 @@ export default function PlexCollectionView({
     } catch (e) {
       // The backend enforces per-library name uniqueness — a taken name comes back localized.
       notifyActionError(e, t("plex.collection.editFailed"));
-    } finally {
-      setBusy(false);
     }
+    setBusy(false);
   }
 
   async function doDelete() {
@@ -243,9 +241,8 @@ export default function PlexCollectionView({
       invalidate();
     } catch (e) {
       notifyActionError(e, t("plex.collection.editFailed"));
-    } finally {
-      setBusy(false);
     }
+    setBusy(false);
   }
 
   async function enableEdit() {
@@ -255,9 +252,8 @@ export default function PlexCollectionView({
       invalidate();
     } catch (e) {
       notifyActionError(e, t("plex.collection.editFailed"));
-    } finally {
-      setBusy(false);
     }
+    setBusy(false);
   }
 
   const meta = [
@@ -301,11 +297,11 @@ export default function PlexCollectionView({
                 onBlur={doRename}
                 onKeyDown={(e) => {
                   if (e.key === "Enter") {
-                    renameFocus.arm(e);
-                    doRename();
+                    armRenameReturn(e);
+                    void doRename(); // reports its own failure
                   }
                   if (e.key === "Escape") {
-                    renameFocus.arm(e);
+                    armRenameReturn(e);
                     setRenaming(false);
                   }
                 }}
@@ -367,7 +363,7 @@ export default function PlexCollectionView({
               {canEdit && (
                 <>
                   <ActionBtn
-                    ref={renameFocus.target}
+                    ref={renameTarget}
                     onClick={() => {
                       setName(d.title);
                       setRenaming(true);
diff --git a/frontend/src/components/PlexInfo.dom.test.tsx b/frontend/src/components/PlexInfo.dom.test.tsx
index 737e7f4d..70a55c88 100644
--- a/frontend/src/components/PlexInfo.dom.test.tsx
+++ b/frontend/src/components/PlexInfo.dom.test.tsx
@@ -300,6 +300,17 @@ describe("PlexInfo — the hero's second column (page)", () => {
     expect(screen.getByTestId("detail-aside").textContent).toContain(`Person ${CREW_SHOWN + 1}`);
     expect(screen.queryByRole("button", { name: "plex.info.crewMore" })).toBeNull();
   });
+
+  // E32 S2: the cast row is the shared CastRow now; the page and the player's overlay hand it their
+  // own palette. Only the overlay sits on the dark art, so only it may carry the white text.
+  it.each([
+    ["page", false],
+    ["overlay", true],
+  ] as const)("the %s variant's cast row takes its own palette", (variant, white) => {
+    wrap(<PlexInfo onPlayItem={noop} detail={full} variant={variant} />);
+    expect(screen.getByText("An Actor").className.includes("text-white/90")).toBe(white);
+    expect(screen.getByText("Hero").className.includes("text-muted")).toBe(!white);
+  });
 });
 
 // E28 review D1 + D2: a collection sibling is a Plex card like any other — its "…" menu, its watched
diff --git a/frontend/src/components/PlexInfo.tsx b/frontend/src/components/PlexInfo.tsx
index 7d9d57f6..1242b324 100644
--- a/frontend/src/components/PlexInfo.tsx
+++ b/frontend/src/components/PlexInfo.tsx
@@ -19,7 +19,6 @@ import { Carousel } from "./ui/Carousel";
 import PlexCollectionEditor from "./PlexCollectionEditor";
 import PlexPlaylistAdd from "./PlexPlaylistAdd";
 import { PLAYABLE_TINT, playableClass } from "./plexPlayable";
-import { navItemAttrs } from "../lib/listNav";
 import { Button } from "./ui/Button";
 import { IconButton } from "./ui/IconButton";
 import { Pressable } from "./ui/Pressable";
@@ -27,7 +26,7 @@ import { SURFACE } from "./ui/surfaces";
 import { Badge } from "./ui/Badge";
 import { IconLink } from "./ui/LinkButton";
 import { PageHeading } from "./ui/Headings";
-import { PlexPosterCard } from "./plexCards";
+import { CastRow, PlexPosterCard } from "./plexCards";
 import { PlexMenu } from "./PlexMenu";
 import { useContextMenu } from "./ui/useContextMenu";
 import { usePlexCardActions } from "./usePlexCardActions";
@@ -594,71 +593,12 @@ export default function PlexInfo({
               <h2 className={`mb-2 text-sm font-semibold ${overlay ? "text-white/80" : ""}`}>
                 {t("plex.info.cast")}
               </h2>
-              <Carousel
-                ariaLabel={t("plex.info.cast")}
-                gap="gap-3"
-                keyboardNav={!!(onOpenPerson || onFilter)}
-              >
-                {cast.map((c, i) => {
-                  const clickable = !!(onOpenPerson || onFilter);
-                  const inner = (
-                    <>
-                      <div
-                        className={`mx-auto mb-1 h-20 w-20 overflow-hidden rounded-full border ${
-                          overlay ? "border-white/15 bg-white/10" : "border-border bg-surface"
-                        } ${clickable ? "group-hover/cast:border-accent" : ""}`}
-                      >
-                        {c.thumb ? (
-                          <img src={c.thumb} alt="" className="h-full w-full object-cover" />
-                        ) : (
-                          <div
-                            className={`grid h-full w-full place-items-center text-lg opacity-40 ${overlay ? "text-white" : ""}`}
-                          >
-                            {c.name.charAt(0)}
-                          </div>
-                        )}
-                      </div>
-                      <div
-                        className={`truncate text-xs font-medium ${overlay ? "text-white/90" : ""} ${
-                          clickable ? "group-hover/cast:text-accent" : ""
-                        }`}
-                      >
-                        {c.name}
-                      </div>
-                      {c.role && (
-                        <div
-                          className={`truncate text-2xs ${overlay ? "text-white/55" : "text-muted"}`}
-                        >
-                          {c.role}
-                        </div>
-                      )}
-                    </>
-                  );
-                  return clickable ? (
-                    <Pressable
-                      selectable
-                      key={i}
-                      align="center"
-                      {...navItemAttrs(i)}
-                      onClick={() =>
-                        onOpenPerson ? onOpenPerson(c.name) : onFilter?.({ actors: [c.name] })
-                      }
-                      title={
-                        onOpenPerson
-                          ? t("plex.info.viewPerson", { name: c.name })
-                          : t("plex.info.filterActor", { name: c.name })
-                      }
-                      className="group/cast w-20 shrink-0"
-                    >
-                      {inner}
-                    </Pressable>
-                  ) : (
-                    <div key={i} className="w-20 shrink-0 text-center">
-                      {inner}
-                    </div>
-                  );
-                })}
-              </Carousel>
+              <CastRow
+                cast={cast}
+                tone={overlay ? "overlay" : "panel"}
+                onFilter={onFilter}
+                onOpenPerson={onOpenPerson}
+              />
             </div>
           );
           if (overlay)
diff --git a/frontend/src/components/PlexPlayer.controls.dom.test.tsx b/frontend/src/components/PlexPlayer.controls.dom.test.tsx
index a56bd335..43a60a9d 100644
--- a/frontend/src/components/PlexPlayer.controls.dom.test.tsx
+++ b/frontend/src/components/PlexPlayer.controls.dom.test.tsx
@@ -219,7 +219,9 @@ describe("a tap on the picture (C3)", () => {
     video()._paused = true;
     act(() => void video().play());
     expect(bandHidden()).toBe(false);
-    act(() => vi.advanceTimersByTime(3000));
+    act(() => {
+      vi.advanceTimersByTime(3000);
+    });
     expect(bandHidden()).toBe(true);
   });
 });
@@ -247,10 +249,14 @@ describe("keyboard focus in the bands", () => {
     fireEvent.keyDown(document.body, { key: "Tab" }); // the keyboard is in use: focus shows
     act(() => vol.focus());
     fireEvent.keyDown(vol, { key: "ArrowUp" });
-    act(() => vi.advanceTimersByTime(5000));
+    act(() => {
+      vi.advanceTimersByTime(5000);
+    });
     expect(bandHidden()).toBe(false);
     act(() => vol.blur());
-    act(() => vi.advanceTimersByTime(3000));
+    act(() => {
+      vi.advanceTimersByTime(3000);
+    });
     expect(bandHidden()).toBe(true);
   });
 
@@ -264,9 +270,13 @@ describe("keyboard focus in the bands", () => {
     fireEvent.keyDown(document.body, { key: "Tab" });
     act(() => vol.focus());
     fireEvent.keyDown(vol, { key: "ArrowUp" });
-    act(() => vi.advanceTimersByTime(9000));
+    act(() => {
+      vi.advanceTimersByTime(9000);
+    });
     expect(bandHidden()).toBe(false);
-    act(() => vi.advanceTimersByTime(1500));
+    act(() => {
+      vi.advanceTimersByTime(1500);
+    });
     expect(bandHidden()).toBe(true);
     expect(document.activeElement).toBe(vol);
     fireEvent.keyDown(vol, { key: "ArrowUp" });
@@ -283,7 +293,9 @@ describe("keyboard focus in the bands", () => {
     fireEvent.keyDown(document.body, { key: "Tab" });
     act(() => mute.focus());
     fireEvent.keyDown(mute, { key: "ArrowUp" });
-    act(() => vi.advanceTimersByTime(10_500));
+    act(() => {
+      vi.advanceTimersByTime(10_500);
+    });
     expect(bandHidden()).toBe(true);
     const pauses = pause.mock.calls.length;
     // prevented: the unseen Mute is not pressed on keyup
@@ -304,7 +316,9 @@ describe("keyboard focus in the bands", () => {
     fireEvent.keyDown(document.body, { key: "Tab" });
     act(() => mute.focus());
     fireEvent.keyDown(mute, { key: "ArrowUp" });
-    act(() => vi.advanceTimersByTime(10_500));
+    act(() => {
+      vi.advanceTimersByTime(10_500);
+    });
     expect(bandHidden()).toBe(true);
     const pauses = pause.mock.calls.length;
     expect(fireEvent.keyDown(mute, { key: "Enter" })).toBe(false);
@@ -325,7 +339,9 @@ describe("keyboard focus in the bands", () => {
       fireEvent.keyDown(document.body, { key: "Tab" });
       act(() => mute.focus());
       fireEvent.keyDown(mute, { key: "ArrowUp" });
-      act(() => vi.advanceTimersByTime(10_500));
+      act(() => {
+        vi.advanceTimersByTime(10_500);
+      });
       expect(bandHidden()).toBe(true);
       expect(fireEvent.keyDown(mute, { key })).toBe(false);
       const toggles = pause.mock.calls.length + play.mock.calls.length;
@@ -352,7 +368,9 @@ describe("keyboard focus in the bands", () => {
     const skip = screen.getByRole("button", { name: /plex\.player\.skipIntro/ });
     fireEvent.keyDown(document.body, { key: "Tab" });
     act(() => skip.focus());
-    act(() => vi.advanceTimersByTime(10_500));
+    act(() => {
+      vi.advanceTimersByTime(10_500);
+    });
     expect(bandHidden()).toBe(true);
     const pauses = pause.mock.calls.length;
     // not prevented: the button's own activation runs, and Space does not pause the film instead
@@ -377,7 +395,9 @@ describe("keyboard focus in the bands", () => {
       return sel === ":focus-visible" ? false : matches.call(this, sel);
     });
     act(() => btn.focus());
-    act(() => vi.advanceTimersByTime(3000));
+    act(() => {
+      vi.advanceTimersByTime(3000);
+    });
     expect(bandHidden()).toBe(true);
     act(() => btn.blur()); // the tap on the picture takes the focus first…
     pressPicture("touch"); // …then toggles
@@ -428,7 +448,9 @@ describe("a double-tap on a side third skips 10 s (C5)", () => {
     pressPicture("touch", 450); // reveal
     expect(bandHidden()).toBe(false);
     expect(band()).toContain("pointer-events-none");
-    act(() => vi.advanceTimersByTime(300));
+    act(() => {
+      vi.advanceTimersByTime(300);
+    });
     expect(band()).not.toContain("pointer-events-none");
   });
 
diff --git a/frontend/src/components/PlexPlayer.session.dom.test.tsx b/frontend/src/components/PlexPlayer.session.dom.test.tsx
index 650282ed..cbb3d66e 100644
--- a/frontend/src/components/PlexPlayer.session.dom.test.tsx
+++ b/frontend/src/components/PlexPlayer.session.dom.test.tsx
@@ -270,7 +270,9 @@ describe("the subtitle poll and notice", () => {
 it("shows a toast raised while it is open inside itself, not under its scrim", async () => {
   mount({ details: { A: item("A") }, sessions: { A: () => new Promise(() => {}) } });
   await screen.findByText("Title A");
-  act(() => notify({ level: "error", message: "Couldn't mark it watched." }));
+  act(() => {
+    notify({ level: "error", message: "Couldn't mark it watched." });
+  });
   const toast = await screen.findByText("Couldn't mark it watched.");
   let host: Element | null = video();
   while (host && !host.contains(toast)) host = host.parentElement;
diff --git a/frontend/src/components/PlexPlayer.tsx b/frontend/src/components/PlexPlayer.tsx
index 837d2563..23f382b0 100644
--- a/frontend/src/components/PlexPlayer.tsx
+++ b/frontend/src/components/PlexPlayer.tsx
@@ -1,4 +1,4 @@
-import { lazy, Suspense, useCallback, useEffect, useRef, useState } from "react";
+import { lazy, Suspense, useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
 import { qk } from "../lib/queryKeys";
 import { createPortal } from "react-dom";
 import { useTranslation } from "react-i18next";
@@ -27,8 +27,10 @@ import {
   Volume2,
   VolumeX,
 } from "lucide-react";
-import { api, HttpError, type PlexTrackNaming } from "../lib/api";
+import { api, HttpError, type PlexPlaySession, type PlexTrackNaming } from "../lib/api";
 import { notifyActionError } from "../lib/actionErrors";
+import { useLatest } from "../lib/useLatest";
+import { seekableEndOf } from "../lib/seekableEnd";
 import {
   audioOrdForLang,
   clockParts,
@@ -67,7 +69,6 @@ import {
   useHelpConditions,
   useKeyboardHelpOpen,
   useKeyScope,
-  usePaletteOpen,
 } from "../lib/keymap";
 import { LS, useAccountPersistedObject } from "../lib/storage";
 import { useDismiss } from "../lib/useDismiss";
@@ -137,8 +138,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
   // through a ref — keeping it OUT of loadSession's deps. Otherwise a mid-playback language change
   // rebuilt loadSession → re-ran the detail effect → reloaded the session from the STALE saved resume
   // position (losing live progress). See the detail effect's deps.
-  const tRef = useRef(t);
-  tRef.current = t;
+  const tRef = useLatest(t);
   // E30: a track named in the reader's language (lib/vocab), not in the Plex server's ("English (AC3 5.1)").
   const audioName = (a: PlexTrackNaming) => trackLabel(t, a, "audio", i18n.language);
   const subtitleName = (x: PlexTrackNaming) => trackLabel(t, x, "subtitle", i18n.language);
@@ -197,21 +197,19 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
   // Whether the current HW transcode tone-mapped a 10-bit/HDR source on the GPU (OpenCL). Feeds the
   // stats mode row's "· HDR→SDR" tag; null/false for an 8-bit HW, software, or non-transcode session.
   const tonemapRef = useRef<boolean | null>(null);
-  const durationRef = useRef(0);
+  const durationRef = useLatest(duration);
   // Rolling per-fragment bitrate meter for the stats overlay. Fed from hls.js FRAG_LOADED below and
   // reset with each session, because the master playlist's own BANDWIDTH is not a measurement — for a
   // remux it is the AAC track's nominal 192k + 10%, i.e. a constant 211 kbps (see plexStats.ts).
   const fragMeterRef = useRef(createFragMeter());
   // ≥2 audio tracks → multi-rendition HLS: all tracks ship in one session and hls.js switches audio
   // client-side (no restart). Ref so the stable loadSession/changeAudio callbacks read it fresh.
-  const multiAudioRef = useRef(false);
-  multiAudioRef.current = (detail?.audio_streams.length ?? 0) > 1;
+  const multiAudioRef = useLatest((detail?.audio_streams.length ?? 0) > 1);
 
   const [playing, setPlaying] = useState(false);
   const [abs, setAbs] = useState(0); // absolute current time
   // Live mirror of `abs` for stable callbacks + the progress checkpoint (seek/skip/ended write it too).
-  const absRef = useRef(0);
-  absRef.current = abs;
+  const absRef = useLatest(abs);
   // Where the current session was ASKED to start — set before the request goes out, so the subtitle
   // poll has a position before `sessionK` (the session's answer) and before the first timeupdate.
   const loadStartRef = useRef(0);
@@ -244,21 +242,16 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
   );
   const { volume, muted } = prefs;
   // Refs for values read inside stable callbacks / the keyboard handler (avoid stale closures).
-  const barAutoHideRef = useRef(prefs.barAutoHide);
-  barAutoHideRef.current = prefs.barAutoHide;
+  const barAutoHideRef = useLatest(prefs.barAutoHide);
   // The two language prefs are read only at ITEM LOAD (the detail effect below), so they go through
   // a ref for the same reason `tRef` above does: naming them in that effect's deps would re-run it
   // when the user picks a track from the player's own menu, double-loading the session the picker
   // has already reloaded. The ref says "latest value, but not a trigger" in code, which an excused
   // dep list only said in prose. Same shape as barAutoHideRef/seekStepRef either side of this.
-  const langPrefsRef = useRef({ audioLang: prefs.audioLang, subLang: prefs.subLang });
-  langPrefsRef.current = { audioLang: prefs.audioLang, subLang: prefs.subLang };
-  const seekStepRef = useRef(prefs.seekStep);
-  seekStepRef.current = prefs.seekStep;
-  const fineSeekStepRef = useRef(prefs.fineSeekStep);
-  fineSeekStepRef.current = prefs.fineSeekStep;
-  const aoffRef = useRef(prefs.audioOffset);
-  aoffRef.current = prefs.audioOffset;
+  const langPrefsRef = useLatest({ audioLang: prefs.audioLang, subLang: prefs.subLang });
+  const seekStepRef = useLatest(prefs.seekStep);
+  const fineSeekStepRef = useLatest(prefs.fineSeekStep);
+  const aoffRef = useLatest(prefs.audioOffset);
   const [menuOpen, setMenuOpen] = useState(false); // the tuning panel (tabbed), from ⋯ → Settings
   // The fixed ⋯ (C5): the rare tools — settings, media info, stats, shortcuts, the original file.
   const [moreOpen, setMoreOpen] = useState(false);
@@ -267,10 +260,10 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
     "sync",
   );
   const audioRef = useRef<number | null>(null);
-  const menuOpenRef = useRef(false);
+  // keep the control bar up while one is open
+  const menuOpenRef = useLatest(menuOpen || tracksOpen || moreOpen);
   const menuRef = useRef<HTMLDivElement>(null);
   const menuTriggerRef = useRef<HTMLButtonElement | null>(null);
-  menuOpenRef.current = menuOpen || tracksOpen || moreOpen; // keep the control bar up while one is open
   // Auto-hiding control bar (reveal on mouse move / any key; hide after 3s while playing).
   const {
     uiVisible,
@@ -325,7 +318,8 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
     fitHeight: true,
     openOnArrowKey: false,
   });
-  const tracksFade = useScrollFade();
+  const { setReference: setTracksReference } = tracksPop.refs;
+  const { ref: tracksFadeRef, style: tracksFadeStyle } = useScrollFade();
   // The ⋯ is both the menu's trigger and the tuning panel's dismiss exception and focus return.
   const setMoreReference = morePop.refs.setReference;
   const moreTriggerRef = useCallback(
@@ -339,11 +333,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
   // player's own overlay. Mirror its open state into a ref because usePlayerVolume still needs to
   // know an overlay is up before it steals a wheel scroll for volume.
   const helpOpen = useKeyboardHelpOpen();
-  const helpOpenRef = useRef(false);
-  helpOpenRef.current = helpOpen;
-  // Read for the Backspace guard below: these two overlays open OVER the player and own the key.
-  const paletteOpenRef = useRef(false);
-  paletteOpenRef.current = usePaletteOpen();
+  const helpOpenRef = useLatest(helpOpen);
 
   // On-screen confirmation for a KEYBOARD track switch. A/S have cycled audio and subtitles since
   // E5, but silently — you changed the track and the only way to see what you landed on was to open
@@ -364,26 +354,27 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
   );
   // "I" toggles a rich info overlay (poster/cast/ratings) over the running video.
   const [infoOpen, setInfoOpen] = useState(false);
-  const infoOpenRef = useRef(false);
-  infoOpenRef.current = infoOpen;
+  const infoOpenRef = useLatest(infoOpen);
   // "D" toggles the stats-for-nerds debug overlay (active mode, codec, dropped frames, buffer…).
   const [statsOpen, setStatsOpen] = useState(false);
-  const statsOpenRef = useRef(false);
-  statsOpenRef.current = statsOpen;
+  const statsOpenRef = useLatest(statsOpen);
   // Up-next end-card: shown at episode end (with a next item) instead of an instant jump (S4).
   const [upNextOpen, setUpNextOpen] = useState(false);
-  const upNextOpenRef = useRef(false);
-  upNextOpenRef.current = upNextOpen;
-  const upNextPrefRef = useRef(prefs.upNext);
-  upNextPrefRef.current = prefs.upNext;
+  const upNextOpenRef = useLatest(upNextOpen);
+  const upNextPrefRef = useLatest(prefs.upNext);
   const now = useWallClock();
 
-  durationRef.current = duration;
-
   // Track selection is (re)derived from the saved language prefs when each item's detail arrives
   // (see the detail effect below) — nothing to reset on id change.
 
   // --- media setup: (re)load a session for `id` at a start offset -------------------------------
+  // The self-restart path inside loadSession reaches the CURRENT loadSession through this, so the
+  // recursion is not a forward reference to a binding that is still being defined. Declared before
+  // it and set after commit (below) — a render-time write would make the React Compiler skip the
+  // whole player.
+  const loadSessionRef = useRef<(startAt: number, resumePlay?: boolean) => Promise<void>>(
+    async () => {},
+  );
   const loadSession = useCallback(
     async (startAt: number, resumePlay = true) => {
       const video = videoRef.current;
@@ -418,12 +409,16 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
       // "Preparing stream…" for a not-yet-known session while the plexSession request is in flight —
       // it's re-set honestly from the response below.
       setSessionIsTranscode(false);
-      let sess;
+      // Initialised, not a bare `let sess;`: the compiler's analysis read an unassigned local as a
+      // value from OUTSIDE this callback and asked for `sess.hw` as a dependency (memo-dependencies).
+      let sess: PlexPlaySession | null = null;
+      // Multi-audio → request the multi-rendition session (no single `audio` ordinal); the track is
+      // selected client-side after the manifest loads. Decided before the try: the React Compiler
+      // cannot lower a conditional inside one yet.
+      const m = multiAudioRef.current;
+      const audio = m ? null : audioRef.current;
       try {
-        // Multi-audio → request the multi-rendition session (no single `audio` ordinal); the track is
-        // selected client-side after the manifest loads.
-        const m = multiAudioRef.current;
-        sess = await api.plexSession(id, startAt, m ? null : audioRef.current, aoffRef.current, m);
+        sess = await api.plexSession(id, startAt, audio, aoffRef.current, m);
       } catch (e) {
         if (!current()) return; // superseded or left: not this request's error to show
         settled();
@@ -581,7 +576,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
               restartsRef.current.n += 1;
               // Through the ref, not by name: this is loadSession calling ITSELF from inside its own
               // useCallback, which the checker rightly reads as "accessed before it is declared".
-              // The ref (assigned right below the callback) is the file's existing answer to that —
+              // The ref (declared above the callback, set below it) is the file's answer to that —
               // detachSessionRef and cancelAutoSkipRef do the same for the same reason.
               void loadSessionRef.current(
                 playhead(absRef, loadStartRef),
@@ -607,13 +602,13 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
         );
       }
     },
-    [id], // NOT `t` — see tRef above (a language switch must not rebuild this / reload the session).
+    // NOT `t` — see tRef above (a language switch must not rebuild this / reload the session). The
+    // refs never change.
+    [id, tRef, multiAudioRef, aoffRef, absRef],
   );
-  // The self-restart path above reaches the CURRENT loadSession through this, so the recursion is
-  // not a forward reference to a binding that is still being defined.
-  const loadSessionRef = useRef(loadSession);
-  // eslint-disable-next-line react-hooks/immutability -- the latest-value ref the self-restart path above reads; see the comment there for why the recursion cannot name loadSession directly.
-  loadSessionRef.current = loadSession;
+  useLayoutEffect(() => {
+    loadSessionRef.current = loadSession;
+  }, [loadSession]);
 
   // Audio/subtitle track selection + subtitle rendering. Owns the selected-ordinal state; the shared
   // media refs stay component-owned (loadSession above + the detail effect below write audioRef too).
@@ -688,7 +683,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
         ? detail.position_seconds || 0
         : 0;
     void loadSession(resume);
-  }, [detail, id, fromStart, loadSession, audioRef, setAudioOrd, setSubOrd]);
+  }, [detail, id, fromStart, loadSession, audioRef, langPrefsRef, setAudioOrd, setSubOrd]);
   // Leaving the item: a session still in flight for it must not land after it, and its stream goes.
   useEffect(
     () => () => {
@@ -719,13 +714,10 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
     aliveRef.current = true;
     const v = videoRef.current;
     return () => {
+      // Lowering the flag is what tells every in-flight session that its answer belongs to nothing
+      // now (`current()` reads it). The generation is bumped by the "leaving the item" cleanup
+      // above, which an unmount runs too.
       aliveRef.current = false;
-      // The rule's advice — copy the ref into a variable and use the copy — is precisely wrong here.
-      // sessGenRef is a LIVE counter: bumping it is how the unmount tells every in-flight session
-      // that its response no longer belongs to anything, and a value captured when the effect ran
-      // would invalidate a generation that has since been superseded instead of the current one.
-      // eslint-disable-next-line react-hooks/exhaustive-deps
-      sessGenRef.current++;
       if (hlsRef.current) {
         hlsRef.current.destroy();
         hlsRef.current = null;
@@ -750,12 +742,8 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
       if (!clockLiveRef.current) return; // the old session's clock (see clockLiveRef)
       const a = sessionStartRef.current + video.currentTime;
       setAbs(a);
-      try {
-        const end = video.seekable.length ? sessionStartRef.current + video.seekable.end(0) : a;
-        setSeekableEnd(end);
-      } catch {
-        /* ignore */
-      }
+      const end = seekableEndOf(video, sessionStartRef.current, a);
+      if (end != null) setSeekableEnd(end);
     };
     const onPlay = () => setPlaying(true);
     const onPause = () => setPlaying(false);
@@ -821,7 +809,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
       const dur = durationRef.current || target;
       const T = Math.max(0, Math.min(target, dur - 1));
       // Reflect the target immediately so a save/beacon right after a seek is accurate — in the STATE
-      // too: `absRef` is re-synced from `abs` on every render, and the restart below renders at once,
+      // too: `absRef` is re-synced from `abs` after every commit, and the restart below renders at once,
       // so the ref alone was back at the pre-seek spot before anything could read it.
       absRef.current = T;
       setAbs(T);
@@ -837,10 +825,10 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
         video.currentTime = rel; // native seek within the loaded region keeps playing on its own
         if (play) video.play().catch(() => {});
       } else {
-        loadSession(T, wasPlaying); // session restart: only auto-resume if we were playing
+        void loadSession(T, wasPlaying); // session restart: only auto-resume if we were playing
       }
     },
-    [loadSession],
+    [loadSession, absRef, durationRef],
   );
 
   // --- controls --------------------------------------------------------------------------------
@@ -882,7 +870,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
 
   const reportWatchedError = useCallback(
     (e: unknown) => notifyActionError(e, tRef.current("plex.watchedFailed")),
-    [],
+    [tRef],
   );
 
   const go = useCallback(
@@ -908,10 +896,13 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
         // file), loadSession returns without replacing the <video> source, leaving the old episode
         // still playing — it would then fire 'ended' against the NEW id and mark the wrong item
         // watched (and scrobble it to Plex). Pausing here severs that stale-tail race.
-        try {
-          videoRef.current?.pause();
-        } catch {
-          /* ignore */
+        const outgoing = videoRef.current;
+        if (outgoing) {
+          try {
+            outgoing.pause();
+          } catch {
+            /* ignore */
+          }
         }
         // Settle the item being left while the position still is its own (see usePlexProgress), and
         // stop trusting the old media's clock: the timeupdate that pause() queues lands after the
@@ -948,7 +939,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
   const backOrPrev = useCallback(() => {
     if (playhead(absRef, loadStartRef) <= BACK_TO_PREV_S && prevId) go(prevId);
     else seekTo(0);
-  }, [prevId, go, seekTo]);
+  }, [prevId, go, seekTo, absRef]);
 
   // What the last press came from. A touch tap on the picture only shows or hides the controls (C3:
   // measured live, a tap used to reveal the bar AND pause); a mouse click there still plays/pauses.
@@ -999,7 +990,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
       }
       toggleControls();
     },
-    [togglePlay, showControls, toggleControls, seekTo, flashOsd, t, lang, uiVisible],
+    [togglePlay, showControls, toggleControls, seekTo, flashOsd, t, lang, uiVisible, absRef],
   );
 
   // Auto-skip intro/credits (countdown → jump to marker end / next item). The refs bridge to the
@@ -1101,7 +1092,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
     };
     video.addEventListener("ended", onEnded);
     return () => video.removeEventListener("ended", onEnded);
-  }, [id, nextId, go, onClose, finishProgress, reportWatchedError]);
+  }, [id, nextId, go, onClose, finishProgress, reportWatchedError, absRef, upNextPrefRef]);
 
   // Up-next card actions: advance = go to the next item (it was already marked watched on 'ended');
   // cancel = dismiss and stay on the finished frame. Loading a new item closes any lingering card.
@@ -1132,7 +1123,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
     else if (statsOpenRef.current) setStatsOpen(false);
     else if (upNextOpenRef.current) setUpNextOpen(false);
     else onClose();
-  }, [onClose]);
+  }, [onClose, menuOpenRef, infoOpenRef, statsOpenRef, upNextOpenRef]);
 
   // The mouse "back" button (and the browser Back) fire history popstate — which would pop the whole
   // player subview and drop straight to the grid, even with a panel or an auto-skip countdown up.
@@ -1328,6 +1319,13 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
     handleBack,
     skipProgressRef,
     cancelAutoSkipRef,
+    absRef,
+    seekStepRef,
+    fineSeekStepRef,
+    menuOpenRef,
+    infoOpenRef,
+    statsOpenRef,
+    upNextOpenRef,
   ]);
 
   // Seekbar hover: a timestamp tooltip that follows the cursor. Store the position as a FRACTION
@@ -1766,7 +1764,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
                   variant="overlay"
                   size="player"
                   round
-                  ref={tracksPop.refs.setReference}
+                  ref={setTracksReference}
                   {...tracksPop.getReferenceProps()}
                   aria-expanded={tracksOpen}
                   label={t("plex.player.tracks")}
@@ -1781,10 +1779,10 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
                   {/* Portaled, but a React child of the player: a click or a wheel here must not
                       reach the stage's play-toggle and volume handlers. */}
                   <div
-                    ref={tracksFade.ref}
+                    ref={tracksFadeRef}
                     onClick={(e) => e.stopPropagation()}
                     onWheel={(e) => e.stopPropagation()}
-                    style={{ ...tracksFade.style, maxHeight: "min(60dvh, var(--fit-max-h))" }}
+                    style={{ ...tracksFadeStyle, maxHeight: "min(60dvh, var(--fit-max-h))" }}
                     className="overflow-auto no-scrollbar p-2"
                   >
                     {detail.audio_streams.length > 1 && (
diff --git a/frontend/src/components/PlexPlaylistAdd.tsx b/frontend/src/components/PlexPlaylistAdd.tsx
index 673c10dd..dfc96a22 100644
--- a/frontend/src/components/PlexPlaylistAdd.tsx
+++ b/frontend/src/components/PlexPlaylistAdd.tsx
@@ -30,7 +30,7 @@ export default function PlexPlaylistAdd({
   onClose: () => void;
 }) {
   const { t } = useTranslation();
-  const fade = useScrollFade();
+  const { ref: fadeRef, style: fadeStyle } = useScrollFade();
   const qc = useQueryClient();
   const [newName, setNewName] = useState("");
   const [busy, setBusy] = useState(false);
@@ -50,7 +50,7 @@ export default function PlexPlaylistAdd({
         : api.plexPlaylists(target.ratingKey),
   });
   const playlists = listQ.data?.playlists ?? [];
-  const refresh = () => qc.invalidateQueries({ queryKey: qk.plexPlaylists() });
+  const refresh = () => void qc.invalidateQueries({ queryKey: qk.plexPlaylists() });
 
   // How many of the target a playlist currently holds (0..size).
   function inCount(p: PlexPlaylist): number {
@@ -82,10 +82,9 @@ export default function PlexPlaylistAdd({
         e,
         t(allIn ? "plex.playlistAdd.removeFailed" : "plex.playlistAdd.addFailed"),
       );
-    } finally {
-      refresh();
-      setBusy(false);
     }
+    refresh();
+    setBusy(false);
   }
 
   async function createNew() {
@@ -106,10 +105,9 @@ export default function PlexPlaylistAdd({
       // The create may already have landed when the add fails — `refresh()` in `finally` is what
       // makes that half-done state visible instead of leaving a playlist the dialog never lists.
       notifyActionError(e, t("plex.playlistAdd.createFailed"));
-    } finally {
-      refresh();
-      setBusy(false);
     }
+    refresh();
+    setBusy(false);
   }
 
   return (
@@ -139,8 +137,8 @@ export default function PlexPlaylistAdd({
       </div>
 
       <div
-        ref={fade.ref}
-        style={fade.style}
+        ref={fadeRef}
+        style={fadeStyle}
         className="max-h-80 space-y-1 overflow-y-auto no-scrollbar"
       >
         {listQ.isLoading ? (
diff --git a/frontend/src/components/PlexPlaylistView.tsx b/frontend/src/components/PlexPlaylistView.tsx
index d5fee5a5..5d1bf1a4 100644
--- a/frontend/src/components/PlexPlaylistView.tsx
+++ b/frontend/src/components/PlexPlaylistView.tsx
@@ -416,7 +416,7 @@ export default function PlexPlaylistView({
   const qc = useQueryClient();
   const confirm = useConfirm();
   const [renaming, setRenaming] = useState(false);
-  const renameFocus = useReturnFocus(renaming);
+  const { target: renameTarget, arm: armRenameReturn } = useReturnFocus(renaming);
   const [name, setName] = useState("");
   const [layout, setLayout] = useState<Layout>(() =>
     getAccountRaw(LS.plexPlaylistLayout) === "tree" ? "tree" : "accordion",
@@ -741,12 +741,12 @@ export default function PlexPlaylistView({
                 onChange={(e) => setName(e.target.value)}
                 onKeyDown={(e) => {
                   if (e.key === "Enter") {
-                    renameFocus.arm(e);
-                    rename();
+                    armRenameReturn(e);
+                    void rename(); // reports its own failure
                   }
                   // Unmounting the field fires no blur, so Escape really does cancel.
                   if (e.key === "Escape") {
-                    renameFocus.arm(e);
+                    armRenameReturn(e);
                     setRenaming(false);
                   }
                 }}
@@ -783,7 +783,7 @@ export default function PlexPlaylistView({
           {/* Rename and delete — the playlist's own, rarer actions — sit in its "…" (E28 C1); a
               rename opened from there hands the focus back to it. */}
           <MoreButton
-            ref={renameFocus.target}
+            ref={renameTarget}
             variant="glass"
             size="md"
             label={t("plex.playlist.menu")}
diff --git a/frontend/src/components/PlexSidebar.tsx b/frontend/src/components/PlexSidebar.tsx
index 167fa7ab..f42824e1 100644
--- a/frontend/src/components/PlexSidebar.tsx
+++ b/frontend/src/components/PlexSidebar.tsx
@@ -401,7 +401,8 @@ export function PlaylistPicker() {
       onChange={(next) => {
         const v = next[0];
         if (!v) return;
-        if (v === CREATE_PLAYLIST) createPlaylist(q);
+        if (v === CREATE_PLAYLIST)
+          void createPlaylist(q); // reports its own failure
         else onOpenPlaylist(Number(v.slice(3)));
       }}
     />
@@ -438,7 +439,7 @@ function CollectionPicker({
   // …but a selection restored from a LINK has ids and no titles, and the list above is only fetched
   // once the picker is opened — so the token rendered the raw rating_key until then. Resolve just the
   // selected ids (see usePlexCollectionTitles).
-  const resolved = usePlexCollectionTitles(values, titles);
+  const { titles: resolved, pending } = usePlexCollectionTitles(values, titles);
   const options: ComboboxOption[] = (q.data?.collections ?? []).map((c) => ({
     value: c.id,
     label: c.title,
@@ -458,6 +459,7 @@ function CollectionPicker({
         options={options}
         selected={values}
         selectedLabels={resolved}
+        labelsPending={pending}
         query={search}
         onQueryChange={setSearch}
         onOpenChange={setOpen}
diff --git a/frontend/src/components/PlexStatsOverlay.tsx b/frontend/src/components/PlexStatsOverlay.tsx
index 369889a8..35a8492d 100644
--- a/frontend/src/components/PlexStatsOverlay.tsx
+++ b/frontend/src/components/PlexStatsOverlay.tsx
@@ -9,6 +9,18 @@ import { IconButton } from "./ui/IconButton";
 // and renders the active mode, resolution, codec/bitrate, dropped frames, buffer, hls level and session
 // offset. No data layer — the refs are already in hand. Doubles as the S1 verification surface (it shows
 // the transcode mode + that the re-encode is engaged). Toggled with "d" / the gauge button / its X.
+/** Dropped / total frames so far. Outside the component: the React Compiler cannot lower an
+ *  optional call inside a try yet, and skipped the whole overlay for it. */
+function frameCounts(v: HTMLVideoElement | null): { dropped: number; total: number } {
+  try {
+    const q = v?.getVideoPlaybackQuality?.();
+    if (q) return { dropped: q.droppedVideoFrames, total: q.totalVideoFrames };
+  } catch {
+    /* getVideoPlaybackQuality unsupported — leave 0/0 (renders as a dash) */
+  }
+  return { dropped: 0, total: 0 };
+}
+
 export function PlexStatsOverlay({
   videoRef,
   hlsRef,
@@ -47,17 +59,7 @@ export function PlexStatsOverlay({
       const v = videoRef.current;
       const hls = hlsRef.current;
 
-      let dropped = 0;
-      let total = 0;
-      try {
-        const q = v?.getVideoPlaybackQuality?.();
-        if (q) {
-          dropped = q.droppedVideoFrames;
-          total = q.totalVideoFrames;
-        }
-      } catch {
-        /* getVideoPlaybackQuality unsupported — leave 0/0 (renders as a dash) */
-      }
+      const { dropped, total } = frameCounts(v);
 
       let bufferAhead = 0;
       if (v) {
diff --git a/frontend/src/components/PrefsProvider.dom.test.tsx b/frontend/src/components/PrefsProvider.dom.test.tsx
index 283e84ca..7dd9a8d5 100644
--- a/frontend/src/components/PrefsProvider.dom.test.tsx
+++ b/frontend/src/components/PrefsProvider.dom.test.tsx
@@ -49,7 +49,10 @@ describe("PrefsProvider seed", () => {
     );
 
     expect(seen[0]).toEqual({ perf: true, hints: false });
-    act(() => vi.advanceTimersByTime(1000)); // past the auto-save debounce
+    // past the auto-save debounce
+    act(() => {
+      vi.advanceTimersByTime(1000);
+    });
     expect(save).not.toHaveBeenCalled();
   });
 });
diff --git a/frontend/src/components/ProfileEditor.tsx b/frontend/src/components/ProfileEditor.tsx
index af963438..d84454a5 100644
--- a/frontend/src/components/ProfileEditor.tsx
+++ b/frontend/src/components/ProfileEditor.tsx
@@ -60,7 +60,7 @@ export default function ProfileEditor({ onClose }: { onClose: () => void }) {
   const [spec, setSpec] = useState<DownloadSpec>(BLANK);
   const [formOpen, setFormOpen] = useState(false);
 
-  const invalidate = () => qc.invalidateQueries({ queryKey: qk.downloadProfiles() });
+  const invalidate = () => void qc.invalidateQueries({ queryKey: qk.downloadProfiles() });
   const startNew = () => {
     setEditing(null);
     setName("");
diff --git a/frontend/src/components/SavedViewsPopover.tsx b/frontend/src/components/SavedViewsPopover.tsx
index 46ab9a72..0ba58e3c 100644
--- a/frontend/src/components/SavedViewsPopover.tsx
+++ b/frontend/src/components/SavedViewsPopover.tsx
@@ -33,6 +33,7 @@ export default function SavedViewsPopover({
   const { views, activeViewId, apply, openModal } = useSavedViews();
   const [open, setOpen] = useState(false);
   const pop = useAnchoredPopover({ open, onOpenChange: setOpen, placement });
+  const { setReference } = pop.refs;
   const label = ariaLabel ?? t("views.saved");
   return (
     <>
@@ -42,7 +43,7 @@ export default function SavedViewsPopover({
           open={open}
           icon={icon}
           trailing={trailing}
-          ref={pop.refs.setReference}
+          ref={setReference}
           {...pop.getReferenceProps()}
           aria-label={label}
         >
@@ -51,7 +52,7 @@ export default function SavedViewsPopover({
       ) : (
         <IconButton
           variant="ghost-accent"
-          ref={pop.refs.setReference}
+          ref={setReference}
           {...pop.getReferenceProps()}
           label={label}
         >
diff --git a/frontend/src/components/SavedViewsProvider.dom.test.tsx b/frontend/src/components/SavedViewsProvider.dom.test.tsx
index 6da9165f..ae68873b 100644
--- a/frontend/src/components/SavedViewsProvider.dom.test.tsx
+++ b/frontend/src/components/SavedViewsProvider.dom.test.tsx
@@ -201,7 +201,9 @@ describe("SavedViewsProvider — signed-out tab", () => {
     });
     expect(spy).not.toHaveBeenCalled();
     // …and it asks as soon as an account signs in.
-    act(() => qc.setQueryData(qk.me(), { id: ID, preferences: {} }));
+    act(() => {
+      qc.setQueryData(qk.me(), { id: ID, preferences: {} });
+    });
     await waitFor(() => expect(spy).toHaveBeenCalledWith("feed"));
   });
 });
diff --git a/frontend/src/components/SavedViewsProvider.tsx b/frontend/src/components/SavedViewsProvider.tsx
index b7a21c80..4ed4087d 100644
--- a/frontend/src/components/SavedViewsProvider.tsx
+++ b/frontend/src/components/SavedViewsProvider.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useRef, useState, type ReactNode } from "react";
+import { useEffect, useEffectEvent, useMemo, useRef, useState, type ReactNode } from "react";
 import { useTranslation } from "react-i18next";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { qk } from "../lib/queryKeys";
@@ -150,21 +150,19 @@ export function SavedViewsProvider({ children }: { children: ReactNode }) {
   // per-account stored-filters key, which is always readable here: BootGate pins the tab's account
   // before this provider mounts.
   const seededRef = useRef<Set<ViewSource>>(new Set());
-  // `cfg` re-memoizes on every filter edit, so it is read through a ref: the seed must fire on the
-  // views query's first resolve for a source and never again, which `seededRef` enforces. Listing
-  // cfg would re-arm nothing (the guard still holds) but would re-run the effect on every keystroke
-  // in the filter bar. The ref keeps the dep list honest without that.
-  const cfgRef = useRef(cfg);
-  cfgRef.current = cfg;
+  // `cfg` re-memoizes on every filter edit, so it is read through an effect event: the seed must
+  // fire on the views query's first resolve for a source and never again, which `seededRef`
+  // enforces. Listing cfg would re-arm nothing (the guard still holds) but would re-run the effect
+  // on every keystroke in the filter bar.
+  const latestCfg = useEffectEvent(() => cfg);
   useEffect(() => {
     const data = viewsQuery.data;
     if (!data || seededRef.current.has(source)) return;
     seededRef.current.add(source);
-    const c = cfgRef.current;
+    const c = latestCfg();
     const def = pickDefaultToSeed(data, c.canSeedDefault());
-    if (!def) return;
-    c.setFilters(c.asFilters(def.filters));
-    setStickyId(def.id);
+    // The name follows by itself: `preferSticky` picks the starred default among same-filter views.
+    if (def) c.setFilters(c.asFilters(def.filters));
   }, [viewsQuery.data, source]);
 
   const currentKey = cfg.keyOf(cfg.filters);
@@ -188,17 +186,17 @@ export function SavedViewsProvider({ children }: { children: ReactNode }) {
   const displayView = activeView ?? stickyView;
   const isDirty = displayView != null && activeView == null;
 
-  const refresh = () => qc.invalidateQueries({ queryKey: qk.savedViews(source) });
+  const refresh = () => void qc.invalidateQueries({ queryKey: qk.savedViews(source) });
   async function runViewMutation(fn: () => Promise<unknown>, failMsg: string): Promise<boolean> {
+    let ok = true;
     try {
       await fn();
-      return true;
     } catch (e) {
       notifyActionError(e, failMsg);
-      return false;
-    } finally {
-      refresh();
+      ok = false;
     }
+    refresh();
+    return ok;
   }
 
   const value: SavedViewsContext = {
diff --git a/frontend/src/components/Scheduler.menu.dom.test.tsx b/frontend/src/components/Scheduler.menu.dom.test.tsx
index cb8e0f26..d9f5fafd 100644
--- a/frontend/src/components/Scheduler.menu.dom.test.tsx
+++ b/frontend/src/components/Scheduler.menu.dom.test.tsx
@@ -74,7 +74,9 @@ afterEach(() => {
 const menuRows = () =>
   screen.getAllByRole("menuitem", { hidden: true }).map((b) => b.textContent ?? "");
 async function openMenu() {
-  act(() => fireEvent.click(screen.getByRole("button", { name: "scheduler.menu" })));
+  act(() => {
+    fireEvent.click(screen.getByRole("button", { name: "scheduler.menu" }));
+  });
   await waitFor(() =>
     expect(screen.getAllByRole("menuitem", { hidden: true }).length).toBeGreaterThan(0),
   );
diff --git a/frontend/src/components/SettingsPanel.tsx b/frontend/src/components/SettingsPanel.tsx
index 0feaa259..fc0e0dd1 100644
--- a/frontend/src/components/SettingsPanel.tsx
+++ b/frontend/src/components/SettingsPanel.tsx
@@ -372,17 +372,17 @@ function SignInMethods({ me }: { me: Me }) {
       notify({ level: "success", message: t("settings.account.sessions.done") });
     } catch (e) {
       notifyActionError(e, t("settings.account.sessions.failed"));
-    } finally {
-      setSessBusy(false);
     }
+    setSessBusy(false);
   };
 
-  const submit = async (e: React.FormEvent) => {
+  const submit = async (e: React.SubmitEvent<HTMLFormElement>) => {
     e.preventDefault();
     setErr(null);
     setBusy(true);
+    const confirmCurrent = me.has_password ? current : undefined;
     try {
-      await api.setPassword(next, me.has_password ? current : undefined);
+      await api.setPassword(next, confirmCurrent);
       setOpen(false);
       setCurrent("");
       setNext("");
@@ -396,9 +396,8 @@ function SignInMethods({ me }: { me: Me }) {
       setErr(
         (e instanceof HttpError ? e.detail : undefined) ?? t("settings.account.password.failed"),
       );
-    } finally {
-      setBusy(false);
     }
+    setBusy(false);
   };
 
   // Offer Google only when this instance has Google OAuth configured (or the account is already
diff --git a/frontend/src/components/SetupWizard.tsx b/frontend/src/components/SetupWizard.tsx
index 93b9190d..6989b7f2 100644
--- a/frontend/src/components/SetupWizard.tsx
+++ b/frontend/src/components/SetupWizard.tsx
@@ -85,47 +85,52 @@ export default function SetupWizard() {
     setError("");
     setBusy(true);
     try {
-      if (step === "admin") {
-        if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email))
-          return setError(t("setup.admin.invalidEmail"));
-        if (password.length < PASSWORD_MIN)
-          return setError(t("setup.admin.shortPassword", { n: PASSWORD_MIN }));
-        await api.setupAdmin(token, email, password);
-      } else if (step === "google" && (gid.trim() || gsecret.trim())) {
-        if (!gid.trim() || !gsecret.trim()) return setError(t("setup.google.bothRequired"));
-        await api.setupConfig(token, {
-          google_client_id: gid.trim(),
-          google_client_secret: gsecret.trim(),
-        });
-      } else if (step === "smtp" && smtp.host.trim()) {
-        await api.setupConfig(token, {
-          smtp_host: smtp.host.trim(),
-          smtp_port: Number(smtp.port) || 587,
-          smtp_user: smtp.user.trim(),
-          smtp_from: smtp.from.trim(),
-          smtp_password: smtp.password,
-        });
-      } else if (step === "finish") {
-        await api.setupFinish(token);
-        window.location.href = "/"; // configured now → reloads into the login page
-        return;
-      }
-      go(1);
+      await saveStep();
     } catch (e) {
       setError((e instanceof HttpError ? e.detail : undefined) ?? t("setup.genericError"));
-    } finally {
-      setBusy(false);
     }
+    setBusy(false);
+  }
+
+  // next()'s steps, apart so `busy` clears on every way out without a try/finally (the React
+  // Compiler cannot lower one yet, and skips the whole component).
+  async function saveStep() {
+    if (step === "admin") {
+      if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email)) return setError(t("setup.admin.invalidEmail"));
+      if (password.length < PASSWORD_MIN)
+        return setError(t("setup.admin.shortPassword", { n: PASSWORD_MIN }));
+      await api.setupAdmin(token, email, password);
+    } else if (step === "google" && (gid.trim() || gsecret.trim())) {
+      if (!gid.trim() || !gsecret.trim()) return setError(t("setup.google.bothRequired"));
+      await api.setupConfig(token, {
+        google_client_id: gid.trim(),
+        google_client_secret: gsecret.trim(),
+      });
+    } else if (step === "smtp" && smtp.host.trim()) {
+      await api.setupConfig(token, {
+        smtp_host: smtp.host.trim(),
+        smtp_port: Number(smtp.port) || 587,
+        smtp_user: smtp.user.trim(),
+        smtp_from: smtp.from.trim(),
+        smtp_password: smtp.password,
+      });
+    } else if (step === "finish") {
+      await api.setupFinish(token);
+      window.location.href = "/"; // configured now → reloads into the login page
+      return;
+    }
+    go(1);
   }
 
   async function sendTest() {
     setTestState("sending");
+    const port = Number(smtp.port) || 587;
     try {
       // Persist the SMTP fields first so the test uses them, then send.
       if (smtp.host.trim())
         await api.setupConfig(token, {
           smtp_host: smtp.host.trim(),
-          smtp_port: Number(smtp.port) || 587,
+          smtp_port: port,
           smtp_user: smtp.user.trim(),
           smtp_from: smtp.from.trim(),
           smtp_password: smtp.password,
diff --git a/frontend/src/components/ShareDialog.tsx b/frontend/src/components/ShareDialog.tsx
index 963391fa..ef003ac4 100644
--- a/frontend/src/components/ShareDialog.tsx
+++ b/frontend/src/components/ShareDialog.tsx
@@ -240,7 +240,7 @@ function LinkShare({ job }: { job: DownloadJob }) {
   const [allowDownload, setAllowDownload] = useState(true);
   const [expiryDays, setExpiryDays] = useState<number | null>(null);
   const [password, setPassword] = useState("");
-  const invalidate = () => qc.invalidateQueries({ queryKey: qk.downloadLinks(job.id) });
+  const invalidate = () => void qc.invalidateQueries({ queryKey: qk.downloadLinks(job.id) });
 
   const create = useMutation({
     mutationFn: () =>
diff --git a/frontend/src/components/SyncStatus.tsx b/frontend/src/components/SyncStatus.tsx
index 19c323e9..d3efc4a7 100644
--- a/frontend/src/components/SyncStatus.tsx
+++ b/frontend/src/components/SyncStatus.tsx
@@ -38,6 +38,7 @@ export default function SyncStatus({
     placement: "bottom-end",
     offset: 8,
   });
+  const { setReference } = pop.refs;
   const { data } = useQuery({
     queryKey: qk.myStatus(),
     queryFn: api.myStatus,
@@ -122,7 +123,7 @@ export default function SyncStatus({
   return (
     <div className="pointer-events-auto shrink-0">
       <Pressable
-        ref={pop.refs.setReference}
+        ref={setReference}
         {...pop.getReferenceProps()}
         // Short label only: the popover already explains the numbers, and the long one overflowed
         // the viewport edge from here.
diff --git a/frontend/src/components/TagFilterChips.tsx b/frontend/src/components/TagFilterChips.tsx
index 882ee5f3..50ed62ff 100644
--- a/frontend/src/components/TagFilterChips.tsx
+++ b/frontend/src/components/TagFilterChips.tsx
@@ -7,6 +7,7 @@ import { chipClass } from "./ui/chipStyles";
 import { PopoverSurface } from "./ui/AnchoredPopover";
 import { useAnchoredPopover } from "./ui/anchoredPopoverHooks";
 import { SURFACE } from "./ui/surfaces";
+import { ChipLabelPending } from "./ui/Skeleton";
 
 // A single-line row of toggle filter chips that collapses its overflow into a trailing "+N" pill whose
 // popover holds the rest (still toggleable) — the same compression the feed's applied-filter row uses
@@ -18,14 +19,22 @@ import { SURFACE } from "./ui/surfaces";
 export interface FilterChip {
   key: string;
   label: string;
+  /** The name is still on its way: the chip draws a placeholder, not `label` (a raw id). */
+  pending?: boolean;
   active: boolean;
   onToggle: () => void;
 }
 
+// A chip's text — the visible chip and the hidden measuring mirror both draw it, so the mirror
+// measures what shows (ActiveFilterChips' ChipText, for this row's chips).
+function ChipText({ chip }: { chip: FilterChip }) {
+  return chip.pending ? <ChipLabelPending value={chip.label} /> : <>{chip.label}</>;
+}
+
 function TagChip({ chip }: { chip: FilterChip }) {
   return (
     <Chip onClick={chip.onToggle} pressed={chip.active}>
-      {chip.label}
+      <ChipText chip={chip} />
     </Chip>
   );
 }
@@ -43,7 +52,9 @@ export default function TagFilterChips({
   const pillRef = useRef<HTMLSpanElement | null>(null);
   // Re-fit when the set, the labels, OR the pressed state change (the pressed paint can change a chip's
   // width via the `.pill` recipe, so an aria-pressed flip must re-measure too).
-  const key = chips.map((c) => `${c.key}:${c.label}:${c.active ? 1 : 0}`).join("|");
+  const key = chips
+    .map((c) => `${c.key}:${c.label}:${c.active ? 1 : 0}${c.pending ? "…" : ""}`)
+    .join("|");
 
   const visible = useChipOverflowFit<number>({
     rowRef,
@@ -82,6 +93,7 @@ export default function TagFilterChips({
     mode: "menu",
     placement: "bottom-end",
   });
+  const { setReference } = pop.refs;
   const moreLabel = t("channels.tags.moreCount", { count: hidden });
 
   return (
@@ -100,7 +112,9 @@ export default function TagFilterChips({
             }}
             className="inline-flex"
           >
-            <span className={chipClass()}>{c.label}</span>
+            <span className={chipClass()}>
+              <ChipText chip={c} />
+            </span>
           </span>
         ))}
         <span ref={pillRef} className={chipClass()}>
@@ -113,7 +127,7 @@ export default function TagFilterChips({
           <TagChip key={c.key} chip={c} />
         ))}
         {hidden > 0 && (
-          <Chip ref={pop.refs.setReference} aria-label={moreLabel} {...pop.getReferenceProps()}>
+          <Chip ref={setReference} aria-label={moreLabel} {...pop.getReferenceProps()}>
             +{hidden}
           </Chip>
         )}
diff --git a/frontend/src/components/TagManager.tsx b/frontend/src/components/TagManager.tsx
index 37e136ec..80ad4f74 100644
--- a/frontend/src/components/TagManager.tsx
+++ b/frontend/src/components/TagManager.tsx
@@ -38,7 +38,7 @@ function TagRow({
   const { t } = useTranslation();
   const [name, setName] = useState(tag.name);
   const [open, setOpen] = useState(false);
-  const popFade = useScrollFade();
+  const { ref: popFadeRef, style: popFadeStyle } = useScrollFade();
   const commit = () => {
     const v = name.trim();
     if (v && v !== tag.name) onRename(v);
@@ -52,6 +52,7 @@ function TagRow({
     offset: 8,
     hoverDelay: { open: 0, close: 150 },
   });
+  const { setReference } = pop.refs;
   return (
     <div className="flex items-center gap-2">
       <Input
@@ -62,7 +63,7 @@ function TagRow({
         onKeyDown={(e) => e.key === "Enter" && (e.target as HTMLInputElement).blur()}
       />
       <span
-        ref={pop.refs.setReference}
+        ref={setReference}
         {...pop.getReferenceProps()}
         className={`text-xs text-muted tabular-nums shrink-0 ${
           channels.length
@@ -81,8 +82,8 @@ function TagRow({
         </div>
         {/* Inner scroller so the scroll-fade mask rides the scrolling box, not the glass panel. */}
         <div
-          ref={popFade.ref}
-          style={popFade.style}
+          ref={popFadeRef}
+          style={popFadeStyle}
           className="max-h-72 overflow-y-auto no-scrollbar"
         >
           {channels.map((ch) => (
@@ -111,7 +112,7 @@ export default function TagManager({
   const { t } = useTranslation();
   const qc = useQueryClient();
   const confirm = useConfirm();
-  const listFade = useScrollFade();
+  const { ref: listFadeRef, style: listFadeStyle } = useScrollFade();
   const [newName, setNewName] = useState("");
   const tagsQuery = useTags();
   const channelsQuery = useQuery({ queryKey: qk.channels(), queryFn: api.channels });
@@ -168,8 +169,8 @@ export default function TagManager({
         ) : (
           // Cap at ~8 rows tall, then scroll — the list can grow long.
           <div
-            ref={listFade.ref}
-            style={listFade.style}
+            ref={listFadeRef}
+            style={listFadeStyle}
             className="flex flex-col gap-2 max-h-88 overflow-y-auto no-scrollbar pr-1"
           >
             {userTags.map((tag) => (
diff --git a/frontend/src/components/UpNextCard.tsx b/frontend/src/components/UpNextCard.tsx
index b169125a..d43d07c0 100644
--- a/frontend/src/components/UpNextCard.tsx
+++ b/frontend/src/components/UpNextCard.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState } from "react";
+import { useEffect, useEffectEvent, useState } from "react";
 import { useQuery } from "@tanstack/react-query";
 import { useTranslation } from "react-i18next";
 import { Play, X } from "lucide-react";
@@ -32,10 +32,9 @@ export function UpNextCard({
   });
   const next = nextQ.data;
 
-  // Countdown. `onAdvance` is read through a ref so the 100ms interval never restarts on re-render.
+  // Countdown. `onAdvance` is an effect event so the 100ms interval never restarts on re-render.
   const [remaining, setRemaining] = useState(COUNTDOWN_S);
-  const advanceRef = useRef(onAdvance);
-  advanceRef.current = onAdvance;
+  const advance = useEffectEvent(onAdvance);
   useEffect(() => {
     const started = performance.now();
     const iv = window.setInterval(() => {
@@ -43,7 +42,7 @@ export function UpNextCard({
       if (left <= 0) {
         window.clearInterval(iv);
         setRemaining(0);
-        advanceRef.current();
+        advance();
       } else {
         setRemaining(left);
       }
diff --git a/frontend/src/components/UploadDialog.tsx b/frontend/src/components/UploadDialog.tsx
index 22743bf3..e54a2964 100644
--- a/frontend/src/components/UploadDialog.tsx
+++ b/frontend/src/components/UploadDialog.tsx
@@ -71,9 +71,10 @@ export default function UploadDialog({ onClose }: { onClose: () => void }) {
     const ac = new AbortController();
     abortRef.current = ac;
     setPct(0);
+    const displayName = name.trim() || undefined;
     try {
       await api.uploadDownload(file, {
-        displayName: name.trim() || undefined,
+        displayName,
         onProgress: setPct,
         signal: ac.signal,
       });
diff --git a/frontend/src/components/VideoEditor.tsx b/frontend/src/components/VideoEditor.tsx
index ae25a61c..cfa8ce2d 100644
--- a/frontend/src/components/VideoEditor.tsx
+++ b/frontend/src/components/VideoEditor.tsx
@@ -41,6 +41,19 @@ type Drag = { type: "seek" } | { type: "boundary"; bi: number };
 
 const MIN_SEG = 0.1;
 
+/** Queues each clip as its own job, in order; `done` collects the ids that made it, so the caller's
+ *  catch can say how many did when one fails part-way. */
+async function enqueueClips(
+  jobId: number,
+  clips: { id: number; spec: EditSpec; dn: string | undefined }[],
+  done: number[],
+) {
+  for (const c of clips) {
+    await api.enqueueEdit({ source_job_id: jobId, edit_spec: c.spec, display_name: c.dn });
+    done.push(c.id);
+  }
+}
+
 export default function VideoEditor({ job, onClose }: { job: DownloadJob; onClose: () => void }) {
   const { t } = useTranslation();
   const qc = useQueryClient();
@@ -141,7 +154,10 @@ export default function VideoEditor({ job, onClose }: { job: DownloadJob; onClos
   const playPause = () => {
     const v = videoRef.current;
     if (!v) return;
-    v.paused ? v.play() : v.pause();
+    // play() rejects when a pause or a source change interrupts it; the button state follows the
+    // element's own events, so there is nothing to undo.
+    if (v.paused) v.play().catch(() => {});
+    else v.pause();
   };
 
   // --- cut-list mutations ---
@@ -186,7 +202,9 @@ export default function VideoEditor({ job, onClose }: { job: DownloadJob; onClos
 
   // --- timeline drag (seek / boundary) + hover preview ---
   const [drag, setDrag] = useState<Drag | null>(null);
-  const [hoverX, setHoverX] = useState<number | null>(null);
+  // The hover point, measured in the pointer handler (track-relative x and its time), so render never
+  // reads the track's geometry (a DOM read in render made the React Compiler skip the editor, E32).
+  const [hover, setHover] = useState<{ x: number; time: number } | null>(null);
   const timeAt = useCallback(
     (clientX: number) => {
       const el = trackRef.current;
@@ -270,19 +288,13 @@ export default function VideoEditor({ job, onClose }: { job: DownloadJob; onClos
     };
   };
   const stripCells = strip && trackW ? Math.max(1, Math.floor(trackW / (44 * aspect))) : 0;
-  const hoverTime = hoverX != null ? timeAt(hoverX) : null;
+  const hoverTime = hover?.time ?? null;
   // Clamp the hover-scrub popover inside the track so it never overflows the modal (which would
   // add a horizontal scrollbar): center it on the cursor, but keep both edges within [0, trackW].
   const HOVER_W = 148;
   const hoverLeft =
-    hoverX != null
-      ? Math.max(
-          0,
-          Math.min(
-            Math.max(0, (trackW || HOVER_W) - HOVER_W),
-            hoverX - (trackRef.current?.getBoundingClientRect().left ?? 0) - HOVER_W / 2,
-          ),
-        )
+    hover != null
+      ? Math.max(0, Math.min(Math.max(0, (trackW || HOVER_W) - HOVER_W), hover.x - HOVER_W / 2))
       : 0;
 
   // --- create ---
@@ -332,19 +344,20 @@ export default function VideoEditor({ job, onClose }: { job: DownloadJob; onClos
           ? prev
           : new Map(kept.map((s, i) => [s.id, N > 1 ? ` (${i + 1}/${N})` : ""]));
       series.current = suffix;
+      // Every clip's request is built before the try, and queued by a helper: the React Compiler
+      // cannot lower a conditional or a loop inside one yet, and skipped the whole editor for it.
+      const clips = kept.map((s) => {
+        const spec: EditSpec = {
+          trim: { start_s: +s.start.toFixed(3), end_s: +s.end.toFixed(3) },
+        };
+        if (cp) spec.crop = cp;
+        else spec.accurate = accurate;
+        const dn = suffix.get(s.id) ? `${base}${suffix.get(s.id)}` : name.trim() || undefined;
+        return { id: s.id, spec, dn };
+      });
       const done: number[] = [];
       try {
-        for (let i = 0; i < N; i++) {
-          const s = kept[i]!; // i < N === kept.length, so kept[i] exists
-          const spec: EditSpec = {
-            trim: { start_s: +s.start.toFixed(3), end_s: +s.end.toFixed(3) },
-          };
-          if (cp) spec.crop = cp;
-          else spec.accurate = accurate;
-          const dn = suffix.get(s.id) ? `${base}${suffix.get(s.id)}` : name.trim() || undefined;
-          await api.enqueueEdit({ source_job_id: job.id, edit_spec: spec, display_name: dn });
-          done.push(s.id);
-        }
+        await enqueueClips(job.id, clips, done);
       } catch (e) {
         // Every clip is its own job, committed as it goes: a failure at clip 3 of 3 (the job cap) left
         // clips 1 and 2 queued while the editor reported a plain failure and kept all three selected,
@@ -462,8 +475,13 @@ export default function VideoEditor({ job, onClose }: { job: DownloadJob; onClos
               setDrag({ type: "seek" });
               seek(timeAt(e.clientX));
             }}
-            onPointerMove={(e) => setHoverX(e.clientX)}
-            onPointerLeave={() => setHoverX(null)}
+            onPointerMove={(e) =>
+              setHover({
+                x: e.clientX - e.currentTarget.getBoundingClientRect().left,
+                time: timeAt(e.clientX),
+              })
+            }
+            onPointerLeave={() => setHover(null)}
           >
             {/* aspect-correct filmstrip */}
             {stripCells > 0 && (
diff --git a/frontend/src/components/ViewSwitcher.tsx b/frontend/src/components/ViewSwitcher.tsx
index 1973248c..8148edd1 100644
--- a/frontend/src/components/ViewSwitcher.tsx
+++ b/frontend/src/components/ViewSwitcher.tsx
@@ -56,6 +56,8 @@ export default function ViewSwitcher<T extends string>({
     selectedIndex: currentIdx,
   });
 
+  const { setReference } = pop.refs;
+
   const current = options[currentIdx];
   if (!current) return null;
   const CurrentIcon = current.icon;
@@ -66,7 +68,7 @@ export default function ViewSwitcher<T extends string>({
         context="toolbar"
         open={open}
         icon={<CurrentIcon className="w-4 h-4 shrink-0" />}
-        ref={pop.refs.setReference}
+        ref={setReference}
         {...pop.getReferenceProps()}
         // The aria-label carries the mode's name at every size — the visible text below is a
         // nicety for wide windows, not the accessible name.
diff --git a/frontend/src/components/WatchPage.tsx b/frontend/src/components/WatchPage.tsx
index 47e87f30..d14c692e 100644
--- a/frontend/src/components/WatchPage.tsx
+++ b/frontend/src/components/WatchPage.tsx
@@ -31,14 +31,15 @@ function useMediaSession(
   useEffect(() => {
     if (!ready || !meta || !("mediaSession" in navigator)) return;
     const video = videoRef.current;
+    const init: MediaMetadataInit = {
+      title: meta.title || "Video",
+      artist: meta.uploader || "Siftlode",
+      artwork: meta.poster_url
+        ? [{ src: meta.poster_url, sizes: "512x512", type: "image/jpeg" }]
+        : [],
+    };
     try {
-      navigator.mediaSession.metadata = new MediaMetadata({
-        title: meta.title || "Video",
-        artist: meta.uploader || "Siftlode",
-        artwork: meta.poster_url
-          ? [{ src: meta.poster_url, sizes: "512x512", type: "image/jpeg" }]
-          : [],
-      });
+      navigator.mediaSession.metadata = new MediaMetadata(init);
       navigator.mediaSession.setActionHandler("play", () => void video?.play());
       navigator.mediaSession.setActionHandler("pause", () => video?.pause());
     } catch {
@@ -197,36 +198,41 @@ export default function WatchPage() {
     setAttempt((n) => n + 1);
   };
 
+  // unlock()'s steps, apart so `unlocking` clears on every way out without a try/finally (the React
+  // Compiler cannot lower one yet, and skips the whole page).
+  const unlockSteps = async () => {
+    const r = await send(`/api/public/watch/${encodeURIComponent(token)}/unlock`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ password }),
+    });
+    if (r.status === 403) {
+      setError(T.wrong);
+      return;
+    }
+    // Unlocking is rate-limited per link: too many tries is not a dead link either.
+    if (r.status === 429) {
+      setError(T.tooMany);
+      return;
+    }
+    if (r.status === 404) {
+      setStatus("gone");
+      return;
+    }
+    if (!r.ok) throw new Error(`HTTP ${r.status}`);
+    setMeta(await r.json());
+    setStatus("ready");
+  };
+
   const unlock = async () => {
     setUnlocking(true);
     setError(null);
     try {
-      const r = await send(`/api/public/watch/${encodeURIComponent(token)}/unlock`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ password }),
-      });
-      if (r.status === 403) {
-        setError(T.wrong);
-        return;
-      }
-      // Unlocking is rate-limited per link: too many tries is not a dead link either.
-      if (r.status === 429) {
-        setError(T.tooMany);
-        return;
-      }
-      if (r.status === 404) {
-        setStatus("gone");
-        return;
-      }
-      if (!r.ok) throw new Error(`HTTP ${r.status}`);
-      setMeta(await r.json());
-      setStatus("ready");
+      await unlockSteps();
     } catch {
       setError(T.unlockFailed);
-    } finally {
-      setUnlocking(false);
     }
+    setUnlocking(false);
   };
 
   return (
diff --git a/frontend/src/components/Welcome.tsx b/frontend/src/components/Welcome.tsx
index 82615fb9..322dfb6e 100644
--- a/frontend/src/components/Welcome.tsx
+++ b/frontend/src/components/Welcome.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState } from "react";
+import { useEffect, useEffectEvent, useRef, useState } from "react";
 import { useHistorySubview } from "../lib/history";
 import { useTranslation } from "react-i18next";
 import {
@@ -270,9 +270,8 @@ function Lightbox({ src, label, onClose }: { src: string; label: string; onClose
   // `useDialogChrome` and its one counted scroll lock.
   const panelRef = useRef<HTMLDivElement>(null);
   useDialogChrome(panelRef);
-  // Keep a stable handler across renders so the stack id is assigned once per mount (as in ui/Modal).
-  const onCloseRef = useRef(onClose);
-  onCloseRef.current = onClose;
+  // An effect event, so the stack id is assigned once per mount (as in ui/Modal).
+  const close = useEffectEvent(onClose);
   useEffect(() => {
     // Round 6 gave this shell the trap and the restore but not the LAYER MEMBERSHIP the other three
     // have, so its Escape and Tab fired from a raw window listener whatever was on top of it. That
@@ -285,7 +284,7 @@ function Lightbox({ src, label, onClose }: { src: string; label: string; onClose
     const onKey = (e: KeyboardEvent) => {
       if (takeEscape(e, id)) {
         e.stopPropagation();
-        onCloseRef.current();
+        close();
         return;
       }
       // The trap defers only to a layer that owns the keyboard, not to a hover card under the pointer.
@@ -478,7 +477,7 @@ function AuthCard({ verify }: { verify: VerifyEntry }) {
     setMode("forgot");
   };
 
-  async function onSubmit(e: React.FormEvent) {
+  async function onSubmit(e: React.SubmitEvent<HTMLFormElement>) {
     e.preventDefault();
     setAttempt((n) => n + 1);
     reset();
@@ -495,13 +494,12 @@ function AuthCard({ verify }: { verify: VerifyEntry }) {
       return;
     }
     setBusy(true);
+    const resetWith = resetToken ?? "";
     try {
       if (mode === "signin") {
         await api.passwordLogin(mail, password);
         window.location.reload();
-        return;
-      }
-      if (mode === "register") {
+      } else if (mode === "register") {
         await api.register(mail, password);
         setDone(t("welcome.auth.registerDone"));
       } else if (mode === "forgot") {
@@ -511,7 +509,7 @@ function AuthCard({ verify }: { verify: VerifyEntry }) {
         await api.resendVerification(mail);
         setDone(t("welcome.auth.resendDone"));
       } else if (mode === "reset") {
-        await api.confirmPasswordReset(resetToken ?? "", password);
+        await api.confirmPasswordReset(resetWith, password);
         setResetToken(null); // single-use: the reset view is no longer a place to come back to
         setDone(t("welcome.auth.resetDone"));
       }
@@ -521,24 +519,21 @@ function AuthCard({ verify }: { verify: VerifyEntry }) {
       const refusal = err instanceof HttpError ? loginBlocked(err.detailData) : null;
       if (refusal && PANEL_REASONS.has(refusal.reason)) {
         setBlocked(refusal);
-        return;
-      }
-      // The token died between the pre-flight check and this submit — or was never checked, because
-      // the probe itself failed. Either way the answer is the same screen, not a red line.
-      if (mode === "reset" && err instanceof HttpError && deadResetLink(err.detailData)) {
+      } else if (mode === "reset" && err instanceof HttpError && deadResetLink(err.detailData)) {
+        // The token died between the pre-flight check and this submit — or was never checked,
+        // because the probe itself failed. Either way the answer is the same screen, not a red line.
         setDeadReset(true);
         setResetToken(null);
-        return;
+      } else {
+        setError(
+          err instanceof HttpError && err.detail ? err.detail : t("welcome.auth.genericError"),
+        );
       }
-      setError(
-        err instanceof HttpError && err.detail ? err.detail : t("welcome.auth.genericError"),
-      );
-    } finally {
-      setBusy(false);
     }
+    setBusy(false);
   }
 
-  async function onDemo(e: React.FormEvent) {
+  async function onDemo(e: React.SubmitEvent<HTMLFormElement>) {
     e.preventDefault();
     setDemoError("");
     const mail = demoEmail.trim().toLowerCase();
@@ -553,9 +548,8 @@ function AuthCard({ verify }: { verify: VerifyEntry }) {
       else setDemoError(t("welcome.auth.demoDenied"));
     } catch {
       setDemoError(t("welcome.auth.demoDenied"));
-    } finally {
-      setDemoBusy(false);
     }
+    setDemoBusy(false);
   }
 
   // A named state owns the card's heading while it is up, so it reads as the card's subject rather
diff --git a/frontend/src/components/YearFilter.tsx b/frontend/src/components/YearFilter.tsx
index 18538a82..97da87f8 100644
--- a/frontend/src/components/YearFilter.tsx
+++ b/frontend/src/components/YearFilter.tsx
@@ -90,6 +90,8 @@ export default function YearFilter({
     placement: "bottom-start",
   });
 
+  const { setReference } = pop.refs;
+
   // Honest states: a first-load / errored fetch must not read as "no years" (an empty chip row).
   if (years.length === 0) {
     if (yearsQuery.isLoading) {
@@ -124,7 +126,7 @@ export default function YearFilter({
       {years.length > quick.length && (
         <>
           <Chip
-            ref={pop.refs.setReference}
+            ref={setReference}
             {...pop.getReferenceProps()}
             aria-label={t("sidebar.year.moreLabel")}
           >
diff --git a/frontend/src/components/accountPanel.dom.test.tsx b/frontend/src/components/accountPanel.dom.test.tsx
index 49191ce8..a7b286f3 100644
--- a/frontend/src/components/accountPanel.dom.test.tsx
+++ b/frontend/src/components/accountPanel.dom.test.tsx
@@ -67,8 +67,8 @@ function mount(u: typeof user = user) {
   const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
   render(
     <QueryClientProvider client={qc}>
-      {/* eslint-disable-next-line @typescript-eslint/no-explicit-any */}
-      <AccountPanel user={u as any} onClose={() => {}} />
+      {/* a partial user fixture: `never` stands in for the full type without an `any` */}
+      <AccountPanel user={u as never} onClose={() => {}} />
     </QueryClientProvider>,
   );
 }
diff --git a/frontend/src/components/authCardStates.dom.test.tsx b/frontend/src/components/authCardStates.dom.test.tsx
index 59c37ade..c0e09e56 100644
--- a/frontend/src/components/authCardStates.dom.test.tsx
+++ b/frontend/src/components/authCardStates.dom.test.tsx
@@ -7,7 +7,7 @@
 //
 // entryUrl snapshots window.location at IMPORT time, so the access-notice cases reset the module
 // registry and set the URL before importing — that is the behaviour under test, not a workaround.
-import { describe, it, expect, afterEach, vi } from "vitest";
+import { describe, it, expect, afterEach, beforeAll, vi } from "vitest";
 import { render, screen, fireEvent, cleanup, act } from "@testing-library/react";
 import type { VerifyEntry } from "../lib/useVerifyEntry";
 
@@ -18,6 +18,13 @@ const noVerify: VerifyEntry = {
   dismiss: () => {},
 };
 
+// Every case re-imports the whole Welcome tree after a module reset. The FIRST import also transforms
+// it, which under the full suite's parallel load ran past the 5 s test timeout (E32 S2, gate flake).
+// Transforms survive resetModules, so warming them once here leaves each case only the evaluation.
+beforeAll(async () => {
+  await import("./Welcome");
+}, 60_000);
+
 afterEach(() => {
   cleanup();
   vi.resetModules();
diff --git a/frontend/src/components/channelChipNames.dom.test.tsx b/frontend/src/components/channelChipNames.dom.test.tsx
new file mode 100644
index 00000000..9dccbdaf
--- /dev/null
+++ b/frontend/src/components/channelChipNames.dom.test.tsx
@@ -0,0 +1,117 @@
+// @vitest-environment jsdom
+//
+// A channel filter's chips are named from the subscription list, which a reload has not fetched yet:
+// they used to read as raw UC… ids for a moment (the owner, 2026-10-03). The names seen last time now
+// name them until the list lands; a channel never named on this browser draws a placeholder instead.
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { act, cleanup, render, renderHook, screen, waitFor } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { createElement, type ReactNode } from "react";
+import { api, type FeedFilters, type ManagedChannel } from "../lib/api";
+import { ACTIVE_ACCOUNT_KEY } from "../lib/activeAccount";
+import { accountKey, LS } from "../lib/storage";
+import { clearedFilters, useActiveFilters } from "../lib/useActiveFilters";
+import ActiveFilterChips from "./ActiveFilterChips";
+import ChannelPicker from "./ChannelPicker";
+
+vi.mock("react-i18next", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("react-i18next")>();
+  return {
+    ...actual,
+    useTranslation: () => ({ t: (key: string) => key, i18n: { language: "en" } }),
+  };
+});
+
+const KNOWN = "UCknown0000000000000000";
+const NEW = "UCnever00000000000000000";
+const filters: FeedFilters = {
+  ...clearedFilters({ q: "" } as FeedFilters),
+  channelIds: [KNOWN, NEW],
+};
+const namesKey = () => accountKey(LS.channelNames, 5)!;
+
+let resolveChannels: (c: ManagedChannel[]) => void;
+let qc: QueryClient;
+const wrapper = ({ children }: { children: ReactNode }) =>
+  createElement(QueryClientProvider, { client: qc }, children);
+
+beforeEach(() => {
+  localStorage.clear();
+  sessionStorage.setItem(ACTIVE_ACCOUNT_KEY, "5");
+  localStorage.setItem(namesKey(), JSON.stringify({ [KNOWN]: "Remembered name" }));
+  qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  vi.spyOn(api, "tags").mockResolvedValue([] as never);
+  vi.spyOn(api, "channels").mockReturnValue(
+    new Promise<ManagedChannel[]>((r) => {
+      resolveChannels = r;
+    }),
+  );
+});
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+const land = async () => {
+  await act(async () => {
+    resolveChannels([
+      { id: KNOWN, title: "Renamed since" },
+      { id: NEW, title: "Brand new" },
+    ] as ManagedChannel[]);
+  });
+};
+
+describe("a channel filter's chip names", () => {
+  it("name a remembered channel before the list lands, and hold the rest as pending", async () => {
+    const { result } = renderHook(() => useActiveFilters(filters, () => {}), { wrapper });
+    const chip = (id: string) => result.current.find((f) => f.key === `channel:${id}`)!;
+    expect(chip(KNOWN)).toMatchObject({ label: "Remembered name", pending: false });
+    expect(chip(NEW)).toMatchObject({ label: NEW, pending: true });
+
+    await land();
+    await waitFor(() => expect(chip(NEW)).toMatchObject({ label: "Brand new", pending: false }));
+    // The list wins over the remembered copy, and replaces it for the next reload.
+    expect(chip(KNOWN).label).toBe("Renamed since");
+    expect(JSON.parse(localStorage.getItem(namesKey())!)).toEqual({
+      [KNOWN]: "Renamed since",
+      [NEW]: "Brand new",
+    });
+  });
+
+  it("draw a placeholder above the feed, not the raw id", () => {
+    const { result } = renderHook(() => useActiveFilters(filters, () => {}), { wrapper });
+    const { container } = render(
+      <ActiveFilterChips filters={result.current} onClearAll={() => {}} />,
+    );
+    expect(screen.getAllByText("Remembered name").length).toBeGreaterThan(0);
+    // The id is only a screen reader's (sr-only), beside a bone; nothing paints it.
+    for (const el of screen.getAllByText(NEW)) expect(el.className).toBe("sr-only");
+    expect(container.querySelectorAll(".animate-pulse").length).toBeGreaterThan(0);
+  });
+
+  it("draw a placeholder in the filter panel's picker, then the name", async () => {
+    const { container } = render(<ChannelPicker filters={filters} setFilters={() => {}} />, {
+      wrapper,
+    });
+    screen.getByText("Remembered name");
+    expect(screen.getByText(NEW).className).toBe("sr-only");
+    expect(container.querySelectorAll(".animate-pulse")).toHaveLength(1);
+
+    await land();
+    await waitFor(() => screen.getByText("Brand new"));
+    expect(screen.queryByText(NEW)).toBeNull();
+    expect(container.querySelectorAll(".animate-pulse")).toHaveLength(0);
+  });
+
+  it("fall back to the id when the list fails, so each chip stays told apart", async () => {
+    localStorage.removeItem(namesKey());
+    vi.spyOn(api, "channels").mockRejectedValue(new Error("down"));
+    const { result } = renderHook(() => useActiveFilters(filters, () => {}), { wrapper });
+    await waitFor(() =>
+      expect(result.current.find((f) => f.key === `channel:${NEW}`)).toMatchObject({
+        label: NEW,
+        pending: false,
+      }),
+    );
+  });
+});
diff --git a/frontend/src/components/channelColumns.dom.test.tsx b/frontend/src/components/channelColumns.dom.test.tsx
index 3128b403..794db934 100644
--- a/frontend/src/components/channelColumns.dom.test.tsx
+++ b/frontend/src/components/channelColumns.dom.test.tsx
@@ -5,8 +5,14 @@
 // "fully" | "needsFull" | "" vocab + predicate — asserted here so a regression can't silently change
 // which channels the top chips show.
 import { describe, it, expect } from "vitest";
-import { applySyncFilter, buildChannelColumns, tagsColumnTest } from "./channelColumns";
-import { NO_TAG_SENTINEL, type ManagedChannel } from "../lib/api";
+import {
+  applySyncFilter,
+  buildChannelColumns,
+  tagFilterChips,
+  tagsColumnTest,
+} from "./channelColumns";
+import { NO_TAG_SENTINEL, type ManagedChannel, type Tag } from "../lib/api";
+import type { TFunction } from "i18next";
 
 const ch = (over: Partial<ManagedChannel>): ManagedChannel => ({
   id: "c",
@@ -72,6 +78,50 @@ describe("tagsColumnTest (item B — 'No tag')", () => {
   });
 });
 
+describe("tagFilterChips — a pick whose tag is gone (E32 S2)", () => {
+  const mine = { id: 1, name: "Music", system: false } as Tag;
+  const t = ((k: string) => k) as unknown as TFunction;
+  type State = "loaded" | "loading" | "failed";
+  const chips = (state: State, picked: string[]) =>
+    tagFilterChips({
+      userTags: state === "loaded" ? [mine] : [],
+      tags: {
+        data: state === "loaded" ? [mine] : undefined,
+        isSuccess: state === "loaded",
+        isPending: state === "loading",
+      },
+      picked,
+      noTagOn: false,
+      toggle: () => {},
+      toggleNoTag: () => {},
+      t,
+    });
+
+  it("stays a visible, active chip instead of an empty table with no reason", () => {
+    expect(chips("loaded", ["1", "77"]).map((c) => [c.key, c.label, c.active])).toEqual([
+      ["t77", "common.deletedTag", true], // first: the "+N" overflow must not fold it away
+      ["t1", "Music", true],
+      [NO_TAG_SENTINEL, "channels.tags.noTag", false],
+    ]);
+  });
+
+  // E32 review: before, a pick had NO chip at all until the list loaded — or ever, after a failed
+  // load — while it still narrowed the table.
+  it("is a placeholder while the tag list loads, never called deleted", () => {
+    expect(chips("loading", ["77"]).map((c) => [c.key, c.label, c.pending])).toEqual([
+      ["t77", "77", true],
+      [NO_TAG_SENTINEL, "channels.tags.noTag", undefined],
+    ]);
+  });
+
+  it("shows the id after a failed load, still a visible, removable chip", () => {
+    expect(chips("failed", ["77"]).map((c) => [c.key, c.label, c.pending, c.active])).toEqual([
+      ["t77", "77", false, true],
+      [NO_TAG_SENTINEL, "channels.tags.noTag", undefined, false],
+    ]);
+  });
+});
+
 describe("buildChannelColumns — the row's end", () => {
   it('ends every row in the channel\'s "…", with no action buttons before it', () => {
     const more = (c: ManagedChannel) => `more:${c.id}`;
diff --git a/frontend/src/components/channelColumns.tsx b/frontend/src/components/channelColumns.tsx
index 35a5f466..1bbd8808 100644
--- a/frontend/src/components/channelColumns.tsx
+++ b/frontend/src/components/channelColumns.tsx
@@ -1,6 +1,7 @@
 import type { ComponentProps, ReactNode } from "react";
 import type { TFunction } from "i18next";
-import { NO_TAG_SENTINEL, type ManagedChannel } from "../lib/api";
+import { NO_TAG_SENTINEL, type ManagedChannel, type Tag } from "../lib/api";
+import { tagPickLabel, type TagList } from "../lib/tagPicks";
 import { formatCountOrDash, formatTotalHours } from "../lib/format";
 import type { Column } from "./ui/DataTable";
 import { PriorityStepper } from "./ui/PriorityStepper";
@@ -10,6 +11,7 @@ import { ChannelTagsControl, type SuggestedTag } from "./ChannelTags";
 import { StoredCell } from "./channelCells";
 import { isFullySynced } from "./channelSync";
 import { RelativeTime } from "./ui/RelativeTime";
+import type { FilterChip } from "./TagFilterChips";
 
 /** The shared "subscribers" DataTable column (right-aligned, sortable, em-dash for null) — identical
  * in the Channels manager and the ChannelDiscovery table, which show subscriber counts on different
@@ -43,11 +45,52 @@ export function applySyncFilter(rows: ManagedChannel[], value: unknown): Managed
 /** The Tags column filter predicate (item B): the "No tag" sentinel keeps channels the user hasn't
  *  personally tagged (empty `tag_ids`); it's exclusive with real tag picks (the chip row enforces that),
  *  so when present it wins. Otherwise a channel passes if it carries ANY selected tag id. */
+/** @internal exported for channelColumns.dom.test.tsx */
 export function tagsColumnTest(c: ManagedChannel, values: string[]): boolean {
   if (values.includes(NO_TAG_SENTINEL)) return c.tag_ids.length === 0;
   return values.some((v) => c.tag_ids.includes(Number(v)));
 }
 
+/** The manager's tag-filter chip row (the Tags column filter's values): any picked id that is not one
+ *  of the user's tags, then each user tag, then the "No tag" sentinel. A stored pick can outlive its
+ *  tag (deleted here or on another device) and still narrows the table to nothing, so it stays a
+ *  visible, removable chip — FIRST, so the row's "+N" overflow never folds the reason away (E32 S2) —
+ *  and so does every pick while the tag list loads or after it failed, named by lib/tagPicks' rule
+ *  (a placeholder, then the name, "Deleted tag" or the id), not hidden (E32 review). */
+export function tagFilterChips(o: {
+  userTags: Tag[];
+  tags: TagList;
+  picked: string[];
+  noTagOn: boolean;
+  toggle: (tagId: number) => void;
+  toggleNoTag: () => void;
+  t: TFunction;
+}): FilterChip[] {
+  const mine = new Set(o.userTags.map((tg) => String(tg.id)));
+  const others = o.picked.filter((id) => id !== NO_TAG_SENTINEL && !mine.has(id));
+  return [
+    ...others.map((id) => ({
+      key: `t${id}`,
+      label: tagPickLabel(Number(id), o.tags, o.t),
+      pending: o.tags.isPending,
+      active: true,
+      onToggle: () => o.toggle(Number(id)),
+    })),
+    ...o.userTags.map((tg) => ({
+      key: `t${tg.id}`,
+      label: tg.name,
+      active: o.picked.includes(String(tg.id)),
+      onToggle: () => o.toggle(tg.id),
+    })),
+    {
+      key: NO_TAG_SENTINEL,
+      label: o.t("channels.tags.noTag"),
+      active: o.noTagOn,
+      onToggle: o.toggleNoTag,
+    },
+  ];
+}
+
 /** Everything the Channels-manager column set closes over. The manager owns the state + mutations;
  * this factory just wires them into `Column<ManagedChannel>` render/filter/sort defs so the ~150-line
  * column block lives outside the page component (its cell components are in channelCells). */
diff --git a/frontend/src/components/compilerCoverage.contract.test.ts b/frontend/src/components/compilerCoverage.contract.test.ts
new file mode 100644
index 00000000..bc24d36e
--- /dev/null
+++ b/frontend/src/components/compilerCoverage.contract.test.ts
@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import { compileReport, shippedSources, type CompileReport } from "./compilerSkips.testkit";
+
+// The React Compiler bails out of a component it cannot prove safe WITHOUT a word: the component
+// still works, it just re-renders everything under it on every render. The channel manager is where
+// it hurt (the owner, 2026-10-03): Channels and DataTable both bailed out, every open, close and
+// reposition of a row's right-click menu rebuilt the rows and columns, and on "All" rows the menu
+// took ~0.9 s to open and ~0.6 s to close. The E32 audit then found 95 such functions across src.
+//
+// A RATCHET over everything the build compiles (E32 S1). KNOWN_SKIPS is the exact set the compiler
+// skips today, `file → function → the compiler's category`; everything else must compile. Both
+// directions are red:
+//   • a NEW skip (or a known one changing category) — fix the function; if it truly cannot be
+//     compiled, adding it here is a decision for the owner, with the reason in docs/gates.md;
+//   • a skip that is GONE — delete its entry, so the list only ever shrinks.
+// E32 burned it down from 93 to the one function below: S3 read the popover engine through
+// destructuring and moved every render-phase ref write to `useEffectEvent` / `useLatest`; S4 took
+// try/finally and every conditional, loop or optional call out of try blocks (the compiler cannot
+// lower them yet — and `react-hooks/todo` does not see the latter, so THIS test is what catches them)
+// and replaced the two exhaustive-deps suppressions, each of which skipped its whole function.
+// VirtualGrid stays: TanStack Virtual's API cannot be memoized safely (IncompatibleLibrary).
+const KNOWN_SKIPS: CompileReport["skipped"] = {
+  "components/ui/VirtualGrid.tsx": { VirtualGrid: "IncompatibleLibrary" },
+};
+
+// The files a regression hurt most: compiled, and they must stay so (a positive check too, so a
+// harness that compiled nothing could not pass as "no skips").
+const MUST_COMPILE: Record<string, string[]> = {
+  "components/Channels.tsx": ["Channels"],
+  "components/ui/DataTable.tsx": ["DataTable"],
+  // Under every button and every popover in the app (E32 S3).
+  "components/ui/FocusSafeButton.tsx": ["FocusSafeButton"],
+  "components/ui/anchoredPopoverHooks.ts": ["useAnchoredPopover"],
+  "components/ui/AnchoredPopover.tsx": ["PopoverSurfaceInner"],
+  // The two players — the largest components here, and the last to compile (E32 S4).
+  "components/PlexPlayer.tsx": ["PlexPlayer"],
+  "components/PlayerModal.tsx": ["PlayerModal"],
+  "lib/playerModalHooks.ts": ["useYtProgress"],
+};
+
+type Row = [file: string, fn: string, category: string];
+const rows = (skips: CompileReport["skipped"]): Row[] =>
+  Object.entries(skips).flatMap(([file, fns]) =>
+    Object.entries(fns).map(([fn, category]): Row => [file, fn, category]),
+  );
+
+describe("the React Compiler", () => {
+  // ~8 s for the whole tree, once, shared by the checks below.
+  const report = compileReport(shippedSources());
+  const actual = rows(report.skipped);
+  const known = rows(KNOWN_SKIPS);
+  const key = ([f, fn]: Row) => `${f} → ${fn}`;
+
+  it("skips nothing new (fix it, or the owner decides to list it)", () => {
+    const knownAs = new Map(known.map((r) => [key(r), r[2]]));
+    expect(
+      actual.filter((r) => knownAs.get(key(r)) !== r[2]).map((r) => `${key(r)}: ${r[2]}`),
+    ).toEqual([]);
+  });
+
+  it("lists no skip that has gone (delete it — the list only shrinks)", () => {
+    const actualAs = new Map(actual.map((r) => [key(r), r[2]]));
+    expect(known.filter((r) => !actualAs.has(key(r))).map(key)).toEqual([]);
+  });
+
+  it.each(Object.entries(MUST_COMPILE))("compiles %s", (file, fns) => {
+    expect(report.skipped[file] ?? {}).toEqual({});
+    for (const fn of fns) expect(report.compiled[file]).toContain(fn);
+  });
+});
diff --git a/frontend/src/components/compilerSkips.testkit.ts b/frontend/src/components/compilerSkips.testkit.ts
new file mode 100644
index 00000000..d42731e3
--- /dev/null
+++ b/frontend/src/components/compilerSkips.testkit.ts
@@ -0,0 +1,124 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { parseSync, transformSync, type types as t } from "@babel/core";
+import reactCompiler from "babel-plugin-react-compiler";
+
+// Runs the real React Compiler — the options reactPlugin.ts gives it — over the shipped source and
+// reports every function it SKIPS, keyed `file → function → category`. The compiler skips without a
+// word (`panicThreshold` is "none" and the build has no logger), so this is the only place a skip is
+// visible at all. Used by compilerCoverage.contract.test.ts.
+
+const SRC = new URL("../", import.meta.url);
+
+/** Every file the production build compiles: src, minus tests and test kits. */
+export function shippedSources(): string[] {
+  return (readdirSync(SRC, { recursive: true }) as string[])
+    .map((p) => p.split("\\").join("/"))
+    .filter(
+      (p) => /\.(ts|tsx)$/.test(p) && !/\.(test|testkit)\.tsx?$/.test(p) && !p.endsWith(".d.ts"),
+    )
+    .sort();
+}
+
+type Node = t.Node & { [k: string]: unknown };
+const isFn = (n: Node) =>
+  n.type === "FunctionDeclaration" ||
+  n.type === "FunctionExpression" ||
+  n.type === "ArrowFunctionExpression";
+
+/** The name a reader would look a function up by: its own, the variable it is assigned to (through
+ *  a `memo(…)` / `forwardRef(…)` wrapper), or `default` for an anonymous default export. */
+function functionNames(ast: t.File): Map<string, string> {
+  const names = new Map<string, string>();
+  const walk = (node: Node, parents: Node[]) => {
+    if (isFn(node) && node.loc) {
+      let name = (node as t.FunctionDeclaration).id?.name ?? null;
+      for (let i = parents.length - 1; !name && i >= 0; i--) {
+        const p = parents[i]!;
+        if (p.type === "VariableDeclarator" && p.id.type === "Identifier") name = p.id.name;
+        else if (p.type === "ExportDefaultDeclaration") name = "default";
+        else if (p.type !== "CallExpression" && p.type !== "TSAsExpression") break;
+      }
+      names.set(
+        `${node.loc.start.line}:${node.loc.start.column}`,
+        name ?? `<line ${node.loc.start.line}>`,
+      );
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+      const v = node[key];
+      if (Array.isArray(v)) {
+        for (const c of v)
+          if (c && typeof c === "object" && "type" in c) walk(c as Node, [...parents, node]);
+      } else if (v && typeof v === "object" && "type" in v) walk(v as Node, [...parents, node]);
+    }
+  };
+  walk(ast as unknown as Node, []);
+  return names;
+}
+
+type Detail = {
+  category?: string;
+  reason?: string;
+  options?: { category?: string; reason?: string };
+};
+
+export interface CompileReport {
+  /** file → function → the compiler's category for the skip (Refs, Todo, Immutability, …). */
+  skipped: Record<string, Record<string, string>>;
+  /** file → the functions it did compile. */
+  compiled: Record<string, string[]>;
+}
+
+export function compileReport(files: string[]): CompileReport {
+  const skipped: CompileReport["skipped"] = {};
+  const compiled: CompileReport["compiled"] = {};
+  for (const file of files) {
+    const source = readFileSync(new URL(file, SRC), "utf8");
+    const opts = { filename: file, babelrc: false, configFile: false } as const;
+    const ast = parseSync(source, { ...opts, parserOpts: { plugins: ["jsx", "typescript"] } });
+    if (!ast) throw new Error(`could not parse ${file}`);
+    const names = functionNames(ast);
+    const nameAt = (loc: t.SourceLocation | null) =>
+      loc
+        ? (names.get(`${loc.start.line}:${loc.start.column}`) ?? `<line ${loc.start.line}>`)
+        : "<unknown>";
+    transformSync(source, {
+      ...opts,
+      parserOpts: { plugins: ["jsx", "typescript"] },
+      plugins: [
+        [
+          reactCompiler,
+          {
+            target: "19",
+            logger: {
+              logEvent: (
+                _f: string | null,
+                e: {
+                  kind: string;
+                  fnLoc?: t.SourceLocation | null;
+                  detail?: Detail;
+                  reason?: string;
+                },
+              ) => {
+                if (e.kind === "CompileSuccess") {
+                  (compiled[file] ??= []).push(nameAt(e.fnLoc ?? null));
+                  return;
+                }
+                let category: string;
+                if (e.kind === "CompileError")
+                  category = e.detail?.options?.category ?? e.detail?.category ?? "Unknown";
+                else if (e.kind === "CompileSkip") category = `Skip: ${e.reason}`;
+                else if (e.kind === "PipelineError") category = "PipelineError";
+                else return;
+                const fns = (skipped[file] ??= {});
+                // The first reason is the one that stopped it; later ones are the same function.
+                fns[nameAt(e.fnLoc ?? null)] ??= category;
+              },
+            },
+          },
+        ],
+      ],
+    });
+  }
+  return { skipped, compiled };
+}
diff --git a/frontend/src/components/downloadAdmin.dom.test.tsx b/frontend/src/components/downloadAdmin.dom.test.tsx
new file mode 100644
index 00000000..575de8e9
--- /dev/null
+++ b/frontend/src/components/downloadAdmin.dom.test.tsx
@@ -0,0 +1,90 @@
+// @vitest-environment jsdom
+//
+// E32 S2: the admin's download-quota editor rendered NOTHING while its quota loaded and nothing when
+// the load failed, so the click looked dead. It now opens at once and says which it is. The save
+// turns the GB field back into bytes; the reset drops the override.
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type { ReactNode } from "react";
+import { api } from "../lib/api";
+import { QuotaModal } from "./downloadAdmin";
+
+vi.mock("react-i18next", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("react-i18next")>();
+  return {
+    ...actual,
+    useTranslation: () => ({ t: (key: string) => key, i18n: { language: "en" } }),
+  };
+});
+
+const GiB = 1024 ** 3;
+const QUOTA = { max_bytes: 5 * GiB, max_jobs: 10, max_concurrent: 2, unlimited: false };
+let qc: QueryClient;
+const wrap = (ui: ReactNode) => <QueryClientProvider client={qc}>{ui}</QueryClientProvider>;
+const open = (onClose = () => {}) =>
+  render(wrap(<QuotaModal userId={4} email="a@b.c" onClose={onClose} />));
+
+beforeEach(() => {
+  qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+});
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+describe("the download-quota editor", () => {
+  it("opens at once and says it is loading", () => {
+    vi.spyOn(api, "adminGetDownloadQuota").mockReturnValue(new Promise(() => {}) as never);
+    open();
+    expect(screen.getByText("downloads.admin.quotaTitle")).toBeTruthy();
+    expect(screen.getAllByRole("status").length).toBeGreaterThan(0);
+  });
+
+  it("says a failed load failed, and retries it", async () => {
+    const get = vi
+      .spyOn(api, "adminGetDownloadQuota")
+      .mockRejectedValueOnce(new Error("down"))
+      .mockResolvedValueOnce(QUOTA as never);
+    open();
+    expect((await screen.findByRole("alert")).textContent).toContain("common.loadError");
+    fireEvent.click(screen.getByText("common.retry"));
+    await screen.findByDisplayValue("5");
+    expect(get).toHaveBeenCalledTimes(2);
+  });
+
+  it("gives the first field the focus when the form arrives after a retry", async () => {
+    // jsdom lays nothing out, so every element reads as hidden to the dialog's focus rules.
+    vi.spyOn(HTMLElement.prototype, "offsetParent", "get").mockReturnValue(document.body);
+    vi.spyOn(api, "adminGetDownloadQuota")
+      .mockRejectedValueOnce(new Error("down"))
+      .mockResolvedValueOnce(QUOTA as never);
+    open();
+    await screen.findByRole("alert");
+    const retry = screen.getByText("common.retry").closest("button")!;
+    await waitFor(() => expect(document.activeElement).toBe(retry));
+    fireEvent.click(retry); // the Retry gives way to the spinner: its focus must not fall to <body>
+    const first = await screen.findByDisplayValue("5");
+    await waitFor(() => expect(document.activeElement).toBe(first));
+  });
+
+  it("saves the GB field as bytes, and the reset drops the override", async () => {
+    vi.spyOn(api, "adminGetDownloadQuota").mockResolvedValue(QUOTA as never);
+    const set = vi.spyOn(api, "adminSetDownloadQuota").mockResolvedValue(QUOTA as never);
+    const reset = vi.spyOn(api, "adminResetDownloadQuota").mockResolvedValue(QUOTA as never);
+    const onClose = vi.fn();
+    open(onClose);
+    fireEvent.change(await screen.findByDisplayValue("5"), { target: { value: "1.5" } });
+    fireEvent.click(screen.getByText("downloads.admin.save"));
+    await waitFor(() => expect(onClose).toHaveBeenCalledTimes(1));
+    expect(set).toHaveBeenCalledWith(4, {
+      max_bytes: Math.round(1.5 * GiB),
+      max_jobs: 10,
+      max_concurrent: 2,
+      unlimited: false,
+    });
+
+    fireEvent.click(screen.getByText("downloads.admin.reset"));
+    await waitFor(() => expect(reset).toHaveBeenCalledWith(4));
+  });
+});
diff --git a/frontend/src/components/downloadAdmin.tsx b/frontend/src/components/downloadAdmin.tsx
index 4ed7ecc9..30af39a8 100644
--- a/frontend/src/components/downloadAdmin.tsx
+++ b/frontend/src/components/downloadAdmin.tsx
@@ -13,6 +13,7 @@ import { jobTitle } from "./downloadTitle";
 import { IconButton } from "./ui/IconButton";
 import { Input } from "./ui/Input";
 import { CheckRow } from "./ui/NativeControls";
+import { LoadingState, StateMessage } from "./ui/QueryState";
 import { SURFACE } from "./ui/surfaces";
 import UserPicker from "./UserPicker";
 
@@ -21,7 +22,8 @@ import UserPicker from "./UserPicker";
 
 const GiB = 1024 ** 3;
 
-function QuotaModal({
+/** @internal exported for downloadAdmin.dom.test.tsx */
+export function QuotaModal({
   userId,
   email,
   onClose,
@@ -74,66 +76,80 @@ function QuotaModal({
     onSuccess: done,
     meta: { failTitle: "errors.writeFailed.downloadQuotaReset" },
   });
-  if (!state) return null;
-  const upd = (p: Partial<typeof state>) => setForm({ ...state, ...p });
+  const upd = (p: Partial<NonNullable<typeof state>>) => {
+    if (state) setForm({ ...state, ...p });
+  };
   return (
     <Modal
       initialFocus="field"
       title={t("downloads.admin.quotaTitle", { email })}
       onClose={onClose}
     >
-      <div className="space-y-3">
-        <div className="grid grid-cols-3 gap-3">
-          <label className="text-sm">
-            {t("downloads.admin.maxBytes")}
-            <Input
-              className="w-full"
-              type="number"
-              value={state.gb}
-              onChange={(e) => upd({ gb: Number(e.target.value) })}
-              disabled={state.unlimited}
-            />
-          </label>
-          <label className="text-sm">
-            {t("downloads.admin.maxJobs")}
-            <Input
-              className="w-full"
-              type="number"
-              value={state.jobs}
-              onChange={(e) => upd({ jobs: Number(e.target.value) })}
-            />
-          </label>
-          <label className="text-sm">
-            {t("downloads.admin.maxConcurrent")}
-            <Input
-              className="w-full"
-              type="number"
-              value={state.conc}
-              onChange={(e) => upd({ conc: Number(e.target.value) })}
-            />
-          </label>
-        </div>
-        <CheckRow
-          checked={state.unlimited}
-          onChange={(checked) => upd({ unlimited: checked })}
-          className="text-sm"
-        >
-          {t("downloads.admin.unlimited")}
-        </CheckRow>
-        <ModalFooter className="flex justify-between gap-2">
-          <Button variant="ghost" size="sm" onClick={() => reset.mutate()}>
-            {t("downloads.admin.reset")}
-          </Button>
-          <Button
-            variant="primary"
-            size="sm"
-            onClick={() => save.mutate()}
-            disabled={save.isPending}
+      {/* The modal opens at once: while the quota loads it says so, and a failed load says THAT,
+          with a retry — it used to render nothing at all, so the click looked dead (E32 S2). The
+          first field still takes focus when the form arrives (Modal's initialFocus="field"). */}
+      {!state ? (
+        q.isError ? (
+          <StateMessage tone="error" onRetry={() => void q.refetch()}>
+            {t("common.loadError")}
+          </StateMessage>
+        ) : (
+          <LoadingState />
+        )
+      ) : (
+        <div className="space-y-3">
+          <div className="grid grid-cols-3 gap-3">
+            <label className="text-sm">
+              {t("downloads.admin.maxBytes")}
+              <Input
+                className="w-full"
+                type="number"
+                value={state.gb}
+                onChange={(e) => upd({ gb: Number(e.target.value) })}
+                disabled={state.unlimited}
+              />
+            </label>
+            <label className="text-sm">
+              {t("downloads.admin.maxJobs")}
+              <Input
+                className="w-full"
+                type="number"
+                value={state.jobs}
+                onChange={(e) => upd({ jobs: Number(e.target.value) })}
+              />
+            </label>
+            <label className="text-sm">
+              {t("downloads.admin.maxConcurrent")}
+              <Input
+                className="w-full"
+                type="number"
+                value={state.conc}
+                onChange={(e) => upd({ conc: Number(e.target.value) })}
+              />
+            </label>
+          </div>
+          <CheckRow
+            checked={state.unlimited}
+            onChange={(checked) => upd({ unlimited: checked })}
+            className="text-sm"
           >
-            {t("downloads.admin.save")}
-          </Button>
-        </ModalFooter>
-      </div>
+            {t("downloads.admin.unlimited")}
+          </CheckRow>
+          <ModalFooter className="flex justify-between gap-2">
+            <Button variant="ghost" size="sm" onClick={() => reset.mutate()}>
+              {t("downloads.admin.reset")}
+            </Button>
+            <Button
+              variant="primary"
+              size="sm"
+              onClick={() => save.mutate()}
+              disabled={save.isPending}
+            >
+              {t("downloads.admin.save")}
+            </Button>
+          </ModalFooter>
+        </div>
+      )}
     </Modal>
   );
 }
diff --git a/frontend/src/components/legal/LegalLayout.tsx b/frontend/src/components/legal/LegalLayout.tsx
index 60e6f2d2..a4dd89bb 100644
--- a/frontend/src/components/legal/LegalLayout.tsx
+++ b/frontend/src/components/legal/LegalLayout.tsx
@@ -35,7 +35,7 @@ function useOperatorContact(): string | null {
   const [contact, setContact] = useState<string | null>(null);
   useEffect(() => {
     let alive = true;
-    fetchOperatorContact().then((c) => alive && setContact(c));
+    void fetchOperatorContact().then((c) => alive && setContact(c)); // never rejects: null on failure
     return () => {
       alive = false;
     };
diff --git a/frontend/src/components/playerModalControls.tsx b/frontend/src/components/playerModalControls.tsx
index b2933370..0649a20f 100644
--- a/frontend/src/components/playerModalControls.tsx
+++ b/frontend/src/components/playerModalControls.tsx
@@ -1,7 +1,11 @@
+import type { CSSProperties, Ref } from "react";
 import { useTranslation } from "react-i18next";
 import { Repeat, Repeat1, Shuffle, SkipBack, SkipForward } from "lucide-react";
+import type { VideoDetail } from "../lib/api";
 import type { AutoMode, LoopMode } from "../lib/playerModes";
 import { Button } from "./ui/Button";
+import { StateMessage } from "./ui/QueryState";
+import { renderDescription } from "./descriptionLinks";
 
 // Presentational controls for the YouTube modal player (PlayerModal), split out of the god component —
 // the sibling of plexPlayerControls.tsx. No state or effects here; all behaviour comes in via props.
@@ -101,3 +105,41 @@ export function PlayerTransportControls({
     </>
   );
 }
+
+/** The description, said the same way in its two places (the popover under 1280 px, the panel beside
+ *  the video above it): loading, failed with a retry, the text in the caller's box, or none. One
+ *  ladder, so the two cannot drift (E31 review 2: the failed state was tested in the panel only).
+ *  `ref` / `style` / `className` dress the text's box only. */
+export function PlayerDescription({
+  detail,
+  currentId,
+  onSeek,
+  onLoadVideo,
+  className,
+  style,
+  ref,
+}: {
+  detail: { isLoading: boolean; isError: boolean; data?: VideoDetail; refetch: () => unknown };
+  currentId: string;
+  onSeek: (seconds: number) => void;
+  onLoadVideo: (id: string, start: number | null) => void;
+  className: string;
+  style?: CSSProperties;
+  ref?: Ref<HTMLDivElement>;
+}) {
+  const { t } = useTranslation();
+  if (detail.isLoading) return <div className="text-sm text-muted">{t("player.loading")}</div>;
+  if (detail.isError && !detail.data)
+    return (
+      <StateMessage tone="error" compact onRetry={() => void detail.refetch()}>
+        {t("player.descriptionFailed")}
+      </StateMessage>
+    );
+  const text = detail.data?.description;
+  if (!text) return <div className="text-sm text-muted">{t("player.noDescription")}</div>;
+  return (
+    <div ref={ref} style={style} className={className}>
+      {renderDescription(text, { currentId, onSeek, onLoadVideo, t })}
+    </div>
+  );
+}
diff --git a/frontend/src/components/plexCards.dom.test.tsx b/frontend/src/components/plexCards.dom.test.tsx
index e155f584..defc33f5 100644
--- a/frontend/src/components/plexCards.dom.test.tsx
+++ b/frontend/src/components/plexCards.dom.test.tsx
@@ -112,9 +112,13 @@ describe("PlexPosterCard preview", () => {
     vi.useFakeTimers();
     render(<PlexPosterCard card={card} onOpen={vi.fn()} />);
     fireEvent.mouseEnter(root());
-    act(() => vi.advanceTimersByTime(600));
+    act(() => {
+      vi.advanceTimersByTime(600);
+    });
     expect(screen.queryByText("A quiet synopsis.")).toBeNull(); // a sweep opens nothing
-    act(() => vi.advanceTimersByTime(400));
+    act(() => {
+      vi.advanceTimersByTime(400);
+    });
     expect(screen.getByText("A quiet synopsis.")).toBeTruthy();
     expect(screen.getAllByText("A long title")).toHaveLength(2); // the card's and the preview's
   });
@@ -123,7 +127,9 @@ describe("PlexPosterCard preview", () => {
     vi.useFakeTimers();
     render(<PlexPosterCard card={card} onOpen={vi.fn()} />);
     fireEvent.focus(screen.getByRole("button", { name: "A long title" }));
-    act(() => vi.advanceTimersByTime(2000));
+    act(() => {
+      vi.advanceTimersByTime(2000);
+    });
     expect(screen.queryByText("A quiet synopsis.")).toBeNull();
   });
 });
diff --git a/frontend/src/components/plexCards.tsx b/frontend/src/components/plexCards.tsx
index d580e6cc..ed1e769e 100644
--- a/frontend/src/components/plexCards.tsx
+++ b/frontend/src/components/plexCards.tsx
@@ -528,69 +528,97 @@ export function CastStrip({
   onOpenPerson?: (name: string) => void;
 }) {
   const { t } = useTranslation();
-  const clickable = !!(onOpenPerson || onFilter);
   return (
     <section
       className={`${SURFACE.panel} p-4 sm:p-5 mb-6`}
       style={{ background: "color-mix(in srgb, var(--card) 55%, transparent)" }}
     >
       <h2 className="text-sm font-semibold mb-3">{t("plex.info.cast")}</h2>
-      <Carousel gap="gap-4" ariaLabel={t("plex.info.cast")} keyboardNav={clickable}>
-        {cast.map((c, i) => {
-          const inner = (
-            <>
-              <div
-                className={`mx-auto h-20 w-20 overflow-hidden rounded-full border bg-surface ${clickable ? "border-border group-hover/cast:border-accent" : "border-border"}`}
-              >
-                {c.thumb ? (
-                  <img src={c.thumb} alt="" loading="lazy" className="h-full w-full object-cover" />
-                ) : (
-                  <div className="grid h-full w-full place-items-center opacity-40">
-                    {c.name.charAt(0)}
-                  </div>
-                )}
-              </div>
-              {/* Name + role are each capped to ONE line (truncate → ellipsis) so every tile has the
-                  same text height and the row of circles sits on one baseline regardless of name length. */}
-              <div
-                className={`mt-1.5 truncate text-xs font-medium leading-tight ${clickable ? "group-hover/cast:text-accent" : ""}`}
-                title={c.name}
-              >
-                {c.name}
-              </div>
-              {c.role && (
-                <div className="truncate text-2xs text-muted" title={c.role}>
-                  {c.role}
+      <CastRow cast={cast} onFilter={onFilter} onOpenPerson={onOpenPerson} />
+    </section>
+  );
+}
+
+// The ONE cast carousel: a show's page (CastStrip) and a title's info (PlexInfo, page or the
+// player's overlay) each frame it with their own heading. Two hand copies of it had drifted apart
+// (gap, lazy pictures, the name's tooltip — E32 S2). `tone="overlay"` is the white-on-art palette.
+export function CastRow({
+  cast,
+  tone = "panel",
+  onFilter,
+  onOpenPerson,
+}: {
+  cast: PlexCastMember[];
+  tone?: "panel" | "overlay";
+  onFilter?: (patch: Partial<PlexFilters>) => void;
+  onOpenPerson?: (name: string) => void;
+}) {
+  const { t } = useTranslation();
+  const clickable = !!(onOpenPerson || onFilter);
+  const overlay = tone === "overlay";
+  return (
+    <Carousel gap="gap-4" ariaLabel={t("plex.info.cast")} keyboardNav={clickable}>
+      {cast.map((c, i) => {
+        const inner = (
+          <>
+            <div
+              className={`mx-auto h-20 w-20 overflow-hidden rounded-full border ${
+                overlay ? "border-white/15 bg-white/10" : "border-border bg-surface"
+              } ${clickable ? "group-hover/cast:border-accent" : ""}`}
+            >
+              {c.thumb ? (
+                <img src={c.thumb} alt="" loading="lazy" className="h-full w-full object-cover" />
+              ) : (
+                <div
+                  className={`grid h-full w-full place-items-center text-lg opacity-40 ${overlay ? "text-white" : ""}`}
+                >
+                  {c.name.charAt(0)}
                 </div>
               )}
-            </>
-          );
-          return clickable ? (
-            <Pressable
-              selectable
-              key={i}
-              align="center"
-              {...navItemAttrs(i)}
-              onClick={() =>
-                onOpenPerson ? onOpenPerson(c.name) : onFilter?.({ actors: [c.name] })
-              }
-              title={
-                onOpenPerson
-                  ? t("plex.info.viewPerson", { name: c.name })
-                  : t("plex.info.filterActor", { name: c.name })
-              }
-              className="group/cast w-20 shrink-0"
-            >
-              {inner}
-            </Pressable>
-          ) : (
-            <div key={i} className="w-20 shrink-0 text-center">
-              {inner}
             </div>
-          );
-        })}
-      </Carousel>
-    </section>
+            {/* Name + role are each capped to ONE line (truncate → ellipsis) so every tile has the
+                same text height and the row of circles sits on one baseline regardless of name length. */}
+            <div
+              className={`mt-1.5 truncate text-xs font-medium leading-tight ${overlay ? "text-white/90" : ""} ${
+                clickable ? "group-hover/cast:text-accent" : ""
+              }`}
+              title={c.name}
+            >
+              {c.name}
+            </div>
+            {c.role && (
+              <div
+                className={`truncate text-2xs ${overlay ? "text-white/55" : "text-muted"}`}
+                title={c.role}
+              >
+                {c.role}
+              </div>
+            )}
+          </>
+        );
+        return clickable ? (
+          <Pressable
+            selectable
+            key={i}
+            align="center"
+            {...navItemAttrs(i)}
+            onClick={() => (onOpenPerson ? onOpenPerson(c.name) : onFilter?.({ actors: [c.name] }))}
+            title={
+              onOpenPerson
+                ? t("plex.info.viewPerson", { name: c.name })
+                : t("plex.info.filterActor", { name: c.name })
+            }
+            className="group/cast w-20 shrink-0"
+          >
+            {inner}
+          </Pressable>
+        ) : (
+          <div key={i} className="w-20 shrink-0 text-center">
+            {inner}
+          </div>
+        );
+      })}
+    </Carousel>
   );
 }
 
diff --git a/frontend/src/components/plexDetailAside.tsx b/frontend/src/components/plexDetailAside.tsx
index 3c312a76..0696bae9 100644
--- a/frontend/src/components/plexDetailAside.tsx
+++ b/frontend/src/components/plexDetailAside.tsx
@@ -184,6 +184,7 @@ export function DetailKeywords({
 // The crew shows its first CREW_SHOWN names and a "Show N more" that opens the rest: the column beside the
 // text is the hero's tallest part, and twelve names ran it ~170px past the text (E31, the owner's call).
 // A list only a little longer than that shows whole: a toggle that hides one or two names saves no room.
+/** @internal exported for PlexInfo.dom.test.tsx */
 export const CREW_SHOWN = 6;
 const CREW_FOLD_OVER = CREW_SHOWN + 2;
 
diff --git a/frontend/src/components/plexViews.tsx b/frontend/src/components/plexViews.tsx
index 14542f66..08c3e606 100644
--- a/frontend/src/components/plexViews.tsx
+++ b/frontend/src/components/plexViews.tsx
@@ -225,7 +225,9 @@ export function PlexPersonView({
     menuOpen: menu.open && menu.target === c,
   });
 
-  const section = (titleKey: string, cards: PlexCard[]) =>
+  // Not `section`: a local named like the <section> it renders confused the React Compiler's scope
+  // analysis ("[hoisting] expected identifier to be defined") and it skipped the component.
+  const renderSection = (titleKey: string, cards: PlexCard[]) =>
     cards.length > 0 ? (
       <section className="mb-5">
         <h2 className="text-sm font-semibold mb-3">{t(titleKey, { count: cards.length })}</h2>
@@ -385,8 +387,8 @@ export function PlexPersonView({
             <p className="text-sm text-muted">{t("plex.person.empty")}</p>
           ) : (
             <>
-              {section("plex.person.movies", d.movies)}
-              {section("plex.person.shows", d.shows)}
+              {renderSection("plex.person.movies", d.movies)}
+              {renderSection("plex.person.shows", d.shows)}
             </>
           )}
         </div>
@@ -468,9 +470,8 @@ export function PlexShowView({
       await api.plexShowState(showId, w);
     } catch (e) {
       notifyActionError(e, t("plex.watchedFailed"));
-    } finally {
-      setBusy(false);
     }
+    setBusy(false);
     qc.invalidateQueries({ queryKey: qk.plexShow(showId) });
     qc.invalidateQueries({ queryKey: qk.plexLibrary() });
   }
@@ -801,15 +802,15 @@ export function PlexSeasonView({
       await api.plexSeasonState(seasonId, w);
     } catch (e) {
       notifyActionError(e, t("plex.watchedFailed"));
-    } finally {
-      setBusy(false);
     }
+    setBusy(false);
     qc.invalidateQueries({ queryKey: qk.plexShow(showId) });
     qc.invalidateQueries({ queryKey: qk.plexLibrary() });
   }
   async function markEpisode(ep: PlexCard) {
+    const next = ep.status === "watched" ? "new" : "watched";
     try {
-      await api.plexSetState(ep.id, ep.status === "watched" ? "new" : "watched");
+      await api.plexSetState(ep.id, next);
     } catch (e) {
       notifyActionError(e, t("plex.watchedFailed"));
     }
diff --git a/frontend/src/components/tagChipNames.dom.test.tsx b/frontend/src/components/tagChipNames.dom.test.tsx
new file mode 100644
index 00000000..b6aa34fa
--- /dev/null
+++ b/frontend/src/components/tagChipNames.dom.test.tsx
@@ -0,0 +1,52 @@
+// @vitest-environment jsdom
+//
+// A saved view or the stored feed filter can outlive its tag. The feed then matches nothing (E32 S2),
+// so the chip must say the tag is gone, not read as a bare id; while the tag list loads it is a
+// placeholder, and if the list fails it falls back to the id rather than claiming "deleted".
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { cleanup, renderHook, waitFor } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { createElement, type ReactNode } from "react";
+import { api, type FeedFilters, type Tag } from "../lib/api";
+import { clearedFilters, useActiveFilters } from "../lib/useActiveFilters";
+
+vi.mock("react-i18next", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("react-i18next")>();
+  return {
+    ...actual,
+    useTranslation: () => ({ t: (key: string) => key, i18n: { language: "en" } }),
+  };
+});
+
+const filters: FeedFilters = { ...clearedFilters({ q: "" } as FeedFilters), tags: [1, 99] };
+let qc: QueryClient;
+const wrapper = ({ children }: { children: ReactNode }) =>
+  createElement(QueryClientProvider, { client: qc }, children);
+const chips = () => renderHook(() => useActiveFilters(filters, () => {}), { wrapper }).result;
+
+beforeEach(() => {
+  qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+});
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+describe("a tag filter's chip names", () => {
+  it("name a live tag, and say a deleted one is gone", async () => {
+    vi.spyOn(api, "tags").mockResolvedValue([{ id: 1, name: "Music", category: "topic" }] as Tag[]);
+    const result = chips();
+    const chip = (id: number) => result.current.find((f) => f.key === `tag:${id}`)!;
+    expect(chip(99).pending).toBe(true);
+    await waitFor(() => expect(chip(1)).toMatchObject({ label: "Music", pending: false }));
+    expect(chip(99)).toMatchObject({ label: "common.deletedTag", pending: false });
+  });
+
+  it("fall back to the id when the tag list fails, never claiming the tag was deleted", async () => {
+    vi.spyOn(api, "tags").mockRejectedValue(new Error("down"));
+    const result = chips();
+    const chip = (id: number) => result.current.find((f) => f.key === `tag:${id}`)!;
+    await waitFor(() => expect(chip(99).pending).toBe(false));
+    expect(chip(99).label).toBe("99");
+  });
+});
diff --git a/frontend/src/components/ui/ActionMenu.tsx b/frontend/src/components/ui/ActionMenu.tsx
index 72dda344..12b4d3e5 100644
--- a/frontend/src/components/ui/ActionMenu.tsx
+++ b/frontend/src/components/ui/ActionMenu.tsx
@@ -164,10 +164,11 @@ function SubMenu({ item, onClose }: { item: SubmenuItem; onClose: () => void })
     // running off the bottom at 768px.
     fitHeight: true,
   });
+  const { setReference } = pop.refs;
   return (
     <>
       <PopoverItem
-        elementRef={pop.refs.setReference}
+        elementRef={setReference}
         {...pop.getReferenceProps()}
         role="menuitem"
         disabled={item.disabled}
@@ -235,12 +236,13 @@ export default function ActionMenu({
   // PopoverItem renders it as a native `disabled` button, which useListNavigation reads and never
   // focuses. No explicit disabledIndices needed. See ActionMenu.dom.test.tsx for the guard.
   const pop = useAnchoredPopover({ open, onOpenChange: setOpen, placement: "bottom-end" });
+  const { setReference } = pop.refs;
   return (
     <>
       {/* A caller-shaped trigger (a labelled pill) is a surface; the default "…" is a glyph. */}
       {className ? (
         <Pressable
-          ref={pop.refs.setReference}
+          ref={setReference}
           {...pop.getReferenceProps()}
           aria-label={ariaLabel}
           title={ariaLabel}
@@ -252,7 +254,7 @@ export default function ActionMenu({
         <IconButton
           variant="glass"
           size="md"
-          ref={pop.refs.setReference}
+          ref={setReference}
           {...pop.getReferenceProps()}
           label={ariaLabel}
         >
diff --git a/frontend/src/components/ui/AnchoredPopover.returnFocus.dom.test.tsx b/frontend/src/components/ui/AnchoredPopover.returnFocus.dom.test.tsx
index b412056a..1ea0ea57 100644
--- a/frontend/src/components/ui/AnchoredPopover.returnFocus.dom.test.tsx
+++ b/frontend/src/components/ui/AnchoredPopover.returnFocus.dom.test.tsx
@@ -27,9 +27,10 @@ afterEach(cleanup);
 
 function Card({ open }: { open: boolean }) {
   const pop = useAnchoredPopover({ open, onOpenChange: () => {}, mode: "hover" });
+  const { setReference } = pop.refs;
   return (
     <>
-      <div tabIndex={-1} data-testid="card" ref={pop.refs.setReference}>
+      <div tabIndex={-1} data-testid="card" ref={setReference}>
         card
       </div>
       <PopoverSurface popover={pop}>
diff --git a/frontend/src/components/ui/AnchoredPopover.tsx b/frontend/src/components/ui/AnchoredPopover.tsx
index 64df5d92..dc64d06e 100644
--- a/frontend/src/components/ui/AnchoredPopover.tsx
+++ b/frontend/src/components/ui/AnchoredPopover.tsx
@@ -43,6 +43,10 @@ import type { useAnchoredPopover } from "./anchoredPopoverHooks";
 // free-text input (the tag creator) must stopPropagation non-Escape keys on that input so ↑/↓ and
 // typeahead act on the text, not the list — see ChannelTags.
 //
+// The trigger takes its ref DESTRUCTURED: `const { setReference } = pop.refs;` then
+// `ref={setReference} {...pop.getReferenceProps()}`. Written `ref={pop.refs.setReference}`, the React
+// Compiler treats the whole `pop` as a ref and skips the component (E32 S3 — 21 call sites did).
+//
 // S? adds a "combobox" mode — the ONE right way to build a typeable combobox (a search/filter input
 // with a listbox of options below), so a hand-rolled floating-ui engine (the old MultiSelectChips /
 // PlexSearchBox pattern) is no longer needed. It differs from menu/listbox in exactly the focus model:
@@ -231,7 +235,7 @@ interface PopoverSurfaceProps {
    *  take its name from. */
   ariaLabel?: string;
   focusManaged?: boolean;
-  initialFocus?: number | React.MutableRefObject<HTMLElement | null>;
+  initialFocus?: number | React.RefObject<HTMLElement | null>;
   /** The surface never receives pointer events — for a passive caption that must not swallow a click
    *  aimed at whatever it happens to cover during its close delay. Interactive hover cards (scrollable
    *  content, links) must NOT set this. */
@@ -294,6 +298,7 @@ function PopoverSurfaceInner({
     elementsRef,
     labelsRef,
   } = popover;
+  const { setFloating } = refs;
 
   // A node portaled to <body> is painted UNDERNEATH whatever holds the fullscreen lock, so a popover
   // opened from a player's control bar in fullscreen would be invisible; it must portal INTO the
@@ -369,7 +374,7 @@ function PopoverSurfaceInner({
 
   const surface = (
     <div
-      ref={refs.setFloating}
+      ref={setFloating}
       {...floatingProps}
       aria-label={listProps ? undefined : ariaLabel}
       className={zClass}
diff --git a/frontend/src/components/ui/Carousel.tsx b/frontend/src/components/ui/Carousel.tsx
index c8bcd30c..d638ccc2 100644
--- a/frontend/src/components/ui/Carousel.tsx
+++ b/frontend/src/components/ui/Carousel.tsx
@@ -6,6 +6,7 @@ import { useScrollEdges } from "../../lib/useScrollEdges";
 import { useListNav } from "../../lib/listNav";
 import { Button } from "./Button";
 import { IconButton } from "./IconButton";
+import { REDUCED_MOTION } from "../../lib/useMediaQuery";
 
 // Shared horizontal rail — the one place the app's "row of cards you scroll sideways" lives, replacing
 // the hand-rolled `flex gap overflow-x-auto` strips (Cast / Related / collections) and the future
@@ -19,7 +20,7 @@ function scrollBehavior(): ScrollBehavior {
   const reduce =
     typeof window !== "undefined" &&
     typeof window.matchMedia === "function" &&
-    window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+    window.matchMedia(REDUCED_MOTION).matches;
   return reduce ? "auto" : "smooth";
 }
 
diff --git a/frontend/src/components/ui/Combobox.dom.test.tsx b/frontend/src/components/ui/Combobox.dom.test.tsx
index 69ad4d2d..34d208a6 100644
--- a/frontend/src/components/ui/Combobox.dom.test.tsx
+++ b/frontend/src/components/ui/Combobox.dom.test.tsx
@@ -206,6 +206,30 @@ describe("Combobox", () => {
     expect(onChange).toHaveBeenCalledWith(["id1"]); // single-select replaces
   });
 
+  it("names a chip by a label that arrives with later options, in that same render", () => {
+    // E32 S3: the label cache was a ref an effect filled AFTER the render that needed it, and nothing
+    // re-rendered afterwards — the chip kept showing the raw id until something unrelated did.
+    const view = (options: { value: string; label?: string }[]) => (
+      <FloatingTree>
+        <Combobox
+          label="Collection"
+          clientFilter={false}
+          options={options}
+          selected={["id1"]}
+          onChange={vi.fn()}
+        />
+      </FloatingTree>
+    );
+    const { rerender } = render(view([]));
+    expect(screen.getByText("id1")).toBeTruthy();
+    rerender(view([{ value: "id1", label: "Harry Potter" }]));
+    expect(screen.queryByText("id1")).toBeNull();
+    expect(screen.getByText("Harry Potter")).toBeTruthy();
+    // …and it outlives the option: a narrower list later still names the chip.
+    rerender(view([]));
+    expect(screen.getByText("Harry Potter")).toBeTruthy();
+  });
+
   it("single-select: picking replaces the value and closes the list", () => {
     const onChange = vi.fn();
     wrap(
diff --git a/frontend/src/components/ui/Combobox.tsx b/frontend/src/components/ui/Combobox.tsx
index a7a16ef1..a6ce688e 100644
--- a/frontend/src/components/ui/Combobox.tsx
+++ b/frontend/src/components/ui/Combobox.tsx
@@ -1,5 +1,5 @@
 import clsx from "clsx";
-import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
+import { useCallback, useMemo, useState, type ReactNode } from "react";
 import { useTranslation } from "react-i18next";
 import { ChevronDown } from "lucide-react";
 import { Button } from "./Button";
@@ -11,6 +11,7 @@ import { InnerInput } from "./Input";
 import { DismissibleChip } from "./Chip";
 import { fieldClass } from "./fieldStyles";
 import { SURFACE } from "./surfaces";
+import { ChipLabelPending } from "./Skeleton";
 
 // The universal combobox: a react-select / Overseerr-style "combi input" — selected values are
 // removable chips that live INSIDE a text field you type into, and a checklist of options opens below.
@@ -72,6 +73,26 @@ export interface ComboboxProps {
   /** Chip/label text for a selected value whose option is not in the current (e.g. server-narrowed)
    *  list — the collection picker passes the stored title here so a reloaded filter still names itself. */
   selectedLabels?: Record<string, string>;
+  /** The labels are still on their way: a selected value with none yet draws a placeholder chip
+   *  instead of its raw value (a channel filter's UC… id after a reload). */
+  labelsPending?: boolean;
+}
+
+/** Remember each value's display label as options flow through, so a selected chip can name itself
+ *  even after the option leaves the query-narrowed list (async single-select). State, merged DURING
+ *  render: a ref written in an effect was read by the render before it, so a chip could name itself
+ *  by its raw value until something else re-rendered (E32). */
+function useLabelCache(options: readonly ComboboxOption[]): Record<string, string> {
+  const [labelCache, setLabelCache] = useState<Record<string, string>>({});
+  const newLabels = options.filter(
+    (o): o is typeof o & { label: string } => o.label != null && labelCache[o.value] !== o.label,
+  );
+  if (newLabels.length)
+    setLabelCache((c) => ({
+      ...c,
+      ...Object.fromEntries(newLabels.map((o) => [o.value, o.label])),
+    }));
+  return labelCache;
 }
 
 export default function Combobox({
@@ -93,6 +114,7 @@ export default function Combobox({
   maxVisible = 50,
   renderOption,
   selectedLabels,
+  labelsPending = false,
 }: ComboboxProps) {
   const { t } = useTranslation();
   const [open, setOpen] = useState(false);
@@ -103,17 +125,16 @@ export default function Combobox({
     if (queryProp === undefined) setQueryState(q);
     onQueryChange?.(q);
   };
-  const inputRef = useRef<HTMLInputElement | null>(null);
-  const fade = useScrollFade();
+  // The input node as STATE, not a ref: the handlers below are handed to getReferenceProps during
+  // render, and a ref inside them made the React Compiler skip the whole component (E32).
+  const [inputEl, setInputEl] = useState<HTMLInputElement | null>(null);
+  const { ref: fadeRef, style: fadeStyle } = useScrollFade();
 
-  // Remember each value's display label as options flow through, so a selected chip can name itself
-  // even after the option leaves the query-narrowed list (async single-select). Caller-supplied
-  // `selectedLabels` win (they survive a page reload where nothing has been fetched yet).
-  const labelCache = useRef<Record<string, string>>({});
-  useEffect(() => {
-    for (const o of options) if (o.label != null) labelCache.current[o.value] = o.label;
-  }, [options]);
-  const labelFor = (v: string) => selectedLabels?.[v] ?? labelCache.current[v] ?? v;
+  // Caller-supplied `selectedLabels` win over the cache (they survive a page reload where nothing
+  // has been fetched yet).
+  const labelCache = useLabelCache(options);
+  const knownLabel = (v: string) => selectedLabels?.[v] ?? labelCache[v];
+  const labelFor = (v: string) => knownLabel(v) ?? v;
 
   const setOpenAnd = (next: boolean) => {
     if (next && disabled) return;
@@ -128,18 +149,19 @@ export default function Combobox({
     if (!next) setQuery("");
   };
   const pop = useAnchoredPopover({ open, onOpenChange: setOpenAnd, mode: "combobox" });
+  const { setReference, setPositionReference } = pop.refs;
   // The input is the combobox reference for floating-ui AND our own focus target (the field's
   // click-to-focus handler, and commit() re-focusing after a pick). A merged callback ref feeds the
-  // node to BOTH — without it `inputRef` stays null, so the field's onMouseDown guard (`e.target !==
-  // inputRef.current`) is always true and preventDefault() cancels the input's own click-focus, making
+  // node to BOTH — without it the node stays null, so the field's onMouseDown guard (`e.target !==
+  // inputEl`) is always true and preventDefault() cancels the input's own click-focus, making
   // the field impossible to type into with the mouse. Memoised so floating-ui's ref isn't re-attached
   // every render.
   const setInputRef = useCallback(
     (node: HTMLInputElement | null) => {
-      pop.refs.setReference(node);
-      inputRef.current = node;
+      setReference(node);
+      setInputEl(node);
     },
-    [pop.refs],
+    [setReference],
   );
   // `highlightIndex` = the row the user actually SEES highlighted (pointer hover, else keyboard); Enter
   // commits THAT, not the bare keyboard `activeIndex` — otherwise arrow-then-hover-then-Enter would toggle
@@ -167,7 +189,7 @@ export default function Combobox({
         selected.includes(value) ? selected.filter((x) => x !== value) : [...selected, value],
       );
       // Keep the field focused so the user can keep picking / typing; the list stays open.
-      inputRef.current?.focus();
+      inputEl?.focus();
     } else {
       // Single-select is final: close and DON'T re-focus — a refocus fires onFocus, which would
       // immediately re-open the list (now that the merged ref makes focus() actually work).
@@ -181,7 +203,7 @@ export default function Combobox({
       {/* The field: removable chips + a free-text input + a chevron, styled as one input box. The whole
           box is the POSITION anchor (the panel matches its width); the input is the combobox reference. */}
       <div
-        ref={pop.refs.setPositionReference}
+        ref={setPositionReference}
         onMouseDown={(e) => {
           // A press anywhere but the input (padding / a chip gap) focuses the field and opens the list —
           // focus drives "open", so a caret click never toggles it shut. A press on a chip's × is its
@@ -191,9 +213,9 @@ export default function Combobox({
             e.preventDefault();
             return;
           }
-          if (e.target !== inputRef.current) {
+          if (e.target !== inputEl) {
             e.preventDefault();
-            inputRef.current?.focus();
+            inputEl?.focus();
             setOpenAnd(true);
           }
         }}
@@ -210,7 +232,11 @@ export default function Combobox({
             onDismiss={() => !disabled && onChange(selected.filter((x) => x !== v))}
             dismissLabel={t("common.removeNamed", { name: labelFor(v) })}
           >
-            {labelFor(v)}
+            {labelsPending && knownLabel(v) === undefined ? (
+              <ChipLabelPending value={v} />
+            ) : (
+              labelFor(v)
+            )}
           </DismissibleChip>
         ))}
         <InnerInput
@@ -267,7 +293,7 @@ export default function Combobox({
         className={`${SURFACE.menu} w-full animate-[popIn_0.16s_ease]`}
       >
         {/* The scroll box owns the height cap AND the scroll-fade mask (ref+style on the same element). */}
-        <div ref={fade.ref} style={fade.style} className="max-h-64 overflow-y-auto no-scrollbar">
+        <div ref={fadeRef} style={fadeStyle} className="max-h-64 overflow-y-auto no-scrollbar">
           {/* The listbox holds the options alone; the lines about the list sit beside it (F4). */}
           <PopoverList>
             {!showError &&
diff --git a/frontend/src/components/ui/CommandPalette.tsx b/frontend/src/components/ui/CommandPalette.tsx
index 2cdee2fc..05adc686 100644
--- a/frontend/src/components/ui/CommandPalette.tsx
+++ b/frontend/src/components/ui/CommandPalette.tsx
@@ -19,7 +19,7 @@ import { fieldClass } from "./fieldStyles";
 // and playlists. On the shell it reuses `Modal` in its `top` placement — same layer stack, Escape,
 // focus restore and Back-to-close as every other dialog.
 
-export interface CommandItem {
+interface CommandItem {
   /** Unique across the whole palette; also the React key. */
   id: string;
   label: string;
diff --git a/frontend/src/components/ui/DataTable.tsx b/frontend/src/components/ui/DataTable.tsx
index 7a2eab8c..b65f8b19 100644
--- a/frontend/src/components/ui/DataTable.tsx
+++ b/frontend/src/components/ui/DataTable.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState, type ReactNode } from "react";
+import { useEffect, useEffectEvent, useRef, useState, type ReactNode } from "react";
 import { useTranslation } from "react-i18next";
 import { sortRows, cycleSort, type SortState } from "../../lib/columnSort";
 import Pager from "./Pager";
@@ -201,24 +201,23 @@ export default function DataTable<T>({
   useListNav(bodyRef, { enabled: keyboardNav && wide });
   useListNav(cardsRef, { enabled: keyboardNav && !wide });
 
-  // Commit a whole new filter map through the owner (controlled) or internal state. A ref holds the
-  // latest resolved map so the externalFilter/reset effects can derive from it without taking
-  // `filters` as a dep (which would re-run them on every filter change).
-  const filtersRef = useRef(filters);
-  filtersRef.current = filters;
-  // …and the same trick for the CALLBACK, one line further: a controlled caller almost always
-  // passes an inline arrow, so `onFiltersChange` is a fresh function on every render. Reading it
-  // through a ref is what lets `commitFilters` be stable, and a stable commitFilters is what lets
-  // the two effects below NAME it in their dep lists instead of switching the check off.
-  const onFiltersChangeRef = useRef(onFiltersChange);
-  onFiltersChangeRef.current = onFiltersChange;
-  const commitFilters = useCallback(
-    (next: FilterMap) => {
-      if (controlledFilters) onFiltersChangeRef.current!(next);
-      else setInternalFilters(next);
-    },
-    [controlledFilters],
-  );
+  // Commit a whole new filter map through the owner (controlled) or internal state.
+  const commitFilters = (next: FilterMap) => {
+    if (controlledFilters) onFiltersChange!(next);
+    else setInternalFilters(next);
+  };
+  // The externalFilter/reset effects below read the latest filters and callback through effect
+  // events, so they re-run only on their own trigger, not on every filter change or on the inline
+  // `onFiltersChange` a controlled caller passes each render. (They used to ride render-written refs,
+  // which made the React Compiler skip this whole component — and with it every row's memo.)
+  const applyExternalFilter = useEffectEvent((key: string, value: string | string[]) => {
+    commitFilters({ ...filters, [key]: value });
+    setPage(0);
+  });
+  const clearFilters = useEffectEvent(() => {
+    commitFilters({});
+    setPage(0);
+  });
 
   // Persist page/size always, but only the sort/filter slices this table actually OWNS — a controlled
   // caller persists those itself, so writing them here would just leave a stale, never-read duplicate.
@@ -242,9 +241,9 @@ export default function DataTable<T>({
   const externalValue = externalFilter?.value;
   useEffect(() => {
     if (externalKey === undefined || externalValue === undefined) return;
-    commitFilters({ ...filtersRef.current, [externalKey]: externalValue });
-    setPage(0);
-  }, [externalKey, externalValue, commitFilters]);
+    // eslint-disable-next-line react-hooks/set-state-in-effect -- a controlled filter commits through the PARENT's setter, which may not run during this table's render; the effect fires once per new external value
+    applyExternalFilter(externalKey, externalValue);
+  }, [externalKey, externalValue]);
 
   // Clear column filters when the reset token advances. The ref starts at 0 (not at the prop)
   // so a navigation that bumped the token still clears even when it remounts this table fresh
@@ -254,9 +253,8 @@ export default function DataTable<T>({
   useEffect(() => {
     if (resetFiltersToken === undefined || resetFiltersToken === resetRef.current) return;
     resetRef.current = resetFiltersToken;
-    commitFilters({});
-    setPage(0);
-  }, [resetFiltersToken, commitFilters]);
+    clearFilters();
+  }, [resetFiltersToken]);
 
   const sorted = sortRows(filterRows(rows, columns, filters), columns, sort, lang);
 
diff --git a/frontend/src/components/ui/FilterSelect.tsx b/frontend/src/components/ui/FilterSelect.tsx
index d310cc06..1765812c 100644
--- a/frontend/src/components/ui/FilterSelect.tsx
+++ b/frontend/src/components/ui/FilterSelect.tsx
@@ -13,6 +13,7 @@ import { SURFACE } from "./surfaces";
 // Built on the same AnchoredPopover platform as ActionMenu/Combobox (arrows/typeahead/Escape/anchor-flip);
 // reusable anywhere a small, known set of options currently renders as a chip group. See FilterSelect.dom.test.
 
+/** @internal exported for FilterSelect.dom.test.tsx */
 export interface FilterSelectOption {
   value: string;
   label: string;
@@ -63,6 +64,7 @@ export default function FilterSelect({
           options.findIndex((o) => o.value === selected[0]),
         ),
   });
+  const { setReference } = pop.refs;
 
   const labelOf = (v: string) => options.find((o) => o.value === v)?.label ?? v;
   // Summarise the trigger value. Multi lists the first chosen (in options order, so it's stable) + "+N".
@@ -95,7 +97,7 @@ export default function FilterSelect({
         context="toolbar"
         open={open}
         label={hideLabel ? undefined : label}
-        ref={pop.refs.setReference}
+        ref={setReference}
         {...pop.getReferenceProps()}
         data-testid={testId}
         // Carry the current value in the accessible name (not just the group label), matching
diff --git a/frontend/src/components/ui/FocusSafeButton.tsx b/frontend/src/components/ui/FocusSafeButton.tsx
index b40099e8..6e22edcc 100644
--- a/frontend/src/components/ui/FocusSafeButton.tsx
+++ b/frontend/src/components/ui/FocusSafeButton.tsx
@@ -1,4 +1,11 @@
-import { forwardRef, useCallback, useRef, useState, type ButtonHTMLAttributes } from "react";
+import {
+  forwardRef,
+  useCallback,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  type ButtonHTMLAttributes,
+} from "react";
 import clsx from "clsx";
 import { endsTextSelection, movedPastSlop } from "../../lib/textSelection";
 
@@ -23,6 +30,8 @@ import { endsTextSelection, movedPastSlop } from "../../lib/textSelection";
 // <button> unless it is `user-select: text`, and then the mouseup that ends the drag still clicks the
 // button (both measured, 2026-09-26), so the flag sets both halves: the text selects, and the click
 // that ends a selection inside the button, or a press dragged past the slop, does nothing.
+const noSubscription = () => () => {};
+
 export const FocusSafeButton = forwardRef<
   HTMLButtonElement,
   ButtonHTMLAttributes<HTMLButtonElement> & {
@@ -58,9 +67,15 @@ export const FocusSafeButton = forwardRef<
   );
   // Focused by the event OR by the document's own answer at render time: when the window itself is
   // not focused (another app in front) `.focus()` moves `activeElement` but fires no focus event
-  // (measured in Chrome), and the button disabled in that state lost the focus all the same.
-  const focused =
-    focusEvent || (!!node.current && node.current.ownerDocument.activeElement === node.current);
+  // (measured in Chrome), and the button disabled in that state lost the focus all the same. Read
+  // through useSyncExternalStore, which React asks on EVERY render, never from a memo: a bare
+  // render-time DOM read made the React Compiler skip the component (E32), and compiled it would be
+  // cached. Nothing to subscribe to — the focus events above already re-render it.
+  const activeNow = useSyncExternalStore(
+    noSubscription,
+    () => node.current !== null && node.current.ownerDocument.activeElement === node.current,
+  );
+  const focused = focusEvent || activeNow;
   const soft = busy || (!!disabled && focused);
   // A caller's own aria-disabled is the "unavailable, and here is why" state (DESIGN.md: the tooltip or
   // label carries the reason, so the button stays focusable): it is kept, never overwritten by ours, and
diff --git a/frontend/src/components/ui/Modal.purpose.dom.test.tsx b/frontend/src/components/ui/Modal.purpose.dom.test.tsx
index 4afb444d..0ec7e197 100644
--- a/frontend/src/components/ui/Modal.purpose.dom.test.tsx
+++ b/frontend/src/components/ui/Modal.purpose.dom.test.tsx
@@ -116,6 +116,28 @@ describe("Modal initial focus by purpose (C4)", () => {
     expect(document.activeElement).toBe(cancel);
   });
 
+  // …and it stays the user's: the form disarms the watch when it arrives, so a later change in the
+  // body (a hint appearing as they type) cannot pull the focus off a ✕ they went back to.
+  it("field that loads late: once arrived, it never takes the focus off the ✕ again", async () => {
+    const view = (ready: boolean, hint = false) => (
+      <Modal initialFocus="field" title="t" onClose={() => {}}>
+        <Late ready={ready} />
+        {hint && <p>hint</p>}
+        <ModalFooter>
+          <button>cancel</button>
+        </ModalFooter>
+      </Modal>
+    );
+    const { rerender } = render(view(false));
+    act(() => screen.getByRole("button", { name: "cancel" }).focus());
+    rerender(view(true));
+    await act(async () => {});
+    act(() => closeBtn().focus());
+    rerender(view(true, true));
+    await act(async () => {});
+    expect(document.activeElement).toBe(closeBtn());
+  });
+
   it("close: the ✕, even with a field in the body", () => {
     render(
       <Modal initialFocus="close" title="t" onClose={() => {}}>
diff --git a/frontend/src/components/ui/Modal.tsx b/frontend/src/components/ui/Modal.tsx
index 31882805..1bf252fb 100644
--- a/frontend/src/components/ui/Modal.tsx
+++ b/frontend/src/components/ui/Modal.tsx
@@ -2,6 +2,7 @@ import {
   createContext,
   useContext,
   useEffect,
+  useEffectEvent,
   useId,
   useRef,
   useState,
@@ -13,16 +14,17 @@ import { X } from "lucide-react";
 import { useBackToClose } from "../../lib/history";
 import { anyBlockingLayerAbove, pushLayer, removeLayer, takeEscape } from "../../lib/layerStack";
 import { useFullscreenPortalHost } from "../../lib/fullscreen";
-import { focusablesIn, trapTab, useDialogChrome } from "./dialogFocus";
+import { firstFieldIn, focusablesIn, trapTab, useDialogChrome } from "./dialogFocus";
 import { IconButton } from "./IconButton";
 import Toaster from "./Toaster";
 import { useOverlayOrder } from "./overlayOrder";
 import { SURFACE } from "./surfaces";
 
-/** Where a dialog opens focused (C4, by purpose — WAI-ARIA APG): `field` = the body's first control
- *  (a form), `close` = the header's ✕ (anything to read or browse), `action` = the child that takes
- *  `autoFocus` itself (a confirm's least destructive button; the ✕ if none does). Required, so every
- *  dialog states its purpose instead of inheriting "the first focusable", which is always the ✕. */
+/** Where a dialog opens focused (C4, by purpose — WAI-ARIA APG): `field` = the body's first control,
+ *  or the one marked `data-initial-focus` (a form), `close` = the header's ✕ (anything to read or
+ *  browse), `action` = the child that takes `autoFocus` itself (a confirm's least destructive button;
+ *  the ✕ if none does). Required, so every dialog states its purpose instead of inheriting "the first
+ *  focusable", which is always the ✕. */
 export type ModalFocus = "field" | "close" | "action";
 
 // The footer slot of the open dialog. `ModalFooter` portals into it from any depth, so a body that
@@ -99,19 +101,35 @@ export default function Modal({
     // Only a rendered target (the trap's own `offsetParent` test); none falls back to the hook's
     // first-focusable rule. `action` lands on the ✕ here and its child's autoFocus then takes over.
     initial: () =>
-      (initialFocus === "field" && bodyRef.current ? focusablesIn(bodyRef.current)[0] : null) ??
+      (initialFocus === "field" && bodyRef.current ? firstFieldIn(bodyRef.current) : null) ??
       (closeRef.current?.offsetParent != null ? closeRef.current : null),
   });
   // A form that loads after the dialog opens (the issue composer shows a spinner first) has no field
-  // to take the focus at open, so it lands on the ✕. When the first control arrives the focus moves
-  // there — but only while it still rests on the ✕: a user who has moved it keeps it where it is.
+  // to take the focus at open, so it lands on the ✕. When the form arrives the focus moves to its
+  // first field — but only while it still rests on the ✕: a user who has moved it keeps it there.
+  // The form takes it ONCE: arrived while the focus was elsewhere, it disarms all the same, or a later
+  // mutation would pull the focus off a ✕ the user went back to (E32 review round 2). The watch
+  // re-arms only when the focus is taken away, not moved: the body has no control again, or the
+  // focused one went (a failed load's Retry giving way to the spinner, or straight to the form) and
+  // the focus fell to <body>. It then goes to the ✕, and on to the first field as soon as the body
+  // has one — at once, when other controls stayed beside the one that went (E32 review). Only
+  // <body>: focus in a dialog stacked on top is not this one's to take.
   useEffect(() => {
     const body = bodyRef.current;
     if (initialFocus !== "field" || !body || focusablesIn(body).length > 0) return;
+    let armed = true;
     const watch = new MutationObserver(() => {
-      const first = focusablesIn(body)[0];
-      if (!first) return;
-      watch.disconnect();
+      if (document.activeElement === document.body && closeRef.current) {
+        closeRef.current.focus();
+        armed = true;
+      }
+      const first = firstFieldIn(body);
+      if (!first) {
+        armed = true;
+        return;
+      }
+      if (!armed) return;
+      armed = false;
       if (document.activeElement === closeRef.current) first.focus();
     });
     watch.observe(body, { childList: true, subtree: true });
@@ -124,15 +142,14 @@ export default function Modal({
   // the backdrop wrongly dismisses — the click event bubbles to the common ancestor (the backdrop).
   const pressedOnBackdrop = useRef(false);
 
-  // Keep a stable handler across renders so the stack id is assigned once per mount.
-  const onCloseRef = useRef(onClose);
-  onCloseRef.current = onClose;
+  // An effect event, so a new handler each render never re-registers: the stack id is assigned once per mount.
+  const close = useEffectEvent(onClose);
   useEffect(() => {
     const id = pushLayer();
     const onKey = (e: KeyboardEvent) => {
       if (takeEscape(e, id)) {
         e.stopPropagation();
-        onCloseRef.current();
+        close();
         return;
       }
       // Focus trap: keep Tab / Shift+Tab cycling inside the dialog instead of reaching the inert
diff --git a/frontend/src/components/ui/NavRail.tsx b/frontend/src/components/ui/NavRail.tsx
index 17446264..d9c1dd2e 100644
--- a/frontend/src/components/ui/NavRail.tsx
+++ b/frontend/src/components/ui/NavRail.tsx
@@ -216,12 +216,13 @@ export function NavRailGroup({
     placement: "right-start",
     offset: 8,
   });
+  const { setReference } = pop.refs;
   const active = pages.some((p) => p.active);
   return (
     <>
       <Tooltip hint={label} side="right" always openDelay={350}>
         <Pressable
-          ref={pop.refs.setReference}
+          ref={setReference}
           {...pop.getReferenceProps()}
           data-testid={testId}
           aria-label={showLabel ? shortLabel : label}
diff --git a/frontend/src/components/ui/PageScroller.tsx b/frontend/src/components/ui/PageScroller.tsx
index a4813094..0a4584b0 100644
--- a/frontend/src/components/ui/PageScroller.tsx
+++ b/frontend/src/components/ui/PageScroller.tsx
@@ -1,4 +1,11 @@
-import { useCallback, useLayoutEffect, useRef, useState, type ReactNode } from "react";
+import {
+  useCallback,
+  useEffectEvent,
+  useLayoutEffect,
+  useRef,
+  useState,
+  type ReactNode,
+} from "react";
 import { useScrollFade } from "../../lib/useScrollFade";
 import { FOCUS_REST_ATTRS, useFocusKeeper } from "../../lib/useFocusKeeper";
 import { StickyTopProvider } from "./stickyTop";
@@ -130,12 +137,11 @@ export default function PageScroller({
     setStickyTops((n) => n + 1);
     return () => setStickyTops((n) => n - 1);
   }, []);
-  const fade = useScrollFade(20, stickyTops === 0);
+  const { ref: fadeRef, style: fadeStyle } = useScrollFade(20, stickyTops === 0);
   const fabUp = useBackToTopShown();
-  const fadeRef = fade.ref;
   const elRef = useRef<HTMLElement | null>(null);
   // Stable identity: an inline ref callback changes every render, which makes React detach and
-  // re-attach the ref each commit — and since fade.ref is a state setter, that re-attach loops it
+  // re-attach the ref each commit — and since fadeRef is a state setter, that re-attach loops it
   // into "Maximum update depth exceeded". useScrollFade's ref setter is itself stable, so binding
   // once here is safe.
   const setRef = useCallback(
@@ -150,29 +156,31 @@ export default function PageScroller({
   // all) leaves the focus in its slot rather than on <body> — see useFocusKeeper.
   useFocusKeeper(elRef);
 
-  // Live scrollKey for the event/nav-bus callbacks (which are bound once, not per scrollKey).
-  const scrollKeyRef = useRef(scrollKey);
-  scrollKeyRef.current = scrollKey;
   const lastComposite = useRef<string | null>(null);
   const cancelRef = useRef<() => void>(() => {});
 
   // Restore (or reset to top) whenever the (history entry + content) identity changes — a page/sub-view
   // navigation, a Back/Forward, or a feed filter change. Idempotent: a no-op when the composite is
-  // unchanged, so it's safe to call from several triggers.
-  const resolve = useCallback(() => {
+  // unchanged, so it's safe to call from several triggers. An effect event: the listeners below are
+  // bound once, not per scrollKey, and still read the live one.
+  const resolve = useEffectEvent(() => {
     const el = elRef.current;
-    if (!el || scrollKeyRef.current == null) return;
-    const key = `${ensureNavId()}:${scrollKeyRef.current}`;
+    if (!el || scrollKey == null) return;
+    const key = `${ensureNavId()}:${scrollKey}`;
     if (key === lastComposite.current) return;
     lastComposite.current = key;
     cancelRef.current();
     cancelRef.current = restoreScroll(el, savedScroll.get(key) ?? 0);
-  }, []);
+  });
+  const remember = useEffectEvent((el: HTMLElement) => {
+    if (scrollKey == null) return;
+    rememberScroll(`${peekNavId()}:${scrollKey}`, el.scrollTop);
+  });
 
   // Trigger 1: mount + a content-key change (page switch, feed filter) — both re-render this component.
   useLayoutEffect(() => {
     resolve();
-  }, [scrollKey, resolve]);
+  }, [scrollKey]);
 
   // Trigger 2: Back/Forward (popstate) and a Plex sub-view open (nav bus) — neither necessarily
   // re-renders this component. Also records the position continuously (not at unmount): the scroller's
@@ -180,20 +188,18 @@ export default function PageScroller({
   useLayoutEffect(() => {
     const el = elRef.current;
     if (!el) return;
-    const onScroll = () => {
-      if (scrollKeyRef.current == null) return;
-      rememberScroll(`${peekNavId()}:${scrollKeyRef.current}`, el.scrollTop);
-    };
+    const onScroll = () => remember(el);
+    const onNav = () => resolve();
     el.addEventListener("scroll", onScroll, { passive: true });
-    window.addEventListener("popstate", resolve);
-    const unsubNav = subscribeNav(resolve);
+    window.addEventListener("popstate", onNav);
+    const unsubNav = subscribeNav(onNav);
     return () => {
       cancelRef.current();
       el.removeEventListener("scroll", onScroll);
-      window.removeEventListener("popstate", resolve);
+      window.removeEventListener("popstate", onNav);
       unsubNav();
     };
-  }, [resolve]);
+  }, []);
 
   return (
     // `id` + `tabIndex={-1}`: the skip link's target (ui/SkipLink) takes the focus, so the next Tab
@@ -204,7 +210,7 @@ export default function PageScroller({
       id={CONTENT_ID}
       tabIndex={-1}
       {...FOCUS_REST_ATTRS}
-      style={fade.style}
+      style={fadeStyle}
       className="flex-1 min-w-0 overflow-y-auto scrollbar-gutter-stable focus:outline-none"
     >
       <StickyTopProvider value={registerStickyTop}>{children}</StickyTopProvider>
diff --git a/frontend/src/components/ui/PriorityStepper.tsx b/frontend/src/components/ui/PriorityStepper.tsx
index 49de5502..c55cea09 100644
--- a/frontend/src/components/ui/PriorityStepper.tsx
+++ b/frontend/src/components/ui/PriorityStepper.tsx
@@ -121,7 +121,7 @@ export function PriorityStepper({
     onPriority(delta);
   };
 
-  const editFocus = useReturnFocus(editing);
+  const { target: editTarget, arm: armEditReturn } = useReturnFocus(editing);
   const commitEdit = () => {
     const parsed = parseInt(draft, 10);
     if (!Number.isNaN(parsed) && parsed !== priority) onSet(parsed);
@@ -162,7 +162,7 @@ export function PriorityStepper({
           } ${cls.value}`}
         >
           <button
-            ref={editFocus.target}
+            ref={editTarget}
             onClick={beginEdit}
             aria-label={t("common.priority.edit")}
             title={t("common.priority.edit")}
@@ -180,10 +180,10 @@ export function PriorityStepper({
               onBlur={commitEdit}
               onKeyDown={(e) => {
                 if (e.key === "Enter") {
-                  editFocus.arm(e);
+                  armEditReturn(e);
                   commitEdit();
                 } else if (e.key === "Escape") {
-                  editFocus.arm(e);
+                  armEditReturn(e);
                   setEditing(false);
                 }
               }}
diff --git a/frontend/src/components/ui/SidePanel.tsx b/frontend/src/components/ui/SidePanel.tsx
index 726e77b1..6f30301a 100644
--- a/frontend/src/components/ui/SidePanel.tsx
+++ b/frontend/src/components/ui/SidePanel.tsx
@@ -66,7 +66,7 @@ export default function SidePanel({
   const { t } = useTranslation();
   const cardRef = useRef<HTMLElement>(null);
   const tabRef = useRef<HTMLButtonElement>(null);
-  const fade = useScrollFade();
+  const { ref: fadeRef, style: fadeStyle } = useScrollFade();
   const peek = useHoverFocusWithin();
   const drawerMode = useMediaQuery(DRAWER_QUERY, false);
   const pinRoom = useMediaQuery(PIN_ROOM_QUERY, true);
@@ -234,8 +234,8 @@ export default function SidePanel({
           )}
 
           <div
-            ref={fade.ref}
-            style={fade.style}
+            ref={fadeRef}
+            style={fadeStyle}
             className="flex-1 min-h-0 overflow-y-auto no-scrollbar"
           >
             <div className="p-3 space-y-3">{body}</div>
diff --git a/frontend/src/components/ui/Skeleton.tsx b/frontend/src/components/ui/Skeleton.tsx
index 2919db0e..5c1576ff 100644
--- a/frontend/src/components/ui/Skeleton.tsx
+++ b/frontend/src/components/ui/Skeleton.tsx
@@ -7,15 +7,32 @@ import { SURFACE } from "./surfaces";
 // paragraph's, for prose that arrives after its page). The
 // shapes are shown through `LoadingState shape=…`, which owns the 300 ms reveal and the status role.
 
-export function Skeleton({ className }: { className?: string }) {
+function Skeleton({ className, inline = false }: { className?: string; inline?: boolean }) {
+  // Inline: a span, for a bone inside phrasing content (a chip is a button, which may not hold a div).
+  const Tag = inline ? "span" : "div";
   return (
-    <div
+    <Tag
       aria-hidden="true"
-      className={clsx("rounded-lg bg-fg/8 animate-pulse motion-reduce:animate-none", className)}
+      className={clsx(
+        "rounded-lg bg-fg/8 animate-pulse motion-reduce:animate-none",
+        inline && "inline-block align-middle",
+        className,
+      )}
     />
   );
 }
 
+/** A chip whose name is still on its way: a name-sized bone, not the raw value (a channel's UC… id).
+ *  A screen reader still gets the value, so two such chips stay told apart. */
+export function ChipLabelPending({ value }: { value: string }) {
+  return (
+    <>
+      <Skeleton inline className="h-3 w-20" />
+      <span className="sr-only">{value}</span>
+    </>
+  );
+}
+
 export type SkeletonShape = "grid" | "poster" | "list" | "table" | "text";
 
 const COUNT: Record<SkeletonShape, number> = { grid: 8, poster: 12, list: 6, table: 8, text: 5 };
diff --git a/frontend/src/components/ui/SortControl.tsx b/frontend/src/components/ui/SortControl.tsx
index 92836d41..7a842533 100644
--- a/frontend/src/components/ui/SortControl.tsx
+++ b/frontend/src/components/ui/SortControl.tsx
@@ -48,6 +48,7 @@ export default function SortControl({
     mode: "menu",
     placement: "bottom-end",
   });
+  const { setReference } = pop.refs;
 
   // A stored sort can name an option this surface no longer offers; show it as unsorted rather than
   // letting an arrow claim a sort that `sortRows`/the server won't actually apply.
@@ -71,7 +72,7 @@ export default function SortControl({
         context="toolbar"
         open={open}
         label={label}
-        ref={pop.refs.setReference}
+        ref={setReference}
         {...pop.getReferenceProps()}
         // Carry the active sort key AND direction in the accessible name (the visible arrow is
         // aria-hidden), matching ViewSwitcher — a screen reader announces "Sort: Date, Descending",
diff --git a/frontend/src/components/ui/Toaster.dom.test.tsx b/frontend/src/components/ui/Toaster.dom.test.tsx
index e5fab134..b42508ea 100644
--- a/frontend/src/components/ui/Toaster.dom.test.tsx
+++ b/frontend/src/components/ui/Toaster.dom.test.tsx
@@ -94,6 +94,18 @@ describe("Toaster — handing the toasts to another host", () => {
     expect(screen.getByText("fresh").closest(".toast-card")!.getAttribute("role")).toBe("alert");
   });
 
+  it("takes the inherited set ONCE, at the takeover: a toast of its own stays an alert", () => {
+    // E32: the handover is a snapshot made when the host becomes top, not a read of what the top
+    // host last showed — re-read on every render, this host's own "first" turned silent the moment
+    // "second" arrived (its own screen had become the handover by then).
+    render(<Toaster />);
+    act(() => void notify({ level: "error", message: "first" }));
+    act(() => void notify({ level: "error", message: "second" }));
+    const card = (text: string) => screen.getByText(text).closest(".toast-card")!;
+    expect(card("first").getAttribute("role")).toBe("alert");
+    expect(card("second").getAttribute("role")).toBe("alert");
+  });
+
   it("keeps its live region off while the inherited toasts go in, and arms it a task later", async () => {
     // The other half of "silently": a region that is already polite when the inherited nodes are
     // inserted announces them anyway. React flushes effects in the SAME task as that render, so the
diff --git a/frontend/src/components/ui/Toaster.tsx b/frontend/src/components/ui/Toaster.tsx
index 1b8b3066..bcd8a8e4 100644
--- a/frontend/src/components/ui/Toaster.tsx
+++ b/frontend/src/components/ui/Toaster.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useId, useRef, useState, useSyncExternalStore } from "react";
+import { useEffect, useId, useLayoutEffect, useState, useSyncExternalStore } from "react";
 import { useTranslation } from "react-i18next";
 import { X } from "lucide-react";
 import { dismiss, getActiveToasts, subscribe } from "../../lib/notifications";
@@ -70,30 +70,29 @@ export default function Toaster({
   // the takeover render. Reading the store live also silenced a toast RAISED in the same commit as
   // the takeover: a dialog that notifies and closes in one handler (UploadDialog) put its success
   // toast up in the very batch that handed the app host the top spot, so it was classified as
-  // inherited and announced by neither path (deep-review round 5). Written during render on purpose
-  // — the handover must be readable by the taking-over host in the SAME commit, and an effect
-  // cleanup runs one phase too late; only the host that IS top writes, so the value is the losing
-  // host's last screen either way.
+  // inherited and announced by neither path (deep-review round 5). The top host records its screen
+  // after each commit (the layout effect below); a host taking over reads it in a LATER render, after
+  // that commit, so it always sees the outgoing host's last committed screen. (It was written during
+  // render, which made the React Compiler skip the Toaster — E32 — and let a discarded render
+  // overwrite it.)
   //
-  // Snapshotted through a ref keyed on `isTop`, not a `useMemo`: React re-invokes a component body
-  // — and every `useMemo` factory in it — on a StrictMode double render and on a restarted one, and
-  // the LAST invocation is what commits. With a memo the second pass re-read `lastTopIds` after the
-  // first pass had already overwritten it on the line below, so the takeover host classified its
-  // OWN new toast as inherited and the dev build behaved exactly like the code this replaced
-  // (measured in jsdom: role "status" without StrictMode, null with it — round 6). The ref only
-  // recomputes when `isTop` actually flips, so a repeated invocation of one render is a no-op.
-  const handover = useRef<{ top: boolean; ids: ReadonlySet<number> }>({
+  // Snapshotted into state when `isTop` flips, adjusted DURING render — not a `useMemo`, which React
+  // may recompute (and the compiler is free to): a recompute while top would re-read this host's OWN
+  // screen and silence its next toast. Under StrictMode the double invocation reads the same,
+  // unchanged global, so both passes agree (the round-6 failure was a render-phase WRITE racing it).
+  const [handover, setHandover] = useState<{ top: boolean; ids: ReadonlySet<number> }>({
     top: false,
     ids: EMPTY_IDS,
   });
-  if (handover.current.top !== isTop)
-    handover.current = { top: isTop, ids: new Set(isTop ? lastTopIds : []) };
-  const inherited = handover.current.ids;
-  // AFTER the snapshot above has read the outgoing host's screen — this host's own first render as
-  // top would otherwise overwrite the handover with the toasts it is about to classify. Writing the
-  // same value twice is harmless; that is the point of the ref.
-  // eslint-disable-next-line react-hooks/globals -- the handover between toast hosts is module-level BY DESIGN and must be written during render — see the 12 lines above, which record why a useMemo produced the wrong answer under StrictMode. The write is idempotent, which is what makes a repeated render invocation safe.
-  if (isTop) lastTopIds = toasts.map((n) => n.id);
+  let inherited = handover.ids;
+  if (handover.top !== isTop) {
+    const next = { top: isTop, ids: new Set(isTop ? lastTopIds : []) };
+    setHandover(next);
+    inherited = next.ids;
+  }
+  useLayoutEffect(() => {
+    if (isTop) lastTopIds = toasts.map((n) => n.id);
+  });
   const [armed, setArmed] = useState(false);
   useEffect(() => {
     if (!isTop) {
@@ -205,7 +204,7 @@ export default function Toaster({
           {/* lib/toastDock is a one-slot registry: this identity changes only when a surface docks
               or undocks, and remounting is then the correct behaviour, not the hazard the rule
               warns about. */}
-          {/* eslint-disable-next-line react-hooks/static-components */}
+          {/* eslint-disable-next-line react-hooks/static-components -- a one-slot dock registry: the identity changes only on dock/undock, where a remount is right */}
           <Docked />
         </div>
       )}
diff --git a/frontend/src/components/ui/Tooltip.tsx b/frontend/src/components/ui/Tooltip.tsx
index 4e3789f0..68408328 100644
--- a/frontend/src/components/ui/Tooltip.tsx
+++ b/frontend/src/components/ui/Tooltip.tsx
@@ -38,12 +38,13 @@ export default function Tooltip({
     // rest-before-show for labels that shouldn't flash on a fast sweep across an icon row.
     hoverDelay: { open: openDelay, close: 0 },
   });
+  const { setReference } = pop.refs;
 
   if (!enabled || !hint) return <>{children}</>;
 
   return (
     <>
-      <span ref={pop.refs.setReference} {...pop.getReferenceProps()} className="inline-flex">
+      <span ref={setReference} {...pop.getReferenceProps()} className="inline-flex">
         {children}
       </span>
       {/* Passive caption: it must not swallow a click aimed at a neighbouring control that it
diff --git a/frontend/src/components/ui/anchoredPopoverHooks.ts b/frontend/src/components/ui/anchoredPopoverHooks.ts
index 909bcae8..eb5e0eef 100644
--- a/frontend/src/components/ui/anchoredPopoverHooks.ts
+++ b/frontend/src/components/ui/anchoredPopoverHooks.ts
@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import {
   useFloating,
   autoUpdate,
@@ -256,12 +256,9 @@ export function useAnchoredPopover(opts: AnchoredPopoverOptions) {
     setActiveIndex(to);
     setHoverIndex(null);
   };
-  const pageKeyRef = useRef(onPageKey);
-  pageKeyRef.current = onPageKey;
-  const paging = useMemo(() => {
-    const onKeyDown = (e: React.KeyboardEvent) => pageKeyRef.current(e);
-    return { reference: { onKeyDown }, floating: { onKeyDown } };
-  }, []);
+  // The compiler memoizes this on what onPageKey reads (the active row), so the prop getters below
+  // change only when that does.
+  const paging = { reference: { onKeyDown: onPageKey }, floating: { onKeyDown: onPageKey } };
 
   const interactions = useInteractions([
     click,
diff --git a/frontend/src/components/ui/backToTopState.ts b/frontend/src/components/ui/backToTopState.ts
index c724dd64..2bfab1bb 100644
--- a/frontend/src/components/ui/backToTopState.ts
+++ b/frontend/src/components/ui/backToTopState.ts
@@ -6,5 +6,5 @@ import { createStore } from "../../lib/store";
 export const backToTopShown = createStore(false);
 
 export function useBackToTopShown(): boolean {
-  return backToTopShown.use();
+  return backToTopShown.useValue();
 }
diff --git a/frontend/src/components/ui/dialogFocus.ts b/frontend/src/components/ui/dialogFocus.ts
index 2fbe6e9c..33a439fb 100644
--- a/frontend/src/components/ui/dialogFocus.ts
+++ b/frontend/src/components/ui/dialogFocus.ts
@@ -16,6 +16,15 @@ const FOCUSABLE =
 export const focusablesIn = (root: HTMLElement): HTMLElement[] =>
   [...root.querySelectorAll<HTMLElement>(FOCUSABLE)].filter((el) => el.offsetParent !== null);
 
+/** A form's first field — where a dialog opened to fill something in takes the focus: its first
+ *  control, unless one is marked `data-initial-focus`. The mark is for a form with a control above
+ *  its fields that is not one of them — the issue composer's Edit / Preview switch took the focus,
+ *  and typing went nowhere (E32 review). */
+export const firstFieldIn = (root: HTMLElement): HTMLElement | undefined => {
+  const all = focusablesIn(root);
+  return all.find((el) => el.hasAttribute("data-initial-focus")) ?? all[0];
+};
+
 /** Keep Tab / Shift+Tab cycling inside `scope` instead of reaching the inert page behind the
  *  backdrop. Call from a keydown handler that has already decided this dialog is the topmost layer —
  *  a nested dialog must defer to its child. `container` is the scope's own tabIndex=-1 panel, if it
diff --git a/frontend/src/components/ui/overlayOrder.ts b/frontend/src/components/ui/overlayOrder.ts
index d04a8df5..28be5f58 100644
--- a/frontend/src/components/ui/overlayOrder.ts
+++ b/frontend/src/components/ui/overlayOrder.ts
@@ -3,9 +3,11 @@ import { useState } from "react";
 // An overlay's toast-host rank (see the overlay-hosts note in Toaster). Its own module so Toaster exports
 // only components (Fast Refresh); the counter is module state, so there is exactly one sequence.
 let overlaySeq = 0;
+// Outside the hook: the React Compiler cannot lower `++` on a module variable inside one (react-hooks/todo).
+const nextOverlaySeq = () => ++overlaySeq;
 /** This overlay's rank among open overlays — taken once, when it mounts. Call it in the overlay
  *  itself, never in a component that can remount while the overlay stays open. */
 export function useOverlayOrder(): number {
-  const [order] = useState(() => ++overlaySeq);
+  const [order] = useState(nextOverlaySeq);
   return order;
 }
diff --git a/frontend/src/components/ui/progressiveRows.ts b/frontend/src/components/ui/progressiveRows.ts
index d420c3bf..d3e39d50 100644
--- a/frontend/src/components/ui/progressiveRows.ts
+++ b/frontend/src/components/ui/progressiveRows.ts
@@ -12,8 +12,9 @@ import { startTransition, useEffect, useState } from "react";
 //
 // Not virtualization: every row still ends up in the DOM, so browser find, keyboard nav past the screen,
 // and the Back focus/scroll restore (which wait for the list to grow) keep working as they did.
+/** @internal exported for DataTable.progressive.dom.test.tsx */
 export const FIRST_ROWS = 30;
-export const STEP_ROWS = 40;
+const STEP_ROWS = 40;
 
 // `view` names what the rows show (page, size, sort, filters). A new view starts over from the first
 // rows, so the urgent render after a click or a key stays small. New data for the same view (a refetch)
diff --git a/frontend/src/components/ui/readAhead.ts b/frontend/src/components/ui/readAhead.ts
index 701adcdc..817eda1d 100644
--- a/frontend/src/components/ui/readAhead.ts
+++ b/frontend/src/components/ui/readAhead.ts
@@ -8,12 +8,16 @@
 //   - ceiling MAX_LOOKAHEAD_ROWS: a tall window renders many rows, and an uncapped lookahead would
 //     eagerly prefetch several pages on every mount / filter change — wasted work on the app's
 //     heaviest query (the feed). The cap bounds that while still buffering a couple of screens ahead.
+/** @internal exported for readAhead.test.ts */
 export const PREFETCH_ROWS = 4;
+/** @internal exported for readAhead.test.ts */
 export const PREFETCH_VIEWPORTS = 2;
+/** @internal exported for readAhead.test.ts */
 export const MAX_LOOKAHEAD_ROWS = 40;
 
 /** How many rows ahead of the last rendered row to keep buffered, for a viewport rendering
  *  `renderedRows` rows. Clamped to [PREFETCH_ROWS, MAX_LOOKAHEAD_ROWS]. */
+/** @internal exported for readAhead.test.ts */
 export function readAheadLookahead(renderedRows: number): number {
   return Math.min(MAX_LOOKAHEAD_ROWS, Math.max(PREFETCH_ROWS, renderedRows * PREFETCH_VIEWPORTS));
 }
diff --git a/frontend/src/components/ui/scrollFold.ts b/frontend/src/components/ui/scrollFold.ts
index 7a0aee54..11e08800 100644
--- a/frontend/src/components/ui/scrollFold.ts
+++ b/frontend/src/components/ui/scrollFold.ts
@@ -10,9 +10,10 @@ import { CONTENT_ID } from "./landmarks";
 //    back (`room - saving > FOLD_AT`): a page barely taller than the window would otherwise fold, lose its
 //    scroll, land at the top, unfold, and so on, with every wheel tick;
 //  - unfold only at the very top, not at the fold point: between the two the header keeps whatever it was.
+/** @internal exported for scrollFold.test.ts */
 export const FOLD_AT = 32;
 
-export interface ScrollPosition {
+interface ScrollPosition {
   // The scroller's scrollTop.
   top: number;
   // How far it can scroll at all: scrollHeight − clientHeight.
@@ -20,6 +21,7 @@ export interface ScrollPosition {
 }
 
 // `saving` = the height the header gives back when it folds (measured while it is unfolded).
+/** @internal exported for scrollFold.test.ts */
 export function nextFolded(
   folded: boolean,
   { top, room }: ScrollPosition,
diff --git a/frontend/src/components/ui/sortableA11y.ts b/frontend/src/components/ui/sortableA11y.ts
index 3c4dd5bc..33077ae2 100644
--- a/frontend/src/components/ui/sortableA11y.ts
+++ b/frontend/src/components/ui/sortableA11y.ts
@@ -1,4 +1,5 @@
-import { useMemo, useRef } from "react";
+import { useMemo } from "react";
+import { useLatest } from "../../lib/useLatest";
 import { useTranslation } from "react-i18next";
 import { closestCenter } from "@dnd-kit/core";
 import type {
@@ -38,8 +39,7 @@ export function useSortableA11y(describe: (id: UniqueIdentifier) => SortableSubj
   announcements: Announcements;
 } {
   const { t } = useTranslation();
-  const latest = useRef(describe);
-  latest.current = describe;
+  const latest = useLatest(describe);
   return useMemo(() => {
     // Spread into a fresh object: i18next's options type is an index signature, which a named
     // interface does not satisfy.
@@ -51,22 +51,21 @@ export function useSortableA11y(describe: (id: UniqueIdentifier) => SortableSubj
     // dnd-kit reports the item over ITSELF right after the pick-up, in the same tick — announced,
     // "moved to position 1" replaced "picked up … use the arrow keys" in the live region before a
     // screen reader read it (measured in Chrome). Only a real move is announced as one.
-    let moved = false;
+    // Per-DRAG state the announcement closures share (a component-lifetime ref would be the wrong
+    // lifetime): an object owned by this memo, so the closures mutate a property, never a binding.
+    const drag = { moved: false };
     return {
       screenReaderInstructions: { draggable: t("common.dnd.instructions") },
       announcements: {
         onDragStart: ({ active }) => {
-          moved = false;
+          drag.moved = false;
           return t("common.dnd.pickedUp", at(active.id));
         },
         onDragOver: ({ active, over }) => {
-          if (!over || (!moved && over.id === active.id)) return undefined;
-          // `moved` is per-DRAG state, and the announcement closures capturing it is the point:
+          if (!over || (!drag.moved && over.id === active.id)) return undefined;
           // dnd-kit reports the item over ITSELF in the pick-up tick (see above), and this flag is
-          // the only thing separating that from a real move. A ref would be the wrong lifetime —
-          // one drag, not the component.
-          // eslint-disable-next-line react-hooks/immutability
-          moved = true;
+          // the only thing separating that from a real move.
+          drag.moved = true;
           return t("common.dnd.movedOver", landing(active.id, over.id));
         },
         onDragEnd: ({ active, over }) =>
@@ -76,7 +75,7 @@ export function useSortableA11y(describe: (id: UniqueIdentifier) => SortableSubj
         onDragCancel: ({ active }) => t("common.dnd.cancelled", at(active.id)),
       },
     };
-  }, [t]);
+  }, [t, latest]);
 }
 
 // A context that nests sortable lists (a Plex playlist: its blocks, and each show's episodes) must
diff --git a/frontend/src/components/ui/surfaces.ts b/frontend/src/components/ui/surfaces.ts
index 403442f6..acc5f2b7 100644
--- a/frontend/src/components/ui/surfaces.ts
+++ b/frontend/src/components/ui/surfaces.ts
@@ -28,5 +28,3 @@ export const SURFACE = {
   /** A full-width sticky band (the design lab's header): square. */
   band: "glass",
 } as const;
-
-export type SurfaceRole = keyof typeof SURFACE;
diff --git a/frontend/src/components/ui/tableHeader.tsx b/frontend/src/components/ui/tableHeader.tsx
index 2fe6b7a5..379579b4 100644
--- a/frontend/src/components/ui/tableHeader.tsx
+++ b/frontend/src/components/ui/tableHeader.tsx
@@ -29,11 +29,11 @@ import { SURFACE } from "./surfaces";
 // The multi-select filter's option list, capped and scrollable. Its own component because it owns a
 // hook — see the FilterPopover note below for why nesting either of these would remount them.
 function FilterOptionList({ children }: { children: ReactNode }) {
-  const fade = useScrollFade();
+  const { ref: fadeRef, style: fadeStyle } = useScrollFade();
   return (
     <div
-      ref={fade.ref}
-      style={fade.style}
+      ref={fadeRef}
+      style={fadeStyle}
       className="flex flex-col gap-0.5 max-h-60 overflow-y-auto no-scrollbar"
     >
       {children}
@@ -77,13 +77,14 @@ function FilterFunnel<T>({
     mode: isText ? "dialog" : "menu",
     role: isText ? "dialog" : "menu",
   });
+  const { setReference } = pop.refs;
   const filterOn = isActive(value);
 
   return (
     <>
       <IconButton
         variant={filterOn ? "ghost-accent" : "ghost"}
-        ref={pop.refs.setReference}
+        ref={setReference}
         {...pop.getReferenceProps()}
         label={t("datatable.filter")}
         // The icon alone was a 14x14 hit target, the smallest in the app; the sm rung is 28.
diff --git a/frontend/src/components/ui/useReturnFocus.dom.test.tsx b/frontend/src/components/ui/useReturnFocus.dom.test.tsx
index e874f2aa..2b5fdc14 100644
--- a/frontend/src/components/ui/useReturnFocus.dom.test.tsx
+++ b/frontend/src/components/ui/useReturnFocus.dom.test.tsx
@@ -14,20 +14,20 @@ afterEach(cleanup);
 
 function Editor() {
   const [open, setOpen] = useState(false);
-  const focus = useReturnFocus(open);
+  const { target, arm } = useReturnFocus(open);
   return open ? (
     <input
       aria-label="name"
       autoFocus
       onKeyDown={(e) => {
         if (e.key === "Enter" || e.key === "Escape") {
-          focus.arm(e);
+          arm(e);
           setOpen(false);
         }
       }}
     />
   ) : (
-    <button ref={focus.target} onClick={() => setOpen(true)}>
+    <button ref={target} onClick={() => setOpen(true)}>
       Rename
     </button>
   );
diff --git a/frontend/src/components/useDebugRecording.ts b/frontend/src/components/useDebugRecording.ts
index b5b39269..80837101 100644
--- a/frontend/src/components/useDebugRecording.ts
+++ b/frontend/src/components/useDebugRecording.ts
@@ -112,9 +112,8 @@ export function useDebugRecording() {
       image = await captureTab();
     } catch (err) {
       notifyActionError(err, t("recorder.pill.shotFailed"));
-    } finally {
-      hide(false);
     }
+    hide(false);
     if (image) shoot.mutate({ id: session.id, image });
   };
 
diff --git a/frontend/src/components/useDownloadActions.tsx b/frontend/src/components/useDownloadActions.tsx
index 3e31a8dd..23e7a70d 100644
--- a/frontend/src/components/useDownloadActions.tsx
+++ b/frontend/src/components/useDownloadActions.tsx
@@ -89,11 +89,7 @@ export function useDownloadActions({
   const quickShare = async (job: DownloadJob) => {
     if (sharingId !== null) return;
     setSharingId(job.id);
-    try {
-      await quickShareLink(qc, job, t);
-    } finally {
-      setSharingId(null);
-    }
+    await quickShareLink(qc, job, t).finally(() => setSharingId(null));
   };
 
   const icon = (I: typeof Play) => <I className="w-4 h-4" />;
diff --git a/frontend/src/components/usePlaylistActions.tsx b/frontend/src/components/usePlaylistActions.tsx
index c502fb7f..57248215 100644
--- a/frontend/src/components/usePlaylistActions.tsx
+++ b/frontend/src/components/usePlaylistActions.tsx
@@ -1,6 +1,7 @@
 import { useQueryClient } from "@tanstack/react-query";
 import { useTranslation } from "react-i18next";
-import { ExternalLink, Pencil, RotateCcw, Trash2, Upload, Youtube } from "lucide-react";
+import { ExternalLink, Pencil, RotateCcw, Trash2, Upload } from "lucide-react";
+import { YouTubeIcon } from "../lib/brandIcons";
 import { qk } from "../lib/queryKeys";
 import { api, type Playlist } from "../lib/api";
 import { notify } from "../lib/notifications";
@@ -58,7 +59,7 @@ export function usePlaylistActions() {
   const copy = useCopyItems();
   const { selectedId } = usePlaylists();
   const { setSelectedId } = usePlaylistsActions();
-  const { pushing, reverting } = inFlight.use();
+  const { pushing, reverting } = inFlight.useValue();
 
   const refresh = (id: number) => {
     qc.invalidateQueries({ queryKey: qk.playlists() });
@@ -139,9 +140,8 @@ export function usePlaylistActions() {
       });
     } catch (e) {
       notifyYouTubeActionError(e, t("playlists.revertFailed"));
-    } finally {
-      mark("reverting", pl.id, false);
     }
+    mark("reverting", pl.id, false);
   }
 
   async function push(pl: Menuable) {
@@ -149,80 +149,85 @@ export function usePlaylistActions() {
     const name = playlistName(pl, t);
     mark("pushing", pl.id, true);
     try {
-      const plan = await api.playlistPushPlan(pl.id);
-      const nothingToDo =
-        plan.action === "update" &&
-        !plan.add_yt &&
-        !plan.add_local &&
-        !plan.remove_yt &&
-        !plan.remove_local &&
-        !plan.to_reorder &&
-        !plan.rename;
-      if (nothingToDo) {
-        notify({ level: "info", message: t("playlists.pushUpToDate", { name }) });
-        return;
-      }
-      if (!plan.affordable) {
-        notify({
-          level: "warning",
-          message: t("playlists.pushNoQuota", {
-            left: plan.remaining_today,
-            units: plan.units_estimate,
-          }),
-        });
-        return;
-      }
-      let message: string;
-      if (plan.action === "create") {
-        message = t("playlists.pushPlanCreate", {
-          count: plan.add_yt,
-          units: plan.units_estimate,
-          left: plan.remaining_today,
-        });
-      } else {
-        // One sentence per side that actually changes; the untouched side gets a short "stays
-        // unchanged" reassurance instead of a "+0 / −0" the reader has to decode.
-        const here: string[] = [];
-        if (plan.add_local) here.push(t("playlists.mergeAddLocal", { count: plan.add_local }));
-        if (plan.remove_local)
-          here.push(t("playlists.mergeRemoveLocal", { count: plan.remove_local }));
-        const yt: string[] = [];
-        if (plan.add_yt) yt.push(t("playlists.mergeAddYt", { count: plan.add_yt }));
-        if (plan.remove_yt) yt.push(t("playlists.mergeRemoveYt", { count: plan.remove_yt }));
-        if (plan.to_reorder) yt.push(t("playlists.mergeReorder", { count: plan.to_reorder }));
-        if (plan.rename) yt.push(t("playlists.mergeRename"));
-        const sentences = [...here, ...yt];
-        if (here.length && !yt.length) sentences.push(t("playlists.mergeYtUnchanged"));
-        if (yt.length && !here.length) sentences.push(t("playlists.mergeLocalUnchanged"));
-        const quota =
-          plan.units_estimate > 0
-            ? t("playlists.mergeQuota", {
-                units: plan.units_estimate,
-                left: plan.remaining_today,
-              })
-            : t("playlists.mergeQuotaFree");
-        message = sentences.join(" ") + quota;
-      }
-      const ok = await confirm({
-        title: t("playlists.pushTitle"),
-        message,
-        confirmLabel: t("playlists.pushConfirm"),
-      });
-      if (!ok) return;
-      const r = await api.pushPlaylist(pl.id);
-      refresh(pl.id);
-      if (r.failures.length) {
-        notify({
-          level: "warning",
-          message: t("playlists.pushPartial", { count: r.failures.length }),
-        });
-      } else {
-        notify({ level: "success", message: t("playlists.pushDone", { name }) });
-      }
+      await pushSteps(pl, name);
     } catch (e) {
       notifyYouTubeActionError(e, t("playlists.pushFailed"));
-    } finally {
-      mark("pushing", pl.id, false);
+    }
+    mark("pushing", pl.id, false);
+  }
+
+  /** push()'s steps, apart so its "pushing" mark clears on every way out without a try/finally
+   *  (the React Compiler cannot lower one yet, and skips the whole hook). */
+  async function pushSteps(pl: Menuable, name: string) {
+    const plan = await api.playlistPushPlan(pl.id);
+    const nothingToDo =
+      plan.action === "update" &&
+      !plan.add_yt &&
+      !plan.add_local &&
+      !plan.remove_yt &&
+      !plan.remove_local &&
+      !plan.to_reorder &&
+      !plan.rename;
+    if (nothingToDo) {
+      notify({ level: "info", message: t("playlists.pushUpToDate", { name }) });
+      return;
+    }
+    if (!plan.affordable) {
+      notify({
+        level: "warning",
+        message: t("playlists.pushNoQuota", {
+          left: plan.remaining_today,
+          units: plan.units_estimate,
+        }),
+      });
+      return;
+    }
+    let message: string;
+    if (plan.action === "create") {
+      message = t("playlists.pushPlanCreate", {
+        count: plan.add_yt,
+        units: plan.units_estimate,
+        left: plan.remaining_today,
+      });
+    } else {
+      // One sentence per side that actually changes; the untouched side gets a short "stays
+      // unchanged" reassurance instead of a "+0 / −0" the reader has to decode.
+      const here: string[] = [];
+      if (plan.add_local) here.push(t("playlists.mergeAddLocal", { count: plan.add_local }));
+      if (plan.remove_local)
+        here.push(t("playlists.mergeRemoveLocal", { count: plan.remove_local }));
+      const yt: string[] = [];
+      if (plan.add_yt) yt.push(t("playlists.mergeAddYt", { count: plan.add_yt }));
+      if (plan.remove_yt) yt.push(t("playlists.mergeRemoveYt", { count: plan.remove_yt }));
+      if (plan.to_reorder) yt.push(t("playlists.mergeReorder", { count: plan.to_reorder }));
+      if (plan.rename) yt.push(t("playlists.mergeRename"));
+      const sentences = [...here, ...yt];
+      if (here.length && !yt.length) sentences.push(t("playlists.mergeYtUnchanged"));
+      if (yt.length && !here.length) sentences.push(t("playlists.mergeLocalUnchanged"));
+      const quota =
+        plan.units_estimate > 0
+          ? t("playlists.mergeQuota", {
+              units: plan.units_estimate,
+              left: plan.remaining_today,
+            })
+          : t("playlists.mergeQuotaFree");
+      message = sentences.join(" ") + quota;
+    }
+    const ok = await confirm({
+      title: t("playlists.pushTitle"),
+      message,
+      confirmLabel: t("playlists.pushConfirm"),
+    });
+    if (!ok) return;
+    const r = await api.pushPlaylist(pl.id);
+    refresh(pl.id);
+    if (r.failures.length) {
+      notify({
+        level: "warning",
+        message: t("playlists.pushPartial", { count: r.failures.length }),
+      });
+    } else {
+      notify({ level: "success", message: t("playlists.pushDone", { name }) });
     }
   }
 
@@ -266,7 +271,7 @@ export function usePlaylistActions() {
               icon: pushing.has(pl.id) ? (
                 <Upload className="w-4 h-4 animate-pulse" />
               ) : linked ? (
-                <Youtube className="w-4 h-4" />
+                <YouTubeIcon className="w-4 h-4" />
               ) : (
                 <Upload className="w-4 h-4" />
               ),
diff --git a/frontend/src/components/usePlexActiveFilters.dom.test.tsx b/frontend/src/components/usePlexActiveFilters.dom.test.tsx
index d036e19f..b5ca2b93 100644
--- a/frontend/src/components/usePlexActiveFilters.dom.test.tsx
+++ b/frontend/src/components/usePlexActiveFilters.dom.test.tsx
@@ -85,6 +85,15 @@ describe("usePlexActiveFilters", () => {
     expect(byKey["collection:A"]).toBe("Marvel");
   });
 
+  it("marks a link-supplied collection chip pending while its title loads, not the known one", () => {
+    qc.removeQueries({ queryKey: qk.plexCollections("titles", "B") });
+    vi.spyOn(api, "plexCollections").mockReturnValue(new Promise(() => {}) as never);
+    const { result } = renderHook(() => usePlexActiveFilters(), { wrapper });
+    const pending = Object.fromEntries(result.current.map((c) => [c.key, c.pending]));
+    expect(pending["collection:B"]).toBe(true);
+    expect(pending["collection:A"]).toBe(false);
+  });
+
   it("removing the last collection chip prunes its title and collapses collectionTitles to undefined", () => {
     setFilters.mockClear();
     const { result } = renderHook(() => usePlexActiveFilters(), { wrapper });
diff --git a/frontend/src/components/usePlexActiveFilters.ts b/frontend/src/components/usePlexActiveFilters.ts
index 9dcc3b78..a9716b9e 100644
--- a/frontend/src/components/usePlexActiveFilters.ts
+++ b/frontend/src/components/usePlexActiveFilters.ts
@@ -23,8 +23,16 @@ export function usePlexActiveFilters(): ActiveFilter[] {
   const patch = (p: Partial<PlexFilters>) => setFilters({ ...filters, ...p });
   // A link opened cold knows the collection ids but not their names — resolve the missing ones for
   // display (see usePlexCollectionTitles for why they are NOT written back into the filter state).
-  const collectionTitles = usePlexCollectionTitles(filters.collections, filters.collectionTitles);
-  return buildPlexActiveFilters(filters, show, patch, setShow, t, collectionTitles);
+  const collections = usePlexCollectionTitles(filters.collections, filters.collectionTitles);
+  return buildPlexActiveFilters(
+    filters,
+    show,
+    patch,
+    setShow,
+    t,
+    collections.titles,
+    collections.pending,
+  );
 }
 
 // The pure builder behind the hook: turns a Plex filter set + watch-state into the source-agnostic
@@ -39,6 +47,8 @@ export function buildPlexActiveFilters(
   /** Collection titles for the chip labels, resolved beyond what the filter state carries. Omitted by
    *  the saved-views manager, which describes a stored view and has only the captured titles. */
   collectionTitles?: Record<string, string>,
+  /** The missing titles are still loading: their chips show a placeholder, not the generic word. */
+  collectionsPending = false,
 ): ActiveFilter[] {
   const out: ActiveFilter[] = [];
 
@@ -134,23 +144,7 @@ export function buildPlexActiveFilters(
       remove: () => patch({ keywords: filters.keywords.filter((x) => x !== k) }),
     });
   }
-  for (const c of filters.collections) {
-    out.push({
-      key: `collection:${c}`,
-      label: collectionTitles?.[c] ?? filters.collectionTitles?.[c] ?? t("plex.filter.collection"),
-      // Prune the title too — collectionTitles is hashed into the plex query keys, so a stale entry
-      // splits the cache from the logically-identical no-collection state (mirrors CollectionPicker).
-      // Collapse an empty map back to undefined so the last-removed state key-matches the pristine
-      // one (an empty `{}` still hashes differently from an absent key).
-      remove: () => {
-        const { [c]: _drop, ...restTitles } = filters.collectionTitles ?? {};
-        patch({
-          collections: filters.collections.filter((x) => x !== c),
-          collectionTitles: Object.keys(restTitles).length ? restTitles : undefined,
-        });
-      },
-    });
-  }
+  out.push(...collectionChips(filters, patch, t, collectionTitles, collectionsPending));
   if (show !== "all") {
     out.push({
       key: "show",
@@ -171,3 +165,30 @@ export function usePlexClearFilters(): () => void {
     setSort(PLEX_SORT_FALLBACK);
   };
 }
+
+// One chip per selected collection, named by the resolved titles (a placeholder while a link's titles
+// load), else by the ones the state carries, else the generic word.
+function collectionChips(
+  filters: PlexFilters,
+  patch: (p: Partial<PlexFilters>) => void,
+  t: TFn,
+  collectionTitles: Record<string, string> | undefined,
+  pending: boolean,
+): ActiveFilter[] {
+  return filters.collections.map((c) => ({
+    key: `collection:${c}`,
+    label: collectionTitles?.[c] ?? filters.collectionTitles?.[c] ?? t("plex.filter.collection"),
+    pending: pending && collectionTitles?.[c] === undefined,
+    // Prune the title too — collectionTitles is hashed into the plex query keys, so a stale entry
+    // splits the cache from the logically-identical no-collection state (mirrors CollectionPicker).
+    // Collapse an empty map back to undefined so the last-removed state key-matches the pristine
+    // one (an empty `{}` still hashes differently from an absent key).
+    remove: () => {
+      const { [c]: _drop, ...restTitles } = filters.collectionTitles ?? {};
+      patch({
+        collections: filters.collections.filter((x) => x !== c),
+        collectionTitles: Object.keys(restTitles).length ? restTitles : undefined,
+      });
+    },
+  }));
+}
diff --git a/frontend/src/components/usePlexPlaylistEdits.dom.test.tsx b/frontend/src/components/usePlexPlaylistEdits.dom.test.tsx
index d3e3c96a..8098dfdc 100644
--- a/frontend/src/components/usePlexPlaylistEdits.dom.test.tsx
+++ b/frontend/src/components/usePlexPlaylistEdits.dom.test.tsx
@@ -99,13 +99,13 @@ describe("usePlexPlaylistEdits · the reorder", () => {
     // answers the same from now on — so the rollback's own refetch comes back deep-equal, keeps
     // the same `q.data`, and could never correct a stale rollback.
     detail.mockResolvedValue({ id: 5, title: "F", items: [movie("1"), movie("3")] } as never);
-    act(() =>
+    act(() => {
       qc.setQueryData(qk.plexPlaylist(5, "en"), {
         id: 5,
         title: "F",
         items: [movie("1"), movie("3")],
-      }),
-    );
+      });
+    });
     // The view has taken the refreshed list in BEFORE the reorder fails — the race as it happens.
     // (react-query batches its notification, so without this wait the refresh landed only after the
     // rollback and quietly corrected a stale one, which proved nothing.)
diff --git a/frontend/src/components/usePlexPlaylistEdits.ts b/frontend/src/components/usePlexPlaylistEdits.ts
index 1259e83b..925e8327 100644
--- a/frontend/src/components/usePlexPlaylistEdits.ts
+++ b/frontend/src/components/usePlexPlaylistEdits.ts
@@ -96,6 +96,7 @@ export function usePlexPlaylistEdits(playlistId: number) {
     const before = items.map((i) => i.id);
     const set = new Set(keys);
     setItems((prev) => prev.filter((i) => !set.has(i.id)));
+    let removed = true;
     try {
       if (keys.length === 1) await api.plexPlaylistRemoveItem(playlistId, keys[0]!);
       else await api.plexPlaylistRemoveBulk(playlistId, keys);
@@ -103,10 +104,10 @@ export function usePlexPlaylistEdits(playlistId: number) {
     } catch (e) {
       notifyActionError(e, t("plex.playlist.removeFailed"));
       putBack();
-      return;
-    } finally {
-      setBusy(false);
+      removed = false;
     }
+    setBusy(false);
+    if (!removed) return;
     notify({
       level: "success",
       message: t("plex.playlist.removedToast", { title }),
diff --git a/frontend/src/content/release-notes/en.json b/frontend/src/content/release-notes/en.json
index 4a97a857..8018b446 100644
--- a/frontend/src/content/release-notes/en.json
+++ b/frontend/src/content/release-notes/en.json
@@ -1,4 +1,23 @@
 [
+  {
+    "version": "0.99.0",
+    "date": "2026-10-04",
+    "new": [
+      "Nearly every screen is now compiled by the React Compiler, so lists and menus re-render less.",
+      "The channel list's row menu opens and closes without redrawing the table."
+    ],
+    "fixed": [
+      "A failed or empty answer from YouTube or Plex no longer empties a playlist, a mirror or your Plex watch history: Siftlode keeps what it had until a complete answer arrives.",
+      "Plex watch states un-watched on Plex now sync for each library on its own, even if another library is briefly unreachable.",
+      "A channel with no uploads no longer fails its backfill on every run.",
+      "“This playlist no longer exists” appears only for a list you picked yourself.",
+      "A filter on a deleted tag matches nothing and its chip says so, and the tag cleanup keeps tags a saved view filters on.",
+      "A channel filter names its channels from the first moment, and a playlist reopened from the cache keeps its rows.",
+      "The bug report opens on its title, and a dialog whose form loads late gives the form the focus once.",
+      "The Plex backdrop crossfade setting is respected even with reduced motion on.",
+      "Smaller fixes to keyboard focus, undo and loading states."
+    ]
+  },
   {
     "version": "0.98.0",
     "date": "2026-10-03",
diff --git a/frontend/src/content/release-notes/hu.json b/frontend/src/content/release-notes/hu.json
index 045da425..729a62bf 100644
--- a/frontend/src/content/release-notes/hu.json
+++ b/frontend/src/content/release-notes/hu.json
@@ -1,4 +1,23 @@
 [
+  {
+    "version": "0.99.0",
+    "date": "2026-10-04",
+    "new": [
+      "Szinte minden képernyőt a React Compiler fordít, így a listák és a menük ritkábban rajzolódnak újra.",
+      "A csatornalista sormenüje a táblázat újrarajzolása nélkül nyílik és csukódik."
+    ],
+    "fixed": [
+      "Egy hibás vagy üres YouTube- vagy Plex-válasz már nem üríti ki a lejátszási listát, a tükröt vagy a Plex-nézettséget: a Siftlode megtartja, ami volt, amíg teljes válasz nem jön.",
+      "A Plexen visszavont nézettség könyvtáranként szinkronizálódik, akkor is, ha egy másik könyvtár épp nem érhető el.",
+      "Egy feltöltés nélküli csatorna mentése már nem hibázik minden futáskor.",
+      "Az „Ez a lejátszási lista már nem létezik” csak egy általad kiválasztott listánál jelenik meg.",
+      "Egy törölt címkére szűrés semmit nem talál, és a szűrő ezt jelzi; a címketakarítás megtartja azokat a címkéket, amelyekre egy mentett nézet szűr.",
+      "A csatornaszűrő az első pillanattól a csatornák nevét mutatja, és a gyorsítótárból újranyitott lista megtartja a sorait.",
+      "A hibajelentés a címén nyílik, és egy később betöltődő űrlap egyszer megkapja a fókuszt.",
+      "A Plex háttérkép-áttűnés beállítása csökkentett mozgás mellett is érvényes.",
+      "Kisebb javítások a billentyűzetes fókuszban, a visszavonásban és a betöltési állapotokban."
+    ]
+  },
   {
     "version": "0.98.0",
     "date": "2026-10-03",
diff --git a/frontend/src/design-lab/batchB.tsx b/frontend/src/design-lab/batchB.tsx
index a15943b3..a4b3b2f0 100644
--- a/frontend/src/design-lab/batchB.tsx
+++ b/frontend/src/design-lab/batchB.tsx
@@ -16,8 +16,8 @@ import {
   SlidersHorizontal,
   Tv,
   Users,
-  Youtube,
 } from "lucide-react";
+import { YouTubeIcon } from "../lib/brandIcons";
 import { Btn } from "./batchA";
 import { hexContrast, hueGap } from "../lib/colorMath";
 import { Reference, Sample } from "./labKit";
@@ -285,7 +285,7 @@ function WatchPage() {
 type NavDef = { icon: typeof Home; en: string; hu: string };
 const NAV: NavDef[] = [
   { icon: Home, en: "Home", hu: "Kezdőlap" },
-  { icon: Youtube, en: "Feed", hu: "Feed" },
+  { icon: YouTubeIcon, en: "Feed", hu: "Feed" },
   { icon: Tv, en: "Channels", hu: "Csatornák" },
   { icon: ListVideo, en: "Playlists", hu: "Listák" },
   { icon: Clapperboard, en: "Plex", hu: "Plex" },
diff --git a/frontend/src/design-lab/labTokens.ts b/frontend/src/design-lab/labTokens.ts
index a58c2f9e..ea28b967 100644
--- a/frontend/src/design-lab/labTokens.ts
+++ b/frontend/src/design-lab/labTokens.ts
@@ -6,9 +6,8 @@
 /** A4: the input edge, ≥ 3:1 against the page in every scheme and mode (index.css --edge-strong). */
 export const STRONG = "var(--edge-strong)";
 
-/** B3 state layers (index.css utilities). */
+/** B3 state layer (an index.css utility). */
 export const LAYER = "state-layer";
-export const FILLED = "state-filled";
 
 /** B9: the header + fade edge (index.css utilities; the host is positioned). */
 export const FADE_BELOW = "fade-below";
diff --git a/frontend/src/i18n/backendIds.contract.test.ts b/frontend/src/i18n/backendIds.contract.test.ts
index 96a69fad..f5f173e4 100644
--- a/frontend/src/i18n/backendIds.contract.test.ts
+++ b/frontend/src/i18n/backendIds.contract.test.ts
@@ -232,7 +232,7 @@ describe("backend ids have their names in both languages", () => {
     expect(failDetails).toEqual(expect.arrayContaining(["facebook.login_wall"]));
     expect(goneWhats).toEqual(expect.arrayContaining(["playlist", "download", "job"]));
     expect(opaqueWhats).toEqual([]);
-    expect(youtubeReasons).toEqual(["quota", "reconnect", "unavailable"]);
+    expect(youtubeReasons).toEqual(["quota", "reconnect", "unavailable", "gone"]);
     expect(crewJobs).toEqual(
       expect.arrayContaining(["Director", "Creator", "Director of Photography"]),
     );
diff --git a/frontend/src/i18n/locales/en/common.json b/frontend/src/i18n/locales/en/common.json
index 50212267..10017eef 100644
--- a/frontend/src/i18n/locales/en/common.json
+++ b/frontend/src/i18n/locales/en/common.json
@@ -26,6 +26,7 @@
   "retry": "Retry",
   "retryWithEnter": "Press Enter to try again.",
   "loadError": "Couldn't load this — check your connection and try again",
+  "deletedTag": "Deleted tag",
   "seeAll": "See all",
   "scrollLeft": "Scroll left",
   "scrollRight": "Scroll right",
diff --git a/frontend/src/i18n/locales/en/errors.json b/frontend/src/i18n/locales/en/errors.json
index 6c5f37fa..60517e95 100644
--- a/frontend/src/i18n/locales/en/errors.json
+++ b/frontend/src/i18n/locales/en/errors.json
@@ -115,7 +115,8 @@
   "youtube": {
     "quota": "Today's YouTube budget for this instance is spent. It resets at midnight Pacific time — try again then.",
     "reconnect": "Google no longer accepts this account's YouTube connection. Sign out and sign in with Google again to reconnect it.",
-    "unavailable": "YouTube didn't accept that just now. Please try again."
+    "unavailable": "YouTube didn't accept that just now. Please try again.",
+    "gone": "This playlist no longer exists on YouTube"
   },
   "refused": {
     "account_no_access": "That account no longer has access",
diff --git a/frontend/src/i18n/locales/en/player.json b/frontend/src/i18n/locales/en/player.json
index ad2d6cd1..ac70e6d0 100644
--- a/frontend/src/i18n/locales/en/player.json
+++ b/frontend/src/i18n/locales/en/player.json
@@ -34,6 +34,7 @@
   "playInApp": "Play in the in-app player",
   "unavailableTitle": "Can't play this here",
   "unavailableBody": "This video isn't available — it may be private, removed, or region-restricted.",
+  "apiLoadFailedBody": "The YouTube player didn't load — a connection problem or a content blocker may be stopping it. It still plays on YouTube.",
   "embedDisabledBody": "The owner disabled playback on other sites (common for auto-generated “Topic” music tracks). It still plays on YouTube.",
   "openOnYoutube": "Open on YouTube",
   "shortcutsHint": "Click: play/pause · Scroll or ↑ ↓: volume · F: fill the window",
diff --git a/frontend/src/i18n/locales/hu/common.json b/frontend/src/i18n/locales/hu/common.json
index e50e5c1d..0e0c00f3 100644
--- a/frontend/src/i18n/locales/hu/common.json
+++ b/frontend/src/i18n/locales/hu/common.json
@@ -26,6 +26,7 @@
   "retry": "Újra",
   "retryWithEnter": "Újrapróbáláshoz nyomd meg az Entert.",
   "loadError": "Nem sikerült betölteni — ellenőrizd a kapcsolatot, és próbáld újra",
+  "deletedTag": "Törölt címke",
   "seeAll": "Összes",
   "scrollLeft": "Görgetés balra",
   "scrollRight": "Görgetés jobbra",
diff --git a/frontend/src/i18n/locales/hu/errors.json b/frontend/src/i18n/locales/hu/errors.json
index 6630b03d..598455bb 100644
--- a/frontend/src/i18n/locales/hu/errors.json
+++ b/frontend/src/i18n/locales/hu/errors.json
@@ -115,7 +115,8 @@
   "youtube": {
     "quota": "Ennek a példánynak elfogyott a mai YouTube-kerete. Csendes-óceáni idő szerint éjfélkor újraindul — akkor próbáld újra.",
     "reconnect": "A Google már nem fogadja el ennek a fióknak a YouTube-kapcsolatát. Jelentkezz ki, majd lépj be újra Google-lel az összekötéshez.",
-    "unavailable": "A YouTube most nem fogadta el. Próbáld újra."
+    "unavailable": "A YouTube most nem fogadta el. Próbáld újra.",
+    "gone": "Ez a lejátszási lista már nem létezik a YouTube-on"
   },
   "refused": {
     "account_no_access": "Ennek a fióknak már nincs hozzáférése",
diff --git a/frontend/src/i18n/locales/hu/player.json b/frontend/src/i18n/locales/hu/player.json
index 4aadfe84..b150a7c0 100644
--- a/frontend/src/i18n/locales/hu/player.json
+++ b/frontend/src/i18n/locales/hu/player.json
@@ -34,6 +34,7 @@
   "playInApp": "Lejátszás a beépített lejátszóban",
   "unavailableTitle": "Ez itt nem játszható le",
   "unavailableBody": "Ez a videó nem elérhető — lehet privát, eltávolított vagy régiókorlátozott.",
+  "apiLoadFailedBody": "A YouTube-lejátszó nem töltődött be — kapcsolati hiba vagy tartalomblokkoló akadályozhatja. A YouTube-on viszont lejátszható.",
   "embedDisabledBody": "A tulajdonos letiltotta a lejátszást más oldalakon (gyakori az automatikusan generált „Topic” zenei sávoknál). A YouTube-on viszont lejátszható.",
   "openOnYoutube": "Megnyitás YouTube-on",
   "shortcutsHint": "Kattintás: lejátszás/szünet · Görgő vagy ↑ ↓: hangerő · F: teljes ablak",
diff --git a/frontend/src/lib/activeAccount.ts b/frontend/src/lib/activeAccount.ts
index c57493ff..3f196d3f 100644
--- a/frontend/src/lib/activeAccount.ts
+++ b/frontend/src/lib/activeAccount.ts
@@ -10,6 +10,7 @@
 // again through `onAccountPinned`.
 //
 // ACTIVE_ACCOUNT_KEY is duplicated here rather than imported from api.ts so this stays dependency-free.
+/** @internal exported for 13 tests (BootGate.dom.test.tsx, …) */
 export const ACTIVE_ACCOUNT_KEY = "siftlode.activeAccount";
 
 // Re-readers for module-level per-account state, run each time the tab is pinned.
diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts
index 5dd9fc72..3b4fdd87 100644
--- a/frontend/src/lib/api.ts
+++ b/frontend/src/lib/api.ts
@@ -6,16 +6,10 @@
 //   3. spreads each domain's method slice into the single `api` object consumers call.
 // A new endpoint therefore has nowhere to land except a domain module — the interleave that
 // motivated R7.5 cannot re-grow here. (An automated guard for that invariant lands in S3.)
-import {
-  alreadyReported,
-  getActiveAccount,
-  HttpError,
-  setActiveAccount,
-  setUnauthorizedHandler,
-} from "./api/core";
+import { getActiveAccount, HttpError, setActiveAccount, setUnauthorizedHandler } from "./api/core";
 
 // Re-export the shared HTTP machinery so consumers keep importing these from "./api" unchanged.
-export { alreadyReported, HttpError, getActiveAccount, setActiveAccount, setUnauthorizedHandler };
+export { HttpError, getActiveAccount, setActiveAccount, setUnauthorizedHandler };
 
 import { accountApi } from "./api/account";
 export type * from "./api/account";
diff --git a/frontend/src/lib/api/discover.ts b/frontend/src/lib/api/discover.ts
index c69e1118..e7d3794f 100644
--- a/frontend/src/lib/api/discover.ts
+++ b/frontend/src/lib/api/discover.ts
@@ -19,11 +19,11 @@ export type HeroTier = "resume" | "comfort" | "surprise";
  *  leads with `HERO_TIERS[start % 3]`, which is how a press can ASK for a tier. */
 export const HERO_TIERS: readonly HeroTier[] = ["resume", "comfort", "surprise"];
 
-export type DiscoverKind = "video" | "movie" | "show" | "episode" | "channel" | "playlist";
+type DiscoverKind = "video" | "movie" | "show" | "episode" | "channel" | "playlist";
 
 // What can go on the comfort shelf. `plex_item` covers a movie or a single episode; a show is pinned
 // as `plex_show` because "put that show on" resolves to whichever episode is next.
-export const PIN_KINDS = ["video", "channel", "plex_item", "plex_show", "playlist"] as const;
+const PIN_KINDS = ["video", "channel", "plex_item", "plex_show", "playlist"] as const;
 export type PinKind = (typeof PIN_KINDS)[number];
 
 export interface DiscoverCard {
diff --git a/frontend/src/lib/api/feed.test.ts b/frontend/src/lib/api/feed.test.ts
new file mode 100644
index 00000000..bc05aa09
--- /dev/null
+++ b/frontend/src/lib/api/feed.test.ts
@@ -0,0 +1,170 @@
+// E32 S2: lib/api/feed was barely covered, and it is where a filter turns into a query string.
+// FastAPI IGNORES a query parameter it does not know, so a misspelt or renamed key does not fail —
+// the filter simply stops applying while its chip still shows. Locked two ways: what each filter
+// emits, and that every key emitted is one the backend's feed endpoints actually read.
+import { readFileSync } from "node:fs";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beacon, req } from "./core";
+import { feedApi, type FeedFilters } from "./feed";
+
+vi.mock("./core", () => ({ req: vi.fn(() => Promise.resolve({})), beacon: vi.fn() }));
+
+const BASE: FeedFilters = {
+  tags: [],
+  tagModes: { language: "or", topic: "or", other: "or" },
+  q: "",
+  sort: "newest",
+  scope: "my",
+  includeNormal: true,
+  includeShorts: false,
+  includeLive: false,
+  show: "unwatched",
+  channelIds: [],
+};
+
+const lastUrl = () => new URL(vi.mocked(req).mock.lastCall![0] as string, "http://x");
+const sent = (f: Partial<FeedFilters>, cursor: string | null = null) => {
+  void feedApi.feed({ ...BASE, ...f }, cursor, 30);
+  return lastUrl().searchParams;
+};
+
+beforeEach(() => vi.mocked(req).mockClear());
+
+describe("feed filters on the wire", () => {
+  it("the defaults: scope, content types, show, library source, sort and page size", () => {
+    const p = sent({});
+    expect(Object.fromEntries(p)).toEqual({
+      scope: "my",
+      show_normal: "true",
+      include_shorts: "false",
+      include_live: "false",
+      show: "unwatched",
+      library_source: "organic",
+      sort: "newest",
+      limit: "30",
+    });
+  });
+
+  it("repeats tags and channels, and sends only the categories matched as ALL", () => {
+    const p = sent({
+      tags: [3, 9],
+      tagModes: { language: "or", topic: "and", other: "or" },
+      channelIds: ["UCa", "UCb"],
+      untagged: true,
+      q: "jazz",
+    });
+    expect(p.getAll("tags")).toEqual(["3", "9"]);
+    expect(p.getAll("channel_ids")).toEqual(["UCa", "UCb"]);
+    expect(p.get("tag_mode_topic")).toBe("and");
+    expect(p.has("tag_mode_language") || p.has("tag_mode_other")).toBe(false);
+    expect(p.get("untagged")).toBe("true");
+    expect(p.get("q")).toBe("jazz");
+  });
+
+  it("a year is a whole-year range and wins over the other date narrowings", () => {
+    const p = sent({ year: 2019, maxAgeDays: 7, dateFrom: "2024-01-01", dateTo: "2024-02-01" });
+    expect(p.get("published_after")).toBe("2019-01-01");
+    expect(p.get("published_before")).toBe("2019-12-31");
+    expect(p.has("max_age_days")).toBe(false);
+
+    const q = sent({ maxAgeDays: 7, dateFrom: "2024-01-01", dateTo: "2024-02-01" });
+    expect([q.get("max_age_days"), q.get("published_after"), q.get("published_before")]).toEqual([
+      "7",
+      "2024-01-01",
+      "2024-02-01",
+    ]);
+  });
+
+  it("a zero-second duration bound is still a bound", () => {
+    const p = sent({ minDuration: 0, maxDuration: 60 });
+    expect([p.get("min_duration"), p.get("max_duration")]).toEqual(["0", "60"]);
+  });
+
+  it("the shuffle seed travels only with the shuffle sort; the cursor when paging", () => {
+    expect(sent({ sort: "shuffle", seed: 42 }).get("seed")).toBe("42");
+    expect(sent({ sort: "newest", seed: 42 }).has("seed")).toBe(false);
+    expect(sent({}, "CUR").get("cursor")).toBe("CUR");
+  });
+
+  it("the summary and the year list see the same filters, without the paging", () => {
+    void feedApi.feedSummary({ ...BASE, tags: [5] });
+    expect(lastUrl().pathname).toBe("/api/feed/summary");
+    expect(lastUrl().searchParams.getAll("tags")).toEqual(["5"]);
+    expect(lastUrl().searchParams.has("limit")).toBe(false);
+    void feedApi.feedYears({ ...BASE, year: 2020 });
+    expect(lastUrl().pathname).toBe("/api/feed/years");
+  });
+
+  it("every key it sends is a parameter the backend's feed endpoints read", () => {
+    const routes = readFileSync(
+      new URL("../../../../backend/app/routes/feed.py", import.meta.url),
+      "utf-8",
+    );
+    const block = routes.match(/def _feed_params\(([\s\S]*?)\) -> dict:/);
+    expect(block, "routes/feed.py no longer defines _feed_params").toBeTruthy();
+    const known = new Set(
+      [...(block?.[1] ?? "").matchAll(/^\s{4}(\w+):/gm)].flatMap((m) => (m[1] ? [m[1]] : [])),
+    );
+    known.add("sort").add("seed").add("cursor").add("limit"); // read by /feed itself
+    // Every field set (Required: a new filter field fails tsc here until it has a value, so its key
+    // is checked too). `year` wins over the other date filters, so the set goes out once with it
+    // and once without.
+    const all: Required<FeedFilters> = {
+      tags: [1],
+      tagModes: { language: "and", topic: "and", other: "and" },
+      q: "x",
+      sort: "shuffle",
+      seed: 1,
+      scope: "all",
+      includeNormal: false,
+      includeShorts: true,
+      includeLive: true,
+      show: "all",
+      librarySource: "search",
+      untagged: true,
+      channelIds: ["UC"],
+      maxAgeDays: 3,
+      minDuration: 1,
+      maxDuration: 2,
+      dateFrom: "2024-01-01",
+      dateTo: "2024-01-02",
+      year: 2020,
+    };
+    const everything = [...sent(all, "C").keys(), ...sent({ ...all, year: undefined }, "C").keys()];
+    const unknown = [...new Set(everything)].filter((k) => !known.has(k));
+    expect(unknown).toEqual([]);
+    expect(known.has("tag_mode_topic")).toBe(true); // the parse found the real list
+  });
+});
+
+describe("watch state and progress", () => {
+  it("progress is saved in whole seconds, and the unload beacon escapes the id", () => {
+    void feedApi.saveProgress("abc", 61.9, 600.4);
+    const [url, init, opts] = vi.mocked(req).mock.lastCall!;
+    expect(url).toBe("/api/videos/abc/progress");
+    expect(JSON.parse((init as RequestInit).body as string)).toEqual({
+      position_seconds: 61,
+      duration_seconds: 600,
+    });
+    expect(opts).toEqual({ idempotent: true });
+
+    feedApi.saveProgressBeacon("a/b", 10.5, 20.5);
+    expect(vi.mocked(beacon)).toHaveBeenLastCalledWith("/api/videos/a%2Fb/progress", {
+      position_seconds: 10,
+      duration_seconds: 20,
+    });
+  });
+
+  it("the live search is quiet, so its panel can show a quota error inline", () => {
+    void feedApi.searchYoutube("cats & dogs", "NEXT", 10);
+    const [url, , opts] = vi.mocked(req).mock.lastCall!;
+    const u = new URL(url as string, "http://x");
+    expect(u.pathname).toBe("/api/search/youtube");
+    expect(Object.fromEntries(u.searchParams)).toEqual({
+      q: "cats & dogs",
+      cursor: "NEXT",
+      limit: "10",
+    });
+    expect(opts).toEqual({ quiet: true });
+  });
+});
diff --git a/frontend/src/lib/api/feed.ts b/frontend/src/lib/api/feed.ts
index dcdf133d..4f0a24b5 100644
--- a/frontend/src/lib/api/feed.ts
+++ b/frontend/src/lib/api/feed.ts
@@ -151,10 +151,6 @@ function feedQuery(f: FeedFilters, cursor: string | null, limit: number): string
 export const feedApi = {
   feed: (f: FeedFilters, cursor: string | null, limit: number): Promise<FeedResponse> =>
     req(`/api/feed?${feedQuery(f, cursor, limit)}`),
-  // SUPERSEDED by feedSummary (PERF-13) — no component calls this anymore; the backend /feed/count
-  // endpoint it targets is kept only as the /feed/summary equivalence-test oracle. Retire together.
-  feedCount: (f: FeedFilters): Promise<{ count: number }> =>
-    req(`/api/feed/count?${filterParams(f).toString()}`),
   // Live YouTube search: results are materialised into the catalog and returned as feed cards.
   // `quiet` so the YT-search panel can render quota/limit errors (incl. 429) inline instead of
   // popping the global modal. `cursor` is the next-page token (an InnerTube continuation token
@@ -169,10 +165,6 @@ export const feedApi = {
   // the now-orphaned, un-kept videos). Returns how many videos were removed.
   clearSearch: (videoIds: string[]): Promise<{ removed: number }> =>
     req("/api/search/clear", { method: "POST", body: JSON.stringify({ video_ids: videoIds }) }),
-  // SUPERSEDED by feedSummary (PERF-13) — no component calls this anymore; the backend /facets
-  // endpoint it targets is kept only as the /feed/summary equivalence-test oracle. Retire together.
-  facets: (f: FeedFilters): Promise<{ counts: Record<string, number> }> =>
-    req(`/api/facets?${filterParams(f).toString()}`),
   // The sidebar's total count + per-tag channel facets in ONE request + ONE grouped query, replacing
   // the separate feedCount + facets the feed and sidebar used to fire on every filter change (PERF-13).
   feedSummary: (f: FeedFilters): Promise<{ count: number; facets: Record<string, number> }> =>
diff --git a/frontend/src/lib/api/plex.ts b/frontend/src/lib/api/plex.ts
index ea60bdbc..516124d6 100644
--- a/frontend/src/lib/api/plex.ts
+++ b/frontend/src/lib/api/plex.ts
@@ -58,7 +58,7 @@ export interface PlexCard {
 // TMDB enrichment block (E5 S2), served from OUR DB (never a live TMDB call) on a movie/show detail.
 // null until the row has been enriched. Powers the S5 enriched detail page: multi-source ratings row,
 // facts sidebar, keyword chips (→ filter), and the full crew.
-export interface PlexTmdbCrew {
+interface PlexTmdbCrew {
   name: string;
   job: string;
   tmdb_id?: number | null;
diff --git a/frontend/src/lib/api/plexFilters.dom.test.ts b/frontend/src/lib/api/plexFilters.dom.test.ts
new file mode 100644
index 00000000..cdeef134
--- /dev/null
+++ b/frontend/src/lib/api/plexFilters.dom.test.ts
@@ -0,0 +1,49 @@
+// @vitest-environment jsdom
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+import { plexFiltersToParams, type PlexFilters } from "./plex";
+
+// FastAPI ignores a query parameter it does not know, so a Plex filter key the frontend misspells or
+// the backend renames does not fail anywhere — the filter silently stops narrowing while its chip
+// still shows (E32 S2, the sibling of lib/api/feed.test.ts). Every key the filter set can put on the
+// wire must be a field of the backend's LibraryFilters, which /library and /facets both inject.
+// Required: a new filter field fails tsc here until it has a value, so the checks below see its key.
+const EVERYTHING: Required<PlexFilters> = {
+  genres: ["Drama"],
+  genreMode: "all",
+  contentRatings: ["PG"],
+  yearMin: 1990,
+  yearMax: 1999,
+  ratingMin: 7,
+  durationMin: 60,
+  durationMax: 7200,
+  addedWithin: "1w",
+  directors: ["A"],
+  actors: ["B"],
+  actorMode: "all",
+  studios: ["C"],
+  playable: ["direct"],
+  keywords: ["heist"],
+  collections: ["123"],
+  collectionMode: "all",
+  collectionTitles: { "123": "Display only" },
+};
+
+describe("Plex filters on the wire", () => {
+  it("every key sent is a LibraryFilters field the backend reads", () => {
+    const src = readFileSync(resolve(__dirname, "../../../../backend/app/plex/query.py"), "utf-8");
+    const block = src.match(/class LibraryFilters:[\s\S]*?"""[\s\S]*?"""([\s\S]*?)def as_dict/);
+    expect(block, "plex/query.py no longer defines LibraryFilters").toBeTruthy();
+    const fields = new Set(
+      [...(block?.[1] ?? "").matchAll(/^\s{4}(\w+):/gm)].flatMap((m) => (m[1] ? [m[1]] : [])),
+    );
+    expect(fields.has("collection_mode")).toBe(true); // the parse found the real list
+
+    const sent = [...plexFiltersToParams(EVERYTHING).keys()];
+    expect(sent.filter((k) => !fields.has(k))).toEqual([]);
+    // Every filter in the set reached the wire (display-only titles excepted), so the check
+    // above saw them all.
+    expect(sent).toHaveLength(Object.keys(EVERYTHING).length - 1);
+  });
+});
diff --git a/frontend/src/lib/api/tagModes.ts b/frontend/src/lib/api/tagModes.ts
index 2282b53d..a8e67d28 100644
--- a/frontend/src/lib/api/tagModes.ts
+++ b/frontend/src/lib/api/tagModes.ts
@@ -2,8 +2,11 @@
 // URL (de)serializer, the sidebar comboboxes, and the saved-view migration. Kept in its own leaf (no
 // imports) so node-env tests and any module can pull it in without dragging the HTTP/i18n machinery.
 
-/** A tag category's match: "or" = a channel with ANY selected tag passes, "and" = it must carry ALL. */
-export type TagMode = "or" | "and";
+/**
+ * A tag category's match: "or" = a channel with ANY selected tag passes, "and" = it must carry ALL.
+ * @internal exported for its test
+ */
+type TagMode = "or" | "and";
 /** The three tag categories, each with its OWN independent match mode. */
 export type TagCategory = "language" | "topic" | "other";
 export type TagModes = Record<TagCategory, TagMode>;
diff --git a/frontend/src/lib/api/tags.ts b/frontend/src/lib/api/tags.ts
index e1f9ec2b..144eb30d 100644
--- a/frontend/src/lib/api/tags.ts
+++ b/frontend/src/lib/api/tags.ts
@@ -11,7 +11,7 @@ export interface Tag {
 }
 
 // One suggested user-tag for a channel, learned from the user's own manual-tag pattern (E8·S4).
-export interface TagSuggestion {
+interface TagSuggestion {
   tag_id: number;
   confidence: number;
 }
diff --git a/frontend/src/lib/brandIcons.ts b/frontend/src/lib/brandIcons.ts
new file mode 100644
index 00000000..59669785
--- /dev/null
+++ b/frontend/src/lib/brandIcons.ts
@@ -0,0 +1,16 @@
+import { createLucideIcon } from "lucide-react";
+
+// Brand marks the app draws itself. Lucide deprecated its brand icons and will remove them, so the
+// YouTube glyph is held here instead — the same 24×24 stroke paths as lucide's `Youtube` (v0.408,
+// ISC licence, © Lucide contributors), built with lucide's own factory so it takes the same props
+// (`className`, `size`, `strokeWidth`) and renders identically next to every other icon.
+export const YouTubeIcon = createLucideIcon("YouTube", [
+  [
+    "path",
+    {
+      d: "M2.5 17a24.12 24.12 0 0 1 0-10 2 2 0 0 1 1.4-1.4 49.56 49.56 0 0 1 16.2 0A2 2 0 0 1 21.5 7a24.12 24.12 0 0 1 0 10 2 2 0 0 1-1.4 1.4 49.55 49.55 0 0 1-16.2 0A2 2 0 0 1 2.5 17",
+      key: "1q2vi4",
+    },
+  ],
+  ["path", { d: "m10 15 5-3-5-3z", key: "1jp15x" }],
+]);
diff --git a/frontend/src/lib/chatDock.dom.test.ts b/frontend/src/lib/chatDock.dom.test.ts
new file mode 100644
index 00000000..adaf4e7f
--- /dev/null
+++ b/frontend/src/lib/chatDock.dom.test.ts
@@ -0,0 +1,52 @@
+// @vitest-environment jsdom
+//
+// The floating chat dock's store (E32 review: moved onto lib/store's createStore). It restores the
+// signed-in user's windows, keeps at most three, flashes a window a message arrives for, and
+// persists everything but the transient flash counter.
+import { describe, expect, it } from "vitest";
+import { act, renderHook } from "@testing-library/react";
+import {
+  closeChat,
+  initDock,
+  notifyIncoming,
+  openChat,
+  toggleMinimize,
+  useDockChats,
+} from "./chatDock";
+import { LS } from "./storage";
+
+const partner = (id: number) => ({ id, name: `P${id}`, avatar_url: null });
+
+describe("the chat dock", () => {
+  it("restores, caps, flashes and persists the user's windows", () => {
+    localStorage.setItem(
+      LS.chatDock(7),
+      JSON.stringify([{ partnerId: 1, name: "P1", avatar: null, minimized: true }]),
+    );
+    const { result } = renderHook(() => useDockChats());
+    act(() => initDock(7));
+    expect(result.current).toEqual([
+      { partnerId: 1, name: "P1", avatar: null, minimized: true, flash: 0 },
+    ]);
+
+    act(() => notifyIncoming(partner(1))); // already open: flash it, keep it minimised
+    expect(result.current[0]).toMatchObject({ partnerId: 1, minimized: true, flash: 1 });
+
+    act(() => {
+      for (const id of [2, 3, 4]) openChat(partner(id));
+    });
+    expect(result.current.map((c) => c.partnerId)).toEqual([4, 3, 2]); // newest first, three at most
+
+    act(() => toggleMinimize(3));
+    act(() => closeChat(2));
+    expect(result.current.map((c) => [c.partnerId, c.minimized])).toEqual([
+      [4, false],
+      [3, true],
+    ]);
+    const stored = JSON.parse(localStorage.getItem(LS.chatDock(7))!) as object[];
+    expect(stored).toEqual([
+      { partnerId: 4, name: "P4", avatar: null, minimized: false },
+      { partnerId: 3, name: "P3", avatar: null, minimized: true },
+    ]);
+  });
+});
diff --git a/frontend/src/lib/chatDock.ts b/frontend/src/lib/chatDock.ts
index 43558904..2f8216c6 100644
--- a/frontend/src/lib/chatDock.ts
+++ b/frontend/src/lib/chatDock.ts
@@ -2,8 +2,8 @@
 // A window can be opened from anywhere (a conversation's "pop out" button, or automatically
 // when a message arrives) and stays open across page navigation. The dock state (which chats
 // are open + their minimised state) is persisted per user so it survives a reload.
-import { useSyncExternalStore } from "react";
 import { LS } from "./storage";
+import { createStore } from "./store";
 
 export interface DockChat {
   partnerId: number;
@@ -16,9 +16,8 @@ export interface DockChat {
 type PartnerLike = { id: number; name: string; avatar_url: string | null };
 
 const MAX_OPEN = 3; // keep the dock from overflowing the corner
-let chats: DockChat[] = [];
+const dock = createStore<DockChat[]>([]);
 let userId: number | null = null;
-const subs = new Set<() => void>();
 
 function storageKey(): string | null {
   return userId != null ? LS.chatDock(userId) : null;
@@ -29,16 +28,15 @@ function persist(): void {
   if (!k) return;
   try {
     // Don't persist the transient flash counter.
-    localStorage.setItem(k, JSON.stringify(chats.map(({ flash, ...c }) => c)));
+    localStorage.setItem(k, JSON.stringify(dock.get().map(({ flash, ...c }) => c)));
   } catch {
     /* ignore quota/serialization errors */
   }
 }
 
 function emit(next: DockChat[]): void {
-  chats = next;
+  dock.set(next);
   persist();
-  for (const s of subs) s();
 }
 
 // Bind the dock to the signed-in user and restore their persisted windows (once per user).
@@ -53,15 +51,17 @@ export function initDock(uid: number): void {
   } catch {
     restored = [];
   }
-  chats = restored.slice(0, MAX_OPEN);
-  for (const s of subs) s();
+  dock.set(restored.slice(0, MAX_OPEN));
 }
 
 export function openChat(partner: PartnerLike): void {
-  const existing = chats.find((c) => c.partnerId === partner.id);
+  const existing = dock.get().find((c) => c.partnerId === partner.id);
   if (existing) {
     // Re-opening focuses it: ensure expanded and move to the front.
-    emit([{ ...existing, minimized: false }, ...chats.filter((c) => c.partnerId !== partner.id)]);
+    emit([
+      { ...existing, minimized: false },
+      ...dock.get().filter((c) => c.partnerId !== partner.id),
+    ]);
     return;
   }
   emit(
@@ -73,7 +73,7 @@ export function openChat(partner: PartnerLike): void {
         minimized: false,
         flash: 0,
       },
-      ...chats,
+      ...dock.get(),
     ].slice(0, MAX_OPEN),
   );
 }
@@ -81,7 +81,7 @@ export function openChat(partner: PartnerLike): void {
 // An incoming message arrived from `partner`: open the window if it's closed, otherwise just
 // flash it (whether expanded or minimised — don't disturb the minimised state).
 export function notifyIncoming(partner: PartnerLike): void {
-  const existing = chats.find((c) => c.partnerId === partner.id);
+  const existing = dock.get().find((c) => c.partnerId === partner.id);
   if (!existing) {
     emit(
       [
@@ -92,29 +92,22 @@ export function notifyIncoming(partner: PartnerLike): void {
           minimized: false,
           flash: 1,
         },
-        ...chats,
+        ...dock.get(),
       ].slice(0, MAX_OPEN),
     );
     return;
   }
-  emit(chats.map((c) => (c.partnerId === partner.id ? { ...c, flash: c.flash + 1 } : c)));
+  emit(dock.get().map((c) => (c.partnerId === partner.id ? { ...c, flash: c.flash + 1 } : c)));
 }
 
 export function closeChat(partnerId: number): void {
-  emit(chats.filter((c) => c.partnerId !== partnerId));
+  emit(dock.get().filter((c) => c.partnerId !== partnerId));
 }
 
 export function toggleMinimize(partnerId: number): void {
-  emit(chats.map((c) => (c.partnerId === partnerId ? { ...c, minimized: !c.minimized } : c)));
+  emit(dock.get().map((c) => (c.partnerId === partnerId ? { ...c, minimized: !c.minimized } : c)));
 }
 
 export function useDockChats(): DockChat[] {
-  return useSyncExternalStore(
-    (cb) => {
-      subs.add(cb);
-      return () => subs.delete(cb);
-    },
-    () => chats,
-    () => chats,
-  );
+  return dock.useValue();
 }
diff --git a/frontend/src/lib/clipboard.ts b/frontend/src/lib/clipboard.ts
index e559a6ff..ec751155 100644
--- a/frontend/src/lib/clipboard.ts
+++ b/frontend/src/lib/clipboard.ts
@@ -39,6 +39,7 @@ function legacyCopy(text: string): boolean {
   ta.style.height = "1px";
   ta.style.padding = "0";
   ta.style.border = "none";
+  // eslint-disable-next-line @typescript-eslint/no-deprecated -- the iOS-tested hidden-but-selectable textarea (see the header); not re-styled blind
   ta.style.clip = "rect(0, 0, 0, 0)";
   ta.style.userSelect = "text";
   ta.style.setProperty("-webkit-user-select", "text");
@@ -47,6 +48,7 @@ function legacyCopy(text: string): boolean {
     ta.focus();
     ta.select();
     ta.setSelectionRange(0, text.length); // iOS needs an explicit range
+    // eslint-disable-next-line @typescript-eslint/no-deprecated -- the only SYNCHRONOUS copy: iOS Safari needs it inside the click gesture, and a non-secure origin has no navigator.clipboard
     return document.execCommand("copy");
   } catch {
     return false;
diff --git a/frontend/src/lib/colorMath.ts b/frontend/src/lib/colorMath.ts
index c5d072f0..a58f6b19 100644
--- a/frontend/src/lib/colorMath.ts
+++ b/frontend/src/lib/colorMath.ts
@@ -34,6 +34,7 @@ export function hueGap(a: string, b: string): number {
 
 /** `color-mix(in srgb, a w, b)` for two opaque hex colours: the channels mix gamma-encoded, as the
  *  browser does in the srgb space. */
+/** @internal exported for theme.contract.test.ts */
 export function mixHex(a: string, b: string, w: number): string {
   const [x, y] = [rgb(a), rgb(b)];
   return `#${x
diff --git a/frontend/src/lib/debugRecorder.ts b/frontend/src/lib/debugRecorder.ts
index e8e266a7..4f0ec654 100644
--- a/frontend/src/lib/debugRecorder.ts
+++ b/frontend/src/lib/debugRecorder.ts
@@ -8,14 +8,14 @@ const startOpen = createStore(false);
 /** Open the start dialog (Settings → Diagnosztika, the palette). */
 export const openRecorderStart = (): void => startOpen.set(true);
 export const closeRecorderStart = (): void => startOpen.set(false);
-export const useRecorderStartOpen = (): boolean => startOpen.use();
+export const useRecorderStartOpen = (): boolean => startOpen.useValue();
 
 // The pill's step prompt — open, and what is typed in it — held here, not in the pill: the pill
 // rides the topmost toast host, and a dialog or the player opening or closing moves it to another
 // one (a remount). The prompt must come along with what was typed.
 const stepPrompt = createStore<string | null>(null);
 /** The step prompt's text while it is open, else null. */
-export const useStepPrompt = (): string | null => stepPrompt.use();
+export const useStepPrompt = (): string | null => stepPrompt.useValue();
 export const setStepPrompt = (text: string | null): void => stepPrompt.set(text);
 
 // Other tabs of this browser: a Start or a Stop in one is news to the rest, which otherwise learn of
@@ -42,7 +42,7 @@ const composing = createStore<string | null>(null);
 /** Open the issue composer for session `id` — after Stop, when the cap ends it, from Settings. */
 export const openComposer = (id: string): void => composing.set(id);
 export const closeComposer = (): void => composing.set(null);
-export const useComposerSession = (): string | null => composing.use();
+export const useComposerSession = (): string | null => composing.useValue();
 
 // Step markers are numbered per session. The count survives a reload (sessionStorage, per tab): a
 // reproduction is often "reload and it happens again", and step 4 coming back as step 1 would make
@@ -61,7 +61,7 @@ function readSteps(): Record<string, number> {
 const steps = createStore<Record<string, number>>(readSteps());
 
 /** How many steps session `id` has marked in this tab. */
-export const useStepCount = (id: string): number => steps.use()[id] ?? 0;
+export const useStepCount = (id: string): number => steps.useValue()[id] ?? 0;
 
 /** Take the next step number for session `id`. */
 export function nextStep(id: string): number {
diff --git a/frontend/src/lib/e2ee.test.ts b/frontend/src/lib/e2ee.test.ts
new file mode 100644
index 00000000..c7b3ac01
--- /dev/null
+++ b/frontend/src/lib/e2ee.test.ts
@@ -0,0 +1,180 @@
+// E32 S2: lib/e2ee was 14% covered, and every way it can break is silent — a message that will not
+// decrypt, a passphrase that unlocks nothing, a key that does not survive a reload. Real WebCrypto
+// (Node's), a minimal in-memory IndexedDB (the module uses open / one store / get / put / delete),
+// and a fresh module per "device", because the unlocked key is module state.
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { MyKeyBundle } from "./api";
+
+type E2ee = typeof import("./e2ee");
+
+function memoryIndexedDb() {
+  const stores = new Map<string, Map<unknown, unknown>>();
+  const later = (fn: () => void) => setTimeout(fn, 0);
+  const request = <T>(run: () => T) => {
+    const r: { result?: T; onsuccess?: () => void; onerror?: () => void } = {};
+    later(() => {
+      r.result = run();
+      r.onsuccess?.();
+    });
+    return r;
+  };
+  const db = {
+    createObjectStore: (name: string) => stores.set(name, new Map()),
+    transaction: (name: string) => {
+      const tx: { oncomplete?: () => void; onerror?: () => void; objectStore: () => unknown } = {
+        objectStore: () => {
+          const s = stores.get(name)!;
+          const done = <T>(v: T) => (later(() => tx.oncomplete?.()), v);
+          return {
+            get: (k: unknown) => request(() => s.get(k)),
+            put: (v: unknown, k: unknown) => done(s.set(k, v)),
+            delete: (k: unknown) => done(s.delete(k)),
+          };
+        },
+      };
+      return tx;
+    },
+  };
+  return {
+    open: () => {
+      const r: { result?: unknown; onupgradeneeded?: () => void; onsuccess?: () => void } = {};
+      later(() => {
+        r.result = db;
+        if (stores.size === 0) r.onupgradeneeded?.();
+        r.onsuccess?.();
+      });
+      return r;
+    },
+  };
+}
+
+async function freshDevice(): Promise<E2ee> {
+  vi.resetModules();
+  return import("./e2ee");
+}
+
+const bundleOf = (k: Awaited<ReturnType<E2ee["setup"]>>): MyKeyBundle =>
+  ({ ...k, has_key: true }) as unknown as MyKeyBundle;
+
+beforeEach(() => {
+  vi.stubGlobal("indexedDB", memoryIndexedDb());
+});
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe("e2ee", () => {
+  it("a message one user encrypts, the other decrypts — and nobody else", async () => {
+    const alice = await freshDevice();
+    const aliceKey = await alice.setup(1, "alice passphrase");
+    const bob = await freshDevice();
+    const bobKey = await bob.setup(2, "bob passphrase");
+
+    const msg = await alice.encryptFor(2, bobKey.public_key, "szia, Bob — ő 🎬");
+    expect(msg.ciphertext).not.toContain("Bob");
+    expect(await bob.decryptFrom(1, aliceKey.public_key, msg.ciphertext, msg.iv)).toBe(
+      "szia, Bob — ő 🎬",
+    );
+
+    const eve = await freshDevice();
+    await eve.setup(3, "eve passphrase");
+    await expect(eve.decryptFrom(1, aliceKey.public_key, msg.ciphertext, msg.iv)).rejects.toThrow();
+  }, 30_000);
+
+  it("each message gets its own IV", async () => {
+    const alice = await freshDevice();
+    await alice.setup(1, "p");
+    const bob = await freshDevice();
+    const bobKey = await bob.setup(2, "q");
+    const a = await alice.encryptFor(2, bobKey.public_key, "same");
+    const b = await alice.encryptFor(2, bobKey.public_key, "same");
+    expect(a.iv).not.toBe(b.iv);
+    expect(a.ciphertext).not.toBe(b.ciphertext);
+  }, 30_000);
+
+  it("a new device unlocks with the passphrase and refuses a wrong one", async () => {
+    const first = await freshDevice();
+    const bundle = bundleOf(await first.setup(1, "the right one"));
+
+    vi.stubGlobal("indexedDB", memoryIndexedDb()); // another browser: nothing stored
+    const second = await freshDevice();
+    expect(await second.loadFromDevice(1)).toBe(false);
+    await expect(second.unlock(1, "a wrong one", bundle)).rejects.toThrow();
+    expect(second.isUnlocked()).toBe(false);
+    await second.unlock(1, "the right one", bundle);
+    expect(second.isUnlocked()).toBe(true);
+  }, 30_000);
+
+  it("the unlocked key survives a reload on the same device, until it is reset", async () => {
+    const before = await freshDevice();
+    await before.setup(7, "p");
+    const after = await freshDevice(); // a reload: module state gone, IndexedDB kept
+    expect(after.isUnlocked()).toBe(false);
+    const seen = vi.fn();
+    after.subscribeUnlock(seen);
+    expect(await after.loadFromDevice(7)).toBe(true);
+    expect(after.isUnlocked()).toBe(true);
+    expect(seen).toHaveBeenCalled();
+
+    await after.resetLocal(7);
+    expect(after.isUnlocked()).toBe(false);
+    const again = await freshDevice();
+    expect(await again.loadFromDevice(7)).toBe(false);
+  }, 30_000);
+
+  it("an incomplete bundle and a locked device are refused, not guessed around", async () => {
+    const e = await freshDevice();
+    await expect(e.unlock(1, "p", { has_key: true } as unknown as MyKeyBundle)).rejects.toThrow(
+      "incomplete key bundle",
+    );
+    await expect(e.encryptFor(2, "AAAA", "x")).rejects.toThrow("locked");
+  });
+
+  it("the key check uses its own nonce, never the wrap IV (GCM nonce reuse)", async () => {
+    const e = await freshDevice();
+    const k = await e.setup(1, "p");
+    // Re-derive the wrap key the way the module does; then the key check must NOT open under the
+    // wrap IV (it would, were the nonce reused), while the wrapped key does.
+    const raw = (s: string) => Uint8Array.from(atob(s), (c) => c.charCodeAt(0));
+    const base = await crypto.subtle.importKey(
+      "raw",
+      new TextEncoder().encode("p"),
+      "PBKDF2",
+      false,
+      ["deriveKey"],
+    );
+    const wrapKey = await crypto.subtle.deriveKey(
+      { name: "PBKDF2", salt: raw(k.salt), iterations: 600_000, hash: "SHA-256" },
+      base,
+      { name: "AES-GCM", length: 256 },
+      false,
+      ["decrypt"],
+    );
+    const open = (ct: string) =>
+      crypto.subtle.decrypt({ name: "AES-GCM", iv: raw(k.wrap_iv) }, wrapKey, raw(ct));
+    await expect(open(k.wrapped_private_key)).resolves.toBeDefined();
+    await expect(open(k.key_check)).rejects.toThrow();
+  }, 30_000);
+
+  it("a partner's rotated key is used only after forgetConv", async () => {
+    const alice = await freshDevice();
+    const aliceKey = await alice.setup(1, "p");
+    const bobOld = await freshDevice();
+    const oldKey = await bobOld.setup(2, "q");
+    await alice.encryptFor(2, oldKey.public_key, "warm the cache");
+
+    const bobNew = await freshDevice(); // Bob reset his passphrase: a new keypair
+    const newKey = await bobNew.setup(2, "r");
+    // Cached by partner id alone: without forgetConv the OLD conversation key is still used…
+    const stale = await alice.encryptFor(2, newKey.public_key, "after the reset");
+    await expect(
+      bobNew.decryptFrom(1, aliceKey.public_key, stale.ciphertext, stale.iv),
+    ).rejects.toThrow();
+    // …and after it, the new one.
+    alice.forgetConv(2);
+    const fresh = await alice.encryptFor(2, newKey.public_key, "after the reset");
+    expect(await bobNew.decryptFrom(1, aliceKey.public_key, fresh.ciphertext, fresh.iv)).toBe(
+      "after the reset",
+    );
+  }, 60_000);
+});
diff --git a/frontend/src/lib/format.ts b/frontend/src/lib/format.ts
index 92a2999e..1ba32853 100644
--- a/frontend/src/lib/format.ts
+++ b/frontend/src/lib/format.ts
@@ -60,6 +60,7 @@ export function formatSpeed(bps: number | null | undefined, lang: string): strin
  * Module-level because it is constant, and exported so the tests can hold that invariant. */
 // A non-empty tuple type (first element + rest) so `RELATIVE_UNITS[0]` is known-present under
 // noUncheckedIndexedAccess — the "sub-minute" branch relies on that first entry always existing.
+/** @internal exported for format.test.ts */
 export const RELATIVE_UNITS: readonly [
   [number, Intl.RelativeTimeFormatUnit],
   ...[number, Intl.RelativeTimeFormatUnit][],
diff --git a/frontend/src/lib/gates.contract.test.ts b/frontend/src/lib/gates.contract.test.ts
new file mode 100644
index 00000000..b826c17d
--- /dev/null
+++ b/frontend/src/lib/gates.contract.test.ts
@@ -0,0 +1,590 @@
+import { createHash } from "node:crypto";
+import { readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ESLint, type Linter } from "eslint";
+import prettierConfig from "eslint-config-prettier";
+import { format, resolveConfig } from "prettier";
+import { parse as parseToml } from "smol-toml";
+import ts from "typescript";
+import tseslint from "typescript-eslint";
+import { describe, expect, it } from "vitest";
+
+// The gate register (docs/gates.md) is held to the EFFECTIVE configuration (E32). A narrowing that
+// is not on the register fails here — a rule switched off for a scope, a weak compiler flag, a ruff
+// ignore, a knip exclusion, an accepted CVE. So "the gate checks X" is a claim this test verifies,
+// not one a comment makes. (The comment that claimed the React Compiler's rules "are also linted"
+// stood for months while the rule that would have said so was off.)
+//
+// Each narrowing is a (scope, id) pair; the register must hold a table row whose first cell is the
+// scope and which names the id in backticks.
+
+const REPO = fileURLToPath(new URL("../../../", import.meta.url));
+const FRONTEND = `${REPO}frontend/`;
+const read = (path: string) => readFileSync(REPO + path, "utf8");
+
+/** register scope → every backticked id on its rows. */
+function register(): Map<string, Set<string>> {
+  const rows = new Map<string, Set<string>>();
+  for (const line of read("docs/gates.md").split("\n")) {
+    if (!line.startsWith("|") || /^\|(\s*-+\s*\|)+\s*$/.test(line)) continue; // not the |---| rule
+    // a row may cover several scopes the same way: `src tests · ui tests · lib tests`
+    for (const scope of line
+      .split("|")[1]!
+      .split(" · ")
+      .map((s) => s.trim())) {
+      const ids = rows.get(scope) ?? new Set<string>();
+      for (const m of line.matchAll(/`([^`]+)`/g)) ids.add(m[1]!);
+      rows.set(scope, ids);
+    }
+  }
+  return rows;
+}
+
+function missingFrom(found: [scope: string, id: string][]): string[] {
+  const reg = register();
+  return found.filter(([scope, id]) => !reg.get(scope)?.has(id)).map(([s, id]) => `${s}: ${id}`);
+}
+
+const jsonc = (path: string) => {
+  const { config, error } = ts.parseConfigFileTextToJson(path, read(path));
+  if (error)
+    throw new Error(`${path}: ${ts.flattenDiagnosticMessageText(error.messageText, "\n")}`);
+  return config as Record<string, unknown>;
+};
+
+// --- ESLint ---------------------------------------------------------------------------------------
+
+const severity = (v: Linter.RuleEntry | undefined): number => {
+  if (v === undefined) return -1; // not applied at all
+  const s = Array.isArray(v) ? v[0] : v;
+  return s === 2 || s === "error" ? 2 : s === 1 || s === "warn" ? 1 : 0;
+};
+// Formatting is Prettier's (its own lane): the rules eslint-config-prettier switches off are not a
+// narrowing of anything.
+const PRETTIER_OFF = new Set(
+  Object.entries(prettierConfig.rules ?? {})
+    .filter(([, v]) => severity(v as Linter.RuleEntry) === 0)
+    .map(([r]) => r),
+);
+// …and the core rules typescript-eslint's compatibility layer switches off for TS files because the
+// type checker reports them itself (no-undef, no-redeclare, no-dupe-keys, …).
+const TSC_OWNED = new Set(
+  Object.entries(tseslint.configs.eslintRecommended.rules ?? {})
+    .filter(([, v]) => severity(v as Linter.RuleEntry) === 0)
+    .map(([r]) => r),
+);
+const family = (rule: string) => (rule.includes("/") ? `${rule.split("/")[0]}/*` : rule);
+
+// A rule option whose key says it lets something through (`allowShortCircuit`,
+// `allowForKnownSafeCalls`, `ignoreRestSiblings`, `exceptAfterSingleLine`) narrows the rule, and a
+// `no-restricted-*` list re-declared for a scope narrows it by every entry it leaves out.
+const RELAXING_KEY = /^(allow|ignore|except)/;
+const relaxes = (options: unknown[]): boolean =>
+  options.some(
+    (o) =>
+      o !== null &&
+      typeof o === "object" &&
+      Object.entries(o).some(
+        ([k, v]) => RELAXING_KEY.test(k) && v !== false && !(Array.isArray(v) && v.length === 0),
+      ),
+  );
+function restrictedEntries(entry: Linter.RuleEntry | undefined): Set<string> {
+  const opts: unknown[] = Array.isArray(entry) ? entry.slice(1) : [];
+  const flat = opts.flatMap((o) => {
+    if (o === null || typeof o !== "object" || Array.isArray(o)) return [o];
+    const { paths = [], patterns = [] } = o as { paths?: unknown[]; patterns?: unknown[] };
+    return "paths" in o || "patterns" in o ? [...paths, ...patterns] : [o];
+  });
+  return new Set(flat.map((e) => JSON.stringify(e)));
+}
+
+// --- the snapshot ---------------------------------------------------------------------------------
+// The configs that can narrow a gate in more shapes than a check can enumerate are held to a
+// COMMITTED SNAPSHOT (E32 review): ESLint's effective config for every file `eslint .` reaches, and
+// the lines that run the lanes. Any change fails until the snapshot is regenerated, so a narrowing
+// arrives as a diff of `gates.snapshot.json` in review instead of slipping past a detector. (Three
+// review rounds kept finding shapes the detector this replaced did not model — a `basePath` global
+// ignore, a widened glob filed under a narrow row, a substring check on a CI line. A comparison
+// against everything has no shape to miss.)
+//
+// Regenerate:  GATE_SNAPSHOT=update npx vitest run src/lib/gates.contract.test.ts
+// then read the diff like any gate change. An ESLint config that changed keeps its scope name when
+// most of its files had it; one no name fits is written as `new config N` — rename it to the
+// register scope it is (the register test below then asks for its rows).
+
+const SNAPSHOT = "frontend/src/lib/gates.snapshot.json";
+const NOT_LINTED = "(not linted)";
+type EslintConfig = {
+  rules: Record<string, unknown[]>;
+  linterOptions: Record<string, unknown>;
+  languageOptions: Record<string, unknown>;
+  plugins: string[];
+  settings: unknown;
+};
+type Snapshot = {
+  eslint: { configs: Record<string, EslintConfig>; files: Record<string, string[]> };
+  lanes: Record<string, unknown>;
+};
+
+const sortKeys = (v: unknown): unknown =>
+  Array.isArray(v)
+    ? v.map(sortKeys)
+    : v !== null && typeof v === "object"
+      ? Object.fromEntries(
+          Object.keys(v)
+            .sort()
+            .map((k) => [k, sortKeys((v as Record<string, unknown>)[k])]),
+        )
+      : v;
+// through JSON, so a value compares as what the file can hold (a RegExp option is `{}` on both sides)
+const canonical = <T>(v: T): T => JSON.parse(JSON.stringify(sortKeys(v) ?? null)) as T;
+
+function normalize(cfg: Linter.Config): EslintConfig {
+  const lang = { ...(cfg.languageOptions ?? {}) } as Record<string, unknown>;
+  const parser = lang.parser as { meta?: { name?: string } } | undefined;
+  const parserOptions = { ...(lang.parserOptions as Record<string, unknown> | undefined) };
+  if (typeof parserOptions.tsconfigRootDir === "string")
+    // absolute: differs per machine
+    parserOptions.tsconfigRootDir = relative(FRONTEND, parserOptions.tsconfigRootDir) || ".";
+  // ~1200 browser globals per config: held by count and digest, not listed
+  const globals = Object.entries((lang.globals ?? {}) as Record<string, unknown>)
+    .map(([name, v]) => `${name}:${String(v)}`)
+    .sort();
+  const digest = createHash("sha1").update(globals.join("\n")).digest("hex").slice(0, 12);
+  return canonical({
+    languageOptions: {
+      ...lang,
+      parser: parser ? (parser.meta?.name ?? "(unnamed parser)") : null,
+      parserOptions,
+      globals: `${globals.length} names, sha1 ${digest}`,
+    },
+    linterOptions: (cfg.linterOptions ?? {}) as Record<string, unknown>,
+    plugins: Object.keys(cfg.plugins ?? {}).sort(),
+    settings: cfg.settings ?? null,
+    rules: Object.fromEntries(
+      Object.entries(cfg.rules ?? {}).map(([rule, v]) => [
+        rule,
+        Array.isArray(v) ? [severity(v), ...v.slice(1)] : [severity(v)],
+      ]),
+    ),
+  });
+}
+
+// Every code file `eslint .` walks into. The skipped directories are the global ignores' generated
+// output (the register's `everywhere` row) — untracked, and present on one machine but not another.
+// Every other file is asked for its config, so a file a new ignore drops lands in `(not linted)`.
+const WALK_SKIP = new Set([
+  "node_modules",
+  "dist",
+  "playwright-report",
+  "test-results",
+  "e2e/.auth",
+]);
+const CODE = /[.](?:[mc]?[jt]s|[jt]sx)$/;
+function codeFiles(dir = ""): string[] {
+  return readdirSync(FRONTEND + dir, { withFileTypes: true }).flatMap((d) => {
+    const path = dir + d.name;
+    if (d.isDirectory()) return WALK_SKIP.has(path) ? [] : codeFiles(`${path}/`);
+    return CODE.test(d.name) ? [path] : [];
+  });
+}
+
+// On disk every config but src is written as its difference from src — the rules it sets otherwise
+// and the src rules it does not apply — so a scope reads like its register rows, and one rule set
+// is not repeated fourteen times. In memory it is always whole.
+type Stored = Omit<EslintConfig, "rules"> & {
+  rules: Record<string, unknown[]>;
+  notApplied?: string[];
+};
+function toStored(configs: Record<string, EslintConfig>): Record<string, Stored> {
+  const src = configs.src?.rules;
+  if (!src) return configs;
+  return Object.fromEntries(
+    Object.entries(configs).map(([name, cfg]) => {
+      if (name === "src") return [name, cfg];
+      const rules = Object.fromEntries(
+        Object.entries(cfg.rules).filter(([r, v]) => JSON.stringify(v) !== JSON.stringify(src[r])),
+      );
+      return [
+        name,
+        { ...cfg, rules, notApplied: Object.keys(src).filter((r) => !(r in cfg.rules)) },
+      ];
+    }),
+  );
+}
+function fromStored(stored: Record<string, Stored>): Record<string, EslintConfig> {
+  const src = stored.src?.rules ?? {};
+  return Object.fromEntries(
+    Object.entries(stored).map(([name, { notApplied, ...cfg }]) => {
+      if (!notApplied) return [name, cfg];
+      const rules = { ...src, ...cfg.rules };
+      for (const r of notApplied) delete rules[r];
+      return [name, canonical({ ...cfg, rules })];
+    }),
+  );
+}
+const committed = (): Snapshot => {
+  const s = JSON.parse(read(SNAPSHOT)) as Snapshot & {
+    eslint: { configs: Record<string, Stored> };
+  };
+  return canonical({ ...s, eslint: { ...s.eslint, configs: fromStored(s.eslint.configs) } });
+};
+
+async function eslintActual(names: Snapshot["eslint"]): Promise<Snapshot["eslint"]> {
+  const eslint = new ESLint({ cwd: FRONTEND });
+  const groups = new Map<string, { config: EslintConfig; files: string[] }>();
+  const notLinted: string[] = [];
+  for (const file of codeFiles().sort()) {
+    const raw = (await eslint.calculateConfigForFile(file)) as Linter.Config | undefined;
+    if (!raw) {
+      notLinted.push(file);
+      continue;
+    }
+    const config = normalize(raw);
+    const key = JSON.stringify(config);
+    const group = groups.get(key) ?? { config, files: [] };
+    group.files.push(file);
+    groups.set(key, group);
+  }
+  // a config is named by the snapshot entry it equals; a changed one by the old name most of its
+  // files had (if still free), so the diff shows the rule that moved, not a renamed scope
+  const byContent = new Map(Object.entries(names.configs).map(([n, c]) => [JSON.stringify(c), n]));
+  const oldName = new Map(
+    Object.entries(names.files).flatMap(([n, files]) => files.map((f) => [f, n] as const)),
+  );
+  const configs: Record<string, EslintConfig> = {};
+  const files: Record<string, string[]> = { [NOT_LINTED]: notLinted };
+  const unnamed: { config: EslintConfig; files: string[] }[] = [];
+  for (const [key, group] of groups) {
+    const name = byContent.get(key);
+    if (name) [configs[name], files[name]] = [group.config, group.files];
+    else unnamed.push(group);
+  }
+  unnamed.forEach((group, i) => {
+    const votes = new Map<string, number>();
+    for (const f of group.files) {
+      const n = oldName.get(f);
+      if (n && n !== NOT_LINTED) votes.set(n, (votes.get(n) ?? 0) + 1);
+    }
+    const best = [...votes].sort((a, b) => b[1] - a[1])[0]?.[0];
+    const name = best && !(best in configs) ? best : `new config ${i + 1}`;
+    [configs[name], files[name]] = [group.config, group.files];
+  });
+  return canonical({ configs, files });
+}
+
+// the lines that run each lane, comments and blank lines aside
+function meaningful(path: string): string[] {
+  return read(path)
+    .split("\n")
+    .map((l) => l.trimEnd())
+    .filter((l) => {
+      const t = l.trim();
+      return t !== "" && !/^(#|\/\/|\/\*|\*)/.test(t);
+    });
+}
+const lanes = () => ({
+  ".gitea/workflows/check.yml": meaningful(".gitea/workflows/check.yml"),
+  "backend/docker-compose.test.yml": meaningful("backend/docker-compose.test.yml"),
+  "backend/Dockerfile.test": meaningful("backend/Dockerfile.test"),
+  "frontend/package.json scripts": (
+    JSON.parse(read("frontend/package.json")) as { scripts: Record<string, string> }
+  ).scripts,
+  "frontend/vitest.config.ts": meaningful("frontend/vitest.config.ts"),
+  "frontend/.prettierignore": meaningful("frontend/.prettierignore"),
+});
+
+let actual: Promise<Snapshot> | undefined;
+const current = () =>
+  (actual ??= (async () =>
+    canonical({ eslint: await eslintActual(committed().eslint), lanes: lanes() }))());
+
+// --- the register, read off the snapshot ------------------------------------------------------------
+
+const ignorable = (rule: string, all: Record<string, unknown>) =>
+  PRETTIER_OFF.has(rule) ||
+  TSC_OWNED.has(rule) ||
+  // a core rule off because its typescript-eslint twin replaces it is reported as the twin
+  (!rule.includes("/") && `@typescript-eslint/${rule}` in all);
+const entry = (v: unknown[] | undefined) => v as Linter.RuleEntry | undefined;
+
+/** Every narrowing in the effective ESLint configs, as (scope, id). */
+function eslintNarrowings({ configs, files }: Snapshot["eslint"]): [string, string][] {
+  const found: [string, string][] = files[NOT_LINTED]!.map((f) => [
+    "everywhere",
+    `${f} — not linted`,
+  ]);
+  const src = configs.src?.rules;
+  if (!src) return [...found, ["src", "(no config named src)"]];
+  for (const [scope, { rules, linterOptions }] of Object.entries(configs)) {
+    // an unused `eslint-disable` is an error on every file, or a stale suppression stays armed
+    if (severity(linterOptions.reportUnusedDisableDirectives as Linter.RuleEntry) !== 2)
+      found.push([scope, "reportUnusedDisableDirectives"]);
+    const ids = new Set<string>();
+    for (const [rule, v] of Object.entries(rules)) {
+      if (ignorable(rule, rules)) continue;
+      const mine = entry(v)!;
+      const theirs = scope === "src" ? undefined : entry(src[rule]);
+      const relaxed = relaxes(v.slice(1)) && JSON.stringify(v) !== JSON.stringify(src[rule]);
+      if (theirs === undefined) {
+        // src, or a rule src does not have (the test and e2e plugins): at off or warn, or relaxed
+        if (severity(mine) < 2 || (scope === "src" ? relaxes(v.slice(1)) : relaxed)) ids.add(rule);
+      } else if (severity(mine) < severity(theirs)) ids.add(rule);
+      else if (rule.includes("no-restricted-")) {
+        const own = restrictedEntries(mine);
+        if ([...restrictedEntries(theirs)].some((e) => !own.has(e))) ids.add(rule);
+      } else if (relaxed) ids.add(rule);
+    }
+    // a src rule not applied at all here: one id for its whole family
+    if (scope !== "src")
+      for (const [rule, v] of Object.entries(src))
+        if (!(rule in rules) && !ignorable(rule, src) && severity(entry(v)) > 0)
+          ids.add(family(rule));
+    for (const id of ids) found.push([scope, id]);
+  }
+  return found;
+}
+
+describe("the gate snapshot (gates.snapshot.json)", () => {
+  it("holds the effective ESLint config of every file and the lines that run each lane", async () => {
+    const now = await current();
+    if (process.env.GATE_SNAPSHOT === "update") {
+      const path = REPO + SNAPSHOT;
+      const options = { ...(await resolveConfig(path)), filepath: path };
+      const stored = { ...now, eslint: { ...now.eslint, configs: toStored(now.eslint.configs) } };
+      writeFileSync(path, await format(JSON.stringify(sortKeys(stored)), options));
+      return;
+    }
+    expect(now).toEqual(committed());
+  }, 120_000);
+});
+
+describe("the gate register (docs/gates.md)", () => {
+  it("lists every ESLint rule narrowed, by scope", async () => {
+    expect(missingFrom(eslintNarrowings((await current()).eslint))).toEqual([]);
+  }, 120_000);
+
+  it("keeps --max-warnings 0, which is what makes a warn-level rule fail", () => {
+    const pkg = JSON.parse(read("frontend/package.json")) as { scripts: Record<string, string> };
+    expect(pkg.scripts.lint).toBe("eslint . --max-warnings 0");
+  });
+
+  // --- TypeScript ---------------------------------------------------------------------------------
+  const PROJECTS = [
+    "frontend/tsconfig.json",
+    "frontend/tsconfig.node.json",
+    "frontend/e2e/tsconfig.json",
+  ];
+  const REQUIRED_ON = [
+    "strict",
+    "noUncheckedIndexedAccess",
+    "noUnusedLocals",
+    "noUnusedParameters",
+    "noFallthroughCasesInSwitch",
+  ];
+  it.each(PROJECTS)("%s keeps the strict flags on", (path) => {
+    const opts = jsonc(path).compilerOptions as Record<string, unknown>;
+    expect(REQUIRED_ON.filter((flag) => opts[flag] !== true)).toEqual([]);
+  });
+  // `strict: true` is a bundle: a sub-flag set false beside it, an `extends` this test cannot see
+  // through, or a narrowed `include` / an `exclude` weakens the project while the five flags above
+  // still read true (E32 review).
+  const STRICT_FAMILY = [
+    "noImplicitAny",
+    "strictNullChecks",
+    "strictFunctionTypes",
+    "strictBindCallApply",
+    "strictPropertyInitialization",
+    "noImplicitThis",
+    "alwaysStrict",
+    "useUnknownInCatchVariables",
+    "strictBuiltinIteratorReturn",
+  ];
+  const INCLUDE: Record<string, string[]> = {
+    "frontend/tsconfig.json": ["src"],
+    "frontend/tsconfig.node.json": [
+      "vite.config.ts",
+      "vitest.config.ts",
+      "reactPlugin.ts",
+      "devOnlyGuard.ts",
+      "playwright.config.ts",
+      "postcss.config.js",
+    ],
+    "frontend/e2e/tsconfig.json": [".", "../playwright.config.ts"],
+  };
+  it("lists every weakening compiler flag", () => {
+    const found: [string, string][] = [];
+    for (const path of PROJECTS) {
+      const cfg = jsonc(path);
+      const opts = cfg.compilerOptions as Record<string, unknown>;
+      if (opts.skipLibCheck === true) found.push(["all three projects", "skipLibCheck"]);
+      for (const flag of STRICT_FAMILY) if (opts[flag] === false) found.push([path, flag]);
+      for (const key of ["extends", "exclude", "files"]) if (key in cfg) found.push([path, key]);
+      expect(cfg.include, path).toEqual(INCLUDE[path]);
+    }
+    expect(missingFrom(found)).toEqual([]);
+  });
+  it("type-checks every config file at the frontend root, or lists it", () => {
+    const checked = new Set(INCLUDE["frontend/tsconfig.node.json"]);
+    const roots = readdirSync(FRONTEND).filter((f) => /[.](ts|js|mjs|cjs)$/.test(f));
+    const found = roots
+      .filter((f) => !checked.has(f))
+      .map((f): [string, string] => ["config files", `${f} — not type-checked`]);
+    expect(missingFrom(found)).toEqual([]);
+    // a `.js` in `include` is dropped without a word unless allowJs, and read unchecked without
+    // checkJs (E32 review round 2)
+    const opts = jsonc("frontend/tsconfig.node.json").compilerOptions as Record<string, unknown>;
+    if ([...checked].some((f) => /[.][mc]?js$/.test(f)))
+      expect([opts.allowJs, opts.checkJs]).toEqual([true, true]);
+  });
+
+  // --- Ruff -----------------------------------------------------------------------------------------
+  // Ruff, pyright, pytest and knip are read as whitelists: a key this test does not know (an
+  // `extend-exclude`, a `lint.extend-ignore`, a narrowing `select`, a pyright `exclude`, a pytest
+  // `-m "not slow"`, a knip `rules`) fails until someone decides whether it narrows (E32 review —
+  // only `ignore` and the immutable calls used to be read). The TOML is PARSED, not scanned line by
+  // line: a `[lint.per-file-ignores]` table or a quoted key is a key path like any other (E32 review
+  // round 2 — a line regex saw neither).
+  const keyPaths = (o: Record<string, unknown>, prefix = ""): string[] =>
+    Object.entries(o).flatMap(([k, v]) =>
+      v !== null && typeof v === "object" && !Array.isArray(v)
+        ? keyPaths(v as Record<string, unknown>, `${prefix}${k}.`)
+        : [`${prefix}${k}`],
+    );
+  it("lists every ruff ignore and immutable call, and knows every key", () => {
+    const cfg = parseToml(read("backend/ruff.toml"));
+    expect(keyPaths(cfg).sort()).toEqual(
+      [
+        "lint.extend-select",
+        "lint.flake8-bugbear.extend-immutable-calls",
+        "line-length",
+        "target-version",
+      ].sort(),
+    );
+    const lint = cfg.lint as Record<string, unknown>;
+    // the selection on top of ruff's defaults (E, F) — dropping one narrows the lane
+    expect(lint["extend-select"]).toEqual([
+      "LOG",
+      "G",
+      "T20",
+      "TRY400",
+      "TRY401",
+      "S110",
+      "S112",
+      "BLE001",
+      "RUF100",
+      "PLW1510",
+      "B",
+    ]);
+    const immutable = (lint["flake8-bugbear"] as Record<string, string[]>)[
+      "extend-immutable-calls"
+    ]!;
+    const found = immutable.map((c): [string, string] => ["backend + scripts", c]);
+    expect(missingFrom(found)).toEqual([]);
+  });
+  // Every ruff lane passes `--config backend/ruff.toml`, which makes ruff ignore any other config
+  // file it would discover (measured: a nested `ruff.toml` selecting the `D` rules changed nothing).
+  // So that flag is what makes this file the whole configuration. The snapshot holds every CI line;
+  // these two are spelled out here because the reason is (round 3: a substring check let an extra
+  // `--config "lint.extend-ignore=…"` override through).
+  it("runs every CI ruff step on backend/ruff.toml and nothing else", () => {
+    const steps = read(".gitea/workflows/check.yml")
+      .split("\n")
+      .filter((l) => /\bruff\b/.test(l) && !l.trim().startsWith("#"))
+      .map((l) => l.trim());
+    expect(steps).toEqual([
+      "- name: ruff",
+      "run: python -m ruff check --config backend/ruff.toml backend scripts",
+      "- name: ruff format --check",
+      "run: python -m ruff format --check --config backend/ruff.toml backend scripts",
+    ]);
+  });
+
+  // --- basedpyright ---------------------------------------------------------------------------------
+  const PYRIGHT_KEYS = [
+    "include",
+    "extraPaths",
+    "typeCheckingMode",
+    "pythonVersion",
+    "pythonPlatform",
+  ];
+  it("lists the type-check mode, the baseline and every rule override, and knows every key", () => {
+    const cfg = jsonc("backend/pyrightconfig.json");
+    const found: [string, string][] = [];
+    if (cfg.typeCheckingMode !== "all" && cfg.typeCheckingMode !== "strict")
+      found.push(["backend/app + alembic", "typeCheckingMode"]);
+    found.push(["backend/app + alembic", "baseline.json"]);
+    const weak = [false, "none", "warning", "information", "hint"];
+    for (const [key, value] of Object.entries(cfg))
+      if (key.startsWith("report") && weak.includes(value as string | boolean))
+        found.push(["backend/app + alembic", key]);
+    expect(
+      Object.keys(cfg).filter((k) => !k.startsWith("report") && !PYRIGHT_KEYS.includes(k)),
+    ).toEqual([]);
+    expect(cfg.include).toEqual(["app", "alembic"]); // tests/ out — its row says why
+    expect(missingFrom(found)).toEqual([]);
+  });
+
+  // --- pytest ---------------------------------------------------------------------------------------
+  // Held line by line, not key by key: pytest's ini reader also takes `key: value` and indented
+  // continuation lines (`addopts = -q` + `    -m "not slow"`), and a key regex saw neither (E32 review
+  // round 2). Every line that is not blank or a comment must be one of these, and all must be there.
+  it("keeps pytest strict: the whole tests/ tree, no selection, no warning filters, --strict-markers", () => {
+    const lines = read("backend/pytest.ini")
+      .split("\n")
+      .map((l) => l.trimEnd())
+      .filter((l) => l.trim() !== "" && !/^[#;]/.test(l.trim()));
+    expect(lines).toEqual([
+      "[pytest]",
+      "testpaths = tests",
+      "pythonpath = .",
+      "addopts = -q -rs --strict-markers",
+    ]);
+  });
+
+  // --- knip -----------------------------------------------------------------------------------------
+  it("lists every knip production exclusion and every other key, and runs both modes", () => {
+    const cfg = jsonc("frontend/knip.jsonc") as { project?: string[] } & Record<string, unknown>;
+    const found: [string, string][] = (cfg.project ?? [])
+      .filter((p) => p.startsWith("!"))
+      .map((p): [string, string] => ["--production", p]);
+    for (const key of Object.keys(cfg).filter(
+      (k) => !["$schema", "project", "playwright"].includes(k),
+    ))
+      found.push(["knip", key]);
+    expect(missingFrom(found)).toEqual([]);
+    const pkg = JSON.parse(read("frontend/package.json")) as { scripts: Record<string, string> };
+    expect(pkg.scripts.knip).toBe("knip && knip --production");
+    // the positive pattern is the project itself: narrowing it drops files from both modes
+    expect((cfg.project ?? []).filter((p) => !p.startsWith("!"))).toEqual(["**/*.{ts,tsx,js}!"]);
+    // and knip.jsonc is the config knip reads: a knip.json (read first) or a package.json `knip` key
+    // (merged in) would narrow it unseen (E32 review round 3)
+    const KNIP_FILES = /^\.?knip(\.config)?\.(json|jsonc|js|ts|mjs|cjs|mts|cts|toml|ya?ml)$/;
+    expect(readdirSync(FRONTEND).filter((f) => KNIP_FILES.test(f))).toEqual(["knip.jsonc"]);
+    expect("knip" in pkg).toBe(false);
+  });
+
+  // --- accepted findings ----------------------------------------------------------------------------
+  it("accepts a CVE only with a statement, an expiry, and a row", () => {
+    const yaml = read(".trivyignore.yaml");
+    const entries = yaml
+      .split(/\n\s*- id:\s*/)
+      .slice(1)
+      .map((chunk) => ({
+        id: chunk.split("\n")[0]!.trim(),
+        statement: /\n\s*statement:\s*\S/.test(chunk),
+        expires: /\n\s*expired_at:\s*\d{4}-\d{2}-\d{2}/.test(chunk),
+      }));
+    expect(entries.filter((e) => !e.statement || !e.expires).map((e) => e.id)).toEqual([]);
+    const pipIgnores = read(".gitea/workflows/check.yml")
+      .split("\n")
+      .filter((l) => !l.trim().startsWith("#")) // the step's comment explains the flag; it is not one
+      .flatMap((l) => [...l.matchAll(/--ignore-vuln[ =](\S+)/g)].map((m) => m[1]!));
+    const found = [...entries.map((e) => e.id), ...pipIgnores].map((id): [string, string] => [
+      "accepted",
+      id,
+    ]);
+    expect(missingFrom(found)).toEqual([]);
+  });
+});
diff --git a/frontend/src/lib/gates.snapshot.json b/frontend/src/lib/gates.snapshot.json
new file mode 100644
index 00000000..502789dc
--- /dev/null
+++ b/frontend/src/lib/gates.snapshot.json
@@ -0,0 +1,2371 @@
+{
+  "eslint": {
+    "configs": {
+      "FocusSafeButton.tsx + AnchoredPopover.tsx": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "1169 names, sha1 aee621727a03",
+          "parser": "typescript-eslint/parser",
+          "parserOptions": { "projectService": true, "tsconfigRootDir": "." },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "notApplied": [],
+        "plugins": [
+          "@",
+          "@eslint-community/eslint-comments",
+          "@typescript-eslint",
+          "local",
+          "react-hooks",
+          "react-refresh"
+        ],
+        "rules": {
+          "local/focus-safe-disabled": [0],
+          "no-restricted-imports": [
+            2,
+            {
+              "patterns": [
+                {
+                  "message": "components/ui/ is domain-free: a platform component may not import a feature component. Invert the dependency (take a prop/render-prop) or keep the component outside ui/.",
+                  "regex": "^\\.\\./(?!\\.\\./)"
+                },
+                {
+                  "message": "components/ui/ is domain-free: a platform component may not import a feature component. Invert the dependency (take a prop/render-prop) or keep the component outside ui/.",
+                  "regex": "^\\.\\./\\.\\./components/(?!ui/)"
+                },
+                {
+                  "message": "components/ui/ is domain-free: a platform component may not call a domain API slice. Take the data as props.",
+                  "regex": "^\\.\\./\\.\\./lib/api(/|$)"
+                }
+              ]
+            }
+          ]
+        },
+        "settings": null
+      },
+      "design-lab": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "1169 names, sha1 aee621727a03",
+          "parser": "typescript-eslint/parser",
+          "parserOptions": { "projectService": true, "tsconfigRootDir": "." },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "notApplied": [],
+        "plugins": [
+          "@",
+          "@eslint-community/eslint-comments",
+          "@typescript-eslint",
+          "local",
+          "react-hooks",
+          "react-refresh"
+        ],
+        "rules": { "local/literal-a11y-text": [0] },
+        "settings": null
+      },
+      "e2e": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "82 names, sha1 29467d490e30",
+          "parser": "typescript-eslint/parser",
+          "parserOptions": { "projectService": true, "tsconfigRootDir": "." },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "notApplied": [
+          "local/button-primitive",
+          "local/focus-safe-disabled",
+          "local/glyph-link",
+          "local/input-primitive",
+          "local/jsx-comment-text",
+          "local/literal-a11y-text",
+          "local/locale-format",
+          "local/sortable-a11y",
+          "local/surface-role",
+          "no-console",
+          "no-restricted-globals",
+          "no-restricted-properties",
+          "no-restricted-syntax",
+          "react-hooks/capitalized-calls",
+          "react-hooks/component-hook-factories",
+          "react-hooks/config",
+          "react-hooks/error-boundaries",
+          "react-hooks/exhaustive-deps",
+          "react-hooks/exhaustive-effect-dependencies",
+          "react-hooks/gating",
+          "react-hooks/globals",
+          "react-hooks/hooks",
+          "react-hooks/immutability",
+          "react-hooks/incompatible-library",
+          "react-hooks/invariant",
+          "react-hooks/memo-dependencies",
+          "react-hooks/memoized-effect-dependencies",
+          "react-hooks/no-deriving-state-in-effects",
+          "react-hooks/preserve-manual-memoization",
+          "react-hooks/purity",
+          "react-hooks/refs",
+          "react-hooks/rule-suppression",
+          "react-hooks/rules-of-hooks",
+          "react-hooks/set-state-in-effect",
+          "react-hooks/set-state-in-render",
+          "react-hooks/static-components",
+          "react-hooks/syntax",
+          "react-hooks/todo",
+          "react-hooks/unsupported-syntax",
+          "react-hooks/use-memo",
+          "react-hooks/void-use-memo",
+          "react-refresh/only-export-components"
+        ],
+        "plugins": ["@", "@eslint-community/eslint-comments", "@typescript-eslint", "playwright"],
+        "rules": {
+          "@typescript-eslint/no-unused-expressions": [
+            2,
+            { "allowShortCircuit": false, "allowTaggedTemplates": false, "allowTernary": false }
+          ],
+          "playwright/no-focused-test": [2],
+          "playwright/no-skipped-test": [2]
+        },
+        "settings": null
+      },
+      "js configs": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "82 names, sha1 29467d490e30",
+          "parser": "(unnamed parser)",
+          "parserOptions": { "sourceType": "module" },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "notApplied": [
+          "@typescript-eslint/ban-ts-comment",
+          "@typescript-eslint/no-array-constructor",
+          "@typescript-eslint/no-deprecated",
+          "@typescript-eslint/no-duplicate-enum-values",
+          "@typescript-eslint/no-empty-object-type",
+          "@typescript-eslint/no-explicit-any",
+          "@typescript-eslint/no-extra-non-null-assertion",
+          "@typescript-eslint/no-floating-promises",
+          "@typescript-eslint/no-misused-new",
+          "@typescript-eslint/no-namespace",
+          "@typescript-eslint/no-non-null-asserted-optional-chain",
+          "@typescript-eslint/no-require-imports",
+          "@typescript-eslint/no-this-alias",
+          "@typescript-eslint/no-unnecessary-type-constraint",
+          "@typescript-eslint/no-unsafe-declaration-merging",
+          "@typescript-eslint/no-unsafe-function-type",
+          "@typescript-eslint/no-unused-expressions",
+          "@typescript-eslint/no-unused-vars",
+          "@typescript-eslint/no-wrapper-object-types",
+          "@typescript-eslint/prefer-as-const",
+          "@typescript-eslint/prefer-namespace-keyword",
+          "@typescript-eslint/triple-slash-reference",
+          "local/button-primitive",
+          "local/focus-safe-disabled",
+          "local/glyph-link",
+          "local/input-primitive",
+          "local/jsx-comment-text",
+          "local/literal-a11y-text",
+          "local/locale-format",
+          "local/sortable-a11y",
+          "local/surface-role",
+          "no-array-constructor",
+          "no-console",
+          "no-new-symbol",
+          "no-restricted-globals",
+          "no-restricted-properties",
+          "no-restricted-syntax",
+          "no-unused-expressions",
+          "no-var",
+          "prefer-const",
+          "prefer-rest-params",
+          "prefer-spread",
+          "react-hooks/capitalized-calls",
+          "react-hooks/component-hook-factories",
+          "react-hooks/config",
+          "react-hooks/error-boundaries",
+          "react-hooks/exhaustive-deps",
+          "react-hooks/exhaustive-effect-dependencies",
+          "react-hooks/gating",
+          "react-hooks/globals",
+          "react-hooks/hooks",
+          "react-hooks/immutability",
+          "react-hooks/incompatible-library",
+          "react-hooks/invariant",
+          "react-hooks/memo-dependencies",
+          "react-hooks/memoized-effect-dependencies",
+          "react-hooks/no-deriving-state-in-effects",
+          "react-hooks/preserve-manual-memoization",
+          "react-hooks/purity",
+          "react-hooks/refs",
+          "react-hooks/rule-suppression",
+          "react-hooks/rules-of-hooks",
+          "react-hooks/set-state-in-effect",
+          "react-hooks/set-state-in-render",
+          "react-hooks/static-components",
+          "react-hooks/syntax",
+          "react-hooks/todo",
+          "react-hooks/unsupported-syntax",
+          "react-hooks/use-memo",
+          "react-hooks/void-use-memo",
+          "react-refresh/only-export-components"
+        ],
+        "plugins": ["@", "@eslint-community/eslint-comments"],
+        "rules": {
+          "constructor-super": [2],
+          "getter-return": [2, { "allowImplicit": false }],
+          "no-class-assign": [2],
+          "no-const-assign": [2],
+          "no-dupe-args": [2],
+          "no-dupe-class-members": [2],
+          "no-dupe-keys": [2],
+          "no-func-assign": [2],
+          "no-import-assign": [2],
+          "no-new-native-nonconstructor": [2],
+          "no-obj-calls": [2],
+          "no-redeclare": [2, { "builtinGlobals": true }],
+          "no-setter-return": [2],
+          "no-this-before-super": [2],
+          "no-undef": [2, { "typeof": false }],
+          "no-unreachable": [2],
+          "no-unsafe-negation": [2, { "enforceForOrderingRelations": false }],
+          "no-unused-vars": [2],
+          "no-with": [2]
+        },
+        "settings": null
+      },
+      "lib tests": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "1169 names, sha1 aee621727a03",
+          "parser": "typescript-eslint/parser",
+          "parserOptions": { "projectService": true, "tsconfigRootDir": "." },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "notApplied": [],
+        "plugins": [
+          "@",
+          "@eslint-community/eslint-comments",
+          "@typescript-eslint",
+          "local",
+          "react-hooks",
+          "react-refresh",
+          "vitest"
+        ],
+        "rules": {
+          "local/button-primitive": [0],
+          "local/glyph-link": [0],
+          "local/input-primitive": [0],
+          "local/literal-a11y-text": [0],
+          "local/surface-role": [0],
+          "no-restricted-globals": [
+            0,
+            {
+              "message": "Use the logged request layer: `fetch` belongs to src/lib/http.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "fetch"
+            },
+            {
+              "message": "Use the logged request layer: `XMLHttpRequest` belongs to src/lib/api/core.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "XMLHttpRequest"
+            },
+            {
+              "message": "Use the logged request layer: `WebSocket` belongs to src/lib/messagesSocket.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "WebSocket"
+            },
+            {
+              "message": "No `EventSource` without a logged owner module (E22 S4).",
+              "name": "EventSource"
+            }
+          ],
+          "no-restricted-imports": [
+            2,
+            {
+              "patterns": [
+                {
+                  "message": "lib/ sits below components/: it may not import from components/, not even a type. Move the shared piece down into lib/.",
+                  "regex": "^(\\.\\./)+components(/|$)"
+                }
+              ]
+            }
+          ],
+          "no-restricted-properties": [
+            0,
+            {
+              "message": "Use lib/http.ts `send` (E22 S4).",
+              "object": "window",
+              "property": "fetch"
+            },
+            {
+              "message": "Use lib/http.ts `send` (E22 S4).",
+              "object": "globalThis",
+              "property": "fetch"
+            },
+            {
+              "message": "Use lib/api/core.ts `beacon` (E22 S4).",
+              "object": "navigator",
+              "property": "sendBeacon"
+            }
+          ],
+          "vitest/no-disabled-tests": [2],
+          "vitest/no-focused-tests": [2, { "fixable": true }]
+        },
+        "settings": null
+      },
+      "lib/api/core.ts": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "1169 names, sha1 aee621727a03",
+          "parser": "typescript-eslint/parser",
+          "parserOptions": { "projectService": true, "tsconfigRootDir": "." },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "notApplied": [],
+        "plugins": [
+          "@",
+          "@eslint-community/eslint-comments",
+          "@typescript-eslint",
+          "local",
+          "react-hooks",
+          "react-refresh"
+        ],
+        "rules": {
+          "no-restricted-globals": [
+            2,
+            {
+              "message": "Use the logged request layer: `fetch` belongs to src/lib/http.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "fetch"
+            },
+            {
+              "message": "Use the logged request layer: `WebSocket` belongs to src/lib/messagesSocket.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "WebSocket"
+            },
+            {
+              "message": "No `EventSource` without a logged owner module (E22 S4).",
+              "name": "EventSource"
+            }
+          ],
+          "no-restricted-imports": [
+            2,
+            {
+              "patterns": [
+                {
+                  "message": "lib/ sits below components/: it may not import from components/, not even a type. Move the shared piece down into lib/.",
+                  "regex": "^(\\.\\./)+components(/|$)"
+                }
+              ]
+            }
+          ]
+        },
+        "settings": null
+      },
+      "lib/http.ts": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "1169 names, sha1 aee621727a03",
+          "parser": "typescript-eslint/parser",
+          "parserOptions": { "projectService": true, "tsconfigRootDir": "." },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "notApplied": [],
+        "plugins": [
+          "@",
+          "@eslint-community/eslint-comments",
+          "@typescript-eslint",
+          "local",
+          "react-hooks",
+          "react-refresh"
+        ],
+        "rules": {
+          "no-restricted-globals": [
+            2,
+            {
+              "message": "Use the logged request layer: `XMLHttpRequest` belongs to src/lib/api/core.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "XMLHttpRequest"
+            },
+            {
+              "message": "Use the logged request layer: `WebSocket` belongs to src/lib/messagesSocket.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "WebSocket"
+            },
+            {
+              "message": "No `EventSource` without a logged owner module (E22 S4).",
+              "name": "EventSource"
+            }
+          ],
+          "no-restricted-imports": [
+            2,
+            {
+              "patterns": [
+                {
+                  "message": "lib/ sits below components/: it may not import from components/, not even a type. Move the shared piece down into lib/.",
+                  "regex": "^(\\.\\./)+components(/|$)"
+                }
+              ]
+            }
+          ]
+        },
+        "settings": null
+      },
+      "lib/messagesSocket.ts": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "1169 names, sha1 aee621727a03",
+          "parser": "typescript-eslint/parser",
+          "parserOptions": { "projectService": true, "tsconfigRootDir": "." },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "notApplied": [],
+        "plugins": [
+          "@",
+          "@eslint-community/eslint-comments",
+          "@typescript-eslint",
+          "local",
+          "react-hooks",
+          "react-refresh"
+        ],
+        "rules": {
+          "no-restricted-globals": [
+            2,
+            {
+              "message": "Use the logged request layer: `fetch` belongs to src/lib/http.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "fetch"
+            },
+            {
+              "message": "Use the logged request layer: `XMLHttpRequest` belongs to src/lib/api/core.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "XMLHttpRequest"
+            },
+            {
+              "message": "No `EventSource` without a logged owner module (E22 S4).",
+              "name": "EventSource"
+            }
+          ],
+          "no-restricted-imports": [
+            2,
+            {
+              "patterns": [
+                {
+                  "message": "lib/ sits below components/: it may not import from components/, not even a type. Move the shared piece down into lib/.",
+                  "regex": "^(\\.\\./)+components(/|$)"
+                }
+              ]
+            }
+          ]
+        },
+        "settings": null
+      },
+      "src": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "1169 names, sha1 aee621727a03",
+          "parser": "typescript-eslint/parser",
+          "parserOptions": { "projectService": true, "tsconfigRootDir": "." },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "plugins": [
+          "@",
+          "@eslint-community/eslint-comments",
+          "@typescript-eslint",
+          "local",
+          "react-hooks",
+          "react-refresh"
+        ],
+        "rules": {
+          "@babel/object-curly-spacing": [0],
+          "@babel/semi": [0],
+          "@eslint-community/eslint-comments/no-unlimited-disable": [2],
+          "@eslint-community/eslint-comments/require-description": [2, { "ignore": [] }],
+          "@stylistic/array-bracket-newline": [0],
+          "@stylistic/array-bracket-spacing": [0],
+          "@stylistic/array-element-newline": [0],
+          "@stylistic/arrow-parens": [0],
+          "@stylistic/arrow-spacing": [0],
+          "@stylistic/block-spacing": [0],
+          "@stylistic/brace-style": [0],
+          "@stylistic/comma-dangle": [0],
+          "@stylistic/comma-spacing": [0],
+          "@stylistic/comma-style": [0],
+          "@stylistic/computed-property-spacing": [0],
+          "@stylistic/dot-location": [0],
+          "@stylistic/eol-last": [0],
+          "@stylistic/func-call-spacing": [0],
+          "@stylistic/function-call-argument-newline": [0],
+          "@stylistic/function-call-spacing": [0],
+          "@stylistic/function-paren-newline": [0],
+          "@stylistic/generator-star-spacing": [0],
+          "@stylistic/implicit-arrow-linebreak": [0],
+          "@stylistic/indent": [0],
+          "@stylistic/indent-binary-ops": [0],
+          "@stylistic/js/array-bracket-newline": [0],
+          "@stylistic/js/array-bracket-spacing": [0],
+          "@stylistic/js/array-element-newline": [0],
+          "@stylistic/js/arrow-parens": [0],
+          "@stylistic/js/arrow-spacing": [0],
+          "@stylistic/js/block-spacing": [0],
+          "@stylistic/js/brace-style": [0],
+          "@stylistic/js/comma-dangle": [0],
+          "@stylistic/js/comma-spacing": [0],
+          "@stylistic/js/comma-style": [0],
+          "@stylistic/js/computed-property-spacing": [0],
+          "@stylistic/js/dot-location": [0],
+          "@stylistic/js/eol-last": [0],
+          "@stylistic/js/func-call-spacing": [0],
+          "@stylistic/js/function-call-argument-newline": [0],
+          "@stylistic/js/function-call-spacing": [0],
+          "@stylistic/js/function-paren-newline": [0],
+          "@stylistic/js/generator-star-spacing": [0],
+          "@stylistic/js/implicit-arrow-linebreak": [0],
+          "@stylistic/js/indent": [0],
+          "@stylistic/js/jsx-quotes": [0],
+          "@stylistic/js/key-spacing": [0],
+          "@stylistic/js/keyword-spacing": [0],
+          "@stylistic/js/linebreak-style": [0],
+          "@stylistic/js/lines-around-comment": [0],
+          "@stylistic/js/max-len": [0],
+          "@stylistic/js/max-statements-per-line": [0],
+          "@stylistic/js/multiline-ternary": [0],
+          "@stylistic/js/new-parens": [0],
+          "@stylistic/js/newline-per-chained-call": [0],
+          "@stylistic/js/no-confusing-arrow": [0],
+          "@stylistic/js/no-extra-parens": [0],
+          "@stylistic/js/no-extra-semi": [0],
+          "@stylistic/js/no-floating-decimal": [0],
+          "@stylistic/js/no-mixed-operators": [0],
+          "@stylistic/js/no-mixed-spaces-and-tabs": [0],
+          "@stylistic/js/no-multi-spaces": [0],
+          "@stylistic/js/no-multiple-empty-lines": [0],
+          "@stylistic/js/no-tabs": [0],
+          "@stylistic/js/no-trailing-spaces": [0],
+          "@stylistic/js/no-whitespace-before-property": [0],
+          "@stylistic/js/nonblock-statement-body-position": [0],
+          "@stylistic/js/object-curly-newline": [0],
+          "@stylistic/js/object-curly-spacing": [0],
+          "@stylistic/js/object-property-newline": [0],
+          "@stylistic/js/one-var-declaration-per-line": [0],
+          "@stylistic/js/operator-linebreak": [0],
+          "@stylistic/js/padded-blocks": [0],
+          "@stylistic/js/quote-props": [0],
+          "@stylistic/js/quotes": [0],
+          "@stylistic/js/rest-spread-spacing": [0],
+          "@stylistic/js/semi": [0],
+          "@stylistic/js/semi-spacing": [0],
+          "@stylistic/js/semi-style": [0],
+          "@stylistic/js/space-before-blocks": [0],
+          "@stylistic/js/space-before-function-paren": [0],
+          "@stylistic/js/space-in-parens": [0],
+          "@stylistic/js/space-infix-ops": [0],
+          "@stylistic/js/space-unary-ops": [0],
+          "@stylistic/js/switch-colon-spacing": [0],
+          "@stylistic/js/template-curly-spacing": [0],
+          "@stylistic/js/template-tag-spacing": [0],
+          "@stylistic/js/wrap-iife": [0],
+          "@stylistic/js/wrap-regex": [0],
+          "@stylistic/js/yield-star-spacing": [0],
+          "@stylistic/jsx-child-element-spacing": [0],
+          "@stylistic/jsx-closing-bracket-location": [0],
+          "@stylistic/jsx-closing-tag-location": [0],
+          "@stylistic/jsx-curly-newline": [0],
+          "@stylistic/jsx-curly-spacing": [0],
+          "@stylistic/jsx-equals-spacing": [0],
+          "@stylistic/jsx-first-prop-new-line": [0],
+          "@stylistic/jsx-indent": [0],
+          "@stylistic/jsx-indent-props": [0],
+          "@stylistic/jsx-max-props-per-line": [0],
+          "@stylistic/jsx-newline": [0],
+          "@stylistic/jsx-one-expression-per-line": [0],
+          "@stylistic/jsx-props-no-multi-spaces": [0],
+          "@stylistic/jsx-quotes": [0],
+          "@stylistic/jsx-tag-spacing": [0],
+          "@stylistic/jsx-wrap-multilines": [0],
+          "@stylistic/jsx/jsx-child-element-spacing": [0],
+          "@stylistic/jsx/jsx-closing-bracket-location": [0],
+          "@stylistic/jsx/jsx-closing-tag-location": [0],
+          "@stylistic/jsx/jsx-curly-newline": [0],
+          "@stylistic/jsx/jsx-curly-spacing": [0],
+          "@stylistic/jsx/jsx-equals-spacing": [0],
+          "@stylistic/jsx/jsx-first-prop-new-line": [0],
+          "@stylistic/jsx/jsx-indent": [0],
+          "@stylistic/jsx/jsx-indent-props": [0],
+          "@stylistic/jsx/jsx-max-props-per-line": [0],
+          "@stylistic/key-spacing": [0],
+          "@stylistic/keyword-spacing": [0],
+          "@stylistic/linebreak-style": [0],
+          "@stylistic/lines-around-comment": [0],
+          "@stylistic/max-len": [0],
+          "@stylistic/max-statements-per-line": [0],
+          "@stylistic/member-delimiter-style": [0],
+          "@stylistic/multiline-ternary": [0],
+          "@stylistic/new-parens": [0],
+          "@stylistic/newline-per-chained-call": [0],
+          "@stylistic/no-confusing-arrow": [0],
+          "@stylistic/no-extra-parens": [0],
+          "@stylistic/no-extra-semi": [0],
+          "@stylistic/no-floating-decimal": [0],
+          "@stylistic/no-mixed-operators": [0],
+          "@stylistic/no-mixed-spaces-and-tabs": [0],
+          "@stylistic/no-multi-spaces": [0],
+          "@stylistic/no-multiple-empty-lines": [0],
+          "@stylistic/no-tabs": [0],
+          "@stylistic/no-trailing-spaces": [0],
+          "@stylistic/no-whitespace-before-property": [0],
+          "@stylistic/nonblock-statement-body-position": [0],
+          "@stylistic/object-curly-newline": [0],
+          "@stylistic/object-curly-spacing": [0],
+          "@stylistic/object-property-newline": [0],
+          "@stylistic/one-var-declaration-per-line": [0],
+          "@stylistic/operator-linebreak": [0],
+          "@stylistic/padded-blocks": [0],
+          "@stylistic/quote-props": [0],
+          "@stylistic/quotes": [0],
+          "@stylistic/rest-spread-spacing": [0],
+          "@stylistic/semi": [0],
+          "@stylistic/semi-spacing": [0],
+          "@stylistic/semi-style": [0],
+          "@stylistic/space-before-blocks": [0],
+          "@stylistic/space-before-function-paren": [0],
+          "@stylistic/space-in-parens": [0],
+          "@stylistic/space-infix-ops": [0],
+          "@stylistic/space-unary-ops": [0],
+          "@stylistic/switch-colon-spacing": [0],
+          "@stylistic/template-curly-spacing": [0],
+          "@stylistic/template-tag-spacing": [0],
+          "@stylistic/ts/block-spacing": [0],
+          "@stylistic/ts/brace-style": [0],
+          "@stylistic/ts/comma-dangle": [0],
+          "@stylistic/ts/comma-spacing": [0],
+          "@stylistic/ts/func-call-spacing": [0],
+          "@stylistic/ts/function-call-spacing": [0],
+          "@stylistic/ts/indent": [0],
+          "@stylistic/ts/key-spacing": [0],
+          "@stylistic/ts/keyword-spacing": [0],
+          "@stylistic/ts/lines-around-comment": [0],
+          "@stylistic/ts/member-delimiter-style": [0],
+          "@stylistic/ts/no-extra-parens": [0],
+          "@stylistic/ts/no-extra-semi": [0],
+          "@stylistic/ts/object-curly-spacing": [0],
+          "@stylistic/ts/quotes": [0],
+          "@stylistic/ts/semi": [0],
+          "@stylistic/ts/space-before-blocks": [0],
+          "@stylistic/ts/space-before-function-paren": [0],
+          "@stylistic/ts/space-infix-ops": [0],
+          "@stylistic/ts/type-annotation-spacing": [0],
+          "@stylistic/type-annotation-spacing": [0],
+          "@stylistic/type-generic-spacing": [0],
+          "@stylistic/type-named-tuple-spacing": [0],
+          "@stylistic/wrap-iife": [0],
+          "@stylistic/wrap-regex": [0],
+          "@stylistic/yield-star-spacing": [0],
+          "@typescript-eslint/ban-ts-comment": [2],
+          "@typescript-eslint/block-spacing": [0],
+          "@typescript-eslint/brace-style": [0],
+          "@typescript-eslint/comma-dangle": [0],
+          "@typescript-eslint/comma-spacing": [0],
+          "@typescript-eslint/func-call-spacing": [0],
+          "@typescript-eslint/indent": [0],
+          "@typescript-eslint/key-spacing": [0],
+          "@typescript-eslint/keyword-spacing": [0],
+          "@typescript-eslint/lines-around-comment": [0],
+          "@typescript-eslint/member-delimiter-style": [0],
+          "@typescript-eslint/no-array-constructor": [2],
+          "@typescript-eslint/no-deprecated": [2],
+          "@typescript-eslint/no-duplicate-enum-values": [2],
+          "@typescript-eslint/no-empty-object-type": [2],
+          "@typescript-eslint/no-explicit-any": [2],
+          "@typescript-eslint/no-extra-non-null-assertion": [2],
+          "@typescript-eslint/no-extra-parens": [0],
+          "@typescript-eslint/no-extra-semi": [0],
+          "@typescript-eslint/no-floating-promises": [
+            2,
+            {
+              "allowForKnownSafeCalls": [
+                {
+                  "from": "package",
+                  "name": [
+                    "invalidateQueries",
+                    "refetchQueries",
+                    "cancelQueries",
+                    "resetQueries",
+                    "prefetchQuery",
+                    "prefetchInfiniteQuery"
+                  ],
+                  "package": "@tanstack/query-core"
+                }
+              ]
+            }
+          ],
+          "@typescript-eslint/no-misused-new": [2],
+          "@typescript-eslint/no-namespace": [2],
+          "@typescript-eslint/no-non-null-asserted-optional-chain": [2],
+          "@typescript-eslint/no-require-imports": [2],
+          "@typescript-eslint/no-this-alias": [2],
+          "@typescript-eslint/no-unnecessary-type-constraint": [2],
+          "@typescript-eslint/no-unsafe-declaration-merging": [2],
+          "@typescript-eslint/no-unsafe-function-type": [2],
+          "@typescript-eslint/no-unused-expressions": [
+            2,
+            { "allowShortCircuit": true, "allowTaggedTemplates": false, "allowTernary": true }
+          ],
+          "@typescript-eslint/no-unused-vars": [0],
+          "@typescript-eslint/no-wrapper-object-types": [2],
+          "@typescript-eslint/object-curly-spacing": [0],
+          "@typescript-eslint/prefer-as-const": [2],
+          "@typescript-eslint/prefer-namespace-keyword": [2],
+          "@typescript-eslint/quotes": [0],
+          "@typescript-eslint/semi": [0],
+          "@typescript-eslint/space-before-blocks": [0],
+          "@typescript-eslint/space-before-function-paren": [0],
+          "@typescript-eslint/space-infix-ops": [0],
+          "@typescript-eslint/triple-slash-reference": [2],
+          "@typescript-eslint/type-annotation-spacing": [0],
+          "array-bracket-newline": [0],
+          "array-bracket-spacing": [0],
+          "array-element-newline": [0],
+          "arrow-parens": [0],
+          "arrow-spacing": [0],
+          "babel/object-curly-spacing": [0],
+          "babel/quotes": [0],
+          "babel/semi": [0],
+          "block-spacing": [0],
+          "brace-style": [0],
+          "comma-dangle": [0],
+          "comma-spacing": [0],
+          "comma-style": [0],
+          "computed-property-spacing": [0],
+          "constructor-super": [0],
+          "curly": [0, "all"],
+          "dot-location": [0],
+          "eol-last": [0],
+          "flowtype/boolean-style": [0],
+          "flowtype/delimiter-dangle": [0],
+          "flowtype/generic-spacing": [0],
+          "flowtype/object-type-curly-spacing": [0],
+          "flowtype/object-type-delimiter": [0],
+          "flowtype/quotes": [0],
+          "flowtype/semi": [0],
+          "flowtype/space-after-type-colon": [0],
+          "flowtype/space-before-generic-bracket": [0],
+          "flowtype/space-before-type-colon": [0],
+          "flowtype/union-intersection-spacing": [0],
+          "for-direction": [2],
+          "func-call-spacing": [0],
+          "function-call-argument-newline": [0],
+          "function-paren-newline": [0],
+          "generator-star": [0],
+          "generator-star-spacing": [0],
+          "getter-return": [0, { "allowImplicit": false }],
+          "implicit-arrow-linebreak": [0],
+          "indent": [0],
+          "indent-legacy": [0],
+          "jsx-quotes": [0],
+          "key-spacing": [0],
+          "keyword-spacing": [0],
+          "linebreak-style": [0],
+          "lines-around-comment": [0],
+          "local/button-primitive": [2],
+          "local/focus-safe-disabled": [2],
+          "local/glyph-link": [2],
+          "local/input-primitive": [2],
+          "local/jsx-comment-text": [2],
+          "local/literal-a11y-text": [2],
+          "local/locale-format": [2],
+          "local/sortable-a11y": [2],
+          "local/surface-role": [2],
+          "max-len": [0],
+          "max-statements-per-line": [0],
+          "multiline-ternary": [0],
+          "new-parens": [0],
+          "newline-per-chained-call": [0],
+          "no-array-constructor": [0],
+          "no-arrow-condition": [0],
+          "no-async-promise-executor": [2],
+          "no-case-declarations": [2],
+          "no-class-assign": [0],
+          "no-comma-dangle": [0],
+          "no-compare-neg-zero": [2],
+          "no-cond-assign": [2, "except-parens"],
+          "no-confusing-arrow": [0],
+          "no-console": [2, {}],
+          "no-const-assign": [0],
+          "no-constant-binary-expression": [2],
+          "no-constant-condition": [2, { "checkLoops": "allExceptWhileTrue" }],
+          "no-control-regex": [2],
+          "no-debugger": [2],
+          "no-delete-var": [2],
+          "no-dupe-args": [0],
+          "no-dupe-class-members": [0],
+          "no-dupe-else-if": [2],
+          "no-dupe-keys": [0],
+          "no-duplicate-case": [2],
+          "no-empty": [2, { "allowEmptyCatch": false }],
+          "no-empty-character-class": [2],
+          "no-empty-pattern": [2, { "allowObjectPatternsAsParameters": false }],
+          "no-empty-static-block": [2],
+          "no-ex-assign": [2],
+          "no-extra-boolean-cast": [2, {}],
+          "no-extra-parens": [0],
+          "no-extra-semi": [0],
+          "no-fallthrough": [
+            2,
+            { "allowEmptyCase": false, "reportUnusedFallthroughComment": false }
+          ],
+          "no-floating-decimal": [0],
+          "no-func-assign": [0],
+          "no-global-assign": [2, { "exceptions": [] }],
+          "no-import-assign": [0],
+          "no-invalid-regexp": [2, {}],
+          "no-irregular-whitespace": [
+            2,
+            {
+              "skipComments": false,
+              "skipJSXText": false,
+              "skipRegExps": false,
+              "skipStrings": true,
+              "skipTemplates": false
+            }
+          ],
+          "no-loss-of-precision": [2],
+          "no-misleading-character-class": [2, { "allowEscape": false }],
+          "no-mixed-operators": [0],
+          "no-mixed-spaces-and-tabs": [0],
+          "no-multi-spaces": [0],
+          "no-multiple-empty-lines": [0],
+          "no-new-native-nonconstructor": [0],
+          "no-new-symbol": [0],
+          "no-nonoctal-decimal-escape": [2],
+          "no-obj-calls": [0],
+          "no-octal": [2],
+          "no-prototype-builtins": [2],
+          "no-redeclare": [0, { "builtinGlobals": true }],
+          "no-regex-spaces": [2],
+          "no-reserved-keys": [0],
+          "no-restricted-globals": [
+            2,
+            {
+              "message": "Use the logged request layer: `fetch` belongs to src/lib/http.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "fetch"
+            },
+            {
+              "message": "Use the logged request layer: `XMLHttpRequest` belongs to src/lib/api/core.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "XMLHttpRequest"
+            },
+            {
+              "message": "Use the logged request layer: `WebSocket` belongs to src/lib/messagesSocket.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "WebSocket"
+            },
+            {
+              "message": "No `EventSource` without a logged owner module (E22 S4).",
+              "name": "EventSource"
+            }
+          ],
+          "no-restricted-properties": [
+            2,
+            {
+              "message": "Use lib/http.ts `send` (E22 S4).",
+              "object": "window",
+              "property": "fetch"
+            },
+            {
+              "message": "Use lib/http.ts `send` (E22 S4).",
+              "object": "globalThis",
+              "property": "fetch"
+            },
+            {
+              "message": "Use lib/api/core.ts `beacon` (E22 S4).",
+              "object": "navigator",
+              "property": "sendBeacon"
+            }
+          ],
+          "no-restricted-syntax": [
+            2,
+            {
+              "message": "fetchNextPage() cancels and re-sends a page already loading: call fetchNextPage(NEXT_PAGE) (lib/nextPage.ts).",
+              "selector": "CallExpression[arguments.length=0]:matches([callee.name='fetchNextPage'], [callee.property.name='fetchNextPage'])"
+            },
+            {
+              "message": "`enabled:hover:` misses a focused FocusSafeButton (aria-disabled): use `act:hover:` (index.css).",
+              "selector": "Literal[value=/(^|\\s)enabled:hover:/]"
+            },
+            {
+              "message": "`enabled:hover:` misses a focused FocusSafeButton (aria-disabled): use `act:hover:` (index.css).",
+              "selector": "TemplateElement[value.raw=/(^|\\s)enabled:hover:/]"
+            },
+            {
+              "message": "a class split by an interpolation (`${x}hover:…`): Tailwind never sees it whole and emits no CSS; write the class literally (a shared guard is the `act:` variant).",
+              "selector": "TemplateLiteral > TemplateElement:not(:first-child)[value.raw=/^([a-z][\\w-]*:[\\w\\[!-]|:[a-z\\[!])/]"
+            },
+            {
+              "message": "No native <select>: use ui/SegmentedToggle for a short fixed set, ui/FilterSelect for a longer one or a user's own list.",
+              "selector": "JSXOpeningElement[name.name='select']"
+            },
+            {
+              "message": "px-frozen font size doesn't scale with --font-scale: use text-2xs/text-3xs or text-[Nrem], not text-[Npx] (R10 S2).",
+              "selector": "Literal[value=/text-\\[[\\d.]+px\\]/]"
+            },
+            {
+              "message": "px-frozen font size doesn't scale with --font-scale: use text-2xs/text-3xs or text-[Nrem], not text-[Npx] (R10 S2).",
+              "selector": "TemplateElement[value.raw=/text-\\[[\\d.]+px\\]/]"
+            },
+            {
+              "message": "px-frozen box size doesn't scale with --font-scale: use the spacing scale (w-37.5, max-w-60), not w-[Npx].",
+              "selector": "Literal[value=/(^|[\\s:])(min-|max-)?(w|h|size|left|right|top|bottom|inset|gap|p[xytrbl]?|m[xytrbl]?)-\\[[\\d.]+px\\]/]"
+            },
+            {
+              "message": "px-frozen box size doesn't scale with --font-scale: use the spacing scale (w-37.5, max-w-60), not w-[Npx].",
+              "selector": "TemplateElement[value.raw=/(^|[\\s:])(min-|max-)?(w|h|size|left|right|top|bottom|inset|gap|p[xytrbl]?|m[xytrbl]?)-\\[[\\d.]+px\\]/]"
+            },
+            {
+              "message": "px-frozen box size doesn't scale with --font-scale: give a grid column's minimum in rem (minmax(9.375rem,1fr)), not minmax(Npx,…).",
+              "selector": "Literal[value=/minmax\\([\\d.]+px,/]"
+            },
+            {
+              "message": "px-frozen box size doesn't scale with --font-scale: give a grid column's minimum in rem (minmax(9.375rem,1fr)), not minmax(Npx,…).",
+              "selector": "TemplateElement[value.raw=/minmax\\([\\d.]+px,/]"
+            },
+            {
+              "message": "z-index off the layer scale: use a named level (z-under, z-base, z-menu, z-chrome, z-panel, z-rail, z-overlay, z-popover, z-tooltip), not z-N or z-[…].",
+              "selector": "Literal[value=/(^|[\\s:])-?z-([1-9]\\d*|\\[[^\\]]+\\])(?![\\w-])/]"
+            },
+            {
+              "message": "z-index off the layer scale: use a named level (z-under, z-base, z-menu, z-chrome, z-panel, z-rail, z-overlay, z-popover, z-tooltip), not z-N or z-[…].",
+              "selector": "TemplateElement[value.raw=/(^|[\\s:])-?z-([1-9]\\d*|\\[[^\\]]+\\])(?![\\w-])/]"
+            },
+            {
+              "message": "hover by a colour swap: use the B3 layer (`state-layer`, Pressable `layer`, `state-filled` on a fill), not hover:bg-card / bg-border / opacity-N.",
+              "selector": "Literal[value=/(^|[\\s:])hover:(bg-(card|border|surface|muted)(?![\\w-])|bg-\\(--(hover|press)\\)|opacity-)/]"
+            },
+            {
+              "message": "hover by a colour swap: use the B3 layer (`state-layer`, Pressable `layer`, `state-filled` on a fill), not hover:bg-card / bg-border / opacity-N.",
+              "selector": "TemplateElement[value.raw=/(^|[\\s:])hover:(bg-(card|border|surface|muted)(?![\\w-])|bg-\\(--(hover|press)\\)|opacity-)/]"
+            },
+            {
+              "message": "a palette colour: use a semantic token (text-rating, bg-live, bg-media-chrome, text-danger, …; DESIGN.md Tokens), not text-amber-500.",
+              "selector": "Literal[value=/(^|[\\s:])(text|bg|border|fill|stroke|from|via|to|ring|outline|decoration|divide|caret|shadow)-(red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose|slate|gray|zinc|neutral|stone)-\\d/]"
+            },
+            {
+              "message": "a palette colour: use a semantic token (text-rating, bg-live, bg-media-chrome, text-danger, …; DESIGN.md Tokens), not text-amber-500.",
+              "selector": "TemplateElement[value.raw=/(^|[\\s:])(text|bg|border|fill|stroke|from|via|to|ring|outline|decoration|divide|caret|shadow)-(red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose|slate|gray|zinc|neutral|stone)-\\d/]"
+            },
+            {
+              "message": "a static label with an edge reads as a pressable chip: use ui/Badge (flat, tonal) for a label that does nothing.",
+              "selector": "JSXOpeningElement[name.name='span'] JSXAttribute[name.name='className'] Literal[value=/^(?=.*(^|\\s)rounded-(full|md|lg|xl|2xl)(\\s|$))(?=.*(^|\\s)border(\\s|$))/]"
+            },
+            {
+              "message": "a static label with an edge reads as a pressable chip: use ui/Badge (flat, tonal) for a label that does nothing.",
+              "selector": "JSXOpeningElement[name.name='span'] JSXAttribute[name.name='className'] TemplateElement[value.raw=/^(?=.*(^|\\s)rounded-(full|md|lg|xl|2xl)(\\s|$))(?=.*(^|\\s)border(\\s|$))/]"
+            }
+          ],
+          "no-self-assign": [2, { "props": true }],
+          "no-setter-return": [0],
+          "no-shadow-restricted-names": [2, { "reportGlobalThis": false }],
+          "no-space-before-semi": [0],
+          "no-spaced-func": [0],
+          "no-sparse-arrays": [2],
+          "no-tabs": [0],
+          "no-this-before-super": [0],
+          "no-trailing-spaces": [0],
+          "no-undef": [0, { "typeof": false }],
+          "no-unexpected-multiline": [0],
+          "no-unreachable": [0],
+          "no-unsafe-finally": [2],
+          "no-unsafe-negation": [0, { "enforceForOrderingRelations": false }],
+          "no-unsafe-optional-chaining": [2, { "disallowArithmeticOperators": false }],
+          "no-unused-expressions": [
+            0,
+            {
+              "allowShortCircuit": false,
+              "allowTaggedTemplates": false,
+              "allowTernary": false,
+              "enforceForJSX": false,
+              "ignoreDirectives": false
+            }
+          ],
+          "no-unused-labels": [2],
+          "no-unused-private-class-members": [2],
+          "no-unused-vars": [0],
+          "no-useless-backreference": [2],
+          "no-useless-catch": [2],
+          "no-useless-escape": [2, { "allowRegexCharacters": [] }],
+          "no-var": [2],
+          "no-whitespace-before-property": [0],
+          "no-with": [0],
+          "no-wrap-func": [0],
+          "nonblock-statement-body-position": [0],
+          "object-curly-newline": [0],
+          "object-curly-spacing": [0],
+          "object-property-newline": [0],
+          "one-var-declaration-per-line": [0],
+          "operator-linebreak": [0],
+          "padded-blocks": [0],
+          "prefer-const": [2, { "destructuring": "any", "ignoreReadBeforeAssign": false }],
+          "prefer-rest-params": [2],
+          "prefer-spread": [2],
+          "quote-props": [0],
+          "quotes": [0],
+          "react-hooks/capitalized-calls": [2],
+          "react-hooks/component-hook-factories": [2],
+          "react-hooks/config": [2],
+          "react-hooks/error-boundaries": [2],
+          "react-hooks/exhaustive-deps": [1],
+          "react-hooks/exhaustive-effect-dependencies": [2],
+          "react-hooks/gating": [2],
+          "react-hooks/globals": [2],
+          "react-hooks/hooks": [2],
+          "react-hooks/immutability": [2],
+          "react-hooks/incompatible-library": [1],
+          "react-hooks/invariant": [2],
+          "react-hooks/memo-dependencies": [2],
+          "react-hooks/memoized-effect-dependencies": [2],
+          "react-hooks/no-deriving-state-in-effects": [2],
+          "react-hooks/preserve-manual-memoization": [2],
+          "react-hooks/purity": [2],
+          "react-hooks/refs": [2],
+          "react-hooks/rule-suppression": [2],
+          "react-hooks/rules-of-hooks": [2],
+          "react-hooks/set-state-in-effect": [2],
+          "react-hooks/set-state-in-render": [2],
+          "react-hooks/static-components": [2],
+          "react-hooks/syntax": [2],
+          "react-hooks/todo": [2],
+          "react-hooks/unsupported-syntax": [1],
+          "react-hooks/use-memo": [2],
+          "react-hooks/void-use-memo": [2],
+          "react-refresh/only-export-components": [1, { "allowConstantExport": true }],
+          "react/jsx-child-element-spacing": [0],
+          "react/jsx-closing-bracket-location": [0],
+          "react/jsx-closing-tag-location": [0],
+          "react/jsx-curly-newline": [0],
+          "react/jsx-curly-spacing": [0],
+          "react/jsx-equals-spacing": [0],
+          "react/jsx-first-prop-new-line": [0],
+          "react/jsx-indent": [0],
+          "react/jsx-indent-props": [0],
+          "react/jsx-max-props-per-line": [0],
+          "react/jsx-newline": [0],
+          "react/jsx-one-expression-per-line": [0],
+          "react/jsx-props-no-multi-spaces": [0],
+          "react/jsx-space-before-closing": [0],
+          "react/jsx-tag-spacing": [0],
+          "react/jsx-wrap-multilines": [0],
+          "require-yield": [2],
+          "rest-spread-spacing": [0],
+          "semi": [0],
+          "semi-spacing": [0],
+          "semi-style": [0],
+          "space-after-function-name": [0],
+          "space-after-keywords": [0],
+          "space-before-blocks": [0],
+          "space-before-function-paren": [0],
+          "space-before-function-parentheses": [0],
+          "space-before-keywords": [0],
+          "space-in-brackets": [0],
+          "space-in-parens": [0],
+          "space-infix-ops": [0],
+          "space-return-throw-case": [0],
+          "space-unary-ops": [0],
+          "space-unary-word-ops": [0],
+          "standard/array-bracket-even-spacing": [0],
+          "standard/computed-property-even-spacing": [0],
+          "standard/object-curly-even-spacing": [0],
+          "switch-colon-spacing": [0],
+          "template-curly-spacing": [0],
+          "template-tag-spacing": [0],
+          "unicorn/empty-brace-spaces": [0],
+          "unicorn/no-nested-ternary": [0],
+          "unicorn/number-literal-case": [0],
+          "unicorn/template-indent": [0],
+          "use-isnan": [2, { "enforceForIndexOf": false, "enforceForSwitchCase": true }],
+          "valid-typeof": [2, { "requireStringLiterals": false }],
+          "vue/array-bracket-newline": [0],
+          "vue/array-bracket-spacing": [0],
+          "vue/array-element-newline": [0],
+          "vue/arrow-spacing": [0],
+          "vue/block-spacing": [0],
+          "vue/block-tag-newline": [0],
+          "vue/brace-style": [0],
+          "vue/comma-dangle": [0],
+          "vue/comma-spacing": [0],
+          "vue/comma-style": [0],
+          "vue/dot-location": [0],
+          "vue/func-call-spacing": [0],
+          "vue/html-closing-bracket-newline": [0],
+          "vue/html-closing-bracket-spacing": [0],
+          "vue/html-end-tags": [0],
+          "vue/html-indent": [0],
+          "vue/html-quotes": [0],
+          "vue/html-self-closing": [0],
+          "vue/key-spacing": [0],
+          "vue/keyword-spacing": [0],
+          "vue/max-attributes-per-line": [0],
+          "vue/max-len": [0],
+          "vue/multiline-html-element-content-newline": [0],
+          "vue/multiline-ternary": [0],
+          "vue/mustache-interpolation-spacing": [0],
+          "vue/no-extra-parens": [0],
+          "vue/no-multi-spaces": [0],
+          "vue/no-spaces-around-equal-signs-in-attribute": [0],
+          "vue/object-curly-newline": [0],
+          "vue/object-curly-spacing": [0],
+          "vue/object-property-newline": [0],
+          "vue/operator-linebreak": [0],
+          "vue/quote-props": [0],
+          "vue/script-indent": [0],
+          "vue/singleline-html-element-content-newline": [0],
+          "vue/space-in-parens": [0],
+          "vue/space-infix-ops": [0],
+          "vue/space-unary-ops": [0],
+          "vue/template-curly-spacing": [0],
+          "wrap-iife": [0],
+          "wrap-regex": [0],
+          "yield-star-spacing": [0]
+        },
+        "settings": null
+      },
+      "src tests": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "1169 names, sha1 aee621727a03",
+          "parser": "typescript-eslint/parser",
+          "parserOptions": { "projectService": true, "tsconfigRootDir": "." },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "notApplied": [],
+        "plugins": [
+          "@",
+          "@eslint-community/eslint-comments",
+          "@typescript-eslint",
+          "local",
+          "react-hooks",
+          "react-refresh",
+          "vitest"
+        ],
+        "rules": {
+          "local/button-primitive": [0],
+          "local/glyph-link": [0],
+          "local/input-primitive": [0],
+          "local/literal-a11y-text": [0],
+          "local/surface-role": [0],
+          "no-restricted-globals": [
+            0,
+            {
+              "message": "Use the logged request layer: `fetch` belongs to src/lib/http.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "fetch"
+            },
+            {
+              "message": "Use the logged request layer: `XMLHttpRequest` belongs to src/lib/api/core.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "XMLHttpRequest"
+            },
+            {
+              "message": "Use the logged request layer: `WebSocket` belongs to src/lib/messagesSocket.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "WebSocket"
+            },
+            {
+              "message": "No `EventSource` without a logged owner module (E22 S4).",
+              "name": "EventSource"
+            }
+          ],
+          "no-restricted-properties": [
+            0,
+            {
+              "message": "Use lib/http.ts `send` (E22 S4).",
+              "object": "window",
+              "property": "fetch"
+            },
+            {
+              "message": "Use lib/http.ts `send` (E22 S4).",
+              "object": "globalThis",
+              "property": "fetch"
+            },
+            {
+              "message": "Use lib/api/core.ts `beacon` (E22 S4).",
+              "object": "navigator",
+              "property": "sendBeacon"
+            }
+          ],
+          "vitest/no-disabled-tests": [2],
+          "vitest/no-focused-tests": [2, { "fixable": true }]
+        },
+        "settings": null
+      },
+      "src/lib": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "1169 names, sha1 aee621727a03",
+          "parser": "typescript-eslint/parser",
+          "parserOptions": { "projectService": true, "tsconfigRootDir": "." },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "notApplied": [],
+        "plugins": [
+          "@",
+          "@eslint-community/eslint-comments",
+          "@typescript-eslint",
+          "local",
+          "react-hooks",
+          "react-refresh"
+        ],
+        "rules": {
+          "no-restricted-imports": [
+            2,
+            {
+              "patterns": [
+                {
+                  "message": "lib/ sits below components/: it may not import from components/, not even a type. Move the shared piece down into lib/.",
+                  "regex": "^(\\.\\./)+components(/|$)"
+                }
+              ]
+            }
+          ]
+        },
+        "settings": null
+      },
+      "ts configs": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "82 names, sha1 29467d490e30",
+          "parser": "typescript-eslint/parser",
+          "parserOptions": { "projectService": true, "tsconfigRootDir": "." },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "notApplied": [
+          "local/button-primitive",
+          "local/focus-safe-disabled",
+          "local/glyph-link",
+          "local/input-primitive",
+          "local/jsx-comment-text",
+          "local/literal-a11y-text",
+          "local/locale-format",
+          "local/sortable-a11y",
+          "local/surface-role",
+          "no-console",
+          "no-restricted-globals",
+          "no-restricted-properties",
+          "no-restricted-syntax",
+          "react-hooks/capitalized-calls",
+          "react-hooks/component-hook-factories",
+          "react-hooks/config",
+          "react-hooks/error-boundaries",
+          "react-hooks/exhaustive-deps",
+          "react-hooks/exhaustive-effect-dependencies",
+          "react-hooks/gating",
+          "react-hooks/globals",
+          "react-hooks/hooks",
+          "react-hooks/immutability",
+          "react-hooks/incompatible-library",
+          "react-hooks/invariant",
+          "react-hooks/memo-dependencies",
+          "react-hooks/memoized-effect-dependencies",
+          "react-hooks/no-deriving-state-in-effects",
+          "react-hooks/preserve-manual-memoization",
+          "react-hooks/purity",
+          "react-hooks/refs",
+          "react-hooks/rule-suppression",
+          "react-hooks/rules-of-hooks",
+          "react-hooks/set-state-in-effect",
+          "react-hooks/set-state-in-render",
+          "react-hooks/static-components",
+          "react-hooks/syntax",
+          "react-hooks/todo",
+          "react-hooks/unsupported-syntax",
+          "react-hooks/use-memo",
+          "react-hooks/void-use-memo",
+          "react-refresh/only-export-components"
+        ],
+        "plugins": ["@", "@eslint-community/eslint-comments", "@typescript-eslint"],
+        "rules": {
+          "@typescript-eslint/no-unused-expressions": [
+            2,
+            { "allowShortCircuit": false, "allowTaggedTemplates": false, "allowTernary": false }
+          ]
+        },
+        "settings": null
+      },
+      "ui": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "1169 names, sha1 aee621727a03",
+          "parser": "typescript-eslint/parser",
+          "parserOptions": { "projectService": true, "tsconfigRootDir": "." },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "notApplied": [],
+        "plugins": [
+          "@",
+          "@eslint-community/eslint-comments",
+          "@typescript-eslint",
+          "local",
+          "react-hooks",
+          "react-refresh"
+        ],
+        "rules": {
+          "no-restricted-imports": [
+            2,
+            {
+              "patterns": [
+                {
+                  "message": "components/ui/ is domain-free: a platform component may not import a feature component. Invert the dependency (take a prop/render-prop) or keep the component outside ui/.",
+                  "regex": "^\\.\\./(?!\\.\\./)"
+                },
+                {
+                  "message": "components/ui/ is domain-free: a platform component may not import a feature component. Invert the dependency (take a prop/render-prop) or keep the component outside ui/.",
+                  "regex": "^\\.\\./\\.\\./components/(?!ui/)"
+                },
+                {
+                  "message": "components/ui/ is domain-free: a platform component may not call a domain API slice. Take the data as props.",
+                  "regex": "^\\.\\./\\.\\./lib/api(/|$)"
+                }
+              ]
+            }
+          ]
+        },
+        "settings": null
+      },
+      "ui tests": {
+        "languageOptions": {
+          "ecmaVersion": 2022,
+          "globals": "1169 names, sha1 aee621727a03",
+          "parser": "typescript-eslint/parser",
+          "parserOptions": { "projectService": true, "tsconfigRootDir": "." },
+          "sourceType": "module"
+        },
+        "linterOptions": { "reportUnusedDisableDirectives": 2 },
+        "notApplied": [],
+        "plugins": [
+          "@",
+          "@eslint-community/eslint-comments",
+          "@typescript-eslint",
+          "local",
+          "react-hooks",
+          "react-refresh",
+          "vitest"
+        ],
+        "rules": {
+          "local/button-primitive": [0],
+          "local/glyph-link": [0],
+          "local/input-primitive": [0],
+          "local/literal-a11y-text": [0],
+          "local/surface-role": [0],
+          "no-restricted-globals": [
+            0,
+            {
+              "message": "Use the logged request layer: `fetch` belongs to src/lib/http.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "fetch"
+            },
+            {
+              "message": "Use the logged request layer: `XMLHttpRequest` belongs to src/lib/api/core.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "XMLHttpRequest"
+            },
+            {
+              "message": "Use the logged request layer: `WebSocket` belongs to src/lib/messagesSocket.ts only (E22 S4 — a request outside it never reaches the client log).",
+              "name": "WebSocket"
+            },
+            {
+              "message": "No `EventSource` without a logged owner module (E22 S4).",
+              "name": "EventSource"
+            }
+          ],
+          "no-restricted-imports": [
+            2,
+            {
+              "patterns": [
+                {
+                  "message": "components/ui/ is domain-free: a platform component may not import a feature component. Invert the dependency (take a prop/render-prop) or keep the component outside ui/.",
+                  "regex": "^\\.\\./(?!\\.\\./)"
+                },
+                {
+                  "message": "components/ui/ is domain-free: a platform component may not import a feature component. Invert the dependency (take a prop/render-prop) or keep the component outside ui/.",
+                  "regex": "^\\.\\./\\.\\./components/(?!ui/)"
+                },
+                {
+                  "message": "components/ui/ is domain-free: a platform component may not call a domain API slice. Take the data as props.",
+                  "regex": "^\\.\\./\\.\\./lib/api(/|$)"
+                }
+              ]
+            }
+          ],
+          "no-restricted-properties": [
+            0,
+            {
+              "message": "Use lib/http.ts `send` (E22 S4).",
+              "object": "window",
+              "property": "fetch"
+            },
+            {
+              "message": "Use lib/http.ts `send` (E22 S4).",
+              "object": "globalThis",
+              "property": "fetch"
+            },
+            {
+              "message": "Use lib/api/core.ts `beacon` (E22 S4).",
+              "object": "navigator",
+              "property": "sendBeacon"
+            }
+          ],
+          "vitest/no-disabled-tests": [2],
+          "vitest/no-focused-tests": [2, { "fixable": true }]
+        },
+        "settings": null
+      }
+    },
+    "files": {
+      "(not linted)": [],
+      "FocusSafeButton.tsx + AnchoredPopover.tsx": [
+        "src/components/ui/AnchoredPopover.tsx",
+        "src/components/ui/FocusSafeButton.tsx"
+      ],
+      "design-lab": [
+        "src/design-lab/DesignLab.tsx",
+        "src/design-lab/batchA.tsx",
+        "src/design-lab/batchB.tsx",
+        "src/design-lab/batchC.tsx",
+        "src/design-lab/batchCActions.tsx",
+        "src/design-lab/batchD.tsx",
+        "src/design-lab/labKit.tsx",
+        "src/design-lab/labTokens.ts"
+      ],
+      "e2e": [
+        "e2e/channel.spec.ts",
+        "e2e/feed.spec.ts",
+        "e2e/global.setup.ts",
+        "e2e/helpers.ts",
+        "e2e/nav.spec.ts",
+        "e2e/player.spec.ts",
+        "e2e/settings.spec.ts"
+      ],
+      "js configs": ["eslint.config.js", "postcss.config.js"],
+      "lib tests": [
+        "src/lib/accountPinnedStores.dom.test.ts",
+        "src/lib/actionErrors.test.ts",
+        "src/lib/activeAccount.dom.test.ts",
+        "src/lib/adminUsers.test.ts",
+        "src/lib/api/adminLogs.dom.test.ts",
+        "src/lib/api/core.test.ts",
+        "src/lib/api/diagnostics.dom.test.ts",
+        "src/lib/api/discover.dom.test.ts",
+        "src/lib/api/downloads.contract.test.ts",
+        "src/lib/api/facade.test.ts",
+        "src/lib/api/feed.test.ts",
+        "src/lib/api/plex.dom.test.ts",
+        "src/lib/api/plexFilters.dom.test.ts",
+        "src/lib/api/plexLang.dom.test.ts",
+        "src/lib/api/tagModes.test.ts",
+        "src/lib/auditGroups.test.ts",
+        "src/lib/browserBackgroundPlay.dom.test.ts",
+        "src/lib/buttonPrimitive.contract.test.ts",
+        "src/lib/captureTab.dom.test.ts",
+        "src/lib/channelDetailPoll.backfill.dom.test.tsx",
+        "src/lib/channelDetailPoll.test.ts",
+        "src/lib/channelOrder.dom.test.ts",
+        "src/lib/channelWriteFailures.dom.test.tsx",
+        "src/lib/channelsUrlState.dom.test.ts",
+        "src/lib/chatDock.dom.test.ts",
+        "src/lib/chipLane.contract.test.ts",
+        "src/lib/chipOverflow.test.ts",
+        "src/lib/columnSort.test.ts",
+        "src/lib/controlRules.contract.test.ts",
+        "src/lib/cropGeometry.test.ts",
+        "src/lib/dateFilter.test.ts",
+        "src/lib/detailLog.dom.test.ts",
+        "src/lib/diagnostics.dom.test.ts",
+        "src/lib/diagnostics.session.dom.test.ts",
+        "src/lib/downloadActions.test.ts",
+        "src/lib/downloadFailure.test.ts",
+        "src/lib/downloads.test.ts",
+        "src/lib/e2ee.test.ts",
+        "src/lib/fadeEdge.contract.test.ts",
+        "src/lib/feedSort.yt.test.ts",
+        "src/lib/focusSafe.contract.test.ts",
+        "src/lib/format.test.ts",
+        "src/lib/gates.contract.test.ts",
+        "src/lib/globalKeymap.dom.test.tsx",
+        "src/lib/headings.contract.test.ts",
+        "src/lib/history.dom.test.ts",
+        "src/lib/history.nav.dom.test.ts",
+        "src/lib/history.navPosition.dom.test.tsx",
+        "src/lib/history.navRestore.reload.dom.test.tsx",
+        "src/lib/history.subview.dom.test.ts",
+        "src/lib/hoverAndLink.contract.test.ts",
+        "src/lib/http.test.ts",
+        "src/lib/inputPrimitive.contract.test.ts",
+        "src/lib/issueDraft.test.ts",
+        "src/lib/jobResult.dom.test.ts",
+        "src/lib/jsxCommentText.contract.test.ts",
+        "src/lib/keymap.sequence.test.ts",
+        "src/lib/keymap.test.ts",
+        "src/lib/layerStack.dom.test.ts",
+        "src/lib/layerStack.integration.dom.test.tsx",
+        "src/lib/lazyWithPreload.dom.test.tsx",
+        "src/lib/linkify.test.ts",
+        "src/lib/listNav.dom.test.tsx",
+        "src/lib/listNav.scope.dom.test.tsx",
+        "src/lib/listPaging.test.ts",
+        "src/lib/literalA11yText.contract.test.ts",
+        "src/lib/localeFormat.contract.test.ts",
+        "src/lib/log.contract.test.ts",
+        "src/lib/log.test.ts",
+        "src/lib/logHooks.dom.test.ts",
+        "src/lib/logsUrlState.test.ts",
+        "src/lib/messagesSocket.test.ts",
+        "src/lib/moveInList.test.ts",
+        "src/lib/mutationFailures.contract.test.ts",
+        "src/lib/navPosition.wiring.contract.test.ts",
+        "src/lib/navRing.contract.test.ts",
+        "src/lib/networkBoundary.contract.test.ts",
+        "src/lib/nextPage.contract.test.ts",
+        "src/lib/nextPage.dom.test.ts",
+        "src/lib/nextPage.wiring.contract.test.ts",
+        "src/lib/nodeEngine.contract.test.ts",
+        "src/lib/notifications.actionTtl.dom.test.ts",
+        "src/lib/pageKeys.dom.test.tsx",
+        "src/lib/pageMeta.test.ts",
+        "src/lib/panelLayout.dom.test.ts",
+        "src/lib/parseId.test.ts",
+        "src/lib/playerModalHooks.apiload.dom.test.tsx",
+        "src/lib/playerModalHooks.progress.dom.test.tsx",
+        "src/lib/playerQueue.test.ts",
+        "src/lib/playerStage.contract.test.ts",
+        "src/lib/playerVolume.test.ts",
+        "src/lib/playlistView.test.ts",
+        "src/lib/plexBackdrop.dom.test.tsx",
+        "src/lib/plexFinishMargin.contract.test.ts",
+        "src/lib/plexImage.contract.test.ts",
+        "src/lib/plexImage.test.ts",
+        "src/lib/plexPlayerHooks.controls.dom.test.tsx",
+        "src/lib/plexPlayerHooks.subtitle.dom.test.tsx",
+        "src/lib/plexQueue.test.ts",
+        "src/lib/plexRating.test.ts",
+        "src/lib/plexStats.test.ts",
+        "src/lib/plexUrlState.dom.test.ts",
+        "src/lib/pxBox.contract.test.ts",
+        "src/lib/pythonEngine.contract.test.ts",
+        "src/lib/queryClient.dom.test.ts",
+        "src/lib/queryKeys.test.ts",
+        "src/lib/reactEngine.contract.test.ts",
+        "src/lib/reinsert.test.ts",
+        "src/lib/releaseNotes.test.ts",
+        "src/lib/repoScripts.contract.test.ts",
+        "src/lib/rovingHighlight.contract.test.ts",
+        "src/lib/saveLanguage.dom.test.ts",
+        "src/lib/savedViews.test.ts",
+        "src/lib/sortableA11y.contract.test.ts",
+        "src/lib/sourceSize.contract.test.ts",
+        "src/lib/staleBuild.dom.test.ts",
+        "src/lib/store.dom.test.tsx",
+        "src/lib/subscriptionCache.test.ts",
+        "src/lib/surfaceRole.contract.test.ts",
+        "src/lib/tabState.dom.test.ts",
+        "src/lib/theme.contract.test.ts",
+        "src/lib/theme.test.ts",
+        "src/lib/touchTarget.contract.test.ts",
+        "src/lib/uiBoundary.contract.test.ts",
+        "src/lib/urlState.dom.test.ts",
+        "src/lib/useCardPager.dom.test.tsx",
+        "src/lib/useChipOverflowFit.dom.test.tsx",
+        "src/lib/useDebounced.dom.test.ts",
+        "src/lib/useDismiss.dom.test.tsx",
+        "src/lib/useFilterState.dom.test.ts",
+        "src/lib/useFocusKeeper.dom.test.tsx",
+        "src/lib/useFocusKeeper.restore.dom.test.tsx",
+        "src/lib/useHoverFocusWithin.dom.test.tsx",
+        "src/lib/usePlexCollectionTitles.dom.test.tsx",
+        "src/lib/usePref.dom.test.ts",
+        "src/lib/usePref.saveFailure.dom.test.ts",
+        "src/lib/useSortState.dom.test.ts",
+        "src/lib/useTags.dom.test.tsx",
+        "src/lib/useUndoable.dom.test.ts",
+        "src/lib/useUrlMirror.dom.test.ts",
+        "src/lib/verifyEntry.dom.test.tsx",
+        "src/lib/viewportUnits.contract.test.ts",
+        "src/lib/vocab.dom.test.ts",
+        "src/lib/zLayer.contract.test.ts"
+      ],
+      "lib/api/core.ts": ["src/lib/api/core.ts"],
+      "lib/http.ts": ["src/lib/http.ts"],
+      "lib/messagesSocket.ts": ["src/lib/messagesSocket.ts"],
+      "src": [
+        "src/App.tsx",
+        "src/components/About.tsx",
+        "src/components/AboutCell.tsx",
+        "src/components/AccountPanel.tsx",
+        "src/components/ActiveFilterChips.tsx",
+        "src/components/AddToPlaylist.tsx",
+        "src/components/AdminLogs.tsx",
+        "src/components/AdminUsers.tsx",
+        "src/components/AppCommandPalette.tsx",
+        "src/components/AuditEarlierRuns.tsx",
+        "src/components/AuditLog.tsx",
+        "src/components/BootGate.tsx",
+        "src/components/ChannelAbout.tsx",
+        "src/components/ChannelDiscovery.tsx",
+        "src/components/ChannelLayoutGrid.tsx",
+        "src/components/ChannelLink.tsx",
+        "src/components/ChannelNameLink.tsx",
+        "src/components/ChannelPage.tsx",
+        "src/components/ChannelPicker.tsx",
+        "src/components/ChannelStatsPopover.tsx",
+        "src/components/ChannelTags.tsx",
+        "src/components/Channels.tsx",
+        "src/components/ChannelsProvider.tsx",
+        "src/components/ChatDock.tsx",
+        "src/components/ChatThread.tsx",
+        "src/components/ConfigPanel.tsx",
+        "src/components/ConfirmProvider.tsx",
+        "src/components/DateFilterSelect.tsx",
+        "src/components/DebugRecorder.tsx",
+        "src/components/DemoBanner.tsx",
+        "src/components/DiagnosticsSettings.tsx",
+        "src/components/DownloadButton.tsx",
+        "src/components/DownloadCenter.tsx",
+        "src/components/DownloadDialog.tsx",
+        "src/components/ErrorBoundary.tsx",
+        "src/components/ErrorDialog.tsx",
+        "src/components/ExcludedChannelList.tsx",
+        "src/components/Feed.tsx",
+        "src/components/FeedFiltersProvider.tsx",
+        "src/components/FeedScopeToggle.tsx",
+        "src/components/FeedViewProvider.tsx",
+        "src/components/FilterRail.tsx",
+        "src/components/Header.tsx",
+        "src/components/Home.tsx",
+        "src/components/IssueComposer.tsx",
+        "src/components/KeyGate.tsx",
+        "src/components/LanguageSwitcher.tsx",
+        "src/components/LibraryPlayer.tsx",
+        "src/components/LogLine.tsx",
+        "src/components/MediaResumeButtons.tsx",
+        "src/components/Messages.tsx",
+        "src/components/MyLogViewer.tsx",
+        "src/components/NavSidebar.tsx",
+        "src/components/NavigationProvider.tsx",
+        "src/components/NotificationsPanel.tsx",
+        "src/components/OnboardingWizard.tsx",
+        "src/components/PaletteLauncher.tsx",
+        "src/components/PersonalViewsModal.tsx",
+        "src/components/PlayerModal.tsx",
+        "src/components/PlaylistLimitsHint.tsx",
+        "src/components/Playlists.tsx",
+        "src/components/PlaylistsProvider.tsx",
+        "src/components/PlaylistsRail.tsx",
+        "src/components/PlexBrowse.tsx",
+        "src/components/PlexCollectionEditor.tsx",
+        "src/components/PlexCollectionView.tsx",
+        "src/components/PlexDiscover.tsx",
+        "src/components/PlexInfo.tsx",
+        "src/components/PlexLibraryPicker.tsx",
+        "src/components/PlexMenu.tsx",
+        "src/components/PlexPlayer.tsx",
+        "src/components/PlexPlayerSettings.tsx",
+        "src/components/PlexPlaylistAdd.tsx",
+        "src/components/PlexPlaylistView.tsx",
+        "src/components/PlexProvider.tsx",
+        "src/components/PlexScopeToggle.tsx",
+        "src/components/PlexSearchBox.tsx",
+        "src/components/PlexSidebar.tsx",
+        "src/components/PlexStatsOverlay.tsx",
+        "src/components/PlexViewBridge.tsx",
+        "src/components/PlexViewToggle.tsx",
+        "src/components/PosterTile.tsx",
+        "src/components/PrefsProvider.tsx",
+        "src/components/ProfileEditor.tsx",
+        "src/components/ReleaseNotes.tsx",
+        "src/components/SavedViewsPopover.tsx",
+        "src/components/SavedViewsProvider.tsx",
+        "src/components/Scheduler.tsx",
+        "src/components/SearchBar.tsx",
+        "src/components/SelectedViewChip.tsx",
+        "src/components/SettingsPanel.tsx",
+        "src/components/SetupWizard.tsx",
+        "src/components/ShareDialog.tsx",
+        "src/components/Sidebar.tsx",
+        "src/components/Stats.tsx",
+        "src/components/SyncStatus.tsx",
+        "src/components/TagFilterChips.tsx",
+        "src/components/TagManager.tsx",
+        "src/components/UpNextCard.tsx",
+        "src/components/UploadDialog.tsx",
+        "src/components/UserPicker.tsx",
+        "src/components/VerifyBanner.tsx",
+        "src/components/VersionBanner.tsx",
+        "src/components/VideoCard.tsx",
+        "src/components/VideoEditor.tsx",
+        "src/components/VideoFollowUp.tsx",
+        "src/components/VideoInfoCard.tsx",
+        "src/components/VideoMenu.tsx",
+        "src/components/ViewSwitcher.tsx",
+        "src/components/VirtualFeed.tsx",
+        "src/components/WatchPage.tsx",
+        "src/components/Welcome.tsx",
+        "src/components/WizardProvider.tsx",
+        "src/components/YearFilter.tsx",
+        "src/components/auditColumns.tsx",
+        "src/components/channelCells.tsx",
+        "src/components/channelColumns.tsx",
+        "src/components/channelSync.ts",
+        "src/components/channelsContext.ts",
+        "src/components/comfortPin.tsx",
+        "src/components/compilerSkips.testkit.ts",
+        "src/components/confirmContext.ts",
+        "src/components/copyItems.tsx",
+        "src/components/descriptionLinks.tsx",
+        "src/components/downloadAdmin.tsx",
+        "src/components/downloadModals.tsx",
+        "src/components/downloadRow.tsx",
+        "src/components/downloadTitle.ts",
+        "src/components/facetOption.ts",
+        "src/components/feedFiltersContext.ts",
+        "src/components/feedFiltersInit.ts",
+        "src/components/feedViewContext.ts",
+        "src/components/legal/LegalLayout.tsx",
+        "src/components/legal/PrivacyPolicy.tsx",
+        "src/components/legal/Terms.tsx",
+        "src/components/legal/useHungarian.ts",
+        "src/components/logLineParts.ts",
+        "src/components/modulePages.tsx",
+        "src/components/moduleRegistry.tsx",
+        "src/components/navigationContext.ts",
+        "src/components/navigationInit.ts",
+        "src/components/playerModalControls.tsx",
+        "src/components/playlistColumns.tsx",
+        "src/components/playlistsContext.ts",
+        "src/components/playlistsInit.ts",
+        "src/components/plexBrowseLists.tsx",
+        "src/components/plexCards.tsx",
+        "src/components/plexContext.ts",
+        "src/components/plexDetailAside.tsx",
+        "src/components/plexDetailUi.tsx",
+        "src/components/plexPlayable.ts",
+        "src/components/plexPlayerControls.tsx",
+        "src/components/plexSubUrl.ts",
+        "src/components/plexViewContext.ts",
+        "src/components/plexViews.tsx",
+        "src/components/prefsContext.ts",
+        "src/components/savedViewsContext.ts",
+        "src/components/useChannelActions.tsx",
+        "src/components/useDebugRecording.ts",
+        "src/components/useDownloadActions.tsx",
+        "src/components/usePlaylistActions.tsx",
+        "src/components/usePlexActiveFilters.ts",
+        "src/components/usePlexCardActions.tsx",
+        "src/components/usePlexPlaylistEdits.ts",
+        "src/components/useTagSuggestions.ts",
+        "src/components/useVideoActions.tsx",
+        "src/components/welcomeMode.ts",
+        "src/components/wizardContext.ts",
+        "src/i18n/appCopy.ts",
+        "src/i18n/index.ts",
+        "src/main.tsx",
+        "src/vite-env.d.ts"
+      ],
+      "src tests": [
+        "src/components/AdminLogs.dom.test.tsx",
+        "src/components/AdminUsers.dom.test.tsx",
+        "src/components/AppCommandPalette.dom.test.tsx",
+        "src/components/BootGate.dom.test.tsx",
+        "src/components/ChannelLayoutGrid.dom.test.tsx",
+        "src/components/ChannelNameLink.dom.test.tsx",
+        "src/components/ChannelPage.backfill.dom.test.tsx",
+        "src/components/ChannelPage.banner.dom.test.tsx",
+        "src/components/ChannelPage.busyFocus.dom.test.tsx",
+        "src/components/ChannelPage.fold.dom.test.tsx",
+        "src/components/ChannelPage.watchState.dom.test.tsx",
+        "src/components/ChannelStatsPopover.dom.test.tsx",
+        "src/components/ChannelTags.suggest.dom.test.tsx",
+        "src/components/ChannelsProvider.dom.test.tsx",
+        "src/components/ConfigPanel.choice.dom.test.tsx",
+        "src/components/ConfigPanel.field.dom.test.tsx",
+        "src/components/ConfigPanel.sections.dom.test.tsx",
+        "src/components/DateFilterSelect.dom.test.tsx",
+        "src/components/DebugRecorder.dom.test.tsx",
+        "src/components/DiagnosticsSettings.dom.test.tsx",
+        "src/components/DownloadCenter.confirm.dom.test.tsx",
+        "src/components/DownloadCenter.menu.dom.test.tsx",
+        "src/components/ErrorBoundary.message.dom.test.tsx",
+        "src/components/ErrorBoundary.staleBuild.dom.test.tsx",
+        "src/components/ExcludedChannelList.dom.test.tsx",
+        "src/components/Feed.countStale.dom.test.tsx",
+        "src/components/Feed.nextPageFailed.dom.test.tsx",
+        "src/components/Feed.reset.dom.test.tsx",
+        "src/components/Feed.ytsort.dom.test.tsx",
+        "src/components/FeedFiltersProvider.dom.test.ts",
+        "src/components/FeedFiltersProvider.seed.dom.test.tsx",
+        "src/components/Home.dom.test.tsx",
+        "src/components/Home.pin.dom.test.tsx",
+        "src/components/IssueComposer.dom.test.tsx",
+        "src/components/LibraryPlayer.dom.test.tsx",
+        "src/components/Messages.keyboard.dom.test.tsx",
+        "src/components/MyLogViewer.dom.test.tsx",
+        "src/components/NavigationProvider.dom.test.tsx",
+        "src/components/NotificationsPanel.menu.dom.test.tsx",
+        "src/components/OnboardingWizard.dialog.dom.test.tsx",
+        "src/components/OnboardingWizard.escape.dom.test.tsx",
+        "src/components/PaletteLauncher.dom.test.tsx",
+        "src/components/PersonalViewsModal.dom.test.tsx",
+        "src/components/PlayerModal.dom.test.tsx",
+        "src/components/PlaylistEditFailures.dom.test.tsx",
+        "src/components/PlaylistLimitsHint.dom.test.tsx",
+        "src/components/Playlists.dom.test.tsx",
+        "src/components/PlaylistsRail.rename.dom.test.tsx",
+        "src/components/PlexCollectionView.dom.test.tsx",
+        "src/components/PlexDiscover.dom.test.tsx",
+        "src/components/PlexInfo.dom.test.tsx",
+        "src/components/PlexLibraryPicker.dom.test.tsx",
+        "src/components/PlexMenu.dom.test.tsx",
+        "src/components/PlexPersonView.dom.test.tsx",
+        "src/components/PlexPlayer.backspace.dom.test.tsx",
+        "src/components/PlexPlayer.controls.dom.test.tsx",
+        "src/components/PlexPlayer.hls.dom.test.tsx",
+        "src/components/PlexPlayer.session.dom.test.tsx",
+        "src/components/PlexPlayer.strictmode.dom.test.tsx",
+        "src/components/PlexPlayer.tabtrap.dom.test.tsx",
+        "src/components/PlexPlayerSettings.dom.test.tsx",
+        "src/components/PlexPlaylistReorder.dom.test.tsx",
+        "src/components/PlexPlaylistView.header.dom.test.tsx",
+        "src/components/PlexPlaylistView.menu.dom.test.tsx",
+        "src/components/PlexProvider.dom.test.tsx",
+        "src/components/PlexScopeToggle.dom.test.tsx",
+        "src/components/PlexSearchBox.dom.test.tsx",
+        "src/components/PlexSidebar.picker.dom.test.tsx",
+        "src/components/PlexViewToggle.dom.test.tsx",
+        "src/components/PrefsProvider.dom.test.tsx",
+        "src/components/SavedViewsPopover.dom.test.tsx",
+        "src/components/SavedViewsProvider.dom.test.tsx",
+        "src/components/Scheduler.dom.test.tsx",
+        "src/components/Scheduler.menu.dom.test.tsx",
+        "src/components/SearchBar.dom.test.tsx",
+        "src/components/SearchBar.keys.dom.test.tsx",
+        "src/components/SettingsPanel.account.dom.test.tsx",
+        "src/components/SettingsPanel.downloadAuth.dom.test.tsx",
+        "src/components/ShareDialog.dom.test.tsx",
+        "src/components/TagFilterChips.dom.test.tsx",
+        "src/components/UpNextCard.dom.test.tsx",
+        "src/components/UploadDialog.dom.test.tsx",
+        "src/components/VideoCard.actions.dom.test.tsx",
+        "src/components/VideoCard.channel.dom.test.tsx",
+        "src/components/VideoCard.nav.dom.test.tsx",
+        "src/components/VideoEditor.partial.dom.test.tsx",
+        "src/components/VideoInfoCard.dom.test.tsx",
+        "src/components/VideoMenu.dom.test.tsx",
+        "src/components/WatchPage.dom.test.tsx",
+        "src/components/WriteFailureReporting.dom.test.tsx",
+        "src/components/accountPanel.dom.test.tsx",
+        "src/components/adminInvites.dom.test.tsx",
+        "src/components/adminPendingAccess.dom.test.tsx",
+        "src/components/auditColumns.dom.test.tsx",
+        "src/components/authCardStates.dom.test.tsx",
+        "src/components/channelChipNames.dom.test.tsx",
+        "src/components/channelColumns.dom.test.tsx",
+        "src/components/channelsTagRow.contract.test.ts",
+        "src/components/clientLogWiring.dom.test.tsx",
+        "src/components/comfortPin.dom.test.ts",
+        "src/components/comfortPin.langSwitch.dom.test.tsx",
+        "src/components/compilerCoverage.contract.test.ts",
+        "src/components/descriptionLinks.dom.test.tsx",
+        "src/components/downloadAdmin.dom.test.tsx",
+        "src/components/downloadRow.dom.test.tsx",
+        "src/components/facetOption.test.ts",
+        "src/components/formAlerts.dom.test.tsx",
+        "src/components/legal/legalBodies.contract.dom.test.tsx",
+        "src/components/listNav.wiring.contract.test.ts",
+        "src/components/mediaPicture.contract.test.ts",
+        "src/components/navigation.dom.test.ts",
+        "src/components/playlistsInit.test.ts",
+        "src/components/plexCards.dom.test.tsx",
+        "src/components/plexCards.lang.dom.test.tsx",
+        "src/components/plexCards.langSwitch.dom.test.tsx",
+        "src/components/plexShow.aside.dom.test.tsx",
+        "src/components/plexSubUrl.test.ts",
+        "src/components/plexViews.restart.dom.test.tsx",
+        "src/components/tagChipNames.dom.test.tsx",
+        "src/components/useChannelActions.dom.test.tsx",
+        "src/components/usePlaylistActions.dom.test.tsx",
+        "src/components/usePlexActiveFilters.dom.test.tsx",
+        "src/components/usePlexPlaylistEdits.dom.test.tsx",
+        "src/components/useTagSuggestions.dom.test.tsx",
+        "src/components/useVideoActions.dom.test.tsx",
+        "src/components/welcomeMode.dom.test.ts",
+        "src/components/welcomeMode.render.dom.test.tsx",
+        "src/i18n/appCopy.dom.test.ts",
+        "src/i18n/backendIds.contract.test.ts",
+        "src/i18n/copyRule.test.ts",
+        "src/i18n/parity.test.ts",
+        "src/i18n/plurals.test.ts",
+        "src/i18n/unusedKeys.contract.test.ts",
+        "src/jsxWhitespace.dom.test.tsx"
+      ],
+      "src/lib": [
+        "src/lib/actionErrors.ts",
+        "src/lib/activeAccount.ts",
+        "src/lib/adminUsers.ts",
+        "src/lib/adminUsersTab.ts",
+        "src/lib/api.ts",
+        "src/lib/api/account.ts",
+        "src/lib/api/admin.ts",
+        "src/lib/api/auth.ts",
+        "src/lib/api/channels.ts",
+        "src/lib/api/diagnostics.ts",
+        "src/lib/api/discover.ts",
+        "src/lib/api/downloads.ts",
+        "src/lib/api/feed.ts",
+        "src/lib/api/messaging.ts",
+        "src/lib/api/notifications.ts",
+        "src/lib/api/playlists.ts",
+        "src/lib/api/plex.ts",
+        "src/lib/api/quota.ts",
+        "src/lib/api/savedViews.ts",
+        "src/lib/api/setup.ts",
+        "src/lib/api/sync.ts",
+        "src/lib/api/tagModes.ts",
+        "src/lib/api/tags.ts",
+        "src/lib/auditGroups.ts",
+        "src/lib/backgroundTarget.ts",
+        "src/lib/brandIcons.ts",
+        "src/lib/browserBackgroundPlay.ts",
+        "src/lib/captureTab.ts",
+        "src/lib/channelDetailPoll.ts",
+        "src/lib/channelLayout.ts",
+        "src/lib/channelOrder.ts",
+        "src/lib/channelsUrlState.ts",
+        "src/lib/chatDock.ts",
+        "src/lib/chipOverflow.ts",
+        "src/lib/clipboard.ts",
+        "src/lib/collate.ts",
+        "src/lib/colorMath.ts",
+        "src/lib/columnSort.ts",
+        "src/lib/cropGeometry.ts",
+        "src/lib/dateFilter.ts",
+        "src/lib/debugRecorder.ts",
+        "src/lib/diagnostics.ts",
+        "src/lib/documentTitle.ts",
+        "src/lib/downloadActions.ts",
+        "src/lib/downloadFailure.ts",
+        "src/lib/downloads.ts",
+        "src/lib/e2ee.ts",
+        "src/lib/entryUrl.ts",
+        "src/lib/errorDialog.ts",
+        "src/lib/feedSort.ts",
+        "src/lib/feedView.ts",
+        "src/lib/filterLog.ts",
+        "src/lib/format.ts",
+        "src/lib/fullscreen.ts",
+        "src/lib/hints.ts",
+        "src/lib/history.ts",
+        "src/lib/homeIntent.ts",
+        "src/lib/hueTile.ts",
+        "src/lib/issueDraft.ts",
+        "src/lib/jobResult.ts",
+        "src/lib/keymap.ts",
+        "src/lib/layerStack.ts",
+        "src/lib/lazyWithPreload.ts",
+        "src/lib/linkify.tsx",
+        "src/lib/lintProbe.testkit.ts",
+        "src/lib/listNav.ts",
+        "src/lib/listPaging.ts",
+        "src/lib/log.ts",
+        "src/lib/logHooks.ts",
+        "src/lib/logsUrlState.ts",
+        "src/lib/mediaLog.ts",
+        "src/lib/mediaSource.ts",
+        "src/lib/messaging.ts",
+        "src/lib/modules.ts",
+        "src/lib/moveInList.ts",
+        "src/lib/nav.ts",
+        "src/lib/nextPage.ts",
+        "src/lib/notifications.ts",
+        "src/lib/onboarding.ts",
+        "src/lib/pageMeta.ts",
+        "src/lib/panelLayout.ts",
+        "src/lib/parseId.ts",
+        "src/lib/playerModalHooks.ts",
+        "src/lib/playerModes.ts",
+        "src/lib/playerQueue.ts",
+        "src/lib/playerVolume.ts",
+        "src/lib/playlistName.ts",
+        "src/lib/playlistView.ts",
+        "src/lib/plexDetail.ts",
+        "src/lib/plexImage.ts",
+        "src/lib/plexPlayerHooks.ts",
+        "src/lib/plexPlayerPrefs.ts",
+        "src/lib/plexQueue.ts",
+        "src/lib/plexRating.ts",
+        "src/lib/plexSearch.ts",
+        "src/lib/plexSort.ts",
+        "src/lib/plexStats.ts",
+        "src/lib/plexUrlState.ts",
+        "src/lib/plexWatch.ts",
+        "src/lib/progressCache.ts",
+        "src/lib/queryClient.ts",
+        "src/lib/queryKeys.ts",
+        "src/lib/reinsert.ts",
+        "src/lib/releaseNotes.ts",
+        "src/lib/saveLanguage.ts",
+        "src/lib/savedViews.ts",
+        "src/lib/seekableEnd.ts",
+        "src/lib/sortOptions.ts",
+        "src/lib/sourceSize.testkit.ts",
+        "src/lib/staleBuild.ts",
+        "src/lib/storage.ts",
+        "src/lib/store.ts",
+        "src/lib/subscriptionCache.ts",
+        "src/lib/tableColumns.ts",
+        "src/lib/tagPicks.ts",
+        "src/lib/textSelection.ts",
+        "src/lib/theme.ts",
+        "src/lib/toastDock.ts",
+        "src/lib/urlState.ts",
+        "src/lib/useActiveFilters.ts",
+        "src/lib/useCardPager.ts",
+        "src/lib/useChannelNames.ts",
+        "src/lib/useChannelPriority.ts",
+        "src/lib/useChannelTagActions.ts",
+        "src/lib/useChipOverflowFit.ts",
+        "src/lib/useDebounced.ts",
+        "src/lib/useDismiss.ts",
+        "src/lib/useFilterFold.ts",
+        "src/lib/useFilterState.ts",
+        "src/lib/useFocusKeeper.ts",
+        "src/lib/useHoverFocusWithin.ts",
+        "src/lib/useLatest.ts",
+        "src/lib/useLiveQuery.ts",
+        "src/lib/useMe.ts",
+        "src/lib/useMediaQuery.ts",
+        "src/lib/usePlexCollectionTitles.ts",
+        "src/lib/usePref.ts",
+        "src/lib/useScrollEdges.ts",
+        "src/lib/useScrollFade.ts",
+        "src/lib/useSortState.ts",
+        "src/lib/useTags.ts",
+        "src/lib/useUndoable.ts",
+        "src/lib/useUrlMirror.ts",
+        "src/lib/useVerifyEntry.ts",
+        "src/lib/version.ts",
+        "src/lib/vocab.ts",
+        "src/lib/youtube.ts",
+        "src/lib/youtubeErrors.ts"
+      ],
+      "ts configs": [
+        "devOnlyGuard.ts",
+        "playwright.config.ts",
+        "reactPlugin.ts",
+        "vite.config.ts",
+        "vitest.config.ts"
+      ],
+      "ui": [
+        "src/components/ui/ActionMenu.tsx",
+        "src/components/ui/Avatar.tsx",
+        "src/components/ui/BackToTop.tsx",
+        "src/components/ui/Badge.tsx",
+        "src/components/ui/Banner.tsx",
+        "src/components/ui/Button.tsx",
+        "src/components/ui/Carousel.tsx",
+        "src/components/ui/Chip.tsx",
+        "src/components/ui/ClampedText.tsx",
+        "src/components/ui/ColumnSortControl.tsx",
+        "src/components/ui/Combobox.tsx",
+        "src/components/ui/CommandPalette.tsx",
+        "src/components/ui/ContextMenu.tsx",
+        "src/components/ui/CountBadge.tsx",
+        "src/components/ui/DataTable.tsx",
+        "src/components/ui/DraftSaveBar.tsx",
+        "src/components/ui/DragHandle.tsx",
+        "src/components/ui/FilterChipGroup.tsx",
+        "src/components/ui/FilterFold.tsx",
+        "src/components/ui/FilterSelect.tsx",
+        "src/components/ui/Headings.tsx",
+        "src/components/ui/HiddenFilterCue.tsx",
+        "src/components/ui/IconButton.tsx",
+        "src/components/ui/InlineNotice.tsx",
+        "src/components/ui/Input.tsx",
+        "src/components/ui/ItemCount.tsx",
+        "src/components/ui/KeyboardHelp.tsx",
+        "src/components/ui/LinkButton.tsx",
+        "src/components/ui/MatchToggle.tsx",
+        "src/components/ui/MediaCard.tsx",
+        "src/components/ui/MediaPreview.tsx",
+        "src/components/ui/MenuCheck.tsx",
+        "src/components/ui/Modal.tsx",
+        "src/components/ui/MoreButton.tsx",
+        "src/components/ui/NativeControls.tsx",
+        "src/components/ui/NavGrid.tsx",
+        "src/components/ui/NavRail.tsx",
+        "src/components/ui/OrderButtons.tsx",
+        "src/components/ui/Overlay.tsx",
+        "src/components/ui/PageMenu.tsx",
+        "src/components/ui/PageScroller.tsx",
+        "src/components/ui/PageShell.tsx",
+        "src/components/ui/Pager.tsx",
+        "src/components/ui/PanelGroup.tsx",
+        "src/components/ui/PanelGroups.tsx",
+        "src/components/ui/Pressable.tsx",
+        "src/components/ui/PriorityStepper.tsx",
+        "src/components/ui/QueryState.tsx",
+        "src/components/ui/RelativeTime.tsx",
+        "src/components/ui/SegmentedToggle.tsx",
+        "src/components/ui/SelectTrigger.tsx",
+        "src/components/ui/SidePanel.tsx",
+        "src/components/ui/Skeleton.tsx",
+        "src/components/ui/SkipLink.tsx",
+        "src/components/ui/SortControl.tsx",
+        "src/components/ui/StatTiles.tsx",
+        "src/components/ui/Tabs.tsx",
+        "src/components/ui/Toaster.tsx",
+        "src/components/ui/Tooltip.tsx",
+        "src/components/ui/UndoToolbar.tsx",
+        "src/components/ui/VirtualGrid.tsx",
+        "src/components/ui/anchoredPopoverHooks.ts",
+        "src/components/ui/backToTopState.ts",
+        "src/components/ui/buttonStyles.ts",
+        "src/components/ui/chipStyles.ts",
+        "src/components/ui/dialogFocus.ts",
+        "src/components/ui/fieldStyles.ts",
+        "src/components/ui/form.tsx",
+        "src/components/ui/gridColumns.ts",
+        "src/components/ui/landmarks.ts",
+        "src/components/ui/mediaCardStyles.ts",
+        "src/components/ui/menuGroups.ts",
+        "src/components/ui/overlayOrder.ts",
+        "src/components/ui/pageHeading.ts",
+        "src/components/ui/pageMenuItems.ts",
+        "src/components/ui/pageMenuSlot.ts",
+        "src/components/ui/pageToolbarSlot.ts",
+        "src/components/ui/pagerContent.ts",
+        "src/components/ui/progressiveRows.ts",
+        "src/components/ui/readAhead.ts",
+        "src/components/ui/reveal.ts",
+        "src/components/ui/scrollFold.ts",
+        "src/components/ui/sortableA11y.ts",
+        "src/components/ui/stickyTop.ts",
+        "src/components/ui/surfaces.ts",
+        "src/components/ui/tabPanel.ts",
+        "src/components/ui/tableAlign.ts",
+        "src/components/ui/tableHeader.tsx",
+        "src/components/ui/toastLevels.ts",
+        "src/components/ui/useContextMenu.ts",
+        "src/components/ui/useMediaPreview.ts",
+        "src/components/ui/useOrderItems.tsx",
+        "src/components/ui/useReturnFocus.ts"
+      ],
+      "ui tests": [
+        "src/components/ui/ActionMenu.dom.test.tsx",
+        "src/components/ui/AnchoredPopover.dom.test.tsx",
+        "src/components/ui/AnchoredPopover.returnFocus.dom.test.tsx",
+        "src/components/ui/Avatar.dom.test.tsx",
+        "src/components/ui/BackToTop.dom.test.tsx",
+        "src/components/ui/Banner.dom.test.tsx",
+        "src/components/ui/Button.dom.test.tsx",
+        "src/components/ui/Carousel.dom.test.tsx",
+        "src/components/ui/Chip.dom.test.tsx",
+        "src/components/ui/ClampedText.dom.test.tsx",
+        "src/components/ui/Combobox.dom.test.tsx",
+        "src/components/ui/CommandPalette.dom.test.tsx",
+        "src/components/ui/CommandPalette.ordering.dom.test.tsx",
+        "src/components/ui/ContextMenu.dom.test.tsx",
+        "src/components/ui/DataTable.fixedLayout.dom.test.tsx",
+        "src/components/ui/DataTable.keyboard.dom.test.tsx",
+        "src/components/ui/DataTable.progressive.dom.test.tsx",
+        "src/components/ui/FilterChipGroup.dom.test.tsx",
+        "src/components/ui/FilterFold.dom.test.tsx",
+        "src/components/ui/FilterSelect.dom.test.tsx",
+        "src/components/ui/FocusSafeButton.select.dom.test.tsx",
+        "src/components/ui/HiddenFilterCue.dom.test.tsx",
+        "src/components/ui/IconButton.dom.test.tsx",
+        "src/components/ui/Input.dom.test.tsx",
+        "src/components/ui/ItemCount.dom.test.tsx",
+        "src/components/ui/KeyboardHelp.dom.test.tsx",
+        "src/components/ui/MatchToggle.dom.test.tsx",
+        "src/components/ui/Modal.dom.test.tsx",
+        "src/components/ui/Modal.fullscreen.dom.test.tsx",
+        "src/components/ui/Modal.purpose.dom.test.tsx",
+        "src/components/ui/Modal.strictmode.dom.test.tsx",
+        "src/components/ui/NavRail.dom.test.tsx",
+        "src/components/ui/OrderButtons.dom.test.tsx",
+        "src/components/ui/PageMenu.dom.test.tsx",
+        "src/components/ui/PageScroller.dom.test.tsx",
+        "src/components/ui/PageShell.dom.test.tsx",
+        "src/components/ui/Pager.dom.test.tsx",
+        "src/components/ui/PanelGroups.dom.test.tsx",
+        "src/components/ui/PriorityStepper.dom.test.tsx",
+        "src/components/ui/QueryState.dom.test.tsx",
+        "src/components/ui/RelativeTime.dom.test.tsx",
+        "src/components/ui/SegmentedToggle.dom.test.tsx",
+        "src/components/ui/SidePanel.drawer.dom.test.tsx",
+        "src/components/ui/SkipLink.dom.test.tsx",
+        "src/components/ui/SortControl.dom.test.tsx",
+        "src/components/ui/StatTiles.dom.test.tsx",
+        "src/components/ui/Tabs.dom.test.tsx",
+        "src/components/ui/Toaster.dom.test.tsx",
+        "src/components/ui/Toaster.hosts.test.ts",
+        "src/components/ui/Toaster.strictmode.dom.test.tsx",
+        "src/components/ui/Tooltip.layer.dom.test.tsx",
+        "src/components/ui/dialogFocus.dom.test.tsx",
+        "src/components/ui/form.dom.test.tsx",
+        "src/components/ui/gridColumns.test.ts",
+        "src/components/ui/hiddenFilterCue.contract.test.ts",
+        "src/components/ui/mediaRail.contract.test.ts",
+        "src/components/ui/menuCheck.contract.test.ts",
+        "src/components/ui/pageMenuScope.contract.test.ts",
+        "src/components/ui/pressableSelectable.contract.test.ts",
+        "src/components/ui/readAhead.test.ts",
+        "src/components/ui/scrollFold.test.ts",
+        "src/components/ui/sortableA11y.dom.test.tsx",
+        "src/components/ui/stickyTop.dom.test.tsx",
+        "src/components/ui/tailwindScan.contract.test.ts",
+        "src/components/ui/uiI18n.contract.test.ts",
+        "src/components/ui/useItemTriggers.dom.test.ts",
+        "src/components/ui/useReturnFocus.dom.test.tsx"
+      ]
+    }
+  },
+  "lanes": {
+    ".gitea/workflows/check.yml": [
+      "name: gate",
+      "on:",
+      "  push:",
+      "    branches: [\"**\"]",
+      "  pull_request:",
+      "jobs:",
+      "  frontend:",
+      "    runs-on: ubuntu-latest",
+      "    container: node:24-bookworm",
+      "    defaults:",
+      "      run:",
+      "        working-directory: frontend",
+      "    steps:",
+      "      - uses: actions/checkout@v4",
+      "      - run: npm ci",
+      "      - run: npm run typecheck",
+      "      - run: npm run lint",
+      "      - run: npm run format:check",
+      "      - run: npm run knip",
+      "      - run: npm run test",
+      "      - run: npx vite build",
+      "      - run: npm audit --omit=dev --audit-level=high",
+      "  backend:",
+      "    runs-on: ubuntu-latest",
+      "    container: nikolaik/python-nodejs:python3.12-nodejs24",
+      "    services:",
+      "      postgres:",
+      "        image: postgres:16-alpine",
+      "        env:",
+      "          POSTGRES_USER: siftlode",
+      "          POSTGRES_PASSWORD: siftlode",
+      "          POSTGRES_DB: siftlode_test",
+      "        options: >-",
+      "          --health-cmd \"pg_isready -U siftlode -d siftlode_test\"",
+      "          --health-interval 2s",
+      "          --health-timeout 3s",
+      "          --health-retries 30",
+      "    env:",
+      "      DATABASE_URL: postgresql+psycopg://siftlode:siftlode@postgres:5432/siftlode_test",
+      "      SIFTLODE_TEST_REQUIRE_DB: \"1\"",
+      "    steps:",
+      "      - uses: actions/checkout@v4",
+      "      - run: apt-get update && apt-get install -y --no-install-recommends ffmpeg postgresql-client",
+      "      - name: Wait for Postgres",
+      "        run: until pg_isready -h postgres -U siftlode -d siftlode_test; do sleep 1; done",
+      "      - run: pip install --no-cache-dir -r backend/requirements.lock -r backend/requirements-dev.txt",
+      "      - name: ruff",
+      "        run: python -m ruff check --config backend/ruff.toml backend scripts",
+      "      - name: ruff format --check",
+      "        run: python -m ruff format --check --config backend/ruff.toml backend scripts",
+      "      - name: basedpyright",
+      "        run: python -m basedpyright --project pyrightconfig.json",
+      "        working-directory: backend",
+      "      - name: basedpyright baseline is committed",
+      "        run: git diff --exit-code -- backend/.basedpyright/baseline.json",
+      "      - name: pytest",
+      "        run: python -m pytest",
+      "        working-directory: backend",
+      "      - name: pip-audit",
+      "        run: pip install --no-cache-dir pip-audit && pip-audit -r backend/requirements.lock"
+    ],
+    "backend/Dockerfile.test": [
+      "FROM python:3.12-slim",
+      "WORKDIR /app",
+      "RUN apt-get update \\",
+      "    && apt-get install -y --no-install-recommends ffmpeg \\",
+      "    && rm -rf /var/lib/apt/lists/*",
+      "COPY requirements.lock requirements-dev.txt ./",
+      "RUN pip install --no-cache-dir -r requirements.lock -r requirements-dev.txt"
+    ],
+    "backend/docker-compose.test.yml": [
+      "services:",
+      "  testdb:",
+      "    image: postgres:16-alpine",
+      "    environment:",
+      "      POSTGRES_USER: siftlode",
+      "      POSTGRES_PASSWORD: siftlode",
+      "      POSTGRES_DB: siftlode_test",
+      "    tmpfs:",
+      "      - /var/lib/postgresql/data  # ephemeral + fast; the schema is rebuilt per run",
+      "    healthcheck:",
+      "      test: [\"CMD-SHELL\", \"pg_isready -U siftlode -d siftlode_test\"]",
+      "      interval: 1s",
+      "      timeout: 3s",
+      "      retries: 30",
+      "  test:",
+      "    build:",
+      "      context: .",
+      "      dockerfile: Dockerfile.test",
+      "    depends_on:",
+      "      testdb:",
+      "        condition: service_healthy",
+      "    environment:",
+      "      DATABASE_URL: postgresql+psycopg://siftlode:siftlode@testdb:5432/siftlode_test",
+      "      SIFTLODE_TEST_REQUIRE_DB: \"1\"",
+      "    volumes:",
+      "      - ./:/app",
+      "    working_dir: /app",
+      "    command:",
+      "      - sh",
+      "      - -c",
+      "      - 'python -m pytest --cov=app --cov-report= ; rc=$$?; echo \">> backend coverage (app/) $$(python -m coverage report --format=total)% of lines\"; exit $$rc'"
+    ],
+    "frontend/.prettierignore": [
+      "dist",
+      "node_modules",
+      "playwright-report",
+      "test-results",
+      "e2e/.auth",
+      "package-lock.json"
+    ],
+    "frontend/package.json scripts": {
+      "build": "npm run typecheck:app && npm run typecheck:node && vite build",
+      "dev": "vite",
+      "e2e": "playwright test",
+      "format": "prettier --write .",
+      "format:check": "prettier --check .",
+      "knip": "knip && knip --production",
+      "lint": "eslint . --max-warnings 0",
+      "preview": "vite preview",
+      "test": "vitest run",
+      "test:watch": "vitest",
+      "typecheck": "npm run typecheck:app && npm run typecheck:node && npm run typecheck:e2e",
+      "typecheck:app": "tsc --noEmit -p tsconfig.json",
+      "typecheck:e2e": "tsc --noEmit -p e2e/tsconfig.json",
+      "typecheck:node": "tsc -p tsconfig.node.json"
+    },
+    "frontend/vitest.config.ts": [
+      "import { defineConfig } from \"vitest/config\";",
+      "import { reactWithCompiler } from \"./reactPlugin\";",
+      "export default defineConfig({",
+      "  plugins: [reactWithCompiler()],",
+      "  test: {",
+      "    include: [\"src/**/*.test.{ts,tsx}\"],",
+      "    environment: \"node\",",
+      "    coverage: {",
+      "      provider: \"v8\",",
+      "      include: [\"src/**/*.{ts,tsx}\"],",
+      "      exclude: [\"src/**/*.test.{ts,tsx}\", \"src/**/*.testkit.ts\", \"src/**/*.d.ts\"],",
+      "      reporter: [\"text-summary\"],",
+      "    },",
+      "  },",
+      "});"
+    ]
+  }
+}
diff --git a/frontend/src/lib/history.ts b/frontend/src/lib/history.ts
index d115d6a6..3f136f77 100644
--- a/frontend/src/lib/history.ts
+++ b/frontend/src/lib/history.ts
@@ -9,7 +9,7 @@
 //     its own button pops exactly its entry without tripping the modals underneath.
 //
 // setPage() pushes a clean { sfPage } entry (dropping _sub/_ov), so each page starts at its root.
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useEffectEvent, useMemo, useState } from "react";
 import { navPosition, restoreNavPosition, type NavPosition } from "./listNav";
 import { urlWithParams } from "./urlState";
 
@@ -137,12 +137,11 @@ export function useHistorySubview<T>(
     }
     return root;
   };
-  const readViewRef = useRef(readView);
-  readViewRef.current = readView;
   const [view, setView] = useState<T>(readView);
+  const readLandedView = useEffectEvent(readView);
   useEffect(() => {
     // Back/Forward restores the sub-view from the landed entry (state OR its restored ?<key> URL).
-    const onPop = () => setView(readViewRef.current());
+    const onPop = () => setView(readLandedView());
     window.addEventListener("popstate", onPop);
     return () => window.removeEventListener("popstate", onPop);
   }, []);
@@ -207,6 +206,9 @@ export function useHistorySubview<T>(
 type Overlay = { token: number; cb: () => void };
 const overlayStack: Overlay[] = [];
 let overlayCounter = 0;
+// A plain function, not `++overlayCounter` inline: the React Compiler cannot lower an update of a
+// module variable inside a hook, and skipped the whole hook for it (react-hooks/todo).
+const nextOverlayToken = () => ++overlayCounter;
 // Overlay history entries we've actually pushed. Reconciled toward overlayStack.length.
 let historyDepth = 0;
 // Programmatic history.back() calls still awaiting their popstate — each must be ignored.
@@ -222,7 +224,7 @@ function reconcileHistory(): void {
   const want = overlayStack.length;
   while (historyDepth < want) {
     historyDepth++;
-    window.history.pushState({ ...window.history.state, _ov: ++overlayCounter }, "");
+    window.history.pushState({ ...window.history.state, _ov: nextOverlayToken() }, "");
   }
   while (historyDepth > want) {
     historyDepth--;
@@ -367,11 +369,10 @@ export function closeTopOverlayThenRun(close: () => void, run: () => void): void
 /** While the calling component is mounted, Back (or the browser/mouse back button) closes it via
  * `onClose` instead of navigating away. Mount the component only while the overlay is open. */
 export function useBackToClose(onClose: () => void): void {
-  const cb = useRef(onClose);
-  cb.current = onClose;
+  const cb = useEffectEvent(onClose);
   useEffect(() => {
     ensureOverlayListener();
-    const entry: Overlay = { token: ++overlayCounter, cb: () => cb.current() };
+    const entry: Overlay = { token: nextOverlayToken(), cb: () => cb() };
     overlayStack.push(entry);
     scheduleReconcile();
     return () => {
@@ -391,12 +392,11 @@ export function useBackToClose(onClose: () => void): void {
  * `active` false, whose cleanup drops the entry and its history state on the next tick — exactly the
  * useBackToClose lifecycle, just gated on a flag. `onExit` runs on a genuine Back while active. */
 export function useBackToExit(active: boolean, onExit: () => void): void {
-  const cb = useRef(onExit);
-  cb.current = onExit;
+  const cb = useEffectEvent(onExit);
   useEffect(() => {
     if (!active) return;
     ensureOverlayListener();
-    const entry: Overlay = { token: ++overlayCounter, cb: () => cb.current() };
+    const entry: Overlay = { token: nextOverlayToken(), cb: () => cb() };
     overlayStack.push(entry);
     scheduleReconcile();
     return () => {
diff --git a/frontend/src/lib/homeIntent.ts b/frontend/src/lib/homeIntent.ts
index 4b8e8c44..ad20cee1 100644
--- a/frontend/src/lib/homeIntent.ts
+++ b/frontend/src/lib/homeIntent.ts
@@ -20,7 +20,7 @@ const surprise = createStore<number | null>(null);
 export const requestSurprise = (): void => surprise.set(ensureNavId());
 
 /** The pending token (null = nothing pending) — the render subscription that wakes Home up. Home only. */
-export const useSurpriseRequest = (): number | null => surprise.use();
+export const useSurpriseRequest = (): number | null => surprise.useValue();
 
 /** Take the pending request, clearing it; true only when it was requested for the entry Home is on.
  *
diff --git a/frontend/src/lib/issueDraft.ts b/frontend/src/lib/issueDraft.ts
index 60783988..4602d936 100644
--- a/frontend/src/lib/issueDraft.ts
+++ b/frontend/src/lib/issueDraft.ts
@@ -58,6 +58,7 @@ export function draftSteps(
 
 /** The operating system a user agent names. Checked most specific first: Android's agent also says
  *  "Linux" — and says it first — and an iPad's also says "Mac OS X". */
+/** @internal exported for issueDraft.test.ts */
 export function osName(ua: string): string {
   const tests: [RegExp, (m: RegExpExecArray) => string][] = [
     [/Android [\d.]+/, (m) => m[0]],
diff --git a/frontend/src/lib/jobResult.ts b/frontend/src/lib/jobResult.ts
index ff22e8ef..70b7bc45 100644
--- a/frontend/src/lib/jobResult.ts
+++ b/frontend/src/lib/jobResult.ts
@@ -7,6 +7,7 @@ import { vocabKey } from "./vocab";
  *  one-liner: `_summarize`'s "new=3, failed=0" (backend/app/scheduler.py). A flat one reads back into a
  *  result, and `enrich`'s bare count ("50") into `{enriched: 50}` as `_result_data` names it; a nested
  *  phase (a Python dict repr) or anything else does not, and stays as it was. */
+/** @internal exported for jobResult.dom.test.ts */
 export function parseSummary(summary: string | null | undefined): JobResult | null {
   if (!summary || /[{}[\]]/.test(summary)) return null;
   if (/^\d+$/.test(summary)) return { enriched: Number(summary) };
diff --git a/frontend/src/lib/keymap.ts b/frontend/src/lib/keymap.ts
index 3372b9c3..f37990a9 100644
--- a/frontend/src/lib/keymap.ts
+++ b/frontend/src/lib/keymap.ts
@@ -1,4 +1,4 @@
-import { useEffect, useRef, type RefObject } from "react";
+import { useEffect, useEffectEvent, type RefObject } from "react";
 import { anyBlockingLayer, escapeHandled } from "./layerStack";
 import { createStore } from "./store";
 import type { Page } from "./urlState";
@@ -259,6 +259,7 @@ function keyMatches(e: KeyboardEvent, name: string): boolean {
  *  Ctrl+A too, so select-all cycled the Plex audio track. It also means Shift+H is not `h` — a
  *  narrowing from the old `case "h": case "H":`, and the reason Shift chords can now be their own
  *  rows (Shift+← steps an episode without ← also seeking). */
+/** @internal exported for keymap.test.ts */
 export function matches(e: KeyboardEvent, chord: string): boolean {
   const parts = chord.split("+");
   const key = parts[parts.length - 1] ?? "";
@@ -415,7 +416,7 @@ const tokens: { scope: KeyScope }[] = [];
 
 /** The live scopes, innermost first, always ending in `global`. Re-renders on change. */
 export function useActiveScopes(): KeyScope[] {
-  const stack = scopeStack.use();
+  const stack = scopeStack.useValue();
   // DEDUPED: a scope can be registered by more than one live component (the Playlists page and its
   // rail each mount a `useContextMenu`), and `helpLines` appends a row's chords once per occurrence —
   // so without this the sheet rendered "⇧ F10 Menu ⇧ F10 Menu" under a duplicated React key
@@ -448,14 +449,14 @@ export const toggleKeyboardHelp = (): void => {
   helpOpen.set(next);
 };
 /** Subscribe to whether the sheet is showing (the Plex player suppresses wheel-volume under it). */
-export const useKeyboardHelpOpen = (): boolean => helpOpen.use();
+export const useKeyboardHelpOpen = (): boolean => helpOpen.useValue();
 /** Whether the sheet was opened over a keyboard-owning layer (see `helpOverLayer`). */
-export const useKeyboardHelpOverLayer = (): boolean => helpOverLayer.use();
+export const useKeyboardHelpOverLayer = (): boolean => helpOverLayer.useValue();
 
 // The modules this account can reach — published by `useGlobalKeymap`, read by the `g` chords and
 // by the sheet (which drops the chord of a gated module rather than promise a page that isn't there).
 const navigablePages = createStore<readonly Page[]>([]);
-export const useNavigablePages = (): readonly Page[] => navigablePages.use();
+export const useNavigablePages = (): readonly Page[] => navigablePages.useValue();
 
 // ── The command palette ───────────────────────────────────────────────────────────────────────
 const paletteOpen = createStore(false);
@@ -463,7 +464,7 @@ const paletteOpen = createStore(false);
 export const closePalette = (): void => paletteOpen.set(false);
 /** Open it from a visible control (the header's key cap / launcher), not only from Ctrl/Cmd+K. */
 export const openPalette = (): void => paletteOpen.set(true);
-export const usePaletteOpen = (): boolean => paletteOpen.use();
+export const usePaletteOpen = (): boolean => paletteOpen.useValue();
 
 /** Bind the `global` and `page` scopes, once, for the whole app. It lives here rather than inside
  *  either overlay because both are opened by it: a listener that sat in one of them would have to
@@ -482,10 +483,9 @@ export function useGlobalKeymap(
   pages: readonly Page[],
 ): void {
   // The page jumps are the global keys whose action lives OUTSIDE this file — navigation is a
-  // provider and `lib/` may not import a component — so App hands it in. Kept in a ref so a fresh
+  // provider and `lib/` may not import a component — so App hands it in. An effect event, so a fresh
   // closure each render doesn't rebind the window listener (and can't leave a stale `setPage`).
-  const navRef = useRef(onNavigate);
-  navRef.current = onNavigate;
+  const navigate = useEffectEvent(onNavigate);
   useKeyScope("page", enabled);
   const pagesKey = pages.join(",");
   useEffect(() => {
@@ -505,7 +505,7 @@ export function useGlobalKeymap(
         (ev: KeyboardEvent) => {
           if (!s.page || !navigablePages.get().includes(s.page)) return;
           ev.preventDefault();
-          navRef.current(s.page);
+          navigate(s.page);
         },
       ]),
     ) as { readonly [K in ShortcutId<"page">]: (e: KeyboardEvent) => void };
@@ -528,7 +528,7 @@ export function useGlobalKeymap(
         },
         home: (ev) => {
           ev.preventDefault();
-          navRef.current("home");
+          navigate("home");
         },
       });
       if (!handled) dispatch(e, "page", pageHandlers);
@@ -576,7 +576,7 @@ export function useSearchFocusKey(input: RefObject<HTMLInputElement | null>): vo
   }, [input]);
 }
 
-export const useHelpConditionValues = (): HelpConditions => helpConditions.use();
+export const useHelpConditionValues = (): HelpConditions => helpConditions.useValue();
 
 // ── Display ───────────────────────────────────────────────────────────────────────────────────
 const GLYPHS: Record<string, string> = {
diff --git a/frontend/src/lib/layerStack.ts b/frontend/src/lib/layerStack.ts
index 23abd042..0a1ed310 100644
--- a/frontend/src/lib/layerStack.ts
+++ b/frontend/src/lib/layerStack.ts
@@ -1,4 +1,4 @@
-import { useEffect, useRef } from "react";
+import { useEffect, useEffectEvent, useRef } from "react";
 
 // R8 S3 — one shared registry of open "dismissable layers" (modals, popovers, players), ordered by
 // open time. It replaces the three mutually-unaware Escape systems that each guessed at ordering with
@@ -48,6 +48,7 @@ export function anyBlockingLayer(): boolean {
   return stack.some((id) => !passive.has(id));
 }
 
+/** @internal exported for layerStack.dom.test.ts */
 export function isTopmost(id: number): boolean {
   return stack.length > 0 && stack[stack.length - 1] === id;
 }
@@ -78,6 +79,7 @@ export function anyBlockingLayerAbove(id: number): boolean {
 // mutation; `anyLayerAbove` stays as the fallback for a layer above with no Escape handler of its own.
 // WeakSet so a spent event is GC'd without a manual sweep.
 const handledEscapes = new WeakSet<KeyboardEvent>();
+/** @internal exported for keymap.test.ts, layerStack.dom.test.ts */
 export function markEscapeHandled(e: KeyboardEvent): void {
   handledEscapes.add(e);
 }
@@ -105,24 +107,21 @@ export function useLayer(
   opts?: { passive?: boolean; trapsTab?: boolean },
 ): { isTopmost: () => boolean; anyAbove: () => boolean; blockingAbove: () => boolean } {
   const idRef = useRef<number | null>(null);
-  const escRef = useRef(onEscape);
-  escRef.current = onEscape;
-  const optsRef = useRef(opts);
-  optsRef.current = opts;
+  const escape = useEffectEvent(() => onEscape?.());
+  const hasEscape = onEscape !== undefined;
+  const passive = !!opts?.passive;
+  const trapsTab = opts?.trapsTab;
 
   useEffect(() => {
     if (!active) return;
-    const id = pushLayer({
-      passive: !!optsRef.current?.passive,
-      trapsTab: optsRef.current?.trapsTab,
-    });
+    const id = pushLayer({ passive, trapsTab });
     idRef.current = id;
     let onKey: ((e: KeyboardEvent) => void) | undefined;
-    if (escRef.current) {
+    if (hasEscape) {
       onKey = (e: KeyboardEvent) => {
         // takeEscape stamps BEFORE closing, so a `window` listener below (fires after this `document`
         // one) sees the Escape as consumed even though closing us pops this layer off the stack.
-        if (takeEscape(e, id)) escRef.current?.();
+        if (takeEscape(e, id)) escape();
       };
       document.addEventListener("keydown", onKey);
     }
@@ -131,8 +130,9 @@ export function useLayer(
       removeLayer(id);
       idRef.current = null;
     };
-    // Re-register only when open/closed toggles; onEscape is read fresh via escRef.
-  }, [active]);
+    // Re-register when open/closed toggles (the shape flags are constant per caller); the Escape
+    // handler is an effect event, so a new `onEscape` each render never re-registers the layer.
+  }, [active, hasEscape, passive, trapsTab]);
 
   return {
     isTopmost: () => idRef.current != null && isTopmost(idRef.current),
diff --git a/frontend/src/lib/lintProbe.testkit.ts b/frontend/src/lib/lintProbe.testkit.ts
index 4e513bea..849b8f42 100644
--- a/frontend/src/lib/lintProbe.testkit.ts
+++ b/frontend/src/lib/lintProbe.testkit.ts
@@ -9,7 +9,31 @@ import { beforeAll } from "vitest";
 // hook below pays that cost once per test file, under its own budget; importing this registers it.
 const FRONTEND = fileURLToPath(new URL("../../", import.meta.url));
 
-export const eslint = new ESLint({ cwd: FRONTEND });
+// The probes lint TEXT under file names that do not exist (`__probe.tsx`, `x.ts`, a feature-folder
+// `Button.tsx`). Since E32 the src config runs type-aware rules, whose project service refuses a
+// file no tsconfig includes, so those names are let into TypeScript's default project here — the
+// probe still runs the real config, typed rules included, rather than a copy with them switched off.
+const PROBE_FILES = [
+  "src/*/__*probe.ts",
+  "src/*/__*probe.tsx",
+  "src/components/ui/__*probe.tsx",
+  "src/lib/api/__*probe.ts",
+  "src/components/Button.tsx",
+  "src/lib/x.ts",
+];
+
+export const eslint = new ESLint({
+  cwd: FRONTEND,
+  overrideConfig: {
+    files: ["src/**/*.{ts,tsx}"],
+    languageOptions: {
+      parserOptions: {
+        projectService: { allowDefaultProject: PROBE_FILES, defaultProject: "tsconfig.json" },
+        tsconfigRootDir: FRONTEND,
+      },
+    },
+  },
+});
 
 beforeAll(async () => {
   await eslint.lintText("", { filePath: "src/components/__probe.tsx" });
diff --git a/frontend/src/lib/listNav.ts b/frontend/src/lib/listNav.ts
index b0a94845..39c6d89c 100644
--- a/frontend/src/lib/listNav.ts
+++ b/frontend/src/lib/listNav.ts
@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState, type RefObject } from "react";
+import { useEffect, useEffectEvent, useState, type RefObject } from "react";
 import { dispatch, useKeyScope } from "./keymap";
 import { scrollParent } from "./listPaging";
 import { focusIsUnclaimed } from "./useFocusKeeper";
@@ -490,8 +490,8 @@ export function useListNav(
     onDelete?: (index: number) => void;
   },
 ): void {
-  const optsRef = useRef(opts);
-  optsRef.current = opts;
+  // Read when a key is pressed, so the registration below never re-runs for a new `opts` object.
+  const latestOpts = useEffectEvent(() => opts);
   // The `list` keys do something only while there is an item to land on. An empty queue, a list still
   // loading or one that failed mounts its container all the same, and the cheat sheet listed j/k, the
   // arrows and Enter over nothing (keymap: a scope is pushed only while its keys really do something).
@@ -503,10 +503,10 @@ export function useListNav(
     if (!opts.enabled || !el) return;
     lists.set(el, {
       el,
-      count: () => optsRef.current.count ?? ownItems(el).length,
-      cols: () => optsRef.current.cols ?? measuredCols(el),
-      reveal: (i) => optsRef.current.reveal?.(i),
-      remove: () => optsRef.current.onDelete ?? null,
+      count: () => latestOpts().count ?? ownItems(el).length,
+      cols: () => latestOpts().cols ?? measuredCols(el),
+      reveal: (i) => latestOpts().reveal?.(i),
+      remove: () => latestOpts().onDelete ?? null,
     });
     el.setAttribute(LIST, "");
     const check = () => setHasItems(el.querySelector(`[${INDEX}]`) !== null);
diff --git a/frontend/src/lib/listPaging.ts b/frontend/src/lib/listPaging.ts
index 78f9c033..6468535a 100644
--- a/frontend/src/lib/listPaging.ts
+++ b/frontend/src/lib/listPaging.ts
@@ -3,7 +3,10 @@
 // over hundreds of channels, the Plex pickers, the filter and sort menus — had only the arrows. One
 // definition of "a page" here, so the palette and the dropdowns cannot drift apart.
 
-/** A page when there is no layout to measure (jsdom, or a list not painted yet). */
+/**
+ * A page when there is no layout to measure (jsdom, or a list not painted yet).
+ * @internal exported for listPaging.test.ts
+ */
 export const PAGE_FALLBACK = 10;
 
 /** The nearest ancestor that scrolls vertically. */
diff --git a/frontend/src/lib/log.ts b/frontend/src/lib/log.ts
index e3c347c8..ce36e3bf 100644
--- a/frontend/src/lib/log.ts
+++ b/frontend/src/lib/log.ts
@@ -21,7 +21,10 @@ import { FRONTEND_VERSION } from "./version";
 
 export type Level = "TRACE" | "DEBUG" | "INFO" | "WARNING" | "ERROR" | "CRITICAL";
 
-/** OpenTelemetry severity numbers — the same table as `logs.SEVERITY` (a contract test compares). */
+/**
+ * OpenTelemetry severity numbers — the same table as `logs.SEVERITY` (a contract test compares).
+ * @internal exported for log.contract.test.ts
+ */
 export const SEVERITY: Record<Level, number> = {
   TRACE: 1,
   DEBUG: 5,
@@ -59,6 +62,7 @@ export interface LogEvent {
 
 /** Events kept. At ~0.5 KB each the ring stays around a megabyte — a long session's worth of
  *  navigation and requests, without growing for as long as a tab stays open. */
+/** @internal exported for log.test.ts */
 export const RING_MAX = 2000;
 
 // --- redaction (mirrors backend/app/logs.py) ------------------------------------------------------
@@ -97,6 +101,7 @@ function redactText(text: string): string {
 
 /** Recursively scrub a structure destined for the log. A value whose KEY names a secret is dropped
  *  whole — a prefix of a token is still a leak. Everything else is scrubbed as text. */
+/** @internal exported for log.contract.test.ts */
 export function redact(value: unknown, key = ""): unknown {
   const lowered = key.toLowerCase();
   if (key && SECRET_KEY_PARTS.some((part) => lowered.includes(part))) return REDACTED;
diff --git a/frontend/src/lib/mediaLog.ts b/frontend/src/lib/mediaLog.ts
index ad839847..c97b55b3 100644
--- a/frontend/src/lib/mediaLog.ts
+++ b/frontend/src/lib/mediaLog.ts
@@ -88,3 +88,11 @@ export function logYouTubeState(state: number, at: number): void {
 export function logYouTubeError(code: number): void {
   log.warn("player.media_error", `youtube error ${code}`, { player: "youtube", code });
 }
+
+/** The IFrame API script never arrived (blocked, offline, timed out), so there is no player at all. */
+export function logYouTubeApiFailed(err: unknown): void {
+  log.warn("player.yt_api_failed", "the YouTube player could not be loaded", {
+    player: "youtube",
+    reason: err instanceof Error ? err.message : String(err),
+  });
+}
diff --git a/frontend/src/lib/modules.ts b/frontend/src/lib/modules.ts
index 43aae549..d6147779 100644
--- a/frontend/src/lib/modules.ts
+++ b/frontend/src/lib/modules.ts
@@ -13,9 +13,9 @@ import {
   SlidersHorizontal,
   Tv,
   Users,
-  Youtube,
   type LucideIcon,
 } from "lucide-react";
+import { YouTubeIcon } from "./brandIcons";
 import type { Me } from "./api";
 import type { Page } from "./urlState";
 
@@ -62,7 +62,7 @@ const MODULES: readonly ModuleDef[] = [
     titleKey: "home.title",
     icon: Home,
   },
-  { id: "feed", labelKey: "header.account.feed", railKey: "nav.rail.feed", icon: Youtube },
+  { id: "feed", labelKey: "header.account.feed", railKey: "nav.rail.feed", icon: YouTubeIcon },
   {
     id: "channels",
     labelKey: "header.account.channels",
diff --git a/frontend/src/lib/notifications.ts b/frontend/src/lib/notifications.ts
index 96d0914b..60b16a72 100644
--- a/frontend/src/lib/notifications.ts
+++ b/frontend/src/lib/notifications.ts
@@ -95,6 +95,7 @@ const ERROR_TTL = 15000;
 // A toast that carries an action (an "Undo") lives at least this long, whatever the reader's toast
 // time: its button is the only way back, and a 3 s toast leaves no time to reach it (owner, E28).
 // The setting still decides for longer, and "never" still means never.
+/** @internal exported for notifications.actionTtl.dom.test.ts */
 export const ACTION_TTL_MIN = 8000;
 
 // 6b: per-account notification settings (persisted by the Settings panel into the
diff --git a/frontend/src/lib/playerModalHooks.apiload.dom.test.tsx b/frontend/src/lib/playerModalHooks.apiload.dom.test.tsx
new file mode 100644
index 00000000..54ae2e66
--- /dev/null
+++ b/frontend/src/lib/playerModalHooks.apiload.dom.test.tsx
@@ -0,0 +1,84 @@
+// @vitest-environment jsdom
+//
+// The YouTube IFrame API script failing to load must END in an error state. `loadYouTubeApi` used to
+// return a promise that only ever resolved: a blocked or failed script (a content blocker, no
+// network) left the modal on an empty stage forever, with no error and no way to retry short of a
+// reload — the promise was memoised, so every later open waited on the same dead one (E32 audit).
+//
+// Its own file on purpose: `loadYouTubeApi` memoises the API promise in a module-level singleton,
+// and these tests need a module instance that has never seen `window.YT`.
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { QueryClient } from "@tanstack/react-query";
+import { createRef, type RefObject } from "react";
+import { useYtProgress, YT_API_LOAD_FAILED, YT_API_TIMEOUT_MS } from "./playerModalHooks";
+import type { YTPlayer } from "./youtube";
+
+const VID = "EC5oFYy9z9g";
+
+const apiScripts = () =>
+  [...document.head.querySelectorAll("script")].filter((s) => s.src.includes("iframe_api"));
+
+const settle = async () => {
+  for (let i = 0; i < 6; i++) await Promise.resolve();
+};
+
+function mountPlayer(setPlayerError: (code: number | null) => void) {
+  const mount = document.createElement("div");
+  document.body.appendChild(mount);
+  return renderHook(() =>
+    useYtProgress({
+      activeId: VID,
+      resumeAt: 0,
+      mountRef: { current: mount },
+      playerRef: createRef<YTPlayer>() as RefObject<YTPlayer | null>,
+      currentIdRef: { current: VID },
+      navRef: { current: { queue: undefined, index: 0 } },
+      modeRef: { current: { autoMode: "off", loopMode: "off" } },
+      setWatched: () => {},
+      setPlayerError,
+      setLiveData: () => {},
+      reapplyStored: () => {},
+      focusModal: () => {},
+      advanceOnEnd: () => {},
+      sessionPosRef: { current: new Map() },
+      qc: new QueryClient(),
+    }),
+  );
+}
+
+describe("useYtProgress — the IFrame API failing to load", () => {
+  // Fail any load still in flight, so the module's memoised promise is cleared for the next test
+  // (a pending one would carry a timer from before that test's fake clock).
+  afterEach(async () => {
+    for (const s of apiScripts()) s.dispatchEvent(new Event("error"));
+    await settle();
+    vi.useRealTimers();
+  });
+
+  it("shows the load-failed state when the script errors, and a later open tries again", async () => {
+    const setPlayerError = vi.fn();
+    const first = mountPlayer(setPlayerError);
+    const [tag] = apiScripts();
+    expect(tag).toBeDefined();
+    tag!.dispatchEvent(new Event("error"));
+    await settle();
+    expect(setPlayerError).toHaveBeenCalledWith(YT_API_LOAD_FAILED);
+    first.unmount();
+
+    // Not memoised as a failure: the next open loads the script again rather than waiting on the
+    // dead promise.
+    const again = mountPlayer(vi.fn());
+    expect(apiScripts()).toHaveLength(1);
+    again.unmount();
+  });
+
+  it("gives up after the timeout when the script never answers", async () => {
+    vi.useFakeTimers();
+    const setPlayerError = vi.fn();
+    const { unmount } = mountPlayer(setPlayerError);
+    await vi.advanceTimersByTimeAsync(YT_API_TIMEOUT_MS + 1);
+    expect(setPlayerError).toHaveBeenCalledWith(YT_API_LOAD_FAILED);
+    unmount();
+  });
+});
diff --git a/frontend/src/lib/playerModalHooks.progress.dom.test.tsx b/frontend/src/lib/playerModalHooks.progress.dom.test.tsx
index c27fee77..30bb2c78 100644
--- a/frontend/src/lib/playerModalHooks.progress.dom.test.tsx
+++ b/frontend/src/lib/playerModalHooks.progress.dom.test.tsx
@@ -12,7 +12,7 @@
 import { describe, it, expect, vi, afterEach } from "vitest";
 import { renderHook } from "@testing-library/react";
 import { QueryClient } from "@tanstack/react-query";
-import { createRef, type MutableRefObject } from "react";
+import { createRef, type RefObject } from "react";
 import { useYtProgress } from "./playerModalHooks";
 import { patchCachedProgress } from "./progressCache";
 import { qk } from "./queryKeys";
@@ -73,7 +73,7 @@ function mountPlayer(qc: QueryClient, sessionPos: Map<string, number>) {
       activeId: VID,
       resumeAt: 748,
       mountRef: { current: mount },
-      playerRef: createRef<YTPlayer>() as MutableRefObject<YTPlayer | null>,
+      playerRef: createRef<YTPlayer>() as RefObject<YTPlayer | null>,
       currentIdRef: { current: VID },
       navRef: { current: { queue: undefined, index: 0 } },
       modeRef: { current: { autoMode: "off", loopMode: "off" } },
diff --git a/frontend/src/lib/playerModalHooks.ts b/frontend/src/lib/playerModalHooks.ts
index b0b15f88..d2773848 100644
--- a/frontend/src/lib/playerModalHooks.ts
+++ b/frontend/src/lib/playerModalHooks.ts
@@ -4,7 +4,6 @@ import {
   useRef,
   useState,
   type Dispatch,
-  type MutableRefObject,
   type RefObject,
   type SetStateAction,
 } from "react";
@@ -22,7 +21,7 @@ import { api, type Video } from "./api";
 import { qk } from "./queryKeys";
 import { patchCachedProgress } from "./progressCache";
 import type { YTNamespace, YTPlayer, YTPlayerEvent } from "./youtube";
-import { logYouTubeError, logYouTubeState } from "./mediaLog";
+import { logYouTubeApiFailed, logYouTubeError, logYouTubeState } from "./mediaLog";
 import type { AutoMode, LoopMode } from "./playerModes";
 
 // How close to the end (seconds) counts as "finished" → auto-mark watched.
@@ -32,19 +31,37 @@ const FINISH_MARGIN = 10;
 const MAX_CONSECUTIVE_ERRORS = 3;
 
 // --- IFrame Player API loader (singleton) ---
+/** `playerError` when the IFrame API itself never arrived — not one of YouTube's own error codes
+ *  (2/5/100/101/150, all positive), and distinct from the -1 an unparseable one maps to. */
+export const YT_API_LOAD_FAILED = -2;
+/** How long the script may take before the player gives up on it. The real answer comes in well
+ *  under a second; anything near this is a blocked or stalled request, not a slow one. */
+/** @internal exported for playerModalHooks.apiload.dom.test.tsx */
+export const YT_API_TIMEOUT_MS = 15_000;
 let apiPromise: Promise<YTNamespace> | null = null;
 function loadYouTubeApi(): Promise<YTNamespace> {
   if (apiPromise) return apiPromise;
-  apiPromise = new Promise<YTNamespace>((resolve) => {
+  apiPromise = new Promise<YTNamespace>((resolve, reject) => {
     const w = window;
     if (w.YT && w.YT.Player) return resolve(w.YT);
+    const tag = document.createElement("script");
+    // A failure is not memoised: the next open loads the script again instead of waiting on a
+    // promise that already lost (a blocker switched off, the network back).
+    const fail = (why: string) => {
+      window.clearTimeout(timer);
+      apiPromise = null;
+      tag.remove();
+      reject(new Error(`YouTube IFrame API ${why}`));
+    };
+    const timer = window.setTimeout(() => fail("timed out"), YT_API_TIMEOUT_MS);
     const prev = w.onYouTubeIframeAPIReady;
     w.onYouTubeIframeAPIReady = () => {
+      window.clearTimeout(timer);
       if (typeof prev === "function") prev();
       // The API-ready callback only fires once the script has installed window.YT.
       resolve(w.YT!);
     };
-    const tag = document.createElement("script");
+    tag.onerror = () => fail("failed to load");
     tag.src = "https://www.youtube.com/iframe_api";
     document.head.appendChild(tag);
   });
@@ -67,7 +84,7 @@ export function useYtVolume({
   dialogRef,
   focusModal,
 }: {
-  playerRef: MutableRefObject<YTPlayer | null>;
+  playerRef: RefObject<YTPlayer | null>;
   dialogRef: RefObject<HTMLDivElement | null>;
   focusModal: () => void;
 }): {
@@ -188,7 +205,7 @@ export function useNativeControlsYield({
   stageRef,
   focusModal,
 }: {
-  playerRef: MutableRefObject<YTPlayer | null>;
+  playerRef: RefObject<YTPlayer | null>;
   stageRef: RefObject<HTMLDivElement | null>;
   focusModal: () => void;
 }): {
@@ -234,13 +251,12 @@ export function useYtBigView({
   focusModal,
 }: {
   stageRef: RefObject<HTMLDivElement | null>;
-  playerRef: MutableRefObject<YTPlayer | null>;
+  playerRef: RefObject<YTPlayer | null>;
   focusModal: () => void;
 }): {
   isFullscreen: boolean;
   maximized: boolean;
-  maximizedRef: MutableRefObject<boolean>;
-  isFullscreenRef: MutableRefObject<boolean>;
+  isFullscreenRef: RefObject<boolean>;
   toggleFullscreen: () => void;
   toggleTrueFullscreen: () => void;
   exitBigView: () => void;
@@ -250,8 +266,6 @@ export function useYtBigView({
   const [isFullscreen, setIsFullscreen] = useState(false);
   // Our own "fills the viewport" mode (the F key). Not the Fullscreen API — see toggleFullscreen.
   const [maximized, setMaximized] = useState(false);
-  const maximizedRef = useRef(false);
-  maximizedRef.current = maximized;
   // Mirrored into a ref because the keydown handler is bound once and would otherwise read false forever.
   const isFullscreenRef = useRef(false);
   // Nested Back: peel fullscreen → maximise → close, one Back at a time (each a history layer only while
@@ -293,7 +307,6 @@ export function useYtBigView({
   return {
     isFullscreen,
     maximized,
-    maximizedRef,
     isFullscreenRef,
     toggleFullscreen,
     toggleTrueFullscreen,
@@ -302,6 +315,21 @@ export function useYtBigView({
   };
 }
 
+/** The player's position and length, or null when there is no usable player — not built yet, or
+ *  tearing down (its methods throw then). Outside the hook: the React Compiler cannot lower a
+ *  conditional inside a try yet, and skipped useYtProgress for it. */
+function playerTimes(p: YTPlayer | null): { cur: number; dur: number } | null {
+  if (!p || typeof p.getCurrentTime !== "function") return null;
+  try {
+    return {
+      cur: p.getCurrentTime(),
+      dur: typeof p.getDuration === "function" ? p.getDuration() : 0,
+    };
+  } catch {
+    return null;
+  }
+}
+
 /** Create the YouTube IFrame player for the active item, resume from the saved position, checkpoint
  * progress every 5 s (+ a pagehide beacon), and auto-mark watched once playback reaches the end. Keyed
  * on activeId (a queue advance recreates the player to reuse this single-video logic). The once-bound
@@ -327,10 +355,10 @@ export function useYtProgress({
   activeId: string;
   resumeAt: number;
   mountRef: RefObject<HTMLDivElement | null>;
-  playerRef: MutableRefObject<YTPlayer | null>;
-  currentIdRef: MutableRefObject<string>;
-  navRef: MutableRefObject<{ queue: Video[] | undefined; index: number }>;
-  modeRef: MutableRefObject<{ autoMode: AutoMode; loopMode: LoopMode }>;
+  playerRef: RefObject<YTPlayer | null>;
+  currentIdRef: RefObject<string>;
+  navRef: RefObject<{ queue: Video[] | undefined; index: number }>;
+  modeRef: RefObject<{ autoMode: AutoMode; loopMode: LoopMode }>;
   setWatched: (on: boolean) => void;
   setPlayerError: (code: number | null) => void;
   setLiveData: (d: { title?: string; author?: string } | null) => void;
@@ -340,15 +368,39 @@ export function useYtProgress({
   // Positions this player session has actually STORED, per video id. Written from the server's
   // answer, read back by the modal's resume so stepping next→prev inside one session does not
   // rewind to the value the frozen launch queue was snapshotted with.
-  sessionPosRef: MutableRefObject<Map<string, number>>;
+  sessionPosRef: RefObject<Map<string, number>>;
   qc: QueryClient;
 }): void {
   const autoMarkedRef = useRef(false);
   const errorStreakRef = useRef(0);
+  // The render values this player is built from, read ONCE when it is built (see the dep note at
+  // the end of the effect).
+  const itemSnapshot = useEffectEvent(() => ({
+    resumeAt,
+    setWatched,
+    setPlayerError,
+    setLiveData,
+    reapplyStored,
+    focusModal,
+    advanceOnEnd,
+    qc,
+  }));
 
   useEffect(() => {
     let cancelled = false;
     const id = activeId;
+    const {
+      resumeAt,
+      setWatched,
+      setPlayerError,
+      setLiveData,
+      reapplyStored,
+      focusModal,
+      advanceOnEnd,
+      qc,
+    } = itemSnapshot();
+    // A position this session already stored for the item beats the queue's snapshot of it.
+    const startAt = sessionPosRef.current.get(id) ?? resumeAt;
     autoMarkedRef.current = false;
     setPlayerError(null);
 
@@ -366,91 +418,94 @@ export function useYtProgress({
       return false;
     };
     const persist = (): Promise<unknown> | void => {
-      const p = playerRef.current;
-      if (!p || typeof p.getCurrentTime !== "function") return;
-      try {
-        const cur = p.getCurrentTime();
-        const dur = typeof p.getDuration === "function" ? p.getDuration() : 0;
-        // If we just auto-marked watched, skip the near-end checkpoint (it would only clear the resume
-        // position, racing the watched write against the progress row it deletes).
-        if (maybeAutoWatch(cur, dur)) return;
-        // Only checkpoint the library item we opened with — a navigated-to video may not be in this
-        // user's library, so the server would 404 on it.
-        if (currentIdRef.current === id) {
-          return (
-            api
-              .saveProgress(id, cur, dur)
-              // Record what the server STORED, not `cur`: a near-end or under-5s checkpoint is
-              // cleared to 0 there, and the resume must agree with the row, not with our reading.
-              .then((res) => void sessionPosRef.current.set(id, res.position_seconds))
-              .catch(() => {})
-          );
-        }
-      } catch {
-        /* player may be tearing down */
+      const times = playerTimes(playerRef.current);
+      if (!times) return;
+      const { cur, dur } = times;
+      // If we just auto-marked watched, skip the near-end checkpoint (it would only clear the resume
+      // position, racing the watched write against the progress row it deletes).
+      if (maybeAutoWatch(cur, dur)) return;
+      // Only checkpoint the library item we opened with — a navigated-to video may not be in this
+      // user's library, so the server would 404 on it.
+      if (currentIdRef.current === id) {
+        return (
+          api
+            .saveProgress(id, cur, dur)
+            // Record what the server STORED, not `cur`: a near-end or under-5s checkpoint is
+            // cleared to 0 there, and the resume must agree with the row, not with our reading.
+            .then((res) => void sessionPosRef.current.set(id, res.position_seconds))
+            .catch(() => {})
+        );
       }
     };
 
-    loadYouTubeApi().then((YT) => {
-      if (cancelled || !mountRef.current) return;
-      playerRef.current = new YT.Player(mountRef.current, {
-        width: "100%",
-        height: "100%",
-        videoId: id,
-        playerVars: {
-          autoplay: 1,
-          start: resumeAt || undefined,
-          rel: 0, // limit "related" to the same channel (full removal is no longer possible)
-          enablejsapi: 1,
-          origin: window.location.origin,
-          playsinline: 1,
-          // Best-effort HD hint (mostly a no-op now; YouTube hard-caps embed quality by on-screen size).
-          vq: "hd1080",
-        },
-        events: {
-          onReady: () => {
-            focusModal();
-            reapplyStored();
+    loadYouTubeApi()
+      .then((YT) => {
+        if (cancelled || !mountRef.current) return;
+        playerRef.current = new YT.Player(mountRef.current, {
+          width: "100%",
+          height: "100%",
+          videoId: id,
+          playerVars: {
+            autoplay: 1,
+            start: startAt || undefined,
+            rel: 0, // limit "related" to the same channel (full removal is no longer possible)
+            enablejsapi: 1,
+            origin: window.location.origin,
+            playsinline: 1,
+            // Best-effort HD hint (mostly a no-op now; YouTube hard-caps embed quality by on-screen size).
+            vq: "hd1080",
           },
-          onStateChange: (e: YTPlayerEvent) => {
-            const p0 = playerRef.current;
-            logYouTubeState(
-              e?.data,
-              p0 && typeof p0.getCurrentTime === "function" ? p0.getCurrentTime() : 0,
-            );
-            // 1 === playing → sync the navigated-to video's title/author for display.
-            if (e?.data === 1) {
-              errorStreakRef.current = 0; // a successful play breaks any unplayable run
-              const p = playerRef.current;
-              const d = p && typeof p.getVideoData === "function" ? p.getVideoData() : null;
-              if (d) setLiveData({ title: d.title, author: d.author });
-            }
-            // 0 === ended → mark watched, then advance to the next queue item if any.
-            if (e?.data === 0 && currentIdRef.current === id) {
-              if (!autoMarkedRef.current) {
-                autoMarkedRef.current = true;
-                setWatched(true);
+          events: {
+            onReady: () => {
+              focusModal();
+              reapplyStored();
+            },
+            onStateChange: (e: YTPlayerEvent) => {
+              const p0 = playerRef.current;
+              logYouTubeState(
+                e?.data,
+                p0 && typeof p0.getCurrentTime === "function" ? p0.getCurrentTime() : 0,
+              );
+              // 1 === playing → sync the navigated-to video's title/author for display.
+              if (e?.data === 1) {
+                errorStreakRef.current = 0; // a successful play breaks any unplayable run
+                const p = playerRef.current;
+                const d = p && typeof p.getVideoData === "function" ? p.getVideoData() : null;
+                if (d) setLiveData({ title: d.title, author: d.author });
               }
+              // 0 === ended → mark watched, then advance to the next queue item if any.
+              if (e?.data === 0 && currentIdRef.current === id) {
+                if (!autoMarkedRef.current) {
+                  autoMarkedRef.current = true;
+                  setWatched(true);
+                }
+                advanceOnEnd();
+              }
+            },
+            onError: (e: YTPlayerEvent) => {
+              logYouTubeError(typeof e?.data === "number" ? e.data : -1);
+              setPlayerError(typeof e?.data === "number" ? e.data : -1);
+              // onError (not 'ended') fires for an unplayable item, so advanceOnEnd() never runs and an
+              // auto-advancing queue would freeze — skip forward instead, but bounded so a run of dead
+              // items can't spin. We do NOT mark the broken video watched.
+              if (currentIdRef.current !== id) return; // a navigated description-link error: leave the queue alone
+              const { autoMode: a } = modeRef.current;
+              const { queue: q } = navRef.current;
+              if (a === "off" || !q || q.length <= 1) return;
+              errorStreakRef.current += 1;
+              if (errorStreakRef.current >= MAX_CONSECUTIVE_ERRORS) return; // give up; leave the overlay
               advanceOnEnd();
-            }
+            },
           },
-          onError: (e: YTPlayerEvent) => {
-            logYouTubeError(typeof e?.data === "number" ? e.data : -1);
-            setPlayerError(typeof e?.data === "number" ? e.data : -1);
-            // onError (not 'ended') fires for an unplayable item, so advanceOnEnd() never runs and an
-            // auto-advancing queue would freeze — skip forward instead, but bounded so a run of dead
-            // items can't spin. We do NOT mark the broken video watched.
-            if (currentIdRef.current !== id) return; // a navigated description-link error: leave the queue alone
-            const { autoMode: a } = modeRef.current;
-            const { queue: q } = navRef.current;
-            if (a === "off" || !q || q.length <= 1) return;
-            errorStreakRef.current += 1;
-            if (errorStreakRef.current >= MAX_CONSECUTIVE_ERRORS) return; // give up; leave the overlay
-            advanceOnEnd();
-          },
-        },
+        });
+      })
+      // The script never arrived (blocked, offline, timed out) or the player could not be built:
+      // an error state with the way out, never an empty stage that waits forever.
+      .catch((err: unknown) => {
+        if (cancelled) return;
+        logYouTubeApiFailed(err);
+        setPlayerError(YT_API_LOAD_FAILED);
       });
-    });
 
     // The session's positions map (mutated in place, never replaced) — held here for the cleanup.
     const sessionPos = sessionPosRef.current;
@@ -459,15 +514,9 @@ export function useYtProgress({
     // Save on page unload too (F5/close/navigate): effect cleanup doesn't run on a full reload. A
     // keepalive beacon so the POST survives the unload. Only for the library item we opened with.
     const onHide = () => {
-      const p = playerRef.current;
-      if (!p || typeof p.getCurrentTime !== "function" || currentIdRef.current !== id) return;
-      try {
-        const cur = p.getCurrentTime();
-        const dur = typeof p.getDuration === "function" ? p.getDuration() : 0;
-        if (cur > 0 && dur > 0) api.saveProgressBeacon(id, cur, dur);
-      } catch {
-        /* player tearing down */
-      }
+      if (currentIdRef.current !== id) return;
+      const times = playerTimes(playerRef.current);
+      if (times && times.cur > 0 && times.dur > 0) api.saveProgressBeacon(id, times.cur, times.dur);
     };
     window.addEventListener("pagehide", onHide);
 
@@ -477,7 +526,7 @@ export function useYtProgress({
       window.removeEventListener("pagehide", onHide);
       // Final flush, then mark the feed + playlists stale so resume bars reflect this session on the next
       // natural refetch — WITHOUT refetching every loaded feed page on each player close (PERF-2).
-      Promise.resolve(persist()).finally(() => {
+      void Promise.resolve(persist()).finally(() => {
         // Write this session's stored positions INTO the cached lists first. Marking them stale is
         // not enough on its own: nothing refetches the feed until it remounts (staleTime 30s,
         // refetchOnWindowFocus off), so a reopen used to resume from the position the cache was
@@ -496,21 +545,18 @@ export function useYtProgress({
       }
       playerRef.current = null;
     };
-    // ONE PLAYER PER VIDEO is the invariant, and it is why this dep list is deliberately just the
-    // id: re-running would destroy and rebuild the YouTube iframe, losing the playing position and
-    // every listener attached to it.
+    // ONE PLAYER PER VIDEO is the invariant: re-running would destroy and rebuild the YouTube
+    // iframe, losing the playing position and every listener attached to it. So the deps are the id
+    // and refs (which never change).
     //
-    // This body DOES capture render values — `resumeAt`, `setWatched`, `advanceOnEnd`,
-    // `reapplyStored`, `focusModal`, `qc` — and it must, because each of them is a PER-ITEM
-    // SNAPSHOT: they describe the video this player was built for, and re-reading them mid-session
-    // would be the bug, not the fix. `resumeAt` is the clearest case, since persist() writes
-    // sessionPosRef and so changes it while `activeId` has not moved; the player is already playing
-    // from it and must not be told again. What genuinely has to stay live mid-session is behind refs
-    // (currentIdRef, modeRef, navRef, sessionPosRef, autoMarkedRef, errorStreakRef, playerRef) — and
-    // THAT split is the enforcement: a value that is not a snapshot does not belong in this closure.
-    //
-    // useEffectEvent cannot help here the way it does above: YT.Player takes its callbacks as an
-    // object literal, and an effect event may not be passed around as a value.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [activeId]);
+    // The render values the body uses — `resumeAt`, `setWatched`, `advanceOnEnd`, `reapplyStored`,
+    // `focusModal`, `qc`, … — are a PER-ITEM SNAPSHOT, taken once through `itemSnapshot` when this
+    // player is built: they describe the video it was built for, and re-reading them mid-session
+    // would be the bug, not the fix. `setWatched` is the clearest case: bound to the item, it lets
+    // this cleanup's late auto-mark land on the item being LEFT, which the modal then ignores. What
+    // genuinely has to stay live mid-session is behind refs (currentIdRef, modeRef, navRef,
+    // sessionPosRef, autoMarkedRef, errorStreakRef, playerRef) — and THAT split is the enforcement:
+    // a value that is not a snapshot does not belong in this closure. (E32: this replaced an
+    // exhaustive-deps suppression, which made the React Compiler skip the whole hook.)
+  }, [activeId, mountRef, playerRef, currentIdRef, navRef, modeRef, sessionPosRef]);
 }
diff --git a/frontend/src/lib/playerVolume.ts b/frontend/src/lib/playerVolume.ts
index f9cc2beb..face470f 100644
--- a/frontend/src/lib/playerVolume.ts
+++ b/frontend/src/lib/playerVolume.ts
@@ -17,7 +17,10 @@ export interface VolumeScale {
   round: boolean;
 }
 
-/** YouTube iframe API: 0–100 integers, no mute flag (level 0 IS muted). */
+/**
+ * YouTube iframe API: 0–100 integers, no mute flag (level 0 IS muted).
+ * @internal exported for playerVolume.test.ts
+ */
 export const YT_SCALE: VolumeScale = { min: 0, max: 100, default: 100, round: true };
 /** HTML5 <video>: a 0..1 float (mute is a separate flag the caller carries). */
 export const PLEX_SCALE: VolumeScale = { min: 0, max: 1, default: 1, round: false };
diff --git a/frontend/src/lib/plexBackdrop.dom.test.tsx b/frontend/src/lib/plexBackdrop.dom.test.tsx
index c12e0826..e24c61de 100644
--- a/frontend/src/lib/plexBackdrop.dom.test.tsx
+++ b/frontend/src/lib/plexBackdrop.dom.test.tsx
@@ -2,12 +2,17 @@
 //
 // E5 S8: the crossfading art backdrop hook. Covers the pieces that don't need real layout — that a
 // pool paints #root + isolates it (so the z-index:-1 overlay can paint above #root's own background),
-// creates exactly one overlay layer when it may animate, and HARD-OFFS the rotation (no overlay, first
-// image only) under prefers-reduced-motion, a single image, or when disabled. matchMedia is stubbed
-// per-test; the hook reads it at effect time.
+// creates exactly one overlay layer when it may animate, and stays static (no overlay, first image
+// only) for a single image, the crossfade off, or when disabled. Then the crossfade setting itself:
+// untouched it follows prefers-reduced-motion, and the reader's own pick wins over it (the owner, whose
+// Windows animation effects are off, never saw the crossfade — 2026-10-03). matchMedia is stubbed per test.
 import { describe, it, expect, afterEach, vi } from "vitest";
-import { render, cleanup } from "@testing-library/react";
-import { useCrossfadeBackdrop } from "./plexDetail";
+import { render, cleanup, renderHook, act } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { createElement, type ReactNode } from "react";
+import { api } from "./api";
+import { qk } from "./queryKeys";
+import { useCrossfadeBackdrop, useDetailPrefs } from "./plexDetail";
 
 function mockReducedMotion(reduce: boolean) {
   window.matchMedia = vi.fn().mockImplementation((query: string) => ({
@@ -64,12 +69,11 @@ describe("useCrossfadeBackdrop", () => {
     expect(overlays().length).toBe(1);
   });
 
-  it("hard-offs the rotation under prefers-reduced-motion (static, no overlay)", () => {
+  it("animates under prefers-reduced-motion once the reader's setting says so", () => {
     withRoot();
     mockReducedMotion(true);
     render(<Harness arts={["/a.jpg", "/b.jpg"]} />);
-    expect(root().style.backgroundImage).toContain('url("/a.jpg")'); // first image still painted
-    expect(overlays().length).toBe(0); // but no crossfade layer
+    expect(overlays().length).toBe(1);
   });
 
   it("stays static for a single image (no overlay)", () => {
@@ -101,3 +105,44 @@ describe("useCrossfadeBackdrop", () => {
     expect(root().style.isolation).toBe("");
   });
 });
+
+describe("the crossfade setting", () => {
+  const prefsWith = (preferences: Record<string, unknown>) => {
+    const qc = new QueryClient();
+    qc.setQueryData(qk.me(), { preferences });
+    return ({ children }: { children: ReactNode }) =>
+      createElement(QueryClientProvider, { client: qc }, children);
+  };
+
+  it.each([
+    [false, true],
+    [true, false],
+  ])("untouched, follows the system (reduced motion %s → crossfade %s)", (reduce, on) => {
+    mockReducedMotion(reduce);
+    const { result } = renderHook(() => useDetailPrefs(), { wrapper: prefsWith({}) });
+    expect(result.current.crossfade).toBe(on);
+  });
+
+  it("keeps the reader's own pick over the system", () => {
+    mockReducedMotion(true);
+    const on = renderHook(() => useDetailPrefs(), {
+      wrapper: prefsWith({ plexInfoArtCrossfade: true }),
+    });
+    expect(on.result.current.crossfade).toBe(true);
+    mockReducedMotion(false);
+    const off = renderHook(() => useDetailPrefs(), {
+      wrapper: prefsWith({ plexInfoArtCrossfade: false }),
+    });
+    expect(off.result.current.crossfade).toBe(false);
+  });
+
+  it("turns on from the state in force, and stores that as the reader's pick", () => {
+    mockReducedMotion(true);
+    const save = vi.spyOn(api, "savePrefs").mockResolvedValue({} as never);
+    const { result } = renderHook(() => useDetailPrefs(), { wrapper: prefsWith({}) });
+    act(() => result.current.toggleCrossfade());
+    expect(result.current.crossfade).toBe(true);
+    expect(save).toHaveBeenCalledWith({ plexInfoArtCrossfade: true });
+    save.mockRestore();
+  });
+});
diff --git a/frontend/src/lib/plexDetail.ts b/frontend/src/lib/plexDetail.ts
index 3834d464..f3ef8d31 100644
--- a/frontend/src/lib/plexDetail.ts
+++ b/frontend/src/lib/plexDetail.ts
@@ -1,4 +1,5 @@
 import { useLayoutEffect } from "react";
+import { REDUCED_MOTION, useMediaQuery } from "./useMediaQuery";
 import { usePref, useSavePref } from "./usePref";
 import type { TFunction } from "i18next";
 import type { PlexCard, PlexTmdb } from "./api";
@@ -14,9 +15,16 @@ export function useDetailPrefs() {
   const [artBg, setArtBg] = usePref<boolean>("plexInfoArtBg", true);
   const [showCast, setShowCast] = usePref<boolean>("plexInfoCast", true);
   const [showRelated, setShowRelated] = usePref<boolean>("plexInfoRelated", true);
-  // E5 S8: slowly cross-dissolve the art backdrop through the item's backdrops/related art. Independent
-  // of prefers-reduced-motion, which hard-disables the rotation regardless of this toggle.
-  const [crossfade, setCrossfade] = usePref<boolean>("plexInfoArtCrossfade", true);
+  // E5 S8: slowly cross-dissolve the art backdrop through the item's backdrops/related art. Untouched,
+  // it follows the system: off where the reader asked for less motion (prefers-reduced-motion — which
+  // Windows also reports whenever its animation effects are off). Once the reader turns it on or off
+  // here, that pick wins on every device: the owner never saw the crossfade, because the system signal
+  // used to switch it off whatever the toggle said (2026-10-03). The toggle shows the state in force.
+  const reduce = useMediaQuery(REDUCED_MOTION, false);
+  const [crossfadePick, setCrossfade] = usePref<boolean | null>("plexInfoArtCrossfade", null, {
+    parse: (raw) => (typeof raw === "boolean" ? raw : null),
+  });
+  const crossfade = crossfadePick ?? !reduce;
   const savePref = useSavePref();
   return {
     artBg,
@@ -103,8 +111,8 @@ export function tmdbBackdropUrl(path: string): string {
 // content, so the dissolve is visible under the chrome. Once faded, the settled image is committed to
 // #root and the overlay reset to transparent — a double buffer, so only ever ONE extra DOM node.
 //
-// The rotation is HARD-OFF under prefers-reduced-motion (shows only the first image, no movement) and
-// when there are fewer than two images or it's disabled; `attachment:fixed` keeps it viewport-anchored
+// The rotation runs only when `animate` says so — the reader's crossfade setting, which already folds in
+// prefers-reduced-motion (useDetailPrefs) — and there are at least two images; `attachment:fixed` keeps it viewport-anchored
 // while the content scrolls. Cleared on unmount / disable / empty pool.
 const BACKDROP_FADE_MS = 1600;
 const BACKDROP_INTERVAL_MS = 7000;
@@ -148,13 +156,9 @@ export function useCrossfadeBackdrop(
     }
     paint(pool[0]!);
 
-    const reduce =
-      typeof window !== "undefined" &&
-      typeof window.matchMedia === "function" &&
-      window.matchMedia("(prefers-reduced-motion: reduce)").matches;
-    // Static case (one image / crossfade off / reduced motion): still MUST clear on unmount — otherwise
-    // #root keeps the painted backdrop after leaving the page (e.g. switching to another module).
-    if (!animate || reduce || pool.length < 2) return clear;
+    // Static case (one image / crossfade off): still MUST clear on unmount — otherwise #root keeps the
+    // painted backdrop after leaving the page (e.g. switching to another module).
+    if (!animate || pool.length < 2) return clear;
 
     const layer = document.createElement("div");
     Object.assign(layer.style, {
diff --git a/frontend/src/lib/plexPlayerHooks.controls.dom.test.tsx b/frontend/src/lib/plexPlayerHooks.controls.dom.test.tsx
index 4db4896e..7fa37a5a 100644
--- a/frontend/src/lib/plexPlayerHooks.controls.dom.test.tsx
+++ b/frontend/src/lib/plexPlayerHooks.controls.dom.test.tsx
@@ -26,7 +26,9 @@ describe("useControlsVisibility", () => {
   it("hides 3 s after the last activity while playing", () => {
     const { result } = setup();
     act(() => result.current.wake());
-    act(() => vi.advanceTimersByTime(3000));
+    act(() => {
+      vi.advanceTimersByTime(3000);
+    });
     expect(result.current.uiVisible).toBe(false);
   });
 
@@ -36,16 +38,45 @@ describe("useControlsVisibility", () => {
       result.current.wake();
       result.current.holdOnHover(true);
     });
-    act(() => vi.advanceTimersByTime(10_000));
+    act(() => {
+      vi.advanceTimersByTime(10_000);
+    });
     expect(result.current.uiVisible).toBe(true);
 
     act(() => result.current.holdOnHover(false));
-    act(() => vi.advanceTimersByTime(2900));
+    act(() => {
+      vi.advanceTimersByTime(2900);
+    });
     expect(result.current.uiVisible).toBe(true); // a fresh 3 s from the leave, not from the wake
-    act(() => vi.advanceTimersByTime(100));
+    act(() => {
+      vi.advanceTimersByTime(100);
+    });
     expect(result.current.uiVisible).toBe(false);
   });
 
+  // E28 E6 / round 2 P4: a keyboard focus in the chrome holds the bar — but only for FOCUS_HOLD_MS
+  // after the last key, not for the whole film. The 3 s timer finds the hold, re-arms for what is
+  // left of it, and hides once it is over (E32 rewrote that re-arm without recursion).
+  it("holds for a keyboard focus until 10 s after the last key, then hides", () => {
+    const { result } = setup();
+    act(() => {
+      result.current.holdOnFocus(true);
+      result.current.wake();
+    });
+    act(() => {
+      vi.advanceTimersByTime(3000);
+    });
+    expect(result.current.uiVisible).toBe(true); // the hold, not the 3 s
+    act(() => {
+      vi.advanceTimersByTime(6900);
+    });
+    expect(result.current.uiVisible).toBe(true); // 9.9 s after the key
+    act(() => {
+      vi.advanceTimersByTime(100);
+    });
+    expect(result.current.uiVisible).toBe(false); // the hold is over, focus or not
+  });
+
   // C3: on touch nothing moves a mouse, so a tap toggles the bar and playback arms the timer.
   it("toggle hides a shown bar at once and shows a hidden one", () => {
     const { result } = setup();
diff --git a/frontend/src/lib/plexPlayerHooks.subtitle.dom.test.tsx b/frontend/src/lib/plexPlayerHooks.subtitle.dom.test.tsx
index eb8b6017..3d7cbcd7 100644
--- a/frontend/src/lib/plexPlayerHooks.subtitle.dom.test.tsx
+++ b/frontend/src/lib/plexPlayerHooks.subtitle.dom.test.tsx
@@ -12,7 +12,7 @@
 import { describe, it, expect, vi, afterEach, beforeEach } from "vitest";
 import { act, cleanup, render, renderHook, waitFor } from "@testing-library/react";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { createRef, type ReactNode, type MutableRefObject } from "react";
+import { createRef, type ReactNode, type RefObject } from "react";
 import { usePlexTracks } from "./plexPlayerHooks";
 import { api, type PlexItemDetail } from "./api";
 import { dismissError, getError } from "./errorDialog";
@@ -49,7 +49,7 @@ function mount(qc: QueryClient, { sessionK = 0, abs = 3600, loadStart = 0 } = {}
         videoRef: createRef<HTMLVideoElement>(),
         hlsRef: createRef<Hls>(),
         multiAudioRef: { current: false },
-        audioRef: { current: 0 } as MutableRefObject<number | null>,
+        audioRef: { current: 0 } as RefObject<number | null>,
         aoffRef: { current: 0 },
         absRef: { current: abs },
         loadStartRef: { current: loadStart },
@@ -325,7 +325,7 @@ function TrackHarness() {
     videoRef: createRef<HTMLVideoElement>(),
     hlsRef: createRef<Hls>(),
     multiAudioRef: { current: false },
-    audioRef: { current: 0 } as MutableRefObject<number | null>,
+    audioRef: { current: 0 } as RefObject<number | null>,
     aoffRef: { current: 0 },
     absRef: { current: 3600 },
     loadStartRef: { current: 0 },
diff --git a/frontend/src/lib/plexPlayerHooks.ts b/frontend/src/lib/plexPlayerHooks.ts
index 31d97f15..d1d04120 100644
--- a/frontend/src/lib/plexPlayerHooks.ts
+++ b/frontend/src/lib/plexPlayerHooks.ts
@@ -3,7 +3,6 @@ import {
   useEffect,
   useRef,
   useState,
-  type MutableRefObject,
   type RefObject,
   type WheelEvent as ReactWheelEvent,
 } from "react";
@@ -17,6 +16,7 @@ import {
 } from "./fullscreen";
 import { api, type PlexItemDetail, type PlexMarker } from "./api";
 import { qk } from "./queryKeys";
+import { useLatest } from "./useLatest";
 import i18n, { plexLang } from "../i18n";
 import { type PlexPlayerPrefs } from "./plexPlayerPrefs";
 import { PLEX_SCALE, normalizeVolumeIn, stepVolumeIn } from "./playerVolume";
@@ -113,16 +113,23 @@ export function useControlsVisibility(opts: {
     if (hideTimer.current) window.clearTimeout(hideTimer.current);
     if (!barAutoHideRef.current) return; // per-user setting: never auto-hide the control bar
     const wokeAt = Date.now();
-    const arm = (ms: number) => {
-      hideTimer.current = window.setTimeout(() => {
-        // Keep the controls up while the audio/subtitle menu is open, else it would vanish mid-choice.
-        if (videoRef.current?.paused || menuOpenRef.current || hovered.current) return;
-        const held = FOCUS_HOLD_MS - (Date.now() - wokeAt);
-        if (focused.current && held > 0) return arm(held);
-        setVisible(false);
-      }, ms);
-    };
-    arm(HIDE_MS);
+    // Keep the controls up while the audio/subtitle menu is open, else it would vanish mid-choice.
+    const busy = () => !!videoRef.current?.paused || menuOpenRef.current || hovered.current;
+    // Not a timer that re-arms itself: a self-calling `arm` read to the compiler's analysis as a
+    // value from outside this callback (memo-dependencies), and a self-naming function expression
+    // tripped one of its invariants. The focus hold re-arms at most once — the second timer fires
+    // when the hold is over, so it has only `busy` left to ask.
+    hideTimer.current = window.setTimeout(() => {
+      if (busy()) return;
+      const held = FOCUS_HOLD_MS - (Date.now() - wokeAt);
+      if (focused.current && held > 0) {
+        hideTimer.current = window.setTimeout(() => {
+          if (!busy()) setVisible(false);
+        }, held);
+        return;
+      }
+      setVisible(false);
+    }, HIDE_MS);
   }, [barAutoHideRef, menuOpenRef, videoRef, setVisible]);
   const show = useCallback(
     (visible: boolean) => {
@@ -188,8 +195,8 @@ export function usePlexProgress(opts: {
   id: string;
   qc: QueryClient;
   videoRef: RefObject<HTMLVideoElement | null>;
-  absRef: MutableRefObject<number>;
-  durationRef: MutableRefObject<number>;
+  absRef: RefObject<number>;
+  durationRef: RefObject<number>;
 }): { settle: () => void; finish: (confirmed?: Promise<unknown>) => void } {
   const { id, qc, videoRef, absRef, durationRef } = opts;
   const settleRef = useRef<() => void>(() => {});
@@ -341,10 +348,7 @@ export function usePlexProgress(opts: {
  *  answer is where the session was ASKED to start. Anything that restarts the session "here" — an
  *  audio switch, an A/V offset, a keyboard seek — must use this: reading `abs` restarted a resume at
  *  20:00 from 0:00, and the next checkpoint saved that (deep-review round 4). */
-export function playhead(
-  absRef: MutableRefObject<number>,
-  loadStartRef: MutableRefObject<number>,
-): number {
+export function playhead(absRef: RefObject<number>, loadStartRef: RefObject<number>): number {
   return absRef.current > 0 ? absRef.current : loadStartRef.current;
 }
 
@@ -439,8 +443,8 @@ export function useAutoSkip(opts: {
 }): {
   activeMarker: PlexMarker | undefined;
   skipProgress: number | null;
-  skipProgressRef: MutableRefObject<number | null>;
-  cancelAutoSkipRef: MutableRefObject<() => void>;
+  skipProgressRef: RefObject<number | null>;
+  cancelAutoSkipRef: RefObject<() => void>;
   doSkip: (m: PlexMarker) => void;
 } {
   const {
@@ -455,17 +459,13 @@ export function useAutoSkip(opts: {
     seekTo,
     videoRef,
   } = opts;
-  const skipProgressRef = useRef<number | null>(null);
-  const cancelAutoSkipRef = useRef<() => void>(() => {});
-
   const activeMarker: PlexMarker | undefined = markers?.find(
     (m) => abs >= m.start_s && abs < m.end_s - 1,
   );
-  const activeMarkerRef = useRef(activeMarker);
-  activeMarkerRef.current = activeMarker;
+  const activeMarkerRef = useLatest(activeMarker);
 
   const [skipProgress, setSkipProgress] = useState<number | null>(null);
-  skipProgressRef.current = skipProgress;
+  const skipProgressRef = useLatest(skipProgress);
   const cancelledMarkerRef = useRef<string | null>(null);
   // Forget a cancelled-skip when the item changes: the ref holds a `${type}-${start_s}` key, and a
   // marker at the same offset on the NEXT episode would otherwise be suppressed by a cancel made on
@@ -476,8 +476,7 @@ export function useAutoSkip(opts: {
   // The running countdown interval, so cancelAutoSkip can actually STOP it — clearing skipProgress
   // alone left the interval ticking, which re-set the progress ~100ms later and skipped anyway.
   const skipTimerRef = useRef<number | null>(null);
-  const reportWatchedErrorRef = useRef(opts.reportWatchedError);
-  reportWatchedErrorRef.current = opts.reportWatchedError;
+  const reportWatchedErrorRef = useLatest(opts.reportWatchedError);
   const doSkip = useCallback(
     (m: PlexMarker) => {
       setSkipProgress(null);
@@ -492,7 +491,7 @@ export function useAutoSkip(opts: {
         go(nextId, watchedWrite);
       } else seekTo(m.end_s);
     },
-    [id, go, nextId, seekTo],
+    [id, go, nextId, seekTo, reportWatchedErrorRef],
   );
   const cancelAutoSkip = useCallback(() => {
     const m = activeMarkerRef.current;
@@ -502,8 +501,8 @@ export function useAutoSkip(opts: {
       skipTimerRef.current = null;
     }
     setSkipProgress(null);
-  }, []);
-  cancelAutoSkipRef.current = cancelAutoSkip;
+  }, [activeMarkerRef]);
+  const cancelAutoSkipRef = useLatest(cancelAutoSkip);
   // The marker is identified by type+offset rather than by object identity: `markers?.find` returns
   // the same element while the playhead stays inside it, but a refetch of the markers list would
   // hand back an equal-but-new object and restart a countdown already under way. The marker itself
@@ -545,6 +544,7 @@ export function useAutoSkip(opts: {
     autoSkipDelay,
     doSkip,
     videoRef,
+    activeMarkerRef,
   ]);
 
   return { activeMarker, skipProgress, skipProgressRef, cancelAutoSkipRef, doSkip };
@@ -594,12 +594,12 @@ export function usePlexTracks(opts: {
   videoRef: RefObject<HTMLVideoElement | null>;
   hlsRef: RefObject<Hls | null>;
   multiAudioRef: RefObject<boolean>;
-  audioRef: MutableRefObject<number | null>;
-  aoffRef: MutableRefObject<number>;
-  absRef: MutableRefObject<number>;
+  audioRef: RefObject<number | null>;
+  aoffRef: RefObject<number>;
+  absRef: RefObject<number>;
   /** The position the current (or still in-flight) session was ASKED to start at — written before
    *  the session request goes out, unlike `sessionK`, which only lands once it has answered. */
-  loadStartRef: MutableRefObject<number>;
+  loadStartRef: RefObject<number>;
 }): {
   audioOrd: number | null;
   setAudioOrd: (ord: number | null) => void;
@@ -670,14 +670,15 @@ export function usePlexTracks(opts: {
       });
       if (multiAudioRef.current && hlsRef.current) {
         // Multi-rendition: switch the audio track CLIENT-SIDE — instant, same timeline, no restart.
+        const track = ord ?? 0;
         try {
-          hlsRef.current.audioTrack = ord ?? 0;
+          hlsRef.current.audioTrack = track;
         } catch {
           /* ignore */
         }
       } else {
         // Single audio (or the session has not answered yet): re-map the track server-side.
-        loadSession(playhead(absRef, loadStartRef));
+        void loadSession(playhead(absRef, loadStartRef));
       }
     },
     [loadSession, detail, patchPrefs, audioRef, multiAudioRef, hlsRef, absRef, loadStartRef],
diff --git a/frontend/src/lib/plexStats.ts b/frontend/src/lib/plexStats.ts
index dbb094da..a8b8aa7f 100644
--- a/frontend/src/lib/plexStats.ts
+++ b/frontend/src/lib/plexStats.ts
@@ -58,6 +58,7 @@ export interface StatRow {
 const DASH = "—";
 
 // bits-per-second → "4.2 Mbps" / "820 kbps". Undefined/0 → dash (hls.js reports 0 before a level loads).
+/** @internal exported for plexStats.test.ts */
 export function fmtBitrate(bps: number | undefined, lang: string): string {
   if (!bps || bps <= 0) return DASH;
   if (bps >= 1_000_000) return `${formatDecimal(bps / 1_000_000, lang)} Mbps`;
@@ -65,12 +66,14 @@ export function fmtBitrate(bps: number | undefined, lang: string): string {
 }
 
 // Seconds of buffer ahead of the playhead → "12.3 sec" / "12,3 mp".
+/** @internal exported for plexStats.test.ts */
 export function fmtBufferSecs(s: number, lang: string): string {
   if (!Number.isFinite(s) || s < 0) return DASH;
   return formatUnit(s, "second", lang, 1);
 }
 
 // Dropped / total decoded frames, with a drop percentage once any frames have been decoded.
+/** @internal exported for plexStats.test.ts */
 export function fmtFrames(dropped: number, total: number, lang: string): string {
   if (total <= 0) return DASH;
   const pct = (dropped / total) * 100;
@@ -80,12 +83,14 @@ export function fmtFrames(dropped: number, total: number, lang: string): string
 
 // Intrinsic decoded resolution. 0×0 means the browser hasn't decoded (or can't) — an honest dash,
 // which is itself the tell for a not-yet-playable codec pre-transcode.
+/** @internal exported for plexStats.test.ts */
 export function fmtRes(w: number, h: number): string {
   if (w <= 0 || h <= 0) return DASH;
   return `${w}×${h}`;
 }
 
 // Seconds → m:ss (offsets/positions are small; hours are folded into minutes deliberately).
+/** @internal exported for plexStats.test.ts */
 export function fmtClock(s: number): string {
   if (!Number.isFinite(s) || s < 0) return DASH;
   const total = Math.floor(s);
@@ -95,6 +100,7 @@ export function fmtClock(s: number): string {
 }
 
 // hls.js active level → "2 / 4 · 1280×720" (1-based index for humans). Auto/unknown level → dash + count.
+/** @internal exported for plexStats.test.ts */
 export function fmtLevel(l: HlsLevelInfo | null): string {
   if (!l || l.total <= 0) return DASH;
   const idx = l.index >= 0 ? `${l.index + 1} / ${l.total}` : `auto / ${l.total}`;
@@ -103,6 +109,7 @@ export function fmtLevel(l: HlsLevelInfo | null): string {
 }
 
 // Video/audio codec from the active hls.js level (only HLS exposes them; direct play → dash).
+/** @internal exported for plexStats.test.ts */
 export function fmtCodec(video: string | undefined, audio: string | undefined): string {
   const v = video?.split(".")[0] || null; // "avc1.640028" → "avc1"
   const a = audio?.split(".")[0] || null;
@@ -115,6 +122,7 @@ export function fmtCodec(video: string | undefined, audio: string | undefined):
 // "· HDR→SDR" tag when the GPU OpenCL tonemap path handled a 10-bit/HDR source ("transcode · GPU ·
 // HDR→SDR"). Non-transcode modes (direct/remux) and an unknown encoder read as the bare mode. Raw tokens
 // (not i18n'd), consistent with the other technical values in this overlay (e.g. transport "hls").
+/** @internal exported for plexStats.test.ts */
 export function fmtMode(
   playable: string,
   hwEncoder?: boolean | null,
diff --git a/frontend/src/lib/queryKeys.test.ts b/frontend/src/lib/queryKeys.test.ts
index 88b035d2..645e7573 100644
--- a/frontend/src/lib/queryKeys.test.ts
+++ b/frontend/src/lib/queryKeys.test.ts
@@ -12,10 +12,6 @@ describe("qk — bare vs parameterized branch", () => {
   it("collapses to the bare prefix key only when no arg is given", () => {
     expect(qk.feed()).toEqual(["feed"]);
     expect(qk.feed(FILTERS)).toEqual(["feed", FILTERS]);
-    expect(qk.feedCount()).toEqual(["feed-count"]);
-    expect(qk.feedCount(FILTERS)).toEqual(["feed-count", FILTERS]);
-    expect(qk.facets()).toEqual(["facets"]);
-    expect(qk.facets(FILTERS)).toEqual(["facets", FILTERS]);
     expect(qk.feedSummary()).toEqual(["feed-summary"]);
     expect(qk.feedSummary(FILTERS)).toEqual(["feed-summary", FILTERS]);
     expect(qk.playlist()).toEqual(["playlist"]);
diff --git a/frontend/src/lib/queryKeys.ts b/frontend/src/lib/queryKeys.ts
index 7c07ca10..13d608ca 100644
--- a/frontend/src/lib/queryKeys.ts
+++ b/frontend/src/lib/queryKeys.ts
@@ -6,7 +6,7 @@ import type { FeedFilters } from "./api";
 // SAME array shape the call sites used before, so TanStack's partial (prefix) matching is
 // unchanged — `qk.feed()` (`["feed"]`) still invalidates `qk.feed(filters)` (`["feed", filters]`).
 // Deliberately NOT bundling co-invalidations into helpers here: the clusters differ per call site
-// (some invalidate `feed` alone, others `feed` + `feed-count`), so collapsing them would change
+// (some invalidate `feed` alone, others `feed` + `feed-summary`), so collapsing them would change
 // which queries refetch. Grouped invalidation stays opt-in per domain (see `invalidateDownloads`).
 // Extended per domain as R7 S2 migrates each area (S2a: feed/channels/playlists + shared roots).
 export const qk = {
@@ -26,10 +26,6 @@ export const qk = {
   // silently collapsed to the prefix.
   feed: (filters?: FeedFilters) =>
     filters !== undefined ? (["feed", filters] as const) : (["feed"] as const),
-  feedCount: (filters?: FeedFilters) =>
-    filters !== undefined ? (["feed-count", filters] as const) : (["feed-count"] as const),
-  facets: (filters?: FeedFilters) =>
-    filters !== undefined ? (["facets", filters] as const) : (["facets"] as const),
   feedSummary: (filters?: FeedFilters) =>
     filters !== undefined ? (["feed-summary", filters] as const) : (["feed-summary"] as const),
   feedYears: (filters?: FeedFilters) =>
diff --git a/frontend/src/lib/repoScripts.contract.test.ts b/frontend/src/lib/repoScripts.contract.test.ts
new file mode 100644
index 00000000..ad79c1fc
--- /dev/null
+++ b/frontend/src/lib/repoScripts.contract.test.ts
@@ -0,0 +1,57 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import js from "@eslint/js";
+import { ESLint } from "eslint";
+import globals from "globals";
+import prettier from "prettier";
+import { describe, expect, it } from "vitest";
+
+// The repo-root `scripts/*.mjs` (the lock check `siftlode check` runs, the CHANGELOG generator its
+// release runs) sit outside every lint lane: the eslint and prettier lanes run from frontend/, and an
+// ESLint config cannot reach past its own directory (E32 review). This holds them to the same bar as
+// the frontend's plain-JS config files — `js.configs.recommended` under Node, and the frontend's
+// Prettier style. Not the typed rules: they are not in a tsc project (docs/gates.md).
+
+const REPO = fileURLToPath(new URL("../../../", import.meta.url));
+const FRONTEND = `${REPO}frontend/`;
+const SCRIPTS = readdirSync(`${REPO}scripts`)
+  .filter((f) => f.endsWith(".mjs"))
+  .map((f) => `scripts/${f}`);
+
+describe("repo-root scripts", () => {
+  it("are found", () => {
+    expect(SCRIPTS).toContain("scripts/check-node-modules.mjs");
+  });
+
+  it("pass the plain-JS lint", async () => {
+    const eslint = new ESLint({
+      cwd: REPO,
+      overrideConfigFile: true,
+      overrideConfig: [
+        {
+          files: ["scripts/*.mjs"],
+          ...js.configs.recommended,
+          languageOptions: { globals: globals.node },
+          linterOptions: { reportUnusedDisableDirectives: "error" },
+        },
+      ],
+    });
+    const hits = (await eslint.lintFiles(SCRIPTS)).flatMap((r) =>
+      r.messages.map((m) => `${r.filePath}:${m.line} ${m.ruleId ?? "parse"}: ${m.message}`),
+    );
+    expect(hits).toEqual([]);
+  });
+
+  it("are formatted in the frontend's Prettier style", async () => {
+    const options = await prettier.resolveConfig(`${FRONTEND}eslint.config.js`);
+    const unformatted: string[] = [];
+    for (const f of SCRIPTS) {
+      const ok = await prettier.check(readFileSync(REPO + f, "utf8"), {
+        ...options,
+        filepath: REPO + f,
+      });
+      if (!ok) unformatted.push(f);
+    }
+    expect(unformatted).toEqual([]);
+  });
+});
diff --git a/frontend/src/lib/savedViews.test.ts b/frontend/src/lib/savedViews.test.ts
index c1cce3c6..0bb8e35e 100644
--- a/frontend/src/lib/savedViews.test.ts
+++ b/frontend/src/lib/savedViews.test.ts
@@ -19,6 +19,15 @@ describe("preferSticky", () => {
     expect(preferSticky([v(1), v(2)], 2)?.id).toBe(2);
   });
 
+  it("without a sticky match, prefers the starred default over an earlier twin", () => {
+    // The first-load seed applies the default's filters and leaves the name to this tie-break: an
+    // earlier view with the same filters must not take the default's name (E32).
+    const d = (id: number, is_default = false) => ({ id, name: `v${id}`, is_default });
+    expect(preferSticky([d(1), d(2, true)], null)?.id).toBe(2);
+    expect(preferSticky([d(1), d(2, true)], 99)?.id).toBe(2);
+    expect(preferSticky([d(1), d(2, true)], 1)?.id).toBe(1);
+  });
+
   it("falls back to the first match when the sticky id isn't among the matches", () => {
     expect(preferSticky([v(1), v(2)], 99)?.id).toBe(1);
     expect(preferSticky([v(1), v(2)], null)?.id).toBe(1);
diff --git a/frontend/src/lib/savedViews.ts b/frontend/src/lib/savedViews.ts
index 0902fa5b..eaafc7c7 100644
--- a/frontend/src/lib/savedViews.ts
+++ b/frontend/src/lib/savedViews.ts
@@ -3,12 +3,19 @@
 
 /** Among the views whose filters match the live filters, pick the one to treat as active: prefer the
  *  explicitly-applied ("sticky") view when several capture identical filters, so apply(B) isn't
- *  silently re-attributed to an earlier duplicate A; otherwise the first match. Null if none match. */
-export function preferSticky<T extends { id: number }>(
+ *  silently re-attributed to an earlier duplicate A; else the starred default, which is what the
+ *  first-load seed applies (so the seed needs no sticky write of its own); else the first match.
+ *  Null if none match. */
+export function preferSticky<T extends { id: number; is_default?: boolean }>(
   matches: T[],
   stickyId: number | null,
 ): T | null {
-  return matches.find((v) => v.id === stickyId) ?? matches[0] ?? null;
+  return (
+    matches.find((v) => v.id === stickyId) ??
+    matches.find((v) => v.is_default) ??
+    matches[0] ??
+    null
+  );
 }
 
 /** The starred default view to seed a module's filters with on first load, or null to leave them.
diff --git a/frontend/src/lib/seekableEnd.ts b/frontend/src/lib/seekableEnd.ts
new file mode 100644
index 00000000..11ed91e8
--- /dev/null
+++ b/frontend/src/lib/seekableEnd.ts
@@ -0,0 +1,14 @@
+/** Where the media can be sought to, on the session's absolute clock (`now` while the element has
+ *  no range yet), or null when the element refuses to say. Its own function, outside PlexPlayer: the
+ *  React Compiler cannot lower a conditional inside a try yet, and skipped the whole player for it. */
+export function seekableEndOf(
+  video: HTMLVideoElement,
+  sessionStart: number,
+  now: number,
+): number | null {
+  try {
+    return video.seekable.length ? sessionStart + video.seekable.end(0) : now;
+  } catch {
+    return null;
+  }
+}
diff --git a/frontend/src/lib/sourceSize.contract.test.ts b/frontend/src/lib/sourceSize.contract.test.ts
new file mode 100644
index 00000000..e587e12f
--- /dev/null
+++ b/frontend/src/lib/sourceSize.contract.test.ts
@@ -0,0 +1,149 @@
+import { describe, expect, it } from "vitest";
+import {
+  boundNamesIn,
+  complexityOffenders,
+  lineCounts,
+  MAX_COMPLEXITY,
+  MAX_LINES,
+  shippedFiles,
+} from "./sourceSize.testkit";
+
+// The size / complexity RATCHET for the shipped frontend (E32, owner 2026-10-03 — "class size" from
+// the quality checklist, measured rather than argued). Two limits, each with today's offenders as a
+// CEILING:
+//   • a file over 800 lines — the listed ones may not grow past their line count; any other
+//     file may not cross the limit;
+//   • a function over complexity 20 (eslint `complexity`, cyclomatic) — a listed one, by its
+//     NAME, may not rise; no other function may cross the limit. (Ranked per file until the E32
+//     review: one function could grow by what another in the same file lost.) A rename reads as a
+//     new offender plus a stale entry: move its row.
+// Shrinking is free; a file or function that drops UNDER the limit must be taken off its list (red
+// until it is), so the lists only get shorter. Raising a ceiling is a decision for the owner, with
+// the reason in docs/gates.md. JSX branches count toward complexity, so a component scores high by
+// construction — the limit catches the outliers, it does not grade style.
+
+const BIG_FILES: Record<string, number> = {
+  "components/AdminUsers.tsx": 993,
+  "components/Channels.tsx": 904,
+  "components/Feed.tsx": 934,
+  "components/Home.tsx": 1136,
+  "components/IssueComposer.tsx": 861,
+  "components/PlayerModal.tsx": 1142,
+  "components/Playlists.tsx": 1069,
+  "components/PlexPlayer.tsx": 1984,
+  "components/PlexPlaylistView.tsx": 830,
+  "components/plexViews.tsx": 941,
+  "components/SettingsPanel.tsx": 885,
+  "components/Welcome.tsx": 944,
+  "lib/plexPlayerHooks.ts": 922,
+};
+
+const COMPLEX: Record<string, number> = {
+  "App.tsx::App": 28,
+  "components/AccountPanel.tsx::AccountPanel": 29,
+  "components/AdminLogs.tsx::AdminLogs": 35,
+  "components/ChannelPage.tsx::ChannelPage": 91,
+  "components/Channels.tsx::Channels": 53,
+  "components/ConfigPanel.tsx::ConfigPanel": 24,
+  "components/ConfigPanel.tsx::Field": 28,
+  "components/DownloadCenter.tsx::DownloadCenter": 36,
+  "components/Feed.tsx::Feed": 64,
+  "components/Home.tsx::Hero": 32,
+  "components/Home.tsx::Home": 34,
+  "components/Home.tsx::useHomeCardMenu": 21,
+  "components/IssueComposer.tsx::ComposerBody": 34,
+  "components/KeyGate.tsx::KeyGate": 22,
+  "components/NotificationsPanel.tsx::NotificationRow": 28,
+  "components/OnboardingWizard.tsx::OnboardingWizard": 21,
+  "components/PersonalViewsModal.tsx::PersonalViewsModal": 22,
+  "components/PlayerModal.tsx::PlayerModal": 98,
+  "components/Playlists.tsx::Playlists": 66,
+  "components/PlexBrowse.tsx::PlexBrowse": 45,
+  "components/PlexCollectionView.tsx::PlexCollectionView": 41,
+  "components/PlexDiscover.tsx::PlexDiscover": 21,
+  "components/PlexInfo.tsx::PlexInfo": 65,
+  "components/PlexPlayer.tsx::onKey": 22,
+  "components/PlexPlayer.tsx::PlexPlayer": 103,
+  "components/PlexPlaylistView.tsx::PlexPlaylistView": 22,
+  "components/PlexSidebar.tsx::PlexSidebar": 32,
+  "components/PlexStatsOverlay.tsx::sample": 25,
+  "components/Scheduler.tsx::JobRow": 21,
+  "components/Scheduler.tsx::Scheduler": 21,
+  "components/SetupWizard.tsx::SetupWizard": 21,
+  "components/SyncStatus.tsx::SyncStatus": 22,
+  "components/VideoCard.tsx::VideoCard": 39,
+  "components/VideoEditor.tsx::VideoEditor": 49,
+  "components/WatchPage.tsx::WatchPage": 30,
+  "components/Welcome.tsx::AuthCard": 39,
+  "components/Welcome.tsx::onSubmit": 24,
+  "components/auditColumns.tsx::localDetails": 24,
+  "components/downloadRow.tsx::DownloadRow": 25,
+  "components/plexCards.tsx::PlexPosterCard": 58,
+  "components/plexViews.tsx::PlexPersonView": 30,
+  "components/plexViews.tsx::PlexSeasonView": 21,
+  "components/plexViews.tsx::PlexShowView": 50,
+  "components/ui/AnchoredPopover.tsx::PopoverSurfaceInner": 22,
+  "components/ui/Combobox.tsx::Combobox": 22,
+  "components/ui/DataTable.tsx::DataTable": 42,
+  "components/ui/PanelGroup.tsx::PanelGroup": 23,
+  "components/ui/SidePanel.tsx::SidePanel": 45,
+  "components/ui/SortControl.tsx::SortControl": 23,
+  "components/ui/anchoredPopoverHooks.ts::useAnchoredPopover": 30,
+  "components/usePlaylistActions.tsx::pushSteps": 23,
+  "components/usePlexActiveFilters.ts::buildPlexActiveFilters": 25,
+  "components/useVideoActions.tsx::items": 25,
+  "lib/api/core.ts::localizeDetail": 48,
+  "lib/api/core.ts::req": 22,
+  "lib/api/plex.ts::appendPlexFilters": 26,
+  "lib/diagnostics.ts::applyDiagnostics": 22,
+  "lib/keymap.ts::dispatch": 28,
+  "lib/logHooks.ts::controlAttrs": 21,
+  "lib/plexDetail.ts::useDetailAside": 24,
+  "lib/plexPlayerHooks.ts::usePlexTracks": 30,
+  "lib/urlState.ts::filtersToParams": 24,
+  "lib/urlState.ts::paramsToFilters": 26,
+  "lib/useActiveFilters.ts::useActiveFilters": 25,
+};
+
+describe("file size", () => {
+  const lines = lineCounts(shippedFiles());
+
+  it(`no file crosses ${MAX_LINES} lines, and a listed one does not grow`, () => {
+    const over = Object.entries(lines)
+      .filter(([f, n]) => n > (BIG_FILES[f] ?? MAX_LINES))
+      .map(([f, n]) => `${f}: ${n} lines (ceiling ${BIG_FILES[f] ?? MAX_LINES})`);
+    expect(over).toEqual([]);
+  });
+
+  it("lists no file that is back under the limit (delete it)", () => {
+    const back = Object.keys(BIG_FILES).filter((f) => (lines[f] ?? 0) <= MAX_LINES);
+    expect(back).toEqual([]);
+  });
+});
+
+describe("function complexity", async () => {
+  const actual = await complexityOffenders();
+
+  it(`no function crosses ${MAX_COMPLEXITY}, and a listed one does not rise`, () => {
+    const worse = Object.entries(actual)
+      .filter(([fn, v]) => v > (COMPLEX[fn] ?? MAX_COMPLEXITY))
+      .map(([fn, v]) => `${fn}: ${v} (ceiling ${COMPLEX[fn] ?? MAX_COMPLEXITY})`);
+    expect(worse).toEqual([]);
+  });
+
+  it("lists no function that is back under the limit, or gone (delete its row)", () => {
+    expect(Object.keys(COMPLEX).filter((fn) => !(fn in actual))).toEqual([]);
+  });
+});
+
+describe("function names (the ratchet's keys)", () => {
+  it("names an unnamed function by what it is bound to, through a wrapping call", () => {
+    const code = [
+      "const onSave = useCallback(() => 1);",
+      "useEffect(() => {});",
+      "const o = { k: function () {} };",
+      "const v = useMemo(() => g(() => 2));",
+    ].join(" ");
+    expect(boundNamesIn(code)).toEqual(["onSave", "useEffect callback", "k", "v", "g callback"]);
+  });
+});
diff --git a/frontend/src/lib/sourceSize.testkit.ts b/frontend/src/lib/sourceSize.testkit.ts
new file mode 100644
index 00000000..9cf51a4c
--- /dev/null
+++ b/frontend/src/lib/sourceSize.testkit.ts
@@ -0,0 +1,141 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { ESLint, Linter, type Rule } from "eslint";
+import tseslint from "typescript-eslint";
+
+// Measures the shipped frontend source for the size/complexity ratchet (E32): lines per file, and the
+// cyclomatic complexity of every function over the limit. Used by sourceSize.contract.test.ts.
+
+export const MAX_LINES = 800;
+export const MAX_COMPLEXITY = 20;
+
+const SRC = fileURLToPath(new URL("../", import.meta.url));
+
+/** src-relative paths of everything the build ships (no tests, no test kits). */
+export function shippedFiles(): string[] {
+  return (readdirSync(SRC, { recursive: true }) as string[])
+    .map((p) => p.split("\\").join("/"))
+    .filter(
+      (p) => /\.(ts|tsx)$/.test(p) && !/\.(test|testkit)\.tsx?$/.test(p) && !p.endsWith(".d.ts"),
+    )
+    .sort();
+}
+
+export function lineCounts(files: string[]): Record<string, number> {
+  const out: Record<string, number> = {};
+  for (const f of files) out[f] = readFileSync(SRC + f, "utf8").split("\n").length;
+  return out;
+}
+
+/** `file::function` → its complexity, for every function over MAX_COMPLEXITY. Keyed by NAME, not by
+ *  rank in the file: a ranked list let one function grow while another in the same file shrank by as
+ *  much (E32 review). ESLint names declarations and methods; a function it leaves unnamed takes the
+ *  name it is bound to (`const onSave = () => …`, `{ onSave: () => … }`), through a wrapping call
+ *  (`const onSave = useCallback(() => …)`, round 3), else `<callee> callback` (`useEffect
+ *  callback`), else `(anonymous)`. A name taken twice in a file gets ` 2`, ` 3` in source order —
+ *  left only for repeated unbound callbacks (two `useEffect`s), where the order IS the identity. A
+ *  bare rule run (no type info, no other rules), so it costs a couple of seconds, not the full lint. */
+type Node = Rule.Node;
+const ident = (n: { type: string; name?: string } | null | undefined): string | undefined =>
+  n?.type === "Identifier" ? n.name : undefined;
+function boundName(p: Node): string | undefined {
+  switch (p.type) {
+    case "VariableDeclarator":
+      return ident(p.id);
+    case "Property":
+    case "PropertyDefinition":
+      return ident(p.key);
+    case "AssignmentExpression":
+      return ident(p.left.type === "MemberExpression" ? p.left.property : p.left);
+    case "CallExpression": {
+      // a wrapped function takes the wrapper's binding: `const onSave = useCallback(() => …)`
+      const outer = p.parent as Node | null;
+      const bound = outer && outer.type !== "CallExpression" ? boundName(outer) : undefined;
+      if (bound) return bound;
+      const callee = ident(p.callee.type === "MemberExpression" ? p.callee.property : p.callee);
+      return callee && `${callee} callback`;
+    }
+    default:
+      return undefined;
+  }
+}
+/** The name each function is bound to, reported where `complexity` reports it (the function's HEAD:
+ *  the `=>` of an arrow, the key of a method, else the function's start) so the two line up. */
+const functionNames: Rule.RuleModule = {
+  create(ctx) {
+    const visit = (node: Node) => {
+      const p = node.parent as Node | null;
+      const name = p && boundName(p);
+      if (!p || !name) return;
+      const head =
+        node.type === "ArrowFunctionExpression"
+          ? ctx.sourceCode.getTokenBefore(node.body, (t) => t.value === "=>")!.loc.start
+          : p.type === "Property" ||
+              p.type === "MethodDefinition" ||
+              p.type === "PropertyDefinition"
+            ? p.loc!.start
+            : node.loc!.start;
+      ctx.report({ loc: head, message: name });
+    };
+    return { ArrowFunctionExpression: visit, FunctionExpression: visit };
+  },
+};
+
+/** The name `functionNames` gives each unnamed function in `code`, in source order (its own test). */
+export function boundNamesIn(code: string): string[] {
+  return new Linter()
+    .verify(
+      code,
+      [
+        {
+          files: ["**/*.tsx"],
+          languageOptions: {
+            parser: tseslint.parser,
+            parserOptions: { ecmaFeatures: { jsx: true } },
+          },
+          plugins: { size: { rules: { "function-names": functionNames } } },
+          rules: { "size/function-names": "error" },
+        },
+      ],
+      "probe.tsx",
+    )
+    .map((m) => m.message);
+}
+
+export async function complexityOffenders(): Promise<Record<string, number>> {
+  const eslint = new ESLint({
+    cwd: fileURLToPath(new URL("../../", import.meta.url)),
+    overrideConfigFile: true,
+    overrideConfig: [
+      {
+        files: ["src/**/*.{ts,tsx}"],
+        ignores: ["**/*.test.*", "**/*.testkit.*"],
+        languageOptions: {
+          parser: tseslint.parser,
+          parserOptions: { ecmaFeatures: { jsx: true } },
+        },
+        plugins: { size: { rules: { "function-names": functionNames } } },
+        rules: { complexity: ["error", MAX_COMPLEXITY], "size/function-names": "error" },
+      },
+    ],
+  });
+  const out: Record<string, number> = {};
+  for (const r of await eslint.lintFiles(["src/**/*.{ts,tsx}"])) {
+    const file = r.filePath
+      .split("\\")
+      .join("/")
+      .replace(/^.*\/frontend\/src\//, "");
+    const at = (m: { line: number; column: number }) => `${m.line}:${m.column}`;
+    const bound = new Map(
+      r.messages.filter((m) => m.ruleId === "size/function-names").map((m) => [at(m), m.message]),
+    );
+    for (const m of r.messages) {
+      if (m.ruleId !== "complexity") continue;
+      const name = /'([^']+)'/.exec(m.message)?.[1] ?? bound.get(at(m)) ?? "(anonymous)";
+      let key = `${file}::${name}`;
+      for (let n = 2; key in out; n++) key = `${file}::${name} ${n}`;
+      out[key] = Number(/complexity of (\d+)/.exec(m.message)?.[1]);
+    }
+  }
+  return out;
+}
diff --git a/frontend/src/lib/storage.ts b/frontend/src/lib/storage.ts
index 1a2feee7..82fe7d7d 100644
--- a/frontend/src/lib/storage.ts
+++ b/frontend/src/lib/storage.ts
@@ -41,6 +41,9 @@ export const LS = {
   channelCardSize: "siftlode.channelCardSize",
   channelDiscoveryCardSize: "siftlode.channelDiscoveryCardSize",
   channelsTable: "siftlode.channelsTable",
+  // Channel id → name as last seen (useChannelNames): names a channel filter's chips after a reload,
+  // before the subscription list has landed. A cache, rewritten from the list on every load.
+  channelNames: "siftlode.channelNames",
   channelDiscoveryTable: "siftlode.channelDiscoveryTable",
   // A page's sub-tab: sessionStorage, per browser tab (useTabPersistedState), like adminUsersTab and
   // statsTab below.
diff --git a/frontend/src/lib/store.contract.test.ts b/frontend/src/lib/store.contract.test.ts
deleted file mode 100644
index 04e397b4..00000000
--- a/frontend/src/lib/store.contract.test.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { readdirSync, readFileSync } from "node:fs";
-import { describe, expect, it } from "vitest";
-
-// A store's `.use()` is a hook the React Compiler cannot see: its name is a method's, not `use…`'s.
-// Called straight from a COMPONENT, the compiled render memoized its result and never re-rendered on
-// a change — Back to top stayed hidden (E28 UAT, measured under vitest's compiler build). Inside a
-// function named `use…` it is compiled as a hook and works, so that is the only place it may be read.
-describe("a store's use()", () => {
-  it("is read only inside a function named use…", () => {
-    const root = new URL("../", import.meta.url);
-    const offenders: string[] = [];
-    for (const f of readdirSync(root, { recursive: true, encoding: "utf8" })) {
-      if (!/\.tsx?$/.test(f) || f.includes(".test.")) continue;
-      const src = readFileSync(new URL(f.replace(/\\/g, "/"), root), "utf8");
-      for (const m of src.matchAll(/\b\w+\.use\(\)/g)) {
-        const before = src.slice(0, m.index);
-        const owners = [...before.matchAll(/(?:function\s+(\w+)|const\s+(\w+)\s*=\s*\()/g)];
-        const owner = owners[owners.length - 1];
-        const name = owner?.[1] ?? owner?.[2] ?? "";
-        if (!name.startsWith("use")) offenders.push(`${f}: ${m[0]} in ${name || "?"}`);
-      }
-    }
-    expect(offenders).toEqual([]);
-  });
-});
diff --git a/frontend/src/lib/store.dom.test.tsx b/frontend/src/lib/store.dom.test.tsx
new file mode 100644
index 00000000..9d54f6e3
--- /dev/null
+++ b/frontend/src/lib/store.dom.test.tsx
@@ -0,0 +1,51 @@
+// @vitest-environment jsdom
+//
+// A store is read from React through `useValue()`, a name the React Compiler knows as a hook. Its
+// old name, `use()`, it did not: the call was compiled as an ordinary one and memoized, so it ran
+// on the first render alone. Read straight from a component, Back to top never re-rendered (E28);
+// read inside a hook that compiles memo scopes around it, usePlaylistActions rendered fewer hooks
+// on its second render and threw (E32 S4, the moment that hook started to compile). Vitest builds
+// with the same compiler as the app (reactPlugin), so this renders the compiled code.
+import { describe, it, expect, afterEach } from "vitest";
+import { render, screen, act, cleanup } from "@testing-library/react";
+import { useState } from "react";
+import { createStore } from "./store";
+
+afterEach(cleanup);
+
+const count = createStore(0);
+
+// A hook shaped like usePlaylistActions: other hooks around the read, and a callback built from it.
+function useCountLabel(prefix: string) {
+  const [step] = useState(1);
+  const value = count.useValue();
+  const next = () => count.set(value + step);
+  return { label: `${prefix}${value}`, next };
+}
+
+function Counter() {
+  const { label, next } = useCountLabel("n=");
+  return <button onClick={next}>{label}</button>;
+}
+
+function Bare() {
+  return <span>{`bare=${count.useValue()}`}</span>;
+}
+
+describe("a store read from React", () => {
+  it("re-renders a compiled hook and a compiled component on every change", () => {
+    act(() => count.set(0));
+    render(
+      <>
+        <Counter />
+        <Bare />
+      </>,
+    );
+    act(() => count.set(1));
+    expect(screen.getByRole("button").textContent).toBe("n=1");
+    expect(screen.getByText("bare=1")).toBeTruthy();
+    act(() => screen.getByRole("button").click());
+    expect(screen.getByRole("button").textContent).toBe("n=2");
+    expect(screen.getByText("bare=2")).toBeTruthy();
+  });
+});
diff --git a/frontend/src/lib/store.ts b/frontend/src/lib/store.ts
index 8f68e9a4..83008505 100644
--- a/frontend/src/lib/store.ts
+++ b/frontend/src/lib/store.ts
@@ -7,8 +7,11 @@ export interface Store<T> {
   get(): T;
   set(next: T | ((prev: T) => T)): void;
   subscribe(listener: () => void): () => void;
-  /** Subscribe from a component; re-renders on every change. */
-  use(): T;
+  /** Subscribe from a component; re-renders on every change. Named `use…` on purpose: the React
+   *  Compiler knows a hook only by that name, and a plain `use()` was compiled as an ordinary call —
+   *  memoized, so it ran on the first render alone (E32: usePlaylistActions then rendered fewer hooks
+   *  and threw; E28: Back to top never re-rendered). */
+  useValue(): T;
 }
 
 export function createStore<T>(initial: T): Store<T> {
@@ -28,6 +31,6 @@ export function createStore<T>(initial: T): Store<T> {
       listeners.forEach((l) => l());
     },
     subscribe,
-    use: () => useSyncExternalStore(subscribe, get, get),
+    useValue: () => useSyncExternalStore(subscribe, get, get),
   };
 }
diff --git a/frontend/src/lib/tagPicks.ts b/frontend/src/lib/tagPicks.ts
new file mode 100644
index 00000000..106eb143
--- /dev/null
+++ b/frontend/src/lib/tagPicks.ts
@@ -0,0 +1,22 @@
+import type { TFunction } from "i18next";
+import type { Tag } from "./api";
+
+// A saved view or a stored filter can outlive its tag (deleted here or on another device). The filter
+// then matches nothing (E32 S2), so its chip must say why instead of reading as a bare id — but only
+// once the tag list has loaded: while it loads the chip is a placeholder (`isPending`), and if the load
+// failed it shows the id, never a guessed "deleted". One rule for the feed's applied-filter row and the
+// channel manager's tag row, which had each written their own and drifted (E32 review).
+
+/** The tag list as react-query hands it over — only what the rule reads. */
+export interface TagList {
+  data?: Tag[];
+  isSuccess: boolean;
+  isPending: boolean;
+}
+
+/** A picked tag's chip label: its name, "Deleted tag" once the list says it is gone, else the id. */
+export function tagPickLabel(id: number, tags: TagList, t: TFunction): string {
+  const tag = tags.data?.find((x) => x.id === id);
+  if (tag) return tag.name;
+  return tags.isSuccess ? t("common.deletedTag") : String(id);
+}
diff --git a/frontend/src/lib/toastDock.ts b/frontend/src/lib/toastDock.ts
index 35665d5a..394b3680 100644
--- a/frontend/src/lib/toastDock.ts
+++ b/frontend/src/lib/toastDock.ts
@@ -24,4 +24,4 @@ export function dockUnderToasts(component: ComponentType): () => void {
 }
 
 /** What is docked (the Toaster reads it). */
-export const useToastDock = (): ComponentType | null => docked.use();
+export const useToastDock = (): ComponentType | null => docked.useValue();
diff --git a/frontend/src/lib/useActiveFilters.ts b/frontend/src/lib/useActiveFilters.ts
index 08fe89c2..c37fd6fd 100644
--- a/frontend/src/lib/useActiveFilters.ts
+++ b/frontend/src/lib/useActiveFilters.ts
@@ -1,7 +1,7 @@
 import { useTranslation } from "react-i18next";
-import { useQuery } from "@tanstack/react-query";
-import { qk } from "./queryKeys";
-import { api, DEFAULT_TAG_MODES, type FeedFilters } from "./api";
+import { DEFAULT_TAG_MODES, type FeedFilters } from "./api";
+import { tagPickLabel } from "./tagPicks";
+import { useChannelNames } from "./useChannelNames";
 import { parseSort } from "./feedSort";
 import { useTags } from "./useTags";
 
@@ -9,6 +9,8 @@ import { useTags } from "./useTags";
 export interface ActiveFilter {
   key: string;
   label: string;
+  /** The name is still on its way: the chip draws a placeholder, not `label` (a raw id). */
+  pending?: boolean;
   remove: () => void;
 }
 
@@ -49,21 +51,16 @@ export function useActiveFilters(
 ): ActiveFilter[] {
   const { t } = useTranslation();
   const tagsQuery = useTags();
-  const channelsQuery = useQuery({
-    queryKey: qk.channels(),
-    queryFn: api.channels,
-    enabled: filters.channelIds.length > 0,
-    staleTime: 5 * 60_000,
-  });
+  const channelNames = useChannelNames(filters.channelIds.length > 0);
 
   const out: ActiveFilter[] = [];
 
   // Tags: one chip each — removing one shouldn't drop the rest.
   for (const id of filters.tags) {
-    const tag = (tagsQuery.data ?? []).find((x) => x.id === id);
     out.push({
       key: `tag:${id}`,
-      label: tag?.name ?? String(id),
+      label: tagPickLabel(id, tagsQuery, t),
+      pending: tagsQuery.isPending,
       remove: () => setFilters({ ...filters, tags: filters.tags.filter((x) => x !== id) }),
     });
   }
@@ -113,9 +110,11 @@ export function useActiveFilters(
   for (const id of filters.channelIds) {
     out.push({
       key: `channel:${id}`,
-      // Fall back to the id, not a generic label: several chips reading "This channel" while
-      // the name cache loads would be indistinguishable, and each ✕ drops a different one.
-      label: channelsQuery.data?.find((c) => c.id === id)?.title ?? id,
+      // Fall back to the id, not a generic label: several chips reading "This channel" would be
+      // indistinguishable, and each ✕ drops a different one. While the list loads, a channel this
+      // browser has never named draws a placeholder instead (the id stays its accessible name).
+      label: channelNames.names[id] ?? id,
+      pending: channelNames.names[id] === undefined && channelNames.pending,
       remove: () =>
         setFilters({ ...filters, channelIds: filters.channelIds.filter((x) => x !== id) }),
     });
diff --git a/frontend/src/lib/useChannelNames.ts b/frontend/src/lib/useChannelNames.ts
new file mode 100644
index 00000000..7cbbd18d
--- /dev/null
+++ b/frontend/src/lib/useChannelNames.ts
@@ -0,0 +1,44 @@
+import { useEffect, useState } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { qk } from "./queryKeys";
+import { api, type ManagedChannel } from "./api";
+import { LS, readAccount, writeAccount } from "./storage";
+
+type Names = Record<string, string>;
+
+const namesOf = (channels: ManagedChannel[]): Names =>
+  Object.fromEntries(channels.map((c) => [c.id, c.title ?? c.id]));
+
+const readNames = (): Names => {
+  const raw = readAccount<unknown>(LS.channelNames, {});
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? (raw as Names) : {};
+};
+
+/**
+ * Channel id → name, for the chips that name a channel filter (the filter panel's picker and the chip
+ * row above the feed). The names come from the subscription list, which a reload has not fetched yet:
+ * for a moment the chips read as raw UC… ids (the owner, 2026-10-03). The names seen last time are
+ * kept per account and name the chips until the list lands; the list then wins and replaces the copy,
+ * so a renamed or dropped channel heals on the next load.
+ *
+ * `pending` is true while the list loads: a channel this browser has never named then has no name to
+ * show, and the chip draws a placeholder rather than its id. A failed list leaves the id (the chips
+ * stay told apart, and each ✕ drops a different one).
+ */
+export function useChannelNames(enabled = true) {
+  const query = useQuery({
+    queryKey: qk.channels(),
+    queryFn: api.channels,
+    enabled,
+    staleTime: 5 * 60_000,
+  });
+  const [remembered] = useState(readNames);
+  useEffect(() => {
+    if (query.data) writeAccount(LS.channelNames, namesOf(query.data));
+  }, [query.data]);
+  return {
+    query,
+    names: query.data ? namesOf(query.data) : remembered,
+    pending: enabled && query.isPending,
+  };
+}
diff --git a/frontend/src/lib/useChannelPriority.ts b/frontend/src/lib/useChannelPriority.ts
index 81d781c7..20257caf 100644
--- a/frontend/src/lib/useChannelPriority.ts
+++ b/frontend/src/lib/useChannelPriority.ts
@@ -2,6 +2,7 @@ import { useCallback, useEffect, useRef } from "react";
 import { api } from "./api";
 import { notifyActionError } from "./actionErrors";
 import i18n from "../i18n";
+import { useLatest } from "./useLatest";
 
 /** The shared feed-priority flow used by both the channel manager and the channel detail page:
  *  an optimistic bump/set with a debounced server flush (~400ms after the last notch) so a
@@ -12,7 +13,7 @@ import i18n from "../i18n";
  *
  *  Timers are keyed by channel id, so a pending flush survives the caller switching channels: it
  *  fires later and reads the right cache via `read(id)`, rather than needing the caller to flush on
- *  every id change. `read`/`optimistic`/`onSuccess`/`onError` are read through a ref so the returned
+ *  every id change. `read`/`optimistic`/`onSuccess`/`onError` are read through `useLatest` so the returned
  *  callbacks stay stable — the unmount flush then runs only on unmount, never on every render. */
 export function useChannelPriority(opts: {
   /** Current priority for this channel from whichever cache the caller owns (undefined if absent). */
@@ -27,22 +28,24 @@ export function useChannelPriority(opts: {
   delay?: number;
 }) {
   const timers = useRef<Map<string, ReturnType<typeof setTimeout>>>(new Map());
-  const optsRef = useRef(opts);
-  optsRef.current = opts;
+  const optsRef = useLatest(opts);
 
-  const flush = useCallback((channelId: string) => {
-    const latest = optsRef.current.read(channelId);
-    if (latest == null) return;
-    api
-      .updateChannel(channelId, { priority: latest })
-      .then(() => optsRef.current.onSuccess?.(channelId))
-      .catch((err: unknown) => {
-        // Said here, once, for both callers: their `onError` only refetches, so a refused priority
-        // used to just snap back — often after the stepper had already been let go (E11 S2b).
-        notifyActionError(err, i18n.t("errors.writeFailed.channelPriority"));
-        optsRef.current.onError(channelId);
-      });
-  }, []);
+  const flush = useCallback(
+    (channelId: string) => {
+      const latest = optsRef.current.read(channelId);
+      if (latest == null) return;
+      api
+        .updateChannel(channelId, { priority: latest })
+        .then(() => optsRef.current.onSuccess?.(channelId))
+        .catch((err: unknown) => {
+          // Said here, once, for both callers: their `onError` only refetches, so a refused priority
+          // used to just snap back — often after the stepper had already been let go (E11 S2b).
+          notifyActionError(err, i18n.t("errors.writeFailed.channelPriority"));
+          optsRef.current.onError(channelId);
+        });
+    },
+    [optsRef],
+  );
 
   // Set an absolute priority (used by both the arrows — via bumpPriority — and the inline edit),
   // optimistically + a debounced flush.
@@ -59,7 +62,7 @@ export function useChannelPriority(opts: {
         }, optsRef.current.delay ?? 400),
       );
     },
-    [flush],
+    [flush, optsRef],
   );
 
   // Read the LATEST value from the cache each step (not a render closure) so a hold-repeat
@@ -68,7 +71,7 @@ export function useChannelPriority(opts: {
     (channelId: string, delta: number) => {
       setPriority(channelId, (optsRef.current.read(channelId) ?? 0) + delta);
     },
-    [setPriority],
+    [setPriority, optsRef],
   );
 
   useEffect(() => {
diff --git a/frontend/src/lib/useChipOverflowFit.ts b/frontend/src/lib/useChipOverflowFit.ts
index 29a6246d..c9064f0d 100644
--- a/frontend/src/lib/useChipOverflowFit.ts
+++ b/frontend/src/lib/useChipOverflowFit.ts
@@ -1,4 +1,4 @@
-import { useLayoutEffect, useRef, useState, type RefObject } from "react";
+import { useEffectEvent, useLayoutEffect, useState, type RefObject } from "react";
 
 // The shared DOM-measure-and-fit core for a single-line chip lane that collapses its overflow into a
 // trailing "+N" pill. Owns the layout-effect + ResizeObserver + initial-measure wiring and reads the
@@ -69,11 +69,10 @@ export function useChipOverflowFit<R>(args: {
 }): R {
   const { rowRef, chipsRef, pillRef, deps, decide, initial } = args;
   const [result, setResult] = useState<R>(initial);
-  // Read `decide` fresh each run without making it an effect dependency: the effect re-runs on `deps`
+  // Read `decide` fresh each run (an effect event) without making it an effect dependency: the effect re-runs on `deps`
   // (and resize), and a caller's decide closure is rebuilt every render — depending on it would
   // resubscribe the ResizeObserver on every render.
-  const decideRef = useRef(decide);
-  decideRef.current = decide;
+  const decideNow = useEffectEvent(decide);
 
   useLayoutEffect(() => {
     const row = rowRef.current;
@@ -85,7 +84,7 @@ export function useChipOverflowFit<R>(args: {
       const chips = (chipsRef.current ?? []).filter((c): c is HTMLElement => c != null);
       const lastChip = chips[chips.length - 1];
       setResult(
-        decideRef.current({
+        decideNow({
           avail: row.clientWidth,
           chipRights: chips.map(rightOf),
           pillW: pill.offsetWidth,
diff --git a/frontend/src/lib/useDebounced.dom.test.ts b/frontend/src/lib/useDebounced.dom.test.ts
index 3107b6a0..ebaa987b 100644
--- a/frontend/src/lib/useDebounced.dom.test.ts
+++ b/frontend/src/lib/useDebounced.dom.test.ts
@@ -16,7 +16,9 @@ describe("useDebounced", () => {
     });
     rerender({ v: "ab" });
     expect(result.current).toBe("a");
-    act(() => vi.advanceTimersByTime(300));
+    act(() => {
+      vi.advanceTimersByTime(300);
+    });
     expect(result.current).toBe("ab");
   });
 
@@ -29,7 +31,9 @@ describe("useDebounced", () => {
     expect(result.current).toBe("boom");
     rerender({ v: "boomx", s: 1 });
     expect(result.current).toBe("boom");
-    act(() => vi.advanceTimersByTime(300));
+    act(() => {
+      vi.advanceTimersByTime(300);
+    });
     expect(result.current).toBe("boomx");
   });
 });
diff --git a/frontend/src/lib/useDismiss.ts b/frontend/src/lib/useDismiss.ts
index a37cbdf1..d162528a 100644
--- a/frontend/src/lib/useDismiss.ts
+++ b/frontend/src/lib/useDismiss.ts
@@ -1,4 +1,4 @@
-import { useEffect, useRef, type RefObject } from "react";
+import { useEffect, useEffectEvent, type RefObject } from "react";
 import { useLayer } from "./layerStack";
 
 /** While `active`, close (call `onClose`) on Escape or a mousedown outside ALL of the given
@@ -26,26 +26,22 @@ export function useDismiss(
 
   // Outside-press stays per-instance (the refs/positioning are the caller's): close on a mousedown
   // that lands outside every registered element.
-  // Both arguments are read through refs so the listener can stay subscribed once per open/close —
+  // Both arguments are read through an effect event so the listener can stay subscribed once per open/close —
   // which is the point of the `[active]` dep list — without going STALE. The disabled dep list this
   // replaces asserted that onClose was "read fresh from this run's closure"; it was not. The closure
   // is built when `active` last flipped, so a caller that re-rendered with a different handler while
   // the popover stayed open kept getting the old one called (regression test in useDismiss.dom.test).
   // `refs` is the weaker case — the ref OBJECTS are stable, so a late-mounting node is seen either
   // way — but a caller that changes WHICH refs it passes while open was equally ignored.
-  const onCloseRef = useRef(onClose);
-  onCloseRef.current = onClose;
-  const refsRef = useRef(refs);
-  refsRef.current = refs;
+  const onPress = useEffectEvent((e: MouseEvent) => {
+    const list = Array.isArray(refs) ? refs : [refs];
+    const target = e.target as Node;
+    if (!list.some((r) => r.current?.contains(target))) onClose();
+  });
 
   useEffect(() => {
     if (!active) return;
-    const onDown = (e: MouseEvent) => {
-      const current = refsRef.current;
-      const list = Array.isArray(current) ? current : [current];
-      const target = e.target as Node;
-      if (!list.some((r) => r.current?.contains(target))) onCloseRef.current();
-    };
+    const onDown = (e: MouseEvent) => onPress(e);
     document.addEventListener("mousedown", onDown);
     return () => {
       document.removeEventListener("mousedown", onDown);
diff --git a/frontend/src/lib/useFocusKeeper.ts b/frontend/src/lib/useFocusKeeper.ts
index 5292d324..aa00c603 100644
--- a/frontend/src/lib/useFocusKeeper.ts
+++ b/frontend/src/lib/useFocusKeeper.ts
@@ -38,6 +38,7 @@ function firstFocusable(node: Node | null, fromEnd = false): HTMLElement | null
  *  else the previous one, widening to the parent's neighbours — so its removal does not drop the
  *  focus to <body>. For a removal the caller makes itself (a chip's ×) anywhere, including a modal
  *  or a side panel, where the keeper below does not watch. False when nothing was found. */
+/** @internal exported for useFocusKeeper.dom.test.tsx */
 export function focusNeighbour(el: HTMLElement): boolean {
   for (let at: HTMLElement | null = el; at && at !== document.body; at = at.parentElement) {
     const hit = firstFocusable(at.nextSibling) ?? firstFocusable(at.previousSibling, true);
diff --git a/frontend/src/lib/useLatest.ts b/frontend/src/lib/useLatest.ts
new file mode 100644
index 00000000..a4cb4ea4
--- /dev/null
+++ b/frontend/src/lib/useLatest.ts
@@ -0,0 +1,26 @@
+import { useCallback, useLayoutEffect, useRef, type RefObject } from "react";
+
+/** A ref that holds the latest COMMITTED `value`, for a stable callback that must still read fresh
+ *  props: an event handler, a timer, an API that takes its callbacks once. When only effects read the
+ *  value, use `useEffectEvent` instead.
+ *
+ *  Written in a layout effect, never during render. A render-phase `ref.current = value` makes the
+ *  React Compiler skip the whole component (E32), and it is wrong under concurrent rendering anyway:
+ *  a render React throws away would still have overwritten the value. Read it outside render only. */
+export function useLatest<T>(value: T): RefObject<T> {
+  const ref = useRef(value);
+  useLayoutEffect(() => {
+    ref.current = value;
+  });
+  return ref;
+}
+
+/** A callback with a STABLE identity that always runs the latest `fn` — for a handler handed to
+ *  something memoized (a column set, a menu model) that must not rebuild whenever the handler's
+ *  inputs change. Call it from events only, never during render: it runs the last COMMITTED `fn`. */
+export function useStableCallback<A extends unknown[], R>(
+  fn: (...args: A) => R,
+): (...args: A) => R {
+  const latest = useLatest(fn);
+  return useCallback((...args: A) => latest.current(...args), [latest]);
+}
diff --git a/frontend/src/lib/useMediaQuery.ts b/frontend/src/lib/useMediaQuery.ts
index 0b8929ed..849aeb2e 100644
--- a/frontend/src/lib/useMediaQuery.ts
+++ b/frontend/src/lib/useMediaQuery.ts
@@ -1,5 +1,9 @@
 import { useSyncExternalStore } from "react";
 
+/** The reader asked the system for less motion (Windows also reports it whenever its animation
+ *  effects are off). One spelling for the hook and for a one-off `matchMedia` read alike. */
+export const REDUCED_MOTION = "(prefers-reduced-motion: reduce)";
+
 /** Whether a CSS media query matches, live. For a component that must RENDER differently at a
  *  breakpoint rather than merely hide one of two renders with CSS (`ui/DataTable` mounted its table
  *  AND its card list at every width: double the DOM, duplicate ids and keyboard targets). Where
diff --git a/frontend/src/lib/usePlexCollectionTitles.dom.test.tsx b/frontend/src/lib/usePlexCollectionTitles.dom.test.tsx
index 1064a41a..32223a48 100644
--- a/frontend/src/lib/usePlexCollectionTitles.dom.test.tsx
+++ b/frontend/src/lib/usePlexCollectionTitles.dom.test.tsx
@@ -44,7 +44,7 @@ describe("usePlexCollectionTitles", () => {
       wrapper: wrap(),
     });
     await waitFor(() =>
-      expect(result.current["17045"]).toBe("Pirates of the Caribbean Collection"),
+      expect(result.current.titles["17045"]).toBe("Pirates of the Caribbean Collection"),
     );
     // Only the missing ids are asked for — nothing else.
     expect(plexCollections).toHaveBeenCalledWith(undefined, undefined, ["17045"]);
@@ -55,7 +55,7 @@ describe("usePlexCollectionTitles", () => {
     const { result } = renderHook(() => usePlexCollectionTitles(["17045"], known), {
       wrapper: wrap(),
     });
-    expect(result.current["17045"]).toBe("Pirates of the Caribbean Collection");
+    expect(result.current.titles["17045"]).toBe("Pirates of the Caribbean Collection");
     // Give a would-be fetch a chance to happen before asserting it did not.
     await new Promise((r) => setTimeout(r, 20));
     expect(plexCollections).not.toHaveBeenCalled();
@@ -66,10 +66,10 @@ describe("usePlexCollectionTitles", () => {
       () => usePlexCollectionTitles(["17045", "68231"], { "17045": "Already Known" }),
       { wrapper: wrap() },
     );
-    await waitFor(() => expect(result.current["68231"]).toBe("IMDb Top 250"));
+    await waitFor(() => expect(result.current.titles["68231"]).toBe("IMDb Top 250"));
     // The known id is not in the request — and its stored title survives the merge.
     expect(plexCollections).toHaveBeenCalledWith(undefined, undefined, ["68231"]);
-    expect(result.current["17045"]).toBe("Already Known");
+    expect(result.current.titles["17045"]).toBe("Already Known");
   });
 
   it("treats the same ids in a different order as one query", async () => {
@@ -77,12 +77,12 @@ describe("usePlexCollectionTitles", () => {
     const a = renderHook(() => usePlexCollectionTitles(["68231", "17045"], undefined), {
       wrapper: w,
     });
-    await waitFor(() => expect(a.result.current["17045"]).toBeDefined());
+    await waitFor(() => expect(a.result.current.titles["17045"]).toBeDefined());
     const calls = plexCollections.mock.calls.length;
     const b = renderHook(() => usePlexCollectionTitles(["17045", "68231"], undefined), {
       wrapper: w,
     });
-    await waitFor(() => expect(b.result.current["17045"]).toBeDefined());
+    await waitFor(() => expect(b.result.current.titles["17045"]).toBeDefined());
     expect(plexCollections.mock.calls.length).toBe(calls);
   });
 
@@ -91,7 +91,21 @@ describe("usePlexCollectionTitles", () => {
     const { result } = renderHook(() => usePlexCollectionTitles(["17045"], undefined), {
       wrapper: wrap(),
     });
-    // The caller falls back to its own label; it must not be handed a half-built map.
-    expect(result.current["17045"]).toBeUndefined();
+    // The caller falls back to its own label; it must not be handed a half-built map — and it is
+    // told the names are on their way, so it draws a placeholder rather than the raw id.
+    expect(result.current.titles["17045"]).toBeUndefined();
+    expect(result.current.pending).toBe(true);
+  });
+
+  it("is not pending when nothing is missing, nor once the lookup answered", async () => {
+    const known = renderHook(() => usePlexCollectionTitles(["17045"], { "17045": "Known" }), {
+      wrapper: wrap(),
+    });
+    expect(known.result.current.pending).toBe(false);
+    const cold = renderHook(() => usePlexCollectionTitles(["17045"], undefined), {
+      wrapper: wrap(),
+    });
+    await waitFor(() => expect(cold.result.current.pending).toBe(false));
+    expect(cold.result.current.titles["17045"]).toBe("Pirates of the Caribbean Collection");
   });
 });
diff --git a/frontend/src/lib/usePlexCollectionTitles.ts b/frontend/src/lib/usePlexCollectionTitles.ts
index ec2c380c..8467b2dc 100644
--- a/frontend/src/lib/usePlexCollectionTitles.ts
+++ b/frontend/src/lib/usePlexCollectionTitles.ts
@@ -10,11 +10,13 @@ import { qk } from "./queryKeys";
 // This resolves the missing ones from the server and merges them over what the filter state already
 // knows. It stays OUT of `collectionTitles`: that map is hashed into the Plex query keys, so writing a
 // resolved title back in would split the cache from the logically identical state and refetch the grid
-// for a label. Titles are display-only, so they belong in a display-only read.
+// for a label. Titles are display-only, so they belong in a display-only read. `pending` says the
+// missing ones are still on their way, so a token or chip can show a placeholder rather than the raw id
+// (Combobox `labelsPending`, ActiveFilter `pending` — the feed's channel picker does the same).
 export function usePlexCollectionTitles(
   ids: string[],
   known: Record<string, string> | undefined,
-): Record<string, string> {
+): { titles: Record<string, string>; pending: boolean } {
   // Sorted so the same set of ids in a different order is the same query.
   const missing = ids.filter((id) => !known?.[id]).sort();
   const q = useQuery({
@@ -25,7 +27,7 @@ export function usePlexCollectionTitles(
     // of the sidebar and the chip row.
     staleTime: 60 * 60_000,
   });
-  const out: Record<string, string> = { ...known };
-  for (const c of q.data?.collections ?? []) out[c.id] = c.title;
-  return out;
+  const titles: Record<string, string> = { ...known };
+  for (const c of q.data?.collections ?? []) titles[c.id] = c.title;
+  return { titles, pending: missing.length > 0 && q.isPending };
 }
diff --git a/frontend/src/lib/usePref.dom.test.ts b/frontend/src/lib/usePref.dom.test.ts
index 05c5bc67..072e9a55 100644
--- a/frontend/src/lib/usePref.dom.test.ts
+++ b/frontend/src/lib/usePref.dom.test.ts
@@ -143,7 +143,9 @@ describe("usePref", () => {
       // Local state is instant; the server write is deferred.
       expect(result.current[0]).toBe(30);
       expect(savePrefs).not.toHaveBeenCalled();
-      act(() => vi.advanceTimersByTime(300));
+      act(() => {
+        vi.advanceTimersByTime(300);
+      });
       expect(savePrefs).toHaveBeenCalledTimes(1);
       expect(savePrefs).toHaveBeenCalledWith({ vol: 30 });
     });
diff --git a/frontend/src/lib/usePref.ts b/frontend/src/lib/usePref.ts
index e081dee8..b195b5be 100644
--- a/frontend/src/lib/usePref.ts
+++ b/frontend/src/lib/usePref.ts
@@ -74,20 +74,13 @@ export function usePref<T>(
   const { localKey, debounceMs, parse } = options;
   const qc = useQueryClient();
 
-  // Latest parse in a ref so the seed and the setter don't depend on a fresh closure each render (which
-  // would churn the memoized setter). parse must be idempotent anyway.
-  const parseRef = useRef(parse);
-  parseRef.current = parse;
-  const norm = useCallback((raw: unknown): T => {
-    const p = parseRef.current;
-    return p ? p(raw) : (raw as T);
-  }, []);
-
   // Seeded inline rather than through a memoized `seed()`: useState calls a lazy initializer exactly
   // once, at mount, so there was nothing for the useCallback to save — and its dep list was the one
   // place in this file that had to be excused from the checker (it read `defaultValue` without
   // naming it). Server preference wins, then the per-account localStorage mirror, then the default.
   const [value, setValue] = useState<T>(() => {
+    // `parse` is read here only, once: the setter stores what it is given.
+    const norm = (raw: unknown): T => (parse ? parse(raw) : (raw as T));
     const server = readServerPref(qc.getQueryData<Me | null>(qk.me()), serverKey);
     if (server !== undefined) return norm(server);
     if (localKey) return norm(readAccount(localKey, defaultValue));
@@ -124,10 +117,10 @@ export function usePref<T>(
         pendingSave.current = flush;
         saveTimer.current = window.setTimeout(() => {
           pendingSave.current = null;
-          flush();
+          void flush();
         }, debounceMs);
       } else {
-        flush();
+        void flush();
       }
     },
     [qc, serverKey, localKey, debounceMs],
diff --git a/frontend/src/lib/useUndoable.dom.test.ts b/frontend/src/lib/useUndoable.dom.test.ts
new file mode 100644
index 00000000..88003698
--- /dev/null
+++ b/frontend/src/lib/useUndoable.dom.test.ts
@@ -0,0 +1,40 @@
+// @vitest-environment jsdom
+//
+// The undo container chains calls made in one tick: a `reset` not yet committed is what the next
+// call builds on. A `rebase` read the mirror ref, which only follows a commit, so it rebased the
+// value from BEFORE the reset and wrote that back — the playlist page, remounted under StrictMode
+// over a cached list, re-ran its seeding effect (reset, then rebase) and painted an empty list.
+import { describe, expect, it } from "vitest";
+import { act, renderHook } from "@testing-library/react";
+import { useUndoable } from "./useUndoable";
+
+describe("useUndoable", () => {
+  it("rebases the value a reset in the same tick installed, not the one before it", () => {
+    const { result } = renderHook(() => useUndoable<number[]>([]));
+    act(() => {
+      result.current.reset([1, 2]);
+      result.current.rebase((xs) => xs.map((x) => x * 10));
+    });
+    expect(result.current.value).toEqual([10, 20]);
+  });
+
+  it("keeps the undo history through a rebase", () => {
+    const { result } = renderHook(() => useUndoable<number[]>([1]));
+    act(() => result.current.set([1, 2]));
+    act(() => result.current.rebase((xs) => xs.map((x) => x + 1)));
+    expect(result.current.value).toEqual([2, 3]);
+    act(() => result.current.undo());
+    expect(result.current.value).toEqual([2]);
+  });
+
+  it("undoes to a rebased snapshot when the undo comes in the same tick as the rebase", () => {
+    const { result } = renderHook(() => useUndoable<number[]>([1, 2]));
+    act(() => result.current.set([2, 1]));
+    act(() => {
+      result.current.rebase((xs) => xs.filter((x) => x !== 2)); // a row removed
+      result.current.undo();
+    });
+    expect(result.current.value).toEqual([1]);
+    expect(result.current.canRedo).toBe(true);
+  });
+});
diff --git a/frontend/src/lib/useUndoable.ts b/frontend/src/lib/useUndoable.ts
index 504efa18..56b89b38 100644
--- a/frontend/src/lib/useUndoable.ts
+++ b/frontend/src/lib/useUndoable.ts
@@ -1,4 +1,5 @@
-import { useCallback, useReducer, useRef } from "react";
+import { useCallback, useLayoutEffect, useRef, useState } from "react";
+import { useLatest } from "./useLatest";
 
 // A generic, reusable undo/redo container for a single piece of state.
 //
@@ -9,8 +10,10 @@ import { useCallback, useReducer, useRef } from "react";
 // onApply (use it when the underlying data is reloaded from the source of truth).
 //
 // Not playlist-specific: any component with an undoable value (sort order, a draft, a set
-// of filters…) can use it. State lives in a ref so the callbacks are stable and never read
-// a stale snapshot; a reducer-based force-render keeps the view in sync.
+// of filters…) can use it. The history is state (what render reads) mirrored in a ref (what the
+// stable callbacks read, so two calls in one tick chain on each other, never on a stale snapshot —
+// save after a `reset`, which is state only and reaches the mirror at its commit; see `reset`).
+// Render never reads the ref: a compiled component would otherwise memoize a stale value (E32).
 export interface Undoable<T> {
   value: T;
   set: (next: T) => void;
@@ -32,10 +35,18 @@ export function useUndoable<T>(
   initial: T,
   opts?: { onApply?: (value: T) => void; limit?: number },
 ): Undoable<T> {
-  const [, force] = useReducer((n: number) => n + 1, 0);
-  const ref = useRef<History<T>>({ past: [], present: initial, future: [] });
-  const onApplyRef = useRef(opts?.onApply);
-  onApplyRef.current = opts?.onApply;
+  const [h, setH] = useState<History<T>>(() => ({ past: [], present: initial, future: [] }));
+  const ref = useRef(h);
+  // The mirror follows every commit, so a `reset` made during render (a caller re-seeding on a new
+  // selection) reaches the callbacks without a render-phase ref write.
+  useLayoutEffect(() => {
+    ref.current = h;
+  }, [h]);
+  const commit = useCallback((next: History<T>) => {
+    ref.current = next;
+    setH(next);
+  }, []);
+  const onApplyRef = useLatest(opts?.onApply);
   const limit = opts?.limit ?? 100;
 
   const set = useCallback(
@@ -44,39 +55,38 @@ export function useUndoable<T>(
       if (Object.is(next, s.present)) return;
       const past = [...s.past, s.present];
       if (past.length > limit) past.shift();
-      ref.current = { past, present: next, future: [] };
-      force();
+      commit({ past, present: next, future: [] });
       onApplyRef.current?.(next);
     },
-    [limit],
+    [limit, commit, onApplyRef],
   );
 
   const undo = useCallback(() => {
     const s = ref.current;
     if (!s.past.length) return;
     const prev = s.past[s.past.length - 1]!; // past is non-empty (guarded above)
-    ref.current = {
+    commit({
       past: s.past.slice(0, -1),
       present: prev,
       future: [s.present, ...s.future],
-    };
-    force();
+    });
     onApplyRef.current?.(prev);
-  }, []);
+  }, [commit, onApplyRef]);
 
   const redo = useCallback(() => {
     const s = ref.current;
     if (!s.future.length) return;
     const next = s.future[0]!; // future is non-empty (guarded above)
     const rest = s.future.slice(1);
-    ref.current = { past: [...s.past, s.present], present: next, future: rest };
-    force();
+    commit({ past: [...s.past, s.present], present: next, future: rest });
     onApplyRef.current?.(next);
-  }, []);
+  }, [commit, onApplyRef]);
 
+  // State only: safe to call during render. `rebase` builds on it at once; `set`/`undo`/`redo` read
+  // the mirror, so they see it from the next commit on (no caller acts in the tick of a reset — a
+  // set, undo or redo in that tick would commit the history from before it).
   const reset = useCallback((value: T) => {
-    ref.current = { past: [], present: value, future: [] };
-    force();
+    setH({ past: [], present: value, future: [] });
   }, []);
 
   // Apply the same transformation to EVERY snapshot — past, present and future — and keep the
@@ -84,17 +94,22 @@ export function useUndoable<T>(
   // removing a playlist item is not itself undoable, yet dropping it from each stored order keeps
   // the user's reorder history valid and usable instead of throwing it away (which is what a
   // `reset` does). No `onApply`: the caller is already persisting the change by its own route.
+  // The STATE through an updater: a `reset` earlier in the same tick is state only, so the mirror
+  // still held the history before it, and rebasing that wrote the old value back over the reset (a
+  // cached playlist remounted under StrictMode re-seeds with reset-then-rebase and painted empty).
+  // The mirror is rebased too, so an `undo` later in the same tick steps back to a rebased snapshot,
+  // not to one that still holds the removed row (E32 review round 2). Called from handlers and
+  // effects only, never during render.
   const rebase = useCallback((map: (value: T) => T) => {
-    const s = ref.current;
-    ref.current = {
+    const over = (s: History<T>) => ({
       past: s.past.map(map),
       present: map(s.present),
       future: s.future.map(map),
-    };
-    force();
+    });
+    ref.current = over(ref.current);
+    setH(over);
   }, []);
 
-  const h = ref.current;
   return {
     value: h.present,
     set,
diff --git a/frontend/src/lib/useUrlMirror.ts b/frontend/src/lib/useUrlMirror.ts
index 5dd8fc9d..451c1194 100644
--- a/frontend/src/lib/useUrlMirror.ts
+++ b/frontend/src/lib/useUrlMirror.ts
@@ -1,4 +1,4 @@
-import { useEffect, useRef } from "react";
+import { useEffect, useEffectEvent } from "react";
 import { urlWithParams } from "./urlState";
 
 // Mirror a set of nav params onto the CURRENT history entry (replaceState — mirroring is not a new
@@ -10,12 +10,13 @@ export function useUrlMirror(updates: Record<string, string | null>): void {
   // The caller typically passes an inline object literal (new identity every render); key on its
   // serialized value so the effect only fires when a param actually changes, not every render.
   const dep = JSON.stringify(updates);
-  // The object itself is read through a ref, so the effect's one reactive input is the serialized
-  // value — which is exactly what the dep list now says. The house pattern (see useChipOverflowFit's
-  // decideRef, usePref's parseRef): a ref for the identity that churns, a primitive for the trigger.
-  const updatesRef = useRef(updates);
-  updatesRef.current = updates;
+  // The object itself is read through an effect event, so the effect's one reactive input is the
+  // serialized value — which is exactly what the dep list says: an effect event for the identity that
+  // churns, a primitive for the trigger.
+  const mirror = useEffectEvent(() => {
+    window.history.replaceState(window.history.state, "", urlWithParams(updates));
+  });
   useEffect(() => {
-    window.history.replaceState(window.history.state, "", urlWithParams(updatesRef.current));
+    mirror();
   }, [dep]);
 }
diff --git a/frontend/tsconfig.node.json b/frontend/tsconfig.node.json
index 3b6092e4..0d2f3c60 100644
--- a/frontend/tsconfig.node.json
+++ b/frontend/tsconfig.node.json
@@ -23,22 +23,27 @@
     "noUnusedLocals": true,
     "noUnusedParameters": true,
     "noFallthroughCasesInSwitch": true,
+    // E32: an index read is `T | undefined` here, as it really is (0 errors when switched on).
+    "noUncheckedIndexedAccess": true,
     "resolveJsonModule": true,
-    // The build-tool configs include two hand-written .js files (tailwind/postcss). checkJs runs
-    // the type checker over them via their `@type` JSDoc, so a bad tailwind/postcss option is
-    // caught by the gate instead of silently mis-building CSS. Was the last hole in C-4.5.
+    // The build-tool configs include a hand-written .js file (postcss; tailwind 4 needs no config
+    // file, and the stale `tailwind.config.js` entry pointed at nothing until E32). checkJs runs
+    // the type checker over it via its `@type` JSDoc, so a bad option is caught by the gate instead
+    // of silently mis-building CSS. Was the last hole in C-4.5.
     "allowJs": true,
     "checkJs": true
   },
   // reactPlugin.ts is the ONE React transform both configs import (E27 S1) — it is build tooling,
   // not app source, so it belongs here and not under tsconfig.json's ["src"]. A file imported by a
-  // listed one but absent from `include` is TS6307, not a silent pass.
+  // listed one but absent from `include` is TS6307, not a silent pass. playwright.config.ts is
+  // here as well as in e2e/tsconfig.json because eslint's typed rules (E32) find a file's project
+  // through tsconfig.json's `references`, which name this project and not the e2e one.
   "include": [
     "vite.config.ts",
     "vitest.config.ts",
     "reactPlugin.ts",
     "devOnlyGuard.ts",
-    "tailwind.config.js",
+    "playwright.config.ts",
     "postcss.config.js"
   ]
 }
diff --git a/frontend/vitest.config.ts b/frontend/vitest.config.ts
index c8ce1502..f7fc3212 100644
--- a/frontend/vitest.config.ts
+++ b/frontend/vitest.config.ts
@@ -19,5 +19,13 @@ export default defineConfig({
     // collected, and the gate still prints green.
     include: ["src/**/*.test.{ts,tsx}"],
     environment: "node",
+    // E32 D4: a coverage REPORT, read and not enforced — the gate's `vitest --coverage` prints the
+    // summary; no threshold, because "every regression test seen red" is the bar, not a percentage.
+    coverage: {
+      provider: "v8",
+      include: ["src/**/*.{ts,tsx}"],
+      exclude: ["src/**/*.test.{ts,tsx}", "src/**/*.testkit.ts", "src/**/*.d.ts"],
+      reporter: ["text-summary"],
+    },
   },
 });
diff --git a/scripts/check-node-modules.mjs b/scripts/check-node-modules.mjs
new file mode 100644
index 00000000..b3ced4fc
--- /dev/null
+++ b/scripts/check-node-modules.mjs
@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+// Does frontend/node_modules hold exactly what frontend/package-lock.json pins? (E32)
+//
+// The local gate's frontend lanes run against the HOST's node_modules, and nothing tied that tree to
+// the lock: a `git pull` that bumped a dependency, or an `npm install` that was never committed, left
+// tsc/eslint/vitest judging the code against packages the build image (`npm ci`) does not use — a
+// green that proves nothing about what ships, in either direction. CI is immune (it runs `npm ci`);
+// this makes the local lanes say so instead of quietly differing.
+//
+// Checks every package the lock places under node_modules/: present, at the pinned version. A package
+// marked `optional` may be absent (a platform binary for another OS). Exit 1 with the list and the
+// one command that fixes it.
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const FRONTEND = join(dirname(fileURLToPath(import.meta.url)), "..", "frontend");
+const lock = JSON.parse(readFileSync(join(FRONTEND, "package-lock.json"), "utf8"));
+
+const problems = [];
+for (const [path, entry] of Object.entries(lock.packages ?? {})) {
+  if (!path.startsWith("node_modules/") || entry.link) continue;
+  const manifest = join(FRONTEND, path, "package.json");
+  if (!existsSync(manifest)) {
+    if (!entry.optional) problems.push(`missing   ${path.slice(13)}@${entry.version}`);
+    continue;
+  }
+  const installed = JSON.parse(readFileSync(manifest, "utf8")).version;
+  if (installed !== entry.version)
+    problems.push(
+      `mismatch  ${path.slice(13)}: installed ${installed}, lock pins ${entry.version}`,
+    );
+}
+
+if (problems.length) {
+  console.error(`frontend/node_modules does not match package-lock.json (${problems.length}):`);
+  for (const p of problems.slice(0, 20)) console.error(`  ${p}`);
+  if (problems.length > 20) console.error(`  … and ${problems.length - 20} more`);
+  console.error("Fix: cd frontend && npm ci");
+  process.exit(1);
+}
+console.log(
+  `node_modules matches package-lock.json (${Object.keys(lock.packages).length - 1} entries)`,
+);
diff --git a/scripts/e2e_seed.py b/scripts/e2e_seed.py
index 975011e4..e1dd85d0 100644
--- a/scripts/e2e_seed.py
+++ b/scripts/e2e_seed.py
@@ -21,10 +21,10 @@ from datetime import datetime, timezone
 
 sys.path.insert(0, "/app")
 
-from sqlalchemy import delete, func, select  # noqa: E402
+from sqlalchemy import delete, func, select
 
-from app.db import SessionLocal  # noqa: E402
-from app.models import (  # noqa: E402
+from app.db import SessionLocal
+from app.models import (
     AppState,
     Channel,
     Playlist,
@@ -34,7 +34,7 @@ from app.models import (  # noqa: E402
     Video,
     VideoState,
 )
-from app.security import hash_password  # noqa: E402
+from app.security import hash_password
 
 EMAIL = os.environ.get("E2E_EMAIL", "e2e@siftlode.local")
 PASSWORD = os.environ.get("E2E_PASSWORD", "")
@@ -171,7 +171,7 @@ def main() -> None:
                 saved = svid.id
         db.commit()
 
-        # noqa T201: this script's stdout IS its interface — the e2e runner parses this JSON.
+        # T201: this script's stdout IS its interface — the e2e runner parses this JSON.
         print(  # noqa: T201
             json.dumps(
                 {
diff --git a/scripts/gen-changelog.mjs b/scripts/gen-changelog.mjs
index 692f33cd..866caf93 100644
--- a/scripts/gen-changelog.mjs
+++ b/scripts/gen-changelog.mjs
@@ -70,7 +70,9 @@ if (process.argv.includes("--check")) {
     );
     process.exit(1);
   }
-  console.log(`CHANGELOG.md is current (${entries.length} releases, newest ${entries[0].version}).`);
+  console.log(
+    `CHANGELOG.md is current (${entries.length} releases, newest ${entries[0].version}).`,
+  );
 } else {
   await writeFile(TARGET, rendered, "utf8");
   console.log(`Wrote CHANGELOG.md — ${entries.length} releases, newest ${entries[0].version}.`);