Merge pull request 'refactor(core): align Spider with upstream card_game idioms' (#162) from refactor/spider-upstream-idioms into master

Phase G of docs/ui-redesign-2026-07.md. The win modal now leads with
actions and reads the stats recap quietly below them:

- Play Again: primary, full-row, Enter accelerator unchanged; still
  fires NewGameRequestEvent::default() (same mode; deal options from
  Settings) so the rematch is one tap.
- Watch Replay / Share Replay: secondary pair reusing the global
  stats_plugin markers (WatchReplayButton / CopyShareLinkButton), so
  both act on the just-won replay — SelectedReplayIndex snaps to 0 on
  every win. This also fixes the old win-modal handler picking
  replays.last(), which after the newest-first history refactor was
  the OLDEST replay, not the newest.
- Watch closes the celebration overlay (new close_overlay_on_watch_-
  replay system); Share keeps it open and relies on the existing
  copy-feedback toasts.
- Stats recap (score breakdown reveal, time, XP, achievements) moves
  below the actions; the Time line drops from headline/primary to
  body/secondary styling.

Tests: 4 new (action presence, Play Again close+request, Watch closes,
Share keeps open) on a manual-clock fixture that steps the 0.5 s
celebration delay deterministically. Workspace suite green, workspace
clippy -D warnings clean, fmt applied.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

.gitea/workflows/test.yml

@@ -29,14 +29,21 @@ on:
 
 jobs:
   test:
-    runs-on: ubuntu-latest
+    runs-on: rust-host
 
     # Full debuginfo made the solitaire_engine test-binary link peak past the
     # runner's memory — ld was OOM-killed (signal 9) on runs 447 and 486.
     # line-tables-only keeps file:line in panic backtraces while cutting the
     # link's memory footprint enough to fit the runner.
+    #
+    # CARGO_BUILD_JOBS=2: with one job per core, cargo links several large
+    # test binaries concurrently; as the workspace grew (runs 514/516/519)
+    # two+ simultaneous ld processes OOM-killed the runner again even at
+    # line-tables-only. Two jobs keeps at most two links in flight — the
+    # compile-throughput cost is small next to the cache-warm build.
     env:
       CARGO_PROFILE_DEV_DEBUG: line-tables-only
+      CARGO_BUILD_JOBS: '2'
 
     steps:
       - name: Checkout

Cargo.lock

@@ -7331,6 +7331,7 @@ dependencies = [
  "card_game",
  "klondike",
  "proptest",
+ "rand 0.10.1",
  "serde",
  "thiserror 2.0.18",
 ]

build_wasm.sh

@@ -77,7 +77,7 @@ wasm-bindgen \
     --out-name canvas \
     --target web \
     --no-typescript \
-    "$REPO_ROOT/target/wasm32-unknown-unknown/wasm-release/solitaire_web.wasm"
+    "${CARGO_TARGET_DIR:-$REPO_ROOT/target}/wasm32-unknown-unknown/wasm-release/solitaire_web.wasm"
 
 # Optional size optimisation — Bevy bundles are large (~5-15 MB uncompressed).
 # wasm-opt passes are skipped silently when the tool is not installed.

docs/ui-redesign-2026-07.md

@@ -0,0 +1,204 @@
+# Menu UX Redesign — July 2026
+
+Status: PLANNING. Visual identity (Terminal / base16-eighties) is settled and
+out of scope — this is about **structure and interaction**, not colors or type.
+
+## Diagnosis (from code survey, 2026-07-07)
+
+| Surface | Today | Pain |
+| --- | --- | --- |
+| Settings | One scrolling modal, 5 section labels, ~37 control rows, single Done | Scroll-hunting for any toggle; endless on the folded (cover) screen; every new feature (theme store, import) stretches it further |
+| Home | Modal launcher: stats strip, draw-mode row, difficulty rows, 6 equal mode cards, Cancel | No "Continue" primacy; deal options (draw/difficulty/winnable) crowd the mode choice; six cards weighted identically though Classic dominates play |
+| HUD menu | Popover with 7 destinations (Help, Modes, Stats, Achievements, Profile, Settings, Leaderboard) | "Modes" duplicates Home's job; flat list, no grouping; each item opens another modal — modal-on-modal navigation |
+| Global | Everything is a modal over the felt | No hierarchy; near-square unfolded Fold renders one narrow wasted column |
+
+## Phase A — Settings tabs (highest pain, lowest risk)
+
+- Replace the single scroll with **tabs**: `Audio · Gameplay · Appearance ·
+  Accessibility · Account`.
+  - *Appearance* = today's Cosmetic (card back, background, card theme,
+    theme store, import).
+  - *Accessibility* = extracted from Gameplay/Cosmetic: color-blind,
+    high-contrast, reduce-motion, touch input mode, tooltip delay.
+  - *Account* = Sync + Privacy merged.
+- Narrow screens: tab chips in a row under the header. Wide (aspect > ~1.2 —
+  unfolded Fold, desktop): left rail, rows in two columns.
+- Only the active tab's rows are spawned → each tab is ≤ 8 rows and fits the
+  cover screen without scrolling.
+- **Implementation constraint:** pure `ui.rs` re-layout + one `SettingsTab`
+  resource. The `SettingsButton` enum, input handlers, and persistence are
+  untouched, so the 25 settings tests and the ambiguity gate stay green.
+
+## Phase B — Home becomes a real home
+
+- **Hierarchy, top to bottom:**
+  1. `Continue` card (only when a game is in progress) — mode, elapsed, score.
+  2. Hero `New Game` — one tap, reuses last mode + deal options.
+  3. Compact 2×3 mode grid (Classic, Daily, Zen, Challenge, Time Attack,
+     Seed) — smaller cards, glyph + name + one-line description on wide only.
+  4. Stats strip moves to the bottom (or right pane when unfolded).
+- **Deal options** (draw 1/3, difficulty, winnable-only) move off the top
+  level into a disclosure on the Classic card / New Game hero — they are
+  Classic-mode concerns, not global ones.
+- Cancel becomes `Back to table` and only renders when a game exists.
+- Unfolded Fold / desktop: two panes — modes left, Continue + stats +
+  daily/weekly right.
+
+## Phase C — HUD menu consolidation
+
+- Drop `Modes` from the popover (Home owns mode selection; HUD's New-Game
+  path opens Home).
+- Group the remaining six: **Play** (Home) · **You** (Profile, Stats,
+  Achievements) · **Community** (Leaderboard) · **System** (Settings, Help) —
+  section dividers in the existing popover, not a new widget.
+- Dismissal audit: Esc / scrim-tap / Done must behave identically on every
+  modal (most already do via `ScrimDismissible`; sweep the stragglers).
+
+## Phase D — Validation gates
+
+- Optional Stitch mockups (Terminal design-system asset
+  `assets/0f1652274fea460585d0b331a9ddbb06`, project 593811793268308763) for
+  Home + Settings before implementing Phase B. Phase A is safe to build
+  straight in-engine.
+- Per-phase gates: full test suite, clippy `-D warnings`, ambiguity gate at 0,
+  Android checklist (§15.3), on-device pass on the Fold 7 in BOTH postures.
+
+## Sequencing & risk
+
+| Phase | Size | Risk | Depends on |
+| --- | --- | --- | --- |
+| A — Settings tabs | ~1 session | Low (layout-only) | — |
+| B — Home hierarchy | 1–2 sessions | Medium (touches launch flow) | D mockups if wanted |
+| C — Menu grouping | small | Low | B (Modes removal) |
+
+## Phase E — "You" hub (reuses the Phase A tab component)
+
+Profile, Stats, Achievements, and the replay browser are four separate
+modals today, reached through the HUD popover one at a time. Fold them
+into ONE tabbed hub — `Profile · Stats · Achievements · Replays` — using
+the same tab widget Phase A builds for Settings. Cuts the HUD popover to
+four destinations and makes the tab component pay for itself twice.
+Existing per-screen systems keep their markers/handlers; only the outer
+shell changes (same trick as Phase A).
+
+## Phase F — Mobile ergonomics (Fold-first)
+
+- **Bottom action bar** on touch: Undo, Hint, Draw within thumb reach at
+  the bottom safe-area edge (via the existing `SafeAreaAnchoredBottom`),
+  score-only band stays on top. Desktop keeps the current top band.
+  Biggest one-handed-play win available; folded posture is tall and
+  top-heavy today.
+- **Hold-to-repeat Undo** — press-and-hold steps back repeatedly
+  (respecting the existing undo scoring penalty), instead of tap-tap-tap.
+- Both are additive; game stays fully playable with the top band alone
+  (UI-first rule §3.3 satisfied).
+
+## Phase G — Post-win flow
+
+Win summary today is a stats dump with a close. Give it an action
+hierarchy: **Play again** (same mode/options, primary) · **Share replay**
+(the upload already returns a share URL; surface it here with copy
+feedback) · **Watch replay** · quiet stats below. Rematch loop drops from
+4 taps to 1.
+
+## Phase H — Feedback polish (small, bundling candidates)
+
+- Unify queued vs. immediate toast styling (two subtly different styles
+  exist today) and anchor both to one position; consider a 5-item toast
+  history on the stats screen.
+- Theme-store modal: render the preview PNGs the server already serves
+  (v1 is text-only rows).
+- Hint: optional ghost-motion preview of the suggested move instead of a
+  static highlight (auto-disabled under reduce-motion).
+
+## Phase I — Onboarding & discoverability
+
+The first-run onboarding exists, but everything learned after it is
+invisible: the radial menu (long-press/right-click), hint cycling,
+tap-to-toggle HUD chrome, hotkeys. Add **contextual one-time tips** —
+fired by the situation, not a tour (first stall → hint tip; first
+long-press-able stack → radial tip; each shows once, stored in
+Settings like `shown_achievement_onboarding` already is). Plus a
+one-shot **"What's new"** card on first launch after a version bump —
+ObtainX updates are silent today, so shipped features go unnoticed
+(nobody will find the theme store on their own).
+
+## Phase J — Keyboard & focus completeness (desktop + web)
+
+`ui_focus` already gives deterministic Esc order and tab-walk
+(`FocusRow`/`Focusable`), and `KeyboardDragState` exists — but full
+keyboard-only play has never been audited end to end. Deliverables: every
+modal reachable/dismissable without a mouse, a visible focus ring styled
+to the Terminal system (current focus state is subtle), and a hotkey
+cheat-sheet overlay (hold `?`) generated from the actual bindings instead
+of the static Help text. Web build (Rhys) benefits most.
+
+## Phase K — UI scale & touch-target accessibility
+
+All type sizes flow through `TYPE_*` tokens and layout through
+`compute_layout` — which makes a **UI scale setting** (90/100/115/130 %)
+cheap to wire and genuinely useful on the Fold's dense cover screen.
+Pair with: respect Android system font scale on first run (seed the
+setting from it), and a one-time audit that every interactive element
+meets the 44 px logical minimum in BOTH Fold postures (the pill buttons
+and picker swatches are the suspects). Lands in the Accessibility tab
+that Phase A creates.
+
+## Phase L — Empty & loading states, standardized
+
+Async/empty surfaces each improvise today: leaderboard with no entries,
+stats with no games, replay browser with no replays, theme store
+loading/error (just added), sync status text. Define ONE pattern —
+glyph + one-line explanation + a single next-step action — as a
+`spawn_empty_state` helper in `ui_modal`, and sweep all five surfaces
+onto it. Small, mechanical, big perceived-quality win.
+
+## Phase M — Sync transparency & data stewardship
+
+The sync layer returns `ConflictReport`s ("data is never silently
+discarded") — but no UI ever shows them; players can't tell what a merge
+did. Add: a post-sync summary line ("merged, 2 conflicts kept newer
+values" → tap for detail in the Account tab), a visible last-synced
+timestamp (exists as `SyncStatus::LastSynced`, barely surfaced), and
+local **data export/import** (zip of the JSON saves) for device
+migrations without a server. Closes the trust loop the server work
+opened.
+
+## Roadmap tie-ins (already in flight elsewhere)
+
+- **Spider mode** (feat/spider-core, PR #157): Home's mode grid gains a
+  7th card once engine work lands — the 2×3 grid in Phase B should be
+  designed as N-card flow from day one. Spider UI also needs positional
+  card→entity keys (documented in spider.rs module docs).
+- **Show solution** (feat/solution-line, in flight): lands in the pause
+  menu; Phase C's grouping should leave room for it under a "Game"
+  cluster if the pause menu grows.
+
+## Sequencing (updated)
+
+| Phase | Size | Risk | Depends on |
+| --- | --- | --- | --- |
+| A — Settings tabs | ~1 session | Low | — (DECIDED: tabs) |
+| E — "You" hub | ~1 session | Low | A's tab component |
+| C — Menu grouping | small | Low | E (popover shrinks) |
+| B — Home hierarchy | 1–2 sessions | Medium | D mockups if wanted |
+| F — Bottom action bar | ~1 session | Medium (input paths) | — |
+| G — Post-win flow | small | Low | — |
+| H — Feedback polish | small each | Low | — |
+| I — Onboarding & discoverability | ~1 session | Low | ships best after B/F land |
+| J — Keyboard & focus completeness | ~1 session | Low | A/E (fewer modals to audit) |
+| K — UI scale & touch targets | ~1 session | Medium (layout-wide) | A (Accessibility tab) |
+| L — Empty-state standardization | small | Low | — |
+| M — Sync transparency & export | ~1 session | Low–Medium | A (Account tab) |
+
+Suggested order: **A → E → C** (one arc: the tab component and the menu
+slimming), then **B**, then **F/G/H** as independent follow-ups.
+
+## Open decisions
+
+1. ~~Settings: tabs vs. sub-pages~~ — **DECIDED 2026-07-07: tabs.**
+2. Deal options: disclosure on Classic card (proposed) vs. keep global row?
+3. Time Attack + Seed: top-level cards (proposed, grid stays symmetric) vs.
+   tucked under a "More" card?
+4. Stitch mockups for Phase B, or iterate directly in-engine?
+5. Phase F bottom bar: touch-only (proposed) or also desktop?

solitaire_core/Cargo.toml

@@ -16,6 +16,11 @@ serde     = { workspace = true }
 thiserror = { workspace = true }
 klondike  = { workspace = true }
 card_game = { workspace = true }
+# Deliberately NOT the workspace rand (0.9): this pins the exact dep the
+# upstream `klondike` crate uses, so `SeedableRng`/`SliceRandom` resolve
+# against the same crate version as `klondike::Rng` and Spider deals go
+# through the identical shuffle stack as Klondike deals.
+rand      = { version = "0.10.1", default-features = false, features = ["std_rng"] }
 
 [lints]
 workspace = true

solitaire_core/src/lib.rs

@@ -3,6 +3,7 @@ pub mod error;
 pub mod game_state;
 pub mod klondike_adapter;
 pub mod scoring;
+pub mod spider;
 
 // Re-export the upstream types that cross the solitaire_core API boundary so
 // downstream crates (engine, wasm) can import from one place without a direct
@@ -21,6 +22,13 @@ pub use klondike::{
 // former `solitaire_data::solver` wrapper module.
 pub use game_state::{DEFAULT_SOLVE_MOVES_BUDGET, DEFAULT_SOLVE_STATES_BUDGET, SolveOutcome};
 
+// Spider rules (second `card_game::Game` implementation; engine UI is a
+// later phase — nothing outside solitaire_core consumes these yet).
+pub use spider::{
+    RunLength, Spider, SpiderConfig, SpiderGameState, SpiderInstruction, SpiderIter, SpiderMove,
+    SpiderScoring, SpiderStats, SpiderSuits, SpiderTableau,
+};
+
 /// All four foundation slots, in slot order.
 ///
 /// Canonical iteration source for `Foundation` — upstream `klondike` has no

solitaire_engine/src/achievement_plugin.rs

@@ -30,13 +30,9 @@ use crate::replay_playback::ReplayPlaybackState;
 use crate::resources::GameStateResource;
 use crate::settings_plugin::{SettingsResource, SettingsStoragePath};
 use crate::stats_plugin::{StatsResource, StatsUpdate};
-use crate::ui_modal::{
-    ButtonVariant, ModalScrim, ScrimDismissible, spawn_modal, spawn_modal_actions,
-    spawn_modal_button, spawn_modal_header,
-};
 use crate::ui_theme::{
     ACCENT_PRIMARY, BORDER_SUBTLE, STATE_SUCCESS, TEXT_DISABLED, TEXT_PRIMARY, TEXT_SECONDARY,
-    TYPE_BODY, TYPE_BODY_LG, TYPE_CAPTION, VAL_SPACE_1, Z_MODAL_PANEL,
+    TYPE_BODY, TYPE_BODY_LG, TYPE_CAPTION, VAL_SPACE_1,
 };
 use crate::ui_tooltip::Tooltip;
 
@@ -137,8 +133,8 @@ impl Plugin for AchievementPlugin {
                     .after(GameMutation)
                     .after(StatsUpdate),
             )
-            .add_systems(Update, toggle_achievements_screen)
-            .add_systems(Update, handle_achievements_close_button)
+            // Open/close/tab handling moved to `you_hub_plugin`
+            // (Phase E) — this plugin now owns body content + scroll.
             .add_systems(Update, scroll_achievements_panel)
             .add_systems(
                 Update,
@@ -385,47 +381,6 @@ pub fn display_name_for(id: &str) -> String {
     achievement_by_id(id).map_or_else(|| id.to_string(), |d| d.name.to_string())
 }
 
-/// Marker on the "Done" button inside the Achievements modal.
-#[derive(Component, Debug)]
-pub struct AchievementsCloseButton;
-
-/// Toggle the achievements overlay — `A` keyboard accelerator or
-/// `ToggleAchievementsRequestEvent` from the HUD Menu popover.
-fn toggle_achievements_screen(
-    mut commands: Commands,
-    keys: Res<ButtonInput<KeyCode>>,
-    mut requests: MessageReader<ToggleAchievementsRequestEvent>,
-    achievements: Res<AchievementsResource>,
-    font_res: Option<Res<FontResource>>,
-    screens: Query<Entity, With<AchievementsScreen>>,
-    other_modal_scrims: Query<(), (With<ModalScrim>, Without<AchievementsScreen>)>,
-) {
-    let button_clicked = requests.read().count() > 0;
-    if !keys.just_pressed(KeyCode::KeyA) && !button_clicked {
-        return;
-    }
-    if let Ok(entity) = screens.single() {
-        commands.entity(entity).despawn();
-    } else if other_modal_scrims.is_empty() {
-        spawn_achievements_screen(&mut commands, &achievements.0, font_res.as_deref());
-    }
-}
-
-/// Click handler for the modal's "Done" button — despawns the overlay
-/// the same way the `A` accelerator does.
-fn handle_achievements_close_button(
-    mut commands: Commands,
-    close_buttons: Query<&Interaction, (With<AchievementsCloseButton>, Changed<Interaction>)>,
-    screens: Query<Entity, With<AchievementsScreen>>,
-) {
-    if !close_buttons.iter().any(|i| *i == Interaction::Pressed) {
-        return;
-    }
-    for entity in &screens {
-        commands.entity(entity).despawn();
-    }
-}
-
 /// Routes mouse-wheel events into the Achievements modal's scrollable body
 /// while the panel is open.
 ///
@@ -458,14 +413,18 @@ fn scroll_achievements_panel(
     }
 }
 
-fn spawn_achievements_screen(
-    commands: &mut Commands,
+/// Builds the Achievements tab body inside the You hub's card. The
+/// unlock-count line that used to live in the standalone modal's
+/// header renders as the first body line instead (the hub owns the
+/// header). All markers (`AchievementRow`, `AchievementsScrollable`)
+/// are unchanged.
+pub(crate) fn spawn_achievements_body(
+    card: &mut ChildSpawnerCommands,
     records: &[AchievementRecord],
     font_res: Option<&FontResource>,
 ) {
     let unlocked: Vec<_> = records.iter().filter(|r| r.unlocked).collect();
     let total = ALL_ACHIEVEMENTS.len();
-    let header = format!("Achievements  ({}/{})", unlocked.len(), total);
 
     let font_handle = font_res.map(|f| f.0.clone()).unwrap_or_default();
     let font_name = TextFont {
@@ -486,8 +445,13 @@ fn spawn_achievements_screen(
 
     let any_unlocked = records.iter().any(|r| r.unlocked);
 
-    let scrim = spawn_modal(commands, AchievementsScreen, Z_MODAL_PANEL, |card| {
-        spawn_modal_header(card, header, font_res);
+    {
+        // Unlock progress — formerly the standalone modal's header.
+        card.spawn((
+            Text::new(format!("Unlocked {} / {}", unlocked.len(), total)),
+            font_name.clone(),
+            TextColor(TEXT_SECONDARY),
+        ));
 
         // First-time hint — shown until the player has unlocked anything.
         // The list itself describes individual rewards, but a top-level
@@ -594,21 +558,7 @@ fn spawn_achievements_screen(
                 ));
             }
         });
-
-        spawn_modal_actions(card, |actions| {
-            spawn_modal_button(
-                actions,
-                AchievementsCloseButton,
-                "Done",
-                Some("A"),
-                ButtonVariant::Primary,
-                font_res,
-            );
-        });
-    });
-    // Achievements is a read-only list — clicking the scrim outside
-    // the card dismisses alongside the existing A / Done paths.
-    commands.entity(scrim).insert(ScrimDismissible);
+    }
 }
 
 fn format_reward(reward: Reward) -> String {
@@ -668,7 +618,8 @@ mod tests {
             .add_plugins(TablePlugin)
             .add_plugins(StatsPlugin::headless())
             .add_plugins(crate::progress_plugin::ProgressPlugin::headless())
-            .add_plugins(AchievementPlugin::headless());
+            .add_plugins(AchievementPlugin::headless())
+            .add_plugins(crate::you_hub_plugin::YouHubPlugin);
         // StatsPlugin's UI toggle system reads ButtonInput<KeyCode>; under
         // MinimalPlugins it isn't auto-registered.
         app.init_resource::<ButtonInput<KeyCode>>();

solitaire_engine/src/core_game_plugin.rs

@@ -111,6 +111,7 @@ impl Plugin for CoreGamePlugin {
             .add_plugins(HelpPlugin)
             .add_plugins(HomePlugin::default())
             .add_plugins(ProfilePlugin)
+            .add_plugins(crate::you_hub_plugin::YouHubPlugin)
             .add_plugins(PausePlugin)
             .add_plugins(SettingsPlugin::default())
             .add_plugins(OnboardingPlugin)

solitaire_engine/src/events.rs

@@ -243,6 +243,11 @@ pub struct ToggleSettingsRequestEvent;
 #[derive(Message, Debug, Clone, Copy, Default)]
 pub struct ToggleLeaderboardRequestEvent;
 
+/// Request to toggle the Home mode launcher. Fired by the HUD
+/// Menu-popover "Home" row alongside the existing `M` accelerator.
+#[derive(Message, Debug, Clone, Copy, Default)]
+pub struct ToggleHomeRequestEvent;
+
 /// Fired by `SyncPlugin` after a pull task resolves and the merged result has
 /// been persisted to disk. `Ok(SyncResponse)` carries the merged payload plus
 /// any `ConflictReport`s the merge produced. `Err(String)` carries a

solitaire_engine/src/help_plugin.rs

@@ -86,13 +86,18 @@ fn toggle_help_screen(
 }
 
 /// Click handler for the modal's "Done" button. F1 toggles the overlay
-/// the same way; this just exposes the close action to mouse / touch.
+/// the same way; Esc closes too, so dismissal matches every other
+/// modal (Phase C dismissal audit). Nothing ever stacks above Help,
+/// so Esc needs no topmost gate.
 fn handle_help_close_button(
     mut commands: Commands,
+    keys: Res<ButtonInput<KeyCode>>,
     close_buttons: Query<&Interaction, (With<HelpCloseButton>, Changed<Interaction>)>,
     screens: Query<Entity, With<HelpScreen>>,
 ) {
-    if !close_buttons.iter().any(|i| *i == Interaction::Pressed) {
+    let clicked = close_buttons.iter().any(|i| *i == Interaction::Pressed);
+    let esc = keys.just_pressed(KeyCode::Escape) && !screens.is_empty();
+    if !clicked && !esc {
         return;
     }
     for entity in &screens {
@@ -583,4 +588,33 @@ mod tests {
             0
         );
     }
+
+    /// Esc must dismiss the Help modal like Done and F1 do (Phase C
+    /// dismissal audit).
+    #[test]
+    fn escape_closes_help_screen() {
+        let mut app = headless_app();
+        app.world_mut()
+            .resource_mut::<ButtonInput<KeyCode>>()
+            .press(KeyCode::F1);
+        app.update();
+
+        {
+            let mut input = app.world_mut().resource_mut::<ButtonInput<KeyCode>>();
+            input.release(KeyCode::F1);
+            input.clear();
+            input.press(KeyCode::Escape);
+        }
+        app.update();
+        app.update();
+
+        assert_eq!(
+            app.world_mut()
+                .query::<&HelpScreen>()
+                .iter(app.world())
+                .count(),
+            0,
+            "Esc must close the Help modal"
+        );
+    }
 }

solitaire_engine/src/home_plugin.rs

@@ -24,7 +24,8 @@ use crate::daily_challenge_plugin::DailyChallengeResource;
 use crate::events::{
     InfoToastEvent, NewGameRequestEvent, StartChallengeRequestEvent,
     StartDailyChallengeRequestEvent, StartDifficultyRequestEvent, StartPlayBySeedRequestEvent,
-    StartTimeAttackRequestEvent, StartZenRequestEvent, ToggleProfileRequestEvent,
+    StartTimeAttackRequestEvent, StartZenRequestEvent, ToggleHomeRequestEvent,
+    ToggleProfileRequestEvent,
 };
 use crate::font_plugin::FontResource;
 use crate::progress_plugin::ProgressResource;
@@ -264,6 +265,7 @@ impl Plugin for HomePlugin {
             .add_message::<StartPlayBySeedRequestEvent>()
             .add_message::<StartDifficultyRequestEvent>()
             .add_message::<InfoToastEvent>()
+            .add_message::<ToggleHomeRequestEvent>()
             .add_message::<ToggleProfileRequestEvent>()
             .add_message::<SettingsChangedEvent>()
             // Defensively register MouseWheel so `scroll_home_panel`
@@ -371,6 +373,7 @@ fn spawn_home_on_launch(
 fn toggle_home_screen(
     mut commands: Commands,
     keys: Res<ButtonInput<KeyCode>>,
+    mut requests: MessageReader<ToggleHomeRequestEvent>,
     progress: Option<Res<ProgressResource>>,
     stats: Option<Res<StatsResource>>,
     settings: Option<Res<SettingsResource>>,
@@ -380,7 +383,8 @@ fn toggle_home_screen(
     other_modal_scrims: Query<(), (With<crate::ui_modal::ModalScrim>, Without<HomeScreen>)>,
     diff_expanded: Res<DifficultyExpanded>,
 ) {
-    if !keys.just_pressed(KeyCode::KeyM) {
+    let button_clicked = requests.read().count() > 0;
+    if !keys.just_pressed(KeyCode::KeyM) && !button_clicked {
         return;
     }
     if let Ok(entity) = screens.single() {
@@ -1621,6 +1625,44 @@ mod tests {
         );
     }
 
+    /// The HUD Menu popover's "Home" row fires
+    /// `ToggleHomeRequestEvent`; it must open Home exactly like the
+    /// `M` accelerator (Phase C: the popover's Play section replaces
+    /// the old Modes row).
+    #[test]
+    fn toggle_home_event_opens_home_screen() {
+        let mut app = headless_app();
+        app.world_mut()
+            .resource_mut::<Messages<ToggleHomeRequestEvent>>()
+            .write(ToggleHomeRequestEvent);
+        app.update();
+
+        assert_eq!(
+            app.world_mut()
+                .query::<&HomeScreen>()
+                .iter(app.world())
+                .count(),
+            1,
+            "ToggleHomeRequestEvent must open the Home modal"
+        );
+
+        // A second request toggles it closed, matching the M key.
+        app.world_mut()
+            .resource_mut::<Messages<ToggleHomeRequestEvent>>()
+            .write(ToggleHomeRequestEvent);
+        app.update();
+        app.update();
+
+        assert_eq!(
+            app.world_mut()
+                .query::<&HomeScreen>()
+                .iter(app.world())
+                .count(),
+            0,
+            "second ToggleHomeRequestEvent must close the Home modal"
+        );
+    }
+
     #[test]
     fn pressing_m_twice_closes_home_screen() {
         let mut app = headless_app();

solitaire_engine/src/hud_plugin/interaction.rs

@@ -311,44 +311,65 @@ pub(super) fn spawn_menu_popover(commands: &mut Commands, font_res: Option<&Font
         ..default()
     };
 
-    // Each row carries a tooltip alongside its label so hover reveals
-    // a one-line description of what each overlay shows — mirroring
-    // the tooltips on the action-bar buttons that opened this popover.
-    let rows: [(MenuOption, &'static str, &'static str); 7] = [
+    // One popover row: destination, label, hover tooltip.
+    type MenuRow = (MenuOption, &'static str, &'static str);
+    // Destinations grouped into labelled sections (Phase C of the menu
+    // redesign): Play · You · Community · System. Each row carries a
+    // tooltip alongside its label so hover reveals a one-line
+    // description of what each overlay shows — mirroring the tooltips
+    // on the action-bar buttons that opened this popover. Mode
+    // selection lives on Home now, so there is no Modes row.
+    let sections: [(&'static str, &'static [MenuRow]); 4] = [
         (
-            MenuOption::Help,
-            "Help",
-            "Show controls, rules, and keyboard shortcuts.",
+            "Play",
+            &[(
+                MenuOption::Home,
+                "Home",
+                "Pick a mode, continue, or start a new game.",
+            )],
         ),
         (
-            MenuOption::Modes,
-            "Game Modes",
-            "Switch modes: Classic, Daily, Zen, Challenge, Time Attack.",
+            "You",
+            &[
+                (
+                    MenuOption::Profile,
+                    "Profile",
+                    "Your level, XP progress, and sync status.",
+                ),
+                (
+                    MenuOption::Stats,
+                    "Stats",
+                    "Lifetime totals: wins, streaks, fastest time, best score.",
+                ),
+                (
+                    MenuOption::Achievements,
+                    "Achievements",
+                    "Browse unlocked achievements and the rewards still ahead.",
+                ),
+            ],
         ),
         (
-            MenuOption::Stats,
-            "Stats",
-            "Lifetime totals: wins, streaks, fastest time, best score.",
+            "Community",
+            &[(
+                MenuOption::Leaderboard,
+                "Leaderboard",
+                "Top players from your sync server. Opt in from Profile.",
+            )],
         ),
         (
-            MenuOption::Achievements,
-            "Achievements",
-            "Browse unlocked achievements and the rewards still ahead.",
-        ),
-        (
-            MenuOption::Profile,
-            "Profile",
-            "Your level, XP progress, and sync status.",
-        ),
-        (
-            MenuOption::Settings,
-            "Settings",
-            "Audio, animations, theme, draw mode, and sync.",
-        ),
-        (
-            MenuOption::Leaderboard,
-            "Leaderboard",
-            "Top players from your sync server. Opt in from Profile.",
+            "System",
+            &[
+                (
+                    MenuOption::Settings,
+                    "Settings",
+                    "Audio, animations, theme, draw mode, and sync.",
+                ),
+                (
+                    MenuOption::Help,
+                    "Help",
+                    "Show controls, rules, and keyboard shortcuts.",
+                ),
+            ],
         ),
     ];
 
@@ -373,27 +394,48 @@ pub(super) fn spawn_menu_popover(commands: &mut Commands, font_res: Option<&Font
             ZIndex(Z_HUD_POPOVER),
         ))
         .with_children(|panel| {
-            for (option, label, tooltip) in rows {
+            let section_font = TextFont {
+                font: font_res.map(|f| f.0.clone()).unwrap_or_default(),
+                font_size: TYPE_CAPTION,
+                ..default()
+            };
+            for (section, rows) in sections {
+                // Non-interactive section header — a quiet divider
+                // inside the existing panel, not a new widget.
                 panel
-                    .spawn((
-                        option,
-                        ActionButton,
-                        PopoverRow,
-                        Button,
-                        Tooltip::new(tooltip),
-                        Node {
-                            padding: UiRect::axes(VAL_SPACE_3, Val::Px(6.0)),
-                            justify_content: JustifyContent::FlexStart,
-                            align_items: AlignItems::Center,
-                            min_width: Val::Px(150.0),
-                            border_radius: BorderRadius::all(Val::Px(RADIUS_SM)),
-                            ..default()
-                        },
-                        BackgroundColor(ACTION_BTN_IDLE),
-                    ))
+                    .spawn(Node {
+                        padding: UiRect::axes(VAL_SPACE_3, Val::Px(2.0)),
+                        ..default()
+                    })
                     .with_children(|b| {
-                        b.spawn((Text::new(label), font.clone(), TextColor(TEXT_PRIMARY)));
+                        b.spawn((
+                            Text::new(section),
+                            section_font.clone(),
+                            TextColor(TEXT_SECONDARY),
+                        ));
                     });
+                for &(option, label, tooltip) in rows {
+                    panel
+                        .spawn((
+                            option,
+                            ActionButton,
+                            PopoverRow,
+                            Button,
+                            Tooltip::new(tooltip),
+                            Node {
+                                padding: UiRect::axes(VAL_SPACE_3, Val::Px(6.0)),
+                                justify_content: JustifyContent::FlexStart,
+                                align_items: AlignItems::Center,
+                                min_width: Val::Px(150.0),
+                                border_radius: BorderRadius::all(Val::Px(RADIUS_SM)),
+                                ..default()
+                            },
+                            BackgroundColor(ACTION_BTN_IDLE),
+                        ))
+                        .with_children(|b| {
+                            b.spawn((Text::new(label), font.clone(), TextColor(TEXT_PRIMARY)));
+                        });
+                }
             }
         });
 
@@ -422,31 +464,28 @@ pub(super) fn handle_menu_option_click(
     interaction_query: Query<(&Interaction, &MenuOption), Changed<Interaction>>,
     popovers: Query<Entity, With<MenuPopover>>,
     backdrops: Query<Entity, With<MenuPopoverBackdrop>>,
+    mut home: MessageWriter<ToggleHomeRequestEvent>,
     mut stats: MessageWriter<ToggleStatsRequestEvent>,
     mut achievements: MessageWriter<ToggleAchievementsRequestEvent>,
     mut profile: MessageWriter<ToggleProfileRequestEvent>,
     mut settings: MessageWriter<ToggleSettingsRequestEvent>,
     mut leaderboard: MessageWriter<ToggleLeaderboardRequestEvent>,
     mut help: MessageWriter<HelpRequestEvent>,
-    progress: Option<Res<ProgressResource>>,
-    daily: Option<Res<DailyChallengeResource>>,
-    font_res: Option<Res<FontResource>>,
     mut commands: Commands,
 ) {
     let mut clicked_any = false;
-    let mut open_modes = false;
     for (interaction, option) in &interaction_query {
         if *interaction != Interaction::Pressed {
             continue;
         }
         clicked_any = true;
         match option {
+            MenuOption::Home => {
+                home.write(ToggleHomeRequestEvent);
+            }
             MenuOption::Help => {
                 help.write(HelpRequestEvent);
             }
-            MenuOption::Modes => {
-                open_modes = true;
-            }
             MenuOption::Stats => {
                 stats.write(ToggleStatsRequestEvent);
             }
@@ -470,14 +509,6 @@ pub(super) fn handle_menu_option_click(
             commands.entity(e).despawn();
         }
     }
-    if open_modes {
-        spawn_modes_popover(
-            &mut commands,
-            progress.as_deref(),
-            daily.as_deref(),
-            font_res.as_deref(),
-        );
-    }
 }
 
 /// Despawns the [`ModesPopover`] and its backdrop when Escape / Android back

solitaire_engine/src/hud_plugin/mod.rs

@@ -30,9 +30,9 @@ use crate::daily_challenge_plugin::DailyChallengeResource;
 use crate::events::{
     HelpRequestEvent, InfoToastEvent, NewGameRequestEvent, PauseRequestEvent,
     StartChallengeRequestEvent, StartDailyChallengeRequestEvent, StartTimeAttackRequestEvent,
-    StartZenRequestEvent, ToggleAchievementsRequestEvent, ToggleLeaderboardRequestEvent,
-    ToggleProfileRequestEvent, ToggleSettingsRequestEvent, ToggleStatsRequestEvent,
-    UndoRequestEvent, WinStreakMilestoneEvent,
+    StartZenRequestEvent, ToggleAchievementsRequestEvent, ToggleHomeRequestEvent,
+    ToggleLeaderboardRequestEvent, ToggleProfileRequestEvent, ToggleSettingsRequestEvent,
+    ToggleStatsRequestEvent, UndoRequestEvent, WinStreakMilestoneEvent,
 };
 use crate::font_plugin::FontResource;
 use crate::game_plugin::{GameMutation, NewGameRequestWriters};
@@ -386,8 +386,9 @@ pub enum ModeOption {
 }
 
 /// Marker on the "Menu" action button. Click toggles the [`MenuPopover`]
-/// which exposes the Stats / Achievements / Profile / Settings /
-/// Leaderboard overlays without needing the S/A/P/O/L hotkeys.
+/// which exposes the Home / Profile / Stats / Achievements /
+/// Leaderboard / Settings / Help overlays without needing the
+/// M/P/S/A/L/O/F1 hotkeys.
 #[derive(Component, Debug)]
 pub struct MenuButton;
 
@@ -413,16 +414,18 @@ struct MenuPopoverBackdrop;
 struct ModesPopoverBackdrop;
 
 /// One row inside the [`MenuPopover`]. The variant selects which
-/// `Toggle*RequestEvent` the click handler fires.
+/// `Toggle*RequestEvent` the click handler fires. Rows render grouped
+/// under section headers (Play · You · Community · System); mode
+/// selection lives on Home, so there is no Modes row here.
 #[derive(Component, Debug, Clone, Copy)]
 pub enum MenuOption {
-    Help,
-    Modes,
+    Home,
+    Profile,
     Stats,
     Achievements,
-    Profile,
-    Settings,
     Leaderboard,
+    Settings,
+    Help,
 }
 
 /// HUD Z-layer — above cards (which start at z=0) but below overlay screens.
@@ -459,6 +462,7 @@ impl Plugin for HudPlugin {
             .add_message::<StartTimeAttackRequestEvent>()
             .add_message::<StartDailyChallengeRequestEvent>()
             .add_message::<ToggleStatsRequestEvent>()
+            .add_message::<ToggleHomeRequestEvent>()
             .add_message::<ToggleAchievementsRequestEvent>()
             .add_message::<ToggleProfileRequestEvent>()
             .add_message::<ToggleSettingsRequestEvent>()

solitaire_engine/src/hud_plugin/tests.rs

@@ -786,8 +786,8 @@ fn popover_rows_carry_tooltip_strings() {
         menu_tooltips.len()
     );
     for expected in [
+        "Pick a mode, continue, or start a new game.",
         "Show controls, rules, and keyboard shortcuts.",
-        "Switch modes: Classic, Daily, Zen, Challenge, Time Attack.",
         "Lifetime totals: wins, streaks, fastest time, best score.",
         "Browse unlocked achievements and the rewards still ahead.",
         "Your level, XP progress, and sync status.",

solitaire_engine/src/leaderboard_plugin.rs

@@ -343,13 +343,21 @@ fn scroll_leaderboard_panel(
     }
 }
 
+/// Done click or Esc dismisses the leaderboard (Phase C dismissal
+/// audit). Esc only fires when the leaderboard is the topmost modal —
+/// with the display-name dialog stacked on top, that dialog owns Esc.
 fn handle_leaderboard_close_button(
     mut commands: Commands,
+    keys: Res<ButtonInput<KeyCode>>,
     close_buttons: Query<&Interaction, (With<LeaderboardCloseButton>, Changed<Interaction>)>,
     screens: Query<Entity, With<LeaderboardScreen>>,
+    other_modal_scrims: Query<(), (With<ModalScrim>, Without<LeaderboardScreen>)>,
     mut closed_flag: ResMut<ClosedThisFrame>,
 ) {
-    if !close_buttons.iter().any(|i| *i == Interaction::Pressed) {
+    let clicked = close_buttons.iter().any(|i| *i == Interaction::Pressed);
+    let esc =
+        keys.just_pressed(KeyCode::Escape) && !screens.is_empty() && other_modal_scrims.is_empty();
+    if !clicked && !esc {
         return;
     }
     for entity in &screens {
@@ -888,12 +896,18 @@ fn handle_display_name_confirm(
 }
 
 /// Discards any typed text and closes the display-name editor modal.
+/// Cancel click or Esc dismisses the display-name dialog without
+/// saving (Phase C dismissal audit — same contract as the sync-setup
+/// dialog's Cancel/Esc pair).
 fn handle_display_name_cancel(
     button_q: Query<&Interaction, (Changed<Interaction>, With<DisplayNameCancelButton>)>,
+    keys: Res<ButtonInput<KeyCode>>,
     screens: Query<Entity, With<DisplayNameModal>>,
     mut commands: Commands,
 ) {
-    if !button_q.iter().any(|i| *i == Interaction::Pressed) {
+    let clicked = button_q.iter().any(|i| *i == Interaction::Pressed);
+    let esc = keys.just_pressed(KeyCode::Escape) && !screens.is_empty();
+    if !clicked && !esc {
         return;
     }
     for entity in &screens {

solitaire_engine/src/lib.rs

@@ -65,6 +65,7 @@ pub mod ui_theme;
 pub mod ui_tooltip;
 pub mod weekly_goals_plugin;
 pub mod win_summary_plugin;
+pub mod you_hub_plugin;
 
 pub use achievement_plugin::{AchievementPlugin, AchievementsResource, AchievementsScreen};
 #[cfg(not(target_arch = "wasm32"))]
@@ -197,3 +198,4 @@ pub use weekly_goals_plugin::{WeeklyGoalCompletedEvent, WeeklyGoalsPlugin};
 pub use win_summary_plugin::{
     ScreenShakeResource, SessionAchievements, WinSummaryPending, WinSummaryPlugin, format_win_time,
 };
+pub use you_hub_plugin::{ActiveYouTab, YouHubPlugin, YouHubScreen, YouTab};

solitaire_engine/src/profile_plugin.rs

@@ -4,7 +4,6 @@
 //! summary in a single scrollable panel. Spawned on the first `P` keypress and
 //! despawned on the second.
 
-use bevy::input::ButtonInput;
 use bevy::input::mouse::{MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
 use chrono::{Duration, Local, NaiveDate};
@@ -13,23 +12,19 @@ use solitaire_data::SyncBackend;
 
 use crate::achievement_plugin::AchievementsResource;
 #[cfg(not(target_arch = "wasm32"))]
-use crate::avatar_plugin::AvatarResource;
+pub(crate) use crate::avatar_plugin::AvatarResource;
 #[cfg(target_arch = "wasm32")]
 #[derive(bevy::prelude::Resource)]
-struct AvatarResource(Option<bevy::prelude::Handle<bevy::prelude::Image>>);
+pub(crate) struct AvatarResource(Option<bevy::prelude::Handle<bevy::prelude::Image>>);
 use crate::events::ToggleProfileRequestEvent;
 use crate::font_plugin::FontResource;
 use crate::progress_plugin::ProgressResource;
 use crate::resources::{SyncStatus, SyncStatusResource};
 use crate::settings_plugin::SettingsResource;
 use crate::stats_plugin::{StatsResource, format_fastest_win, format_win_rate};
-use crate::ui_modal::{
-    ButtonVariant, ModalScrim, ScrimDismissible, spawn_modal, spawn_modal_actions,
-    spawn_modal_button, spawn_modal_header,
-};
 use crate::ui_theme::{
     ACCENT_PRIMARY, BG_ELEVATED, BORDER_STRONG, SPACE_1, STATE_INFO, STATE_SUCCESS, TEXT_PRIMARY,
-    TEXT_SECONDARY, TYPE_BODY, TYPE_BODY_LG, TYPE_CAPTION, VAL_SPACE_1, VAL_SPACE_2, Z_MODAL_PANEL,
+    TEXT_SECONDARY, TYPE_BODY, TYPE_BODY_LG, TYPE_CAPTION, VAL_SPACE_1, VAL_SPACE_2,
 };
 
 /// Number of days surfaced in the daily-challenge calendar row.
@@ -60,13 +55,11 @@ pub struct DailyCalendarDot {
     pub is_today: bool,
 }
 
-/// Registers the `P` key toggle for the profile overlay.
+/// Registers the Profile body's scroll handling. Opening/closing moved
+/// to the You hub (`you_hub_plugin`), which calls
+/// [`spawn_profile_body`] for this tab's content.
 pub struct ProfilePlugin;
 
-/// Marker on the "Done" button inside the Profile modal.
-#[derive(Component, Debug)]
-pub struct ProfileCloseButton;
-
 /// Marker on the scrollable body Node inside the Profile modal.
 ///
 /// The Profile panel renders sync info, progression (incl. 14-day
@@ -87,14 +80,9 @@ impl Plugin for ProfilePlugin {
             // profile-scroll system also runs cleanly under
             // `MinimalPlugins` in tests.
             .add_message::<MouseWheel>()
-            .add_systems(
-                Update,
-                (
-                    toggle_profile_screen,
-                    handle_profile_close_button,
-                    scroll_profile_panel,
-                ),
-            );
+            // Open/close/tab handling moved to `you_hub_plugin`
+            // (Phase E) — this plugin now owns body content + scroll.
+            .add_systems(Update, scroll_profile_panel);
     }
 }
 
@@ -124,70 +112,12 @@ fn scroll_profile_panel(
     }
 }
 
-fn handle_profile_close_button(
-    mut commands: Commands,
-    close_buttons: Query<&Interaction, (With<ProfileCloseButton>, Changed<Interaction>)>,
-    screens: Query<Entity, With<ProfileScreen>>,
-) {
-    if !close_buttons.iter().any(|i| *i == Interaction::Pressed) {
-        return;
-    }
-    for entity in &screens {
-        commands.entity(entity).despawn();
-    }
-}
-
+/// Builds the Profile tab body inside the You hub's card. All markers
+/// (`ProfileScrollable`, `DailyCalendarDot`, …) are unchanged, so the
+/// scroll and test queries keep working.
 #[allow(clippy::too_many_arguments)]
-fn toggle_profile_screen(
-    mut commands: Commands,
-    keys: Res<ButtonInput<KeyCode>>,
-    mut requests: MessageReader<ToggleProfileRequestEvent>,
-    settings: Option<Res<SettingsResource>>,
-    sync_status: Option<Res<SyncStatusResource>>,
-    progress: Option<Res<ProgressResource>>,
-    achievements: Option<Res<AchievementsResource>>,
-    stats: Option<Res<StatsResource>>,
-    font_res: Option<Res<FontResource>>,
-    avatar: Option<Res<AvatarResource>>,
-    screens: Query<Entity, With<ProfileScreen>>,
-    scrims: Query<(), With<ModalScrim>>,
-) {
-    let button_clicked = requests.read().count() > 0;
-    let p_pressed = keys.just_pressed(KeyCode::KeyP);
-    let esc_pressed = keys.just_pressed(KeyCode::Escape);
-    let already_open = !screens.is_empty();
-    // P / button toggles open-or-close. Esc only ever closes — when
-    // Profile is layered over Home (clicking the new Home stats chip
-    // opens this on top), Esc must dismiss the *topmost* modal.
-    // Without this branch, Esc fell through to Home's cancel handler
-    // and closed the wrong modal.
-    let want_open = !already_open && (p_pressed || button_clicked);
-    let want_close = already_open && (p_pressed || button_clicked || esc_pressed);
-    if !want_open && !want_close {
-        return;
-    }
-    if want_open && !scrims.is_empty() {
-        return;
-    }
-    if let Ok(entity) = screens.single() {
-        commands.entity(entity).despawn();
-    } else {
-        spawn_profile_screen(
-            &mut commands,
-            settings.as_deref(),
-            sync_status.as_deref(),
-            progress.as_deref(),
-            achievements.as_deref(),
-            stats.as_deref(),
-            font_res.as_deref(),
-            avatar.as_deref(),
-        );
-    }
-}
-
-#[allow(clippy::too_many_arguments)]
-fn spawn_profile_screen(
-    commands: &mut Commands,
+pub(crate) fn spawn_profile_body(
+    card: &mut ChildSpawnerCommands,
     settings: Option<&SettingsResource>,
     sync_status: Option<&SyncStatusResource>,
     progress: Option<&ProgressResource>,
@@ -208,9 +138,7 @@ fn spawn_profile_screen(
         ..default()
     };
 
-    let scrim = spawn_modal(commands, ProfileScreen, Z_MODAL_PANEL, |card| {
-        spawn_modal_header(card, "Profile", font_res);
-
+    {
         // Scrollable body — the Profile panel renders sync info,
         // progression (incl. a 14-day calendar), every unlocked
         // achievement (up to ~18), and a stats summary, which can
@@ -472,20 +400,7 @@ fn spawn_profile_screen(
                 ));
             }
         });
-
-        spawn_modal_actions(card, |actions| {
-            spawn_modal_button(
-                actions,
-                ProfileCloseButton,
-                "Done",
-                Some("P"),
-                ButtonVariant::Primary,
-                font_res,
-            );
-        });
-    });
-    // Profile is read-only — opt into click-outside-to-dismiss.
-    commands.entity(scrim).insert(ScrimDismissible);
+    }
 }
 
 /// Spawn a fixed-height vertical spacer node.
@@ -627,6 +542,7 @@ mod tests {
     use crate::settings_plugin::SettingsPlugin;
     use crate::stats_plugin::StatsPlugin;
     use crate::table_plugin::TablePlugin;
+    use crate::ui_modal::ModalScrim;
 
     fn headless_app() -> App {
         let mut app = App::new();
@@ -637,7 +553,8 @@ mod tests {
             .add_plugins(ProgressPlugin::headless())
             .add_plugins(AchievementPlugin::headless())
             .add_plugins(SettingsPlugin::headless())
-            .add_plugins(ProfilePlugin);
+            .add_plugins(ProfilePlugin)
+            .add_plugins(crate::you_hub_plugin::YouHubPlugin);
         app.init_resource::<ButtonInput<KeyCode>>();
         app.update();
         app

solitaire_engine/src/safe_area.rs

@@ -82,7 +82,8 @@ impl Plugin for SafeAreaInsetsPlugin {
             );
 
         #[cfg(target_os = "android")]
-        app.init_resource::<android::SafeAreaPollTries>()
+        app.add_message::<crate::events::StateChangedEvent>()
+            .init_resource::<android::SafeAreaPollTries>()
             .add_systems(Update, android::refresh_insets)
             .add_systems(Update, android::rearm_on_resumed)
             .add_systems(Update, android::refresh_surface_size);
@@ -330,11 +331,16 @@ mod android {
     ///    `on_window_resized` in `table_plugin` recomputes the board layout,
     /// 3. re-arms the inset poller, because a screen change almost always
     ///    moves the system bars too — covering the "re-poll never fires"
-    ///    hole left open in #116.
+    ///    hole left open in #116,
+    /// 4. emits `StateChangedEvent` so `card_plugin`'s sync pipeline
+    ///    re-renders every card sprite from scratch — belt-and-braces for
+    ///    the transient tableau clip of #130, where geometry converged but
+    ///    stale card visuals survived the relayout.
     pub(super) fn refresh_surface_size(
         mut frame: Local<u32>,
         mut windows: Query<(Entity, &mut Window)>,
         mut resize_events: MessageWriter<WindowResized>,
+        mut state_events: MessageWriter<crate::events::StateChangedEvent>,
         mut poll: ResMut<SafeAreaPollTries>,
     ) {
         const POLL_INTERVAL_FRAMES: u32 = 30; // ~0.5 s @ 60 fps
@@ -381,6 +387,7 @@ mod android {
             width: decor_w as f32 / scale,
             height: decor_h as f32 / scale,
         });
+        state_events.write(crate::events::StateChangedEvent);
         poll.0 = 0;
     }
 

solitaire_engine/src/settings_plugin/input.rs

@@ -50,15 +50,21 @@ pub(super) fn handle_volume_keys(
 }
 
 /// Opens or closes the Settings panel — `O` keyboard accelerator or
-/// `ToggleSettingsRequestEvent` from the HUD Menu popover.
+/// `ToggleSettingsRequestEvent` from the HUD Menu popover. Esc closes
+/// too (Phase C dismissal audit), but only when Settings is the
+/// topmost modal — with sync-setup or the theme store stacked on top,
+/// the stacked dialog owns Esc.
 pub(super) fn toggle_settings_screen(
     keys: Res<ButtonInput<KeyCode>>,
     mut requests: MessageReader<ToggleSettingsRequestEvent>,
     mut screen: ResMut<SettingsScreen>,
+    other_modal_scrims: Query<(), (With<ModalScrim>, Without<SettingsPanel>)>,
 ) {
     let button_clicked = requests.read().count() > 0;
     if keys.just_pressed(KeyCode::KeyO) || button_clicked {
         screen.0 = !screen.0;
+    } else if keys.just_pressed(KeyCode::Escape) && screen.0 && other_modal_scrims.is_empty() {
+        screen.0 = false;
     }
 }
 
@@ -418,6 +424,25 @@ pub(super) fn handle_settings_buttons(
     }
 }
 
+/// Switches the active Settings tab when a chip is pressed. The
+/// rebuild itself happens in `rebuild_panel_on_tab_change`, driven by
+/// change detection on [`ActiveSettingsTab`].
+pub(super) fn handle_tab_buttons(
+    interactions: Query<(&Interaction, &SettingsTabButton), Changed<Interaction>>,
+    mut active: ResMut<ActiveSettingsTab>,
+) {
+    for (interaction, chip) in &interactions {
+        if *interaction != Interaction::Pressed {
+            continue;
+        }
+        // Compare before writing so re-clicking the active chip doesn't
+        // trip change detection and rebuild the panel for nothing.
+        if active.0 != chip.0 {
+            active.0 = chip.0;
+        }
+    }
+}
+
 /// Handles sync-related settings buttons: Sync Now, Connect, Disconnect,
 /// and Delete Account. Split from `handle_settings_buttons` to stay within
 /// Bevy's 16-parameter system limit.

solitaire_engine/src/settings_plugin/mod.rs

@@ -170,6 +170,51 @@ struct SmartDefaultSizeText;
 #[derive(Component, Debug)]
 struct AnalyticsEnabledText;
 
+/// Which tab of the Settings panel is showing. Tabs replace the old
+/// single-scroll five-section layout (Phase A of
+/// `docs/ui-redesign-2026-07.md`) so each group fits on screen without
+/// scroll-hunting.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub(super) enum SettingsTab {
+    #[default]
+    Audio,
+    Gameplay,
+    Appearance,
+    Accessibility,
+    Account,
+}
+
+impl SettingsTab {
+    /// Every tab, in display order.
+    pub(super) const ALL: [Self; 5] = [
+        Self::Audio,
+        Self::Gameplay,
+        Self::Appearance,
+        Self::Accessibility,
+        Self::Account,
+    ];
+
+    /// Chip label.
+    pub(super) fn label(self) -> &'static str {
+        match self {
+            Self::Audio => "Audio",
+            Self::Gameplay => "Gameplay",
+            Self::Appearance => "Appearance",
+            Self::Accessibility => "Access",
+            Self::Account => "Account",
+        }
+    }
+}
+
+/// The active Settings tab. Session-only — deliberately not persisted;
+/// reopening Settings within a session returns to the last tab.
+#[derive(Resource, Debug, Default)]
+pub(super) struct ActiveSettingsTab(pub(super) SettingsTab);
+
+/// Marker on each tab chip button in the Settings header row.
+#[derive(Component, Debug)]
+pub(super) struct SettingsTabButton(pub(super) SettingsTab);
+
 /// Marks the scrollable inner card so the mouse-wheel system can target it.
 #[derive(Component, Debug)]
 struct SettingsPanelScrollable;
@@ -369,6 +414,7 @@ impl Plugin for SettingsPlugin {
             .insert_resource(SettingsStoragePath(self.storage_path.clone()))
             .init_resource::<SettingsScreen>()
             .init_resource::<SettingsScrollPos>()
+            .init_resource::<ActiveSettingsTab>()
             .init_resource::<PendingWindowGeometry>()
             .add_message::<SettingsChangedEvent>()
             .add_message::<ManualSyncRequestEvent>()
@@ -423,7 +469,15 @@ impl Plugin for SettingsPlugin {
             app.add_systems(
                 Update,
                 (
-                    sync_settings_panel_visibility,
+                    // Chained: a tab click must observe this frame's
+                    // visibility state, and the rebuild must observe the
+                    // click — total order avoids panel double-spawns.
+                    (
+                        sync_settings_panel_visibility,
+                        handle_tab_buttons,
+                        rebuild_panel_on_tab_change,
+                    )
+                        .chain(),
                     handle_settings_buttons,
                     handle_sync_buttons,
                     #[cfg(not(target_arch = "wasm32"))]

solitaire_engine/src/settings_plugin/tests.rs

@@ -98,6 +98,25 @@ fn volume_clamped_at_zero_does_not_emit_event() {
     );
 }
 
+/// Opens the Settings panel showing `tab`, then waits out the
+/// spawn / child-flush / marker-attach frames.
+fn open_settings_on(app: &mut App, tab: SettingsTab) {
+    app.world_mut().resource_mut::<ActiveSettingsTab>().0 = tab;
+    app.world_mut().resource_mut::<SettingsScreen>().0 = true;
+    app.update();
+    app.update();
+    app.update();
+}
+
+/// Switches the already-open panel to `tab` (drives the
+/// `rebuild_panel_on_tab_change` path) and waits out the rebuild frames.
+fn switch_settings_tab(app: &mut App, tab: SettingsTab) {
+    app.world_mut().resource_mut::<ActiveSettingsTab>().0 = tab;
+    app.update();
+    app.update();
+    app.update();
+}
+
 #[test]
 fn pressing_o_toggles_settings_screen_flag() {
     let mut app = headless_app();
@@ -121,6 +140,31 @@ fn pressing_o_toggles_settings_screen_flag() {
     );
 }
 
+/// Esc closes the Settings panel like O / Done do (Phase C dismissal
+/// audit). Esc while the panel is closed must NOT open it.
+#[test]
+fn escape_closes_settings_screen_flag() {
+    let mut app = headless_app();
+
+    press(&mut app, KeyCode::Escape);
+    app.update();
+    assert!(
+        !app.world().resource::<SettingsScreen>().0,
+        "Esc on a closed panel stays closed"
+    );
+
+    press(&mut app, KeyCode::KeyO);
+    app.update();
+    assert!(app.world().resource::<SettingsScreen>().0, "O opens");
+
+    press(&mut app, KeyCode::Escape);
+    app.update();
+    assert!(
+        !app.world().resource::<SettingsScreen>().0,
+        "Esc closes settings"
+    );
+}
+
 // cycle_unlocked pure-function tests
 #[test]
 fn cycle_unlocked_wraps_at_end() {
@@ -243,40 +287,40 @@ fn headless_app_with_focus() -> App {
 fn settings_buttons_get_focusable_marker() {
     let mut app = headless_app_with_focus();
 
-    // Open the panel.
-    app.world_mut().resource_mut::<SettingsScreen>().0 = true;
-    app.update();
-    // Two more ticks: the first runs `sync_settings_panel_visibility`
-    // and queues the spawn commands; the second flushes them and
-    // runs `attach_focusable_to_settings_buttons`.
-    app.update();
-    app.update();
+    // Walk every tab: each rebuild must leave no bespoke
+    // `SettingsButton` (not `Done`, which is also a `ModalButton`)
+    // without a `Focusable`.
+    let mut total_tagged = 0usize;
+    for (i, tab) in SettingsTab::ALL.into_iter().enumerate() {
+        if i == 0 {
+            open_settings_on(&mut app, tab);
+        } else {
+            switch_settings_tab(&mut app, tab);
+        }
 
-    // Every bespoke `SettingsButton` (not `Done`, which is also a
-    // `ModalButton`) must carry a `Focusable`.
-    let untagged: Vec<&SettingsButton> = app
-        .world_mut()
-        .query_filtered::<&SettingsButton, (With<Button>, Without<Focusable>, Without<ModalButton>)>()
-        .iter(app.world())
-        .collect();
+        let untagged: Vec<&SettingsButton> = app
+            .world_mut()
+            .query_filtered::<&SettingsButton, (With<Button>, Without<Focusable>, Without<ModalButton>)>()
+            .iter(app.world())
+            .collect();
+        assert!(
+            untagged.is_empty(),
+            "every bespoke Settings button on tab {tab:?} must carry Focusable; missing: {untagged:?}"
+        );
 
+        total_tagged += app
+            .world_mut()
+            .query_filtered::<&SettingsButton, With<Focusable>>()
+            .iter(app.world())
+            .count();
+    }
+
+    // Floor across all five tabs so the assertion above isn't
+    // vacuously true (audio 4 + gameplay 8 + appearance ≥5 +
+    // accessibility 6 + account ≥1).
     assert!(
-        untagged.is_empty(),
-        "every bespoke Settings button must carry Focusable; missing: {:?}",
-        untagged
-    );
-
-    // And there must be at least one tagged `SettingsButton` so the
-    // assertion above isn't vacuously true (the panel really did
-    // spawn).
-    let tagged_count = app
-        .world_mut()
-        .query_filtered::<&SettingsButton, With<Focusable>>()
-        .iter(app.world())
-        .count();
-    assert!(
-        tagged_count >= 6,
-        "expected the panel to spawn many bespoke buttons (volume up/down ×2, toggles ×4, sync, swatches…); got {tagged_count}"
+        total_tagged >= 20,
+        "expected the five tabs to spawn many bespoke buttons; got {total_tagged}"
     );
 }
 
@@ -290,41 +334,45 @@ fn settings_buttons_get_focusable_marker() {
 fn settings_buttons_carry_tooltip() {
     let mut app = headless_app_with_focus();
 
-    // Open the panel and let spawn + child-flush run.
-    app.world_mut().resource_mut::<SettingsScreen>().0 = true;
-    app.update();
-    app.update();
-    app.update();
+    // Walk every tab: no bespoke `SettingsButton` (i.e. excluding
+    // `Done`, which is also a `ModalButton`) may be missing a
+    // `Tooltip` on any of them.
+    let mut total_tipped = 0usize;
+    for (i, tab) in SettingsTab::ALL.into_iter().enumerate() {
+        if i == 0 {
+            open_settings_on(&mut app, tab);
+        } else {
+            switch_settings_tab(&mut app, tab);
+        }
 
-    // No bespoke `SettingsButton` (i.e. excluding `Done`, which is
-    // also a `ModalButton`) may be missing a `Tooltip`.
-    let untipped: Vec<&SettingsButton> = app
-        .world_mut()
-        .query_filtered::<&SettingsButton, (With<Button>, Without<Tooltip>, Without<ModalButton>)>()
-        .iter(app.world())
-        .collect();
+        let untipped: Vec<&SettingsButton> = app
+            .world_mut()
+            .query_filtered::<&SettingsButton, (With<Button>, Without<Tooltip>, Without<ModalButton>)>()
+            .iter(app.world())
+            .collect();
+        assert!(
+            untipped.is_empty(),
+            "every bespoke Settings button on tab {tab:?} must carry Tooltip; missing: {untipped:?}"
+        );
+
+        total_tipped += app
+            .world_mut()
+            .query_filtered::<&SettingsButton, With<Tooltip>>()
+            .iter(app.world())
+            .count();
+    }
+
+    // Floor across all five tabs so the assertion above isn't
+    // vacuously true.
     assert!(
-        untipped.is_empty(),
-        "every bespoke Settings button must carry Tooltip; missing: {:?}",
-        untipped
+        total_tipped >= 20,
+        "expected the five tabs to spawn many tooltipped buttons; got {total_tipped}"
     );
 
-    // And there must be at least 6 tipped buttons so the assertion
-    // above isn't vacuously true: SFX +/−, Music +/−, Draw Mode,
-    // Anim Speed, Theme, Color-blind, Sync Now, plus at least one
-    // card-back and one background swatch — well over the floor.
-    let tipped_count = app
-        .world_mut()
-        .query_filtered::<&SettingsButton, With<Tooltip>>()
-        .iter(app.world())
-        .count();
-    assert!(
-        tipped_count >= 6,
-        "expected the panel to spawn many tooltipped buttons; got {tipped_count}"
-    );
+    // The loop ends on the Account tab, where with default (Local)
+    // settings the Connect button spawns.
 
-    // Spot-check: with default (Local) settings the Connect button
-    // spawns. We verify its tooltip carries the canonical microcopy.
+    // We verify its tooltip carries the canonical microcopy.
     let connect_tip = app
         .world_mut()
         .query::<(&SettingsButton, &Tooltip)>()
@@ -342,10 +390,8 @@ fn settings_buttons_carry_tooltip() {
 fn settings_picker_rows_get_focus_row_marker() {
     let mut app = headless_app_with_focus();
 
-    app.world_mut().resource_mut::<SettingsScreen>().0 = true;
-    app.update();
-    app.update();
-    app.update();
+    // Picker rows live on the Appearance tab.
+    open_settings_on(&mut app, SettingsTab::Appearance);
 
     // Two picker rows are spawned (card-back + background); each
     // must carry the FocusRow marker.
@@ -360,6 +406,45 @@ fn settings_picker_rows_get_focus_row_marker() {
     );
 }
 
+/// Switching tabs despawns the old rows and spawns the new tab's —
+/// exactly one panel exists afterwards (no double-spawn from the
+/// visibility system racing the rebuild system).
+#[test]
+fn switching_tab_rebuilds_panel_with_new_rows() {
+    let mut app = headless_app_with_focus();
+
+    fn has_button(app: &mut App, wanted: fn(&SettingsButton) -> bool) -> bool {
+        app.world_mut()
+            .query::<&SettingsButton>()
+            .iter(app.world())
+            .any(wanted)
+    }
+
+    open_settings_on(&mut app, SettingsTab::Audio);
+    assert!(has_button(&mut app, |b| matches!(b, SettingsButton::SfxUp)));
+    assert!(
+        !has_button(&mut app, |b| matches!(b, SettingsButton::ToggleDrawMode)),
+        "Gameplay rows must not spawn while the Audio tab is active"
+    );
+
+    switch_settings_tab(&mut app, SettingsTab::Gameplay);
+    assert!(
+        !has_button(&mut app, |b| matches!(b, SettingsButton::SfxUp)),
+        "Audio rows must despawn when leaving the Audio tab"
+    );
+    assert!(has_button(&mut app, |b| matches!(
+        b,
+        SettingsButton::ToggleDrawMode
+    )));
+
+    let panel_count = app
+        .world_mut()
+        .query_filtered::<Entity, With<SettingsPanel>>()
+        .iter(app.world())
+        .count();
+    assert_eq!(panel_count, 1, "tab switch must not stack panels");
+}
+
 /// Test 3 of the thumbnail-picker spec: when [`ThemeRegistry`] has
 /// at least one theme and the [`ThemeThumbnailCache`] holds a
 /// fully-populated [`ThemeThumbnailPair`] for that theme's id, the
@@ -404,11 +489,9 @@ fn theme_picker_chip_includes_thumbnail_sprite_when_thumbnails_loaded() {
     );
     app.insert_resource(cache);
 
-    // Open the panel and let the spawn + child-flush systems run.
-    app.world_mut().resource_mut::<SettingsScreen>().0 = true;
-    app.update();
-    app.update();
-    app.update();
+    // Open the panel on the Appearance tab (the theme picker's home)
+    // and let the spawn + child-flush systems run.
+    open_settings_on(&mut app, SettingsTab::Appearance);
 
     // Find every ImageNode tagged with ThemeThumbnailMarker — the
     // theme picker chip for "test_theme" must contribute exactly

solitaire_engine/src/settings_plugin/ui.rs

@@ -18,6 +18,7 @@ use crate::theme::{ImportError, import_theme, refresh_registry};
 use crate::ui_focus::FocusRow;
 use crate::ui_modal::{
     ButtonVariant, spawn_modal, spawn_modal_actions, spawn_modal_button, spawn_modal_header,
+    spawn_tab_chip,
 };
 use crate::ui_theme::{
     BG_BASE, BG_ELEVATED, BG_ELEVATED_HI, BORDER_SUBTLE, HighContrastBorder, RADIUS_SM,
@@ -45,13 +46,34 @@ pub(super) fn spawn_settings_panel(
     scroll_offset: f32,
     font_res: Option<&FontResource>,
     theme_overrides_back: bool,
+    active_tab: SettingsTab,
 ) {
     spawn_modal(commands, SettingsPanel, Z_MODAL_PANEL, |card| {
         spawn_modal_header(card, "Settings", font_res);
 
-        // Scrollable body — contains every section so tall content stays
-        // reachable on short windows. The Done button below stays fixed
-        // outside the scroll so it's always one click away.
+        // Tab chips — one group of rows on screen at a time, no
+        // scroll-hunting (Phase A, docs/ui-redesign-2026-07.md).
+        card.spawn((
+            FocusRow,
+            Node {
+                flex_direction: FlexDirection::Row,
+                flex_wrap: FlexWrap::Wrap,
+                column_gap: VAL_SPACE_2,
+                row_gap: VAL_SPACE_2,
+                margin: UiRect::bottom(VAL_SPACE_3),
+                ..default()
+            },
+        ))
+        .with_children(|row| {
+            for tab in SettingsTab::ALL {
+                tab_chip(row, tab, tab == active_tab, font_res);
+            }
+        });
+
+        // Scrollable body — most tabs fit without scrolling, but the
+        // Appearance pickers can still overflow short windows. The Done
+        // button below stays fixed outside the scroll so it's always one
+        // click away.
         card.spawn((
             SettingsPanelScrollable,
             SettingsScrollNode,
@@ -65,200 +87,20 @@ pub(super) fn spawn_settings_panel(
                 ..default()
             },
         ))
-        .with_children(|body| {
-            // --- Audio ---
-            section_label(body, "Audio", font_res);
-            volume_row(
+        .with_children(|body| match active_tab {
+            SettingsTab::Audio => spawn_audio_tab(body, settings, font_res),
+            SettingsTab::Gameplay => spawn_gameplay_tab(body, settings, font_res),
+            SettingsTab::Appearance => spawn_appearance_tab(
                 body,
-                "SFX Volume",
-                settings.sfx_volume,
-                SfxVolumeText,
-                SettingsButton::SfxDown,
-                SettingsButton::SfxUp,
-                "Lower sound effects volume.",
-                "Raise sound effects volume.",
-                font_res,
-            );
-            volume_row(
-                body,
-                "Music Volume",
-                settings.music_volume,
-                MusicVolumeText,
-                SettingsButton::MusicDown,
-                SettingsButton::MusicUp,
-                "Lower music and ambience volume.",
-                "Raise music and ambience volume.",
-                font_res,
-            );
-
-            // --- Gameplay ---
-            section_label(body, "Gameplay", font_res);
-            toggle_row(
-                body,
-                "Draw Mode",
-                DrawModeText,
-                draw_mode_label(&settings.draw_mode),
-                SettingsButton::ToggleDrawMode,
-                "Switch between Draw 1 and Draw 3. Takes effect next deal.",
-                font_res,
-            );
-            toggle_row(
-                body,
-                "Winnable deals only",
-                WinnableDealsOnlyText,
-                winnable_deals_only_label(settings.winnable_deals_only),
-                SettingsButton::ToggleWinnableDealsOnly,
-                "When on, fresh Classic deals are filtered through a solver \
-                 (may take a moment when on).",
-                font_res,
-            );
-            toggle_row(
-                body,
-                "Anim Speed",
-                AnimSpeedText,
-                anim_speed_label(&settings.animation_speed),
-                SettingsButton::CycleAnimSpeed,
-                "Cycle animation speed: Normal, Fast, Instant.",
-                font_res,
-            );
-            tooltip_delay_row(
-                body,
-                settings.tooltip_delay_secs,
-                font_res,
-            );
-            time_bonus_multiplier_row(
-                body,
-                settings.time_bonus_multiplier,
-                font_res,
-            );
-            replay_move_interval_row(
-                body,
-                settings.replay_move_interval_secs,
-                font_res,
-            );
-            toggle_row(
-                body,
-                "Smart window size",
-                SmartDefaultSizeText,
-                smart_default_size_label(!settings.disable_smart_default_size),
-                SettingsButton::ToggleSmartDefaultSize,
-                "When ON, fresh launches resize the window to ~70 % of the \
-                 monitor. OFF pins the 1280\u{00D7}800 baseline. Saved \
-                 window size always wins.",
-                font_res,
-            );
-
-            // --- Cosmetic ---
-            section_label(body, "Cosmetic", font_res);
-            toggle_row(
-                body,
-                "Theme",
-                ThemeText,
-                theme_label(&settings.theme),
-                SettingsButton::ToggleTheme,
-                "Cycle felt color: Green, Blue, Dark.",
-                font_res,
-            );
-            toggle_row(
-                body,
-                "Color-blind Mode",
-                ColorBlindText,
-                color_blind_label(settings.color_blind_mode),
-                SettingsButton::ToggleColorBlind,
-                "Show shape glyphs alongside suit colors. Suit-blind friendly.",
-                font_res,
-            );
-            toggle_row(
-                body,
-                "High Contrast",
-                HighContrastText,
-                on_off_label(settings.high_contrast_mode),
-                SettingsButton::ToggleHighContrast,
-                "Boosts foreground + suit-red glyphs to higher-luminance variants for low-vision readers and low-quality displays.",
-                font_res,
-            );
-            toggle_row(
-                body,
-                "Reduce Motion",
-                ReduceMotionText,
-                on_off_label(settings.reduce_motion_mode),
-                SettingsButton::ToggleReduceMotion,
-                "Skips card-slide animations and other non-essential motion. Cards snap instantly to their target.",
-                font_res,
-            );
-            toggle_row(
-                body,
-                "Touch Input Mode",
-                TouchInputModeText,
-                touch_input_mode_label(&settings.touch_input_mode),
-                SettingsButton::ToggleTouchInputMode,
-                "One-tap: tap a card to auto-move it. Tap to select: first tap selects a card, second tap on a pile moves it.",
-                font_res,
-            );
-            if theme_overrides_back {
-                // The active theme provides its own back; the legacy
-                // picker has no visible effect, so we replace its
-                // swatch row with an informational caption. The
-                // player's `selected_card_back` value still
-                // round-trips through `settings.json` — the moment
-                // they switch to a theme without a back, the picker
-                // re-appears with their previous choice intact.
-                picker_row_overridden_by_theme(body, "Card Back", font_res);
-            } else {
-                picker_row(
-                    body,
-                    "Card Back",
-                    unlocked_card_backs,
-                    settings.selected_card_back,
-                    SettingsButton::SelectCardBack,
-                    "Choose your deck art. New backs unlock at higher levels.",
-                    font_res,
-                );
-            }
-            picker_row(
-                body,
-                "Background",
+                settings,
+                unlocked_card_backs,
                 unlocked_backgrounds,
-                settings.selected_background,
-                SettingsButton::SelectBackground,
-                "Choose your felt art. New felts unlock at higher levels.",
+                themes,
+                theme_overrides_back,
                 font_res,
-            );
-            // Card-art theme picker — only renders when the registry has
-            // entries (production: always; tests: only when
-            // ThemeRegistryPlugin is installed).
-            if !themes.is_empty() {
-                theme_picker_row(
-                    body,
-                    "Card Theme",
-                    themes,
-                    &settings.selected_theme_id,
-                    "Choose card-face artwork. Imported themes appear here.",
-                    font_res,
-                );
-            }
-            #[cfg(not(target_arch = "wasm32"))]
-            import_themes_row(body, font_res);
-            #[cfg(not(target_arch = "wasm32"))]
-            theme_store_row(body, font_res);
-
-            // --- Privacy (only shown when a Matomo URL is configured) ---
-            if settings.matomo_url.is_some() {
-                section_label(body, "Privacy", font_res);
-                toggle_row(
-                    body,
-                    "Share usage data",
-                    AnalyticsEnabledText,
-                    on_off_label(settings.analytics_enabled),
-                    SettingsButton::ToggleAnalytics,
-                    "Sends anonymous game events to Matomo for aggregate analytics.",
-                    font_res,
-                );
-            }
-
-            // --- Sync ---
-            section_label(body, "Sync", font_res);
-            sync_row(body, sync_status, &settings.sync_backend, font_res);
+            ),
+            SettingsTab::Accessibility => spawn_accessibility_tab(body, settings, font_res),
+            SettingsTab::Account => spawn_account_tab(body, settings, sync_status, font_res),
         });
 
         // Done is the only action — primary so the player always knows
@@ -276,6 +118,244 @@ pub(super) fn spawn_settings_panel(
     });
 }
 
+/// One Settings tab chip — thin wrapper over the shared
+/// [`spawn_tab_chip`] widget so Settings and the You hub stay visually
+/// identical.
+fn tab_chip(
+    parent: &mut ChildSpawnerCommands,
+    tab: SettingsTab,
+    active: bool,
+    font_res: Option<&FontResource>,
+) {
+    spawn_tab_chip(
+        parent,
+        SettingsTabButton(tab),
+        tab.label(),
+        active,
+        font_res,
+    );
+}
+
+/// Audio tab: the two volume rows.
+fn spawn_audio_tab(
+    body: &mut ChildSpawnerCommands,
+    settings: &Settings,
+    font_res: Option<&FontResource>,
+) {
+    volume_row(
+        body,
+        "SFX Volume",
+        settings.sfx_volume,
+        SfxVolumeText,
+        SettingsButton::SfxDown,
+        SettingsButton::SfxUp,
+        "Lower sound effects volume.",
+        "Raise sound effects volume.",
+        font_res,
+    );
+    volume_row(
+        body,
+        "Music Volume",
+        settings.music_volume,
+        MusicVolumeText,
+        SettingsButton::MusicDown,
+        SettingsButton::MusicUp,
+        "Lower music and ambience volume.",
+        "Raise music and ambience volume.",
+        font_res,
+    );
+}
+
+/// Gameplay tab: rules and pacing.
+fn spawn_gameplay_tab(
+    body: &mut ChildSpawnerCommands,
+    settings: &Settings,
+    font_res: Option<&FontResource>,
+) {
+    toggle_row(
+        body,
+        "Draw Mode",
+        DrawModeText,
+        draw_mode_label(&settings.draw_mode),
+        SettingsButton::ToggleDrawMode,
+        "Switch between Draw 1 and Draw 3. Takes effect next deal.",
+        font_res,
+    );
+    toggle_row(
+        body,
+        "Winnable deals only",
+        WinnableDealsOnlyText,
+        winnable_deals_only_label(settings.winnable_deals_only),
+        SettingsButton::ToggleWinnableDealsOnly,
+        "When on, fresh Classic deals are filtered through a solver \
+                 (may take a moment when on).",
+        font_res,
+    );
+    toggle_row(
+        body,
+        "Anim Speed",
+        AnimSpeedText,
+        anim_speed_label(&settings.animation_speed),
+        SettingsButton::CycleAnimSpeed,
+        "Cycle animation speed: Normal, Fast, Instant.",
+        font_res,
+    );
+    time_bonus_multiplier_row(body, settings.time_bonus_multiplier, font_res);
+    replay_move_interval_row(body, settings.replay_move_interval_secs, font_res);
+    toggle_row(
+        body,
+        "Smart window size",
+        SmartDefaultSizeText,
+        smart_default_size_label(!settings.disable_smart_default_size),
+        SettingsButton::ToggleSmartDefaultSize,
+        "When ON, fresh launches resize the window to ~70 % of the \
+                 monitor. OFF pins the 1280\u{00D7}800 baseline. Saved \
+                 window size always wins.",
+        font_res,
+    );
+}
+
+/// Appearance tab: felt, deck art, backgrounds, and the theme system.
+#[allow(clippy::too_many_arguments)]
+fn spawn_appearance_tab(
+    body: &mut ChildSpawnerCommands,
+    settings: &Settings,
+    unlocked_card_backs: &[usize],
+    unlocked_backgrounds: &[usize],
+    themes: &[ThemePickerEntry],
+    theme_overrides_back: bool,
+    font_res: Option<&FontResource>,
+) {
+    toggle_row(
+        body,
+        "Theme",
+        ThemeText,
+        theme_label(&settings.theme),
+        SettingsButton::ToggleTheme,
+        "Cycle felt color: Green, Blue, Dark.",
+        font_res,
+    );
+    if theme_overrides_back {
+        // The active theme provides its own back; the legacy
+        // picker has no visible effect, so we replace its
+        // swatch row with an informational caption. The
+        // player's `selected_card_back` value still
+        // round-trips through `settings.json` — the moment
+        // they switch to a theme without a back, the picker
+        // re-appears with their previous choice intact.
+        picker_row_overridden_by_theme(body, "Card Back", font_res);
+    } else {
+        picker_row(
+            body,
+            "Card Back",
+            unlocked_card_backs,
+            settings.selected_card_back,
+            SettingsButton::SelectCardBack,
+            "Choose your deck art. New backs unlock at higher levels.",
+            font_res,
+        );
+    }
+    picker_row(
+        body,
+        "Background",
+        unlocked_backgrounds,
+        settings.selected_background,
+        SettingsButton::SelectBackground,
+        "Choose your felt art. New felts unlock at higher levels.",
+        font_res,
+    );
+    // Card-art theme picker — only renders when the registry has
+    // entries (production: always; tests: only when
+    // ThemeRegistryPlugin is installed).
+    if !themes.is_empty() {
+        theme_picker_row(
+            body,
+            "Card Theme",
+            themes,
+            &settings.selected_theme_id,
+            "Choose card-face artwork. Imported themes appear here.",
+            font_res,
+        );
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    import_themes_row(body, font_res);
+    #[cfg(not(target_arch = "wasm32"))]
+    theme_store_row(body, font_res);
+}
+
+/// Accessibility tab: perception and input assists, gathered from the
+/// old Gameplay/Cosmetic sections so they're findable in one place.
+fn spawn_accessibility_tab(
+    body: &mut ChildSpawnerCommands,
+    settings: &Settings,
+    font_res: Option<&FontResource>,
+) {
+    toggle_row(
+        body,
+        "Color-blind Mode",
+        ColorBlindText,
+        color_blind_label(settings.color_blind_mode),
+        SettingsButton::ToggleColorBlind,
+        "Show shape glyphs alongside suit colors. Suit-blind friendly.",
+        font_res,
+    );
+    toggle_row(
+        body,
+        "High Contrast",
+        HighContrastText,
+        on_off_label(settings.high_contrast_mode),
+        SettingsButton::ToggleHighContrast,
+        "Boosts foreground + suit-red glyphs to higher-luminance variants for low-vision readers and low-quality displays.",
+        font_res,
+    );
+    toggle_row(
+        body,
+        "Reduce Motion",
+        ReduceMotionText,
+        on_off_label(settings.reduce_motion_mode),
+        SettingsButton::ToggleReduceMotion,
+        "Skips card-slide animations and other non-essential motion. Cards snap instantly to their target.",
+        font_res,
+    );
+    toggle_row(
+        body,
+        "Touch Input Mode",
+        TouchInputModeText,
+        touch_input_mode_label(&settings.touch_input_mode),
+        SettingsButton::ToggleTouchInputMode,
+        "One-tap: tap a card to auto-move it. Tap to select: first tap selects a card, second tap on a pile moves it.",
+        font_res,
+    );
+    tooltip_delay_row(body, settings.tooltip_delay_secs, font_res);
+}
+
+/// Account tab: privacy opt-in (when analytics is configured) and the
+/// sync backend controls.
+fn spawn_account_tab(
+    body: &mut ChildSpawnerCommands,
+    settings: &Settings,
+    sync_status: &str,
+    font_res: Option<&FontResource>,
+) {
+    // --- Privacy (only shown when a Matomo URL is configured) ---
+    if settings.matomo_url.is_some() {
+        section_label(body, "Privacy", font_res);
+        toggle_row(
+            body,
+            "Share usage data",
+            AnalyticsEnabledText,
+            on_off_label(settings.analytics_enabled),
+            SettingsButton::ToggleAnalytics,
+            "Sends anonymous game events to Matomo for aggregate analytics.",
+            font_res,
+        );
+    }
+
+    // --- Sync ---
+    section_label(body, "Sync", font_res);
+    sync_row(body, sync_status, &settings.sync_backend, font_res);
+}
+
 /// Section divider — small lavender label inside the scrollable body.
 pub(super) fn section_label(
     parent: &mut ChildSpawnerCommands,

solitaire_engine/src/settings_plugin/updates.rs

@@ -17,6 +17,7 @@ use crate::ui_theme::{BORDER_SUBTLE_HC, HighContrastBackground, HighContrastBord
 #[allow(clippy::too_many_arguments)]
 pub(super) fn sync_settings_panel_visibility(
     screen: Res<SettingsScreen>,
+    active_tab: Res<ActiveSettingsTab>,
     panels: Query<Entity, With<SettingsPanel>>,
     other_modal_scrims: Query<(), (With<ModalScrim>, Without<SettingsPanel>)>,
     scroll_nodes: Query<&ScrollPosition, With<SettingsScrollNode>>,
@@ -35,60 +36,17 @@ pub(super) fn sync_settings_panel_visibility(
     }
     if screen.0 {
         if panels.is_empty() && other_modal_scrims.is_empty() {
-            let status_label = sync_status.map_or_else(
-                || "Status: local only".to_string(),
-                |s| sync_status_label(&s.0),
-            );
-            let unlocked_backs = progress
-                .as_ref()
-                .map_or(&[0][..], |p| p.0.unlocked_card_backs.as_slice());
-            let unlocked_bgs = progress
-                .as_ref()
-                .map_or(&[0][..], |p| p.0.unlocked_backgrounds.as_slice());
-            // Snapshot themes by id, display_name and (optional)
-            // thumbnail pair so spawn_settings_panel doesn't have to
-            // know about the registry / cache shapes. Empty when
-            // ThemeRegistryPlugin isn't installed (tests under
-            // MinimalPlugins) — the picker row simply won't render.
-            // Missing thumbnails (cache not ready, or partial user
-            // theme) leave `thumbnails: None` so the chip renders its
-            // plain-text fallback instead of a broken sprite.
-            let themes: Vec<ThemePickerEntry> = theme_registry
-                .as_deref()
-                .map(|r| {
-                    r.iter()
-                        .map(|e| ThemePickerEntry {
-                            id: e.id.clone(),
-                            display_name: e.display_name.clone(),
-                            thumbnails: theme_thumbs
-                                .as_deref()
-                                .and_then(|c| c.get(&e.id))
-                                .filter(|p| p.is_fully_populated())
-                                .cloned(),
-                        })
-                        .collect()
-                })
-                .unwrap_or_default();
-            // The active card-art theme can supply its own back image —
-            // see `card_plugin::CardImageSet::theme_back`. When that is
-            // populated the legacy "Card Back" picker has no visible
-            // effect, so we render it muted with an explanatory caption
-            // rather than letting the player click swatches that do
-            // nothing. Absent under `MinimalPlugins`; treated as
-            // "no override" in that case.
-            let theme_overrides_back = card_images
-                .as_ref()
-                .is_some_and(|cs| cs.theme_back.is_some());
-            spawn_settings_panel(
+            build_panel(
                 &mut commands,
                 &settings.0,
-                &status_label,
-                unlocked_backs,
-                unlocked_bgs,
-                &themes,
-                scroll_pos.0,
+                sync_status.as_deref(),
+                progress.as_deref(),
                 font_res.as_deref(),
-                theme_overrides_back,
+                theme_registry.as_deref(),
+                theme_thumbs.as_deref(),
+                card_images.as_deref(),
+                scroll_pos.0,
+                active_tab.0,
             );
         }
     } else {
@@ -102,6 +60,116 @@ pub(super) fn sync_settings_panel_visibility(
     }
 }
 
+/// Gathers the spawn context (sync label, unlocks, theme snapshot,
+/// back-override flag) and spawns the panel showing `active_tab`.
+/// Shared by [`sync_settings_panel_visibility`] (open) and
+/// [`rebuild_panel_on_tab_change`] (tab switch).
+#[allow(clippy::too_many_arguments)]
+fn build_panel(
+    commands: &mut Commands,
+    settings: &Settings,
+    sync_status: Option<&SyncStatusResource>,
+    progress: Option<&ProgressResource>,
+    font_res: Option<&FontResource>,
+    theme_registry: Option<&crate::theme::ThemeRegistry>,
+    theme_thumbs: Option<&ThemeThumbnailCache>,
+    card_images: Option<&crate::card_plugin::CardImageSet>,
+    scroll_offset: f32,
+    active_tab: SettingsTab,
+) {
+    let status_label = sync_status.map_or_else(
+        || "Status: local only".to_string(),
+        |s| sync_status_label(&s.0),
+    );
+    let unlocked_backs = progress.map_or(&[0][..], |p| p.0.unlocked_card_backs.as_slice());
+    let unlocked_bgs = progress.map_or(&[0][..], |p| p.0.unlocked_backgrounds.as_slice());
+    // Snapshot themes by id, display_name and (optional)
+    // thumbnail pair so spawn_settings_panel doesn't have to
+    // know about the registry / cache shapes. Empty when
+    // ThemeRegistryPlugin isn't installed (tests under
+    // MinimalPlugins) — the picker row simply won't render.
+    // Missing thumbnails (cache not ready, or partial user
+    // theme) leave `thumbnails: None` so the chip renders its
+    // plain-text fallback instead of a broken sprite.
+    let themes: Vec<ThemePickerEntry> = theme_registry
+        .map(|r| {
+            r.iter()
+                .map(|e| ThemePickerEntry {
+                    id: e.id.clone(),
+                    display_name: e.display_name.clone(),
+                    thumbnails: theme_thumbs
+                        .and_then(|c| c.get(&e.id))
+                        .filter(|p| p.is_fully_populated())
+                        .cloned(),
+                })
+                .collect()
+        })
+        .unwrap_or_default();
+    // The active card-art theme can supply its own back image —
+    // see `card_plugin::CardImageSet::theme_back`. When that is
+    // populated the legacy "Card Back" picker has no visible
+    // effect, so we render it muted with an explanatory caption
+    // rather than letting the player click swatches that do
+    // nothing. Absent under `MinimalPlugins`; treated as
+    // "no override" in that case.
+    let theme_overrides_back = card_images.is_some_and(|cs| cs.theme_back.is_some());
+    spawn_settings_panel(
+        commands,
+        settings,
+        &status_label,
+        unlocked_backs,
+        unlocked_bgs,
+        &themes,
+        scroll_offset,
+        font_res,
+        theme_overrides_back,
+        active_tab,
+    );
+}
+
+/// Rebuilds the open panel when [`ActiveSettingsTab`] changes (tab chip
+/// clicked). No-op while the panel is closed — the next open reads the
+/// resource directly.
+#[allow(clippy::too_many_arguments)]
+pub(super) fn rebuild_panel_on_tab_change(
+    active_tab: Res<ActiveSettingsTab>,
+    panels: Query<Entity, With<SettingsPanel>>,
+    mut scroll_pos: ResMut<SettingsScrollPos>,
+    mut commands: Commands,
+    settings: Res<SettingsResource>,
+    sync_status: Option<Res<SyncStatusResource>>,
+    progress: Option<Res<ProgressResource>>,
+    font_res: Option<Res<FontResource>>,
+    theme_registry: Option<Res<crate::theme::ThemeRegistry>>,
+    theme_thumbs: Option<Res<ThemeThumbnailCache>>,
+    card_images: Option<Res<crate::card_plugin::CardImageSet>>,
+) {
+    if !active_tab.is_changed() || active_tab.is_added() {
+        return;
+    }
+    if panels.is_empty() {
+        return;
+    }
+    for entity in &panels {
+        commands.entity(entity).despawn();
+    }
+    // A fresh tab starts at the top; per-tab scroll memory isn't worth
+    // the bookkeeping now that no tab needs much scrolling.
+    scroll_pos.0 = 0.0;
+    build_panel(
+        &mut commands,
+        &settings.0,
+        sync_status.as_deref(),
+        progress.as_deref(),
+        font_res.as_deref(),
+        theme_registry.as_deref(),
+        theme_thumbs.as_deref(),
+        card_images.as_deref(),
+        0.0,
+        active_tab.0,
+    );
+}
+
 /// Keeps the sync-status text node current while the panel is open.
 pub(super) fn update_sync_status_text(
     sync_status: Option<Res<SyncStatusResource>>,

solitaire_engine/src/stats_plugin.rs

@@ -8,7 +8,6 @@
 
 use std::path::PathBuf;
 
-use bevy::input::ButtonInput;
 use bevy::input::mouse::{MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
 use solitaire_data::{
@@ -25,17 +24,13 @@ use crate::events::{
 use crate::font_plugin::FontResource;
 use crate::game_plugin::GameMutation;
 use crate::platform::ClipboardBackendResource;
-use crate::progress_plugin::ProgressResource;
 use crate::resources::GameStateResource;
 use crate::time_attack_plugin::TimeAttackResource;
-use crate::ui_modal::{
-    ButtonVariant, ModalButton, ModalScrim, ScrimDismissible, spawn_modal, spawn_modal_actions,
-    spawn_modal_button, spawn_modal_header,
-};
+use crate::ui_modal::{ButtonVariant, ModalButton, spawn_modal_button};
 use crate::ui_theme::{
     ACCENT_PRIMARY, BG_ELEVATED_HI, BORDER_SUBTLE, HighContrastBorder, RADIUS_SM, STATE_INFO,
     STATE_WARNING, STREAK_MILESTONES, TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY, TYPE_BODY_LG,
-    TYPE_CAPTION, TYPE_HEADLINE, VAL_SPACE_1, VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4, Z_MODAL_PANEL,
+    TYPE_CAPTION, TYPE_HEADLINE, VAL_SPACE_1, VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4,
 };
 
 /// Bevy resource wrapping the current stats.
@@ -225,8 +220,9 @@ impl Plugin for StatsPlugin {
                     .before(GameMutation)
                     .before(update_stats_on_new_game),
             )
-            .add_systems(Update, toggle_stats_screen.after(GameMutation))
-            .add_systems(Update, handle_stats_close_button)
+            // Open/close/tab handling moved to `you_hub_plugin`
+            // (Phase E) — this plugin now owns body content, replay
+            // selector behavior, and scroll.
             .add_systems(Update, refresh_replay_history_on_win.after(GameMutation))
             .add_systems(Update, handle_watch_replay_button)
             .add_systems(Update, handle_copy_share_link_button)
@@ -632,70 +628,17 @@ fn handle_forfeit(
     }
 }
 
-/// Marker on the "Done" button inside the Stats modal. Click despawns
-/// the overlay; `S` keyboard shortcut toggles it the same way.
-#[derive(Component, Debug)]
-pub struct StatsCloseButton;
-
-#[allow(clippy::too_many_arguments)]
-fn toggle_stats_screen(
-    mut commands: Commands,
-    keys: Res<ButtonInput<KeyCode>>,
-    mut requests: MessageReader<ToggleStatsRequestEvent>,
-    stats: Res<StatsResource>,
-    progress: Option<Res<ProgressResource>>,
-    time_attack: Option<Res<TimeAttackResource>>,
-    font_res: Option<Res<FontResource>>,
-    latest_replay: Res<ReplayHistoryResource>,
-    selected_index: Res<SelectedReplayIndex>,
-    screens: Query<Entity, With<StatsScreen>>,
-    other_modal_scrims: Query<(), (With<ModalScrim>, Without<StatsScreen>)>,
-) {
-    let button_clicked = requests.read().count() > 0;
-    if !keys.just_pressed(KeyCode::KeyS) && !button_clicked {
-        return;
-    }
-    if let Ok(entity) = screens.single() {
-        commands.entity(entity).despawn();
-    } else {
-        if !other_modal_scrims.is_empty() {
-            return;
-        }
-        spawn_stats_screen(
-            &mut commands,
-            &stats.0,
-            progress.as_deref().map(|p| &p.0),
-            time_attack.as_deref(),
-            font_res.as_deref(),
-            &latest_replay.0.replays,
-            selected_index.0,
-        );
-    }
-}
-
-/// Click handler for the modal's "Done" button — despawns the overlay
-/// the same way the `S` accelerator does.
-fn handle_stats_close_button(
-    mut commands: Commands,
-    close_buttons: Query<&Interaction, (With<StatsCloseButton>, Changed<Interaction>)>,
-    screens: Query<Entity, With<StatsScreen>>,
-) {
-    if !close_buttons.iter().any(|i| *i == Interaction::Pressed) {
-        return;
-    }
-    for entity in &screens {
-        commands.entity(entity).despawn();
-    }
-}
-
-fn spawn_stats_screen(
-    commands: &mut Commands,
+/// Builds the Stats tab body inside the You hub's card: the 8-cell
+/// grid plus per-mode bests, progression, weekly goals, unlocks, and
+/// the optional Time Attack line. The replay selector lives on its own
+/// hub tab now — see [`spawn_replays_body`]. All markers
+/// (`StatsCell`, `PerModeBestsRow`, `StatsScrollable`) are unchanged.
+pub(crate) fn spawn_stats_body(
+    card: &mut ChildSpawnerCommands,
     stats: &StatsSnapshot,
     progress: Option<&PlayerProgress>,
     time_attack: Option<&TimeAttackResource>,
     font_res: Option<&FontResource>,
-    replays: &[Replay],
-    selected_index: usize,
 ) {
     // --- primary stat cells ---
     // First-launch zero-state: when no games have been played yet, render
@@ -756,9 +699,7 @@ fn spawn_stats_screen(
         ..default()
     };
 
-    let scrim = spawn_modal(commands, StatsScreen, Z_MODAL_PANEL, |card| {
-        spawn_modal_header(card, "Statistics", font_res);
-
+    {
         // Scrollable body — the Stats panel renders an 8-cell grid plus
         // multiple sections (per-mode bests, progression, weekly goals,
         // unlocks, optional Time Attack, latest replay caption) and
@@ -935,7 +876,45 @@ fn spawn_stats_screen(
                     TextColor(STATE_WARNING),
                 ));
             }
+        });
+    }
+}
 
+/// Builds the Replays tab body inside the You hub's card: the
+/// Prev/Next selector, detail line, and the Watch / Copy-share-link
+/// actions (buttons live in the body now — the hub owns the single
+/// Done in the action row). All markers (`ReplayPrevButton`,
+/// `ReplayNextButton`, `ReplaySelectorCaption`, `ReplaySelectorDetail`,
+/// `WatchReplayButton`, `CopyShareLinkButton`) are unchanged, so the
+/// selector/watch/copy systems keep working.
+pub(crate) fn spawn_replays_body(
+    card: &mut ChildSpawnerCommands,
+    replays: &[Replay],
+    selected_index: usize,
+    font_res: Option<&FontResource>,
+) {
+    let font_handle = font_res.map(|f| f.0.clone()).unwrap_or_default();
+    let font_row = TextFont {
+        font: font_handle,
+        font_size: TYPE_BODY,
+        ..default()
+    };
+
+    {
+        // Scrollable body — mirrors the other hub tabs so short
+        // windows can still reach every control.
+        card.spawn((
+            StatsScrollable,
+            ScrollPosition::default(),
+            Node {
+                flex_direction: FlexDirection::Column,
+                row_gap: VAL_SPACE_3,
+                max_height: Val::Vh(70.0),
+                overflow: Overflow::scroll_y(),
+                ..default()
+            },
+        ))
+        .with_children(|body| {
             // --- Replay selector ---
             // Prev / Next chips step through the full replay history;
             // `repaint_replay_selector_caption` and
@@ -1019,12 +998,21 @@ fn spawn_stats_screen(
             ));
         });
 
-        spawn_modal_actions(card, |actions| {
-            // The Watch Replay button is always rendered so the
-            // affordance is discoverable from a fresh install. When no
-            // replay exists, the click handler surfaces a clear
-            // "No replay recorded yet" toast rather than silently
-            // doing nothing.
+        // Tab-local actions. The Watch Replay button is always
+        // rendered so the affordance is discoverable from a fresh
+        // install — with no replay, its click handler surfaces a
+        // "No replay recorded yet" toast rather than silently doing
+        // nothing. Same policy for Copy share link (toast explains
+        // when no shareable upload exists).
+        card.spawn(Node {
+            flex_direction: FlexDirection::Row,
+            flex_wrap: FlexWrap::Wrap,
+            column_gap: VAL_SPACE_2,
+            row_gap: VAL_SPACE_2,
+            margin: UiRect::top(VAL_SPACE_2),
+            ..default()
+        })
+        .with_children(|actions| {
             spawn_modal_button(
                 actions,
                 WatchReplayButton,
@@ -1033,11 +1021,6 @@ fn spawn_stats_screen(
                 ButtonVariant::Secondary,
                 font_res,
             );
-            // Copy share link only renders when a sharable URL is in
-            // hand. The button is intentionally absent (rather than
-            // disabled) when no upload has happened yet — keeps the
-            // action bar free of dead controls in the local-only and
-            // first-launch cases.
             spawn_modal_button(
                 actions,
                 CopyShareLinkButton,
@@ -1046,18 +1029,8 @@ fn spawn_stats_screen(
                 ButtonVariant::Secondary,
                 font_res,
             );
-            spawn_modal_button(
-                actions,
-                StatsCloseButton,
-                "Done",
-                Some("S"),
-                ButtonVariant::Primary,
-                font_res,
-            );
         });
-    });
-    // Stats is read-only — opt into click-outside-to-dismiss.
-    commands.entity(scrim).insert(ScrimDismissible);
+    }
 }
 
 /// Spawn one row of the "Per-mode bests" section: the mode label on the
@@ -1290,6 +1263,7 @@ mod tests {
         // ProgressResource is an optional dependency for the stats screen;
         // include it so toggle tests exercise the progression panel.
         app.add_plugins(crate::progress_plugin::ProgressPlugin::headless());
+        app.add_plugins(crate::you_hub_plugin::YouHubPlugin);
         app.update();
         app
     }
@@ -1832,6 +1806,25 @@ mod tests {
     // Prev/Next replay selector spawn-site tests
     // -----------------------------------------------------------------------
 
+    /// Opens the You hub via `S`, then switches to the Replays tab
+    /// (where the selector lives since Phase E) and settles the rebuild.
+    fn open_replays_tab(app: &mut App) {
+        app.world_mut()
+            .resource_mut::<ButtonInput<KeyCode>>()
+            .press(KeyCode::KeyS);
+        app.update();
+        // MinimalPlugins never clears input, so the sticky `just_pressed`
+        // would keep re-requesting the Stats tab every frame.
+        app.world_mut()
+            .resource_mut::<ButtonInput<KeyCode>>()
+            .clear();
+        app.world_mut()
+            .resource_mut::<crate::you_hub_plugin::ActiveYouTab>()
+            .0 = crate::you_hub_plugin::YouTab::Replays;
+        app.update();
+        app.update();
+    }
+
     #[test]
     fn selector_row_spawns_when_stats_screen_opens() {
         let mut app = headless_app();
@@ -1840,10 +1833,7 @@ mod tests {
             let mut hist = app.world_mut().resource_mut::<ReplayHistoryResource>();
             hist.0.replays.push(make_test_replay(90, None));
         }
-        app.world_mut()
-            .resource_mut::<ButtonInput<KeyCode>>()
-            .press(KeyCode::KeyS);
-        app.update();
+        open_replays_tab(&mut app);
 
         let prev = app
             .world_mut()
@@ -1878,10 +1868,7 @@ mod tests {
             let mut hist = app.world_mut().resource_mut::<ReplayHistoryResource>();
             hist.0.replays.push(make_test_replay(120, None));
         }
-        app.world_mut()
-            .resource_mut::<ButtonInput<KeyCode>>()
-            .press(KeyCode::KeyS);
-        app.update();
+        open_replays_tab(&mut app);
 
         let mut q = app
             .world_mut()
@@ -1901,10 +1888,7 @@ mod tests {
             let mut hist = app.world_mut().resource_mut::<ReplayHistoryResource>();
             hist.0.replays.push(make_test_replay(65, None)); // 65s → "1:05"
         }
-        app.world_mut()
-            .resource_mut::<ButtonInput<KeyCode>>()
-            .press(KeyCode::KeyS);
-        app.update();
+        open_replays_tab(&mut app);
 
         let mut q = app
             .world_mut()

solitaire_engine/src/theme_store_plugin.rs

@@ -118,6 +118,9 @@ impl Plugin for ThemeStorePlugin {
             .init_resource::<CatalogTask>()
             .init_resource::<InstallTask>()
             .init_resource::<StoreBaseUrl>()
+            // Esc-close reads keyboard input; register defensively so
+            // the plugin works under MinimalPlugins in tests.
+            .init_resource::<ButtonInput<KeyCode>>()
             .add_message::<ThemeStoreOpenRequestEvent>()
             .add_message::<InfoToastEvent>()
             .add_message::<WarningToastEvent>()
@@ -344,19 +347,23 @@ fn poll_install_task(
     );
 }
 
-/// Despawns the store modal when Close is pressed.
+/// Despawns the store modal when Close is pressed or on Esc (Phase C
+/// dismissal audit). The store only ever stacks over Settings and
+/// nothing stacks over the store, so it owns Esc whenever it is open
+/// (Settings' own Esc handler is gated on being topmost).
 fn handle_close_button(
     interactions: Query<&Interaction, (Changed<Interaction>, With<ThemeStoreCloseButton>)>,
+    keys: Res<ButtonInput<KeyCode>>,
     screens: Query<Entity, With<ThemeStoreScreen>>,
     mut commands: Commands,
 ) {
-    for interaction in &interactions {
-        if *interaction != Interaction::Pressed {
-            continue;
-        }
-        for entity in &screens {
-            commands.entity(entity).despawn();
-        }
+    let clicked = interactions.iter().any(|i| *i == Interaction::Pressed);
+    let esc = keys.just_pressed(KeyCode::Escape) && !screens.is_empty();
+    if !clicked && !esc {
+        return;
+    }
+    for entity in &screens {
+        commands.entity(entity).despawn();
     }
 }
 

solitaire_engine/src/ui_modal.rs

@@ -60,9 +60,9 @@ use crate::settings_plugin::SettingsResource;
 use crate::ui_theme::{
     ACCENT_PRIMARY, ACCENT_PRIMARY_HOVER, ACCENT_SECONDARY, BG_BASE, BG_ELEVATED, BG_ELEVATED_HI,
     BG_ELEVATED_PRESSED, BG_ELEVATED_TOP, BORDER_STRONG, BORDER_SUBTLE, HighContrastBorder,
-    MOTION_MODAL_SECS, RADIUS_LG, RADIUS_MD, SCRIM, TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY_LG,
-    TYPE_CAPTION, TYPE_HEADLINE, VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4, VAL_SPACE_5,
-    scaled_duration,
+    MOTION_MODAL_SECS, RADIUS_LG, RADIUS_MD, RADIUS_SM, SCRIM, STATE_SUCCESS, TEXT_PRIMARY,
+    TEXT_SECONDARY, TYPE_BODY_LG, TYPE_CAPTION, TYPE_HEADLINE, VAL_SPACE_2, VAL_SPACE_3,
+    VAL_SPACE_4, VAL_SPACE_5, scaled_duration,
 };
 
 // ---------------------------------------------------------------------------
@@ -402,6 +402,46 @@ pub fn spawn_modal_button<M: Component>(
         });
 }
 
+/// One tab chip for a tabbed modal (Settings, the You hub). The active
+/// chip is filled + bright with a success-green border; inactive chips
+/// are quiet outlines. `marker` is the plugin's click-target component
+/// carrying which tab the chip selects.
+pub fn spawn_tab_chip<M: Component>(
+    parent: &mut ChildSpawnerCommands,
+    marker: M,
+    label: &str,
+    active: bool,
+    font_res: Option<&FontResource>,
+) {
+    let font = TextFont {
+        font: font_res.map(|f| f.0.clone()).unwrap_or_default(),
+        font_size: TYPE_CAPTION,
+        ..default()
+    };
+    parent
+        .spawn((
+            marker,
+            Button,
+            Node {
+                padding: UiRect::axes(VAL_SPACE_3, VAL_SPACE_2),
+                justify_content: JustifyContent::Center,
+                border: UiRect::all(Val::Px(1.0)),
+                border_radius: BorderRadius::all(Val::Px(RADIUS_SM)),
+                ..default()
+            },
+            BackgroundColor(if active { BG_ELEVATED_HI } else { BG_BASE }),
+            BorderColor::all(if active { STATE_SUCCESS } else { BORDER_SUBTLE }),
+            HighContrastBorder::with_default(if active { STATE_SUCCESS } else { BORDER_SUBTLE }),
+        ))
+        .with_children(|b| {
+            b.spawn((
+                Text::new(label),
+                font,
+                TextColor(if active { TEXT_PRIMARY } else { TEXT_SECONDARY }),
+            ));
+        });
+}
+
 // ---------------------------------------------------------------------------
 // Generic touch-scroll helper
 // ---------------------------------------------------------------------------

solitaire_engine/src/win_summary_plugin.rs

@@ -5,6 +5,13 @@
 //! started), a full-screen modal is spawned showing score, time, XP, and a
 //! "Play Again" button that fires `NewGameRequestEvent` and closes the modal.
 //!
+//! # Phase G (docs/ui-redesign-2026-07.md) — action hierarchy
+//! The modal leads with actions: **Play Again** (primary, Enter
+//! accelerator), then **Watch Replay** and **Share Replay** (shared
+//! `stats_plugin` markers, so the global handlers there act on the
+//! just-won replay), with the score/time/XP recap reading quietly
+//! below.
+//!
 //! # Task #47 — Win fanfare screen-shake
 //! When `GameWonEvent` fires, `ScreenShakeResource` is set. A system offsets
 //! the `Camera2d` `Transform` each frame with a decaying oscillation until the
@@ -23,7 +30,7 @@ use crate::game_plugin::GameMutation;
 use crate::progress_plugin::ProgressResource;
 use crate::resources::GameStateResource;
 use crate::settings_plugin::SettingsResource;
-use crate::stats_plugin::{StatsResource, StatsUpdate};
+use crate::stats_plugin::{CopyShareLinkButton, StatsResource, StatsUpdate, WatchReplayButton};
 use crate::ui_modal::ModalScrim;
 use crate::ui_theme::{
     ACCENT_PRIMARY, BG_BASE, BG_ELEVATED, MOTION_SCORE_BREAKDOWN_FADE_SECS,
@@ -163,12 +170,15 @@ pub struct SessionAchievements {
 #[derive(Component, Debug)]
 pub struct WinSummaryOverlay;
 
-/// Marker on the "Play Again" / "Watch Replay" buttons inside the win-summary modal.
+/// Marker on the "Play Again" button inside the win-summary modal.
+///
+/// Watch Replay and Share Replay carry the shared
+/// [`WatchReplayButton`] / [`CopyShareLinkButton`] markers from
+/// `stats_plugin`, so the global handlers there drive them (both act
+/// on [`crate::stats_plugin::SelectedReplayIndex`], which snaps to the
+/// just-won replay on every `GameWonEvent`).
 #[derive(Component, Debug)]
-enum WinSummaryButton {
-    PlayAgain,
-    WatchReplay,
-}
+struct WinSummaryPlayAgainButton;
 
 /// Marker for one row of the win-modal score-breakdown reveal.
 ///
@@ -230,6 +240,7 @@ impl Plugin for WinSummaryPlugin {
                     collect_session_achievements,
                     spawn_win_summary_after_delay,
                     handle_win_summary_buttons,
+                    close_overlay_on_watch_replay,
                     handle_win_summary_keyboard,
                     apply_screen_shake,
                     reveal_score_breakdown,
@@ -604,50 +615,48 @@ fn spawn_win_summary_after_delay(
     }
 }
 
-/// Handles "Play Again" and "Watch Replay" in the win-summary modal.
-/// Handles "Play Again" and "Watch Replay" in the win-summary modal.
+/// Handles "Play Again" in the win-summary modal: collapses the
+/// overlay and requests a fresh deal. `NewGameRequestEvent::default()`
+/// reuses the current game's `GameMode`, and `handle_new_game` reads
+/// the deal options (draw mode, difficulty) from `Settings` — so the
+/// rematch is "same mode + same options" in one tap.
 fn handle_win_summary_buttons(
-    interaction_query: Query<(&Interaction, &WinSummaryButton), Changed<Interaction>>,
+    interaction_query: Query<&Interaction, (Changed<Interaction>, With<WinSummaryPlayAgainButton>)>,
     overlays: Query<Entity, With<WinSummaryOverlay>>,
     mut commands: Commands,
     mut new_game: MessageWriter<NewGameRequestEvent>,
-    mut toast: MessageWriter<InfoToastEvent>,
-    history: Option<Res<crate::stats_plugin::ReplayHistoryResource>>,
-    mut playback: Option<ResMut<crate::replay_playback::ReplayPlaybackState>>,
 ) {
-    // Collect all pressed buttons first to avoid moving `playback` inside the loop.
-    let pressed: Vec<&WinSummaryButton> = interaction_query
-        .iter()
-        .filter(|(i, _)| **i == Interaction::Pressed)
-        .map(|(_, b)| b)
-        .collect();
+    if !interaction_query.iter().any(|i| *i == Interaction::Pressed) {
+        return;
+    }
+    for entity in &overlays {
+        commands.entity(entity).despawn();
+    }
+    new_game.write(NewGameRequestEvent::default());
+}
 
-    for button in pressed {
-        match button {
-            WinSummaryButton::PlayAgain => {
-                for entity in &overlays {
-                    commands.entity(entity).despawn();
-                }
-                new_game.write(NewGameRequestEvent::default());
-            }
-            WinSummaryButton::WatchReplay => {
-                let latest = history.as_ref().and_then(|h| h.0.replays.last()).cloned();
-                match (latest, playback.as_mut()) {
-                    (Some(replay), Some(pb)) => {
-                        for entity in &overlays {
-                            commands.entity(entity).despawn();
-                        }
-                        crate::replay_playback::start_replay_playback(&mut commands, pb, replay);
-                    }
-                    (Some(_), None) => {
-                        toast.write(InfoToastEvent("Replay playback not available".to_string()));
-                    }
-                    (None, _) => {
-                        toast.write(InfoToastEvent("No replay saved yet".to_string()));
-                    }
-                }
-            }
-        }
+/// Collapses the win-summary overlay when its "Watch Replay" button is
+/// pressed, so playback (started by `stats_plugin`'s global
+/// [`WatchReplayButton`] handler reacting to the same press) is not
+/// hidden behind the celebration scrim. No-op while the overlay is
+/// closed — the Replays-tab copy of the button manages its own modal.
+///
+/// "Share Replay" ([`CopyShareLinkButton`]) deliberately does NOT
+/// close the overlay: the player stays on the celebration while the
+/// copy-feedback toast confirms the link.
+fn close_overlay_on_watch_replay(
+    buttons: Query<&Interaction, (Changed<Interaction>, With<WatchReplayButton>)>,
+    overlays: Query<Entity, With<WinSummaryOverlay>>,
+    mut commands: Commands,
+) {
+    if overlays.is_empty() {
+        return;
+    }
+    if !buttons.iter().any(|i| *i == Interaction::Pressed) {
+        return;
+    }
+    for entity in &overlays {
+        commands.entity(entity).despawn();
     }
 }
 
@@ -818,18 +827,68 @@ fn spawn_overlay(
                     ));
                 }
 
-                // Score breakdown reveal — replaces the previous single
-                // "Score:" line with a per-component multi-row layout.
+                // --- Action hierarchy (Phase G) ---
+                // Play Again is the hero action; the two replay
+                // actions sit under it; the stats recap reads quietly
+                // below all three. Rematch is one tap.
+
+                // Play Again (primary, full row)
+                card.spawn((
+                    WinSummaryPlayAgainButton,
+                    Button,
+                    Node {
+                        padding: UiRect::axes(Val::Px(20.0), VAL_SPACE_3),
+                        justify_content: JustifyContent::Center,
+                        align_self: AlignSelf::Stretch,
+                        border_radius: BorderRadius::all(Val::Px(RADIUS_MD)),
+                        margin: UiRect::top(VAL_SPACE_2),
+                        ..default()
+                    },
+                    BackgroundColor(ACCENT_PRIMARY),
+                ))
+                .with_children(|b| {
+                    b.spawn((
+                        Text::new("Play Again  \u{21B5}"),
+                        TextFont {
+                            font_size: TYPE_BODY_LG,
+                            ..default()
+                        },
+                        TextColor(BG_BASE),
+                    ));
+                });
+
+                // Watch Replay + Share Replay (secondary, side by side).
+                // Both reuse the global stats_plugin handlers, which
+                // target the just-won replay (`SelectedReplayIndex`
+                // snaps to 0 on every win). Each is always rendered —
+                // with no replay / no share URL the handler explains
+                // itself in a toast instead of silently doing nothing.
+                card.spawn(Node {
+                    flex_direction: FlexDirection::Row,
+                    justify_content: JustifyContent::Center,
+                    column_gap: VAL_SPACE_3,
+                    ..default()
+                })
+                .with_children(|row| {
+                    spawn_replay_action(row, WatchReplayButton, "Watch Replay");
+                    spawn_replay_action(row, CopyShareLinkButton, "Share Replay");
+                });
+
+                // --- Quiet stats recap, below the actions ---
+
+                // Score breakdown reveal — per-component multi-row
+                // layout with the staggered fade-in.
                 spawn_score_breakdown(card, &breakdown, anim_speed);
 
-                // Time
+                // Time (demoted to body/secondary — part of the quiet
+                // recap, not the celebration headline)
                 card.spawn((
                     Text::new(format!("Time: {}", format_win_time(pending.time_seconds))),
                     TextFont {
-                        font_size: TYPE_HEADLINE,
+                        font_size: TYPE_BODY_LG,
                         ..default()
                     },
-                    TextColor(TEXT_PRIMARY),
+                    TextColor(TEXT_SECONDARY),
                 ));
 
                 // XP total
@@ -859,68 +918,40 @@ fn spawn_overlay(
                 if !session.names.is_empty() {
                     spawn_achievements_section(card, &session.names);
                 }
-
-                // Button row: Watch Replay + Play Again side by side.
-                card.spawn(Node {
-                    flex_direction: FlexDirection::Row,
-                    justify_content: JustifyContent::Center,
-                    column_gap: VAL_SPACE_3,
-                    margin: UiRect::top(VAL_SPACE_2),
-                    ..default()
-                })
-                .with_children(|row| {
-                    // Watch Replay (secondary style)
-                    row.spawn((
-                        WinSummaryButton::WatchReplay,
-                        Button,
-                        Node {
-                            padding: UiRect::axes(Val::Px(20.0), VAL_SPACE_3),
-                            justify_content: JustifyContent::Center,
-                            border_radius: BorderRadius::all(Val::Px(RADIUS_MD)),
-                            border: UiRect::all(Val::Px(1.0)),
-                            ..default()
-                        },
-                        BackgroundColor(Color::NONE),
-                        BorderColor::all(ACCENT_PRIMARY),
-                    ))
-                    .with_children(|b| {
-                        b.spawn((
-                            Text::new("Watch Replay"),
-                            TextFont {
-                                font_size: TYPE_BODY_LG,
-                                ..default()
-                            },
-                            TextColor(ACCENT_PRIMARY),
-                        ));
-                    });
-
-                    // Play Again (primary style)
-                    row.spawn((
-                        WinSummaryButton::PlayAgain,
-                        Button,
-                        Node {
-                            padding: UiRect::axes(Val::Px(20.0), VAL_SPACE_3),
-                            justify_content: JustifyContent::Center,
-                            border_radius: BorderRadius::all(Val::Px(RADIUS_MD)),
-                            ..default()
-                        },
-                        BackgroundColor(ACCENT_PRIMARY),
-                    ))
-                    .with_children(|b| {
-                        b.spawn((
-                            Text::new("Play Again  \u{21B5}"),
-                            TextFont {
-                                font_size: TYPE_BODY_LG,
-                                ..default()
-                            },
-                            TextColor(BG_BASE),
-                        ));
-                    });
-                });
             });
         });
 }
 
+/// Spawns one secondary (outline-style) replay action button in the
+/// win modal's replay row. `marker` is the shared `stats_plugin`
+/// click-target component (`WatchReplayButton` / `CopyShareLinkButton`)
+/// whose global handler reacts to the press.
+fn spawn_replay_action<M: Component>(row: &mut ChildSpawnerCommands, marker: M, label: &str) {
+    row.spawn((
+        marker,
+        Button,
+        Node {
+            padding: UiRect::axes(Val::Px(20.0), VAL_SPACE_3),
+            justify_content: JustifyContent::Center,
+            border_radius: BorderRadius::all(Val::Px(RADIUS_MD)),
+            border: UiRect::all(Val::Px(1.0)),
+            ..default()
+        },
+        BackgroundColor(Color::NONE),
+        BorderColor::all(ACCENT_PRIMARY),
+    ))
+    .with_children(|b| {
+        b.spawn((
+            Text::new(label.to_string()),
+            TextFont {
+                font_size: TYPE_BODY_LG,
+                ..default()
+            },
+            TextColor(ACCENT_PRIMARY),
+        ));
+    });
+}
+
 /// Maximum number of achievement names shown explicitly in the win modal before
 /// the overflow "...and N more" line is shown instead.
 const MAX_ACHIEVEMENTS_SHOWN: usize = 3;
@@ -1863,4 +1894,134 @@ mod tests {
         assert_eq!(stagger, 0.0);
         assert_eq!(fade, 0.0);
     }
+
+    // -----------------------------------------------------------------------
+    // Phase G — action hierarchy
+    // -----------------------------------------------------------------------
+
+    /// Like [`make_app`] but with `TimePlugin` disabled and a manual
+    /// `Time` resource, so tests can step the win-summary delay timer
+    /// deterministically via `Time::advance_by` (the real clock's
+    /// microsecond deltas would never reach the 0.5 s threshold).
+    fn make_app_manual_clock() -> App {
+        use bevy::time::TimePlugin;
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins.build().disable::<TimePlugin>())
+            .add_plugins(WinSummaryPlugin)
+            .insert_resource(StatsResource(StatsSnapshot::default()))
+            .insert_resource(GameStateResource(GameState::new(
+                0,
+                solitaire_core::DrawStockConfig::DrawOne,
+            )))
+            .insert_resource(ProgressResource(PlayerProgress::default()));
+        app.init_resource::<Time>();
+        app.update();
+        app
+    }
+
+    /// Drives the real spawn path: fire `GameWonEvent`, then advance
+    /// `Time` past the 0.5 s celebration delay so
+    /// `spawn_win_summary_after_delay` spawns the overlay.
+    fn open_win_overlay(app: &mut App) {
+        app.world_mut().write_message(GameWonEvent {
+            score: 1200,
+            time_seconds: 90,
+        });
+        app.update();
+        {
+            let mut time = app.world_mut().resource_mut::<Time>();
+            time.advance_by(std::time::Duration::from_secs_f32(
+                WIN_SUMMARY_DELAY_SECS + 0.1,
+            ));
+        }
+        app.update();
+        // One more frame so the deferred spawn commands flush.
+        app.update();
+    }
+
+    fn overlay_count(app: &mut App) -> usize {
+        app.world_mut()
+            .query::<&WinSummaryOverlay>()
+            .iter(app.world())
+            .count()
+    }
+
+    fn button_entity<M: Component>(app: &mut App) -> Entity {
+        let entities: Vec<Entity> = app
+            .world_mut()
+            .query_filtered::<Entity, With<M>>()
+            .iter(app.world())
+            .collect();
+        assert_eq!(entities.len(), 1, "expected exactly one button");
+        entities[0]
+    }
+
+    /// The win modal must render all three Phase G actions: the
+    /// primary Play Again plus the shared Watch/Share replay buttons.
+    #[test]
+    fn win_modal_renders_play_again_watch_and_share_actions() {
+        let mut app = make_app_manual_clock();
+        open_win_overlay(&mut app);
+        assert_eq!(overlay_count(&mut app), 1, "overlay must spawn after delay");
+        button_entity::<WinSummaryPlayAgainButton>(&mut app);
+        button_entity::<WatchReplayButton>(&mut app);
+        button_entity::<CopyShareLinkButton>(&mut app);
+    }
+
+    /// Play Again collapses the overlay and requests a fresh deal.
+    #[test]
+    fn play_again_press_closes_overlay_and_requests_new_game() {
+        use bevy::ecs::message::Messages;
+
+        let mut app = make_app_manual_clock();
+        open_win_overlay(&mut app);
+        let button = button_entity::<WinSummaryPlayAgainButton>(&mut app);
+        app.world_mut()
+            .entity_mut(button)
+            .insert(Interaction::Pressed);
+        app.update();
+
+        assert_eq!(overlay_count(&mut app), 0, "Play Again must close overlay");
+        let events = app.world().resource::<Messages<NewGameRequestEvent>>();
+        assert!(
+            !events.is_empty(),
+            "Play Again must write NewGameRequestEvent"
+        );
+    }
+
+    /// Watch Replay collapses the overlay so playback (driven by the
+    /// global `stats_plugin` handler on the same press) is visible.
+    #[test]
+    fn watch_replay_press_closes_the_overlay() {
+        let mut app = make_app_manual_clock();
+        open_win_overlay(&mut app);
+        let button = button_entity::<WatchReplayButton>(&mut app);
+        app.world_mut()
+            .entity_mut(button)
+            .insert(Interaction::Pressed);
+        app.update();
+        assert_eq!(
+            overlay_count(&mut app),
+            0,
+            "Watch Replay must close the celebration overlay"
+        );
+    }
+
+    /// Share Replay leaves the overlay open — the player stays on the
+    /// celebration while the copy-feedback toast confirms the link.
+    #[test]
+    fn share_replay_press_keeps_the_overlay_open() {
+        let mut app = make_app_manual_clock();
+        open_win_overlay(&mut app);
+        let button = button_entity::<CopyShareLinkButton>(&mut app);
+        app.world_mut()
+            .entity_mut(button)
+            .insert(Interaction::Pressed);
+        app.update();
+        assert_eq!(
+            overlay_count(&mut app),
+            1,
+            "Share Replay must not close the overlay"
+        );
+    }
 }

solitaire_engine/src/you_hub_plugin.rs

@@ -0,0 +1,486 @@
+//! The "You" hub — Profile · Stats · Achievements · Replays folded
+//! into one tabbed modal (Phase E of `docs/ui-redesign-2026-07.md`).
+//!
+//! The four screens were previously standalone modals reached one at a
+//! time through the HUD popover. The hub owns the modal shell (header,
+//! tab chips via the shared [`spawn_tab_chip`] widget, a single Done
+//! button); each tab's content is a body builder that lives in its
+//! original plugin (`spawn_profile_body`, `spawn_stats_body`,
+//! `spawn_achievements_body`, `spawn_replays_body`) so every marker
+//! component and per-row update system keeps working unchanged.
+//!
+//! Legacy screen markers (`ProfileScreen`, `StatsScreen`,
+//! `AchievementsScreen`) are inserted on the hub scrim while their tab
+//! is active, so existing queries and tests keep their meaning.
+//!
+//! Open paths: `ToggleProfileRequestEvent` / `ToggleStatsRequestEvent`
+//! / `ToggleAchievementsRequestEvent` (HUD popover) and the P / S / A
+//! accelerators — each opens the hub pre-selected to its tab, toggles
+//! the hub closed when its tab is already showing, or switches tabs
+//! when a different tab is showing. Esc, Done, and scrim-click close.
+
+use bevy::ecs::system::SystemParam;
+use bevy::prelude::*;
+
+use solitaire_data::StatsSnapshot;
+
+use crate::achievement_plugin::{AchievementsResource, AchievementsScreen};
+use crate::events::{
+    ToggleAchievementsRequestEvent, ToggleProfileRequestEvent, ToggleStatsRequestEvent,
+};
+use crate::font_plugin::FontResource;
+use crate::profile_plugin::{AvatarResource, ProfileScreen};
+use crate::progress_plugin::ProgressResource;
+use crate::resources::SyncStatusResource;
+use crate::settings_plugin::SettingsResource;
+use crate::stats_plugin::{ReplayHistoryResource, SelectedReplayIndex, StatsResource, StatsScreen};
+use crate::time_attack_plugin::TimeAttackResource;
+use crate::ui_focus::FocusRow;
+use crate::ui_modal::{
+    ButtonVariant, ModalScrim, ScrimDismissible, spawn_modal, spawn_modal_actions,
+    spawn_modal_button, spawn_modal_header, spawn_tab_chip,
+};
+use crate::ui_theme::{VAL_SPACE_2, VAL_SPACE_3, Z_MODAL_PANEL};
+
+/// Which tab of the You hub is showing.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum YouTab {
+    #[default]
+    Profile,
+    Stats,
+    Achievements,
+    Replays,
+}
+
+impl YouTab {
+    /// Every tab, in display order.
+    pub const ALL: [Self; 4] = [
+        Self::Profile,
+        Self::Stats,
+        Self::Achievements,
+        Self::Replays,
+    ];
+
+    /// Chip label.
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Profile => "Profile",
+            Self::Stats => "Stats",
+            Self::Achievements => "Awards",
+            Self::Replays => "Replays",
+        }
+    }
+}
+
+/// The active hub tab. Session-only; reopening returns to the last tab
+/// unless an open request names a different one.
+#[derive(Resource, Debug, Default)]
+pub struct ActiveYouTab(pub YouTab);
+
+/// Marker on the hub modal's scrim root.
+#[derive(Component)]
+pub struct YouHubScreen;
+
+/// Per-chip tab selector button.
+#[derive(Component, Debug)]
+struct YouHubTabButton(YouTab);
+
+/// Marker on the hub's Done button.
+#[derive(Component)]
+struct YouHubCloseButton;
+
+/// Read-only bundle of everything the tab bodies render from. Split
+/// out as a [`SystemParam`] because the open + rebuild systems both
+/// need the full set and Bevy caps systems at 16 parameters.
+#[derive(SystemParam)]
+struct YouHubContext<'w> {
+    settings: Option<Res<'w, SettingsResource>>,
+    sync_status: Option<Res<'w, SyncStatusResource>>,
+    progress: Option<Res<'w, ProgressResource>>,
+    achievements: Option<Res<'w, AchievementsResource>>,
+    stats: Option<Res<'w, StatsResource>>,
+    avatar: Option<Res<'w, AvatarResource>>,
+    time_attack: Option<Res<'w, TimeAttackResource>>,
+    replay_history: Option<Res<'w, ReplayHistoryResource>>,
+    selected_replay: Option<Res<'w, SelectedReplayIndex>>,
+    font_res: Option<Res<'w, FontResource>>,
+}
+
+/// Bevy plugin owning the You hub lifecycle. Requires the profile,
+/// stats, and achievement plugins for live data; degrades to empty tab
+/// bodies without them (headless tests).
+pub struct YouHubPlugin;
+
+impl Plugin for YouHubPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<ActiveYouTab>()
+            .add_message::<ToggleProfileRequestEvent>()
+            .add_message::<ToggleStatsRequestEvent>()
+            .add_message::<ToggleAchievementsRequestEvent>()
+            .add_systems(
+                Update,
+                // Chained: a toggle/chip press must be observed before
+                // the rebuild, and the rebuild before close — total
+                // order prevents double-spawns within one frame.
+                (
+                    open_or_toggle_you_hub,
+                    handle_tab_buttons,
+                    rebuild_on_tab_change,
+                    handle_close_button,
+                )
+                    .chain(),
+            );
+    }
+}
+
+/// Maps this frame's toggle events + accelerator keys to a requested
+/// tab, mirroring the semantics the three standalone screens had.
+fn requested_tab(
+    profile_events: &mut MessageReader<ToggleProfileRequestEvent>,
+    stats_events: &mut MessageReader<ToggleStatsRequestEvent>,
+    achievements_events: &mut MessageReader<ToggleAchievementsRequestEvent>,
+    keys: &ButtonInput<KeyCode>,
+) -> Option<YouTab> {
+    let profile = profile_events.read().count() > 0 || keys.just_pressed(KeyCode::KeyP);
+    let stats = stats_events.read().count() > 0 || keys.just_pressed(KeyCode::KeyS);
+    let achievements = achievements_events.read().count() > 0 || keys.just_pressed(KeyCode::KeyA);
+    if profile {
+        Some(YouTab::Profile)
+    } else if stats {
+        Some(YouTab::Stats)
+    } else if achievements {
+        Some(YouTab::Achievements)
+    } else {
+        None
+    }
+}
+
+/// Opens the hub on the requested tab, switches tabs when it's already
+/// open on a different one, toggles it closed on a same-tab request or
+/// Esc.
+#[allow(clippy::too_many_arguments)]
+fn open_or_toggle_you_hub(
+    mut commands: Commands,
+    keys: Res<ButtonInput<KeyCode>>,
+    mut profile_events: MessageReader<ToggleProfileRequestEvent>,
+    mut stats_events: MessageReader<ToggleStatsRequestEvent>,
+    mut achievements_events: MessageReader<ToggleAchievementsRequestEvent>,
+    screens: Query<Entity, With<YouHubScreen>>,
+    other_modal_scrims: Query<(), (With<ModalScrim>, Without<YouHubScreen>)>,
+    mut active: ResMut<ActiveYouTab>,
+    ctx: YouHubContext,
+) {
+    let requested = requested_tab(
+        &mut profile_events,
+        &mut stats_events,
+        &mut achievements_events,
+        &keys,
+    );
+    let open = !screens.is_empty();
+
+    if open {
+        // Esc closes the topmost modal — the hub, when it's showing.
+        if keys.just_pressed(KeyCode::Escape) {
+            for entity in &screens {
+                commands.entity(entity).despawn();
+            }
+            return;
+        }
+        match requested {
+            Some(tab) if tab == active.0 => {
+                // Same-tab request toggles closed (P opens Profile,
+                // P again closes — parity with the old screens).
+                for entity in &screens {
+                    commands.entity(entity).despawn();
+                }
+            }
+            Some(tab) => {
+                // Different tab: switch in place. The rebuild system
+                // (next in the chain) observes the change.
+                active.0 = tab;
+            }
+            None => {}
+        }
+        return;
+    }
+
+    let Some(tab) = requested else { return };
+    if !other_modal_scrims.is_empty() {
+        return; // Another modal is already visible (§14.2).
+    }
+    if active.0 != tab {
+        // Written before the spawn; the rebuild system also runs this
+        // frame but sees no live hub (the spawn below is deferred), so
+        // no double-spawn.
+        active.0 = tab;
+    }
+    spawn_you_hub(&mut commands, tab, &ctx);
+}
+
+/// Switches the active tab when a chip is pressed.
+fn handle_tab_buttons(
+    interactions: Query<(&Interaction, &YouHubTabButton), Changed<Interaction>>,
+    mut active: ResMut<ActiveYouTab>,
+) {
+    for (interaction, chip) in &interactions {
+        if *interaction != Interaction::Pressed {
+            continue;
+        }
+        if active.0 != chip.0 {
+            active.0 = chip.0;
+        }
+    }
+}
+
+/// Rebuilds the open hub when [`ActiveYouTab`] changes.
+fn rebuild_on_tab_change(
+    active: Res<ActiveYouTab>,
+    screens: Query<Entity, With<YouHubScreen>>,
+    mut commands: Commands,
+    ctx: YouHubContext,
+) {
+    if !active.is_changed() || active.is_added() {
+        return;
+    }
+    if screens.is_empty() {
+        return;
+    }
+    for entity in &screens {
+        commands.entity(entity).despawn();
+    }
+    spawn_you_hub(&mut commands, active.0, &ctx);
+}
+
+/// Despawns the hub when Done is pressed.
+fn handle_close_button(
+    interactions: Query<&Interaction, (Changed<Interaction>, With<YouHubCloseButton>)>,
+    screens: Query<Entity, With<YouHubScreen>>,
+    mut commands: Commands,
+) {
+    for interaction in &interactions {
+        if *interaction != Interaction::Pressed {
+            continue;
+        }
+        for entity in &screens {
+            commands.entity(entity).despawn();
+        }
+    }
+}
+
+/// Spawns the hub modal showing `tab`, and stamps the scrim with the
+/// tab's legacy screen marker so pre-hub queries keep working.
+fn spawn_you_hub(commands: &mut Commands, tab: YouTab, ctx: &YouHubContext) {
+    let font_res = ctx.font_res.as_deref();
+    let scrim = spawn_modal(commands, YouHubScreen, Z_MODAL_PANEL, |card| {
+        spawn_modal_header(card, "You", font_res);
+
+        // Tab chips — shared widget with the Settings panel.
+        card.spawn((
+            FocusRow,
+            Node {
+                flex_direction: FlexDirection::Row,
+                flex_wrap: FlexWrap::Wrap,
+                column_gap: VAL_SPACE_2,
+                row_gap: VAL_SPACE_2,
+                margin: UiRect::bottom(VAL_SPACE_3),
+                ..default()
+            },
+        ))
+        .with_children(|row| {
+            for chip_tab in YouTab::ALL {
+                spawn_tab_chip(
+                    row,
+                    YouHubTabButton(chip_tab),
+                    chip_tab.label(),
+                    chip_tab == tab,
+                    font_res,
+                );
+            }
+        });
+
+        match tab {
+            YouTab::Profile => crate::profile_plugin::spawn_profile_body(
+                card,
+                ctx.settings.as_deref(),
+                ctx.sync_status.as_deref(),
+                ctx.progress.as_deref(),
+                ctx.achievements.as_deref(),
+                ctx.stats.as_deref(),
+                font_res,
+                ctx.avatar.as_deref(),
+            ),
+            YouTab::Stats => {
+                let default_stats = StatsSnapshot::default();
+                crate::stats_plugin::spawn_stats_body(
+                    card,
+                    ctx.stats.as_deref().map_or(&default_stats, |s| &s.0),
+                    ctx.progress.as_deref().map(|p| &p.0),
+                    ctx.time_attack.as_deref(),
+                    font_res,
+                );
+            }
+            YouTab::Achievements => crate::achievement_plugin::spawn_achievements_body(
+                card,
+                ctx.achievements
+                    .as_deref()
+                    .map_or(&[][..], |a| a.0.as_slice()),
+                font_res,
+            ),
+            YouTab::Replays => crate::stats_plugin::spawn_replays_body(
+                card,
+                ctx.replay_history
+                    .as_deref()
+                    .map_or(&[][..], |h| h.0.replays.as_slice()),
+                ctx.selected_replay.as_deref().map_or(0, |s| s.0),
+                font_res,
+            ),
+        }
+
+        spawn_modal_actions(card, |actions| {
+            spawn_modal_button(
+                actions,
+                YouHubCloseButton,
+                "Done",
+                None,
+                ButtonVariant::Primary,
+                font_res,
+            );
+        });
+    });
+    let mut scrim_commands = commands.entity(scrim);
+    scrim_commands.insert(ScrimDismissible);
+    // Legacy markers: pre-hub code and tests query these.
+    match tab {
+        YouTab::Profile => {
+            scrim_commands.insert(ProfileScreen);
+        }
+        YouTab::Stats | YouTab::Replays => {
+            scrim_commands.insert(StatsScreen);
+        }
+        YouTab::Achievements => {
+            scrim_commands.insert(AchievementsScreen);
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn headless_app() -> App {
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins).add_plugins(YouHubPlugin);
+        app.init_resource::<ButtonInput<KeyCode>>();
+        app.update();
+        app
+    }
+
+    fn hub_count(app: &mut App) -> usize {
+        app.world_mut()
+            .query::<&YouHubScreen>()
+            .iter(app.world())
+            .count()
+    }
+
+    /// Each Toggle*RequestEvent opens the hub pre-selected to its tab,
+    /// stamped with the tab's legacy screen marker.
+    #[test]
+    fn toggle_events_open_hub_on_their_tab() {
+        use bevy::ecs::message::Messages;
+
+        let mut app = headless_app();
+        app.world_mut()
+            .resource_mut::<Messages<ToggleStatsRequestEvent>>()
+            .write(ToggleStatsRequestEvent);
+        app.update();
+        app.update();
+
+        assert_eq!(hub_count(&mut app), 1, "stats request must open the hub");
+        assert_eq!(app.world().resource::<ActiveYouTab>().0, YouTab::Stats);
+        assert_eq!(
+            app.world_mut()
+                .query::<&StatsScreen>()
+                .iter(app.world())
+                .count(),
+            1,
+            "legacy StatsScreen marker must ride the hub scrim"
+        );
+
+        // A different tab's request switches in place — still one hub.
+        app.world_mut()
+            .resource_mut::<Messages<ToggleAchievementsRequestEvent>>()
+            .write(ToggleAchievementsRequestEvent);
+        app.update();
+        app.update();
+        assert_eq!(hub_count(&mut app), 1, "tab switch must not stack hubs");
+        assert_eq!(
+            app.world().resource::<ActiveYouTab>().0,
+            YouTab::Achievements
+        );
+        assert_eq!(
+            app.world_mut()
+                .query::<&AchievementsScreen>()
+                .iter(app.world())
+                .count(),
+            1
+        );
+
+        // Same-tab request toggles the hub closed.
+        app.world_mut()
+            .resource_mut::<Messages<ToggleAchievementsRequestEvent>>()
+            .write(ToggleAchievementsRequestEvent);
+        app.update();
+        app.update();
+        assert_eq!(hub_count(&mut app), 0, "same-tab request must close");
+    }
+
+    /// Chip-driven tab switches rebuild the single hub with the new
+    /// tab's body (Profile scrollable swaps for the Stats one).
+    #[test]
+    fn tab_switch_swaps_bodies_without_stacking() {
+        use crate::profile_plugin::ProfileScrollable;
+        use crate::stats_plugin::StatsScrollable;
+        use bevy::ecs::message::Messages;
+
+        let mut app = headless_app();
+        app.world_mut()
+            .resource_mut::<Messages<ToggleProfileRequestEvent>>()
+            .write(ToggleProfileRequestEvent);
+        app.update();
+        app.update();
+        assert_eq!(
+            app.world_mut()
+                .query::<&ProfileScrollable>()
+                .iter(app.world())
+                .count(),
+            1,
+            "profile body must spawn on the Profile tab"
+        );
+
+        app.world_mut().resource_mut::<ActiveYouTab>().0 = YouTab::Stats;
+        app.update();
+        app.update();
+
+        assert_eq!(hub_count(&mut app), 1, "rebuild must not stack scrims");
+        assert_eq!(
+            app.world_mut()
+                .query::<&ProfileScrollable>()
+                .iter(app.world())
+                .count(),
+            0,
+            "profile body must despawn when leaving the tab"
+        );
+        assert_eq!(
+            app.world_mut()
+                .query::<&StatsScrollable>()
+                .iter(app.world())
+                .count(),
+            1,
+            "stats body must spawn on the Stats tab"
+        );
+    }
+}

solitaire_server/web/pkg/canvas.js

@@ -1649,62 +1649,62 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 61918, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 62028, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hd94d76233321402f);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 7361, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 7471, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h26ff63c654218354);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Array<any>"), NamedExternref("ResizeObserver")], shim_idx: 7364, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Array<any>"), NamedExternref("ResizeObserver")], shim_idx: 7474, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hfc779804ccb0943e);
             return ret;
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Array<any>")], shim_idx: 7361, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Array<any>")], shim_idx: 7471, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h26ff63c654218354_3);
             return ret;
         },
         __wbindgen_cast_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 7361, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 7471, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h26ff63c654218354_4);
             return ret;
         },
         __wbindgen_cast_0000000000000006: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("FocusEvent")], shim_idx: 7361, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("FocusEvent")], shim_idx: 7471, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h26ff63c654218354_5);
             return ret;
         },
         __wbindgen_cast_0000000000000007: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("KeyboardEvent")], shim_idx: 7361, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("KeyboardEvent")], shim_idx: 7471, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h26ff63c654218354_6);
             return ret;
         },
         __wbindgen_cast_0000000000000008: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("PageTransitionEvent")], shim_idx: 7361, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("PageTransitionEvent")], shim_idx: 7471, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h26ff63c654218354_7);
             return ret;
         },
         __wbindgen_cast_0000000000000009: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("PointerEvent")], shim_idx: 7361, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("PointerEvent")], shim_idx: 7471, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h26ff63c654218354_8);
             return ret;
         },
         __wbindgen_cast_000000000000000a: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("WheelEvent")], shim_idx: 7361, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("WheelEvent")], shim_idx: 7471, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h26ff63c654218354_9);
             return ret;
         },
         __wbindgen_cast_000000000000000b: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Option(NamedExternref("Blob"))], shim_idx: 7362, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Option(NamedExternref("Blob"))], shim_idx: 7472, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hfd77696cd35180b1);
             return ret;
         },
         __wbindgen_cast_000000000000000c: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 7363, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 7473, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hebcd362fbbe0fc8c);
             return ret;
         },