feat(replay): add full-screen tableau dim layer for mini-tableau preview

Spawn a `ReplayTableauDimLayer` UI node (100% × 100%, 50% opacity black) at z=54 (Z_REPLAY_OVERLAY − 1) whenever a replay starts. The dim layer darkens the entire card world so the replay chrome (banner at z=55, move-log panel at z=55) reads clearly against the scene without obscuring card positions — matching the mockup's "Game Peek Band at 50% opacity" spec. Bevy's UI/world compositor means no changes to card_plugin are needed: UI nodes always render above world-space sprites regardless of Transform.z values. The dim layer carries no Interaction component (purely visual; pointer events pass through). Despawned alongside the banner and move-log panel in `react_to_state_change` when the replay ends. Adds Z_REPLAY_DIM (= 54) and TABLEAU_DIM_ALPHA (= 0.5) constants plus two new tests: lifecycle (spawn/despawn mirrors floating chip pattern) and z-ordering invariant (Z_REPLAY_DIM < Z_REPLAY_OVERLAY pinned). 1275 tests pass / 0 failing. Closes the last major B-2 sub-piece. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
docs(handoff): refresh post-v0.21.6 — anchor to new tag, reset menu state
2026-05-08 18:01:22 -07:00 · 2026-05-08 17:48:51 -07:00 · 2026-05-08 17:46:24 -07:00 · 2026-05-08 17:44:59 -07:00 · 2026-05-08 17:41:14 -07:00 · 2026-05-08 17:35:07 -07:00
10 changed files with 3683 additions and 113 deletions
@@ -6,9 +6,390 @@ project follows [Semantic Versioning](https://semver.org/).
 ## [Unreleased]
-No threads in flight. v0.21.3 cut on 2026-05-08; CHANGELOG accumulates
+No threads in flight. v0.21.6 cut on 2026-05-08; CHANGELOG accumulates
 the next cycle here.
 ## [0.21.6] — 2026-05-08
 Patch release for the post-v0.21.5 work. Through-line:
 **Move Log panel + scrub-UX polish**. v0.21.5 closed out the
 keyboard-accelerator surface (Space / Esc / ← / →) and the
 keybind footer; v0.21.6 builds on that with two parallel
 threads — accessibility + scrub-on-hold polish for the v0.21.5
 surfaces, plus a brand-new Move Log panel anchored to the
 viewport's bottom edge that gives players a 5-row recent-and-
 upcoming move history alongside the existing top-edge banner.
 The Move Log panel is the first replay-overlay surface that
 *isn't* attached to the banner — it lives at a separate screen
 anchor (bottom: 0) with its own spawn/despawn lifecycle.
 Establishes the pattern for "multi-anchor replay UI" that the
 remaining B-2 sub-piece (mini-tableau preview) will inherit.
 ### Added
 - **HC-mode coverage for the scrub track + quarter-mark notch
  ticks** (`d3cb1a5`). Adds parallel primitive
  `HighContrastBackground` to `ui_theme` and a paint system
  `update_high_contrast_backgrounds` in `settings_plugin` that
  mirrors the existing border-marker pattern but targets
  `BackgroundColor` instead of `BorderColor`. Tags the 1 px
  scrub track Node and all five quarter-mark notch ticks so
  they bump from `BORDER_SUBTLE` (`#505050`) →
  `BORDER_SUBTLE_HC` (`#a0a0a0`) under HC mode. Scrub fill
  (`ACCENT_PRIMARY`) and WIN MOVE marker (`STATE_SUCCESS`)
  don't get the marker — accent and state colours are already
  saturated and don't need an HC luminance variant.
 - **Continuous scrub on key-held arrow keys** (`2e25476`).
  Holding ← or → triggers continuous step at 100 ms cadence
  (10 steps/sec) — matches the mockup's `[← →] scrub`
  terminology while keeping single-press = single-step
  semantics. Per-key accumulators in a new
  `ReplayScrubKeyHold` resource; `just_pressed` events bypass
  the accumulator and fire immediately. Release resets to 0
  so the next fresh press fires immediately rather than at
  half-interval.
 - **Move Log panel** (`d6f32d3` + `140251b` + `e7345ae` +
  `4437a1a`). New bottom-edge UI panel showing a 5-row window
  onto recent + upcoming moves: 2 prev rows above the active
  row + active row highlighted in `ACCENT_PRIMARY` + 2 next
  rows below. Header reads `▌ MOVE LOG · N/M` (or
  `▌ MOVE LOG · COMPLETE` when finished). Active row carries
  a `▶` focus prefix and `TEXT_PRIMARY_HC` text colour for
  legible contrast against the brick-red highlight. Prev /
  next rows render in `TEXT_SECONDARY` so the active row
  stays the focal point.
  - Sibling-of-banner pattern (separate root entity anchored
    at viewport bottom, not a banner child) — same
    spawn/despawn lifecycle as `ReplayFloatingProgressChip`,
    different screen anchor.
  - Five pure helpers handle the formatting:
    `format_pile`, `format_move_body`,
    `format_move_log_header`, `format_kth_recent_row` (active
    + prev), `format_kth_next_row` (next). 1-indexed display
    numbers throughout (`Foundation(2)` reads as "foundation
    3" rather than the enum's 0-index).
  - Panel grows from 56 → 84 → 112 px across the four
    move-log commits. `MOVE_LOG_PREV_ROWS` and
    `MOVE_LOG_NEXT_ROWS` constants (both = 2) parameterise
    the row count; `format_kth_recent_row` and
    `format_kth_next_row` return empty for out-of-range k so
    panels gracefully under-fill at the start (cursor=1) and
    end (cursor=N-1) of a replay.
  - HC marker on the panel's top border so the 1 px edge
    bumps under HC mode (same pattern as the keybind footer).
 ### Changed
 - **`react_to_state_change` despawns the Move Log panel** on
  `Playing → Inactive` alongside the banner root and floating
  progress chip. Third query in the same defer-and-despawn
  cycle.
 - **Move Log panel height grew 56 → 84 → 112 px** across the
  prev-rows and next-rows commits. The panel is sized to fit
  the chosen row count + header + padding; tunable via the
  `MOVE_LOG_PANEL_HEIGHT` const.
 - **`format_active_move_row` now prefixes the `▶` focus
  marker** (`e7345ae`). Wraps `format_kth_recent_row(state, 1)`
  and prepends the prefix when the body is non-empty. Empty
  case still returns empty — cursor=0 doesn't paint a stray
  `▶` on an otherwise-empty row.
 ### Documentation
 - `SESSION_HANDOFF.md` refreshed twice this cycle — once
  recording the HC paint + continuous-scrub polish, then
  again as the Move Log arc shipped commit-by-commit. The
  Resume menu's B option now traces the full arc:
  notches → labels → footer → ESC → HC → arrow keys →
  HC paint → continuous scrub → move log.
 ### Stats
 - **1273 passing tests / 0 failing** across the workspace
  (net +23 from v0.21.5's 1250 baseline):
  - 2 from `d3cb1a5` (HC marker on track + notches).
  - 2 from `2e25476` (continuous-scrub repeat-while-held +
    release-resets-accumulator).
  - 8 from `d6f32d3` (move-log panel init + 5 helpers + 3
    spawn / lifecycle scenarios).
  - 4 from `140251b` (prev rows: helper k coverage + spawn
    cardinality + spawn texts + repaint on cursor advance).
  - 3 from `e7345ae` (active row highlight: wrapper bg +
    text colour + focus prefix + cursor=0 stays empty).
  - 4 from `4437a1a` (next rows: helper k coverage + spawn
    cardinality + spawn texts + under-fill at replay end).
 - Clippy clean across the workspace.
 ## [0.21.5] — 2026-05-08
 Patch release for the post-v0.21.4 work. One through-line:
 **replay-overlay scrubbing affordances + accessibility**. v0.21.4
 shipped pause / resume / step + the WIN MOVE marker as the first
 *scrubbing-shaped* additions to the replay overlay; v0.21.5
 fills out the rest of the scrubbing UX so the player has both
 visual anchor points (notches + labels) and a complete keyboard
 control surface (Space / Esc / ← / →) for navigating a paused
 replay.
 Two of the six commits in this cycle are layout-changing — they
 grow the banner height from 60 px → 76 px → 92 px to make room
 for the notch labels and keybind footer. Banner geometry was
 fixed for every prior B-2 commit; this release establishes the
 "grow the container, add a flex-column child" pattern that the
 remaining B-2 sub-pieces (move-log scroller, mini-tableau
 preview) will inherit when they land.
 ### Added
 - **Quarter-mark scrub-bar notches** (`fe68861`). Five 1 px
  vertical ticks at 0 / 25 / 50 / 75 / 100 % give the player
  visual anchor points without needing to mentally bisect the
  bar. Pure helper `scrub_notch_positions()` returns the fixed
  array; spawn loop sits next to the WIN MOVE marker spawn so
  the lifecycles match. Notches paint in `BORDER_SUBTLE` (same
  as the unfilled track) and rely on extending past the 1 px
  track (5 px tall, anchored 2 px above the track top) for
  visibility — same trick the WIN MOVE marker uses. Spawned
  *after* the WIN MOVE marker so a notch and the marker
  landing on the same percentage paint the marker on top.
 - **Percentage labels under each notch** (`d322abf`). Five
  `0%` / `25%` / `50%` / `75%` / `100%` labels in a new 16 px
  row beneath the 1 px scrub track give the player explicit
  quarter-mark readouts. Banner grew from 60 → 76 px to
  accommodate the row — first **layout-changing** commit in
  the B-2 arc. Pure helper `scrub_notch_labels()` returns the
  fixed array, paired index-for-index with
  `scrub_notch_positions()`. Spawn loop applies an "endpoints
  flush, middle three percent-anchored" positioning pattern:
  leftmost label gets `left: 0`, rightmost gets `right: 0`,
  middle three anchor at `left: Val::Percent(p)` since Bevy
  0.18 UI lacks a clean CSS-style `translate-x: -50%`
  centering primitive. Label colour is `TEXT_SECONDARY`
  rather than the mockup's `BORDER_SUBTLE` (the latter would
  match the notches but is too low-contrast against
  `BG_ELEVATED_HI` to read at 12 px).
 - **Keybind-hint footer** (`1873b3f`). Vim-style mode line on
  the left (`▌ NORMAL │ replay`) plus a keybind hint on the
  right at the bottom edge of the banner. Banner grew from
  76 → 92 px to fit the 16 px footer row. Surfaces every
  wired keyboard accelerator visually so CLAUDE.md §3.3's
  UI-first contract holds for keyboard accelerators too. The
  footer lists *only* keybinds that are actually wired —
  the only-wired-keybinds discipline means each release
  cycle's hint string is a precise honest contract with the
  player. Two pure helpers (`keybind_footer_mode_text`,
  `keybind_footer_hint_text`) keep the static text testable.
  1 px top border in `BORDER_SUBTLE` separates the footer
  from the labels row.
 - **ESC keyboard accelerator for replay-stop** (`90e24d9`).
  New `handle_stop_keyboard` system parallels
  `handle_pause_keyboard` in shape — fires only when state
  is `Playing`, calls `stop_replay_playback`. Cross-plugin
  coordination via `pause_plugin::toggle_pause`: added a
  fourth defer-if check
  (`replay_state.is_some_and(|s| s.is_playing())`) right
  after the existing `other_modal_scrims` check so ESC
  during active replay belongs to the replay overlay, not
  the pause modal.
 - **HC-mode coverage for the keybind-footer top border**
  (`23902cd`).
  `HighContrastBorder::with_default(BORDER_SUBTLE)` marker
  on the footer's border-carrying Node so the existing
  `apply_high_contrast_borders` system bumps the 1 px top
  border from `#505050` → `#a0a0a0` when
  `Settings::high_contrast_mode` is on. Without the marker
  the footer reads as floating loose under HC because the
  border that anchors it to the labels row is
  near-invisible.
 - **← / → keyboard accelerators for paused stepping**
  (`e5c4f51`). New `step_backwards_replay_playback` in
  `replay_playback.rs` decrements the cursor and dispatches
  `UndoRequestEvent`; the game's `handle_undo` reads it
  next frame to reverse its most-recent move. Hooks the
  existing undo system rather than replaying-forward-from-
  zero — every replay-applied move pushes to the undo stack
  the same way a player move would, so undo is the right
  reversal primitive. Both arrow keys are paused-only via
  the same destructure-gate pattern the forward step uses.
  The mockup labels these `[← →] scrub`; single-move step
  is the closest behaviour shippable today, so the footer
  hint reads `[← →] step` — only-wired-keybinds discipline.
 ### Changed
 - **Banner height grew 60 → 76 → 92 px** across two
  layout-changing commits (`d322abf` then `1873b3f`). Top
  row's `flex_grow: 1.0` still consumes 59 px so the
  existing content (label / progress chip / buttons) has
  the same vertical space; the new rows (16 px labels +
  16 px footer) extend the banner downward into the
  gameplay area. Banner geometry is now mutable — every
  prior B-2 commit fit inside fixed 60 px space.
 - **Keybind-footer hint text grew alongside the wirings**:
  `[SPACE] pause/resume` →
  `[SPACE] pause/resume · [ESC] stop` →
  `[SPACE] pause/resume · [ESC] stop · [← →] step`.
 - **`pause_plugin::toggle_pause` now defers when a replay
  is active** (`90e24d9`). Adds a fourth defer-if check to
  the existing modal-stack pattern.
 - **`ReplayOverlayPlugin` registers
  `add_message::<UndoRequestEvent>()`** (`e5c4f51`).
  Defensive registration so the plugin runs cleanly under
  `MinimalPlugins` without `GamePlugin` attached.
 ### Documentation
 - `SESSION_HANDOFF.md` refreshed five times this cycle.
  The B option in the Resume menu now traces the full arc:
  notches → labels → footer → ESC → HC → arrow keys.
 - The pre-existing `daily_challenge` warning test that
  fails when wall-clock UTC is within 30 minutes of
  midnight is documented in this cycle's handoff. Same
  shape as the earlier `winnable_seed_search` flake —
  time-dependent, deterministically passes outside the
  trigger window.
 ### Stats
 - **1250 total tests / 1249 passing / 1 pre-existing
  time-dependent flake** across the workspace (net +22 from
  v0.21.4's 1228 baseline):
  - 4 from `fe68861` (scrub-notch coverage)
  - 4 from `d322abf` (notch-label coverage)
  - 4 from `1873b3f` (keybind-footer coverage)
  - 3 from `90e24d9` (ESC-accelerator coverage)
  - 1 from `23902cd` (HC-marker coverage)
  - 6 from `e5c4f51` (arrow-keyboard coverage)
 - **Pre-existing flake**:
  `daily_challenge_plugin::tests::check_system_fires_warning_event_only_once_per_day`
  fails when wall-clock UTC is within 30 minutes of
  midnight. Verified pre-existing by stash-and-retest
  before each commit. Will pass deterministically outside
  the trigger window. Not introduced by this release.
 - Clippy clean across the workspace.
 ## [0.21.4] — 2026-05-08
 Patch release for the post-v0.21.3 work. One through-line:
 **replay-scrubbing accessibility**. The replay overlay used to be
 pure-passive — the player started a replay, watched it execute,
 and waited for it to end. v0.21.4 adds the scaffolding for
 *navigating within* a replay: a WIN MOVE marker on the scrub bar
 so the player can see at a glance where the winning move sits,
 and pause / resume / step controls so they can stop on any move
 and inspect the board.
 The work is also the first three commits on the B-2 replay
 screen-takeover redesign arc. The remaining pieces (screen-
 takeover layout, move-log scroller, mini-tableau preview) are
 deferred to a future cycle because they need a layout reflow
 that the existing banner-only overlay can't carry.
 ### Added
 - **`Replay::win_move_index: Option<usize>` data field**
  (`ab857bb`). Additive optional field on the persisted
  `Replay` shape. `#[serde(default)]` keeps older
  `latest_replay.json` / `replays.json` files loadable without
  bumping `REPLAY_SCHEMA_VERSION` — this is purely additive.
  Populated at the live recording site
  (`game_plugin::handle_game_won`) via a new builder-style
  setter `Replay::with_win_move_index`. For fresh recordings
  the value is always `Some(moves.len() - 1)` because recording
  freezes on win, but storing it explicitly lets the playback
  UI read the WIN MOVE position directly without re-deriving
  on every render.
 - **WIN MOVE scrub-bar marker** (`52befa6`). New
  `ReplayOverlayWinMoveMarker` component spawned as a sibling
  to `ReplayOverlayScrubFill` under the 1px scrub track,
  absolute-positioned at `replay.win_move_index / total %` of
  the bar. Painted in `STATE_SUCCESS` (green) so the marker
  reads as "this is where the win lives." Pure helper
  `win_move_marker_pct` returns `None` for any state where the
  marker shouldn't draw (Inactive, Completed, replay missing
  the field, empty move list); percentage clamps to `[0, 100]`
  defensively. Spawn-time only — the position never changes
  during a single playback because the underlying `Replay` is
  immutable while `Playing`.
 - **Pause / Resume / Step playback controls** (`fbe48ac`). New
  `paused: bool` field on `ReplayPlaybackState::Playing`.
  `tick_replay_playback` skips the `secs_to_next` decrement
  entirely while paused so cursor and timer freeze together;
  resuming starts the next move from a full interval. New
  public API: `toggle_pause_replay_playback` and
  `step_replay_playback` (the latter hard-gated to `Playing {
  paused: true }` via the destructure pattern itself, so
  manual stepping can't race the tick loop). On-screen Pause
  and Step buttons sit alongside the existing Stop button;
  `Space` keyboard accelerator toggles pause / resume.
 - **`Replay::with_win_move_index` builder** (`ab857bb`).
  Chainable setter so the recording site can write
  `Replay::new(...).with_win_move_index(idx)`. Keeps
  `Replay::new`'s signature stable across the 13+ existing
  test-fixture call sites that don't care about the field.
 ### Changed
 - **`Replay::new` writes `win_move_index: None`** (`ab857bb`).
  Existing canonical constructor stays signature-compatible
  with all existing callers. The field is opt-in via the
  builder.
 - **`game_plugin::handle_game_won` populates the new field**
  (`ab857bb`). The recording site computes
  `recording.moves.len().checked_sub(1)` as the win-move
  index. `checked_sub` rather than direct subtraction guards
  the unreachable empty-recording branch (which is also
  guarded earlier in the function).
 - **`tick_replay_playback` honors the new `paused` flag**
  (`fbe48ac`). Skipping the timer decrement is the only
  behavior change; the loop body and Completed-detection are
  unchanged. Stepping fires moves directly via
  `step_replay_playback`, bypassing the tick path entirely.
 - **Pause / Resume button label is reactive** (`fbe48ac`).
  `update_pause_button_label` walks `Children` from the
  marked button to its inner `Text` and repaints the label
  whenever `ReplayPlaybackState` changes. Pure helper
  `pause_button_label` covers all four state arms (running,
  paused, inactive, completed).
 - **25 existing `Playing { ... }` construction sites gained
  `paused: false`** (`fbe48ac`). Mechanical edit across
  `replay_overlay`, `achievement_plugin`, and
  `replay_playback` tests to satisfy the new field
  requirement. No behavioral change.
 ### Documentation
 - `SESSION_HANDOFF.md` refreshed three times this cycle —
  once after each post-cut feature commit. The B-2 entry in
  the Visual-identity follow-ups list now points at the
  remaining sub-pieces (screen-takeover layout, move-log
  scroller, mini-tableau preview) as a single multi-session
  arc rather than three independent ones, since they share a
  layout-reflow prerequisite.
 ### Stats
 - **1228 passing tests / 0 failing** across the workspace
  (net +21 from v0.21.3's 1207 baseline):
  - 5 from `ab857bb`'s `win_move_index` coverage: default
    constructor, builder set / set-None, on-disk round-trip,
    legacy-JSON-loads-with-None backward-compat. The last
    test pins the no-schema-bump claim — if a future refactor
    drops the `#[serde(default)]`, that test catches it.
  - 8 from `52befa6`'s WIN MOVE marker: pure-helper truth
    table (Inactive / Completed / no-field / correct-position
    / clamp) + spawn-presence-with-field /
    spawn-absence-without / despawn-with-overlay observables.
  - 8 from `fbe48ac`'s playback controls: label truth table,
    label repaint on state change, click-toggles-paused,
    step advances cursor by exactly one with paused
    preserved, step-while-running no-op, Space toggles
    paused.
 - Zero clippy warnings under `cargo clippy --workspace
  --all-targets -- -D warnings`.
 - `cargo test --workspace` clean.
 ## [0.21.3] — 2026-05-08
 Patch release for the post-v0.21.2 work. One through-line:
@@ -1,73 +1,85 @@
 # Solitaire Quest — Session Handoff
-**Last updated:** 2026-05-08 — v0.21.2 cut and tagged at `f23df3b`;
+**Last updated:** 2026-05-08 — **v0.21.6 cut and tagged at
-post-cut work shipped: Toast Warning (`279e23d`) and the HC
+`f63db76`**, working tree clean, all post-tag work pushed to
-dynamic-paint rollout (`c153363`). Working tree clean, all
+origin.
 post-tag work pushed to origin.
-v0.21.2 is a patch release for the post-v0.21.1 polish work:
+v0.21.6 is a patch release with through-line:
-extends accessibility (full HC chrome rollout across 8 surfaces;
+**Move Log panel + scrub-UX polish**. v0.21.5 closed out the
-splash reduce-motion gating on scanline + cursor pulse), adds a
+keyboard-accelerator surface (Space / Esc / ← / →) and the
-floating MOVE chip above the destination card during replay
+keybind footer; v0.21.6 builds on that with two parallel
-playback, and lights up the first real consumer of
+threads — accessibility + scrub-on-hold polish for the v0.21.5
-`ToastVariant::Error` (a "Invalid move" toast as the third leg
+surfaces, plus a brand-new Move Log panel anchored to the
-of the existing audio + visual rejection-feedback stool).
+viewport's bottom edge that gives players a 5-row recent-and-
 upcoming move history alongside the existing top-edge banner.
-Full v0.21.2 detail lives in `CHANGELOG.md` § [0.21.2]. This
+The Move Log panel is the first replay-overlay surface that
 *isn't* attached to the banner — it lives at a separate screen
 anchor (`bottom: 0`) with its own spawn/despawn lifecycle.
 Establishes the "multi-anchor replay UI" pattern that the
 remaining B-2 sub-piece (mini-tableau preview) will inherit.
 Six commits on the B-2 replay screen-takeover redesign arc land
 here, bringing the post-v0.21.4 total to 12. The remaining B-2
 piece — mini-tableau preview that dims the gameplay tableau
 during replay — is the only major sub-piece still open.
 Full v0.21.6 detail lives in `CHANGELOG.md` § [0.21.6]. This
 file from here on focuses on what's *open* post-cut and how to
 resume.
 ## Status at pause
 - **HEAD locally:** see `git rev-parse HEAD`. The cut commit is
-  `f23df3b`; post-cut work (`279e23d` Toast Warning, `c153363`
+  `f63db76`; any post-cut docs edits ride on top of that.
-  HC dynamic-paint rollout) rides on top of that.
+- **HEAD on origin:** matches local. v0.21.6 is fully on origin.
 - **HEAD on origin:** matches local. v0.21.2 is fully on origin.
 - **Working tree:** clean. No WIP outstanding.
 - **`artwork/` directory:** still untracked. Intentional.
 - **Build:** `cargo clippy --workspace --all-targets -- -D warnings`
  clean.
- **Tests:** **1207 passing / 0 failing** across the workspace
+- **Tests:** **1273 passing / 0 failing** across the workspace.
-  (net +12 from the v0.21.2 cut: 8 from Toast Warning wiring;
+  Detail in `CHANGELOG.md` § [0.21.6] § Stats.
-  4 from the radial-rim HC truth-table).
+- **Tags on origin:** `v0.9.0` through `v0.21.6`. v0.21.6 is on
- **Tags on origin:** `v0.9.0` through `v0.21.2`. v0.21.2 is on
+  `f63db76`; v0.21.5 stays on `a2432df`; v0.21.4 stays on
  `23ff62c`; v0.21.3 stays on `3d92a91`; v0.21.2 stays on
  `f23df3b`; v0.21.1 stays on `daa655a`; v0.21.0 stays on
  `04f9bf9`; v0.20.0 stays on `41a009a`.
-## Since the v0.21.2 cut
+## Since the v0.21.6 cut
- **`279e23d` — Toast Warning variant wired.** First in-engine
+No threads in flight. Working tree clean as of 2026-05-08. New
-  consumer of `ToastVariant::Warning`: a 4 s amber-bordered
+work since the cut would land here as commit narratives; for
-  toast that fires once per daily-challenge date when the
+the v0.21.6 contents themselves, see `CHANGELOG.md` § [0.21.6].
  player is within 30 min of UTC midnight reset and hasn't yet
  completed today's challenge. Mirrors the v0.21.2 Toast Error
  pattern — a domain message (`WarningToastEvent(String)`) is
  the contract between the daily plugin and the animation
  plugin's spawn handler. Suppression decided by a pure helper
  (`compute_expiry_warning_minutes`) that's exhaustively tested
  without an `App`. After this commit every `ToastVariant`
  (Info / Warning / Error / Celebration) has at least one real
  driver — the variant enum is fully load-bearing.
 - **`c153363` — HC rollout to the dynamic-paint sites.** Closes
  the v0.21.2 carve-out. Re-reading the code revealed only one
  of three "dynamic-paint" sites was actually a border-paint
  cycle — HUD action buttons and modal buttons paint
  *backgrounds* dynamically with static borders, so they take
  the existing `HighContrastBorder` marker pattern cleanly. The
  radial menu rim is the only true dynamic-painter (full
  per-frame respawn of `Sprite` entities); HC is folded into
  the spawn there with a pure helper (`radial_rim_outline`)
  that boosts the *focused* rim to `BORDER_SUBTLE_HC` under HC
  rather than `BORDER_STRONG` — naive marker substitution would
  invert the focused-vs-resting hierarchy because
  `BORDER_SUBTLE_HC` (#a0a0a0) is lighter than `BORDER_STRONG`
  (#505050). After this commit, every UI surface in the v0.21.x
  accessibility arc either carries the marker or has HC folded
  into its own spawn cycle. No "un-tagged because race-risk"
  surfaces remain.
-For the v0.21.2 contents themselves, see `CHANGELOG.md` §
+Open next-step menu (Move Log + scrub-UX + keyboard accelerator
-[0.21.2].
+coverage + accessibility are all complete):
 1. **Mini-tableau preview** — the only remaining major B-2
   sub-piece. Mockup shows a 240 px-tall band at 50 % opacity
   showing the gameplay tableau peeking through the replay
   chrome. Implementation needs to add a settings-aware dim
   overlay or alpha modulation on the tableau cards during
   replay. Architectural — touches `card_plugin` rendering.
   Multi-session.
 2. **Move Log auto-scroll** — only relevant if the panel's
   row count grows beyond the current 5-row fixed window.
   Currently the prev-2 / active / next-2 layout fits all
   visible content, so auto-scroll is unneeded. Becomes
   relevant if a future commit expands the panel's row
   capacity (e.g. 10-row scrolling list).
 3. **Polish: notch label centering.** Bevy 0.18 lacks a
   clean `translate-x: -50%` primitive so middle three
   labels sit slightly right-of-notch. Could use a child
   Text wrapper with computed left-margin compensation.
   Tiny commit, requires visual review.
 4. **Polish: WIN MOVE marker HC bump.** Currently uses
   `STATE_SUCCESS` lime which stays visible under HC, but a
   contrast bump under HC would make it even more legible
   alongside the bumped notches. Optional.
 Recommended order: option 1 (mini-tableau preview) is the
 big remaining piece that closes B-2 — best tackled in a
 fresh session because it crosses into `card_plugin`. Options
 3 and 4 are visual polish that benefit from user review.
 ## Open punch list
@@ -105,11 +117,25 @@ palette refresh all shipped in v0.20.0 + v0.21.0. What stays open:
  a WIN MOVE marker on the scrub bar. Banner-local pieces all
  shipped in v0.21.0 (`c84d9f4` + `6204db8` + `54005d5` +
  `e080b49`); the floating MOVE chip above the focused card
-  shipped in v0.21.2 (`2fb2d63`). The screen-takeover is a
+  shipped in v0.21.2 (`2fb2d63`). The WIN MOVE scrub-bar marker
-  multi-session redesign with data-layer impact — needs a new
+  shipped post-v0.21.3 in `ab857bb` (data field) + `52befa6`
-  `win_move_index: Option<usize>` field on `Replay` (currently
+  (UI). Playback controls (pause / resume / step + Space
-  unimplemented), a move-log scroller, and a mini-tableau
+  accelerator) shipped post-v0.21.3 in `fbe48ac`. v0.21.5
-  preview.
+  bundled six more commits under "replay-overlay scrubbing
  affordances + accessibility" (scrub notches + labels +
  keybind footer + ESC and ← / → accelerators + HC border).
  v0.21.6 bundled six more under "Move Log panel + scrub-UX
  polish" — bottom-edge Move Log panel with prev/active/next
  rows + active highlight, HC-mode coverage for the scrub
  track + notches, continuous scrub on key-held arrows. Banner
  height grew 60 → 76 → 92 px across two layout-changing
  commits in v0.21.5; Move Log panel grew 56 → 84 → 112 px
  across the v0.21.6 move-log commits. Per-commit detail in
  `CHANGELOG.md` § [0.21.5] and § [0.21.6]. The only major
  B-2 piece left is the mini-tableau preview — the mockup's
  "Game Peek Band" at 50 % opacity. Architectural; touches
  `card_plugin` rendering.
  Multi-session.
 - *Floating `MOVE N/M` chip above the focused card during
  playback — closed 2026-05-08 by `2fb2d63`.* World-space
  `Text2d` entity sibling to the banner overlay; uses the same
@@ -252,22 +278,23 @@ into a v0.21.1 / v0.22.0 cut.
 ```
 You are a senior Rust + Bevy developer working on Solitaire Quest.
 Working directory: <Rusty_Solitaire clone path on this machine>.
-Branch: master. v0.21.2 is tagged at f23df3b (cut 2026-05-08, a
+Branch: master. v0.21.6 is tagged at f63db76 (cut 2026-05-08, a
-patch release rolling up accessibility extensions, replay polish,
+patch release rolling up Move Log panel + scrub-UX polish:
-and the first real `ToastVariant::Error` consumer). v0.21.1 stays
+brand-new bottom-edge Move Log panel with prev / active / next
-at daa655a, v0.21.0 at 04f9bf9. Working tree clean. Post-cut
+row context + active-row highlight, plus HC-mode coverage for
-work shipped: Toast Warning variant (`279e23d`) and the HC
+scrub track + notches and continuous scrub on key-held arrow
-dynamic-paint rollout (`c153363`) — accessibility arc is fully
+keys). v0.21.5 stays at a2432df, v0.21.4 at 23ff62c, v0.21.3
-closed, every `ToastVariant` has at least one real driver. See
+at 3d92a91, v0.21.2 at f23df3b, v0.21.1 at daa655a, v0.21.0 at
-CHANGELOG.md § [0.21.2] + the "Since the v0.21.2 cut" section
+04f9bf9. Working tree clean. See CHANGELOG.md § [0.21.6] for
-above for full detail.
+full detail.
-State: HEAD locally — see `git rev-parse HEAD`. All workspace tests
+State: HEAD locally — see `git rev-parse HEAD`. The cut commit
-pass (1207+; check with `cargo test --workspace`), clippy clean.
+is f63db76; any post-cut docs edits ride on top of that.
 Workspace tests: 1273 passing / 0 failing. Clippy clean.
 READ FIRST (in order, before doing anything):
  1. SESSION_HANDOFF.md  — this file
-  2. CHANGELOG.md        — [0.21.2] section is the most recent cut
+  2. CHANGELOG.md        — [0.21.6] section is the most recent cut
  3. CLAUDE.md           — unified-3.0 rule set
  4. CLAUDE_SPEC.md      — formal architecture spec
  5. ARCHITECTURE.md     — crate responsibilities + data flow
@@ -287,11 +314,22 @@ DECISION TO ASK THE PLAYER FIRST:
     tests can't catch. Likely surfaces JNI ClipboardManager
     and Android Keystore stubs that need real bridges. Larger
     scope; needs an Android device or emulator running.
-  B. Replay-overlay screen-takeover redesign — multi-session
+  B. Replay-overlay screen-takeover redesign — nearly complete
-     work: move-log scroller, mini-tableau preview, WIN MOVE
+     after 12 commits across v0.21.4-6. Scrub bar with notches
-     marker on the scrub bar (needs new `Replay::win_move_index`
+     + labels + WIN MOVE marker, pause / resume / step / stop
-     field), playback controls. The smaller floating-MOVE-chip
+     buttons, Space + Esc + ← / → keyboard accelerators with
-     piece of B already shipped in v0.21.2 (`2fb2d63`).
+     continuous scrub on hold, keybind-hint footer, full HC-mode
     coverage on the banner pieces, and a brand-new bottom-edge
     Move Log panel with a 5-row prev/active/next window all
     ship. The only remaining major B-2 sub-piece is the
     **mini-tableau preview** — the mockup's "Game Peek Band"
     at 50 % opacity showing the tableau through the replay
     chrome. Implementation needs a settings-aware dim overlay
     or alpha modulation on the tableau cards during replay.
     Architectural — touches `card_plugin` rendering. Best
     tackled in a fresh session because it crosses into a
     plugin the recent B-2 work hasn't touched. Mockup at
     `docs/ui-mockups/replay-overlay-mobile.html`.
  C. Phase 8 (sync) — local storage scaffolding, self-hosted
     Axum server, `SolitaireServerClient` impl, GPGS stub
     wired into Settings. The biggest open arc by scope; rolls
@@ -147,12 +147,38 @@ pub struct Replay {
    /// [`REPLAY_SCHEMA_VERSION`].
    #[serde(default)]
    pub share_url: Option<String>,
    /// Index into [`moves`](Self::moves) of the move that triggered
    /// the win condition (i.e. completed the last foundation pile).
    ///
    /// For replays recorded by the live engine this is always
    /// `Some(moves.len() - 1)` because recording freezes on win — but
    /// the field is stored explicitly so the playback UI can read it
    /// directly without re-deriving "the last move was the win" each
    /// time, and to leave room for future recording semantics that
    /// might capture post-win state.
    ///
    /// `None` for replays loaded from disk that pre-date this field.
    /// `#[serde(default)]` keeps older `latest_replay.json` /
    /// `replays.json` files loadable without bumping
    /// [`REPLAY_SCHEMA_VERSION`] — this is an additive optional
    /// field, not a schema-breaking change.
    ///
    /// Surfaced by the replay-overlay scrub bar's WIN MOVE marker
    /// (B-2 screen-takeover redesign) when present.
    #[serde(default)]
    pub win_move_index: Option<usize>,
 }
 impl Replay {
    /// Construct a fresh replay with the current schema version. The
    /// caller fills in the recorded fields; this is the canonical
    /// constructor used by the engine on win.
    ///
    /// [`win_move_index`](Self::win_move_index) and
    /// [`share_url`](Self::share_url) default to `None` — the engine
    /// uses [`with_win_move_index`](Self::with_win_move_index) at the
    /// recording site to set the former, and `sync_plugin` writes the
    /// latter directly when the upload task resolves.
    pub fn new(
        seed: u64,
        draw_mode: DrawMode,
@@ -172,8 +198,24 @@ impl Replay {
            recorded_at,
            moves,
            share_url: None,
            win_move_index: None,
        }
    }
    /// Builder-style setter for [`win_move_index`](Self::win_move_index).
    /// Returns `self` so the recording site can chain it onto
    /// [`Replay::new`]:
    ///
    /// ```ignore
    /// let replay = Replay::new(...).with_win_move_index(Some(recording.moves.len() - 1));
    /// ```
    ///
    /// `None` is a valid input — useful for tests that don't care about
    /// the WIN MOVE marker's scrub-bar position.
    pub fn with_win_move_index(mut self, idx: Option<usize>) -> Self {
        self.win_move_index = idx;
        self
    }
 }
 /// Rolling history of the player's most recent winning replays.
@@ -737,4 +779,71 @@ mod tests {
        let _ = fs::remove_file(&path);
    }
    // -----------------------------------------------------------------------
    // win_move_index — additive optional field for the WIN MOVE marker
    // -----------------------------------------------------------------------
    #[test]
    fn replay_new_defaults_win_move_index_to_none() {
        let r = sample_replay();
        assert_eq!(r.win_move_index, None);
    }
    #[test]
    fn with_win_move_index_sets_value() {
        let r = sample_replay().with_win_move_index(Some(3));
        assert_eq!(r.win_move_index, Some(3));
    }
    #[test]
    fn with_win_move_index_accepts_none() {
        // Passing None through the builder is a valid no-op — useful for
        // tests / synthetic replays that don't care about the marker.
        let r = sample_replay().with_win_move_index(None);
        assert_eq!(r.win_move_index, None);
    }
    #[test]
    fn replay_with_win_move_index_round_trips_on_disk() {
        let path = tmp_path("win_move_index_round_trip");
        let _ = fs::remove_file(&path);
        let original = sample_replay().with_win_move_index(Some(3));
        save_latest_replay_to(&path, &original).expect("save");
        let loaded = load_latest_replay_from(&path).expect("load");
        assert_eq!(loaded.win_move_index, Some(3));
        assert_eq!(loaded, original);
        let _ = fs::remove_file(&path);
    }
    /// Older replay files written before this field was added must still
    /// load — `#[serde(default)]` keeps `win_move_index` optional and
    /// defaults missing fields to `None`. This is the contract that lets
    /// us add the field without bumping `REPLAY_SCHEMA_VERSION`.
    #[test]
    fn replay_without_win_move_index_loads_with_none() {
        let path = tmp_path("legacy_no_win_move_index");
        let _ = fs::remove_file(&path);
        // Hand-rolled minimal v2 replay JSON with no win_move_index field.
        let v2_no_field = r#"{
            "schema_version": 2,
            "seed": 1,
            "draw_mode": "DrawOne",
            "mode": "Classic",
            "time_seconds": 60,
            "final_score": 100,
            "recorded_at": "2026-05-02",
            "moves": []
        }"#;
        fs::write(&path, v2_no_field).expect("write fixture");
        let loaded = load_latest_replay_from(&path).expect("load");
        assert_eq!(loaded.win_move_index, None);
        assert_eq!(loaded.schema_version, REPLAY_SCHEMA_VERSION);
        let _ = fs::remove_file(&path);
    }
 }
@@ -1445,6 +1445,7 @@ mod tests {
                replay: dummy_replay(),
                cursor: 0,
                secs_to_next: 0.0,
                paused: false,
            };
        app.update();
        assert!(
@@ -1480,6 +1481,7 @@ mod tests {
                replay: dummy_replay(),
                cursor: 0,
                secs_to_next: 0.0,
                paused: false,
            };
        app.update();
@@ -1512,6 +1514,7 @@ mod tests {
                replay: dummy_replay(),
                cursor: 0,
                secs_to_next: 0.0,
                paused: false,
            };
        app.update();
        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
@@ -1534,6 +1537,7 @@ mod tests {
                replay: dummy_replay(),
                cursor: 0,
                secs_to_next: 0.0,
                paused: false,
            };
        app.update();
        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
@@ -1559,6 +1563,7 @@ mod tests {
                replay: dummy_replay(),
                cursor: 0,
                secs_to_next: 0.0,
                paused: false,
            };
        app.update();
        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
@@ -936,6 +936,11 @@ pub fn record_replay_on_win(
        if recording.moves.is_empty() {
            continue;
        }
        // Recording freezes on win, so the move that triggered the
        // win condition is the last one in the list. Storing the
        // index explicitly lets the playback UI read the WIN MOVE
        // position directly instead of re-deriving it on every render.
        let win_move_index = recording.moves.len().checked_sub(1);
        let replay = Replay::new(
            game.0.seed,
            game.0.draw_mode.clone(),
@@ -944,7 +949,8 @@ pub fn record_replay_on_win(
            ev.score,
            Utc::now().date_naive(),
            recording.moves.clone(),
-        );
+        )
        .with_win_move_index(win_move_index);
        let Some(p) = path.as_ref().and_then(|r| r.0.as_deref()) else {
            // No persistence path configured (e.g. tests / minimal Linux
            // containers without dirs::data_dir). The in-memory replay
@@ -30,6 +30,7 @@ use crate::events::{
 use crate::font_plugin::FontResource;
 use crate::game_plugin::{GameOverScreen, GameStatePath};
 use crate::progress_plugin::ProgressResource;
 use crate::replay_playback::ReplayPlaybackState;
 use crate::resources::{DragState, GameStateResource};
 use crate::selection_plugin::{SelectionKeySet, SelectionState};
 use crate::settings_plugin::{SettingsChangedEvent, SettingsResource, SettingsStoragePath};
@@ -154,6 +155,7 @@ fn toggle_pause(
    mut drag: Option<ResMut<DragState>>,
    mut changed: MessageWriter<StateChangedEvent>,
    selection: Option<Res<SelectionState>>,
    replay_state: Option<Res<ReplayPlaybackState>>,
 ) {
    let PauseModalQueries {
        pause_screens: screens,
@@ -184,6 +186,15 @@ fn toggle_pause(
    if !other_modal_scrims.is_empty() {
        return;
    }
    // If a replay is currently playing, let `replay_overlay::handle_stop_keyboard`
    // own the Esc press — that handler stops the replay. Without this guard a
    // single Esc both stops the replay AND opens the pause modal on top of the
    // (now empty) board, leaving the player on a screen they didn't ask for.
    // The HUD-button path is gated too; clicking Pause while watching a replay
    // is almost always an accident.
    if replay_state.is_some_and(|s| s.is_playing()) {
        return;
    }
    // If a card is currently selected, let SelectionPlugin handle this Escape
    // (it will clear the selection). Pause must not also open in the same frame.
    if selection.is_some_and(|s| s.selected_pile.is_some()) {
@@ -42,7 +42,7 @@
 use bevy::prelude::*;
 use solitaire_data::{Replay, ReplayMove};
-use crate::events::{DrawRequestEvent, MoveRequestEvent, StateChangedEvent};
+use crate::events::{DrawRequestEvent, MoveRequestEvent, StateChangedEvent, UndoRequestEvent};
 use crate::game_plugin::{GameMutation, RecordingReplay};
 use crate::resources::GameStateResource;
 use crate::settings_plugin::SettingsResource;
@@ -119,6 +119,15 @@ pub enum ReplayPlaybackState {
        cursor: usize,
        /// Seconds remaining until the next move is dispatched.
        secs_to_next: f32,
        /// `true` while playback is paused — `tick_replay_playback`
        /// skips the `secs_to_next` decrement entirely while this is
        /// set, so the cursor and the timer freeze together. The
        /// overlay stays mounted (`is_playing()` still returns
        /// `true`) so the player can see the paused state and the
        /// Resume / Step controls. Stepping while paused fires the
        /// next move directly via [`step_replay_playback`] and
        /// leaves the paused flag untouched.
        paused: bool,
    },
    /// The replay finished playing back. The overlay swaps the banner
    /// label to "Replay complete" until [`auto_clear_completed_replay`]
@@ -194,6 +203,7 @@ pub fn start_replay_playback(
        replay,
        cursor: 0,
        secs_to_next: REPLAY_MOVE_INTERVAL_SECS,
        paused: false,
    };
 }
@@ -219,6 +229,107 @@ pub fn stop_replay_playback(
    **state = ReplayPlaybackState::Inactive;
 }
 /// Toggle the `paused` flag on the active playback. No-op when not
 /// `Playing` (i.e. `Inactive` or `Completed`) — pause has no meaning
 /// in those states. Returns the new paused value, or `None` if the
 /// state wasn't `Playing`.
 pub fn toggle_pause_replay_playback(state: &mut ResMut<ReplayPlaybackState>) -> Option<bool> {
    if let ReplayPlaybackState::Playing { paused, .. } = state.as_mut() {
        *paused = !*paused;
        Some(*paused)
    } else {
        None
    }
 }
 /// Advance playback by exactly one move. Only meaningful while paused
 /// — when called on an unpaused playback it would race the
 /// `tick_replay_playback` loop. Returns `true` when a move was fired,
 /// `false` when no-op (state isn't `Playing { paused: true }` or the
 /// cursor is already at the end of the move list).
 ///
 /// Stepping the last move transitions the state to `Completed` on
 /// the next `tick_replay_playback` frame — same end-of-list path the
 /// normal advance loop takes.
 pub fn step_replay_playback(
    state: &mut ResMut<ReplayPlaybackState>,
    moves_writer: &mut MessageWriter<MoveRequestEvent>,
    draws_writer: &mut MessageWriter<DrawRequestEvent>,
 ) -> bool {
    let ReplayPlaybackState::Playing {
        replay,
        cursor,
        paused: true,
        ..
    } = state.as_mut()
    else {
        return false;
    };
    if *cursor >= replay.moves.len() {
        return false;
    }
    match &replay.moves[*cursor] {
        ReplayMove::Move { from, to, count } => {
            moves_writer.write(MoveRequestEvent {
                from: from.clone(),
                to: to.clone(),
                count: *count,
            });
        }
        ReplayMove::StockClick => {
            draws_writer.write(DrawRequestEvent);
        }
    }
    *cursor += 1;
    true
 }
 /// Steps the replay **backwards** by exactly one move while paused.
 ///
 /// Strategy: the live game's undo system is the source of truth for
 /// reversing moves. Every move the replay forward-stepped (via
 /// [`step_replay_playback`] or the auto-advance loop in
 /// [`tick_replay_playback`]) was dispatched as a canonical
 /// [`MoveRequestEvent`] / [`DrawRequestEvent`], which the game
 /// applied and pushed onto its undo stack. So a backwards step here
 /// is simply: decrement the cursor (so the about-to-apply move
 /// re-points at the one we're rewinding past) and fire an
 /// [`UndoRequestEvent`] so the game reverses its most-recent move
 /// next frame.
 ///
 /// Hard-gated to the paused state via destructure pattern —
 /// matches the existing [`step_replay_playback`] gate so the
 /// player can only scrub one direction at a time and the tick
 /// loop never races a manual rewind.
 ///
 /// Returns `false` and is a no-op in three cases:
 /// - State isn't `Playing` (no replay attached).
 /// - State is `Playing` but not paused (the tick loop owns the cursor).
 /// - Cursor is already at 0 (nothing to rewind past).
 ///
 /// Returns `true` on a successful step; the actual game-state
 /// reversal happens next frame when `handle_undo` reads the
 /// `UndoRequestEvent`.
 pub fn step_backwards_replay_playback(
    state: &mut ResMut<ReplayPlaybackState>,
    undo_writer: &mut MessageWriter<UndoRequestEvent>,
 ) -> bool {
    let ReplayPlaybackState::Playing {
        cursor,
        paused: true,
        ..
    } = state.as_mut()
    else {
        return false;
    };
    if *cursor == 0 {
        return false;
    }
    *cursor -= 1;
    undo_writer.write(UndoRequestEvent);
    true
 }
 /// Tick system. Runs every frame; only does work when
 /// [`ReplayPlaybackState::is_playing`].
 ///
@@ -249,28 +360,36 @@ fn tick_replay_playback(
        replay,
        cursor,
        secs_to_next,
        paused,
    } = state.as_mut()
    {
-        *secs_to_next -= dt;
+        // While paused, the cursor and the timer freeze together —
-        while *secs_to_next <= 0.0 && *cursor < replay.moves.len() {
+        // skip the decrement entirely so resuming starts the next
-            match &replay.moves[*cursor] {
+        // move from a full `secs_to_next` window. Stepping (handled
-                ReplayMove::Move { from, to, count } => {
+        // separately) fires moves directly without touching this
-                    moves_writer.write(MoveRequestEvent {
+        // path.
-                        from: from.clone(),
+        if !*paused {
-                        to: to.clone(),
+            *secs_to_next -= dt;
-                        count: *count,
+            while *secs_to_next <= 0.0 && *cursor < replay.moves.len() {
-                    });
+                match &replay.moves[*cursor] {
-                }
+                    ReplayMove::Move { from, to, count } => {
-                ReplayMove::StockClick => {
+                        moves_writer.write(MoveRequestEvent {
-                    draws_writer.write(DrawRequestEvent);
+                            from: from.clone(),
                            to: to.clone(),
                            count: *count,
                        });
                    }
                    ReplayMove::StockClick => {
                        draws_writer.write(DrawRequestEvent);
                    }
                }
                *cursor += 1;
                *secs_to_next += interval;
            }
            *cursor += 1;
            *secs_to_next += interval;
        }
-        if *cursor >= replay.moves.len() {
+            if *cursor >= replay.moves.len() {
-            transition_to_completed = true;
+                transition_to_completed = true;
            }
        }
    }
@@ -34,7 +34,8 @@ use crate::ui_modal::{
 };
 use crate::ui_tooltip::Tooltip;
 use crate::ui_theme::{
-    BG_BASE, BG_ELEVATED, BG_ELEVATED_HI, BORDER_SUBTLE, BORDER_SUBTLE_HC, HighContrastBorder,
+    BG_BASE, BG_ELEVATED, BG_ELEVATED_HI, BORDER_SUBTLE, BORDER_SUBTLE_HC, HighContrastBackground,
    HighContrastBorder,
    RADIUS_SM, SPACE_2, STATE_SUCCESS, TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY, TYPE_BODY_LG,
    TYPE_CAPTION, VAL_SPACE_2, VAL_SPACE_3, Z_MODAL_PANEL,
 };
@@ -365,6 +366,7 @@ impl Plugin for SettingsPlugin {
                    update_color_blind_text,
                    update_high_contrast_text,
                    update_high_contrast_borders,
                    update_high_contrast_backgrounds,
                    update_reduce_motion_text,
                    update_tooltip_delay_text,
                    update_time_bonus_multiplier_text,
@@ -674,6 +676,41 @@ fn update_high_contrast_borders(
    }
 }
 /// Repaints `BackgroundColor` on every entity tagged with
 /// [`HighContrastBackground`] based on `Settings::high_contrast_mode`.
 /// Off → the marker's `default_color`; on → `BORDER_SUBTLE_HC`
 /// (`#a0a0a0`). Compares against the current background and only
 /// mutates when different so Bevy's change-detection doesn't trigger
 /// repaints every frame.
 ///
 /// Parallel to [`update_high_contrast_borders`]. Same on/off rule,
 /// same change-suppression idiom, different colour channel —
 /// `BackgroundColor` for tick marks, decorative strips, fine
 /// separators that paint their shape directly rather than via a
 /// `BorderColor` on a wider Node.
 ///
 /// Tagged sites in v0.21.x: the replay overlay's 1 px scrub track
 /// + 5 quarter-mark notch ticks (`replay_overlay::spawn_overlay`).
 ///
 /// More sites can be tagged in follow-ups by adding
 /// `HighContrastBackground::with_default(...)` to their spawn tuple.
 pub(crate) fn update_high_contrast_backgrounds(
    settings: Res<SettingsResource>,
    mut backgrounds: Query<(&HighContrastBackground, &mut BackgroundColor)>,
 ) {
    let high_contrast = settings.0.high_contrast_mode;
    for (marker, mut bg) in backgrounds.iter_mut() {
        let target = if high_contrast {
            BORDER_SUBTLE_HC
        } else {
            marker.default_color
        };
        if bg.0 != target {
            *bg = BackgroundColor(target);
        }
    }
 }
 fn update_reduce_motion_text(
    settings: Res<SettingsResource>,
    mut text_nodes: Query<&mut Text, With<ReduceMotionText>>,
@@ -252,6 +252,35 @@ impl HighContrastBorder {
    }
 }
 /// Marker for entities whose [`BackgroundColor`] should swap to
 /// [`BORDER_SUBTLE_HC`] when `Settings::high_contrast_mode` is on.
 /// Parallel to [`HighContrastBorder`] but for sites that paint their
 /// shape via `BackgroundColor` rather than `BorderColor` —
 /// `bevy::ui` 1 px decorative strips, tick marks, fine separators
 /// often render as tiny full-bleed `Node`s, not as borders, so the
 /// border-marker pattern doesn't apply.
 ///
 /// `default_color` records the off-state colour the entity was
 /// spawned with so the system can revert when HC is toggled back
 /// off. The accompanying paint system is
 /// [`update_high_contrast_backgrounds`](crate::settings_plugin::update_high_contrast_backgrounds).
 ///
 /// [`BackgroundColor`]: bevy::prelude::BackgroundColor
 #[derive(bevy::prelude::Component, Debug, Clone, Copy)]
 pub struct HighContrastBackground {
    /// Background colour to use when high-contrast mode is *off* —
    /// the site's normal idle / active-state colour.
    pub default_color: bevy::prelude::Color,
 }
 impl HighContrastBackground {
    /// Convenience constructor —
    /// `HighContrastBackground::with_default(BORDER_SUBTLE)`.
    pub const fn with_default(default_color: bevy::prelude::Color) -> Self {
        Self { default_color }
    }
 }
 /// Strong border — hover outline, focused button, active popover.
 /// `outline` from the design system. `#505050`.
 pub const BORDER_STRONG: Color = Color::srgba(0.314, 0.314, 0.314, 1.0);