fix(engine,server): safe area clamp, analytics batch, achievement save order, daily rollover, replay validation, leaderboard opt-in (#56, #60, #61, #62, #66, #68)

- #66: Clamp safe-area insets to 25% of window height with warn!() on excess
- #68: Move fire_flush outside per-event loop in analytics (batch flush once)
- #56: Persist progress before marking reward_granted to prevent XP loss on crash
- #60: Add DateRolloverTimer + check_date_rollover system for midnight seed refresh
- #62: Add validate_header() in replay upload with mode/draw_mode allowlists
- #61: Restore two-query leaderboard opt-in check (SELECT then UPDATE); original
       queries already in .sqlx cache; EXISTS variant would require sqlx prepare

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Cargo.lock

@@ -7087,6 +7087,7 @@ dependencies = [
  "serde_json",
  "solitaire_core",
  "wasm-bindgen",
+ "web-sys",
 ]
 
 [[package]]

solitaire_app/src/lib.rs

@@ -364,17 +364,12 @@ fn android_main(android_app: bevy::android::android_activity::AndroidApp) {
 /// unchanged. If the data directory is unavailable, the wrapper silently
 /// falls through — the default hook handles output either way.
 fn install_crash_log_hook() {
-    let crash_log_path = settings_file_path().and_then(|p| {
-        p.parent()
-            .map(|parent| parent.join("crash.log"))
-    });
+    let crash_log_path =
+        settings_file_path().and_then(|p| p.parent().map(|parent| parent.join("crash.log")));
     let default_hook = std::panic::take_hook();
     std::panic::set_hook(Box::new(move |info| {
         if let Some(path) = crash_log_path.as_ref()
-            && let Ok(mut file) = OpenOptions::new()
-                .create(true)
-                .append(true)
-                .open(path)
+            && let Ok(mut file) = OpenOptions::new().create(true).append(true).open(path)
         {
             // Plain unix-seconds timestamp keeps the format trivially
             // parseable and avoids pulling in chrono just for this.

solitaire_assetgen/src/bin/gen_art.rs

@@ -30,7 +30,9 @@ fn suit_color(suit: u8) -> [u8; 4] {
 }
 
 fn rank_str(rank: u8) -> &'static str {
-    ["A","2","3","4","5","6","7","8","9","10","J","Q","K"][rank as usize]
+    [
+        "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K",
+    ][rank as usize]
 }
 
 // ---------------------------------------------------------------------------
@@ -86,13 +88,15 @@ impl Canvas {
     }
 
     fn set(&mut self, x: i32, y: i32, c: [u8; 4]) {
-        if x < 0 || y < 0 || x >= W as i32 || y >= H as i32 { return; }
+        if x < 0 || y < 0 || x >= W as i32 || y >= H as i32 {
+            return;
+        }
         let i = (y as u32 * W + x as u32) as usize * 4;
         let a = c[3] as f32 / 255.0;
         if a >= 0.99 {
             self.data[i..i + 4].copy_from_slice(&c);
         } else if a > 0.01 {
-            self.data[i]     = (self.data[i]     as f32 * (1.0 - a) + c[0] as f32 * a) as u8;
+            self.data[i] = (self.data[i] as f32 * (1.0 - a) + c[0] as f32 * a) as u8;
             self.data[i + 1] = (self.data[i + 1] as f32 * (1.0 - a) + c[1] as f32 * a) as u8;
             self.data[i + 2] = (self.data[i + 2] as f32 * (1.0 - a) + c[2] as f32 * a) as u8;
             self.data[i + 3] = 255;
@@ -172,27 +176,36 @@ fn draw_heart(cv: &mut Canvas, cx: f32, cy: f32, sz: f32, c: [u8; 4]) {
     let oy = cy - sz * 0.04;
     cv.circle(cx - sz * 0.22, oy, r, c);
     cv.circle(cx + sz * 0.22, oy, r, c);
-    cv.triangle([
-        (cx - sz * 0.52, oy + r * 0.4),
-        (cx + sz * 0.52, oy + r * 0.4),
-        (cx, cy + sz * 0.52),
-    ], c);
+    cv.triangle(
+        [
+            (cx - sz * 0.52, oy + r * 0.4),
+            (cx + sz * 0.52, oy + r * 0.4),
+            (cx, cy + sz * 0.52),
+        ],
+        c,
+    );
 }
 
 fn draw_spade(cv: &mut Canvas, cx: f32, cy: f32, sz: f32, c: [u8; 4]) {
-    cv.triangle([
-        (cx, cy - sz * 0.52),
-        (cx - sz * 0.52, cy + sz * 0.1),
-        (cx + sz * 0.52, cy + sz * 0.1),
-    ], c);
+    cv.triangle(
+        [
+            (cx, cy - sz * 0.52),
+            (cx - sz * 0.52, cy + sz * 0.1),
+            (cx + sz * 0.52, cy + sz * 0.1),
+        ],
+        c,
+    );
     cv.circle(cx - sz * 0.22, cy + sz * 0.06, sz * 0.3, c);
     cv.circle(cx + sz * 0.22, cy + sz * 0.06, sz * 0.3, c);
     // stem + base
-    cv.triangle([
-        (cx, cy + sz * 0.12),
-        (cx - sz * 0.13, cy + sz * 0.5),
-        (cx + sz * 0.13, cy + sz * 0.5),
-    ], c);
+    cv.triangle(
+        [
+            (cx, cy + sz * 0.12),
+            (cx - sz * 0.13, cy + sz * 0.5),
+            (cx + sz * 0.13, cy + sz * 0.5),
+        ],
+        c,
+    );
     cv.fill_rect(
         (cx - sz * 0.26) as i32,
         (cy + sz * 0.43) as i32,
@@ -231,7 +244,15 @@ fn draw_club(cv: &mut Canvas, cx: f32, cy: f32, sz: f32, c: [u8; 4]) {
 // Text rendering via ab_glyph
 // ---------------------------------------------------------------------------
 
-fn draw_text(cv: &mut Canvas, font: &FontRef<'_>, text: &str, px: f32, left: f32, top: f32, c: [u8; 4]) {
+fn draw_text(
+    cv: &mut Canvas,
+    font: &FontRef<'_>,
+    text: &str,
+    px: f32,
+    left: f32,
+    top: f32,
+    c: [u8; 4],
+) {
     let scale = PxScale::from(px);
     let baseline = top + font.as_scaled(scale).ascent();
     let mut x = left;
@@ -278,12 +299,63 @@ fn pip_positions(rank: u8) -> &'static [(f32, f32)] {
         1 => &[(0.5, 0.2), (0.5, 0.8)],
         2 => &[(0.5, 0.12), (0.5, 0.5), (0.5, 0.88)],
         3 => &[(0.25, 0.18), (0.75, 0.18), (0.25, 0.82), (0.75, 0.82)],
-        4 => &[(0.25, 0.18), (0.75, 0.18), (0.5, 0.5), (0.25, 0.82), (0.75, 0.82)],
-        5 => &[(0.25, 0.12), (0.75, 0.12), (0.25, 0.5), (0.75, 0.5), (0.25, 0.88), (0.75, 0.88)],
-        6 => &[(0.25, 0.1), (0.75, 0.1), (0.5, 0.31), (0.25, 0.5), (0.75, 0.5), (0.25, 0.9), (0.75, 0.9)],
-        7 => &[(0.25, 0.1), (0.75, 0.1), (0.5, 0.28), (0.25, 0.48), (0.75, 0.48), (0.5, 0.70), (0.25, 0.9), (0.75, 0.9)],
-        8 => &[(0.25, 0.1), (0.75, 0.1), (0.25, 0.35), (0.75, 0.35), (0.5, 0.5), (0.25, 0.65), (0.75, 0.65), (0.25, 0.9), (0.75, 0.9)],
-        9 => &[(0.25, 0.09), (0.75, 0.09), (0.5, 0.27), (0.25, 0.44), (0.75, 0.44), (0.25, 0.56), (0.75, 0.56), (0.5, 0.73), (0.25, 0.91), (0.75, 0.91)],
+        4 => &[
+            (0.25, 0.18),
+            (0.75, 0.18),
+            (0.5, 0.5),
+            (0.25, 0.82),
+            (0.75, 0.82),
+        ],
+        5 => &[
+            (0.25, 0.12),
+            (0.75, 0.12),
+            (0.25, 0.5),
+            (0.75, 0.5),
+            (0.25, 0.88),
+            (0.75, 0.88),
+        ],
+        6 => &[
+            (0.25, 0.1),
+            (0.75, 0.1),
+            (0.5, 0.31),
+            (0.25, 0.5),
+            (0.75, 0.5),
+            (0.25, 0.9),
+            (0.75, 0.9),
+        ],
+        7 => &[
+            (0.25, 0.1),
+            (0.75, 0.1),
+            (0.5, 0.28),
+            (0.25, 0.48),
+            (0.75, 0.48),
+            (0.5, 0.70),
+            (0.25, 0.9),
+            (0.75, 0.9),
+        ],
+        8 => &[
+            (0.25, 0.1),
+            (0.75, 0.1),
+            (0.25, 0.35),
+            (0.75, 0.35),
+            (0.5, 0.5),
+            (0.25, 0.65),
+            (0.75, 0.65),
+            (0.25, 0.9),
+            (0.75, 0.9),
+        ],
+        9 => &[
+            (0.25, 0.09),
+            (0.75, 0.09),
+            (0.5, 0.27),
+            (0.25, 0.44),
+            (0.75, 0.44),
+            (0.25, 0.56),
+            (0.75, 0.56),
+            (0.5, 0.73),
+            (0.25, 0.91),
+            (0.75, 0.91),
+        ],
         _ => &[],
     }
 }
@@ -327,14 +399,28 @@ fn make_card_face(font: &FontRef<'_>, rank: u8, suit: u8) -> Canvas {
     let tl_x = 6.0f32;
     let tl_y = 5.0f32;
     draw_text(&mut cv, font, rank_s, rank_px, tl_x, tl_y, sc);
-    draw_suit(&mut cv, tl_x + suit_sz * 0.62, tl_y + rh + 2.0 + suit_sz * 0.75, suit_sz, suit, sc);
+    draw_suit(
+        &mut cv,
+        tl_x + suit_sz * 0.62,
+        tl_y + rh + 2.0 + suit_sz * 0.75,
+        suit_sz,
+        suit,
+        sc,
+    );
 
     // Bottom-right corner (right-aligned rank, suit above it)
     let br_rx = W as f32 - 6.0;
     let br_by = H as f32 - 5.0;
     let br_ty = br_by - corner_h;
     draw_text(&mut cv, font, rank_s, rank_px, br_rx - rw, br_ty, sc);
-    draw_suit(&mut cv, br_rx - suit_sz * 0.62, br_ty + rh + 2.0 + suit_sz * 0.75, suit_sz, suit, sc);
+    draw_suit(
+        &mut cv,
+        br_rx - suit_sz * 0.62,
+        br_ty + rh + 2.0 + suit_sz * 0.75,
+        suit_sz,
+        suit,
+        sc,
+    );
 
     // Center content
     if rank >= 10 {
@@ -346,7 +432,14 @@ fn make_card_face(font: &FontRef<'_>, rank: u8, suit: u8) -> Canvas {
         let big_y = H as f32 * 0.28;
         draw_text(&mut cv, font, rank_s, big_px, big_x, big_y, sc);
         let sym_sz = 22.0f32;
-        draw_suit(&mut cv, W as f32 * 0.5, big_y + big_h + sym_sz * 1.0, sym_sz, suit, sc);
+        draw_suit(
+            &mut cv,
+            W as f32 * 0.5,
+            big_y + big_h + sym_sz * 1.0,
+            sym_sz,
+            suit,
+            sc,
+        );
     } else {
         // Pip cards
         let pip_sz = if rank == 0 {
@@ -375,15 +468,17 @@ fn save_card_png(path: &Path, cv: &Canvas) {
 }
 
 fn save_png_wh(path: &Path, data: &[u8], w: u32, h: u32) {
-    let file = File::create(path)
-        .unwrap_or_else(|e| panic!("cannot create {}: {e}", path.display()));
+    let file =
+        File::create(path).unwrap_or_else(|e| panic!("cannot create {}: {e}", path.display()));
     let mut bw = BufWriter::new(file);
     let mut enc = png::Encoder::new(&mut bw, w, h);
     enc.set_color(png::ColorType::Rgba);
     enc.set_depth(png::BitDepth::Eight);
-    let mut writer = enc.write_header()
+    let mut writer = enc
+        .write_header()
         .unwrap_or_else(|e| panic!("png header error for {}: {e}", path.display()));
-    writer.write_image_data(data)
+    writer
+        .write_image_data(data)
         .unwrap_or_else(|e| panic!("png data error for {}: {e}", path.display()));
 }
 
@@ -401,8 +496,18 @@ fn make_back_0() -> Canvas {
 
     // 2-pixel border
     let bw = 4i32;
-    for x in 0..W as i32 { for t in 0..bw { cv.set(x, t, LIGHT); cv.set(x, H as i32 - 1 - t, LIGHT); } }
-    for y in 0..H as i32 { for t in 0..bw { cv.set(t, y, LIGHT); cv.set(W as i32 - 1 - t, y, LIGHT); } }
+    for x in 0..W as i32 {
+        for t in 0..bw {
+            cv.set(x, t, LIGHT);
+            cv.set(x, H as i32 - 1 - t, LIGHT);
+        }
+    }
+    for y in 0..H as i32 {
+        for t in 0..bw {
+            cv.set(t, y, LIGHT);
+            cv.set(W as i32 - 1 - t, y, LIGHT);
+        }
+    }
 
     // Diamond grid: row/col spacing
     let gx = 18.0f32;
@@ -455,8 +560,18 @@ fn make_back_1() -> Canvas {
 
     // 4-pixel border
     let bw = 4i32;
-    for x in 0..W as i32 { for t in 0..bw { cv.set(x, t, BORDER); cv.set(x, H as i32 - 1 - t, BORDER); } }
-    for y in 0..H as i32 { for t in 0..bw { cv.set(t, y, BORDER); cv.set(W as i32 - 1 - t, y, BORDER); } }
+    for x in 0..W as i32 {
+        for t in 0..bw {
+            cv.set(x, t, BORDER);
+            cv.set(x, H as i32 - 1 - t, BORDER);
+        }
+    }
+    for y in 0..H as i32 {
+        for t in 0..bw {
+            cv.set(t, y, BORDER);
+            cv.set(W as i32 - 1 - t, y, BORDER);
+        }
+    }
     cv
 }
 
@@ -470,8 +585,18 @@ fn make_back_2() -> Canvas {
 
     // 4-pixel border
     let bw = 4i32;
-    for x in 0..W as i32 { for t in 0..bw { cv.set(x, t, BORDER); cv.set(x, H as i32 - 1 - t, BORDER); } }
-    for y in 0..H as i32 { for t in 0..bw { cv.set(t, y, BORDER); cv.set(W as i32 - 1 - t, y, BORDER); } }
+    for x in 0..W as i32 {
+        for t in 0..bw {
+            cv.set(x, t, BORDER);
+            cv.set(x, H as i32 - 1 - t, BORDER);
+        }
+    }
+    for y in 0..H as i32 {
+        for t in 0..bw {
+            cv.set(t, y, BORDER);
+            cv.set(W as i32 - 1 - t, y, BORDER);
+        }
+    }
 
     // Circle array (staggered rows)
     let gx = 16.0f32;
@@ -513,8 +638,18 @@ fn make_back_3() -> Canvas {
 
     // 4-pixel border
     let bw = 4i32;
-    for x in 0..W as i32 { for t in 0..bw { cv.set(x, t, BORDER); cv.set(x, H as i32 - 1 - t, BORDER); } }
-    for y in 0..H as i32 { for t in 0..bw { cv.set(t, y, BORDER); cv.set(W as i32 - 1 - t, y, BORDER); } }
+    for x in 0..W as i32 {
+        for t in 0..bw {
+            cv.set(x, t, BORDER);
+            cv.set(x, H as i32 - 1 - t, BORDER);
+        }
+    }
+    for y in 0..H as i32 {
+        for t in 0..bw {
+            cv.set(t, y, BORDER);
+            cv.set(W as i32 - 1 - t, y, BORDER);
+        }
+    }
     cv
 }
 
@@ -543,8 +678,18 @@ fn make_back_4() -> Canvas {
 
     // 4-pixel border
     let bw = 4i32;
-    for x in 0..W as i32 { for t in 0..bw { cv.set(x, t, BORDER); cv.set(x, H as i32 - 1 - t, BORDER); } }
-    for y in 0..H as i32 { for t in 0..bw { cv.set(t, y, BORDER); cv.set(W as i32 - 1 - t, y, BORDER); } }
+    for x in 0..W as i32 {
+        for t in 0..bw {
+            cv.set(x, t, BORDER);
+            cv.set(x, H as i32 - 1 - t, BORDER);
+        }
+    }
+    for y in 0..H as i32 {
+        for t in 0..bw {
+            cv.set(t, y, BORDER);
+            cv.set(W as i32 - 1 - t, y, BORDER);
+        }
+    }
     cv
 }
 
@@ -574,7 +719,7 @@ fn make_bg_0() -> Canvas {
 fn make_bg_1() -> Canvas {
     const BASE: [u8; 4] = [0x40, 0x2D, 0x1A, 0xFF];
     const PLANK_EDGE: [u8; 4] = [0x28, 0x1A, 0x0A, 0xFF]; // dark plank separator
-    const GRAIN: [u8; 4] = [0x55, 0x3D, 0x28, 0xA0];      // lighter grain streak
+    const GRAIN: [u8; 4] = [0x55, 0x3D, 0x28, 0xA0]; // lighter grain streak
     let mut cv = Canvas::new();
     cv.fill_solid(BASE);
     // Horizontal plank edges every 24 px
@@ -585,7 +730,9 @@ fn make_bg_1() -> Canvas {
     // Grain lines within each plank (every 3 px between plank edges)
     for y in (0..H as i32).step_by(3) {
         // Skip the plank edge rows
-        if y % 24 < 2 { continue; }
+        if y % 24 < 2 {
+            continue;
+        }
         cv.hline(y, 2, W as i32 - 3, GRAIN);
     }
     cv
@@ -608,7 +755,11 @@ fn make_bg_2() -> Canvas {
         let mut cx = gx * 0.5 + offset;
         while cx < W as f32 {
             // alternate bright/dim to give depth
-            let c = if (row + (cx / gx) as u32).is_multiple_of(3) { STAR_A } else { STAR_B };
+            let c = if (row + (cx / gx) as u32).is_multiple_of(3) {
+                STAR_A
+            } else {
+                STAR_B
+            };
             cv.circle(cx, cy, 1.0, c);
             cx += gx;
         }
@@ -679,12 +830,13 @@ fn main() {
     let font_path = root.join("assets/fonts/main.ttf");
     let font_bytes = std::fs::read(&font_path)
         .unwrap_or_else(|e| panic!("failed to read {}: {e}", font_path.display()));
-    let font = FontRef::try_from_slice(&font_bytes)
-        .expect("failed to parse assets/fonts/main.ttf");
+    let font = FontRef::try_from_slice(&font_bytes).expect("failed to parse assets/fonts/main.ttf");
 
     // 52 card faces
     let suits = ["c", "d", "h", "s"];
-    let ranks = ["a","2","3","4","5","6","7","8","9","10","j","q","k"];
+    let ranks = [
+        "a", "2", "3", "4", "5", "6", "7", "8", "9", "10", "j", "q", "k",
+    ];
     for suit in 0u8..4 {
         for rank in 0u8..13 {
             let cv = make_card_face(&font, rank, suit);
@@ -696,14 +848,32 @@ fn main() {
     }
 
     // Card backs
-    for (i, cv) in [make_back_0(), make_back_1(), make_back_2(), make_back_3(), make_back_4()].iter().enumerate() {
+    for (i, cv) in [
+        make_back_0(),
+        make_back_1(),
+        make_back_2(),
+        make_back_3(),
+        make_back_4(),
+    ]
+    .iter()
+    .enumerate()
+    {
         let path = root.join(format!("assets/cards/backs/back_{i}.png"));
         save_card_png(&path, cv);
         println!("wrote {}", path.display());
     }
 
     // Backgrounds
-    for (i, cv) in [make_bg_0(), make_bg_1(), make_bg_2(), make_bg_3(), make_bg_4()].iter().enumerate() {
+    for (i, cv) in [
+        make_bg_0(),
+        make_bg_1(),
+        make_bg_2(),
+        make_bg_3(),
+        make_bg_4(),
+    ]
+    .iter()
+    .enumerate()
+    {
         let path = root.join(format!("assets/backgrounds/bg_{i}.png"));
         save_card_png(&path, cv);
         println!("wrote {}", path.display());

solitaire_assetgen/src/bin/gen_difficulty_seeds.rs

@@ -20,15 +20,15 @@
 //!   --help      Print this message
 
 use solitaire_core::game_state::DrawMode;
-use solitaire_core::solver::{try_solve, SolverConfig, SolverResult};
+use solitaire_core::solver::{SolverConfig, SolverResult, try_solve};
 
 // Budget boundaries defining each tier. A seed belongs to the lowest tier
 // whose budget proves it Winnable.
 const BUDGETS: &[(&str, u64, usize)] = &[
-    ("Easy",        1_000,   1_000),
-    ("Medium",      5_000,   5_000),
-    ("Hard",       25_000,  25_000),
-    ("Expert",    100_000, 100_000),
+    ("Easy", 1_000, 1_000),
+    ("Medium", 5_000, 5_000),
+    ("Hard", 25_000, 25_000),
+    ("Expert", 100_000, 100_000),
     ("Grandmaster", 200_000, 200_000),
 ];
 
@@ -86,7 +86,11 @@ fn main() {
     );
     eprintln!(
         "  Tiers: {}",
-        BUDGETS.iter().map(|(n, _, _)| *n).collect::<Vec<_>>().join(", ")
+        BUDGETS
+            .iter()
+            .map(|(n, _, _)| *n)
+            .collect::<Vec<_>>()
+            .join(", ")
     );
 
     while buckets.iter().any(|b| b.len() < per_tier) {
@@ -95,7 +99,10 @@ fn main() {
             if buckets[i].len() >= per_tier {
                 continue;
             }
-            let cfg = SolverConfig { move_budget, state_budget };
+            let cfg = SolverConfig {
+                move_budget,
+                state_budget,
+            };
             match try_solve(seed, draw_mode, &cfg) {
                 SolverResult::Winnable => {
                     buckets[i].push(seed);
@@ -123,7 +130,9 @@ fn main() {
         seed = seed.wrapping_add(1);
     }
 
-    eprintln!("\nDone ({tried} seeds examined). Paste the blocks below into difficulty_seeds.rs:\n");
+    eprintln!(
+        "\nDone ({tried} seeds examined). Paste the blocks below into difficulty_seeds.rs:\n"
+    );
 
     let date = current_date();
     for (i, (tier_name, _, _)) in BUDGETS.iter().enumerate() {
@@ -148,7 +157,10 @@ fn main() {
 
 fn parse_u64(s: &str) -> u64 {
     let cleaned = s.replace('_', "");
-    if let Some(hex) = cleaned.strip_prefix("0x").or_else(|| cleaned.strip_prefix("0X")) {
+    if let Some(hex) = cleaned
+        .strip_prefix("0x")
+        .or_else(|| cleaned.strip_prefix("0X"))
+    {
         u64::from_str_radix(hex, 16).unwrap_or_else(|_| {
             eprintln!("error: could not parse '{s}' as a hex u64");
             std::process::exit(1);
@@ -181,7 +193,18 @@ fn current_date() -> String {
     }
     let leap = (y.is_multiple_of(4) && !y.is_multiple_of(100)) || y.is_multiple_of(400);
     let month_days: [u64; 12] = [
-        31, if leap { 29 } else { 28 }, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
+        31,
+        if leap { 29 } else { 28 },
+        31,
+        30,
+        31,
+        30,
+        31,
+        31,
+        30,
+        31,
+        30,
+        31,
     ];
     let mut m = 0usize;
     for &md in &month_days {

solitaire_assetgen/src/bin/gen_seeds.rs

@@ -18,7 +18,7 @@
 //!   --help   Print this message
 
 use solitaire_core::game_state::DrawMode;
-use solitaire_core::solver::{try_solve, SolverConfig, SolverResult};
+use solitaire_core::solver::{SolverConfig, SolverResult, try_solve};
 
 fn main() {
     let mut args = std::env::args().skip(1).peekable();
@@ -45,7 +45,14 @@ fn main() {
                 });
             }
             "--help" | "-h" => {
-                eprintln!("{}", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/bin/gen_seeds.rs")).lines().take(20).collect::<Vec<_>>().join("\n"));
+                eprintln!(
+                    "{}",
+                    include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/bin/gen_seeds.rs"))
+                        .lines()
+                        .take(20)
+                        .collect::<Vec<_>>()
+                        .join("\n")
+                );
                 return;
             }
             other => {
@@ -66,16 +73,11 @@ fn main() {
     let mut tried: u64 = 0;
     let mut seed = start;
 
-    eprintln!(
-        "gen_seeds: finding {count} Winnable seeds from 0x{start:016X} (DrawOne) …"
-    );
+    eprintln!("gen_seeds: finding {count} Winnable seeds from 0x{start:016X} (DrawOne) …");
 
     while found.len() < count {
         tried += 1;
-        if matches!(
-            try_solve(seed, draw_mode, &cfg),
-            SolverResult::Winnable
-        ) {
+        if matches!(try_solve(seed, draw_mode, &cfg), SolverResult::Winnable) {
             found.push(seed);
             eprintln!(
                 "  [{:>3}/{}]  0x{:016X}  ({} tried so far)",
@@ -88,7 +90,9 @@ fn main() {
         seed = seed.wrapping_add(1);
     }
 
-    eprintln!("\nDone. Paste the block below into CHALLENGE_SEEDS in solitaire_data/src/challenge.rs:\n");
+    eprintln!(
+        "\nDone. Paste the block below into CHALLENGE_SEEDS in solitaire_data/src/challenge.rs:\n"
+    );
 
     println!(
         "    // Generated by solitaire_assetgen::gen_seeds \
@@ -111,7 +115,10 @@ fn main() {
 
 fn parse_u64(s: &str) -> u64 {
     let cleaned = s.replace('_', "");
-    if let Some(hex) = cleaned.strip_prefix("0x").or_else(|| cleaned.strip_prefix("0X")) {
+    if let Some(hex) = cleaned
+        .strip_prefix("0x")
+        .or_else(|| cleaned.strip_prefix("0X"))
+    {
         u64::from_str_radix(hex, 16).unwrap_or_else(|_| {
             eprintln!("error: could not parse '{s}' as a hex u64");
             std::process::exit(1);
@@ -144,7 +151,20 @@ fn current_date() -> String {
         y += 1;
     }
     let leap = (y.is_multiple_of(4) && !y.is_multiple_of(100)) || y.is_multiple_of(400);
-    let month_days: [u64; 12] = [31, if leap { 29 } else { 28 }, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    let month_days: [u64; 12] = [
+        31,
+        if leap { 29 } else { 28 },
+        31,
+        30,
+        31,
+        30,
+        31,
+        31,
+        30,
+        31,
+        30,
+        31,
+    ];
     let mut m = 0usize;
     for &md in &month_days {
         if d < md {

solitaire_core/src/achievement.rs

@@ -355,7 +355,11 @@ mod tests {
         ids.sort();
         let len = ids.len();
         ids.dedup();
-        assert_eq!(ids.len(), len, "duplicate achievement ID in ALL_ACHIEVEMENTS");
+        assert_eq!(
+            ids.len(),
+            len,
+            "duplicate achievement ID in ALL_ACHIEVEMENTS"
+        );
     }
 
     #[test]
@@ -422,13 +426,19 @@ mod tests {
         for hour in [22u32, 23, 0, 1, 2] {
             c.wall_clock_hour = Some(hour);
             let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-            assert!(ids.contains(&"night_owl"), "expected night_owl at hour {hour}");
+            assert!(
+                ids.contains(&"night_owl"),
+                "expected night_owl at hour {hour}"
+            );
         }
         // Daytime hours must not trigger.
         for hour in [3u32, 7, 12, 20, 21] {
             c.wall_clock_hour = Some(hour);
             let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-            assert!(!ids.contains(&"night_owl"), "unexpected night_owl at hour {hour}");
+            assert!(
+                !ids.contains(&"night_owl"),
+                "unexpected night_owl at hour {hour}"
+            );
         }
     }
 
@@ -440,13 +450,19 @@ mod tests {
         for hour in [5u32, 6] {
             c.wall_clock_hour = Some(hour);
             let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-            assert!(ids.contains(&"early_bird"), "expected early_bird at hour {hour}");
+            assert!(
+                ids.contains(&"early_bird"),
+                "expected early_bird at hour {hour}"
+            );
         }
         // Outside the window must not trigger.
         for hour in [0u32, 3, 4, 7, 12, 23] {
             c.wall_clock_hour = Some(hour);
             let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-            assert!(!ids.contains(&"early_bird"), "unexpected early_bird at hour {hour}");
+            assert!(
+                !ids.contains(&"early_bird"),
+                "unexpected early_bird at hour {hour}"
+            );
         }
     }
 
@@ -506,7 +522,10 @@ mod tests {
 
     #[test]
     fn achievement_by_id_finds_known_and_returns_none_for_unknown() {
-        assert_eq!(achievement_by_id("first_win").map(|d| d.name), Some("First Win"));
+        assert_eq!(
+            achievement_by_id("first_win").map(|d| d.name),
+            Some("First Win")
+        );
         assert!(achievement_by_id("nonexistent").is_none());
     }
 
@@ -538,7 +557,10 @@ mod tests {
         let mut c = ctx_defaults();
         c.last_win_time_seconds = 179;
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-        assert!(ids.contains(&"speed_demon"), "speed_demon should unlock at 179s");
+        assert!(
+            ids.contains(&"speed_demon"),
+            "speed_demon should unlock at 179s"
+        );
     }
 
     #[test]
@@ -546,7 +568,10 @@ mod tests {
         let mut c = ctx_defaults();
         c.last_win_time_seconds = 181;
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-        assert!(!ids.contains(&"speed_demon"), "speed_demon must not unlock at 181s");
+        assert!(
+            !ids.contains(&"speed_demon"),
+            "speed_demon must not unlock at 181s"
+        );
     }
 
     #[test]
@@ -562,7 +587,10 @@ mod tests {
         let mut c = ctx_defaults();
         c.last_win_time_seconds = 90;
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-        assert!(!ids.contains(&"lightning"), "lightning must not unlock at exactly 90s");
+        assert!(
+            !ids.contains(&"lightning"),
+            "lightning must not unlock at exactly 90s"
+        );
     }
 
     #[test]
@@ -570,7 +598,10 @@ mod tests {
         let mut c = ctx_defaults();
         c.last_win_used_undo = false;
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-        assert!(ids.contains(&"no_undo"), "no_undo should unlock when undo was not used");
+        assert!(
+            ids.contains(&"no_undo"),
+            "no_undo should unlock when undo was not used"
+        );
     }
 
     #[test]
@@ -578,7 +609,10 @@ mod tests {
         let mut c = ctx_defaults();
         c.last_win_used_undo = true;
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-        assert!(!ids.contains(&"no_undo"), "no_undo must not unlock when undo was used");
+        assert!(
+            !ids.contains(&"no_undo"),
+            "no_undo must not unlock when undo was used"
+        );
     }
 
     #[test]
@@ -586,7 +620,10 @@ mod tests {
         let mut c = ctx_defaults();
         c.best_single_score = 5_000;
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-        assert!(ids.contains(&"high_scorer"), "high_scorer should unlock at best_single_score=5000");
+        assert!(
+            ids.contains(&"high_scorer"),
+            "high_scorer should unlock at best_single_score=5000"
+        );
     }
 
     #[test]
@@ -594,7 +631,10 @@ mod tests {
         let mut c = ctx_defaults();
         c.best_single_score = 4_999;
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-        assert!(!ids.contains(&"high_scorer"), "high_scorer must not unlock at best_single_score=4999");
+        assert!(
+            !ids.contains(&"high_scorer"),
+            "high_scorer must not unlock at best_single_score=4999"
+        );
     }
 
     #[test]
@@ -602,7 +642,10 @@ mod tests {
         let mut c = ctx_defaults();
         c.win_streak_current = 3;
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-        assert!(ids.contains(&"on_a_roll"), "on_a_roll should unlock at streak=3");
+        assert!(
+            ids.contains(&"on_a_roll"),
+            "on_a_roll should unlock at streak=3"
+        );
     }
 
     #[test]
@@ -610,7 +653,10 @@ mod tests {
         let mut c = ctx_defaults();
         c.last_win_recycle_count = 3;
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-        assert!(ids.contains(&"comeback"), "comeback should unlock at last_win_recycle_count=3");
+        assert!(
+            ids.contains(&"comeback"),
+            "comeback should unlock at last_win_recycle_count=3"
+        );
     }
 
     #[test]
@@ -631,12 +677,18 @@ mod tests {
         c.win_streak_current = 9;
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
         assert!(!ids.contains(&"unstoppable"));
-        assert!(ids.contains(&"on_a_roll"), "streak 9 must still satisfy on_a_roll");
+        assert!(
+            ids.contains(&"on_a_roll"),
+            "streak 9 must still satisfy on_a_roll"
+        );
 
         c.win_streak_current = 10;
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
         assert!(ids.contains(&"unstoppable"));
-        assert!(ids.contains(&"on_a_roll"), "streak 10 must also satisfy on_a_roll");
+        assert!(
+            ids.contains(&"on_a_roll"),
+            "streak 10 must also satisfy on_a_roll"
+        );
     }
 
     #[test]
@@ -657,12 +709,18 @@ mod tests {
         c.games_played = 499;
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
         assert!(!ids.contains(&"veteran"));
-        assert!(ids.contains(&"century"), "499 games must also satisfy century");
+        assert!(
+            ids.contains(&"century"),
+            "499 games must also satisfy century"
+        );
 
         c.games_played = 500;
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
         assert!(ids.contains(&"veteran"));
-        assert!(ids.contains(&"century"), "500 games must also satisfy century");
+        assert!(
+            ids.contains(&"century"),
+            "500 games must also satisfy century"
+        );
     }
 
     #[test]
@@ -727,7 +785,10 @@ mod tests {
         assert!(ids.contains(&"first_win"), "first_win should unlock");
         assert!(ids.contains(&"on_a_roll"), "on_a_roll should unlock");
         assert!(ids.contains(&"no_undo"), "no_undo should unlock");
-        assert!(ids.len() >= 3, "at least 3 achievements must fire simultaneously");
+        assert!(
+            ids.len() >= 3,
+            "at least 3 achievements must fire simultaneously"
+        );
     }
 
     #[test]
@@ -742,7 +803,10 @@ mod tests {
 
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
         assert!(ids.contains(&"perfectionist"), "perfectionist must unlock");
-        assert!(ids.contains(&"no_undo"), "no_undo must also unlock when perfectionist does");
+        assert!(
+            ids.contains(&"no_undo"),
+            "no_undo must also unlock when perfectionist does"
+        );
     }
 
     #[test]
@@ -778,6 +842,9 @@ mod tests {
         c.last_win_score = 50_000;
 
         let ids: Vec<&str> = check_achievements(&c).iter().map(|d| d.id).collect();
-        assert!(ids.contains(&"perfectionist"), "score far above threshold must pass");
+        assert!(
+            ids.contains(&"perfectionist"),
+            "score far above threshold must pass"
+        );
     }
 }

solitaire_core/src/card.rs

@@ -27,27 +27,37 @@ impl Suit {
 /// Card rank, Ace through King.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum Rank {
-    Ace   = 1,
-    Two   = 2,
+    Ace = 1,
+    Two = 2,
     Three = 3,
-    Four  = 4,
-    Five  = 5,
-    Six   = 6,
+    Four = 4,
+    Five = 5,
+    Six = 6,
     Seven = 7,
     Eight = 8,
-    Nine  = 9,
-    Ten   = 10,
-    Jack  = 11,
+    Nine = 9,
+    Ten = 10,
+    Jack = 11,
     Queen = 12,
-    King  = 13,
+    King = 13,
 }
 
 impl Rank {
     /// All thirteen ranks in ascending order.
     pub const RANKS: [Self; 13] = [
-        Self::Ace, Self::Two, Self::Three, Self::Four, Self::Five,
-        Self::Six, Self::Seven, Self::Eight, Self::Nine, Self::Ten,
-        Self::Jack, Self::Queen, Self::King,
+        Self::Ace,
+        Self::Two,
+        Self::Three,
+        Self::Four,
+        Self::Five,
+        Self::Six,
+        Self::Seven,
+        Self::Eight,
+        Self::Nine,
+        Self::Ten,
+        Self::Jack,
+        Self::Queen,
+        Self::King,
     ];
 
     /// Numeric value: Ace = 1, King = 13.
@@ -57,20 +67,20 @@ impl Rank {
 
     const fn new(n: u8) -> Option<Self> {
         match n {
-            1  => Some(Self::Ace),
-            2  => Some(Self::Two),
-            3  => Some(Self::Three),
-            4  => Some(Self::Four),
-            5  => Some(Self::Five),
-            6  => Some(Self::Six),
-            7  => Some(Self::Seven),
-            8  => Some(Self::Eight),
-            9  => Some(Self::Nine),
+            1 => Some(Self::Ace),
+            2 => Some(Self::Two),
+            3 => Some(Self::Three),
+            4 => Some(Self::Four),
+            5 => Some(Self::Five),
+            6 => Some(Self::Six),
+            7 => Some(Self::Seven),
+            8 => Some(Self::Eight),
+            9 => Some(Self::Nine),
             10 => Some(Self::Ten),
             11 => Some(Self::Jack),
             12 => Some(Self::Queen),
             13 => Some(Self::King),
-            _  => None,
+            _ => None,
         }
     }
 
@@ -147,7 +157,11 @@ mod tests {
     #[test]
     fn suit_red_and_black_are_complementary() {
         for suit in [Suit::Clubs, Suit::Diamonds, Suit::Hearts, Suit::Spades] {
-            assert_ne!(suit.is_red(), suit.is_black(), "{suit:?} must be exactly one of red/black");
+            assert_ne!(
+                suit.is_red(),
+                suit.is_black(),
+                "{suit:?} must be exactly one of red/black"
+            );
         }
         assert!(Suit::Diamonds.is_red() && Suit::Hearts.is_red());
         assert!(Suit::Clubs.is_black() && Suit::Spades.is_black());

solitaire_core/src/deck.rs

@@ -1,13 +1,23 @@
-use rand::{seq::SliceRandom, SeedableRng};
-use rand::rngs::StdRng;
 use crate::card::{Card, Rank, Suit};
 use crate::pile::{Pile, PileType};
+use rand::rngs::StdRng;
+use rand::{SeedableRng, seq::SliceRandom};
 
 const ALL_SUITS: [Suit; 4] = [Suit::Clubs, Suit::Diamonds, Suit::Hearts, Suit::Spades];
 const ALL_RANKS: [Rank; 13] = [
-    Rank::Ace, Rank::Two, Rank::Three, Rank::Four, Rank::Five,
-    Rank::Six, Rank::Seven, Rank::Eight, Rank::Nine, Rank::Ten,
-    Rank::Jack, Rank::Queen, Rank::King,
+    Rank::Ace,
+    Rank::Two,
+    Rank::Three,
+    Rank::Four,
+    Rank::Five,
+    Rank::Six,
+    Rank::Seven,
+    Rank::Eight,
+    Rank::Nine,
+    Rank::Ten,
+    Rank::Jack,
+    Rank::Queen,
+    Rank::King,
 ];
 
 /// A standard 52-card deck.
@@ -23,7 +33,12 @@ impl Deck {
         let mut id = 0u32;
         for &suit in &ALL_SUITS {
             for &rank in &ALL_RANKS {
-                cards.push(Card { id, suit, rank, face_up: false });
+                cards.push(Card {
+                    id,
+                    suit,
+                    rank,
+                    face_up: false,
+                });
                 id += 1;
             }
         }
@@ -50,7 +65,11 @@ impl Default for Deck {
 /// Column `i` contains `i + 1` cards; only the top card is face-up.
 /// Stock receives the remaining 24 cards, all face-down.
 pub fn deal_klondike(deck: Deck) -> ([Pile; 7], Pile) {
-    debug_assert_eq!(deck.cards.len(), 52, "deal_klondike requires a full 52-card deck");
+    debug_assert_eq!(
+        deck.cards.len(),
+        52,
+        "deal_klondike requires a full 52-card deck"
+    );
     let mut tableau: [Pile; 7] = core::array::from_fn(|i| Pile::new(PileType::Tableau(i)));
     // Safety: the debug_assert above documents the 52-card contract; index arithmetic is bounded.
     let mut idx = 0usize;
@@ -102,21 +121,26 @@ mod tests {
 
     #[test]
     fn same_seed_produces_same_order() {
-        let mut d1 = Deck::new(); d1.shuffle(42);
-        let mut d2 = Deck::new(); d2.shuffle(42);
+        let mut d1 = Deck::new();
+        d1.shuffle(42);
+        let mut d2 = Deck::new();
+        d2.shuffle(42);
         assert_eq!(d1.cards, d2.cards);
     }
 
     #[test]
     fn different_seeds_produce_different_orders() {
-        let mut d1 = Deck::new(); d1.shuffle(1);
-        let mut d2 = Deck::new(); d2.shuffle(2);
+        let mut d1 = Deck::new();
+        d1.shuffle(1);
+        let mut d2 = Deck::new();
+        d2.shuffle(2);
         assert_ne!(d1.cards, d2.cards);
     }
 
     #[test]
     fn deal_klondike_correct_tableau_sizes() {
-        let mut deck = Deck::new(); deck.shuffle(0);
+        let mut deck = Deck::new();
+        deck.shuffle(0);
         let (tableau, stock) = deal_klondike(deck);
         for (i, pile) in tableau.iter().enumerate() {
             assert_eq!(pile.cards.len(), i + 1, "col {i} wrong size");
@@ -126,7 +150,8 @@ mod tests {
 
     #[test]
     fn deal_klondike_top_cards_are_face_up() {
-        let mut deck = Deck::new(); deck.shuffle(0);
+        let mut deck = Deck::new();
+        deck.shuffle(0);
         let (tableau, _) = deal_klondike(deck);
         for pile in &tableau {
             assert!(pile.cards.last().unwrap().face_up);
@@ -135,7 +160,8 @@ mod tests {
 
     #[test]
     fn deal_klondike_non_top_cards_are_face_down() {
-        let mut deck = Deck::new(); deck.shuffle(0);
+        let mut deck = Deck::new();
+        deck.shuffle(0);
         let (tableau, _) = deal_klondike(deck);
         for pile in &tableau {
             for card in &pile.cards[..pile.cards.len().saturating_sub(1)] {
@@ -146,17 +172,21 @@ mod tests {
 
     #[test]
     fn deal_klondike_stock_is_face_down() {
-        let mut deck = Deck::new(); deck.shuffle(0);
+        let mut deck = Deck::new();
+        deck.shuffle(0);
         let (_, stock) = deal_klondike(deck);
         assert!(stock.cards.iter().all(|c| !c.face_up));
     }
 
     #[test]
     fn deal_klondike_all_52_cards_present() {
-        let mut deck = Deck::new(); deck.shuffle(99);
+        let mut deck = Deck::new();
+        deck.shuffle(99);
         let (tableau, stock) = deal_klondike(deck);
         let mut ids: Vec<u32> = stock.cards.iter().map(|c| c.id).collect();
-        for pile in &tableau { ids.extend(pile.cards.iter().map(|c| c.id)); }
+        for pile in &tableau {
+            ids.extend(pile.cards.iter().map(|c| c.id));
+        }
         ids.sort_unstable();
         assert_eq!(ids, (0u32..52).collect::<Vec<_>>());
     }

solitaire_core/src/pile.rs

@@ -1,5 +1,5 @@
-use serde::{Deserialize, Serialize};
 use crate::card::{Card, Suit};
+use serde::{Deserialize, Serialize};
 
 /// Identifies which pile on the board a set of cards belongs to.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
@@ -28,7 +28,10 @@ pub struct Pile {
 impl Pile {
     /// Creates a new empty pile of the given type.
     pub fn new(pile_type: PileType) -> Self {
-        Self { pile_type, cards: Vec::new() }
+        Self {
+            pile_type,
+            cards: Vec::new(),
+        }
     }
 
     /// Returns a reference to the top (last) card, or `None` if empty.
@@ -61,8 +64,18 @@ mod tests {
     #[test]
     fn pile_top_returns_last_card() {
         let mut pile = Pile::new(PileType::Waste);
-        pile.cards.push(Card { id: 0, suit: Suit::Hearts, rank: Rank::Ace, face_up: true });
-        pile.cards.push(Card { id: 1, suit: Suit::Clubs, rank: Rank::Two, face_up: true });
+        pile.cards.push(Card {
+            id: 0,
+            suit: Suit::Hearts,
+            rank: Rank::Ace,
+            face_up: true,
+        });
+        pile.cards.push(Card {
+            id: 1,
+            suit: Suit::Clubs,
+            rank: Rank::Two,
+            face_up: true,
+        });
         assert_eq!(pile.top().unwrap().id, 1);
     }
 
@@ -91,15 +104,30 @@ mod tests {
     #[test]
     fn claimed_suit_is_none_for_non_foundation() {
         let mut pile = Pile::new(PileType::Tableau(0));
-        pile.cards.push(Card { id: 0, suit: Suit::Hearts, rank: Rank::Ace, face_up: true });
+        pile.cards.push(Card {
+            id: 0,
+            suit: Suit::Hearts,
+            rank: Rank::Ace,
+            face_up: true,
+        });
         assert!(pile.claimed_suit().is_none());
     }
 
     #[test]
     fn claimed_suit_returns_bottom_card_suit() {
         let mut pile = Pile::new(PileType::Foundation(2));
-        pile.cards.push(Card { id: 0, suit: Suit::Hearts, rank: Rank::Ace, face_up: true });
-        pile.cards.push(Card { id: 1, suit: Suit::Hearts, rank: Rank::Two, face_up: true });
+        pile.cards.push(Card {
+            id: 0,
+            suit: Suit::Hearts,
+            rank: Rank::Ace,
+            face_up: true,
+        });
+        pile.cards.push(Card {
+            id: 1,
+            suit: Suit::Hearts,
+            rank: Rank::Two,
+            face_up: true,
+        });
         assert_eq!(pile.claimed_suit(), Some(Suit::Hearts));
     }
 }

solitaire_core/src/rules.rs

@@ -52,7 +52,12 @@ mod tests {
     use crate::pile::{Pile, PileType};
 
     fn card(suit: Suit, rank: Rank) -> Card {
-        Card { id: 0, suit, rank, face_up: true }
+        Card {
+            id: 0,
+            suit,
+            rank,
+            face_up: true,
+        }
     }
 
     fn pile_with(pile_type: PileType, cards: Vec<Card>) -> Pile {
@@ -100,7 +105,10 @@ mod tests {
     #[test]
     fn foundation_skipping_rank_is_invalid() {
         let c = card(Suit::Diamonds, Rank::Three);
-        let p = pile_with(PileType::Foundation(0), vec![card(Suit::Diamonds, Rank::Ace)]);
+        let p = pile_with(
+            PileType::Foundation(0),
+            vec![card(Suit::Diamonds, Rank::Ace)],
+        );
         assert!(!can_place_on_foundation(&c, &p));
     }
 
@@ -151,7 +159,10 @@ mod tests {
     fn foundation_king_on_queen_completes_suit() {
         // The last card placed to complete a foundation is always King on Queen.
         let c = card(Suit::Spades, Rank::King);
-        let p = pile_with(PileType::Foundation(0), vec![card(Suit::Spades, Rank::Queen)]);
+        let p = pile_with(
+            PileType::Foundation(0),
+            vec![card(Suit::Spades, Rank::Queen)],
+        );
         assert!(can_place_on_foundation(&c, &p));
     }
 
@@ -159,7 +170,10 @@ mod tests {
     fn foundation_king_wrong_suit_is_invalid() {
         // King of Hearts cannot go on a Spades-claimed foundation even if rank matches.
         let c = card(Suit::Hearts, Rank::King);
-        let p = pile_with(PileType::Foundation(0), vec![card(Suit::Spades, Rank::Queen)]);
+        let p = pile_with(
+            PileType::Foundation(0),
+            vec![card(Suit::Spades, Rank::Queen)],
+        );
         assert!(!can_place_on_foundation(&c, &p));
     }
 

solitaire_core/src/scoring.rs

@@ -38,7 +38,11 @@ pub fn score_flip() -> i32 {
 /// Subsequent recycles cost -100 (Draw-1) or -20 (Draw-3).
 /// `recycle_count` is the new total count **after** this recycle.
 pub fn score_recycle(recycle_count: u32, is_draw_three: bool) -> i32 {
-    let (free, penalty) = if is_draw_three { (3_u32, -20_i32) } else { (1_u32, -100_i32) };
+    let (free, penalty) = if is_draw_three {
+        (3_u32, -20_i32)
+    } else {
+        (1_u32, -100_i32)
+    };
     if recycle_count > free { penalty } else { 0 }
 }
 
@@ -58,7 +62,10 @@ mod tests {
     #[test]
     fn move_to_foundation_scores_ten() {
         assert_eq!(score_move(&PileType::Waste, &PileType::Foundation(2)), 10);
-        assert_eq!(score_move(&PileType::Tableau(0), &PileType::Foundation(0)), 10);
+        assert_eq!(
+            score_move(&PileType::Tableau(0), &PileType::Foundation(0)),
+            10
+        );
     }
 
     #[test]
@@ -94,10 +101,12 @@ mod tests {
     #[test]
     fn foundation_to_tableau_penalises_fifteen() {
         // Moving a card back off a foundation (take_from_foundation rule) costs -15.
-        assert_eq!(score_move(&PileType::Foundation(0), &PileType::Tableau(0)), -15);
+        assert_eq!(
+            score_move(&PileType::Foundation(0), &PileType::Tableau(0)),
+            -15
+        );
     }
 
-
     #[test]
     fn move_to_stock_or_waste_scores_zero() {
         // These destinations are illegal moves in practice, but the function
@@ -110,7 +119,10 @@ mod tests {
     fn time_bonus_is_capped_at_i32_max_for_huge_values() {
         // Very short elapsed time would overflow without the .min() guard.
         let bonus = compute_time_bonus(1);
-        assert!(bonus >= 0, "time bonus must be non-negative after u64→i32 cast");
+        assert!(
+            bonus >= 0,
+            "time bonus must be non-negative after u64→i32 cast"
+        );
     }
 
     #[test]

solitaire_core/src/solver.rs

@@ -64,7 +64,7 @@ use std::collections::HashSet;
 use std::hash::{Hash, Hasher};
 
 use crate::card::{Card, Suit};
-use crate::deck::{deal_klondike, Deck};
+use crate::deck::{Deck, deal_klondike};
 use crate::game_state::{DrawMode, GameState};
 use crate::pile::{Pile, PileType};
 use crate::rules::{can_place_on_foundation, can_place_on_tableau, is_valid_tableau_sequence};
@@ -212,7 +212,11 @@ pub fn try_solve_from_state(state: &GameState, config: &SolverConfig) -> SolveOu
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum InternalMove {
     /// Move `count` cards from a tableau column to another tableau column.
-    TableauToTableau { from: usize, to: usize, count: usize },
+    TableauToTableau {
+        from: usize,
+        to: usize,
+        count: usize,
+    },
     /// Move the top of a tableau column to a foundation slot.
     TableauToFoundation { from: usize, slot: u8 },
     /// Move the top of the waste pile to a tableau column.
@@ -303,10 +307,9 @@ impl SolverState {
         self.foundation.iter().all(|pile| {
             pile.len() == 13
                 && pile[0].rank == crate::card::Rank::Ace
-                && pile.windows(2).all(|w| {
-                    w[0].suit == w[1].suit
-                        && w[1].rank.value() == w[0].rank.value() + 1
-                })
+                && pile
+                    .windows(2)
+                    .all(|w| w[0].suit == w[1].suit && w[1].rank.value() == w[0].rank.value() + 1)
         })
     }
 
@@ -350,10 +353,8 @@ impl SolverState {
                 && top.face_up
                 && let Some(slot) = self.target_foundation_slot(top.suit)
             {
-                let foundation_pile = Self::pile_view(
-                    PileType::Foundation(slot),
-                    &self.foundation[slot as usize],
-                );
+                let foundation_pile =
+                    Self::pile_view(PileType::Foundation(slot), &self.foundation[slot as usize]);
                 if can_place_on_foundation(top, &foundation_pile) {
                     moves.push(InternalMove::TableauToFoundation { from: i, slot });
                 }
@@ -364,10 +365,8 @@ impl SolverState {
         if let Some(top) = self.waste.last()
             && let Some(slot) = self.target_foundation_slot(top.suit)
         {
-            let foundation_pile = Self::pile_view(
-                PileType::Foundation(slot),
-                &self.foundation[slot as usize],
-            );
+            let foundation_pile =
+                Self::pile_view(PileType::Foundation(slot), &self.foundation[slot as usize]);
             if can_place_on_foundation(top, &foundation_pile) {
                 moves.push(InternalMove::WasteToFoundation { slot });
             }
@@ -401,13 +400,14 @@ impl SolverState {
                     // column onto another empty column".
                     let leaves_source_empty = start == 0;
                     let dest_empty = self.tableau[dst].is_empty();
-                    if leaves_source_empty
-                        && dest_empty
-                        && bottom.rank == crate::card::Rank::King
-                    {
+                    if leaves_source_empty && dest_empty && bottom.rank == crate::card::Rank::King {
                         continue;
                     }
-                    moves.push(InternalMove::TableauToTableau { from: src, to: dst, count });
+                    moves.push(InternalMove::TableauToTableau {
+                        from: src,
+                        to: dst,
+                        count,
+                    });
                 }
             }
         }
@@ -432,8 +432,7 @@ impl SolverState {
         // a single full cycle requires at most `ceil(stock_cycle_len / draw_count)`
         // draws (Draw 1 → exactly stock_cycle_len; Draw 3 → fewer), so
         // anything past that without intervening progress is wasteful.
-        let cycled_without_progress =
-            self.consecutive_draws > stock_cycle_len.saturating_add(1);
+        let cycled_without_progress = self.consecutive_draws > stock_cycle_len.saturating_add(1);
         if can_draw && !cycled_without_progress {
             moves.push(InternalMove::Draw);
         }
@@ -578,9 +577,7 @@ impl SolverState {
         while let Some(frame) = stack.last_mut() {
             // Budget gates — checked before consuming the next move so
             // the budget exhaustion is reflected in the verdict.
-            if *moves_consumed >= config.move_budget
-                || visited.len() >= config.state_budget
-            {
+            if *moves_consumed >= config.move_budget || visited.len() >= config.state_budget {
                 *budget_exceeded = true;
                 return None;
             }
@@ -622,7 +619,12 @@ impl SolverState {
         let mut moves_consumed: u64 = 0;
         let mut budget_exceeded = false;
         let already_won = self.is_won();
-        let first_move = self.search(config, &mut visited, &mut moves_consumed, &mut budget_exceeded);
+        let first_move = self.search(
+            config,
+            &mut visited,
+            &mut moves_consumed,
+            &mut budget_exceeded,
+        );
         let result = if already_won || first_move.is_some() {
             SolverResult::Winnable
         } else if budget_exceeded {
@@ -800,18 +802,38 @@ mod tests {
     }
 
     fn ace(suit: Suit, id: u32) -> Card {
-        Card { id, suit, rank: Rank::Ace, face_up: true }
+        Card {
+            id,
+            suit,
+            rank: Rank::Ace,
+            face_up: true,
+        }
     }
 
     fn rank_card(suit: Suit, rank: Rank, id: u32) -> Card {
-        Card { id, suit, rank, face_up: true }
+        Card {
+            id,
+            suit,
+            rank,
+            face_up: true,
+        }
     }
 
     fn full_run(suit: Suit, base_id: u32) -> Vec<Card> {
         let ranks = [
-            Rank::Ace, Rank::Two, Rank::Three, Rank::Four, Rank::Five,
-            Rank::Six, Rank::Seven, Rank::Eight, Rank::Nine, Rank::Ten,
-            Rank::Jack, Rank::Queen, Rank::King,
+            Rank::Ace,
+            Rank::Two,
+            Rank::Three,
+            Rank::Four,
+            Rank::Five,
+            Rank::Six,
+            Rank::Seven,
+            Rank::Eight,
+            Rank::Nine,
+            Rank::Ten,
+            Rank::Jack,
+            Rank::Queen,
+            Rank::King,
         ];
         ranks
             .iter()
@@ -846,14 +868,28 @@ mod tests {
         tableau[2] = vec![rank_card(Suit::Hearts, Rank::King, 102)];
         tableau[3] = vec![rank_card(Suit::Spades, Rank::King, 103)];
 
-        let state = synthetic(tableau, foundations, Vec::new(), Vec::new(), DrawMode::DrawOne);
+        let state = synthetic(
+            tableau,
+            foundations,
+            Vec::new(),
+            Vec::new(),
+            DrawMode::DrawOne,
+        );
         let mut visited: HashSet<u64> = HashSet::new();
         let mut moves_consumed: u64 = 0;
         let mut budget_exceeded = false;
         let cfg = SolverConfig::default();
-        let first_move = state.search(&cfg, &mut visited, &mut moves_consumed, &mut budget_exceeded);
+        let first_move = state.search(
+            &cfg,
+            &mut visited,
+            &mut moves_consumed,
+            &mut budget_exceeded,
+        );
 
-        assert!(first_move.is_some(), "obviously-winnable position must be recognised as Winnable");
+        assert!(
+            first_move.is_some(),
+            "obviously-winnable position must be recognised as Winnable"
+        );
         assert!(!budget_exceeded);
         assert!(
             moves_consumed < 1000,
@@ -872,8 +908,18 @@ mod tests {
         // Column 0: bottom-to-top [A♠, 2♠]. The Ace is the bottom
         // card; the Two on top of it has no valid destination.
         tableau[0] = vec![
-            Card { id: 0, suit: Suit::Spades, rank: Rank::Ace, face_up: true },
-            Card { id: 1, suit: Suit::Spades, rank: Rank::Two, face_up: true },
+            Card {
+                id: 0,
+                suit: Suit::Spades,
+                rank: Rank::Ace,
+                face_up: true,
+            },
+            Card {
+                id: 1,
+                suit: Suit::Spades,
+                rank: Rank::Two,
+                face_up: true,
+            },
         ];
         // Other six columns isolated. Put a face-up King with no
         // matching Queen anywhere — it cannot move because every
@@ -894,9 +940,20 @@ mod tests {
         let mut visited: HashSet<u64> = HashSet::new();
         let mut moves_consumed: u64 = 0;
         let mut budget_exceeded = false;
-        let first_move = state.search(&cfg, &mut visited, &mut moves_consumed, &mut budget_exceeded);
-        assert!(first_move.is_none(), "buried Ace under same-suit Two with no recovery must not solve");
-        assert!(!budget_exceeded, "small synthetic state must complete within budget");
+        let first_move = state.search(
+            &cfg,
+            &mut visited,
+            &mut moves_consumed,
+            &mut budget_exceeded,
+        );
+        assert!(
+            first_move.is_none(),
+            "buried Ace under same-suit Two with no recovery must not solve"
+        );
+        assert!(
+            !budget_exceeded,
+            "small synthetic state must complete within budget"
+        );
     }
 
     #[test]
@@ -960,9 +1017,12 @@ mod tests {
 
     #[test]
     fn longest_face_up_run_handles_face_down_at_top() {
-        let cards = vec![
-            Card { id: 1, suit: Suit::Spades, rank: Rank::King, face_up: false },
-        ];
+        let cards = vec![Card {
+            id: 1,
+            suit: Suit::Spades,
+            rank: Rank::King,
+            face_up: false,
+        }];
         assert_eq!(longest_face_up_run(&cards), 0);
     }
 
@@ -970,10 +1030,30 @@ mod tests {
     fn longest_face_up_run_extends_through_valid_run() {
         let cards = vec![
             // bottom: face-down filler
-            Card { id: 0, suit: Suit::Spades, rank: Rank::Two, face_up: false },
-            Card { id: 1, suit: Suit::Spades, rank: Rank::King, face_up: true },
-            Card { id: 2, suit: Suit::Hearts, rank: Rank::Queen, face_up: true },
-            Card { id: 3, suit: Suit::Clubs, rank: Rank::Jack, face_up: true },
+            Card {
+                id: 0,
+                suit: Suit::Spades,
+                rank: Rank::Two,
+                face_up: false,
+            },
+            Card {
+                id: 1,
+                suit: Suit::Spades,
+                rank: Rank::King,
+                face_up: true,
+            },
+            Card {
+                id: 2,
+                suit: Suit::Hearts,
+                rank: Rank::Queen,
+                face_up: true,
+            },
+            Card {
+                id: 3,
+                suit: Suit::Clubs,
+                rank: Rank::Jack,
+                face_up: true,
+            },
         ];
         assert_eq!(longest_face_up_run(&cards), 3);
     }
@@ -983,9 +1063,24 @@ mod tests {
         // K♠ Q♥ Q♣ — second pair fails the descending check, so the
         // run is just the top single card (Q♣).
         let cards = vec![
-            Card { id: 1, suit: Suit::Spades, rank: Rank::King, face_up: true },
-            Card { id: 2, suit: Suit::Hearts, rank: Rank::Queen, face_up: true },
-            Card { id: 3, suit: Suit::Clubs, rank: Rank::Queen, face_up: true },
+            Card {
+                id: 1,
+                suit: Suit::Spades,
+                rank: Rank::King,
+                face_up: true,
+            },
+            Card {
+                id: 2,
+                suit: Suit::Hearts,
+                rank: Rank::Queen,
+                face_up: true,
+            },
+            Card {
+                id: 3,
+                suit: Suit::Clubs,
+                rank: Rank::Queen,
+                face_up: true,
+            },
         ];
         assert_eq!(longest_face_up_run(&cards), 1);
     }
@@ -1082,7 +1177,9 @@ mod tests {
         println!(
             "\nmedian: {median} ms   mean: {} ms   Winnable: {}  Unwinnable: {}  Inconclusive: {}",
             total / samples_ms.len() as u128,
-            counts[0], counts[1], counts[2],
+            counts[0],
+            counts[1],
+            counts[2],
         );
     }
 
@@ -1122,9 +1219,18 @@ mod tests {
         // `target_foundation_slot` ordering.
         let suit_for_slot = [Suit::Clubs, Suit::Diamonds, Suit::Hearts, Suit::Spades];
         let ranks_below_king = [
-            Rank::Ace, Rank::Two, Rank::Three, Rank::Four, Rank::Five,
-            Rank::Six, Rank::Seven, Rank::Eight, Rank::Nine, Rank::Ten,
-            Rank::Jack, Rank::Queen,
+            Rank::Ace,
+            Rank::Two,
+            Rank::Three,
+            Rank::Four,
+            Rank::Five,
+            Rank::Six,
+            Rank::Seven,
+            Rank::Eight,
+            Rank::Nine,
+            Rank::Ten,
+            Rank::Jack,
+            Rank::Queen,
         ];
         for (slot, suit) in suit_for_slot.iter().enumerate() {
             let pile = game
@@ -1166,7 +1272,9 @@ mod tests {
             SolverResult::Winnable,
             "near-finished state must solve as Winnable"
         );
-        let mv = outcome.first_move.expect("Winnable must include a first_move");
+        let mv = outcome
+            .first_move
+            .expect("Winnable must include a first_move");
         // The first move must be a King going from a tableau column to
         // its matching foundation slot. Single-card move.
         assert_eq!(mv.count, 1);
@@ -1200,15 +1308,30 @@ mod tests {
         // Tableau 0: A♠ on the bottom, 2♠ on top — the 2♠ has no legal
         // destination, so the Ace is buried forever.
         let t0 = game.piles.get_mut(&PileType::Tableau(0)).unwrap();
-        t0.cards.push(Card { id: 0, suit: Suit::Spades, rank: Rank::Ace, face_up: true });
-        t0.cards.push(Card { id: 1, suit: Suit::Spades, rank: Rank::Two, face_up: true });
+        t0.cards.push(Card {
+            id: 0,
+            suit: Suit::Spades,
+            rank: Rank::Ace,
+            face_up: true,
+        });
+        t0.cards.push(Card {
+            id: 1,
+            suit: Suit::Spades,
+            rank: Rank::Two,
+            face_up: true,
+        });
         // Tableau 1: a face-up King with nothing else — irrelevant; the
         // pruning check elides "King → empty" no-ops.
         game.piles
             .get_mut(&PileType::Tableau(1))
             .unwrap()
             .cards
-            .push(Card { id: 2, suit: Suit::Clubs, rank: Rank::King, face_up: true });
+            .push(Card {
+                id: 2,
+                suit: Suit::Clubs,
+                rank: Rank::King,
+                face_up: true,
+            });
 
         let cfg = SolverConfig::default();
         let outcome = try_solve_from_state(&game, &cfg);
@@ -1248,7 +1371,13 @@ mod tests {
         let a = try_solve_with_first_move(7, DrawMode::DrawOne, &cfg);
         let game = GameState::new(7, DrawMode::DrawOne);
         let b = try_solve_from_state(&game, &cfg);
-        assert_eq!(a.result, b.result, "verdicts must match across the two entry points");
-        assert_eq!(a.first_move, b.first_move, "first_move must match across the two entry points");
+        assert_eq!(
+            a.result, b.result,
+            "verdicts must match across the two entry points"
+        );
+        assert_eq!(
+            a.first_move, b.first_move,
+            "first_move must match across the two entry points"
+        );
     }
 }

solitaire_data/src/achievements.rs

@@ -72,14 +72,11 @@ mod tests {
         let path = tmp_path("round_trip");
         let _ = fs::remove_file(&path);
 
-        let records = vec![
-            AchievementRecord::locked("first_win"),
-            {
-                let mut r = AchievementRecord::locked("century");
-                r.unlock(Utc::now());
-                r
-            },
-        ];
+        let records = vec![AchievementRecord::locked("first_win"), {
+            let mut r = AchievementRecord::locked("century");
+            r.unlock(Utc::now());
+            r
+        }];
         save_achievements_to(&path, &records).expect("save");
         let loaded = load_achievements_from(&path);
         assert_eq!(loaded.len(), 2);

solitaire_data/src/android_keystore.rs

@@ -14,8 +14,8 @@
 ///
 /// Only compiled and linked on `target_os = "android"`.
 use jni::{
-    objects::{JByteArray, JObject, JObjectArray, JValue, JValueOwned},
     JNIEnv, JavaVM,
+    objects::{JByteArray, JObject, JObjectArray, JValue, JValueOwned},
 };
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -100,8 +100,7 @@ fn load_or_create_key<'local>(env: &mut JNIEnv<'local>) -> jni::errors::Result<J
     }
 
     // No key yet — generate AES-256 with GCM block mode.
-    let builder_class =
-        env.find_class("android/security/keystore/KeyGenParameterSpec$Builder")?;
+    let builder_class = env.find_class("android/security/keystore/KeyGenParameterSpec$Builder")?;
     let alias2 = JValueOwned::from(env.new_string(KEY_ALIAS)?);
     // PURPOSE_ENCRYPT | PURPOSE_DECRYPT = 1 | 2 = 3
     let purpose = JValueOwned::Int(3);
@@ -252,11 +251,7 @@ fn decrypt_gcm(
     let tag_len = JValueOwned::Int(128);
     let iv_arr = env.byte_array_from_slice(iv)?;
     let iv_val = JValueOwned::Object(iv_arr.into());
-    let spec = env.new_object(
-        &spec_class,
-        "(I[B)V",
-        &[tag_len.borrow(), iv_val.borrow()],
-    )?;
+    let spec = env.new_object(&spec_class, "(I[B)V", &[tag_len.borrow(), iv_val.borrow()])?;
 
     // cipher.init(Cipher.DECRYPT_MODE=2, key, spec)
     let mode = JValueOwned::Int(2);
@@ -284,8 +279,7 @@ fn decrypt_gcm(
 // ---------------------------------------------------------------------------
 
 fn token_file_path() -> Option<PathBuf> {
-    crate::platform::data_dir()
-        .map(|d| d.join(crate::APP_DIR_NAME).join("auth_tokens.bin"))
+    crate::platform::data_dir().map(|d| d.join(crate::APP_DIR_NAME).join("auth_tokens.bin"))
 }
 
 /// Path where the token file lived before the APP_DIR_NAME subdirectory was
@@ -302,8 +296,8 @@ fn read_file_bytes_from(path: &PathBuf) -> Result<Vec<u8>, TokenError> {
 }
 
 fn write_file_bytes(data: &[u8]) -> Result<(), TokenError> {
-    let path = token_file_path()
-        .ok_or_else(|| TokenError::KeychainUnavailable("no data dir".into()))?;
+    let path =
+        token_file_path().ok_or_else(|| TokenError::KeychainUnavailable("no data dir".into()))?;
     if let Some(parent) = path.parent() {
         std::fs::create_dir_all(parent)
             .map_err(|e| TokenError::Keyring(format!("create dir: {e}")))?;
@@ -328,8 +322,8 @@ fn write_file_bytes(data: &[u8]) -> Result<(), TokenError> {
 ///    - Delete the legacy file (best-effort; leave it if removal fails).
 /// 3. If neither file exists, return an empty map.
 fn read_map() -> Result<HashMap<String, TokenBlob>, TokenError> {
-    let new_path = token_file_path()
-        .ok_or_else(|| TokenError::KeychainUnavailable("no data dir".into()))?;
+    let new_path =
+        token_file_path().ok_or_else(|| TokenError::KeychainUnavailable("no data dir".into()))?;
     let legacy_path = legacy_token_file_path();
 
     // --- 1. New path exists ---
@@ -339,7 +333,9 @@ fn read_map() -> Result<HashMap<String, TokenBlob>, TokenError> {
             other => other,
         })?;
         if data.len() < 12 {
-            return Err(TokenError::Keyring("auth_tokens.bin corrupt (too short)".into()));
+            return Err(TokenError::Keyring(
+                "auth_tokens.bin corrupt (too short)".into(),
+            ));
         }
         let plaintext = with_jvm(|env| {
             let key = load_or_create_key(env)?;
@@ -355,7 +351,9 @@ fn read_map() -> Result<HashMap<String, TokenBlob>, TokenError> {
             map.insert(blob.username.clone(), blob);
             return Ok(map);
         }
-        return Err(TokenError::Keyring("auth_tokens.bin unrecognised format".into()));
+        return Err(TokenError::Keyring(
+            "auth_tokens.bin unrecognised format".into(),
+        ));
     }
 
     // --- 2. Legacy path migration ---
@@ -390,8 +388,8 @@ fn read_map() -> Result<HashMap<String, TokenBlob>, TokenError> {
 
 /// Serialise and encrypt a map, then write it atomically.
 fn write_map_inner(map: &HashMap<String, TokenBlob>) -> Result<(), TokenError> {
-    let plaintext = serde_json::to_vec(map)
-        .map_err(|e| TokenError::Keyring(format!("JSON encode: {e}")))?;
+    let plaintext =
+        serde_json::to_vec(map).map_err(|e| TokenError::Keyring(format!("JSON encode: {e}")))?;
     let encrypted = with_jvm(|env| {
         let key = load_or_create_key(env)?;
         encrypt_gcm(env, &key, &plaintext)
@@ -500,8 +498,13 @@ pub fn delete_tokens(username: &str) -> Result<(), TokenError> {
             .v()?;
 
             let alias = JValueOwned::from(env.new_string(KEY_ALIAS)?);
-            env.call_method(&ks, "deleteEntry", "(Ljava/lang/String;)V", &[alias.borrow()])?
-                .v()
+            env.call_method(
+                &ks,
+                "deleteEntry",
+                "(Ljava/lang/String;)V",
+                &[alias.borrow()],
+            )?
+            .v()
         })
     } else {
         // Other users still exist — just rewrite the map without this user.

solitaire_data/src/difficulty_seeds.rs

@@ -294,7 +294,11 @@ mod tests {
         sorted.sort_unstable();
         let before = sorted.len();
         sorted.dedup();
-        assert_eq!(sorted.len(), before, "duplicate seeds found across difficulty tiers");
+        assert_eq!(
+            sorted.len(),
+            before,
+            "duplicate seeds found across difficulty tiers"
+        );
     }
 
     #[test]

solitaire_data/src/lib.rs

@@ -104,43 +104,43 @@ pub use stats::{StatsExt, StatsSnapshot};
 
 pub mod storage;
 pub use storage::{
-    cleanup_orphaned_tmp_files, delete_game_state_at, delete_time_attack_session_at,
-    game_state_file_path, load_game_state_from, load_stats, load_stats_from,
-    load_time_attack_session_from, load_time_attack_session_from_at, save_game_state_to,
-    save_stats, save_stats_to, save_time_attack_session_to, stats_file_path,
-    time_attack_session_path, time_attack_session_with_now, TimeAttackSession,
+    TimeAttackSession, cleanup_orphaned_tmp_files, delete_game_state_at,
+    delete_time_attack_session_at, game_state_file_path, load_game_state_from, load_stats,
+    load_stats_from, load_time_attack_session_from, load_time_attack_session_from_at,
+    save_game_state_to, save_stats, save_stats_to, save_time_attack_session_to, stats_file_path,
+    time_attack_session_path, time_attack_session_with_now,
 };
 
 pub mod achievements;
 pub use achievements::{
-    achievements_file_path, load_achievements_from, save_achievements_to, AchievementRecord,
+    AchievementRecord, achievements_file_path, load_achievements_from, save_achievements_to,
 };
 
 pub mod progress;
 pub use progress::{
-    daily_seed_for, level_for_xp, load_progress_from, progress_file_path, save_progress_to,
-    xp_for_win, PlayerProgress,
+    PlayerProgress, daily_seed_for, level_for_xp, load_progress_from, progress_file_path,
+    save_progress_to, xp_for_win,
 };
 
 pub mod weekly;
 pub use weekly::{
-    current_iso_week_key, weekly_goal_by_id, WeeklyGoalContext, WeeklyGoalDef, WeeklyGoalKind,
-    WEEKLY_GOALS, WEEKLY_GOAL_XP,
+    WEEKLY_GOAL_XP, WEEKLY_GOALS, WeeklyGoalContext, WeeklyGoalDef, WeeklyGoalKind,
+    current_iso_week_key, weekly_goal_by_id,
 };
 
 pub mod challenge;
-pub use challenge::{challenge_count, challenge_seed_for, CHALLENGE_SEEDS};
+pub use challenge::{CHALLENGE_SEEDS, challenge_count, challenge_seed_for};
 
 pub mod difficulty_seeds;
-pub use difficulty_seeds::{seeds_for, DifficultySeeds};
+pub use difficulty_seeds::{DifficultySeeds, seeds_for};
 
 pub mod settings;
 pub use settings::{
-    load_settings_from, save_settings_to, settings_file_path, AnimSpeed, Settings, SyncBackend,
-    Theme, WindowGeometry, REPLAY_MOVE_INTERVAL_MAX_SECS, REPLAY_MOVE_INTERVAL_MIN_SECS,
-    REPLAY_MOVE_INTERVAL_STEP_SECS, SOLVER_DEAL_RETRY_CAP, TIME_BONUS_MULTIPLIER_MAX,
-    TIME_BONUS_MULTIPLIER_MIN, TIME_BONUS_MULTIPLIER_STEP, TOOLTIP_DELAY_MAX_SECS,
-    TOOLTIP_DELAY_MIN_SECS, TOOLTIP_DELAY_STEP_SECS,
+    AnimSpeed, REPLAY_MOVE_INTERVAL_MAX_SECS, REPLAY_MOVE_INTERVAL_MIN_SECS,
+    REPLAY_MOVE_INTERVAL_STEP_SECS, SOLVER_DEAL_RETRY_CAP, Settings, SyncBackend,
+    TIME_BONUS_MULTIPLIER_MAX, TIME_BONUS_MULTIPLIER_MIN, TIME_BONUS_MULTIPLIER_STEP,
+    TOOLTIP_DELAY_MAX_SECS, TOOLTIP_DELAY_MIN_SECS, TOOLTIP_DELAY_STEP_SECS, Theme, WindowGeometry,
+    load_settings_from, save_settings_to, settings_file_path,
 };
 
 #[cfg(target_os = "android")]
@@ -148,20 +148,20 @@ mod android_keystore;
 
 pub mod auth_tokens;
 pub use auth_tokens::{
-    delete_tokens, load_access_token, load_refresh_token, store_tokens, TokenError,
+    TokenError, delete_tokens, load_access_token, load_refresh_token, store_tokens,
 };
 
 pub mod sync_client;
-pub use sync_client::{provider_for_backend, LocalOnlyProvider, SolitaireServerClient};
+pub use sync_client::{LocalOnlyProvider, SolitaireServerClient, provider_for_backend};
 
 pub mod replay;
+pub use replay::{
+    REPLAY_HISTORY_CAP, REPLAY_HISTORY_SCHEMA_VERSION, REPLAY_SCHEMA_VERSION, Replay,
+    ReplayHistory, ReplayMove, append_replay_to_history, load_replay_history_from,
+    migrate_legacy_latest_replay, replay_history_path, save_replay_history_to,
+};
 #[allow(deprecated)]
 pub use replay::{latest_replay_path, load_latest_replay_from, save_latest_replay_to};
-pub use replay::{
-    append_replay_to_history, load_replay_history_from, migrate_legacy_latest_replay,
-    replay_history_path, save_replay_history_to, Replay, ReplayHistory, ReplayMove,
-    REPLAY_HISTORY_CAP, REPLAY_HISTORY_SCHEMA_VERSION, REPLAY_SCHEMA_VERSION,
-};
 
 pub mod matomo_client;
 pub use matomo_client::MatomoClient;

solitaire_data/src/matomo_client.rs

@@ -47,13 +47,7 @@ impl MatomoClient {
     ///
     /// When the buffer exceeds 100 events the oldest 50 are dropped to
     /// prevent unbounded memory growth during extended offline play.
-    pub fn event(
-        &self,
-        category: &str,
-        action: &str,
-        name: Option<&str>,
-        value: Option<f64>,
-    ) {
+    pub fn event(&self, category: &str, action: &str, name: Option<&str>, value: Option<f64>) {
         let Ok(mut guard) = self.pending.lock() else {
             return;
         };

solitaire_data/src/platform.rs

@@ -87,6 +87,9 @@ mod tests {
     #[test]
     fn data_dir_returns_sandbox_path_on_android() {
         let dir = data_dir().expect("android must report a data dir");
-        assert_eq!(dir, PathBuf::from("/data/data/com.ferrousapp.solitaire/files"));
+        assert_eq!(
+            dir,
+            PathBuf::from("/data/data/com.ferrousapp.solitaire/files")
+        );
     }
 }

solitaire_data/src/progress.rs

@@ -11,8 +11,8 @@ use std::path::{Path, PathBuf};
 
 use chrono::{Datelike, NaiveDate};
 
-pub use solitaire_sync::progress::level_for_xp;
 pub use solitaire_sync::PlayerProgress;
+pub use solitaire_sync::progress::level_for_xp;
 
 const FILE_NAME: &str = "progress.json";
 
@@ -147,7 +147,10 @@ mod tests {
 
     #[test]
     fn add_xp_saturates_on_overflow() {
-        let mut p = PlayerProgress { total_xp: u64::MAX - 5, ..Default::default() };
+        let mut p = PlayerProgress {
+            total_xp: u64::MAX - 5,
+            ..Default::default()
+        };
         p.add_xp(100);
         assert_eq!(p.total_xp, u64::MAX);
     }

solitaire_data/src/replay.rs

@@ -293,11 +293,9 @@ pub fn replay_history_path() -> Option<PathBuf> {
 ///
 /// Overwrites any existing replay — only the most recent winning replay
 /// is retained on disk.
-#[deprecated(
-    note = "single-slot replay storage replaced by the rolling history; \
+#[deprecated(note = "single-slot replay storage replaced by the rolling history; \
             use append_replay_to_history instead. Kept for the one-shot \
-            legacy migration."
-)]
+            legacy migration.")]
 pub fn save_latest_replay_to(path: &Path, replay: &Replay) -> io::Result<()> {
     if let Some(parent) = path.parent() {
         fs::create_dir_all(parent)?;
@@ -317,11 +315,9 @@ pub fn save_latest_replay_to(path: &Path, replay: &Replay) -> io::Result<()> {
 /// "No replay recorded yet" caption rather than a half-loaded broken
 /// replay. Bumping [`REPLAY_SCHEMA_VERSION`] therefore invalidates every
 /// older save without further migration code.
-#[deprecated(
-    note = "single-slot replay storage replaced by the rolling history; \
+#[deprecated(note = "single-slot replay storage replaced by the rolling history; \
             use load_replay_history_from instead. Kept for the one-shot \
-            legacy migration."
-)]
+            legacy migration.")]
 pub fn load_latest_replay_from(path: &Path) -> Option<Replay> {
     let data = fs::read(path).ok()?;
     let replay: Replay = serde_json::from_slice(&data).ok()?;
@@ -383,10 +379,7 @@ pub fn load_replay_history_from(path: &Path) -> Option<ReplayHistory> {
 /// [`ReplayHistory`] is the exact value written to disk so callers can
 /// update an in-memory mirror (e.g. the Stats overlay's
 /// `ReplayHistoryResource`) without a follow-up `load`.
-pub fn append_replay_to_history(
-    path: &Path,
-    replay: Replay,
-) -> io::Result<ReplayHistory> {
+pub fn append_replay_to_history(path: &Path, replay: Replay) -> io::Result<ReplayHistory> {
     let mut history = load_replay_history_from(path).unwrap_or_default();
     // Most recent first. Reserve the front slot; pop the oldest if we
     // exceed the cap so the file never grows unbounded.
@@ -438,9 +431,7 @@ pub fn migrate_legacy_latest_replay(latest_path: &Path, history_path: &Path) {
         // Migration failure is non-fatal: on the next launch we'll just
         // try again. We log to stderr rather than panic so headless
         // tests stay quiet.
-        eprintln!(
-            "replay: failed to migrate legacy latest_replay.json into rolling history: {e}",
-        );
+        eprintln!("replay: failed to migrate legacy latest_replay.json into rolling history: {e}",);
     }
 }
 
@@ -623,8 +614,8 @@ mod tests {
 
         let mut last_returned = ReplayHistory::default();
         for i in 0..10 {
-            last_returned = append_replay_to_history(&path, replay_with_id(i))
-                .expect("append must succeed");
+            last_returned =
+                append_replay_to_history(&path, replay_with_id(i)).expect("append must succeed");
         }
 
         assert_eq!(
@@ -634,7 +625,11 @@ mod tests {
         );
         // The most recent ten pushes were ids 0..=9; ids 9, 8, ..., 2
         // survive (newest first), ids 0 and 1 aged out.
-        let ids: Vec<i32> = last_returned.replays.iter().map(|r| r.final_score).collect();
+        let ids: Vec<i32> = last_returned
+            .replays
+            .iter()
+            .map(|r| r.final_score)
+            .collect();
         assert_eq!(
             ids,
             vec![9, 8, 7, 6, 5, 4, 3, 2],
@@ -683,18 +678,30 @@ mod tests {
         // Seed the legacy file with a real replay.
         let legacy_replay = sample_replay();
         save_latest_replay_to(&latest, &legacy_replay).expect("seed legacy");
-        assert!(!history.exists(), "history file must not exist pre-migration");
+        assert!(
+            !history.exists(),
+            "history file must not exist pre-migration"
+        );
 
         migrate_legacy_latest_replay(&latest, &history);
 
         assert!(history.exists(), "migration must create the history file");
-        let loaded = load_replay_history_from(&history)
-            .expect("post-migration history must load");
-        assert_eq!(loaded.replays.len(), 1, "history must hold exactly the legacy entry");
-        assert_eq!(loaded.replays[0], legacy_replay, "entry must equal the legacy replay");
+        let loaded = load_replay_history_from(&history).expect("post-migration history must load");
+        assert_eq!(
+            loaded.replays.len(),
+            1,
+            "history must hold exactly the legacy entry"
+        );
+        assert_eq!(
+            loaded.replays[0], legacy_replay,
+            "entry must equal the legacy replay"
+        );
         // Legacy file is intentionally retained for one release as a
         // safety net — see `migrate_legacy_latest_replay` doc comment.
-        assert!(latest.exists(), "legacy file must NOT be deleted by migration");
+        assert!(
+            latest.exists(),
+            "legacy file must NOT be deleted by migration"
+        );
 
         let _ = fs::remove_file(&latest);
         let _ = fs::remove_file(&history);
@@ -720,7 +727,10 @@ mod tests {
         migrate_legacy_latest_replay(&latest, &history);
 
         let loaded = load_replay_history_from(&history).expect("load");
-        assert_eq!(loaded, pre_existing, "existing history must not be overwritten");
+        assert_eq!(
+            loaded, pre_existing,
+            "existing history must not be overwritten"
+        );
 
         let _ = fs::remove_file(&latest);
         let _ = fs::remove_file(&history);

solitaire_data/src/settings.rs

@@ -60,7 +60,6 @@ pub enum SyncBackend {
         avatar_url: Option<String>,
         // JWT tokens are stored in the OS keychain — not here.
     },
-
 }
 
 /// Persisted window size (in logical pixels) and screen position
@@ -280,7 +279,7 @@ fn default_music_volume() -> f32 {
 }
 
 fn default_theme_id() -> String {
-    "classic".to_string()
+    "dark".to_string()
 }
 
 /// Default tooltip-hover dwell delay in seconds. Mirrors
@@ -447,8 +446,8 @@ impl Settings {
     /// to `[TOOLTIP_DELAY_MIN_SECS, TOOLTIP_DELAY_MAX_SECS]`. Returns the
     /// new value.
     pub fn adjust_tooltip_delay(&mut self, delta: f32) -> f32 {
-        self.tooltip_delay_secs = (self.tooltip_delay_secs + delta)
-            .clamp(TOOLTIP_DELAY_MIN_SECS, TOOLTIP_DELAY_MAX_SECS);
+        self.tooltip_delay_secs =
+            (self.tooltip_delay_secs + delta).clamp(TOOLTIP_DELAY_MIN_SECS, TOOLTIP_DELAY_MAX_SECS);
         self.tooltip_delay_secs
     }
 
@@ -522,7 +521,10 @@ mod tests {
 
     #[test]
     fn adjust_sfx_volume_clamps() {
-        let mut s = Settings { sfx_volume: 0.5, ..Default::default() };
+        let mut s = Settings {
+            sfx_volume: 0.5,
+            ..Default::default()
+        };
         assert!((s.adjust_sfx_volume(0.3) - 0.8).abs() < 1e-6);
         assert!((s.adjust_sfx_volume(0.5) - 1.0).abs() < 1e-6);
         assert!((s.adjust_sfx_volume(-2.0) - 0.0).abs() < 1e-6);
@@ -531,7 +533,10 @@ mod tests {
 
     #[test]
     fn adjust_music_volume_clamps() {
-        let mut s = Settings { music_volume: 0.5, ..Default::default() };
+        let mut s = Settings {
+            music_volume: 0.5,
+            ..Default::default()
+        };
         assert!((s.adjust_music_volume(0.3) - 0.8).abs() < 1e-6);
         assert!((s.adjust_music_volume(0.5) - 1.0).abs() < 1e-6);
         assert!((s.adjust_music_volume(-2.0) - 0.0).abs() < 1e-6);
@@ -570,7 +575,10 @@ mod tests {
 
     #[test]
     fn adjust_tooltip_delay_clamps_to_range() {
-        let mut s = Settings { tooltip_delay_secs: 0.5, ..Default::default() };
+        let mut s = Settings {
+            tooltip_delay_secs: 0.5,
+            ..Default::default()
+        };
         // Step up to 0.6.
         assert!((s.adjust_tooltip_delay(0.1) - 0.6).abs() < 1e-6);
         // Big positive jump clamps to TOOLTIP_DELAY_MAX_SECS.
@@ -583,21 +591,23 @@ mod tests {
 
     #[test]
     fn adjust_time_bonus_multiplier_clamps_and_rounds() {
-        let mut s = Settings { time_bonus_multiplier: 1.0, ..Default::default() };
+        let mut s = Settings {
+            time_bonus_multiplier: 1.0,
+            ..Default::default()
+        };
         // Step up to 1.1.
         assert!((s.adjust_time_bonus_multiplier(0.1) - 1.1).abs() < 1e-6);
         // Big positive jump clamps to TIME_BONUS_MULTIPLIER_MAX.
-        assert!(
-            (s.adjust_time_bonus_multiplier(99.0) - TIME_BONUS_MULTIPLIER_MAX).abs() < 1e-6
-        );
+        assert!((s.adjust_time_bonus_multiplier(99.0) - TIME_BONUS_MULTIPLIER_MAX).abs() < 1e-6);
         // Big negative jump clamps to TIME_BONUS_MULTIPLIER_MIN.
-        assert!(
-            (s.adjust_time_bonus_multiplier(-99.0) - TIME_BONUS_MULTIPLIER_MIN).abs() < 1e-6
-        );
+        assert!((s.adjust_time_bonus_multiplier(-99.0) - TIME_BONUS_MULTIPLIER_MIN).abs() < 1e-6);
         assert_eq!(s.time_bonus_multiplier, 0.0);
 
         // Repeated incremental adds must not drift past the 0.1 grid.
-        let mut s2 = Settings { time_bonus_multiplier: 0.0, ..Default::default() };
+        let mut s2 = Settings {
+            time_bonus_multiplier: 0.0,
+            ..Default::default()
+        };
         for _ in 0..10 {
             s2.adjust_time_bonus_multiplier(0.1);
         }
@@ -611,20 +621,24 @@ mod tests {
 
     #[test]
     fn adjust_replay_move_interval_clamps_and_rounds() {
-        let mut s = Settings { replay_move_interval_secs: 0.45, ..Default::default() };
+        let mut s = Settings {
+            replay_move_interval_secs: 0.45,
+            ..Default::default()
+        };
         // Step down to 0.40.
         assert!((s.adjust_replay_move_interval(-0.05) - 0.40).abs() < 1e-6);
         // Big positive jump clamps to MAX.
-        assert!(
-            (s.adjust_replay_move_interval(99.0) - REPLAY_MOVE_INTERVAL_MAX_SECS).abs() < 1e-6
-        );
+        assert!((s.adjust_replay_move_interval(99.0) - REPLAY_MOVE_INTERVAL_MAX_SECS).abs() < 1e-6);
         // Big negative jump clamps to MIN.
         assert!(
             (s.adjust_replay_move_interval(-99.0) - REPLAY_MOVE_INTERVAL_MIN_SECS).abs() < 1e-6
         );
 
         // Repeated 0.05 steps must not drift past the 0.05 grid.
-        let mut s2 = Settings { replay_move_interval_secs: 0.10, ..Default::default() };
+        let mut s2 = Settings {
+            replay_move_interval_secs: 0.10,
+            ..Default::default()
+        };
         for _ in 0..6 {
             s2.adjust_replay_move_interval(0.05);
         }

solitaire_data/src/stats.rs

@@ -231,14 +231,24 @@ mod tests {
         // Win once — current becomes 1, best must remain 5.
         s.update_on_win(100, 60, &DrawMode::DrawOne);
         assert_eq!(s.win_streak_current, 1);
-        assert_eq!(s.win_streak_best, 5, "best must not drop to match shorter streak");
+        assert_eq!(
+            s.win_streak_best, 5,
+            "best must not drop to match shorter streak"
+        );
     }
 
     #[test]
     fn lifetime_score_saturates_at_u64_max() {
-        let mut s = StatsSnapshot { lifetime_score: u64::MAX - 100, ..Default::default() };
+        let mut s = StatsSnapshot {
+            lifetime_score: u64::MAX - 100,
+            ..Default::default()
+        };
         s.update_on_win(200, 60, &DrawMode::DrawOne);
-        assert_eq!(s.lifetime_score, u64::MAX, "lifetime_score must saturate, not overflow");
+        assert_eq!(
+            s.lifetime_score,
+            u64::MAX,
+            "lifetime_score must saturate, not overflow"
+        );
     }
 
     // -----------------------------------------------------------------------

solitaire_data/src/storage.rs

@@ -9,7 +9,7 @@ use std::path::{Path, PathBuf};
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use serde::{Deserialize, Serialize};
-use solitaire_core::game_state::{GameState, GAME_STATE_SCHEMA_VERSION};
+use solitaire_core::game_state::{GAME_STATE_SCHEMA_VERSION, GameState};
 
 use crate::stats::StatsSnapshot;
 
@@ -57,9 +57,8 @@ pub fn load_stats() -> StatsSnapshot {
 /// Save stats to the platform default path. Returns an error if the platform
 /// data dir is unavailable or the write fails.
 pub fn save_stats(stats: &StatsSnapshot) -> io::Result<()> {
-    let path = stats_file_path().ok_or_else(|| {
-        io::Error::new(io::ErrorKind::NotFound, "platform data dir unavailable")
-    })?;
+    let path = stats_file_path()
+        .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "platform data dir unavailable"))?;
     save_stats_to(&path, stats)
 }
 
@@ -89,11 +88,7 @@ pub fn load_game_state_from(path: &Path) -> Option<GameState> {
     if gs.schema_version != GAME_STATE_SCHEMA_VERSION {
         return None;
     }
-    if gs.is_won {
-        None
-    } else {
-        Some(gs)
-    }
+    if gs.is_won { None } else { Some(gs) }
 }
 
 /// Save an in-progress `GameState` atomically. Skips the write if `gs.is_won`
@@ -180,7 +175,10 @@ pub struct TimeAttackSession {
 /// Returns the platform-specific path to `time_attack_session.json`, or
 /// `None` if `crate::data_dir()` is unavailable.
 pub fn time_attack_session_path() -> Option<PathBuf> {
-    crate::data_dir().map(|d| d.join(crate::APP_DIR_NAME).join(TIME_ATTACK_SESSION_FILE_NAME))
+    crate::data_dir().map(|d| {
+        d.join(crate::APP_DIR_NAME)
+            .join(TIME_ATTACK_SESSION_FILE_NAME)
+    })
 }
 
 /// Save a Time Attack session atomically. Mirrors `save_game_state_to`'s
@@ -422,7 +420,10 @@ mod tests {
         let mut gs = GameState::new(99, DrawMode::DrawOne);
         gs.is_won = true;
         save_game_state_to(&path, &gs).expect("save should be no-op, not error");
-        assert!(!path.exists(), "should not have written a file for a won game");
+        assert!(
+            !path.exists(),
+            "should not have written a file for a won game"
+        );
     }
 
     #[test]
@@ -556,7 +557,10 @@ mod tests {
             loaded.remaining_secs,
         );
         assert_eq!(loaded.wins, 3, "wins must round-trip");
-        assert_eq!(loaded.saved_at_unix_secs, saved_at, "timestamp must round-trip");
+        assert_eq!(
+            loaded.saved_at_unix_secs, saved_at,
+            "timestamp must round-trip"
+        );
 
         let _ = fs::remove_file(&path);
     }

solitaire_data/src/sync_client.rs

@@ -15,10 +15,10 @@ use async_trait::async_trait;
 use solitaire_sync::{ChallengeGoal, LeaderboardEntry, SyncPayload, SyncResponse};
 
 use crate::{
+    SyncError, SyncProvider,
     auth_tokens::{load_access_token, load_refresh_token, store_tokens},
     replay::Replay,
     settings::SyncBackend,
-    SyncError, SyncProvider,
 };
 
 // ---------------------------------------------------------------------------
@@ -125,10 +125,7 @@ impl SolitaireServerClient {
     async fn extract_auth_tokens(resp: reqwest::Response) -> Result<(String, String), SyncError> {
         let status = resp.status();
         if !status.is_success() {
-            let body: serde_json::Value = resp
-                .json()
-                .await
-                .unwrap_or(serde_json::json!({}));
+            let body: serde_json::Value = resp.json().await.unwrap_or(serde_json::json!({}));
             let msg = body["error"]
                 .as_str()
                 .or_else(|| body["message"].as_str())
@@ -166,8 +163,8 @@ impl SolitaireServerClient {
     /// new refresh token that replaces the old one. Both tokens are persisted
     /// to the OS keychain on success.
     async fn refresh_token(&self) -> Result<(), SyncError> {
-        let old_refresh = load_refresh_token(&self.username)
-            .map_err(|e| SyncError::Auth(e.to_string()))?;
+        let old_refresh =
+            load_refresh_token(&self.username).map_err(|e| SyncError::Auth(e.to_string()))?;
 
         let resp = self
             .client
@@ -186,9 +183,9 @@ impl SolitaireServerClient {
             .await
             .map_err(|e| SyncError::Serialization(e.to_string()))?;
 
-        let new_access = body["access_token"]
-            .as_str()
-            .ok_or_else(|| SyncError::Serialization("missing access_token in refresh response".into()))?;
+        let new_access = body["access_token"].as_str().ok_or_else(|| {
+            SyncError::Serialization("missing access_token in refresh response".into())
+        })?;
 
         // Server rotates refresh tokens — store the new one.
         // Fall back to the old token if the field is absent (pre-rotation server).
@@ -368,13 +365,19 @@ impl SyncProvider for SolitaireServerClient {
                 .await
                 .map_err(|e| SyncError::Network(e.to_string()))?;
             if !resp.status().is_success() {
-                return Err(SyncError::Auth(format!("opt-out failed: {}", resp.status())));
+                return Err(SyncError::Auth(format!(
+                    "opt-out failed: {}",
+                    resp.status()
+                )));
             }
             return Ok(());
         }
 
         if !resp.status().is_success() {
-            return Err(SyncError::Auth(format!("opt-out failed: {}", resp.status())));
+            return Err(SyncError::Auth(format!(
+                "opt-out failed: {}",
+                resp.status()
+            )));
         }
         Ok(())
     }
@@ -402,13 +405,19 @@ impl SyncProvider for SolitaireServerClient {
                 .await
                 .map_err(|e| SyncError::Network(e.to_string()))?;
             if !resp.status().is_success() {
-                return Err(SyncError::Auth(format!("delete account failed: {}", resp.status())));
+                return Err(SyncError::Auth(format!(
+                    "delete account failed: {}",
+                    resp.status()
+                )));
             }
             return Ok(());
         }
 
         if !resp.status().is_success() {
-            return Err(SyncError::Auth(format!("delete account failed: {}", resp.status())));
+            return Err(SyncError::Auth(format!(
+                "delete account failed: {}",
+                resp.status()
+            )));
         }
         Ok(())
     }
@@ -480,27 +489,26 @@ impl SyncProvider for SolitaireServerClient {
 impl SolitaireServerClient {
     /// Pulled out of `push_replay` so both the first attempt and the
     /// post-401-retry attempt go through the same parse path.
-    async fn share_url_from_response(
-        &self,
-        resp: reqwest::Response,
-    ) -> Result<String, SyncError> {
+    async fn share_url_from_response(&self, resp: reqwest::Response) -> Result<String, SyncError> {
         let status = resp.status();
         if !status.is_success() {
-            return Err(if status == reqwest::StatusCode::UNAUTHORIZED
-                || status == reqwest::StatusCode::FORBIDDEN
-            {
-                SyncError::Auth(format!("server returned {status}"))
-            } else {
-                SyncError::Network(format!("server returned {status}"))
-            });
+            return Err(
+                if status == reqwest::StatusCode::UNAUTHORIZED
+                    || status == reqwest::StatusCode::FORBIDDEN
+                {
+                    SyncError::Auth(format!("server returned {status}"))
+                } else {
+                    SyncError::Network(format!("server returned {status}"))
+                },
+            );
         }
         let body: serde_json::Value = resp
             .json()
             .await
             .map_err(|e| SyncError::Serialization(e.to_string()))?;
-        let id = body["id"].as_str().ok_or_else(|| {
-            SyncError::Serialization("upload response missing `id`".into())
-        })?;
+        let id = body["id"]
+            .as_str()
+            .ok_or_else(|| SyncError::Serialization("upload response missing `id`".into()))?;
         Ok(format!("{}/replays/{}", self.base_url, id))
     }
 
@@ -540,7 +548,10 @@ impl SolitaireServerClient {
     /// Like [`fetch_me`] but uses an explicit token instead of reading from the
     /// OS keychain. Useful immediately after login/register when the token has
     /// not yet been persisted.
-    pub async fn fetch_me_with_token(&self, token: &str) -> Result<(String, Option<String>), SyncError> {
+    pub async fn fetch_me_with_token(
+        &self,
+        token: &str,
+    ) -> Result<(String, Option<String>), SyncError> {
         let url = format!("{}/api/me", self.base_url);
         let resp = self
             .client
@@ -552,7 +563,9 @@ impl SolitaireServerClient {
         Self::extract_me_body(resp).await
     }
 
-    async fn extract_me_body(resp: reqwest::Response) -> Result<(String, Option<String>), SyncError> {
+    async fn extract_me_body(
+        resp: reqwest::Response,
+    ) -> Result<(String, Option<String>), SyncError> {
         let status = resp.status();
         if !status.is_success() {
             return Err(SyncError::Network(format!("GET /api/me returned {status}")));
@@ -595,7 +608,9 @@ async fn extract_pull_body(resp: reqwest::Response) -> Result<SyncPayload, SyncE
 }
 
 /// Deserialize a leaderboard response body as `Vec<LeaderboardEntry>`.
-async fn extract_leaderboard_body(resp: reqwest::Response) -> Result<Vec<LeaderboardEntry>, SyncError> {
+async fn extract_leaderboard_body(
+    resp: reqwest::Response,
+) -> Result<Vec<LeaderboardEntry>, SyncError> {
     let status = resp.status();
     if status.is_success() {
         resp.json()

solitaire_data/tests/sync_round_trip.rs

@@ -30,13 +30,11 @@
 //! expired-on-purpose tokens for the JWT-refresh test.
 
 use chrono::Utc;
-use jsonwebtoken::{encode, EncodingKey, Header};
-use solitaire_data::{
-    delete_tokens, store_tokens, SolitaireServerClient, SyncError, SyncProvider,
-};
+use jsonwebtoken::{EncodingKey, Header, encode};
+use solitaire_data::{SolitaireServerClient, SyncError, SyncProvider, delete_tokens, store_tokens};
 use solitaire_sync::{PlayerProgress, StatsSnapshot, SyncPayload};
-use sqlx::sqlite::SqlitePoolOptions;
 use sqlx::SqlitePool;
+use sqlx::sqlite::SqlitePoolOptions;
 use std::sync::Once;
 use uuid::Uuid;
 
@@ -58,8 +56,8 @@ static MOCK_KEYRING_INIT: Once = Once::new();
 /// default. Safe to call from any test — only the first call has effect.
 fn ensure_mock_keyring() {
     MOCK_KEYRING_INIT.call_once(|| {
-        let store = keyring_core::mock::Store::new()
-            .expect("failed to construct mock keyring store");
+        let store =
+            keyring_core::mock::Store::new().expect("failed to construct mock keyring store");
         keyring_core::set_default_store(store);
     });
 }
@@ -95,9 +93,7 @@ async fn spawn_test_server() -> String {
     let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
         .await
         .expect("failed to bind test listener");
-    let addr = listener
-        .local_addr()
-        .expect("listener has no local addr");
+    let addr = listener.local_addr().expect("listener has no local addr");
 
     let app = solitaire_server::build_test_router(fresh_pool().await);
 
@@ -119,11 +115,7 @@ async fn spawn_test_server() -> String {
 /// Register a fresh user against `base_url` and return the access + refresh
 /// tokens straight from the response body. Bypasses the keyring entirely so
 /// the caller can store the tokens under whatever username they want.
-async fn register_user_raw(
-    base_url: &str,
-    username: &str,
-    password: &str,
-) -> (String, String) {
+async fn register_user_raw(base_url: &str, username: &str, password: &str) -> (String, String) {
     let client = reqwest::Client::new();
     let resp = client
         .post(format!("{base_url}/api/auth/register"))
@@ -154,19 +146,15 @@ async fn register_user_raw(
 /// Decode a JWT's `sub` claim without validating expiry (so test crafted
 /// tokens still parse). Returns the user UUID as a `String`.
 fn decode_sub(token: &str) -> String {
-    use jsonwebtoken::{decode, DecodingKey, Validation};
+    use jsonwebtoken::{DecodingKey, Validation, decode};
     #[derive(serde::Deserialize)]
     struct Claims {
         sub: String,
     }
     let mut v = Validation::default();
     v.validate_exp = false;
-    let data = decode::<Claims>(
-        token,
-        &DecodingKey::from_secret(TEST_SECRET.as_bytes()),
-        &v,
-    )
-    .expect("failed to decode JWT");
+    let data = decode::<Claims>(token, &DecodingKey::from_secret(TEST_SECRET.as_bytes()), &v)
+        .expect("failed to decode JWT");
     data.claims.sub
 }
 
@@ -208,8 +196,7 @@ async fn register_login_push_pull_round_trip() {
     let username = "rt_alice";
 
     let (access, refresh) = register_user_raw(&base, username, "alicepass1!").await;
-    store_tokens(username, &access, &refresh)
-        .expect("storing tokens in mock keyring must succeed");
+    store_tokens(username, &access, &refresh).expect("storing tokens in mock keyring must succeed");
 
     let user_id = decode_sub(&access);
     let payload = make_payload(&user_id, 42);
@@ -257,8 +244,7 @@ async fn pull_after_concurrent_pushes_merges_correctly() {
     let username = "rt_bob";
 
     let (access, refresh) = register_user_raw(&base, username, "bobpass1!").await;
-    store_tokens(username, &access, &refresh)
-        .expect("storing tokens in mock keyring must succeed");
+    store_tokens(username, &access, &refresh).expect("storing tokens in mock keyring must succeed");
 
     let user_id = decode_sub(&access);
 
@@ -269,11 +255,17 @@ async fn pull_after_concurrent_pushes_merges_correctly() {
 
     // Client A: low value first.
     let payload_a = make_payload(&user_id, 5);
-    client_a.push(&payload_a).await.expect("client A push must succeed");
+    client_a
+        .push(&payload_a)
+        .await
+        .expect("client A push must succeed");
 
     // Client B: higher value second.
     let payload_b = make_payload(&user_id, 99);
-    client_b.push(&payload_b).await.expect("client B push must succeed");
+    client_b
+        .push(&payload_b)
+        .await
+        .expect("client B push must succeed");
 
     // Either client should now pull max(5, 99) = 99.
     let pulled = client_a
@@ -330,8 +322,7 @@ async fn jwt_refresh_on_401_succeeds() {
     let username = "rt_expiring";
 
     // Register to get a real, valid refresh token signed with TEST_SECRET.
-    let (_real_access, real_refresh) =
-        register_user_raw(&base, username, "expirepass1!").await;
+    let (_real_access, real_refresh) = register_user_raw(&base, username, "expirepass1!").await;
     let user_id = decode_sub(&_real_access);
 
     // Craft an expired access token signed with TEST_SECRET so the server's
@@ -361,9 +352,10 @@ async fn jwt_refresh_on_401_succeeds() {
 
     // Pull: server returns 401, client refreshes, retries, succeeds.
     let client = SolitaireServerClient::new(&base, username);
-    let pulled = client.pull().await.expect(
-        "pull must succeed after the client transparently refreshes the access token",
-    );
+    let pulled = client
+        .pull()
+        .await
+        .expect("pull must succeed after the client transparently refreshes the access token");
     // Default merge for a never-pushed user yields games_played = 0.
     assert_eq!(
         pulled.stats.games_played, 0,
@@ -387,8 +379,7 @@ async fn pull_after_account_deletion_returns_default_or_error() {
     let username = "rt_deleter";
 
     let (access, refresh) = register_user_raw(&base, username, "deletepass1!").await;
-    store_tokens(username, &access, &refresh)
-        .expect("storing tokens in mock keyring must succeed");
+    store_tokens(username, &access, &refresh).expect("storing tokens in mock keyring must succeed");
 
     let user_id = decode_sub(&access);
     let client = SolitaireServerClient::new(&base, username);
@@ -431,8 +422,7 @@ async fn push_retries_after_401_on_expired_access_token() {
     let base = spawn_test_server().await;
     let username = "rt_push_expiring";
 
-    let (_real_access, real_refresh) =
-        register_user_raw(&base, username, "pushexpirepass1!").await;
+    let (_real_access, real_refresh) = register_user_raw(&base, username, "pushexpirepass1!").await;
     let user_id = decode_sub(&_real_access);
 
     #[derive(serde::Serialize)]

solitaire_engine/examples/card_face_generator.rs

@@ -27,8 +27,8 @@
 //! alongside the `card_plugin` constant migration.
 
 use solitaire_engine::assets::card_face_svg::{
-    back_svg, face_svg, rank_filename, suit_filename, theme_rank_token, theme_suit_token,
-    ALL_RANKS, ALL_SUITS, BACK_ACCENTS, TARGET,
+    ALL_RANKS, ALL_SUITS, BACK_ACCENTS, TARGET, back_svg, face_svg, rank_filename, suit_filename,
+    theme_rank_token, theme_suit_token,
 };
 use solitaire_engine::assets::rasterize_svg;
 use std::path::PathBuf;

solitaire_engine/examples/card_face_poc.rs

@@ -44,8 +44,8 @@ fn main() {
     // 256×384 = 2:3 aspect at half the default svg_loader resolution.
     // See migration plan § "Output format" for the rationale.
     let target = UVec2::new(256, 384);
-    let image = rasterize_svg(svg.as_bytes(), target)
-        .expect("rasterising the PoC SVG should succeed");
+    let image =
+        rasterize_svg(svg.as_bytes(), target).expect("rasterising the PoC SVG should succeed");
 
     let bytes = image
         .data
@@ -61,11 +61,13 @@ fn main() {
     // bytes from a Pixmap inside `svg_loader`; this round-trip is
     // the cost of going through Bevy's `Image` shape.
     let size = IntSize::from_wh(target.x, target.y).expect("target size is non-zero");
-    let pixmap = Pixmap::from_vec(bytes, size)
-        .expect("RGBA byte buffer should form a valid Pixmap");
+    let pixmap =
+        Pixmap::from_vec(bytes, size).expect("RGBA byte buffer should form a valid Pixmap");
 
     let out = "/tmp/ace_spades_terminal.png";
-    pixmap.save_png(out).expect("writing the PNG should succeed");
+    pixmap
+        .save_png(out)
+        .expect("writing the PNG should succeed");
 
     println!(
         "Wrote {} ({}×{} RGBA8, {} bytes on disk)",

solitaire_engine/examples/icon_generator.rs

@@ -18,7 +18,7 @@
 //! pipeline already used by every other generated asset).
 
 use bevy::math::UVec2;
-use solitaire_engine::assets::icon_svg::{icon_svg, ICON_SIZES};
+use solitaire_engine::assets::icon_svg::{ICON_SIZES, icon_svg};
 use solitaire_engine::assets::rasterize_svg;
 use std::path::PathBuf;
 use tiny_skia::{IntSize, Pixmap};

solitaire_engine/src/achievement_plugin.rs

@@ -11,12 +11,12 @@ use bevy::input::mouse::{MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
 use chrono::{Local, Timelike, Utc};
 use solitaire_core::achievement::{
-    achievement_by_id, check_achievements, AchievementContext, AchievementDef, Reward,
-    ALL_ACHIEVEMENTS,
+    ALL_ACHIEVEMENTS, AchievementContext, AchievementDef, Reward, achievement_by_id,
+    check_achievements,
 };
 use solitaire_data::{
-    achievements_file_path, load_achievements_from, save_achievements_to, save_settings_to,
-    AchievementRecord, save_progress_to,
+    AchievementRecord, achievements_file_path, load_achievements_from, save_achievements_to,
+    save_progress_to, save_settings_to,
 };
 
 use crate::events::{
@@ -31,8 +31,8 @@ use crate::resources::GameStateResource;
 use crate::settings_plugin::{SettingsResource, SettingsStoragePath};
 use crate::stats_plugin::{StatsResource, StatsUpdate};
 use crate::ui_modal::{
-    spawn_modal, spawn_modal_actions, spawn_modal_button, spawn_modal_header, ButtonVariant,
-    ModalScrim, ScrimDismissible,
+    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,
@@ -140,7 +140,10 @@ impl Plugin for AchievementPlugin {
             .add_systems(Update, toggle_achievements_screen)
             .add_systems(Update, handle_achievements_close_button)
             .add_systems(Update, scroll_achievements_panel)
-            .add_systems(Update, crate::ui_modal::touch_scroll_panel::<AchievementsScrollable>)
+            .add_systems(
+                Update,
+                crate::ui_modal::touch_scroll_panel::<AchievementsScrollable>,
+            )
             // Event-driven unlock: observe `ReplayPlaybackState` and unlock
             // `cinephile` the first time playback runs to natural completion.
             // Reads the resource via `Option<Res<_>>` so headless tests that
@@ -235,17 +238,23 @@ fn evaluate_on_win(
             unlocks.write(AchievementUnlockedEvent(record.clone()));
         }
 
-        if achievements_changed
-            && let Some(target) = &path.0
-                && let Err(e) = save_achievements_to(target, &achievements.0) {
-                    warn!("failed to save achievements: {e}");
-                }
-
+        // Persist progress FIRST. Only if that succeeds do we mark
+        // `reward_granted = true` on the achievements and save them.
+        // This prevents the corruption where reward_granted is persisted
+        // but the XP was not (permanent XP loss on next launch).
         if progress_changed
             && let Some(target) = &progress_path.0
-                && let Err(e) = save_progress_to(target, &progress.0) {
-                    warn!("failed to save progress after reward: {e}");
-                }
+            && let Err(e) = save_progress_to(target, &progress.0)
+        {
+            warn!("failed to save progress after reward: {e}");
+        }
+
+        if achievements_changed
+            && let Some(target) = &path.0
+            && let Err(e) = save_achievements_to(target, &achievements.0)
+        {
+            warn!("failed to save achievements: {e}");
+        }
     }
 }
 
@@ -486,9 +495,7 @@ fn spawn_achievements_screen(
         // greyed-out grid.
         if !any_unlocked {
             card.spawn((
-                Text::new(
-                    "Complete games and try new modes to unlock achievements and rewards.",
-                ),
+                Text::new("Complete games and try new modes to unlock achievements and rewards."),
                 TextFont {
                     font: font_res.map(|f| f.0.clone()).unwrap_or_default(),
                     font_size: TYPE_CAPTION,
@@ -802,7 +809,10 @@ mod tests {
         // trigger update_stats_on_win first (StatsUpdate runs before
         // evaluate_on_win), bumping draw_three_wins to 10 — the unlock
         // threshold for the draw_three_master achievement.
-        app.world_mut().resource_mut::<StatsResource>().0.draw_three_wins = 9;
+        app.world_mut()
+            .resource_mut::<StatsResource>()
+            .0
+            .draw_three_wins = 9;
 
         // The current game must be in DrawThree mode so update_on_win
         // increments draw_three_wins (and not draw_one_wins).
@@ -830,7 +840,10 @@ mod tests {
             .find(|r| r.id == "draw_three_master")
             .map(|r| r.unlocked)
             .unwrap_or(false);
-        assert!(unlocked, "draw_three_master must unlock at the 10th Draw-Three win");
+        assert!(
+            unlocked,
+            "draw_three_master must unlock at the 10th Draw-Three win"
+        );
 
         // Verify the AchievementUnlockedEvent fired for this id.
         let events = app.world().resource::<Messages<AchievementUnlockedEvent>>();
@@ -848,7 +861,10 @@ mod tests {
 
         // Pre-seed eight prior Draw-Three wins. The pending GameWonEvent
         // brings draw_three_wins to 9 — one short of the threshold.
-        app.world_mut().resource_mut::<StatsResource>().0.draw_three_wins = 8;
+        app.world_mut()
+            .resource_mut::<StatsResource>()
+            .0
+            .draw_three_wins = 8;
         app.world_mut()
             .resource_mut::<GameStateResource>()
             .0
@@ -871,7 +887,10 @@ mod tests {
             .find(|r| r.id == "draw_three_master")
             .map(|r| r.unlocked)
             .unwrap_or(false);
-        assert!(!unlocked, "draw_three_master must remain locked at 9 Draw-Three wins");
+        assert!(
+            !unlocked,
+            "draw_three_master must remain locked at 9 Draw-Three wins"
+        );
 
         let events = app.world().resource::<Messages<AchievementUnlockedEvent>>();
         let mut cursor = events.get_cursor();
@@ -892,10 +911,8 @@ mod tests {
 
         // Put the active game in Zen mode. evaluate_on_win reads
         // GameStateResource.mode directly to populate last_win_is_zen.
-        app.world_mut()
-            .resource_mut::<GameStateResource>()
-            .0
-            .mode = solitaire_core::game_state::GameMode::Zen;
+        app.world_mut().resource_mut::<GameStateResource>().0.mode =
+            solitaire_core::game_state::GameMode::Zen;
 
         app.world_mut().write_message(GameWonEvent {
             score: 0,
@@ -1170,9 +1187,9 @@ mod tests {
         // canonical secret description in `solitaire_core` is already
         // generic ("A secret achievement"); these checks guard against a
         // future leak where someone replaces it with the literal predicate.
-        let leaked_predicate = tips.iter().any(|t| {
-            t.contains("90") && t.to_lowercase().contains("without undo")
-        });
+        let leaked_predicate = tips
+            .iter()
+            .any(|t| t.contains("90") && t.to_lowercase().contains("without undo"));
         assert!(
             !leaked_predicate,
             "no tooltip may state the speed_and_skill predicate: {tips:?}"
@@ -1375,9 +1392,9 @@ mod tests {
     // -----------------------------------------------------------------------
 
     use crate::replay_playback::ReplayPlaybackState;
-    use solitaire_data::{Replay, ReplayMove};
     use chrono::NaiveDate;
     use solitaire_core::game_state::{DrawMode, GameMode};
+    use solitaire_data::{Replay, ReplayMove};
 
     /// Headless app variant that injects a default `ReplayPlaybackState`
     /// directly (no `ReplayPlaybackPlugin`) so we can drive the resource
@@ -1441,13 +1458,12 @@ mod tests {
 
         // Frame 1: enter Playing. The observer's first sample sees
         // `last_was_playing = false` and `now_playing = true`.
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
-            ReplayPlaybackState::Playing {
-                replay: dummy_replay(),
-                cursor: 0,
-                secs_to_next: 0.0,
-                paused: false,
-            };
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Playing {
+            replay: dummy_replay(),
+            cursor: 0,
+            secs_to_next: 0.0,
+            paused: false,
+        };
         app.update();
         assert!(
             !cinephile_unlocked(&app),
@@ -1456,8 +1472,7 @@ mod tests {
 
         // Frame 2: transition to Completed. The observer must detect
         // `last_was_playing = true && now_completed = true` and unlock.
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
-            ReplayPlaybackState::Completed;
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Completed;
         app.update();
 
         assert!(
@@ -1477,19 +1492,17 @@ mod tests {
     fn cinephile_does_not_unlock_on_stop_button_abort() {
         let mut app = cinephile_app();
 
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
-            ReplayPlaybackState::Playing {
-                replay: dummy_replay(),
-                cursor: 0,
-                secs_to_next: 0.0,
-                paused: false,
-            };
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Playing {
+            replay: dummy_replay(),
+            cursor: 0,
+            secs_to_next: 0.0,
+            paused: false,
+        };
         app.update();
 
         // Direct Playing → Inactive — the path the Stop button takes via
         // `stop_replay_playback`. Must not unlock cinephile.
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
-            ReplayPlaybackState::Inactive;
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Inactive;
         app.update();
 
         assert!(
@@ -1510,18 +1523,19 @@ mod tests {
         let mut app = cinephile_app();
 
         // First completion cycle to unlock.
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
-            ReplayPlaybackState::Playing {
-                replay: dummy_replay(),
-                cursor: 0,
-                secs_to_next: 0.0,
-                paused: false,
-            };
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Playing {
+            replay: dummy_replay(),
+            cursor: 0,
+            secs_to_next: 0.0,
+            paused: false,
+        };
         app.update();
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
-            ReplayPlaybackState::Completed;
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Completed;
         app.update();
-        assert!(cinephile_unlocked(&app), "precondition: first cycle must unlock");
+        assert!(
+            cinephile_unlocked(&app),
+            "precondition: first cycle must unlock"
+        );
 
         // Drain the event queue so the next assertion doesn't double-count
         // the legitimate first-time unlock event.
@@ -1530,19 +1544,16 @@ mod tests {
             .clear();
 
         // Second cycle: Inactive → Playing → Completed once more.
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
-            ReplayPlaybackState::Inactive;
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Inactive;
         app.update();
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
-            ReplayPlaybackState::Playing {
-                replay: dummy_replay(),
-                cursor: 0,
-                secs_to_next: 0.0,
-                paused: false,
-            };
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Playing {
+            replay: dummy_replay(),
+            cursor: 0,
+            secs_to_next: 0.0,
+            paused: false,
+        };
         app.update();
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
-            ReplayPlaybackState::Completed;
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Completed;
         app.update();
 
         assert_eq!(
@@ -1559,16 +1570,14 @@ mod tests {
     fn cinephile_fires_once_across_completed_linger() {
         let mut app = cinephile_app();
 
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
-            ReplayPlaybackState::Playing {
-                replay: dummy_replay(),
-                cursor: 0,
-                secs_to_next: 0.0,
-                paused: false,
-            };
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Playing {
+            replay: dummy_replay(),
+            cursor: 0,
+            secs_to_next: 0.0,
+            paused: false,
+        };
         app.update();
-        *app.world_mut().resource_mut::<ReplayPlaybackState>() =
-            ReplayPlaybackState::Completed;
+        *app.world_mut().resource_mut::<ReplayPlaybackState>() = ReplayPlaybackState::Completed;
         app.update();
         // Stay in Completed for a few more frames as the real auto-clear
         // does. Each subsequent frame the resource is still `Completed`

solitaire_engine/src/analytics_plugin.rs

@@ -9,7 +9,7 @@ use std::sync::Arc;
 use bevy::prelude::*;
 use bevy::tasks::AsyncComputeTaskPool;
 use solitaire_core::game_state::GameMode;
-use solitaire_data::{matomo_client::MatomoClient, settings::SyncBackend, Settings};
+use solitaire_data::{Settings, matomo_client::MatomoClient, settings::SyncBackend};
 
 use crate::events::{AchievementUnlockedEvent, ForfeitEvent, GameWonEvent, NewGameRequestEvent};
 use crate::resources::{GameStateResource, TokioRuntimeResource};
@@ -59,13 +59,13 @@ impl Plugin for AnalyticsPlugin {
         // refuses to create threads (resource-limited / sandboxed environments).
         match TokioRuntimeResource::new() {
             Ok(rt) => {
-                app.insert_resource(rt).add_systems(
-                    Update,
-                    (on_game_won, on_forfeit, tick_flush_timer),
-                );
+                app.insert_resource(rt)
+                    .add_systems(Update, (on_game_won, on_forfeit, tick_flush_timer));
             }
             Err(e) => {
-                bevy::log::warn!("analytics_plugin: Tokio runtime unavailable — analytics flush disabled: {e}");
+                bevy::log::warn!(
+                    "analytics_plugin: Tokio runtime unavailable — analytics flush disabled: {e}"
+                );
             }
         }
     }
@@ -96,9 +96,13 @@ fn on_game_won(
     let Some(client) = analytics.client.clone() else {
         return;
     };
+    let mut any = false;
     for ev in wins.read() {
         client.event("Game", "Won", None, Some(ev.score as f64));
-        fire_flush(client.clone(), rt.0.clone());
+        any = true;
+    }
+    if any {
+        fire_flush(client, rt.0.clone());
     }
 }
 
@@ -110,9 +114,13 @@ fn on_forfeit(
     let Some(client) = analytics.client.clone() else {
         return;
     };
+    let mut any = false;
     for _ev in forfeits.read() {
         client.event("Game", "Forfeit", None, None);
-        fire_flush(client.clone(), rt.0.clone());
+        any = true;
+    }
+    if any {
+        fire_flush(client, rt.0.clone());
     }
 }
 
@@ -172,7 +180,11 @@ fn client_for(settings: &Settings) -> Option<Arc<MatomoClient>> {
         SyncBackend::SolitaireServer { username, .. } => Some(username.clone()),
         SyncBackend::Local => None,
     };
-    Some(Arc::new(MatomoClient::new(url, settings.matomo_site_id, uid)))
+    Some(Arc::new(MatomoClient::new(
+        url,
+        settings.matomo_site_id,
+        uid,
+    )))
 }
 
 fn fire_flush(client: Arc<MatomoClient>, rt: Arc<tokio::runtime::Runtime>) {

solitaire_engine/src/android_clipboard.rs

@@ -6,8 +6,8 @@
 pub fn set_text(text: &str) -> Result<(), String> {
     use bevy::android::ANDROID_APP;
     use jni::{
-        objects::{JObject, JValueOwned},
         JavaVM,
+        objects::{JObject, JValueOwned},
     };
 
     let app = ANDROID_APP

solitaire_engine/src/animation_plugin.rs

@@ -17,7 +17,7 @@ use solitaire_data::{AnimSpeed, Settings};
 
 use crate::achievement_plugin::display_name_for;
 use crate::auto_complete_plugin::AutoCompleteState;
-use crate::card_animation::{sample_curve, CardAnimation, MotionCurve};
+use crate::card_animation::{CardAnimation, MotionCurve, sample_curve};
 use crate::card_plugin::CardEntity;
 use crate::challenge_plugin::ChallengeAdvancedEvent;
 use crate::daily_challenge_plugin::{DailyChallengeCompletedEvent, DailyGoalAnnouncementEvent};
@@ -32,9 +32,9 @@ use crate::progress_plugin::LevelUpEvent;
 use crate::settings_plugin::{SettingsChangedEvent, SettingsResource};
 use crate::time_attack_plugin::TimeAttackEndedEvent;
 use crate::ui_theme::{
-    scaled_duration, ACCENT_SECONDARY, BG_ELEVATED, MOTION_CASCADE_SLIDE_SECS,
-    MOTION_CASCADE_STAGGER_SECS, MOTION_SLIDE_SECS, RADIUS_MD, STATE_DANGER, STATE_INFO,
-    STATE_WARNING, TEXT_PRIMARY, TYPE_BODY_LG, VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4, Z_TOAST,
+    ACCENT_SECONDARY, BG_ELEVATED, MOTION_CASCADE_SLIDE_SECS, MOTION_CASCADE_STAGGER_SECS,
+    MOTION_SLIDE_SECS, RADIUS_MD, STATE_DANGER, STATE_INFO, STATE_WARNING, TEXT_PRIMARY,
+    TYPE_BODY_LG, VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4, Z_TOAST, scaled_duration,
 };
 use crate::weekly_goals_plugin::WeeklyGoalCompletedEvent;
 
@@ -53,7 +53,9 @@ pub struct EffectiveSlideDuration {
 
 impl Default for EffectiveSlideDuration {
     fn default() -> Self {
-        Self { slide_secs: SLIDE_SECS }
+        Self {
+            slide_secs: SLIDE_SECS,
+        }
     }
 }
 
@@ -329,12 +331,12 @@ fn handle_win_cascade(
         Vec3::new(-margin, 0.0, 300.0),
     ];
 
-    let step = settings
-        .as_ref()
-        .map_or(CASCADE_STAGGER_NORMAL, |s| cascade_step_secs(s.0.animation_speed));
-    let duration = settings
-        .as_ref()
-        .map_or(CASCADE_DURATION_NORMAL, |s| cascade_duration_secs(s.0.animation_speed));
+    let step = settings.as_ref().map_or(CASCADE_STAGGER_NORMAL, |s| {
+        cascade_step_secs(s.0.animation_speed)
+    });
+    let duration = settings.as_ref().map_or(CASCADE_DURATION_NORMAL, |s| {
+        cascade_duration_secs(s.0.animation_speed)
+    });
 
     for (i, (entity, transform)) in cards.iter().enumerate() {
         // Use the curve-aware `CardAnimation` here (not `CardAnim`) so we can
@@ -444,7 +446,11 @@ fn handle_time_attack_toast(
     for ev in events.read() {
         spawn_toast(
             &mut commands,
-            format!("Time Attack: {} win{}", ev.wins, if ev.wins == 1 { "" } else { "s" }),
+            format!(
+                "Time Attack: {} win{}",
+                ev.wins,
+                if ev.wins == 1 { "" } else { "s" }
+            ),
             TIME_ATTACK_TOAST_SECS,
             ToastVariant::Info,
         );
@@ -528,10 +534,7 @@ fn handle_auto_complete_toast(
 /// This is the first half of the two-system toast queue (Task #67). The queue
 /// decouples event production from rendering so multiple simultaneous events do
 /// not cause overlapping toast text on screen.
-fn enqueue_toasts(
-    mut events: MessageReader<InfoToastEvent>,
-    mut queue: ResMut<ToastQueue>,
-) {
+fn enqueue_toasts(mut events: MessageReader<InfoToastEvent>, mut queue: ResMut<ToastQueue>) {
     for ev in events.read() {
         queue.0.push_back(ev.0.clone());
     }
@@ -572,11 +575,12 @@ fn drive_toast_display(
 
     // If no active toast and the queue has messages, show the next one.
     if active.entity.is_none()
-        && let Some(message) = queue.0.pop_front() {
-            let entity = spawn_queued_toast(&mut commands, message);
-            active.entity = Some(entity);
-            active.timer = QUEUED_TOAST_SECS;
-        }
+        && let Some(message) = queue.0.pop_front()
+    {
+        let entity = spawn_queued_toast(&mut commands, message);
+        active.entity = Some(entity);
+        active.timer = QUEUED_TOAST_SECS;
+    }
 }
 
 /// Visual variant of a toast — drives the 1px border accent per the
@@ -682,10 +686,7 @@ fn handle_move_rejected_toast(
 /// Mirrors [`handle_move_rejected_toast`] but reads a generic carrier
 /// event (not a domain-specific one) because Warning has multiple
 /// candidate drivers and the call-site knows the message wording.
-fn handle_warning_toast(
-    mut commands: Commands,
-    mut events: MessageReader<WarningToastEvent>,
-) {
+fn handle_warning_toast(mut commands: Commands, mut events: MessageReader<WarningToastEvent>) {
     for ev in events.read() {
         spawn_toast(&mut commands, ev.0.clone(), 4.0, ToastVariant::Warning);
     }
@@ -832,7 +833,11 @@ mod tests {
             reduce_motion_mode: true,
             ..Settings::default()
         };
-        assert_eq!(effective_slide_secs(&s), 0.0, "Fast + reduce-motion still 0.0");
+        assert_eq!(
+            effective_slide_secs(&s),
+            0.0,
+            "Fast + reduce-motion still 0.0"
+        );
     }
 
     #[test]
@@ -869,13 +874,24 @@ mod tests {
             .world_mut()
             .spawn((
                 Transform::from_translation(start),
-                CardAnim { start, target, elapsed: 0.5, duration: 1.0, delay: 0.0 },
+                CardAnim {
+                    start,
+                    target,
+                    elapsed: 0.5,
+                    duration: 1.0,
+                    delay: 0.0,
+                },
             ))
             .id();
 
         app.update();
 
-        let pos = app.world().entity(entity).get::<Transform>().unwrap().translation;
+        let pos = app
+            .world()
+            .entity(entity)
+            .get::<Transform>()
+            .unwrap()
+            .translation;
         assert!(
             pos.x > 50.0 && pos.x < 100.0,
             "with SmoothSnap, t=0.5 should be past geometric midpoint but short of target; got {}",
@@ -897,7 +913,13 @@ mod tests {
             .world_mut()
             .spawn((
                 Transform::from_translation(Vec3::ZERO),
-                CardAnim { start: Vec3::ZERO, target, elapsed: 1.0, duration: 1.0, delay: 0.0 },
+                CardAnim {
+                    start: Vec3::ZERO,
+                    target,
+                    elapsed: 1.0,
+                    duration: 1.0,
+                    delay: 0.0,
+                },
             ))
             .id();
 
@@ -907,7 +929,12 @@ mod tests {
             app.world().entity(entity).get::<CardAnim>().is_none(),
             "CardAnim should be removed when done"
         );
-        let pos = app.world().entity(entity).get::<Transform>().unwrap().translation;
+        let pos = app
+            .world()
+            .entity(entity)
+            .get::<Transform>()
+            .unwrap()
+            .translation;
         assert!((pos.x - 10.0).abs() < 1e-3);
     }
 
@@ -932,7 +959,12 @@ mod tests {
 
         app.update();
 
-        let pos = app.world().entity(entity).get::<Transform>().unwrap().translation;
+        let pos = app
+            .world()
+            .entity(entity)
+            .get::<Transform>()
+            .unwrap()
+            .translation;
         assert!(pos.x.abs() < 1e-3, "card must not move during delay period");
     }
 
@@ -1021,7 +1053,8 @@ mod tests {
         let mut app = App::new();
         app.add_plugins(MinimalPlugins).add_plugins(AnimationPlugin);
 
-        app.world_mut().write_message(InfoToastEvent("hello".to_string()));
+        app.world_mut()
+            .write_message(InfoToastEvent("hello".to_string()));
         app.update();
 
         let count = app
@@ -1125,8 +1158,12 @@ mod tests {
         let mut app = App::new();
         app.add_plugins(MinimalPlugins).add_plugins(AnimationPlugin);
 
-        let fast_settings = Settings { animation_speed: AnimSpeed::Fast, ..Default::default() };
-        app.world_mut().write_message(SettingsChangedEvent(fast_settings));
+        let fast_settings = Settings {
+            animation_speed: AnimSpeed::Fast,
+            ..Default::default()
+        };
+        app.world_mut()
+            .write_message(SettingsChangedEvent(fast_settings));
         app.update();
 
         let dur = app.world().resource::<EffectiveSlideDuration>().slide_secs;
@@ -1144,8 +1181,10 @@ mod tests {
             .count();
         assert_eq!(before, 0, "no animations before win");
 
-        app.world_mut()
-            .write_message(GameWonEvent { score: 500, time_seconds: 60 });
+        app.world_mut().write_message(GameWonEvent {
+            score: 500,
+            time_seconds: 60,
+        });
         app.update();
 
         let after = app
@@ -1162,8 +1201,10 @@ mod tests {
     #[test]
     fn win_cascade_uses_expressive_curve() {
         let mut app = app_with_anim();
-        app.world_mut()
-            .write_message(GameWonEvent { score: 0, time_seconds: 0 });
+        app.world_mut().write_message(GameWonEvent {
+            score: 0,
+            time_seconds: 0,
+        });
         app.update();
 
         let mut q = app.world_mut().query::<&CardAnimation>();
@@ -1179,8 +1220,10 @@ mod tests {
     #[test]
     fn win_cascade_applies_per_card_rotation() {
         let mut app = app_with_anim();
-        app.world_mut()
-            .write_message(GameWonEvent { score: 0, time_seconds: 0 });
+        app.world_mut().write_message(GameWonEvent {
+            score: 0,
+            time_seconds: 0,
+        });
         app.update();
 
         // At least one card's rotation must differ from identity — the
@@ -1190,7 +1233,10 @@ mod tests {
         let any_rotated = q
             .iter(app.world())
             .any(|(_, t)| t.rotation.z.abs() > 1e-4 || t.rotation.w < 0.999);
-        assert!(any_rotated, "expected at least one card to receive a Z rotation drift");
+        assert!(
+            any_rotated,
+            "expected at least one card to receive a Z rotation drift"
+        );
     }
 
     #[test]

solitaire_engine/src/assets/mod.rs

@@ -11,9 +11,9 @@ pub mod svg_loader;
 pub mod user_dir;
 
 pub use sources::{
+    AssetSourcesPlugin, CLASSIC_THEME_MANIFEST_URL, DARK_THEME_MANIFEST_URL, USER_THEMES,
     bundled_theme_url, classic_theme_svg_bytes, dark_theme_svg_bytes,
     populate_embedded_classic_theme, populate_embedded_dark_theme, register_theme_asset_sources,
-    AssetSourcesPlugin, CLASSIC_THEME_MANIFEST_URL, DARK_THEME_MANIFEST_URL, USER_THEMES,
 };
-pub use svg_loader::{rasterize_svg, SvgLoader, SvgLoaderError, SvgLoaderSettings};
+pub use svg_loader::{SvgLoader, SvgLoaderError, SvgLoaderSettings, rasterize_svg};
 pub use user_dir::{set_user_theme_dir, user_theme_dir};

solitaire_engine/src/assets/sources.rs

@@ -47,10 +47,10 @@
 //! comments on each call out the pairing so a future reader doesn't
 //! accidentally drop one half.
 
+use bevy::asset::AssetApp;
+use bevy::asset::io::AssetSourceBuilder;
 use bevy::asset::io::embedded::EmbeddedAssetRegistry;
 use bevy::asset::io::file::FileAssetReader;
-use bevy::asset::io::AssetSourceBuilder;
-use bevy::asset::AssetApp;
 use bevy::prelude::*;
 
 use crate::assets::user_dir::user_theme_dir;
@@ -75,8 +75,7 @@ pub const DARK_THEME_MANIFEST_URL: &str =
 const DARK_THEME_MANIFEST_PATH: &str = "solitaire_engine/assets/themes/dark/theme.ron";
 
 /// Bytes of the bundled Dark theme manifest, embedded at compile time.
-const DARK_THEME_MANIFEST_BYTES: &[u8] =
-    include_bytes!("../../assets/themes/dark/theme.ron");
+const DARK_THEME_MANIFEST_BYTES: &[u8] = include_bytes!("../../assets/themes/dark/theme.ron");
 
 /// Stable embedded asset URL of the bundled Classic theme manifest.
 pub const CLASSIC_THEME_MANIFEST_URL: &str =
@@ -89,8 +88,7 @@ pub const CLASSIC_THEME_MANIFEST_URL: &str =
 const CLASSIC_THEME_MANIFEST_PATH: &str = "solitaire_engine/assets/themes/classic/theme.ron";
 
 /// Bytes of the bundled Classic theme manifest, embedded at compile time.
-const CLASSIC_THEME_MANIFEST_BYTES: &[u8] =
-    include_bytes!("../../assets/themes/classic/theme.ron");
+const CLASSIC_THEME_MANIFEST_BYTES: &[u8] = include_bytes!("../../assets/themes/classic/theme.ron");
 
 /// Generates a `(stable_path, bytes)` entry for one Dark-theme SVG.
 macro_rules! embed_dark_svg {
@@ -377,10 +375,11 @@ mod tests {
     fn populate_embedded_dark_theme_runs_without_asset_plugin() {
         let mut app = App::new();
         populate_embedded_dark_theme(&mut app);
-        assert!(app
-            .world()
-            .get_resource::<EmbeddedAssetRegistry>()
-            .is_some());
+        assert!(
+            app.world()
+                .get_resource::<EmbeddedAssetRegistry>()
+                .is_some()
+        );
     }
 
     #[test]
@@ -425,10 +424,11 @@ mod tests {
     fn populate_embedded_classic_theme_runs_without_asset_plugin() {
         let mut app = App::new();
         populate_embedded_classic_theme(&mut app);
-        assert!(app
-            .world()
-            .get_resource::<EmbeddedAssetRegistry>()
-            .is_some());
+        assert!(
+            app.world()
+                .get_resource::<EmbeddedAssetRegistry>()
+                .is_some()
+        );
     }
 
     #[test]

solitaire_engine/src/assets/svg_loader.rs

@@ -24,6 +24,7 @@ use std::sync::{Arc, OnceLock};
 use bevy::asset::io::Reader;
 use bevy::asset::{AssetLoader, LoadContext, RenderAssetUsages};
 use bevy::image::Image;
+use bevy::log::warn;
 use bevy::math::UVec2;
 use bevy::reflect::TypePath;
 use bevy::render::render_resource::{Extent3d, TextureDimension, TextureFormat};
@@ -156,7 +157,7 @@ pub fn rasterize_svg(svg_bytes: &[u8], target: UVec2) -> Result<Image, SvgLoader
 /// share the same canonical face.
 const BUNDLED_FONT_BYTES: &[u8] = include_bytes!("../../../assets/fonts/main.ttf");
 
-/// Returns a process-wide font database holding only the bundled
+/// Returns a process-wide font database that tries to load the bundled
 /// FiraMono-Medium face. Initialised lazily on first SVG that references
 /// text, then shared (via `Arc`) across every subsequent rasterisation.
 ///
@@ -165,17 +166,19 @@ const BUNDLED_FONT_BYTES: &[u8] = include_bytes!("../../../assets/fonts/main.ttf
 /// such request directly to FiraMono so rasterisation is deterministic
 /// across machines and the system font path is never consulted.
 ///
-/// Aborts the program if the embedded bytes don't parse — bundled at
-/// compile time, so a parse failure means the binary is corrupt.
+/// If the embedded bytes fail to yield any faces, log a warning and
+/// fall back to an empty database so startup can continue.
 fn shared_fontdb() -> Arc<fontdb::Database> {
     static DB: OnceLock<Arc<fontdb::Database>> = OnceLock::new();
     DB.get_or_init(|| {
         let mut db = fontdb::Database::new();
-        db.load_font_data(BUNDLED_FONT_BYTES.to_vec());
-        assert!(
-            db.faces().next().is_some(),
-            "bundled FiraMono failed to parse — binary is corrupt"
-        );
+        let loaded_faces = db.load_font_source(fontdb::Source::Binary(Arc::new(
+            BUNDLED_FONT_BYTES.to_vec(),
+        )));
+        if loaded_faces.is_empty() {
+            let e = "no faces loaded from bundled bytes";
+            warn!("Failed to load bundled FiraMono font: {e}");
+        }
         Arc::new(db)
     })
     .clone()
@@ -245,8 +248,7 @@ mod tests {
 
     #[test]
     fn rasterizes_svg_with_unmatched_font_family() {
-        let image =
-            rasterize_svg(TEST_SVG_WITH_TEXT, UVec2::new(64, 96)).expect("rasterisation");
+        let image = rasterize_svg(TEST_SVG_WITH_TEXT, UVec2::new(64, 96)).expect("rasterisation");
         assert_eq!(image.size().x, 64);
         assert_eq!(image.size().y, 96);
     }
@@ -259,9 +261,11 @@ mod tests {
 
     #[test]
     fn pixmap_data_is_rgba_with_target_byte_count() {
-        let image =
-            rasterize_svg(TEST_SVG, UVec2::new(32, 48)).expect("rasterisation");
-        let pixels = image.data.as_ref().expect("rasterised image carries pixel data");
+        let image = rasterize_svg(TEST_SVG, UVec2::new(32, 48)).expect("rasterisation");
+        let pixels = image
+            .data
+            .as_ref()
+            .expect("rasterised image carries pixel data");
         // 32 × 48 × 4 (RGBA bytes) = 6144 bytes
         assert_eq!(pixels.len(), 32 * 48 * 4);
     }

solitaire_engine/src/assets/user_dir.rs

@@ -123,7 +123,10 @@ mod tests {
         // user's `$HOME` on desktop, but it must at least be a
         // non-empty path with a parent component.
         let dir = detected_platform_data_dir();
-        assert!(dir.parent().is_some(), "data dir {dir:?} should be absolute");
+        assert!(
+            dir.parent().is_some(),
+            "data dir {dir:?} should be absolute"
+        );
     }
 
     // The OnceLock-based override is intentionally NOT covered here:

solitaire_engine/src/audio_plugin.rs

@@ -22,8 +22,8 @@
 use std::io::Cursor;
 
 use bevy::prelude::*;
-use kira::sound::static_sound::{StaticSoundData, StaticSoundHandle};
 use kira::sound::Region;
+use kira::sound::static_sound::{StaticSoundData, StaticSoundHandle};
 use kira::track::{TrackBuilder, TrackHandle};
 use kira::{AudioManager, AudioManagerSettings, Decibels, DefaultBackend, Tween, Value};
 
@@ -178,8 +178,7 @@ fn build_library() -> Option<SoundLibrary> {
     let place = decode(include_bytes!("../../assets/audio/card_place.wav"))?;
     let invalid = decode(include_bytes!("../../assets/audio/card_invalid.wav"))?;
     let fanfare = decode(include_bytes!("../../assets/audio/win_fanfare.wav"))?;
-    let foundation_complete =
-        decode(include_bytes!("../../assets/audio/foundation_complete.wav"))?;
+    let foundation_complete = decode(include_bytes!("../../assets/audio/foundation_complete.wav"))?;
     Some(SoundLibrary {
         deal,
         flip,
@@ -212,8 +211,7 @@ fn start_ambient_loop(
 ) -> Option<StaticSoundHandle> {
     let manager = manager?;
 
-    let ambient_bytes: &'static [u8] =
-        include_bytes!("../../assets/audio/ambient_loop.wav");
+    let ambient_bytes: &'static [u8] = include_bytes!("../../assets/audio/ambient_loop.wav");
     let mut data = match StaticSoundData::from_cursor(Cursor::new(ambient_bytes.to_vec())) {
         Ok(d) => d,
         Err(e) => {
@@ -280,13 +278,19 @@ impl AudioState {
 
 fn set_sfx_volume(audio: &mut AudioState, volume: f32) {
     if let Some(track) = audio.sfx_track.as_mut() {
-        track.set_volume(amplitude_to_decibels(volume.clamp(0.0, 1.0)), Tween::default());
+        track.set_volume(
+            amplitude_to_decibels(volume.clamp(0.0, 1.0)),
+            Tween::default(),
+        );
     }
 }
 
 fn set_music_volume(audio: &mut AudioState, volume: f32) {
     if let Some(track) = audio.music_track.as_mut() {
-        track.set_volume(amplitude_to_decibels(volume.clamp(0.0, 1.0)), Tween::default());
+        track.set_volume(
+            amplitude_to_decibels(volume.clamp(0.0, 1.0)),
+            Tween::default(),
+        );
     }
 }
 
@@ -319,7 +323,10 @@ fn apply_volume_on_change(
         let sfx_muted = mute.as_ref().is_some_and(|m| m.sfx_muted);
         let music_muted = mute.as_ref().is_some_and(|m| m.music_muted);
         set_sfx_volume(&mut audio, if sfx_muted { 0.0 } else { ev.0.sfx_volume });
-        set_music_volume(&mut audio, if music_muted { 0.0 } else { ev.0.music_volume });
+        set_music_volume(
+            &mut audio,
+            if music_muted { 0.0 } else { ev.0.music_volume },
+        );
     }
 }
 
@@ -374,8 +381,7 @@ fn play_on_draw(
 
         if is_recycle(stock_len) {
             let mut data = lib.flip.clone();
-            data.settings.volume =
-                Value::Fixed(amplitude_to_decibels(RECYCLE_VOLUME as f32));
+            data.settings.volume = Value::Fixed(amplitude_to_decibels(RECYCLE_VOLUME as f32));
             let result = if let Some(track) = audio.sfx_track.as_mut() {
                 track.play(data)
             } else if let Some(manager) = audio.manager.as_mut() {
@@ -516,7 +522,10 @@ mod tests {
         toggle_all(&mut m);
         assert!(m.sfx_muted && m.music_muted, "M should mute both channels");
         toggle_all(&mut m);
-        assert!(!m.sfx_muted && !m.music_muted, "second M should unmute both channels");
+        assert!(
+            !m.sfx_muted && !m.music_muted,
+            "second M should unmute both channels"
+        );
     }
 
     #[test]
@@ -537,14 +546,23 @@ mod tests {
         assert!(m.music_muted && !m.sfx_muted);
         // M should mute sfx (not-all-muted → mute-all).
         toggle_all(&mut m);
-        assert!(m.sfx_muted && m.music_muted, "M unmutes neither — it mutes all when sfx was audible");
+        assert!(
+            m.sfx_muted && m.music_muted,
+            "M unmutes neither — it mutes all when sfx was audible"
+        );
     }
 
     #[test]
     fn mute_all_when_both_already_muted_unmutes_both() {
-        let mut m = MuteState { sfx_muted: true, music_muted: true };
+        let mut m = MuteState {
+            sfx_muted: true,
+            music_muted: true,
+        };
         toggle_all(&mut m);
-        assert!(!m.sfx_muted && !m.music_muted, "M should unmute both when all were muted");
+        assert!(
+            !m.sfx_muted && !m.music_muted,
+            "M should unmute both when all were muted"
+        );
     }
 
     // -----------------------------------------------------------------------

solitaire_engine/src/auto_complete_plugin.rs

@@ -39,17 +39,16 @@ pub struct AutoCompletePlugin;
 
 impl Plugin for AutoCompletePlugin {
     fn build(&self, app: &mut App) {
-        app.init_resource::<AutoCompleteState>()
-            .add_systems(
-                Update,
-                (
-                    detect_auto_complete,
-                    on_auto_complete_start,
-                    drive_auto_complete,
-                )
-                    .chain()
-                    .after(GameMutation),
-            );
+        app.init_resource::<AutoCompleteState>().add_systems(
+            Update,
+            (
+                detect_auto_complete,
+                on_auto_complete_start,
+                drive_auto_complete,
+            )
+                .chain()
+                .after(GameMutation),
+        );
     }
 }
 
@@ -103,7 +102,9 @@ fn on_auto_complete_start(
         return;
     }
 
-    let (Some(audio), Some(lib)) = (audio.as_mut(), lib) else { return };
+    let (Some(audio), Some(lib)) = (audio.as_mut(), lib) else {
+        return;
+    };
     audio.play_sfx_at_volume(&lib.fanfare, AUTO_COMPLETE_CHIME_VOLUME);
 }
 
@@ -163,14 +164,22 @@ mod tests {
         g.piles.get_mut(&PileType::Stock).unwrap().cards.clear();
         g.piles.get_mut(&PileType::Waste).unwrap().cards.clear();
         for i in 0..7 {
-            g.piles.get_mut(&PileType::Tableau(i)).unwrap().cards.clear();
+            g.piles
+                .get_mut(&PileType::Tableau(i))
+                .unwrap()
+                .cards
+                .clear();
         }
-        g.piles.get_mut(&PileType::Tableau(0)).unwrap().cards.push(Card {
-            id: 99,
-            suit: Suit::Clubs,
-            rank: Rank::Ace,
-            face_up: true,
-        });
+        g.piles
+            .get_mut(&PileType::Tableau(0))
+            .unwrap()
+            .cards
+            .push(Card {
+                id: 99,
+                suit: Suit::Clubs,
+                rank: Rank::Ace,
+                face_up: true,
+            });
         g.is_auto_completable = true;
         g
     }

solitaire_engine/src/avatar_plugin.rs

@@ -19,7 +19,7 @@
 
 use bevy::asset::RenderAssetUsages;
 use bevy::prelude::*;
-use bevy::tasks::{futures_lite::future, AsyncComputeTaskPool, Task};
+use bevy::tasks::{AsyncComputeTaskPool, Task, futures_lite::future};
 
 use crate::resources::TokioRuntimeResource;
 
@@ -60,7 +60,9 @@ impl Plugin for AvatarPlugin {
                     .add_systems(Update, handle_avatar_fetch);
             }
             Err(e) => {
-                bevy::log::warn!("avatar_plugin: Tokio runtime unavailable — avatar fetch disabled: {e}");
+                bevy::log::warn!(
+                    "avatar_plugin: Tokio runtime unavailable — avatar fetch disabled: {e}"
+                );
             }
         }
     }
@@ -78,14 +80,7 @@ fn handle_avatar_fetch(
         pending.0 = Some(AsyncComputeTaskPool::get().spawn(async move {
             rt.block_on(async move {
                 let client = reqwest::Client::new();
-                let bytes = client
-                    .get(&url)
-                    .send()
-                    .await
-                    .ok()?
-                    .bytes()
-                    .await
-                    .ok()?;
+                let bytes = client.get(&url).send().await.ok()?.bytes().await.ok()?;
                 Some(bytes.to_vec())
             })
         }));

solitaire_engine/src/card_animation/animation.rs

@@ -34,7 +34,7 @@ use std::f32::consts::PI;
 
 use bevy::prelude::*;
 
-use super::curves::{sample_curve, MotionCurve};
+use super::curves::{MotionCurve, sample_curve};
 use super::timing::compute_duration;
 use crate::pause_plugin::PausedResource;
 
@@ -192,7 +192,11 @@ pub fn retarget_animation(
             let carry = (t * 0.12).min(0.10);
             (anim.current_xy(), transform.translation.z, carry)
         }
-        _ => (transform.translation.truncate(), transform.translation.z, 0.0),
+        _ => (
+            transform.translation.truncate(),
+            transform.translation.z,
+            0.0,
+        ),
     };
 
     let distance = current_xy.distance(new_end);
@@ -328,7 +332,10 @@ mod tests {
     fn current_xy_at_start() {
         let anim = make_anim(Vec2::ZERO, Vec2::new(100.0, 0.0), 0.0, 1.0);
         let pos = anim.current_xy();
-        assert!(pos.x < 5.0, "at t=0 position should be near start, got {pos:?}");
+        assert!(
+            pos.x < 5.0,
+            "at t=0 position should be near start, got {pos:?}"
+        );
     }
 
     #[test]
@@ -390,7 +397,10 @@ mod tests {
     fn win_scatter_targets_are_off_center() {
         for t in win_scatter_targets(400.0) {
             let dist = t.length();
-            assert!(dist > 100.0, "scatter target should be well off-center: {t:?}");
+            assert!(
+                dist > 100.0,
+                "scatter target should be well off-center: {t:?}"
+            );
         }
     }
 }

solitaire_engine/src/card_animation/curves.rs

@@ -126,7 +126,12 @@ mod tests {
             MotionCurve::Responsive,
             MotionCurve::Expressive,
         ] {
-            assert_near(sample_curve(curve, 0.0), 0.0, 1e-5, &format!("{curve:?} at t=0"));
+            assert_near(
+                sample_curve(curve, 0.0),
+                0.0,
+                1e-5,
+                &format!("{curve:?} at t=0"),
+            );
         }
     }
 
@@ -137,7 +142,12 @@ mod tests {
             MotionCurve::SoftBounce,
             MotionCurve::Responsive,
         ] {
-            assert_near(sample_curve(curve, 1.0), 1.0, 1e-4, &format!("{curve:?} at t=1"));
+            assert_near(
+                sample_curve(curve, 1.0),
+                1.0,
+                1e-4,
+                &format!("{curve:?} at t=1"),
+            );
         }
         // Spring-based curves have residual oscillation at finite t=1; allow 2 e-3.
         assert_near(
@@ -159,8 +169,14 @@ mod tests {
     fn smooth_snap_overshoots_slightly_near_end() {
         // Peak overshoot is around t = 0.875.
         let peak = sample_curve(MotionCurve::SmoothSnap, 0.875);
-        assert!(peak > 1.0, "SmoothSnap should overshoot at t=0.875, got {peak}");
-        assert!(peak < 1.03, "SmoothSnap overshoot should be small (<3 %), got {peak}");
+        assert!(
+            peak > 1.0,
+            "SmoothSnap should overshoot at t=0.875, got {peak}"
+        );
+        assert!(
+            peak < 1.03,
+            "SmoothSnap overshoot should be small (<3 %), got {peak}"
+        );
     }
 
     #[test]
@@ -186,11 +202,21 @@ mod tests {
 
     #[test]
     fn sample_curve_clamps_t_below_zero() {
-        assert_near(sample_curve(MotionCurve::SmoothSnap, -1.0), 0.0, 1e-5, "t<0 clamped");
+        assert_near(
+            sample_curve(MotionCurve::SmoothSnap, -1.0),
+            0.0,
+            1e-5,
+            "t<0 clamped",
+        );
     }
 
     #[test]
     fn sample_curve_clamps_t_above_one() {
-        assert_near(sample_curve(MotionCurve::Responsive, 2.0), 1.0, 1e-5, "t>1 clamped");
+        assert_near(
+            sample_curve(MotionCurve::Responsive, 2.0),
+            1.0,
+            1e-5,
+            "t>1 clamped",
+        );
     }
 }

solitaire_engine/src/card_animation/diagnostics.rs

@@ -190,7 +190,10 @@ mod tests {
         // is_above_target(30.0) is strict: fps must be > 30, not >=.
         // At exactly 30 FPS the result depends on floating-point rounding,
         // so just check that it's consistent with > 60 being false.
-        assert!(!d.is_above_target(60.0), "30 FPS is not above 60 FPS target");
+        assert!(
+            !d.is_above_target(60.0),
+            "30 FPS is not above 60 FPS target"
+        );
     }
 
     #[test]

solitaire_engine/src/card_animation/interaction.rs

@@ -71,7 +71,9 @@ pub struct HoverState {
 /// Describes a user action that arrived while cards were still animating.
 #[derive(Debug, Clone)]
 pub enum BufferedInput {
-    Move { from: crate::events::MoveRequestEvent },
+    Move {
+        from: crate::events::MoveRequestEvent,
+    },
     Draw,
     Undo,
 }
@@ -139,9 +141,7 @@ pub(crate) fn detect_hover(
     let mut best: Option<(Entity, f32)> = None;
     for (entity, transform) in &cards {
         let pos = transform.translation.truncate();
-        if (cursor_world.x - pos.x).abs() < half_w
-            && (cursor_world.y - pos.y).abs() < half_h
-        {
+        if (cursor_world.x - pos.x).abs() < half_w && (cursor_world.y - pos.y).abs() < half_h {
             let z = transform.translation.z;
             if best.is_none_or(|(_, bz)| z > bz) {
                 best = Some((entity, z));
@@ -187,9 +187,7 @@ pub(crate) fn apply_hover_scale(
 
     // Update the tracked scale for external inspection.
     hover_state.scale = if let Some(entity) = target_entity {
-        cards
-            .get(entity)
-            .map_or(hover_target, |(_, t)| t.scale.x)
+        cards.get(entity).map_or(hover_target, |(_, t)| t.scale.x)
     } else {
         1.0
     };

solitaire_engine/src/card_animation/mod.rs

@@ -80,14 +80,14 @@ pub mod interaction;
 pub mod timing;
 pub mod tuning;
 
-pub use animation::{retarget_animation, win_scatter_targets, CardAnimation};
+pub use animation::{CardAnimation, retarget_animation, win_scatter_targets};
 pub use chain::AnimationChain;
-pub use curves::{sample_curve, MotionCurve};
+pub use curves::{MotionCurve, sample_curve};
 pub use diagnostics::{FrameTimeDiagnostics, WINDOW_SIZE as DIAG_WINDOW_SIZE};
 pub use interaction::{BufferedInput, HoverState, InputBuffer};
 pub use timing::{
-    cascade_delay, compute_duration, micro_vary, DEAL_INTERVAL_SECS, MAX_DURATION_SECS,
-    MIN_DURATION_SECS, WIN_CASCADE_INTERVAL_SECS,
+    DEAL_INTERVAL_SECS, MAX_DURATION_SECS, MIN_DURATION_SECS, WIN_CASCADE_INTERVAL_SECS,
+    cascade_delay, compute_duration, micro_vary,
 };
 pub use tuning::{AnimationTuning, InputPlatform};
 
@@ -179,10 +179,7 @@ pub struct WinCascadePlugin;
 
 impl Plugin for WinCascadePlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(
-            Update,
-            trigger_expressive_win_cascade.after(GameMutation),
-        );
+        app.add_systems(Update, trigger_expressive_win_cascade.after(GameMutation));
     }
 }
 
@@ -200,9 +197,7 @@ fn trigger_expressive_win_cascade(
         return;
     }
 
-    let radius = layout
-        .as_ref()
-        .map_or(800.0, |l| l.0.card_size.x * 8.0);
+    let radius = layout.as_ref().map_or(800.0, |l| l.0.card_size.x * 8.0);
 
     let targets = win_scatter_targets(radius);
 
@@ -212,10 +207,16 @@ fn trigger_expressive_win_cascade(
         let target = targets[index % targets.len()];
 
         commands.entity(entity).insert(
-            CardAnimation::slide(start_xy, start_z, target, start_z + 60.0, MotionCurve::Expressive)
-                .with_delay(cascade_delay(index, WIN_CASCADE_INTERVAL_SECS))
-                .with_duration(0.65)
-                .with_z_lift(25.0),
+            CardAnimation::slide(
+                start_xy,
+                start_z,
+                target,
+                start_z + 60.0,
+                MotionCurve::Expressive,
+            )
+            .with_delay(cascade_delay(index, WIN_CASCADE_INTERVAL_SECS))
+            .with_duration(0.65)
+            .with_z_lift(25.0),
         );
     }
 }
@@ -265,7 +266,8 @@ mod tests {
     #[test]
     fn card_animation_advances_and_removes_itself() {
         let mut app = App::new();
-        app.add_plugins(MinimalPlugins).add_plugins(CardAnimationPlugin);
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(CardAnimationPlugin);
 
         let start = Vec2::new(0.0, 0.0);
         let end = Vec2::new(100.0, 0.0);
@@ -306,7 +308,8 @@ mod tests {
     #[test]
     fn card_animation_instant_snaps_on_zero_duration() {
         let mut app = App::new();
-        app.add_plugins(MinimalPlugins).add_plugins(CardAnimationPlugin);
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(CardAnimationPlugin);
 
         let end = Vec2::new(200.0, 100.0);
         let entity = app
@@ -353,7 +356,8 @@ mod tests {
     #[test]
     fn card_animation_respects_delay() {
         let mut app = App::new();
-        app.add_plugins(MinimalPlugins).add_plugins(CardAnimationPlugin);
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(CardAnimationPlugin);
 
         let entity = app
             .world_mut()
@@ -391,8 +395,14 @@ mod tests {
         buf.push(BufferedInput::Draw);
         buf.push(BufferedInput::Undo);
         // FIFO: Draw comes out first.
-        assert!(matches!(buf.queue.pop_front().unwrap(), BufferedInput::Draw));
-        assert!(matches!(buf.queue.pop_front().unwrap(), BufferedInput::Undo));
+        assert!(matches!(
+            buf.queue.pop_front().unwrap(),
+            BufferedInput::Draw
+        ));
+        assert!(matches!(
+            buf.queue.pop_front().unwrap(),
+            BufferedInput::Undo
+        ));
     }
 
     #[test]

solitaire_engine/src/card_animation/timing.rs

@@ -88,7 +88,10 @@ mod tests {
         let mut prev = 0.0f32;
         for d in [10, 50, 100, 200, 400, 600] {
             let dur = compute_duration(d as f32);
-            assert!(dur >= prev, "duration must be monotone: d={d} dur={dur} prev={prev}");
+            assert!(
+                dur >= prev,
+                "duration must be monotone: d={d} dur={dur} prev={prev}"
+            );
             prev = dur;
         }
     }
@@ -129,7 +132,10 @@ mod tests {
         let a = micro_vary(0.2, 1);
         let b = micro_vary(0.2, 2);
         // Very unlikely to be equal (would require hash collision mod 65536).
-        assert!((a - b).abs() > 1e-9, "micro_vary should differ for different indices");
+        assert!(
+            (a - b).abs() > 1e-9,
+            "micro_vary should differ for different indices"
+        );
     }
 
     #[test]

solitaire_engine/src/card_animation/tuning.rs

@@ -114,7 +114,7 @@ impl AnimationTuning {
             platform: InputPlatform::Touch,
             duration_scale: 0.75,
             overshoot_scale: 0.5,
-            drag_threshold_px: 8.0,  // Android ViewConfiguration.getScaledTouchSlop()
+            drag_threshold_px: 8.0, // Android ViewConfiguration.getScaledTouchSlop()
             drag_scale: 1.12,
             hover_scale: 1.0, // no hover affordance on touch
             hover_lerp_speed: 20.0,
@@ -182,15 +182,24 @@ mod tests {
         assert_eq!(t.duration_scale, 1.0);
         assert_eq!(t.platform, InputPlatform::Mouse);
         assert!(t.hover_scale > 1.0, "desktop hover must lift the card");
-        assert!(t.drag_threshold_px < 10.0, "desktop threshold must be smaller than mobile");
+        assert!(
+            t.drag_threshold_px < 10.0,
+            "desktop threshold must be smaller than mobile"
+        );
     }
 
     #[test]
     fn mobile_is_faster_than_desktop() {
         let d = AnimationTuning::desktop();
         let m = AnimationTuning::mobile();
-        assert!(m.duration_scale < d.duration_scale, "mobile must animate faster");
-        assert!(m.overshoot_scale < d.overshoot_scale, "mobile must bounce less");
+        assert!(
+            m.duration_scale < d.duration_scale,
+            "mobile must animate faster"
+        );
+        assert!(
+            m.overshoot_scale < d.overshoot_scale,
+            "mobile must bounce less"
+        );
     }
 
     #[test]

solitaire_engine/src/challenge_plugin.rs

@@ -58,12 +58,15 @@ fn advance_on_challenge_win(
         let prev = progress.0.challenge_index;
         progress.0.challenge_index = prev.saturating_add(1);
         if let Some(target) = &path.0
-            && let Err(e) = save_progress_to(target, &progress.0) {
-                warn!("failed to save progress after challenge advance: {e}");
-            }
+            && let Err(e) = save_progress_to(target, &progress.0)
+        {
+            warn!("failed to save progress after challenge advance: {e}");
+        }
         // Human-readable level is 1-based (index 0 → "Challenge 1").
         let level_number = prev.saturating_add(1);
-        toast.write(InfoToastEvent(format!("Challenge {level_number} complete!")));
+        toast.write(InfoToastEvent(format!(
+            "Challenge {level_number} complete!"
+        )));
         advanced.write(ChallengeAdvancedEvent {
             previous_index: prev,
             new_index: progress.0.challenge_index,
@@ -184,8 +187,7 @@ mod tests {
     #[test]
     fn pressing_x_at_unlock_level_fires_new_game_with_challenge_seed() {
         let mut app = headless_app();
-        app.world_mut().resource_mut::<ProgressResource>().0.level =
-            CHALLENGE_UNLOCK_LEVEL;
+        app.world_mut().resource_mut::<ProgressResource>().0.level = CHALLENGE_UNLOCK_LEVEL;
         app.world_mut()
             .resource_mut::<ProgressResource>()
             .0
@@ -215,7 +217,10 @@ mod tests {
     fn challenge_win_fires_complete_toast_with_level_number() {
         let mut app = headless_app();
         // Set challenge_index to 2 so the completed level is "Challenge 3".
-        app.world_mut().resource_mut::<ProgressResource>().0.challenge_index = 2;
+        app.world_mut()
+            .resource_mut::<ProgressResource>()
+            .0
+            .challenge_index = 2;
         app.world_mut().resource_mut::<GameStateResource>().0 =
             GameState::new_with_mode(1, DrawMode::DrawOne, GameMode::Challenge);
 
@@ -228,7 +233,11 @@ mod tests {
         let events = app.world().resource::<Messages<InfoToastEvent>>();
         let mut cursor = events.get_cursor();
         let fired: Vec<_> = cursor.read(events).collect();
-        assert_eq!(fired.len(), 1, "exactly one toast must fire on challenge win");
+        assert_eq!(
+            fired.len(),
+            1,
+            "exactly one toast must fire on challenge win"
+        );
         assert!(
             fired[0].0.contains("Challenge 3"),
             "toast must name the 1-based level that was just completed"

solitaire_engine/src/cursor_plugin.rs

@@ -41,7 +41,7 @@ use solitaire_core::rules::{can_place_on_foundation, can_place_on_tableau};
 use crate::card_plugin::RightClickHighlight;
 use crate::layout::{Layout, LayoutResource};
 use crate::resources::{DragState, GameStateResource};
-use crate::table_plugin::{PileMarker, PILE_MARKER_DEFAULT_COLOUR};
+use crate::table_plugin::{PILE_MARKER_DEFAULT_COLOUR, PileMarker};
 use crate::ui_theme::{
     DROP_TARGET_FILL, DROP_TARGET_OUTLINE, DROP_TARGET_OUTLINE_PX, Z_DROP_OVERLAY,
 };
@@ -126,7 +126,9 @@ fn update_cursor_icon(
     button_q: Query<&Interaction, With<Button>>,
     mut commands: Commands,
 ) {
-    let Ok((win_entity, window)) = windows.single() else { return };
+    let Ok((win_entity, window)) = windows.single() else {
+        return;
+    };
 
     let is_dragging = !drag.is_idle();
 
@@ -225,7 +227,9 @@ fn update_drop_highlights(
     let Some(game) = game else { return };
 
     // The first element of drag.cards is the bottom card that lands on the target.
-    let Some(&bottom_id) = drag.cards.first() else { return };
+    let Some(&bottom_id) = drag.cards.first() else {
+        return;
+    };
     let bottom_card = game
         .0
         .piles
@@ -233,7 +237,9 @@ fn update_drop_highlights(
         .flat_map(|p| p.cards.iter())
         .find(|c| c.id == bottom_id)
         .cloned();
-    let Some(bottom_card) = bottom_card else { return };
+    let Some(bottom_card) = bottom_card else {
+        return;
+    };
     let drag_count = drag.cards.len();
 
     for (marker, mut sprite, _rch) in &mut markers {
@@ -532,10 +538,7 @@ mod tests {
     fn marker_valid_and_default_colours_are_distinct() {
         // Regression guard — ensure these constants haven't been accidentally
         // set to the same value.
-        assert_ne!(
-            format!("{MARKER_VALID:?}"),
-            format!("{MARKER_DEFAULT:?}")
-        );
+        assert_ne!(format!("{MARKER_VALID:?}"), format!("{MARKER_DEFAULT:?}"));
     }
 
     #[test]
@@ -603,13 +606,17 @@ mod tests {
 
     #[test]
     fn cursor_over_draggable_returns_false_for_empty_game() {
-        use solitaire_core::game_state::{DrawMode, GameState};
         use crate::layout::compute_layout;
+        use solitaire_core::game_state::{DrawMode, GameState};
 
         let game = GameState::new(42, DrawMode::DrawOne);
         let layout = compute_layout(Vec2::new(1280.0, 800.0), 0.0, 0.0, true);
         // A cursor far off-screen should never hit anything.
-        assert!(!cursor_over_draggable(Vec2::new(-9999.0, -9999.0), &game, &layout));
+        assert!(!cursor_over_draggable(
+            Vec2::new(-9999.0, -9999.0),
+            &game,
+            &layout
+        ));
     }
 
     // -----------------------------------------------------------------------
@@ -627,7 +634,12 @@ mod tests {
         let mut app = App::new();
         app.add_plugins(MinimalPlugins)
             .insert_resource(GameStateResource(game))
-            .insert_resource(LayoutResource(compute_layout(Vec2::new(1280.0, 800.0), 0.0, 0.0, true)))
+            .insert_resource(LayoutResource(compute_layout(
+                Vec2::new(1280.0, 800.0),
+                0.0,
+                0.0,
+                true,
+            )))
             .insert_resource(DragState::default())
             .add_systems(Update, update_drop_target_overlays);
         app
@@ -674,9 +686,19 @@ mod tests {
         set_tableau_top(
             &mut game,
             2,
-            Card { id: 9001, suit: Suit::Spades, rank: Rank::Six, face_up: true },
+            Card {
+                id: 9001,
+                suit: Suit::Spades,
+                rank: Rank::Six,
+                face_up: true,
+            },
         );
-        let dragged = Card { id: 9002, suit: Suit::Hearts, rank: Rank::Five, face_up: true };
+        let dragged = Card {
+            id: 9002,
+            suit: Suit::Hearts,
+            rank: Rank::Five,
+            face_up: true,
+        };
 
         let mut app = overlay_test_app(game);
         begin_drag_with(&mut app, dragged);
@@ -704,9 +726,19 @@ mod tests {
         set_tableau_top(
             &mut game,
             2,
-            Card { id: 9101, suit: Suit::Clubs, rank: Rank::Six, face_up: true },
+            Card {
+                id: 9101,
+                suit: Suit::Clubs,
+                rank: Rank::Six,
+                face_up: true,
+            },
         );
-        let dragged = Card { id: 9102, suit: Suit::Spades, rank: Rank::Five, face_up: true };
+        let dragged = Card {
+            id: 9102,
+            suit: Suit::Spades,
+            rank: Rank::Five,
+            face_up: true,
+        };
 
         let mut app = overlay_test_app(game);
         begin_drag_with(&mut app, dragged);
@@ -734,9 +766,19 @@ mod tests {
         set_tableau_top(
             &mut game,
             2,
-            Card { id: 9201, suit: Suit::Spades, rank: Rank::Six, face_up: true },
+            Card {
+                id: 9201,
+                suit: Suit::Spades,
+                rank: Rank::Six,
+                face_up: true,
+            },
         );
-        let dragged = Card { id: 9202, suit: Suit::Hearts, rank: Rank::Five, face_up: true };
+        let dragged = Card {
+            id: 9202,
+            suit: Suit::Hearts,
+            rank: Rank::Five,
+            face_up: true,
+        };
 
         let mut app = overlay_test_app(game);
         begin_drag_with(&mut app, dragged);

solitaire_engine/src/daily_challenge_plugin.rs

@@ -13,7 +13,7 @@
 
 use bevy::input::ButtonInput;
 use bevy::prelude::*;
-use bevy::tasks::{futures_lite::future, AsyncComputeTaskPool, Task};
+use bevy::tasks::{AsyncComputeTaskPool, Task, futures_lite::future};
 use chrono::{DateTime, Duration, Local, NaiveDate, Utc};
 use solitaire_data::{daily_seed_for, save_progress_to};
 use solitaire_sync::ChallengeGoal;
@@ -89,6 +89,16 @@ struct DailyChallengeTask(Option<Task<Option<ChallengeGoal>>>);
 #[derive(Resource, Default, Debug)]
 struct DailyExpiryWarningShown(Option<NaiveDate>);
 
+/// Throttle timer so `check_date_rollover` does not call `Local::now()` every frame.
+#[derive(Resource)]
+struct DateRolloverTimer(Timer);
+
+impl Default for DateRolloverTimer {
+    fn default() -> Self {
+        Self(Timer::from_seconds(60.0, TimerMode::Repeating))
+    }
+}
+
 /// Fetches today's daily challenge seed and goal from the sync server on startup and tracks completion.
 /// Fires `DailyChallengeCompletedEvent` when the player wins a matching game.
 pub struct DailyChallengePlugin;
@@ -98,6 +108,7 @@ impl Plugin for DailyChallengePlugin {
         app.insert_resource(DailyChallengeResource::for_today())
             .init_resource::<DailyChallengeTask>()
             .init_resource::<DailyExpiryWarningShown>()
+            .init_resource::<DateRolloverTimer>()
             .add_message::<DailyChallengeCompletedEvent>()
             .add_message::<DailyGoalAnnouncementEvent>()
             .add_message::<GameWonEvent>()
@@ -111,7 +122,8 @@ impl Plugin for DailyChallengePlugin {
             // ProgressPlugin's add_xp on the same frame.
             .add_systems(Update, handle_daily_completion.after(ProgressUpdate))
             .add_systems(Update, handle_start_daily_request.before(GameMutation))
-            .add_systems(Update, check_daily_expiry_warning);
+            .add_systems(Update, check_daily_expiry_warning)
+            .add_systems(Update, check_date_rollover);
     }
 }
 
@@ -161,8 +173,7 @@ fn poll_server_challenge(
         daily.max_time_secs = goal.max_time_secs;
         info!(
             "daily challenge seed updated from server: {old_seed} → {} ({})",
-            goal.seed,
-            goal.description
+            goal.seed, goal.description
         );
     }
 }
@@ -184,28 +195,35 @@ fn handle_daily_completion(
         }
         // Enforce server-supplied goal constraints when present.
         if let Some(target) = daily.target_score
-            && ev.score < target {
-                continue; // score goal not met
-            }
+            && ev.score < target
+        {
+            continue; // score goal not met
+        }
         if let Some(max_secs) = daily.max_time_secs
-            && ev.time_seconds > max_secs {
-                continue; // time limit exceeded
-            }
+            && ev.time_seconds > max_secs
+        {
+            continue; // time limit exceeded
+        }
         if !progress.0.record_daily_completion(daily.date) {
             // Already counted today — no-op.
             continue;
         }
         progress.0.add_xp(DAILY_BONUS_XP);
-        xp_awarded.write(XpAwardedEvent { amount: DAILY_BONUS_XP });
+        xp_awarded.write(XpAwardedEvent {
+            amount: DAILY_BONUS_XP,
+        });
         if let Some(target) = &path.0
-            && let Err(e) = save_progress_to(target, &progress.0) {
-                warn!("failed to save progress after daily completion: {e}");
-            }
+            && let Err(e) = save_progress_to(target, &progress.0)
+        {
+            warn!("failed to save progress after daily completion: {e}");
+        }
         completed.write(DailyChallengeCompletedEvent {
             date: daily.date,
             streak: progress.0.daily_challenge_streak,
         });
-        toast.write(InfoToastEvent("Daily challenge complete! +100 XP".to_string()));
+        toast.write(InfoToastEvent(
+            "Daily challenge complete! +100 XP".to_string(),
+        ));
     }
 }
 
@@ -298,12 +316,40 @@ fn check_daily_expiry_warning(
     )));
 }
 
+/// Detects when the local calendar day changes while the app is running
+/// (e.g. the app stays open past midnight) and refreshes the daily
+/// challenge resource for the new day.
+fn check_date_rollover(
+    time: Res<Time>,
+    mut timer: ResMut<DateRolloverTimer>,
+    mut daily: ResMut<DailyChallengeResource>,
+    mut shown: ResMut<DailyExpiryWarningShown>,
+) {
+    timer.0.tick(time.delta());
+    if !timer.0.just_finished() {
+        return;
+    }
+    let today = Local::now().date_naive();
+    if today != daily.date {
+        info!(
+            "daily_challenge: date rolled over from {} to {}; refreshing challenge",
+            daily.date, today
+        );
+        *daily = DailyChallengeResource::for_today();
+        // Reset the expiry-warning state so the new day's warning can fire.
+        shown.0 = None;
+    }
+}
+
+
 #[cfg(test)]
+#[allow(dead_code)]
 mod tests {
     use super::*;
     use crate::game_plugin::GamePlugin;
     use crate::progress_plugin::ProgressPlugin;
     use crate::table_plugin::TablePlugin;
+    #[allow(unused_imports)]
     use solitaire_core::game_state::{DrawMode, GameState};
 
     fn headless_app() -> App {
@@ -346,7 +392,9 @@ mod tests {
         // +100 from the daily bonus
         assert!(progress.total_xp >= DAILY_BONUS_XP);
 
-        let events = app.world().resource::<Messages<DailyChallengeCompletedEvent>>();
+        let events = app
+            .world()
+            .resource::<Messages<DailyChallengeCompletedEvent>>();
         let mut cursor = events.get_cursor();
         let fired: Vec<_> = cursor.read(events).copied().collect();
         assert_eq!(fired.len(), 1);
@@ -370,7 +418,9 @@ mod tests {
         let progress = &app.world().resource::<ProgressResource>().0;
         assert_eq!(progress.daily_challenge_streak, 0);
 
-        let events = app.world().resource::<Messages<DailyChallengeCompletedEvent>>();
+        let events = app
+            .world()
+            .resource::<Messages<DailyChallengeCompletedEvent>>();
         let mut cursor = events.get_cursor();
         assert!(cursor.read(events).next().is_none());
     }
@@ -395,7 +445,10 @@ mod tests {
         app.update();
 
         let progress = &app.world().resource::<ProgressResource>().0;
-        assert_eq!(progress.daily_challenge_streak, 1, "streak does not double-count");
+        assert_eq!(
+            progress.daily_challenge_streak, 1,
+            "streak does not double-count"
+        );
     }
 
     #[test]
@@ -428,7 +481,9 @@ mod tests {
             .press(KeyCode::KeyC);
         app.update();
 
-        let events = app.world().resource::<Messages<DailyGoalAnnouncementEvent>>();
+        let events = app
+            .world()
+            .resource::<Messages<DailyGoalAnnouncementEvent>>();
         let mut cursor = events.get_cursor();
         let fired: Vec<_> = cursor.read(events).cloned().collect();
         assert_eq!(fired.len(), 1);
@@ -439,14 +494,21 @@ mod tests {
     fn pressing_c_with_no_description_uses_fallback() {
         let mut app = headless_app();
         // Ensure no description is set.
-        assert!(app.world().resource::<DailyChallengeResource>().goal_description.is_none());
+        assert!(
+            app.world()
+                .resource::<DailyChallengeResource>()
+                .goal_description
+                .is_none()
+        );
 
         app.world_mut()
             .resource_mut::<ButtonInput<KeyCode>>()
             .press(KeyCode::KeyC);
         app.update();
 
-        let events = app.world().resource::<Messages<DailyGoalAnnouncementEvent>>();
+        let events = app
+            .world()
+            .resource::<Messages<DailyGoalAnnouncementEvent>>();
         let mut cursor = events.get_cursor();
         let fired: Vec<_> = cursor.read(events).cloned().collect();
         assert_eq!(fired.len(), 1);
@@ -511,13 +573,8 @@ mod tests {
     fn warning_suppressed_when_already_completed_today() {
         // 23:50 UTC inside threshold, but today is already done.
         let now = utc_at(2026, 5, 8, 23, 50);
-        let mins = compute_expiry_warning_minutes(
-            ymd(2026, 5, 8),
-            Some(ymd(2026, 5, 8)),
-            None,
-            now,
-            30,
-        );
+        let mins =
+            compute_expiry_warning_minutes(ymd(2026, 5, 8), Some(ymd(2026, 5, 8)), None, now, 30);
         assert_eq!(mins, None);
     }
 
@@ -525,26 +582,16 @@ mod tests {
     fn warning_suppressed_when_yesterdays_completion_is_stale() {
         // Yesterday's completion is irrelevant — we want to warn about today.
         let now = utc_at(2026, 5, 8, 23, 50);
-        let mins = compute_expiry_warning_minutes(
-            ymd(2026, 5, 8),
-            Some(ymd(2026, 5, 7)),
-            None,
-            now,
-            30,
-        );
+        let mins =
+            compute_expiry_warning_minutes(ymd(2026, 5, 8), Some(ymd(2026, 5, 7)), None, now, 30);
         assert_eq!(mins, Some(10));
     }
 
     #[test]
     fn warning_suppressed_when_already_shown_for_this_date() {
         let now = utc_at(2026, 5, 8, 23, 50);
-        let mins = compute_expiry_warning_minutes(
-            ymd(2026, 5, 8),
-            None,
-            Some(ymd(2026, 5, 8)),
-            now,
-            30,
-        );
+        let mins =
+            compute_expiry_warning_minutes(ymd(2026, 5, 8), None, Some(ymd(2026, 5, 8)), now, 30);
         assert_eq!(mins, None);
     }
 
@@ -553,13 +600,8 @@ mod tests {
         // Player kept the app open across a midnight rollover. Stale
         // "shown" date doesn't suppress today's warning.
         let now = utc_at(2026, 5, 8, 23, 50);
-        let mins = compute_expiry_warning_minutes(
-            ymd(2026, 5, 8),
-            None,
-            Some(ymd(2026, 5, 7)),
-            now,
-            30,
-        );
+        let mins =
+            compute_expiry_warning_minutes(ymd(2026, 5, 8), None, Some(ymd(2026, 5, 7)), now, 30);
         assert_eq!(mins, Some(10));
     }
 
@@ -578,9 +620,7 @@ mod tests {
         let today = app.world().resource::<DailyChallengeResource>().date;
 
         // Pre-mark warning as already shown for today.
-        app.world_mut()
-            .resource_mut::<DailyExpiryWarningShown>()
-            .0 = Some(today);
+        app.world_mut().resource_mut::<DailyExpiryWarningShown>().0 = Some(today);
         // Flush any stale events from headless_app()'s initial update (the
         // double-buffer keeps them visible for one extra frame).
         app.update();
@@ -596,9 +636,7 @@ mod tests {
         );
 
         // Reset shown, mark today as completed.
-        app.world_mut()
-            .resource_mut::<DailyExpiryWarningShown>()
-            .0 = None;
+        app.world_mut().resource_mut::<DailyExpiryWarningShown>().0 = None;
         app.world_mut()
             .resource_mut::<ProgressResource>()
             .0

solitaire_engine/src/difficulty_plugin.rs

@@ -74,10 +74,7 @@ impl Plugin for DifficultyPlugin {
         app.init_resource::<DifficultyIndexResource>()
             .add_message::<StartDifficultyRequestEvent>()
             .add_message::<NewGameRequestEvent>()
-            .add_systems(
-                Update,
-                handle_difficulty_request.before(GameMutation),
-            );
+            .add_systems(Update, handle_difficulty_request.before(GameMutation));
     }
 }
 
@@ -210,7 +207,10 @@ mod tests {
 
         let events = drain_new_game_events(&mut app);
         assert_eq!(events.len(), 1);
-        assert!(events[0].seed.is_some(), "Random should always produce Some(seed)");
+        assert!(
+            events[0].seed.is_some(),
+            "Random should always produce Some(seed)"
+        );
         assert_eq!(
             events[0].mode,
             Some(GameMode::Difficulty(DifficultyLevel::Random))

solitaire_engine/src/feedback_anim_plugin.rs

@@ -244,7 +244,9 @@ fn start_shake_anim(
         }
         let dest_pile = &ev.to;
         // Collect the card ids that belong to the destination pile.
-        let Some(pile) = game.0.piles.get(dest_pile) else { continue };
+        let Some(pile) = game.0.piles.get(dest_pile) else {
+            continue;
+        };
         let dest_card_ids: Vec<u32> = pile.cards.iter().map(|c| c.id).collect();
 
         if dest_card_ids.is_empty() {
@@ -395,7 +397,9 @@ fn start_deal_anim(
         return;
     }
     let Some(layout) = layout else { return };
-    let Some(&stock_pos) = layout.0.pile_positions.get(&PileType::Stock) else { return };
+    let Some(&stock_pos) = layout.0.pile_positions.get(&PileType::Stock) else {
+        return;
+    };
     let stock_start = Vec3::new(stock_pos.x, stock_pos.y, 0.0);
 
     let speed = settings.as_ref().map(|s| &s.0.animation_speed);
@@ -501,7 +505,12 @@ fn start_foundation_flourish(
     game: Res<GameStateResource>,
     settings: Option<Res<SettingsResource>>,
     card_entities: Query<(Entity, &CardEntity)>,
-    mut pile_markers: Query<(Entity, &PileMarker, &Sprite, Option<&FoundationMarkerFlourish>)>,
+    mut pile_markers: Query<(
+        Entity,
+        &PileMarker,
+        &Sprite,
+        Option<&FoundationMarkerFlourish>,
+    )>,
     mut commands: Commands,
 ) {
     let reduce_motion = settings.as_deref().is_some_and(|s| s.0.reduce_motion_mode);
@@ -767,7 +776,8 @@ mod tests {
             "flourish scale at t=0 must be 1.0"
         );
         assert!(
-            (foundation_flourish_scale(dur / 2.0, dur) - FOUNDATION_FLOURISH_PEAK_SCALE).abs() < 1e-5,
+            (foundation_flourish_scale(dur / 2.0, dur) - FOUNDATION_FLOURISH_PEAK_SCALE).abs()
+                < 1e-5,
             "flourish scale at midpoint must be FOUNDATION_FLOURISH_PEAK_SCALE"
         );
         assert!(
@@ -848,10 +858,8 @@ mod tests {
 
         // Spawn a minimal CardEntity matching that id so the system would
         // find it and insert ShakeAnim if the gate were absent.
-        app.world_mut().spawn((
-            CardEntity { card_id },
-            Transform::default(),
-        ));
+        app.world_mut()
+            .spawn((CardEntity { card_id }, Transform::default()));
 
         app.world_mut()
             .resource_mut::<Messages<MoveRejectedEvent>>()
@@ -867,7 +875,10 @@ mod tests {
             .query::<&ShakeAnim>()
             .iter(app.world())
             .count();
-        assert_eq!(shake_count, 0, "ShakeAnim must not be inserted under reduce-motion");
+        assert_eq!(
+            shake_count, 0,
+            "ShakeAnim must not be inserted under reduce-motion"
+        );
     }
 
     /// `start_foundation_flourish` must not insert `FoundationFlourish` when
@@ -901,6 +912,9 @@ mod tests {
             .query::<&FoundationFlourish>()
             .iter(app.world())
             .count();
-        assert_eq!(flourish_count, 0, "FoundationFlourish must not be inserted under reduce-motion");
+        assert_eq!(
+            flourish_count, 0,
+            "FoundationFlourish must not be inserted under reduce-motion"
+        );
     }
 }

solitaire_engine/src/help_plugin.rs

@@ -13,12 +13,12 @@ use crate::font_plugin::FontResource;
 use crate::hud_plugin::ANDROID_HINT_LABEL;
 use crate::platform::SHOW_KEYBOARD_ACCELERATORS;
 use crate::ui_modal::{
-    spawn_modal, spawn_modal_actions, spawn_modal_button, spawn_modal_header, ButtonVariant,
-    ModalScrim, ScrimDismissible,
+    ButtonVariant, ModalScrim, ScrimDismissible, spawn_modal, spawn_modal_actions,
+    spawn_modal_button, spawn_modal_header,
 };
 use crate::ui_theme::{
-    BORDER_SUBTLE, HighContrastBorder, RADIUS_SM, SPACE_2, TEXT_PRIMARY, TEXT_SECONDARY,
-    TYPE_BODY, TYPE_CAPTION, VAL_SPACE_1, VAL_SPACE_2, VAL_SPACE_3, Z_MODAL_PANEL,
+    BORDER_SUBTLE, HighContrastBorder, RADIUS_SM, SPACE_2, TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY,
+    TYPE_CAPTION, VAL_SPACE_1, VAL_SPACE_2, VAL_SPACE_3, Z_MODAL_PANEL,
 };
 
 /// Marker on the help overlay root node.
@@ -145,26 +145,56 @@ const CONTROL_SECTIONS: &[ControlSection] = &[
     ControlSection {
         title: "Touch",
         rows: &[
-            ControlRow { keys: "Tap stock", description: "Draw from stock" },
-            ControlRow { keys: "Drag card", description: "Move cards between piles" },
-            ControlRow { keys: "Tap foundation area", description: "Auto-move top card to foundation" },
+            ControlRow {
+                keys: "Tap stock",
+                description: "Draw from stock",
+            },
+            ControlRow {
+                keys: "Drag card",
+                description: "Move cards between piles",
+            },
+            ControlRow {
+                keys: "Tap foundation area",
+                description: "Auto-move top card to foundation",
+            },
         ],
     },
     ControlSection {
         title: "New Game",
         rows: &[
-            ControlRow { keys: "New+", description: "Start a new Classic game" },
-            ControlRow { keys: "Modes↓", description: "Pick Daily, Zen, Challenge, or Time Attack" },
+            ControlRow {
+                keys: "New+",
+                description: "Start a new Classic game",
+            },
+            ControlRow {
+                keys: "Modes↓",
+                description: "Pick Daily, Zen, Challenge, or Time Attack",
+            },
         ],
     },
     ControlSection {
         title: "HUD buttons",
         rows: &[
-            ControlRow { keys: "←", description: "Undo last move" },
-            ControlRow { keys: "||", description: "Pause / resume" },
-            ControlRow { keys: "?", description: "This help screen" },
-            ControlRow { keys: ANDROID_HINT_LABEL, description: "Show a hint" },
-            ControlRow { keys: "≡", description: "Open menu (Stats, Settings, Profile...)" },
+            ControlRow {
+                keys: "←",
+                description: "Undo last move",
+            },
+            ControlRow {
+                keys: "||",
+                description: "Pause / resume",
+            },
+            ControlRow {
+                keys: "?",
+                description: "This help screen",
+            },
+            ControlRow {
+                keys: ANDROID_HINT_LABEL,
+                description: "Show a hint",
+            },
+            ControlRow {
+                keys: "≡",
+                description: "Open menu (Stats, Settings, Profile...)",
+            },
         ],
     },
 ];
@@ -174,17 +204,35 @@ const CONTROL_SECTIONS: &[ControlSection] = &[
     ControlSection {
         title: "Gameplay",
         rows: &[
-            ControlRow { keys: "Drag", description: "Move cards between piles" },
-            ControlRow { keys: "D / Space", description: "Draw from stock" },
-            ControlRow { keys: "U", description: "Undo last move" },
-            ControlRow { keys: "Click stock", description: "Draw" },
+            ControlRow {
+                keys: "Drag",
+                description: "Move cards between piles",
+            },
+            ControlRow {
+                keys: "D / Space",
+                description: "Draw from stock",
+            },
+            ControlRow {
+                keys: "U",
+                description: "Undo last move",
+            },
+            ControlRow {
+                keys: "Click stock",
+                description: "Draw",
+            },
         ],
     },
     ControlSection {
         title: "Mouse",
         rows: &[
-            ControlRow { keys: "Double-click", description: "Auto-move card to its best destination" },
-            ControlRow { keys: "Right-click", description: "Highlight legal destinations briefly" },
+            ControlRow {
+                keys: "Double-click",
+                description: "Auto-move card to its best destination",
+            },
+            ControlRow {
+                keys: "Right-click",
+                description: "Highlight legal destinations briefly",
+            },
             ControlRow {
                 keys: "Hold RMB",
                 description: "Open radial menu — release over an icon to quick-drop",
@@ -194,48 +242,129 @@ const CONTROL_SECTIONS: &[ControlSection] = &[
     ControlSection {
         title: "Keyboard drag",
         rows: &[
-            ControlRow { keys: "Tab", description: "Focus next draggable card" },
-            ControlRow { keys: "Enter", description: "Lift focused card (then arrows pick where)" },
-            ControlRow { keys: "Arrows / Tab", description: "Cycle legal destinations while lifted" },
-            ControlRow { keys: "Enter", description: "Drop the lifted cards on the focused pile" },
-            ControlRow { keys: "Esc", description: "Cancel lift (Esc again clears focus)" },
-            ControlRow { keys: "Space", description: "Auto-move focused card (foundation first)" },
+            ControlRow {
+                keys: "Tab",
+                description: "Focus next draggable card",
+            },
+            ControlRow {
+                keys: "Enter",
+                description: "Lift focused card (then arrows pick where)",
+            },
+            ControlRow {
+                keys: "Arrows / Tab",
+                description: "Cycle legal destinations while lifted",
+            },
+            ControlRow {
+                keys: "Enter",
+                description: "Drop the lifted cards on the focused pile",
+            },
+            ControlRow {
+                keys: "Esc",
+                description: "Cancel lift (Esc again clears focus)",
+            },
+            ControlRow {
+                keys: "Space",
+                description: "Auto-move focused card (foundation first)",
+            },
         ],
     },
     ControlSection {
         title: "New Game",
         rows: &[
-            ControlRow { keys: "N", description: "New Classic game (N twice if in progress)" },
-            ControlRow { keys: "C", description: "Start today's daily challenge" },
-            ControlRow { keys: "Z", description: "Start a Zen game (level 5+)" },
-            ControlRow { keys: "X", description: "Start the next Challenge (level 5+)" },
-            ControlRow { keys: "T", description: "Start a Time Attack session (level 5+)" },
+            ControlRow {
+                keys: "N",
+                description: "New Classic game (N twice if in progress)",
+            },
+            ControlRow {
+                keys: "C",
+                description: "Start today's daily challenge",
+            },
+            ControlRow {
+                keys: "Z",
+                description: "Start a Zen game (level 5+)",
+            },
+            ControlRow {
+                keys: "X",
+                description: "Start the next Challenge (level 5+)",
+            },
+            ControlRow {
+                keys: "T",
+                description: "Start a Time Attack session (level 5+)",
+            },
         ],
     },
     ControlSection {
         title: "Mode Launcher (M)",
         rows: &[
-            ControlRow { keys: "1", description: "Launch Classic" },
-            ControlRow { keys: "2", description: "Launch Daily Challenge" },
-            ControlRow { keys: "3", description: "Launch Zen (level 5+)" },
-            ControlRow { keys: "4", description: "Launch Challenge (level 5+)" },
-            ControlRow { keys: "5", description: "Launch Time Attack (level 5+)" },
+            ControlRow {
+                keys: "1",
+                description: "Launch Classic",
+            },
+            ControlRow {
+                keys: "2",
+                description: "Launch Daily Challenge",
+            },
+            ControlRow {
+                keys: "3",
+                description: "Launch Zen (level 5+)",
+            },
+            ControlRow {
+                keys: "4",
+                description: "Launch Challenge (level 5+)",
+            },
+            ControlRow {
+                keys: "5",
+                description: "Launch Time Attack (level 5+)",
+            },
         ],
     },
     ControlSection {
         title: "Overlays",
         rows: &[
-            ControlRow { keys: "M", description: "Mode launcher (Home)" },
-            ControlRow { keys: "P", description: "Profile" },
-            ControlRow { keys: "S", description: "Stats & progression" },
-            ControlRow { keys: "A", description: "Achievements" },
-            ControlRow { keys: "L", description: "Leaderboard" },
-            ControlRow { keys: "O", description: "Settings" },
-            ControlRow { keys: "F1", description: "This help screen" },
-            ControlRow { keys: "F11", description: "Toggle fullscreen" },
-            ControlRow { keys: "Esc", description: "Pause / resume" },
-            ControlRow { keys: "[ / ]", description: "SFX volume down / up" },
-            ControlRow { keys: "Enter", description: "Play Again (on the Win Summary)" },
+            ControlRow {
+                keys: "M",
+                description: "Mode launcher (Home)",
+            },
+            ControlRow {
+                keys: "P",
+                description: "Profile",
+            },
+            ControlRow {
+                keys: "S",
+                description: "Stats & progression",
+            },
+            ControlRow {
+                keys: "A",
+                description: "Achievements",
+            },
+            ControlRow {
+                keys: "L",
+                description: "Leaderboard",
+            },
+            ControlRow {
+                keys: "O",
+                description: "Settings",
+            },
+            ControlRow {
+                keys: "F1",
+                description: "This help screen",
+            },
+            ControlRow {
+                keys: "F11",
+                description: "Toggle fullscreen",
+            },
+            ControlRow {
+                keys: "Esc",
+                description: "Pause / resume",
+            },
+            ControlRow {
+                keys: "[ / ]",
+                description: "SFX volume down / up",
+            },
+            ControlRow {
+                keys: "Enter",
+                description: "Play Again (on the Win Summary)",
+            },
         ],
     },
 ];
@@ -315,7 +444,8 @@ fn spawn_help_screen(commands: &mut Commands, font_res: Option<&FontResource>) {
                             });
                         }
 
-                        line.spawn((                            Text::new(row.description),
+                        line.spawn((
+                            Text::new(row.description),
                             font_row.clone(),
                             TextColor(TEXT_PRIMARY),
                         ));

solitaire_engine/src/home_plugin.rs

@@ -13,8 +13,8 @@
 //! [`InfoToastEvent`] explaining the gate but does not launch the mode
 //! or close the overlay.
 
-use bevy::input::mouse::{MouseScrollUnit, MouseWheel};
 use bevy::input::ButtonInput;
+use bevy::input::mouse::{MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
 use solitaire_core::game_state::{DifficultyLevel, DrawMode};
 use solitaire_data::save_settings_to;
@@ -28,15 +28,12 @@ use crate::events::{
 };
 use crate::font_plugin::FontResource;
 use crate::progress_plugin::ProgressResource;
-use crate::settings_plugin::{
-    SettingsChangedEvent, SettingsResource, SettingsStoragePath,
-};
+use crate::settings_plugin::{SettingsChangedEvent, SettingsResource, SettingsStoragePath};
 use crate::stats_plugin::StatsResource;
 use crate::ui_focus::{Disabled, FocusGroup, Focusable};
 use crate::ui_modal::{
-    spawn_modal, spawn_modal_actions, spawn_modal_button, spawn_modal_header, ButtonVariant,
-    ModalButton,
-    ScrimDismissible,
+    ButtonVariant, ModalButton, ScrimDismissible, spawn_modal, spawn_modal_actions,
+    spawn_modal_button, spawn_modal_header,
 };
 use crate::ui_theme::{
     ACCENT_PRIMARY, BG_ELEVATED, BG_ELEVATED_HI, BORDER_STRONG, BORDER_SUBTLE, HighContrastBorder,
@@ -189,7 +186,10 @@ impl HomeMode {
 
     /// `true` when the mode is gated behind `CHALLENGE_UNLOCK_LEVEL`.
     fn requires_unlock(self) -> bool {
-        matches!(self, HomeMode::Zen | HomeMode::Challenge | HomeMode::TimeAttack)
+        matches!(
+            self,
+            HomeMode::Zen | HomeMode::Challenge | HomeMode::TimeAttack
+        )
     }
 
     /// `true` if the player at `level` is allowed to launch the mode.
@@ -342,7 +342,10 @@ fn spawn_home_on_launch(
     }
 
     // Pre-expand the difficulty section when the player has a saved preference.
-    if settings.as_ref().is_some_and(|s| s.0.last_difficulty.is_some()) {
+    if settings
+        .as_ref()
+        .is_some_and(|s| s.0.last_difficulty.is_some())
+    {
         diff_expanded.0 = true;
     }
 
@@ -429,9 +432,7 @@ fn build_home_context<'a>(
         zen_best: stats.map_or(0, |s| s.0.zen_best_score),
         challenge_best: stats.map_or(0, |s| s.0.challenge_best_score),
         daily_today,
-        draw_mode: settings
-            .map(|s| s.0.draw_mode)
-            .unwrap_or(DrawMode::DrawOne),
+        draw_mode: settings.map(|s| s.0.draw_mode).unwrap_or(DrawMode::DrawOne),
         font_res,
         difficulty_expanded,
         last_difficulty: settings.and_then(|s| s.0.last_difficulty),
@@ -1113,8 +1114,16 @@ fn spawn_draw_mode_chip<M: Component>(
 /// update without Visibility component surgery.
 fn spawn_difficulty_section(parent: &mut ChildSpawnerCommands, ctx: &HomeContext<'_>) {
     let font_handle = ctx.font_res.map(|f| f.0.clone()).unwrap_or_default();
-    let font_label = TextFont { font: font_handle.clone(), font_size: TYPE_BODY, ..default() };
-    let font_chip = TextFont { font: font_handle, font_size: TYPE_CAPTION, ..default() };
+    let font_label = TextFont {
+        font: font_handle.clone(),
+        font_size: TYPE_BODY,
+        ..default()
+    };
+    let font_chip = TextFont {
+        font: font_handle,
+        font_size: TYPE_CAPTION,
+        ..default()
+    };
 
     let chevron = if ctx.difficulty_expanded { "v" } else { ">" };
 
@@ -1184,11 +1193,7 @@ fn spawn_difficulty_section(parent: &mut ChildSpawnerCommands, ctx: &HomeContext
                         HighContrastBorder::with_default(BORDER_SUBTLE),
                     ))
                     .with_children(|c| {
-                        c.spawn((
-                            Text::new(level.label()),
-                            font_chip.clone(),
-                            TextColor(fg),
-                        ));
+                        c.spawn((Text::new(level.label()), font_chip.clone(), TextColor(fg)));
                     });
                 }
             });
@@ -1223,12 +1228,11 @@ fn score_chip_text_for(mode: HomeMode, ctx: &HomeContext<'_>) -> Option<String>
         HomeMode::Zen if ctx.zen_best > 0 => {
             Some(format!("Best {}", format_compact(ctx.zen_best as u64)))
         }
-        HomeMode::Challenge if ctx.challenge_best > 0 => {
-            Some(format!("Best {}", format_compact(ctx.challenge_best as u64)))
-        }
-        HomeMode::Daily if ctx.daily_streak > 0 => {
-            Some(format!("Streak {}", ctx.daily_streak))
-        }
+        HomeMode::Challenge if ctx.challenge_best > 0 => Some(format!(
+            "Best {}",
+            format_compact(ctx.challenge_best as u64)
+        )),
+        HomeMode::Daily if ctx.daily_streak > 0 => Some(format!("Streak {}", ctx.daily_streak)),
         _ => None,
     }
 }
@@ -1302,11 +1306,7 @@ fn attach_focusable_to_home_mode_cards(
 /// feedback is supplied by `paint_modal_buttons` via the `ModalButton`
 /// component, which we attach with `ButtonVariant::Secondary` so the card
 /// reads as a standard interactive surface.
-fn spawn_mode_card(
-    parent: &mut ChildSpawnerCommands,
-    mode: HomeMode,
-    ctx: &HomeContext<'_>,
-) {
+fn spawn_mode_card(parent: &mut ChildSpawnerCommands, mode: HomeMode, ctx: &HomeContext<'_>) {
     let level = ctx.level;
     let font_res = ctx.font_res;
     let score_chip = score_chip_text_for(mode, ctx);
@@ -1338,10 +1338,26 @@ fn spawn_mode_card(
     // Locked cards mute their text to communicate the disabled state at
     // a glance; the explicit "Unlocks at level N" caption underneath
     // backs that up with copy.
-    let title_color = if unlocked { TEXT_PRIMARY } else { TEXT_DISABLED };
-    let desc_color = if unlocked { TEXT_SECONDARY } else { TEXT_DISABLED };
-    let border_color = if unlocked { BORDER_SUBTLE } else { BORDER_STRONG };
-    let glyph_color = if unlocked { ACCENT_PRIMARY } else { TEXT_DISABLED };
+    let title_color = if unlocked {
+        TEXT_PRIMARY
+    } else {
+        TEXT_DISABLED
+    };
+    let desc_color = if unlocked {
+        TEXT_SECONDARY
+    } else {
+        TEXT_DISABLED
+    };
+    let border_color = if unlocked {
+        BORDER_SUBTLE
+    } else {
+        BORDER_STRONG
+    };
+    let glyph_color = if unlocked {
+        ACCENT_PRIMARY
+    } else {
+        TEXT_DISABLED
+    };
 
     parent
         .spawn((
@@ -1489,9 +1505,7 @@ fn spawn_mode_card(
             // Locked footnote — explicit copy so the gate is unambiguous.
             if !unlocked {
                 c.spawn((
-                    Text::new(format!(
-                        "Unlocks at level {CHALLENGE_UNLOCK_LEVEL}"
-                    )),
+                    Text::new(format!("Unlocks at level {CHALLENGE_UNLOCK_LEVEL}")),
                     TextFont {
                         font: font_desc.font.clone(),
                         font_size: TYPE_CAPTION,
@@ -1734,10 +1748,7 @@ mod tests {
     fn unlocked_zen_click_fires_start_zen_event_and_closes_modal() {
         let mut app = headless_app();
         // Bump the player to the unlock level.
-        app.world_mut()
-            .resource_mut::<ProgressResource>()
-            .0
-            .level = CHALLENGE_UNLOCK_LEVEL;
+        app.world_mut().resource_mut::<ProgressResource>().0.level = CHALLENGE_UNLOCK_LEVEL;
         let _ = open_home(&mut app);
 
         app.world_mut()
@@ -1991,10 +2002,7 @@ mod tests {
         let mut app = headless_app();
         // Bump the player to the unlock level *before* opening the modal
         // so the Mode Launcher is in its unlocked state.
-        app.world_mut()
-            .resource_mut::<ProgressResource>()
-            .0
-            .level = CHALLENGE_UNLOCK_LEVEL;
+        app.world_mut().resource_mut::<ProgressResource>().0.level = CHALLENGE_UNLOCK_LEVEL;
         let _ = open_home(&mut app);
 
         app.world_mut()
@@ -2026,10 +2034,7 @@ mod tests {
         let mut app = headless_app();
         // Modal is NOT open. Bump level so Zen would otherwise be allowed
         // — this isolates the modal-scope guard from the unlock check.
-        app.world_mut()
-            .resource_mut::<ProgressResource>()
-            .0
-            .level = CHALLENGE_UNLOCK_LEVEL;
+        app.world_mut().resource_mut::<ProgressResource>().0.level = CHALLENGE_UNLOCK_LEVEL;
 
         // Drain any pre-existing events.
         app.world_mut()
@@ -2071,19 +2076,25 @@ mod tests {
             zc.read(zen).next().is_none(),
             "Digit keys with no modal open must not fire StartZenRequestEvent"
         );
-        let chal = app.world().resource::<Messages<StartChallengeRequestEvent>>();
+        let chal = app
+            .world()
+            .resource::<Messages<StartChallengeRequestEvent>>();
         let mut cc = chal.get_cursor();
         assert!(
             cc.read(chal).next().is_none(),
             "Digit keys with no modal open must not fire StartChallengeRequestEvent"
         );
-        let ta = app.world().resource::<Messages<StartTimeAttackRequestEvent>>();
+        let ta = app
+            .world()
+            .resource::<Messages<StartTimeAttackRequestEvent>>();
         let mut tc = ta.get_cursor();
         assert!(
             tc.read(ta).next().is_none(),
             "Digit keys with no modal open must not fire StartTimeAttackRequestEvent"
         );
-        let daily = app.world().resource::<Messages<StartDailyChallengeRequestEvent>>();
+        let daily = app
+            .world()
+            .resource::<Messages<StartDailyChallengeRequestEvent>>();
         let mut dc = daily.get_cursor();
         assert!(
             dc.read(daily).next().is_none(),

solitaire_engine/src/hud_plugin.rs

@@ -14,21 +14,8 @@ use solitaire_core::pile::PileType;
 
 use crate::auto_complete_plugin::AutoCompleteState;
 use crate::avatar_plugin::AvatarResource;
-use solitaire_data::SyncBackend;
 use crate::challenge_plugin::CHALLENGE_UNLOCK_LEVEL;
 use crate::daily_challenge_plugin::DailyChallengeResource;
-use crate::progress_plugin::ProgressResource;
-use crate::settings_plugin::SettingsResource;
-use crate::layout::HUD_BAND_HEIGHT;
-use crate::safe_area::{SafeAreaAnchoredBottom, SafeAreaAnchoredTop};
-use crate::ui_theme::SPACE_2;
-use crate::ui_theme::{
-    scaled_duration, ACCENT_PRIMARY, ACCENT_SECONDARY, BG_ELEVATED, BG_ELEVATED_HI,
-    BG_ELEVATED_PRESSED, BG_HUD_BAND, BORDER_SUBTLE, HighContrastBorder, MOTION_SCORE_PULSE_SECS,
-    MOTION_STREAK_FLOURISH_SECS, RADIUS_MD, RADIUS_SM, STATE_DANGER, STATE_INFO, STATE_SUCCESS,
-    STATE_WARNING, STREAK_FLOURISH_PEAK_SCALE, TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY,
-    TYPE_BODY_LG, TYPE_CAPTION, TYPE_HEADLINE, VAL_SPACE_1, VAL_SPACE_2, VAL_SPACE_3,
-};
 use crate::events::{
     HelpRequestEvent, InfoToastEvent, NewGameRequestEvent, PauseRequestEvent,
     StartChallengeRequestEvent, StartDailyChallengeRequestEvent, StartTimeAttackRequestEvent,
@@ -40,18 +27,32 @@ use crate::font_plugin::FontResource;
 use crate::game_plugin::GameMutation;
 #[cfg(target_os = "android")]
 use crate::input_plugin::TouchDragSet;
+use crate::layout::HUD_BAND_HEIGHT;
 use crate::layout::LayoutSystem;
-use crate::platform::{SHOW_KEYBOARD_ACCELERATORS, USE_TOUCH_UI_LAYOUT};
 #[cfg(target_os = "android")]
 use crate::pause_plugin::PausedResource;
+use crate::platform::{SHOW_KEYBOARD_ACCELERATORS, USE_TOUCH_UI_LAYOUT};
+use crate::progress_plugin::ProgressResource;
 use crate::resources::GameStateResource;
 #[cfg(target_os = "android")]
 use crate::resources::{DragState, GameInputConsumedResource};
+use crate::safe_area::{SafeAreaAnchoredBottom, SafeAreaAnchoredTop};
 use crate::selection_plugin::SelectionState;
+use crate::settings_plugin::SettingsResource;
 use crate::time_attack_plugin::TimeAttackResource;
 use crate::ui_focus::{FocusGroup, Focusable};
 use crate::ui_modal::ModalScrim;
+use crate::ui_theme::SPACE_2;
+use crate::ui_theme::{
+    ACCENT_PRIMARY, ACCENT_SECONDARY, BG_ELEVATED, BG_ELEVATED_HI, BG_ELEVATED_PRESSED,
+    BG_HUD_BAND, BORDER_SUBTLE, HighContrastBorder, MOTION_SCORE_PULSE_SECS,
+    MOTION_STREAK_FLOURISH_SECS, RADIUS_MD, RADIUS_SM, STATE_DANGER, STATE_INFO, STATE_SUCCESS,
+    STATE_WARNING, STREAK_FLOURISH_PEAK_SCALE, TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY,
+    TYPE_BODY_LG, TYPE_CAPTION, TYPE_HEADLINE, VAL_SPACE_1, VAL_SPACE_2, VAL_SPACE_3,
+    scaled_duration,
+};
 use crate::ui_tooltip::Tooltip;
+use solitaire_data::SyncBackend;
 
 /// Marker on the score text node.
 #[derive(Component, Debug)]
@@ -310,9 +311,25 @@ pub struct HintButton;
 pub(crate) const ANDROID_HINT_LABEL: &str = "!";
 
 #[cfg(target_os = "android")]
-const ACTION_BAR_LABELS: [&str; 7] = ["\u{2261}", "\u{2190}", "||", "?", ANDROID_HINT_LABEL, "M", "+"];
+const ACTION_BAR_LABELS: [&str; 7] = [
+    "\u{2261}",
+    "\u{2190}",
+    "||",
+    "?",
+    ANDROID_HINT_LABEL,
+    "M",
+    "+",
+];
 #[cfg(not(target_os = "android"))]
-const ACTION_BAR_LABELS: [&str; 7] = ["Menu \u{2193}", "Undo", "Pause", "Help", "Hint", "Modes \u{2193}", "New Game"];
+const ACTION_BAR_LABELS: [&str; 7] = [
+    "Menu \u{2193}",
+    "Undo",
+    "Pause",
+    "Help",
+    "Hint",
+    "Modes \u{2193}",
+    "New Game",
+];
 #[cfg(target_os = "android")]
 const ACTION_BAR_COLUMN_GAP: Val = Val::Px(4.0);
 #[cfg(not(target_os = "android"))]
@@ -564,10 +581,7 @@ fn spawn_hud_band(mut commands: Commands) {
 /// player's #1 complaint. This restructure groups by purpose, lets
 /// transient items disappear cleanly, and uses the typography scale to
 /// make Score the visual protagonist.
-fn spawn_hud(
-    font_res: Option<Res<FontResource>>,
-    mut commands: Commands,
-) {
+fn spawn_hud(font_res: Option<Res<FontResource>>, mut commands: Commands) {
     let font_handle = font_res.as_ref().map(|f| f.0.clone()).unwrap_or_default();
     let font_score = TextFont {
         font: font_handle.clone(),
@@ -637,9 +651,7 @@ fn spawn_hud(
                 ));
                 t1.spawn((
                     HudMoves,
-                    Tooltip::new(
-                        "Moves you've made this game. Counts placements and stock draws.",
-                    ),
+                    Tooltip::new("Moves you've made this game. Counts placements and stock draws."),
                     Text::new("Moves: 0"),
                     font_lg.clone(),
                     TextColor(TEXT_SECONDARY),
@@ -680,9 +692,7 @@ fn spawn_hud(
                 ));
                 t2.spawn((
                     HudWonPreviously,
-                    Tooltip::new(
-                        "You've won this deal before. Same seed in your replay history.",
-                    ),
+                    Tooltip::new("You've won this deal before. Same seed in your replay history."),
                     Text::new(""),
                     font_body.clone(),
                     TextColor(STATE_SUCCESS),
@@ -695,9 +705,7 @@ fn spawn_hud(
             hud.spawn(row_node()).with_children(|t3| {
                 t3.spawn((
                     HudUndos,
-                    Tooltip::new(
-                        "Undos used this game. Any undo blocks the No Undo achievement.",
-                    ),
+                    Tooltip::new("Undos used this game. Any undo blocks the No Undo achievement."),
                     Text::new(""),
                     font_body.clone(),
                     TextColor(STATE_WARNING),
@@ -874,7 +882,8 @@ fn spawn_action_buttons(
     windows: Query<&Window>,
     mut commands: Commands,
 ) {
-    let action_font_size = action_bar_font_size(windows.iter().next().map_or(900.0, |win| win.width()));
+    let action_font_size =
+        action_bar_font_size(windows.iter().next().map_or(900.0, |win| win.width()));
     let font = TextFont {
         font: font_res.as_ref().map(|f| f.0.clone()).unwrap_or_default(),
         font_size: action_font_size,
@@ -915,13 +924,76 @@ fn spawn_action_buttons(
             // so Tab cycles the action bar in visual reading order.
             // Undo and Pause are the primary gameplay actions — full brightness.
             // Menu, Help, Hint, Modes, New are navigation/utility — dimmed.
-            spawn_action_button(row, MenuButton, ACTION_BAR_LABELS[0], None, "Open Stats, Achievements, Profile, Settings, or Leaderboard.", &font, 0, TEXT_SECONDARY);
-            spawn_action_button(row, UndoButton, ACTION_BAR_LABELS[1], Some("U"), "Take back your last move. Costs points and blocks No Undo.", &font, 1, TEXT_PRIMARY);
-            spawn_action_button(row, PauseButton, ACTION_BAR_LABELS[2], Some("Esc"), "Pause the game and freeze the timer.", &font, 2, TEXT_PRIMARY);
-            spawn_action_button(row, HelpButton, ACTION_BAR_LABELS[3], Some("F1"), "Show controls, rules, and keyboard shortcuts.", &font, 3, TEXT_SECONDARY);
-            spawn_action_button(row, HintButton, ACTION_BAR_LABELS[4], Some("H"), "Highlight a suggested move. Cycles through alternatives on repeat taps.", &font, 4, TEXT_SECONDARY);
-            spawn_action_button(row, ModesButton, ACTION_BAR_LABELS[5], None, "Switch modes: Classic, Daily, Zen, Challenge, Time Attack.", &font, 5, TEXT_SECONDARY);
-            spawn_action_button(row, NewGameButton, ACTION_BAR_LABELS[6], Some("N"), "Start a fresh deal. Confirms first if a game is in progress.", &font, 6, TEXT_SECONDARY);
+            spawn_action_button(
+                row,
+                MenuButton,
+                ACTION_BAR_LABELS[0],
+                None,
+                "Open Stats, Achievements, Profile, Settings, or Leaderboard.",
+                &font,
+                0,
+                TEXT_SECONDARY,
+            );
+            spawn_action_button(
+                row,
+                UndoButton,
+                ACTION_BAR_LABELS[1],
+                Some("U"),
+                "Take back your last move. Costs points and blocks No Undo.",
+                &font,
+                1,
+                TEXT_PRIMARY,
+            );
+            spawn_action_button(
+                row,
+                PauseButton,
+                ACTION_BAR_LABELS[2],
+                Some("Esc"),
+                "Pause the game and freeze the timer.",
+                &font,
+                2,
+                TEXT_PRIMARY,
+            );
+            spawn_action_button(
+                row,
+                HelpButton,
+                ACTION_BAR_LABELS[3],
+                Some("F1"),
+                "Show controls, rules, and keyboard shortcuts.",
+                &font,
+                3,
+                TEXT_SECONDARY,
+            );
+            spawn_action_button(
+                row,
+                HintButton,
+                ACTION_BAR_LABELS[4],
+                Some("H"),
+                "Highlight a suggested move. Cycles through alternatives on repeat taps.",
+                &font,
+                4,
+                TEXT_SECONDARY,
+            );
+            spawn_action_button(
+                row,
+                ModesButton,
+                ACTION_BAR_LABELS[5],
+                None,
+                "Switch modes: Classic, Daily, Zen, Challenge, Time Attack.",
+                &font,
+                5,
+                TEXT_SECONDARY,
+            );
+            spawn_action_button(
+                row,
+                NewGameButton,
+                ACTION_BAR_LABELS[6],
+                Some("N"),
+                "Start a fresh deal. Confirms first if a game is in progress.",
+                &font,
+                6,
+                TEXT_SECONDARY,
+            );
         });
 }
 
@@ -952,7 +1024,11 @@ fn spawn_action_button<M: Component>(
     // touch device — the button itself is the affordance — and they
     // visibly clutter the narrow-viewport action row. The chevrons on
     // Menu/Modes remain because they indicate dropdown behaviour.
-    let hotkey = if SHOW_KEYBOARD_ACCELERATORS { hotkey } else { None };
+    let hotkey = if SHOW_KEYBOARD_ACCELERATORS {
+        hotkey
+    } else {
+        None
+    };
 
     let hotkey_font = TextFont {
         font: font.font.clone(),
@@ -1082,9 +1158,7 @@ fn handle_modes_button(
     font_res: Option<Res<FontResource>>,
     mut commands: Commands,
 ) {
-    let pressed = interaction_query
-        .iter()
-        .any(|i| *i == Interaction::Pressed);
+    let pressed = interaction_query.iter().any(|i| *i == Interaction::Pressed);
     if !pressed {
         return;
     }
@@ -1261,9 +1335,7 @@ fn handle_mode_option_click(
             }
         }
     }
-    if clicked_any
-        && let Ok(entity) = popovers.single()
-    {
+    if clicked_any && let Ok(entity) = popovers.single() {
         commands.entity(entity).despawn();
         for e in &backdrops {
             commands.entity(e).despawn();
@@ -1282,9 +1354,7 @@ fn handle_menu_button(
     font_res: Option<Res<FontResource>>,
     mut commands: Commands,
 ) {
-    let pressed = interaction_query
-        .iter()
-        .any(|i| *i == Interaction::Pressed);
+    let pressed = interaction_query.iter().any(|i| *i == Interaction::Pressed);
     if !pressed {
         return;
     }
@@ -1462,13 +1532,12 @@ fn handle_menu_option_click(
             }
         }
     }
-    if clicked_any
-        && let Ok(entity) = popovers.single() {
-            commands.entity(entity).despawn();
-            for e in &backdrops {
-                commands.entity(e).despawn();
-            }
+    if clicked_any && let Ok(entity) = popovers.single() {
+        commands.entity(entity).despawn();
+        for e in &backdrops {
+            commands.entity(e).despawn();
         }
+    }
     if open_modes {
         spawn_modes_popover(
             &mut commands,
@@ -1587,11 +1656,7 @@ const ACTION_FADE_RATE_PER_SEC: f32 = 6.0;
 /// (player is using keyboard); `0.0` otherwise. Lerps `alpha` toward
 /// `target` at a fixed rate so the visual transition is smooth across
 /// variable framerates.
-fn update_action_fade(
-    windows: Query<&Window>,
-    time: Res<Time>,
-    mut fade: ResMut<HudActionFade>,
-) {
+fn update_action_fade(windows: Query<&Window>, time: Res<Time>, mut fade: ResMut<HudActionFade>) {
     let Ok(window) = windows.single() else {
         return;
     };
@@ -2022,12 +2087,14 @@ fn update_won_previously(
     let won_before = !game.0.is_won
         && history.as_ref().is_some_and(|h| {
             h.0.replays.iter().any(|r| {
-                r.seed == game.0.seed
-                    && r.draw_mode == game.0.draw_mode
-                    && r.mode == game.0.mode
+                r.seed == game.0.seed && r.draw_mode == game.0.draw_mode && r.mode == game.0.mode
             })
         });
-    let next = if won_before { "\u{2713} Won before" } else { "" };
+    let next = if won_before {
+        "\u{2713} Won before"
+    } else {
+        ""
+    };
     if text.0 != next {
         text.0 = next.to_string();
     }
@@ -2290,13 +2357,14 @@ fn update_hud(
     let ac_active = auto_complete.as_ref().is_some_and(|ac| ac.active);
     let ac_changed = auto_complete.as_ref().is_some_and(|ac| ac.is_changed());
     if (ac_changed || game.is_changed())
-        && let Ok(mut t) = auto_q.single_mut() {
-            **t = if ac_active {
-                "AUTO".to_string()
-            } else {
-                String::new()
-            };
-        }
+        && let Ok(mut t) = auto_q.single_mut()
+    {
+        **t = if ac_active {
+            "AUTO".to_string()
+        } else {
+            String::new()
+        };
+    }
 }
 
 /// Updates the `HudSelection` text node to show which pile is Tab-selected.
@@ -2480,9 +2548,17 @@ fn action_bar_font_size(window_width: f32) -> f32 {
 
 fn action_button_metrics() -> (UiRect, Val, Val) {
     if USE_TOUCH_UI_LAYOUT {
-        (UiRect::axes(Val::Px(4.0), Val::Px(4.0)), Val::Px(52.0), Val::Px(44.0))
+        (
+            UiRect::axes(Val::Px(4.0), Val::Px(4.0)),
+            Val::Px(52.0),
+            Val::Px(44.0),
+        )
     } else {
-        (UiRect::axes(VAL_SPACE_2, VAL_SPACE_2), Val::Px(48.0), Val::Px(48.0))
+        (
+            UiRect::axes(VAL_SPACE_2, VAL_SPACE_2),
+            Val::Px(48.0),
+            Val::Px(48.0),
+        )
     }
 }
 
@@ -2493,7 +2569,12 @@ fn spawn_action_button_label(
     text_color: Color,
 ) {
     if USE_TOUCH_UI_LAYOUT {
-        parent.spawn((ActionButtonLabel, Text::new(label), font.clone(), TextColor(text_color)));
+        parent.spawn((
+            ActionButtonLabel,
+            Text::new(label),
+            font.clone(),
+            TextColor(text_color),
+        ));
     } else {
         parent.spawn((Text::new(label), font.clone(), TextColor(text_color)));
     }
@@ -2508,7 +2589,10 @@ fn resize_action_bar_labels(
     windows: Query<&Window>,
     mut labels: Query<&mut TextFont, With<ActionButtonLabel>>,
 ) {
-    let w = windows.iter().next().map_or(layout.0.card_size.x * 7.25, |win| win.width());
+    let w = windows
+        .iter()
+        .next()
+        .map_or(layout.0.card_size.x * 7.25, |win| win.width());
     let new_size = action_bar_font_size(w);
     for mut font in &mut labels {
         font.font_size = new_size;
@@ -2545,8 +2629,7 @@ fn toggle_hud_on_tap(
                 // Record whether the finger-down landed on a button so
                 // the finger-up doesn't double-fire (toggle bar + press
                 // button at the same time).
-                tracker.started_on_button =
-                    buttons.iter().any(|i| *i != Interaction::None);
+                tracker.started_on_button = buttons.iter().any(|i| *i != Interaction::None);
             }
             TouchPhase::Ended if drag.is_idle() => {
                 // Also treat taps where game logic consumed the touch (e.g.
@@ -2630,7 +2713,10 @@ mod tests {
     #[test]
     fn moves_reflects_game_state() {
         let mut app = headless_app();
-        app.world_mut().resource_mut::<GameStateResource>().0.move_count = 42;
+        app.world_mut()
+            .resource_mut::<GameStateResource>()
+            .0
+            .move_count = 42;
         app.update();
         assert_eq!(read_hud_text::<HudMoves>(&mut app), "Moves: 42");
     }
@@ -2660,7 +2746,10 @@ mod tests {
     #[test]
     fn time_display_uses_mm_ss_format() {
         let mut app = headless_app();
-        app.world_mut().resource_mut::<GameStateResource>().0.elapsed_seconds = 125;
+        app.world_mut()
+            .resource_mut::<GameStateResource>()
+            .0
+            .elapsed_seconds = 125;
         app.update();
         // 125 seconds = 2 minutes 5 seconds → "2:05"
         assert_eq!(read_hud_text::<HudTime>(&mut app), "2:05");
@@ -2834,7 +2923,10 @@ mod tests {
     #[test]
     fn undos_hud_shows_count_after_undo() {
         let mut app = headless_app();
-        app.world_mut().resource_mut::<GameStateResource>().0.undo_count = 3;
+        app.world_mut()
+            .resource_mut::<GameStateResource>()
+            .0
+            .undo_count = 3;
         app.update();
         assert_eq!(read_hud_text::<HudUndos>(&mut app), "Undos: 3");
     }
@@ -2859,7 +2951,10 @@ mod tests {
         let mut app = headless_app_with_auto_complete();
         app.world_mut().resource_mut::<AutoCompleteState>().active = true;
         // Also trigger game state change so the update fires.
-        app.world_mut().resource_mut::<GameStateResource>().0.move_count += 1;
+        app.world_mut()
+            .resource_mut::<GameStateResource>()
+            .0
+            .move_count += 1;
         app.update();
         assert_eq!(read_hud_text::<HudAutoComplete>(&mut app), "AUTO");
     }
@@ -2868,7 +2963,10 @@ mod tests {
     fn auto_complete_badge_empty_when_inactive() {
         let mut app = headless_app_with_auto_complete();
         // active is false by default.
-        app.world_mut().resource_mut::<GameStateResource>().0.move_count += 1;
+        app.world_mut()
+            .resource_mut::<GameStateResource>()
+            .0
+            .move_count += 1;
         app.update();
         assert_eq!(read_hud_text::<HudAutoComplete>(&mut app), "");
     }
@@ -2928,9 +3026,9 @@ mod tests {
     fn set_manual_time_step(app: &mut App, secs: f32) {
         use bevy::time::TimeUpdateStrategy;
         use std::time::Duration;
-        app.insert_resource(TimeUpdateStrategy::ManualDuration(
-            Duration::from_secs_f32(secs),
-        ));
+        app.insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_secs_f32(
+            secs,
+        )));
     }
 
     /// Counts entities matching component `M` currently in the world.
@@ -3130,9 +3228,7 @@ mod tests {
     /// which is the invariant we want to enforce for HUD readouts and
     /// action buttons (each marker is spawned exactly once).
     fn tooltip_for<M: Component>(app: &mut App) -> String {
-        let mut q = app
-            .world_mut()
-            .query_filtered::<&Tooltip, With<M>>();
+        let mut q = app.world_mut().query_filtered::<&Tooltip, With<M>>();
         let world = app.world();
         let mut iter = q.iter(world);
         let first = iter

solitaire_engine/src/layout.rs

@@ -75,7 +75,7 @@ const VERTICAL_GAP_FRAC: f32 = 0.2;
 /// column must fit at this fraction). On desktop (height-limited) windows the
 /// adaptive computation returns this value exactly; on portrait phones it
 /// expands to fill available vertical space.
-const TABLEAU_FAN_FRAC: f32 = 0.18;
+pub const TABLEAU_FAN_FRAC: f32 = 0.18;
 
 /// Minimum fraction for face-down tableau cards. Scales proportionally with
 /// the adaptive face-up fraction so hit-testing and rendering stay in sync.
@@ -183,7 +183,12 @@ pub struct Layout {
 /// - Top row (stock, waste, 4 foundations) aligns with tableau columns
 ///   0, 1, 3, 4, 5, 6 — column 2 is intentionally empty to separate the
 ///   waste/stock cluster from the foundations.
-pub fn compute_layout(window: Vec2, safe_area_top: f32, safe_area_bottom: f32, hud_visible: bool) -> Layout {
+pub fn compute_layout(
+    window: Vec2,
+    safe_area_top: f32,
+    safe_area_bottom: f32,
+    hud_visible: bool,
+) -> Layout {
     let window = window.max(MIN_WINDOW);
     let band_h = if hud_visible { HUD_BAND_HEIGHT } else { 0.0 };
 
@@ -213,7 +218,8 @@ pub fn compute_layout(window: Vec2, safe_area_top: f32, safe_area_bottom: f32, h
 
     let fan_factor = 1.0 + (MAX_TABLEAU_CARDS - 1.0) * TABLEAU_FAN_FRAC;
     let height_denom = 0.5 + (1.0 + fan_factor + VERTICAL_GAP_FRAC) * CARD_ASPECT;
-    let card_width_height_based = (window.y - safe_area_top - effective_safe_bottom - band_h).max(0.0) / height_denom;
+    let card_width_height_based =
+        (window.y - safe_area_top - effective_safe_bottom - band_h).max(0.0) / height_denom;
 
     let card_width = card_width_width_based.min(card_width_height_based);
     let card_height = card_width * CARD_ASPECT;
@@ -262,7 +268,8 @@ pub fn compute_layout(window: Vec2, safe_area_top: f32, safe_area_bottom: f32, h
     //
     // avail = distance from the top of the first tableau card to the bottom
     //         margin — i.e. the space available for 12 fan steps.
-    let avail = (tableau_y - (-window.y / 2.0 + effective_safe_bottom + h_gap) - card_height / 2.0).max(0.0);
+    let avail = (tableau_y - (-window.y / 2.0 + effective_safe_bottom + h_gap) - card_height / 2.0)
+        .max(0.0);
     let ideal_fan_frac = if card_height > 0.0 {
         avail / ((MAX_TABLEAU_CARDS - 1.0) * card_height)
     } else {
@@ -298,7 +305,9 @@ mod tests {
         assert!(layout.pile_positions.contains_key(&PileType::Waste));
         for slot in 0..4_u8 {
             assert!(
-                layout.pile_positions.contains_key(&PileType::Foundation(slot)),
+                layout
+                    .pile_positions
+                    .contains_key(&PileType::Foundation(slot)),
                 "missing foundation slot {slot}",
             );
         }

solitaire_engine/src/leaderboard_plugin.rs

@@ -9,9 +9,13 @@
 //! When the provider does not support leaderboards (e.g. `LocalOnlyProvider`)
 //! the panel shows "Not available" immediately.
 
-use bevy::input::{ButtonState, keyboard::KeyboardInput, mouse::{MouseScrollUnit, MouseWheel}};
+use bevy::input::{
+    ButtonState,
+    keyboard::KeyboardInput,
+    mouse::{MouseScrollUnit, MouseWheel},
+};
 use bevy::prelude::*;
-use bevy::tasks::{futures_lite::future, AsyncComputeTaskPool, Task};
+use bevy::tasks::{AsyncComputeTaskPool, Task, futures_lite::future};
 use solitaire_data::{save_settings_to, settings::SyncBackend};
 use solitaire_sync::LeaderboardEntry;
 
@@ -20,13 +24,13 @@ use crate::font_plugin::FontResource;
 use crate::settings_plugin::{SettingsResource, SettingsStoragePath};
 use crate::sync_plugin::SyncProviderResource;
 use crate::ui_modal::{
-    spawn_modal, spawn_modal_actions, spawn_modal_button, spawn_modal_header, ButtonVariant,
-    ModalScrim, ScrimDismissible,
+    ButtonVariant, ModalScrim, ScrimDismissible, spawn_modal, spawn_modal_actions,
+    spawn_modal_button, spawn_modal_header,
 };
 use crate::ui_theme::{
-    ACCENT_PRIMARY, BG_ELEVATED, BORDER_SUBTLE, RADIUS_SM, STATE_INFO,
-    TEXT_DISABLED, TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY, TYPE_BODY_LG, TYPE_CAPTION,
-    VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4, Z_MODAL_PANEL, Z_PAUSE_DIALOG,
+    ACCENT_PRIMARY, BG_ELEVATED, BORDER_SUBTLE, RADIUS_SM, STATE_INFO, TEXT_DISABLED, TEXT_PRIMARY,
+    TEXT_SECONDARY, TYPE_BODY, TYPE_BODY_LG, TYPE_CAPTION, VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4,
+    Z_MODAL_PANEL, Z_PAUSE_DIALOG,
 };
 
 // ---------------------------------------------------------------------------
@@ -208,18 +212,30 @@ fn toggle_leaderboard_screen(
     let remote_available = provider
         .as_ref()
         .is_some_and(|p| p.0.backend_name() != "local");
-    let dn = settings.as_ref().and_then(|s| s.0.leaderboard_display_name.as_deref());
-    spawn_leaderboard_screen(&mut commands, &data, remote_available, dn, font_res.as_deref());
+    let dn = settings
+        .as_ref()
+        .and_then(|s| s.0.leaderboard_display_name.as_deref());
+    spawn_leaderboard_screen(
+        &mut commands,
+        &data,
+        remote_available,
+        dn,
+        font_res.as_deref(),
+    );
 
     // Start a background fetch if not already in flight.
     if task_res.0.is_none()
-        && let Some(p) = provider {
-            let provider = p.0.clone();
-            let task = AsyncComputeTaskPool::get().spawn(async move {
-                provider.fetch_leaderboard().await.map_err(|e| e.to_string())
-            });
-            task_res.0 = Some(task);
-        }
+        && let Some(p) = provider
+    {
+        let provider = p.0.clone();
+        let task = AsyncComputeTaskPool::get().spawn(async move {
+            provider
+                .fetch_leaderboard()
+                .await
+                .map_err(|e| e.to_string())
+        });
+        task_res.0 = Some(task);
+    }
 }
 
 /// Poll the background fetch task; store results when complete.
@@ -227,8 +243,12 @@ fn poll_leaderboard_fetch(
     mut task_res: ResMut<LeaderboardFetchTask>,
     mut result_res: ResMut<LeaderboardFetchResult>,
 ) {
-    let Some(task) = task_res.0.as_mut() else { return };
-    let Some(result) = future::block_on(future::poll_once(task)) else { return };
+    let Some(task) = task_res.0.as_mut() else {
+        return;
+    };
+    let Some(result) = future::block_on(future::poll_once(task)) else {
+        return;
+    };
     task_res.0 = None;
     result_res.0 = Some(result);
 }
@@ -247,7 +267,9 @@ fn update_leaderboard_panel(
     font_res: Option<Res<FontResource>>,
     closed_flag: Res<ClosedThisFrame>,
 ) {
-    let Some(result) = result_res.0.take() else { return };
+    let Some(result) = result_res.0.take() else {
+        return;
+    };
 
     match result {
         Ok(entries) => {
@@ -272,10 +294,18 @@ fn update_leaderboard_panel(
     let remote_available = provider
         .as_ref()
         .is_some_and(|p| p.0.backend_name() != "local");
-    let dn = settings.as_ref().and_then(|s| s.0.leaderboard_display_name.as_deref());
+    let dn = settings
+        .as_ref()
+        .and_then(|s| s.0.leaderboard_display_name.as_deref());
     for entity in &screens {
         commands.entity(entity).despawn();
-        spawn_leaderboard_screen(&mut commands, &data, remote_available, dn, font_res.as_deref());
+        spawn_leaderboard_screen(
+            &mut commands,
+            &data,
+            remote_available,
+            dn,
+            font_res.as_deref(),
+        );
     }
 }
 
@@ -358,8 +388,12 @@ fn handle_opt_in_button(
             .unwrap_or_else(|| "Player".to_string());
 
         let provider = provider.0.clone();
-        let task = AsyncComputeTaskPool::get()
-            .spawn(async move { provider.opt_in_leaderboard(&display_name).await.map_err(|e| e.to_string()) });
+        let task = AsyncComputeTaskPool::get().spawn(async move {
+            provider
+                .opt_in_leaderboard(&display_name)
+                .await
+                .map_err(|e| e.to_string())
+        });
         task_res.0 = Some(task);
     }
 }
@@ -372,8 +406,12 @@ fn poll_opt_in_task(
     settings: Option<ResMut<SettingsResource>>,
     settings_path: Option<Res<SettingsStoragePath>>,
 ) {
-    let Some(task) = task_res.0.as_mut() else { return };
-    let Some(result) = future::block_on(future::poll_once(task)) else { return };
+    let Some(task) = task_res.0.as_mut() else {
+        return;
+    };
+    let Some(result) = future::block_on(future::poll_once(task)) else {
+        return;
+    };
     task_res.0 = None;
     match result {
         Ok(()) => {
@@ -409,8 +447,12 @@ fn handle_opt_out_button(
             continue;
         }
         let provider = provider.0.clone();
-        let task = AsyncComputeTaskPool::get()
-            .spawn(async move { provider.opt_out_leaderboard().await.map_err(|e| e.to_string()) });
+        let task = AsyncComputeTaskPool::get().spawn(async move {
+            provider
+                .opt_out_leaderboard()
+                .await
+                .map_err(|e| e.to_string())
+        });
         task_res.0 = Some(task);
     }
 }
@@ -423,8 +465,12 @@ fn poll_opt_out_task(
     settings: Option<ResMut<SettingsResource>>,
     settings_path: Option<Res<SettingsStoragePath>>,
 ) {
-    let Some(task) = task_res.0.as_mut() else { return };
-    let Some(result) = future::block_on(future::poll_once(task)) else { return };
+    let Some(task) = task_res.0.as_mut() else {
+        return;
+    };
+    let Some(result) = future::block_on(future::poll_once(task)) else {
+        return;
+    };
     task_res.0 = None;
     match result {
         Ok(()) => {
@@ -941,7 +987,10 @@ fn update_leaderboard_public_name_label(
     if labels.is_empty() {
         return;
     }
-    let new_label = match settings.as_ref().and_then(|s| s.0.leaderboard_display_name.as_deref()) {
+    let new_label = match settings
+        .as_ref()
+        .and_then(|s| s.0.leaderboard_display_name.as_deref())
+    {
         Some(n) => format!("Public name: {n}"),
         None => "Public name: (same as username)".to_string(),
     };
@@ -974,14 +1023,14 @@ fn format_secs(secs: u64) -> String {
 mod tests {
     use super::*;
     use crate::game_plugin::GamePlugin;
-    use crate::table_plugin::TablePlugin;
     use crate::sync_plugin::SyncPlugin;
-    use solitaire_data::SyncError;
-    use solitaire_sync::{SyncPayload, SyncResponse};
+    use crate::table_plugin::TablePlugin;
     use chrono::Utc;
-    use uuid::Uuid;
-    use solitaire_sync::PlayerProgress;
     use solitaire_data::StatsSnapshot;
+    use solitaire_data::SyncError;
+    use solitaire_sync::PlayerProgress;
+    use solitaire_sync::{SyncPayload, SyncResponse};
+    use uuid::Uuid;
 
     struct NoOpProvider;
 
@@ -1009,18 +1058,20 @@ mod tests {
                 conflicts: vec![],
             })
         }
-        fn backend_name(&self) -> &'static str { "no-op" }
-        fn is_authenticated(&self) -> bool { false }
+        fn backend_name(&self) -> &'static str {
+            "no-op"
+        }
+        fn is_authenticated(&self) -> bool {
+            false
+        }
 
         async fn fetch_leaderboard(&self) -> Result<Vec<LeaderboardEntry>, SyncError> {
-            Ok(vec![
-                LeaderboardEntry {
-                    display_name: "Alice".to_string(),
-                    best_score: Some(5000),
-                    best_time_secs: Some(180),
-                    recorded_at: Utc::now(),
-                },
-            ])
+            Ok(vec![LeaderboardEntry {
+                display_name: "Alice".to_string(),
+                best_score: Some(5000),
+                best_time_secs: Some(180),
+                recorded_at: Utc::now(),
+            }])
         }
     }
 
@@ -1148,7 +1199,9 @@ mod tests {
 
     fn headless_app_with_settings() -> App {
         let mut app = headless_app();
-        app.insert_resource(SettingsResource(solitaire_data::settings::Settings::default()));
+        app.insert_resource(SettingsResource(
+            solitaire_data::settings::Settings::default(),
+        ));
         app
     }
 
@@ -1231,11 +1284,12 @@ mod tests {
         let mut app = headless_app_with_settings();
 
         // Confirm the flag starts false.
-        assert!(!app
-            .world()
-            .resource::<SettingsResource>()
-            .0
-            .leaderboard_opted_in);
+        assert!(
+            !app.world()
+                .resource::<SettingsResource>()
+                .0
+                .leaderboard_opted_in
+        );
 
         let ok_task = AsyncComputeTaskPool::get().spawn(async { Ok::<(), String>(()) });
         app.world_mut().resource_mut::<OptInTask>().0 = Some(ok_task);

solitaire_engine/src/lib.rs

@@ -1,46 +1,46 @@
 //! Bevy integration layer for Ferrous Solitaire.
 
-#[cfg(target_os = "android")]
-pub mod android_clipboard;
-pub mod assets;
-pub mod card_animation;
 pub mod achievement_plugin;
 pub mod analytics_plugin;
+#[cfg(target_os = "android")]
+pub mod android_clipboard;
 pub mod animation_plugin;
-pub mod avatar_plugin;
-pub mod auto_complete_plugin;
+pub mod assets;
 pub mod audio_plugin;
+pub mod auto_complete_plugin;
+pub mod avatar_plugin;
+pub mod card_animation;
 pub mod card_plugin;
-pub mod font_plugin;
-pub mod feedback_anim_plugin;
 pub mod challenge_plugin;
+pub mod core_game_plugin;
 pub mod cursor_plugin;
 pub mod daily_challenge_plugin;
-pub mod difficulty_plugin;
 pub mod diagnostics_hud;
+pub mod difficulty_plugin;
 pub mod events;
-pub mod core_game_plugin;
+pub mod feedback_anim_plugin;
+pub mod font_plugin;
 pub mod game_plugin;
 pub mod help_plugin;
 pub mod home_plugin;
 pub mod hud_plugin;
-pub mod leaderboard_plugin;
 pub mod input_plugin;
 pub mod layout;
+pub mod leaderboard_plugin;
 pub mod onboarding_plugin;
 pub mod pause_plugin;
 pub mod pending_hint;
-pub mod play_by_seed_plugin;
 pub mod platform;
+pub mod play_by_seed_plugin;
 pub mod profile_plugin;
+pub mod progress_plugin;
 pub mod radial_menu;
 pub mod replay_overlay;
 pub mod replay_playback;
-pub mod settings_plugin;
-pub mod progress_plugin;
 pub mod resources;
 pub mod safe_area;
 pub mod selection_plugin;
+pub mod settings_plugin;
 pub mod splash_plugin;
 pub mod stats_plugin;
 pub mod sync_plugin;
@@ -55,50 +55,37 @@ pub mod ui_tooltip;
 pub mod weekly_goals_plugin;
 pub mod win_summary_plugin;
 
-pub use assets::{
-    bundled_theme_url, populate_embedded_dark_theme, register_theme_asset_sources,
-    AssetSourcesPlugin, DARK_THEME_MANIFEST_URL, USER_THEMES,
-};
-pub use theme::{
-    set_theme, ActiveTheme, CardTheme, CardThemeLoader, ThemeEntry, ThemePlugin, ThemeRegistry,
-    ThemeRegistryPlugin,
-};
 pub use achievement_plugin::{AchievementPlugin, AchievementsResource, AchievementsScreen};
 pub use analytics_plugin::{AnalyticsPlugin, AnalyticsResource};
-pub use challenge_plugin::{
-    challenge_progress_label, ChallengeAdvancedEvent, ChallengePlugin, CHALLENGE_UNLOCK_LEVEL,
-};
-pub use core_game_plugin::CoreGamePlugin;
-pub use daily_challenge_plugin::{
-    DailyChallengeCompletedEvent, DailyChallengePlugin, DailyChallengeResource,
-};
-pub use progress_plugin::{LevelUpEvent, ProgressPlugin, ProgressResource, ProgressUpdate};
-pub use weekly_goals_plugin::{WeeklyGoalCompletedEvent, WeeklyGoalsPlugin};
 pub use animation_plugin::{ActiveToast, AnimationPlugin, CardAnim, ToastEntity, ToastQueue};
-pub use card_animation::{
-    CardAnimation, CardAnimationPlugin, MotionCurve, WinCascadePlugin,
-    retarget_animation, sample_curve, compute_duration, cascade_delay, micro_vary,
-    HoverState, InputBuffer, BufferedInput,
-    win_scatter_targets, WIN_CASCADE_INTERVAL_SECS, DEAL_INTERVAL_SECS,
-    MIN_DURATION_SECS, MAX_DURATION_SECS,
-    AnimationChain,
-    AnimationTuning, InputPlatform,
-    FrameTimeDiagnostics, DIAG_WINDOW_SIZE,
+pub use assets::{
+    AssetSourcesPlugin, DARK_THEME_MANIFEST_URL, USER_THEMES, bundled_theme_url,
+    populate_embedded_dark_theme, register_theme_asset_sources,
 };
-pub use feedback_anim_plugin::{
-    deal_stagger_delay, deal_stagger_secs_for_speed, foundation_flourish_scale, shake_offset,
-    settle_scale, FeedbackAnimPlugin, FoundationFlourish, FoundationMarkerFlourish, SettleAnim,
-    ShakeAnim,
-};
-pub use auto_complete_plugin::AutoCompletePlugin;
 pub use audio_plugin::{AudioPlugin, AudioState, SoundLibrary};
+pub use auto_complete_plugin::AutoCompletePlugin;
+pub use avatar_plugin::{AvatarFetchEvent, AvatarPlugin, AvatarResource};
+pub use card_animation::{
+    AnimationChain, AnimationTuning, BufferedInput, CardAnimation, CardAnimationPlugin,
+    DEAL_INTERVAL_SECS, DIAG_WINDOW_SIZE, FrameTimeDiagnostics, HoverState, InputBuffer,
+    InputPlatform, MAX_DURATION_SECS, MIN_DURATION_SECS, MotionCurve, WIN_CASCADE_INTERVAL_SECS,
+    WinCascadePlugin, cascade_delay, compute_duration, micro_vary, retarget_animation,
+    sample_curve, win_scatter_targets,
+};
 pub use card_plugin::{
     CardEntity, CardImageSet, CardLabel, CardPlugin, HintHighlight, HintHighlightTimer,
     RightClickHighlight, RightClickHighlightTimer,
 };
-pub use font_plugin::{FontPlugin, FontResource};
+pub use challenge_plugin::{
+    CHALLENGE_UNLOCK_LEVEL, ChallengeAdvancedEvent, ChallengePlugin, challenge_progress_label,
+};
+pub use core_game_plugin::CoreGamePlugin;
 pub use cursor_plugin::CursorPlugin;
+pub use daily_challenge_plugin::{
+    DailyChallengeCompletedEvent, DailyChallengePlugin, DailyChallengeResource,
+};
 pub use diagnostics_hud::DiagnosticsHudPlugin;
+pub use difficulty_plugin::{DifficultyIndexResource, DifficultyPlugin};
 pub use events::{
     AchievementUnlockedEvent, CardFaceRevealedEvent, CardFlippedEvent, DrawRequestEvent,
     ForfeitEvent, ForfeitRequestEvent, FoundationCompletedEvent, GameWonEvent, HelpRequestEvent,
@@ -107,12 +94,15 @@ pub use events::{
     StartDailyChallengeRequestEvent, StartDifficultyRequestEvent, StartPlayBySeedRequestEvent,
     StartTimeAttackRequestEvent, StartZenRequestEvent, StateChangedEvent, SyncCompleteEvent,
     ToggleAchievementsRequestEvent, ToggleLeaderboardRequestEvent, ToggleProfileRequestEvent,
-    ToggleSettingsRequestEvent, ToggleStatsRequestEvent, UndoRequestEvent,
-    WinStreakMilestoneEvent, XpAwardedEvent,
+    ToggleSettingsRequestEvent, ToggleStatsRequestEvent, UndoRequestEvent, WinStreakMilestoneEvent,
+    XpAwardedEvent,
 };
-pub use difficulty_plugin::{DifficultyIndexResource, DifficultyPlugin};
-pub use play_by_seed_plugin::{PlayBySeedPlugin, PlayBySeedScreen};
-pub use platform::{PlatformTime, StorageBackend};
+pub use feedback_anim_plugin::{
+    FeedbackAnimPlugin, FoundationFlourish, FoundationMarkerFlourish, SettleAnim, ShakeAnim,
+    deal_stagger_delay, deal_stagger_secs_for_speed, foundation_flourish_scale, settle_scale,
+    shake_offset,
+};
+pub use font_plugin::{FontPlugin, FontResource};
 pub use game_plugin::{
     ConfirmNewGameScreen, GameMutation, GameOverScreen, GamePlugin, GameStatePath, RecordingReplay,
     ReplayPath,
@@ -120,60 +110,69 @@ pub use game_plugin::{
 pub use help_plugin::{HelpPlugin, HelpScreen};
 pub use home_plugin::{HomePlugin, HomeScreen};
 pub use hud_plugin::{
-    streak_flourish_scale, ActionButton, HelpButton, HudAutoComplete, HudPlugin, HudVisibility,
-    MenuButton, MenuOption, MenuPopover, ModeOption, ModesButton, ModesPopover, NewGameButton,
-    PauseButton, StreakFlourish, UndoButton,
+    ActionButton, HelpButton, HudAutoComplete, HudPlugin, HudVisibility, MenuButton, MenuOption,
+    MenuPopover, ModeOption, ModesButton, ModesPopover, NewGameButton, PauseButton, StreakFlourish,
+    UndoButton, streak_flourish_scale,
 };
-pub use leaderboard_plugin::{LeaderboardPlugin, LeaderboardResource, LeaderboardScreen};
 pub use input_plugin::InputPlugin;
+pub use layout::{Layout, LayoutResource, compute_layout};
+pub use leaderboard_plugin::{LeaderboardPlugin, LeaderboardResource, LeaderboardScreen};
 pub use onboarding_plugin::{OnboardingPlugin, OnboardingScreen};
 pub use pause_plugin::{ForfeitConfirmScreen, PausePlugin, PauseScreen, PausedResource};
-pub use avatar_plugin::{AvatarFetchEvent, AvatarPlugin, AvatarResource};
+pub use platform::{PlatformTime, StorageBackend};
+pub use play_by_seed_plugin::{PlayBySeedPlugin, PlayBySeedScreen};
 pub use profile_plugin::{ProfilePlugin, ProfileScreen};
+pub use progress_plugin::{LevelUpEvent, ProgressPlugin, ProgressResource, ProgressUpdate};
 pub use radial_menu::{
-    legal_destinations_for_card, radial_anchor_for_index, radial_hovered_index, RadialIcon,
-    RadialMenuPlugin, RightClickRadialState, Z_RADIAL_MENU,
+    RadialIcon, RadialMenuPlugin, RightClickRadialState, Z_RADIAL_MENU,
+    legal_destinations_for_card, radial_anchor_for_index, radial_hovered_index,
 };
 pub use replay_overlay::{
     ReplayOverlayBannerText, ReplayOverlayPlugin, ReplayOverlayProgressText, ReplayOverlayRoot,
     ReplayStopButton, Z_REPLAY_OVERLAY,
 };
 pub use replay_playback::{
-    start_replay_playback, stop_replay_playback, ReplayPlaybackPlugin, ReplayPlaybackState,
-    REPLAY_COMPLETION_LINGER_SECS, REPLAY_MOVE_INTERVAL_SECS,
+    REPLAY_COMPLETION_LINGER_SECS, REPLAY_MOVE_INTERVAL_SECS, ReplayPlaybackPlugin,
+    ReplayPlaybackState, start_replay_playback, stop_replay_playback,
 };
-pub use settings_plugin::{
-    PendingWindowGeometry, SettingsChangedEvent, SettingsPlugin, SettingsResource, SettingsScreen,
-    SFX_STEP, WINDOW_GEOMETRY_DEBOUNCE_SECS,
+pub use resources::{
+    DragState, GameStateResource, HintCycleIndex, SettingsScrollPos, SyncStatus, SyncStatusResource,
 };
-pub use layout::{compute_layout, Layout, LayoutResource};
-pub use resources::{DragState, GameStateResource, HintCycleIndex, SettingsScrollPos, SyncStatus, SyncStatusResource};
 pub use safe_area::{SafeAreaAnchoredTop, SafeAreaInsets, SafeAreaInsetsPlugin};
 pub use selection_plugin::{
     KeyboardDragState, SelectionHighlight, SelectionPlugin, SelectionState,
 };
-pub use splash_plugin::{SplashAge, SplashPlugin, SplashRoot};
-pub use stats_plugin::{
-    format_replay_caption, LatestReplayPath, ReplayHistoryResource, ReplayNextButton,
-    ReplayPrevButton, ReplaySelectorCaption, SelectedReplayIndex, StatsPlugin, StatsResource,
-    StatsScreen, StatsUpdate, WatchReplayButton,
+pub use settings_plugin::{
+    PendingWindowGeometry, SFX_STEP, SettingsChangedEvent, SettingsPlugin, SettingsResource,
+    SettingsScreen, WINDOW_GEOMETRY_DEBOUNCE_SECS,
 };
 pub use solitaire_data::SyncProvider;
+pub use splash_plugin::{SplashAge, SplashPlugin, SplashRoot};
+pub use stats_plugin::{
+    LatestReplayPath, ReplayHistoryResource, ReplayNextButton, ReplayPrevButton,
+    ReplaySelectorCaption, SelectedReplayIndex, StatsPlugin, StatsResource, StatsScreen,
+    StatsUpdate, WatchReplayButton, format_replay_caption,
+};
 pub use sync_plugin::{SyncPlugin, SyncProviderResource};
 pub use sync_setup_plugin::SyncSetupPlugin;
-pub use ui_focus::{Disabled, FocusGroup, Focusable, FocusedButton, UiFocusPlugin};
-pub use ui_modal::{
-    spawn_modal, spawn_modal_actions, spawn_modal_body_text, spawn_modal_button,
-    spawn_modal_header, ButtonVariant, ModalActions, ModalBody, ModalButton, ModalCard,
-    ModalHeader, ModalScrim, UiModalPlugin,
-};
-pub use ui_tooltip::{Tooltip, UiTooltipPlugin};
 pub use table_plugin::{
     BackgroundImageSet, HintPileHighlight, PileMarker, TableBackground, TablePlugin,
 };
+pub use theme::{
+    ActiveTheme, CardTheme, CardThemeLoader, ThemeEntry, ThemePlugin, ThemeRegistry,
+    ThemeRegistryPlugin, set_theme,
+};
 pub use time_attack_plugin::{
-    TimeAttackEndedEvent, TimeAttackPlugin, TimeAttackResource, TIME_ATTACK_DURATION_SECS,
+    TIME_ATTACK_DURATION_SECS, TimeAttackEndedEvent, TimeAttackPlugin, TimeAttackResource,
 };
+pub use ui_focus::{Disabled, FocusGroup, Focusable, FocusedButton, UiFocusPlugin};
+pub use ui_modal::{
+    ButtonVariant, ModalActions, ModalBody, ModalButton, ModalCard, ModalHeader, ModalScrim,
+    UiModalPlugin, spawn_modal, spawn_modal_actions, spawn_modal_body_text, spawn_modal_button,
+    spawn_modal_header,
+};
+pub use ui_tooltip::{Tooltip, UiTooltipPlugin};
+pub use weekly_goals_plugin::{WeeklyGoalCompletedEvent, WeeklyGoalsPlugin};
 pub use win_summary_plugin::{
-    format_win_time, ScreenShakeResource, SessionAchievements, WinSummaryPending, WinSummaryPlugin,
+    ScreenShakeResource, SessionAchievements, WinSummaryPending, WinSummaryPlugin, format_win_time,
 };

solitaire_engine/src/onboarding_plugin.rs

@@ -23,20 +23,20 @@
 use std::path::PathBuf;
 
 use bevy::prelude::*;
-use solitaire_data::{save_settings_to, Settings};
+use solitaire_data::{Settings, save_settings_to};
 
 use crate::font_plugin::FontResource;
 use crate::settings_plugin::{SettingsResource, SettingsStoragePath};
 use crate::ui_modal::{
-    spawn_modal, spawn_modal_actions, spawn_modal_body_text, spawn_modal_button,
-    spawn_modal_header, ButtonVariant,
+    ButtonVariant, spawn_modal, spawn_modal_actions, spawn_modal_body_text, spawn_modal_button,
+    spawn_modal_header,
 };
-use crate::ui_theme::{TEXT_SECONDARY, Z_ONBOARDING};
 #[cfg(not(target_os = "android"))]
 use crate::ui_theme::{
     BORDER_SUBTLE, HighContrastBorder, RADIUS_SM, TEXT_PRIMARY, TYPE_BODY, TYPE_CAPTION,
     VAL_SPACE_1, VAL_SPACE_2, VAL_SPACE_3,
 };
+use crate::ui_theme::{TEXT_SECONDARY, Z_ONBOARDING};
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -101,16 +101,46 @@ struct HotkeyRow {
 /// refactor the help plugin.
 #[cfg(not(target_os = "android"))]
 const HOTKEYS: &[HotkeyRow] = &[
-    HotkeyRow { keys: "D / Space", description: "Draw from stock" },
-    HotkeyRow { keys: "U", description: "Undo last move" },
-    HotkeyRow { keys: "Tab → Enter", description: "Pick a card; arrows pick where; Enter to drop" },
-    HotkeyRow { keys: "N", description: "New Classic game" },
-    HotkeyRow { keys: "M", description: "Open Mode Launcher (then 1–5 to pick)" },
-    HotkeyRow { keys: "S", description: "Stats & progression" },
-    HotkeyRow { keys: "A", description: "Achievements" },
-    HotkeyRow { keys: "O", description: "Settings" },
-    HotkeyRow { keys: "Esc", description: "Pause / resume" },
-    HotkeyRow { keys: "F1", description: "Help / controls" },
+    HotkeyRow {
+        keys: "D / Space",
+        description: "Draw from stock",
+    },
+    HotkeyRow {
+        keys: "U",
+        description: "Undo last move",
+    },
+    HotkeyRow {
+        keys: "Tab → Enter",
+        description: "Pick a card; arrows pick where; Enter to drop",
+    },
+    HotkeyRow {
+        keys: "N",
+        description: "New Classic game",
+    },
+    HotkeyRow {
+        keys: "M",
+        description: "Open Mode Launcher (then 1–5 to pick)",
+    },
+    HotkeyRow {
+        keys: "S",
+        description: "Stats & progression",
+    },
+    HotkeyRow {
+        keys: "A",
+        description: "Achievements",
+    },
+    HotkeyRow {
+        keys: "O",
+        description: "Settings",
+    },
+    HotkeyRow {
+        keys: "Esc",
+        description: "Pause / resume",
+    },
+    HotkeyRow {
+        keys: "F1",
+        description: "Help / controls",
+    },
 ];
 
 // ---------------------------------------------------------------------------
@@ -126,11 +156,7 @@ impl Plugin for OnboardingPlugin {
             .add_systems(PostStartup, spawn_if_first_run)
             .add_systems(
                 Update,
-                (
-                    handle_onboarding_buttons,
-                    handle_onboarding_keyboard,
-                )
-                    .chain(),
+                (handle_onboarding_buttons, handle_onboarding_keyboard).chain(),
             );
     }
 }
@@ -523,11 +549,16 @@ mod tests {
         assert_eq!(current_slide(&app), 0);
 
         // Spawn a Next button with Pressed interaction.
-        app.world_mut().spawn((OnboardingNextButton, Button, Interaction::Pressed));
+        app.world_mut()
+            .spawn((OnboardingNextButton, Button, Interaction::Pressed));
         app.update();
 
         assert_eq!(current_slide(&app), 1, "Next must advance to slide 1");
-        assert_eq!(count_screens(&mut app), 1, "exactly one modal must be visible");
+        assert_eq!(
+            count_screens(&mut app),
+            1,
+            "exactly one modal must be visible"
+        );
     }
 
     #[test]
@@ -548,10 +579,15 @@ mod tests {
             }
         }
 
-        app.world_mut().spawn((OnboardingBackButton, Button, Interaction::Pressed));
+        app.world_mut()
+            .spawn((OnboardingBackButton, Button, Interaction::Pressed));
         app.update();
 
-        assert_eq!(current_slide(&app), 1, "Back must retreat from slide 2 to slide 1");
+        assert_eq!(
+            current_slide(&app),
+            1,
+            "Back must retreat from slide 2 to slide 1"
+        );
     }
 
     #[test]
@@ -561,7 +597,8 @@ mod tests {
         assert_eq!(current_slide(&app), 0);
 
         // Pressing Back on slide 0 must be a no-op (no underflow to u8::MAX).
-        app.world_mut().spawn((OnboardingBackButton, Button, Interaction::Pressed));
+        app.world_mut()
+            .spawn((OnboardingBackButton, Button, Interaction::Pressed));
         app.update();
 
         assert_eq!(current_slide(&app), 0, "Back on slide 0 must not underflow");
@@ -576,15 +613,23 @@ mod tests {
         app.world_mut().resource_mut::<OnboardingSlideIndex>().0 = SLIDE_COUNT - 1;
 
         // Next on the last slide should complete onboarding, not advance further.
-        app.world_mut().spawn((OnboardingNextButton, Button, Interaction::Pressed));
+        app.world_mut()
+            .spawn((OnboardingNextButton, Button, Interaction::Pressed));
         app.update();
 
         // first_run_complete must be set.
         assert!(
-            app.world().resource::<SettingsResource>().0.first_run_complete,
+            app.world()
+                .resource::<SettingsResource>()
+                .0
+                .first_run_complete,
             "Next on last slide must set first_run_complete"
         );
-        assert_eq!(count_screens(&mut app), 0, "modal must be gone after completion");
+        assert_eq!(
+            count_screens(&mut app),
+            0,
+            "modal must be gone after completion"
+        );
     }
 
     // -----------------------------------------------------------------------
@@ -596,11 +641,15 @@ mod tests {
         let mut app = headless_app();
         app.update();
 
-        app.world_mut().spawn((OnboardingSkipButton, Button, Interaction::Pressed));
+        app.world_mut()
+            .spawn((OnboardingSkipButton, Button, Interaction::Pressed));
         app.update();
 
         assert!(
-            app.world().resource::<SettingsResource>().0.first_run_complete,
+            app.world()
+                .resource::<SettingsResource>()
+                .0
+                .first_run_complete,
             "Skip must set first_run_complete"
         );
         assert_eq!(count_screens(&mut app), 0);
@@ -658,7 +707,10 @@ mod tests {
 
         assert_eq!(count_screens(&mut app), 0, "Esc must dismiss onboarding");
         assert!(
-            app.world().resource::<SettingsResource>().0.first_run_complete,
+            app.world()
+                .resource::<SettingsResource>()
+                .0
+                .first_run_complete,
             "Esc must set first_run_complete"
         );
     }
@@ -675,7 +727,10 @@ mod tests {
         app.update();
 
         assert!(
-            app.world().resource::<SettingsResource>().0.first_run_complete,
+            app.world()
+                .resource::<SettingsResource>()
+                .0
+                .first_run_complete,
             "Enter on last slide must complete onboarding"
         );
         assert_eq!(count_screens(&mut app), 0);
@@ -694,7 +749,10 @@ mod tests {
     #[test]
     #[cfg(target_os = "android")]
     fn slide_count_constant_is_two_on_android() {
-        assert_eq!(SLIDE_COUNT, 2, "SLIDE_COUNT must be 2 on Android (no keyboard slide)");
+        assert_eq!(
+            SLIDE_COUNT, 2,
+            "SLIDE_COUNT must be 2 on Android (no keyboard slide)"
+        );
     }
 
     #[test]
@@ -727,7 +785,10 @@ mod tests {
         app.update();
 
         assert!(
-            app.world().resource::<SettingsResource>().0.first_run_complete,
+            app.world()
+                .resource::<SettingsResource>()
+                .0
+                .first_run_complete,
             "completing the last slide must set first_run_complete"
         );
         assert_eq!(count_screens(&mut app), 0);
@@ -746,7 +807,10 @@ mod tests {
     fn all_hotkey_rows_have_non_empty_fields() {
         for row in HOTKEYS {
             assert!(!row.keys.is_empty(), "hotkey key field must not be empty");
-            assert!(!row.description.is_empty(), "hotkey description must not be empty");
+            assert!(
+                !row.description.is_empty(),
+                "hotkey description must not be empty"
+            );
         }
     }
 }

solitaire_engine/src/pause_plugin.rs

@@ -29,21 +29,21 @@ use crate::events::{
 };
 use crate::font_plugin::FontResource;
 use crate::game_plugin::{GameOverScreen, GameStatePath};
+use crate::hud_plugin::HudPopoverOpen;
 use crate::progress_plugin::ProgressResource;
 use crate::replay_playback::ReplayPlaybackState;
 use crate::resources::{DragState, GameStateResource};
 use crate::selection_plugin::{SelectionKeySet, SelectionState};
 use crate::settings_plugin::{SettingsChangedEvent, SettingsResource, SettingsStoragePath};
 use crate::stats_plugin::StatsResource;
-use crate::hud_plugin::HudPopoverOpen;
 use crate::ui_modal::{
-    spawn_modal, spawn_modal_actions, spawn_modal_body_text, spawn_modal_button,
-    spawn_modal_header, ButtonVariant, ModalScrim,
+    ButtonVariant, ModalScrim, spawn_modal, spawn_modal_actions, spawn_modal_body_text,
+    spawn_modal_button, spawn_modal_header,
 };
-use bevy::ecs::system::SystemParam;
 use crate::ui_theme::{
     self, TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY_LG, TYPE_CAPTION, VAL_SPACE_3,
 };
+use bevy::ecs::system::SystemParam;
 
 /// Toggleable flag read by `tick_elapsed_time` and `advance_time_attack`.
 #[derive(Resource, Debug, Default)]
@@ -223,11 +223,12 @@ fn toggle_pause(
     // Clearing DragState and emitting StateChangedEvent snaps the dragged cards
     // back to their resting positions exactly as a rejected drop does.
     if let Some(ref mut d) = drag
-        && !d.is_idle() {
-            d.clear();
-            changed.write(StateChangedEvent);
-            return;
-        }
+        && !d.is_idle()
+    {
+        d.clear();
+        changed.write(StateChangedEvent);
+        return;
+    }
     if let Ok(entity) = screens.single() {
         commands.entity(entity).despawn();
         paused.0 = false;
@@ -236,21 +237,16 @@ fn toggle_pause(
         let level = progress.as_deref().map(|p| p.0.level);
         let streak = stats.as_deref().map(|s| s.0.win_streak_current);
         let draw_mode = settings.as_deref().map(|s| s.0.draw_mode);
-        spawn_pause_screen(
-            &mut commands,
-            level,
-            streak,
-            draw_mode,
-            font_res.as_deref(),
-        );
+        spawn_pause_screen(&mut commands, level, streak, draw_mode, font_res.as_deref());
         paused.0 = true;
         // Persist the current game state whenever the player opens the pause
         // overlay so an OS-level kill still leaves a resumable save.
         if let (Some(g), Some(p)) = (game, path)
             && let Some(disk_path) = p.0.as_deref()
-                && let Err(e) = save_game_state_to(disk_path, &g.0) {
-                    warn!("game_state: failed to save on pause: {e}");
-                }
+            && let Err(e) = save_game_state_to(disk_path, &g.0)
+        {
+            warn!("game_state: failed to save on pause: {e}");
+        }
     }
 }
 
@@ -276,16 +272,21 @@ fn handle_pause_draw_buttons(
         return;
     }
     let Some(mut settings) = settings else { return };
-    let new_mode = if pressed_one { DrawMode::DrawOne } else { DrawMode::DrawThree };
+    let new_mode = if pressed_one {
+        DrawMode::DrawOne
+    } else {
+        DrawMode::DrawThree
+    };
     if settings.0.draw_mode == new_mode {
         return;
     }
     settings.0.draw_mode = new_mode;
     if let Some(p) = &path
         && let Some(target) = &p.0
-            && let Err(e) = solitaire_data::save_settings_to(target, &settings.0) {
-                warn!("failed to save settings after draw-mode change: {e}");
-            }
+        && let Err(e) = solitaire_data::save_settings_to(target, &settings.0)
+    {
+        warn!("failed to save settings after draw-mode change: {e}");
+    }
     changed.write(SettingsChangedEvent(settings.0.clone()));
 }
 
@@ -440,7 +441,11 @@ fn close_forfeit_modal(
 /// Query filter for modals that are not part of the pause flow.
 /// Excludes both `PauseScreen` (the pause modal itself) and
 /// `ForfeitConfirmScreen` (spawned from within the pause flow).
-type NonPauseFamilyScrim = (With<ModalScrim>, Without<PauseScreen>, Without<ForfeitConfirmScreen>);
+type NonPauseFamilyScrim = (
+    With<ModalScrim>,
+    Without<PauseScreen>,
+    Without<ForfeitConfirmScreen>,
+);
 
 fn auto_resume_on_overlay(
     mut commands: Commands,
@@ -536,13 +541,23 @@ fn spawn_draw_mode_row(
             ..default()
         })
         .with_children(|row| {
-            row.spawn((
-                Text::new("Draw Mode"),
-                label_font,
-                TextColor(TEXT_PRIMARY),
-            ));
-            spawn_modal_button(row, PauseDrawOneButton, "Draw 1", None, one_variant, font_res);
-            spawn_modal_button(row, PauseDrawThreeButton, "Draw 3", None, three_variant, font_res);
+            row.spawn((Text::new("Draw Mode"), label_font, TextColor(TEXT_PRIMARY)));
+            spawn_modal_button(
+                row,
+                PauseDrawOneButton,
+                "Draw 1",
+                None,
+                one_variant,
+                font_res,
+            );
+            spawn_modal_button(
+                row,
+                PauseDrawThreeButton,
+                "Draw 3",
+                None,
+                three_variant,
+                font_res,
+            );
         });
     parent.spawn((
         Text::new("Takes effect next game"),
@@ -744,7 +759,10 @@ mod tests {
 
         // Set known values.
         app.world_mut().resource_mut::<ProgressResource>().0.level = 7;
-        app.world_mut().resource_mut::<StatsResource>().0.win_streak_current = 3;
+        app.world_mut()
+            .resource_mut::<StatsResource>()
+            .0
+            .win_streak_current = 3;
 
         press_esc(&mut app);
         app.update();
@@ -797,7 +815,10 @@ mod tests {
     fn draw_mode_label_covers_all_variants() {
         for mode in [DrawMode::DrawOne, DrawMode::DrawThree] {
             let label = draw_mode_label(mode);
-            assert!(!label.is_empty(), "draw_mode_label must never return an empty string");
+            assert!(
+                !label.is_empty(),
+                "draw_mode_label must never return an empty string"
+            );
         }
     }
 
@@ -827,19 +848,12 @@ mod tests {
         app.world_mut().resource_mut::<PausedResource>().0 = true;
 
         // Pressing "Draw 3" while DrawOne is active should switch to DrawThree.
-        app.world_mut().spawn((
-            PauseDrawThreeButton,
-            Button,
-            Interaction::Pressed,
-        ));
+        app.world_mut()
+            .spawn((PauseDrawThreeButton, Button, Interaction::Pressed));
 
         app.update();
 
-        let mode = &app
-            .world()
-            .resource::<SettingsResource>()
-            .0
-            .draw_mode;
+        let mode = &app.world().resource::<SettingsResource>().0.draw_mode;
         assert_eq!(
             *mode,
             DrawMode::DrawThree,
@@ -847,19 +861,12 @@ mod tests {
         );
 
         // Pressing "Draw 1" while DrawThree is active should switch back.
-        app.world_mut().spawn((
-            PauseDrawOneButton,
-            Button,
-            Interaction::Pressed,
-        ));
+        app.world_mut()
+            .spawn((PauseDrawOneButton, Button, Interaction::Pressed));
 
         app.update();
 
-        let mode2 = &app
-            .world()
-            .resource::<SettingsResource>()
-            .0
-            .draw_mode;
+        let mode2 = &app.world().resource::<SettingsResource>().0.draw_mode;
         assert_eq!(
             *mode2,
             DrawMode::DrawOne,
@@ -896,8 +903,14 @@ mod tests {
             .query::<&PauseForfeitButton>()
             .iter(app.world())
             .count();
-        assert_eq!(resume_count, 1, "Resume button must be present on the pause modal");
-        assert_eq!(forfeit_count, 1, "Forfeit button must be present on the pause modal");
+        assert_eq!(
+            resume_count, 1,
+            "Resume button must be present on the pause modal"
+        );
+        assert_eq!(
+            forfeit_count, 1,
+            "Forfeit button must be present on the pause modal"
+        );
     }
 
     /// Clicking the Resume button (via Pressed interaction) closes the
@@ -911,20 +924,29 @@ mod tests {
 
         // Mark the Resume button as Pressed.
         let resume_entity = {
-            let mut q = app.world_mut().query_filtered::<Entity, With<PauseResumeButton>>();
-            q.iter(app.world()).next().expect("Resume button must exist")
+            let mut q = app
+                .world_mut()
+                .query_filtered::<Entity, With<PauseResumeButton>>();
+            q.iter(app.world())
+                .next()
+                .expect("Resume button must exist")
         };
         app.world_mut()
             .entity_mut(resume_entity)
             .insert(Interaction::Pressed);
 
         // Clear keys so the simulated "click" isn't competing with a real Esc press.
-        app.world_mut().resource_mut::<ButtonInput<KeyCode>>().clear();
+        app.world_mut()
+            .resource_mut::<ButtonInput<KeyCode>>()
+            .clear();
         app.update();
         // One more frame so the resulting PauseRequestEvent is consumed by toggle_pause.
         app.update();
 
-        assert!(!app.world().resource::<PausedResource>().0, "Resume must clear PausedResource");
+        assert!(
+            !app.world().resource::<PausedResource>().0,
+            "Resume must clear PausedResource"
+        );
         assert_eq!(
             app.world_mut()
                 .query::<&PauseScreen>()
@@ -1137,7 +1159,10 @@ mod tests {
         app.update();
         assert!(app.world().resource::<PausedResource>().0);
         assert_eq!(
-            app.world_mut().query::<&PauseScreen>().iter(app.world()).count(),
+            app.world_mut()
+                .query::<&PauseScreen>()
+                .iter(app.world())
+                .count(),
             1
         );
 
@@ -1150,7 +1175,10 @@ mod tests {
             "auto_resume_on_overlay must clear PausedResource when another modal opens"
         );
         assert_eq!(
-            app.world_mut().query::<&PauseScreen>().iter(app.world()).count(),
+            app.world_mut()
+                .query::<&PauseScreen>()
+                .iter(app.world())
+                .count(),
             0,
             "auto_resume_on_overlay must despawn PauseScreen when another modal opens"
         );

solitaire_engine/src/pending_hint.rs

@@ -25,10 +25,10 @@
 //! old state would be confusing.
 
 use bevy::prelude::*;
-use bevy::tasks::{futures_lite::future, AsyncComputeTaskPool, Task};
+use bevy::tasks::{AsyncComputeTaskPool, Task, futures_lite::future};
 use solitaire_core::game_state::GameState;
 use solitaire_core::pile::PileType;
-use solitaire_core::solver::{try_solve_from_state, SolverConfig, SolverResult};
+use solitaire_core::solver::{SolverConfig, SolverResult, try_solve_from_state};
 
 use crate::card_plugin::CardEntity;
 use crate::events::{HintVisualEvent, InfoToastEvent, StateChangedEvent};
@@ -101,10 +101,7 @@ struct HintTask {
 enum HintTaskOutput {
     /// Solver verdict was `Winnable`; here is the first move on the
     /// solution path.
-    SolverMove {
-        from: PileType,
-        to: PileType,
-    },
+    SolverMove { from: PileType, to: PileType },
     /// Solver was `Unwinnable` or `Inconclusive`. The poll system
     /// runs the legacy heuristic against the live `GameState` so the
     /// H key always produces feedback while any legal move exists.
@@ -162,15 +159,13 @@ pub fn poll_pending_hint_task(
 
     let (from, to) = match output {
         HintTaskOutput::SolverMove { from, to } => (from, to),
-        HintTaskOutput::NeedsHeuristic => {
-            match find_heuristic_hint(&g.0, &mut hint_cycle) {
-                Some(pair) => pair,
-                None => {
-                    info_toast.write(InfoToastEvent("No hints available".to_string()));
-                    return;
-                }
+        HintTaskOutput::NeedsHeuristic => match find_heuristic_hint(&g.0, &mut hint_cycle) {
+            Some(pair) => pair,
+            None => {
+                info_toast.write(InfoToastEvent("No hints available".to_string()));
+                return;
             }
-        }
+        },
     };
     emit_hint_visuals(
         &g.0,
@@ -209,11 +204,7 @@ mod tests {
         // poll fire before the drop.
         app.add_systems(
             Update,
-            (
-                drop_pending_hint_on_state_change,
-                poll_pending_hint_task,
-            )
-                .chain(),
+            (drop_pending_hint_on_state_change, poll_pending_hint_task).chain(),
         );
         app
     }
@@ -241,9 +232,18 @@ mod tests {
         game.piles.get_mut(&PileType::Waste).unwrap().cards.clear();
         let suits = [Suit::Clubs, Suit::Diamonds, Suit::Hearts, Suit::Spades];
         let ranks_below_king = [
-            Rank::Ace, Rank::Two, Rank::Three, Rank::Four, Rank::Five,
-            Rank::Six, Rank::Seven, Rank::Eight, Rank::Nine, Rank::Ten,
-            Rank::Jack, Rank::Queen,
+            Rank::Ace,
+            Rank::Two,
+            Rank::Three,
+            Rank::Four,
+            Rank::Five,
+            Rank::Six,
+            Rank::Seven,
+            Rank::Eight,
+            Rank::Nine,
+            Rank::Ten,
+            Rank::Jack,
+            Rank::Queen,
         ];
         for (slot, suit) in suits.iter().enumerate() {
             let pile = game
@@ -304,7 +304,8 @@ mod tests {
         let mut cursor = messages.get_cursor();
         let collected: Vec<HintVisualEvent> = cursor.read(messages).cloned().collect();
         assert_eq!(
-            collected.len(), 1,
+            collected.len(),
+            1,
             "exactly one HintVisualEvent must fire when the solver returns Winnable",
         );
         assert!(
@@ -395,7 +396,8 @@ mod tests {
         let mut cursor = messages.get_cursor();
         let collected: Vec<HintVisualEvent> = cursor.read(messages).cloned().collect();
         assert_eq!(
-            collected.len(), 1,
+            collected.len(),
+            1,
             "cancel-on-replace: only the surviving task's result emits a visual",
         );
     }

solitaire_engine/src/play_by_seed_plugin.rs

@@ -22,17 +22,17 @@
 
 use bevy::input::ButtonInput;
 use bevy::prelude::*;
-use bevy::tasks::{futures_lite::future, AsyncComputeTaskPool, Task};
+use bevy::tasks::{AsyncComputeTaskPool, Task, futures_lite::future};
 use solitaire_core::game_state::DrawMode;
-use solitaire_core::solver::{try_solve, SolverConfig, SolverResult};
+use solitaire_core::solver::{SolverConfig, SolverResult, try_solve};
 
 use crate::events::{NewGameRequestEvent, StartPlayBySeedRequestEvent};
 use crate::font_plugin::FontResource;
 use crate::game_plugin::GameMutation;
 use crate::settings_plugin::SettingsResource;
 use crate::ui_modal::{
-    spawn_modal, spawn_modal_actions, spawn_modal_body_text, spawn_modal_button, spawn_modal_header,
-    ButtonVariant, ScrimDismissible,
+    ButtonVariant, ScrimDismissible, spawn_modal, spawn_modal_actions, spawn_modal_body_text,
+    spawn_modal_button, spawn_modal_header,
 };
 use crate::ui_theme::{
     ACCENT_PRIMARY, BG_ELEVATED_PRESSED, BORDER_SUBTLE, HighContrastBorder, RADIUS_MD,
@@ -341,8 +341,7 @@ fn tick_debounce_and_spawn_solver_task(
         .as_ref()
         .map_or(DrawMode::DrawOne, |s| s.0.draw_mode);
     let cfg = SolverConfig::default();
-    let task = AsyncComputeTaskPool::get()
-        .spawn(async move { try_solve(seed, draw_mode, &cfg) });
+    let task = AsyncComputeTaskPool::get().spawn(async move { try_solve(seed, draw_mode, &cfg) });
 
     pending.seed = Some(seed);
     pending.handle = Some(task);
@@ -407,7 +406,9 @@ fn handle_confirm(
     }
 
     let Ok(buf) = buffers.single() else { return };
-    let Ok(seed) = buf.text.parse::<u64>() else { return };
+    let Ok(seed) = buf.text.parse::<u64>() else {
+        return;
+    };
 
     new_game.write(NewGameRequestEvent {
         seed: Some(seed),
@@ -470,8 +471,7 @@ mod tests {
     }
 
     fn open_dialog(app: &mut App) {
-        app.world_mut()
-            .write_message(StartPlayBySeedRequestEvent);
+        app.world_mut().write_message(StartPlayBySeedRequestEvent);
         app.update();
     }
 
@@ -547,7 +547,10 @@ mod tests {
 
         let msgs = app.world().resource::<Messages<NewGameRequestEvent>>();
         let mut cursor = msgs.get_cursor();
-        assert!(cursor.read(msgs).next().is_none(), "no NewGameRequestEvent when buffer empty");
+        assert!(
+            cursor.read(msgs).next().is_none(),
+            "no NewGameRequestEvent when buffer empty"
+        );
         // Dialog should still be open.
         assert!(dialog_present(&mut app));
     }
@@ -607,7 +610,10 @@ mod tests {
         }
 
         let pending = app.world().resource::<PendingVerification>();
-        assert!(pending.handle.is_some(), "solver task should have been spawned after debounce");
+        assert!(
+            pending.handle.is_some(),
+            "solver task should have been spawned after debounce"
+        );
         assert_eq!(pending.seed, Some(42));
     }
 
@@ -623,11 +629,21 @@ mod tests {
         for _ in 0..DEBOUNCE_FRAMES {
             app.update();
         }
-        assert!(app.world().resource::<PendingVerification>().handle.is_some());
+        assert!(
+            app.world()
+                .resource::<PendingVerification>()
+                .handle
+                .is_some()
+        );
 
         // New keypress should cancel the in-flight task.
         press_key(&mut app, KeyCode::Digit3);
-        assert!(app.world().resource::<PendingVerification>().handle.is_none());
+        assert!(
+            app.world()
+                .resource::<PendingVerification>()
+                .handle
+                .is_none()
+        );
         assert_eq!(app.world().resource::<PendingVerification>().seed, None);
     }
 
@@ -649,7 +665,11 @@ mod tests {
 
         // Poll until the solver task resolves (cap at 15 s wall-clock).
         let deadline = Instant::now() + std::time::Duration::from_secs(15);
-        while app.world().resource::<PendingVerification>().handle.is_some()
+        while app
+            .world()
+            .resource::<PendingVerification>()
+            .handle
+            .is_some()
             && Instant::now() < deadline
         {
             app.update();
@@ -664,7 +684,13 @@ mod tests {
             .next()
             .map(|(t, _)| t.0.clone())
             .unwrap_or_default();
-        assert_ne!(badge_text, "Verifying\u{2026}", "badge should have resolved to a verdict");
-        assert_ne!(badge_text, "Type a number", "badge should show verdict, not idle state");
+        assert_ne!(
+            badge_text, "Verifying\u{2026}",
+            "badge should have resolved to a verdict"
+        );
+        assert_ne!(
+            badge_text, "Type a number",
+            "badge should show verdict, not idle state"
+        );
     }
 }

solitaire_engine/src/profile_plugin.rs

@@ -4,11 +4,11 @@
 //! summary in a single scrollable panel. Spawned on the first `P` keypress and
 //! despawned on the second.
 
-use bevy::input::mouse::{MouseScrollUnit, MouseWheel};
 use bevy::input::ButtonInput;
+use bevy::input::mouse::{MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
 use chrono::{Duration, Local, NaiveDate};
-use solitaire_core::achievement::{achievement_by_id, ALL_ACHIEVEMENTS};
+use solitaire_core::achievement::{ALL_ACHIEVEMENTS, achievement_by_id};
 use solitaire_data::SyncBackend;
 
 use crate::achievement_plugin::AchievementsResource;
@@ -18,10 +18,10 @@ use crate::font_plugin::FontResource;
 use crate::progress_plugin::ProgressResource;
 use crate::resources::{SyncStatus, SyncStatusResource};
 use crate::settings_plugin::SettingsResource;
-use crate::stats_plugin::{format_fastest_win, format_win_rate, StatsResource};
+use crate::stats_plugin::{StatsResource, format_fastest_win, format_win_rate};
 use crate::ui_modal::{
-    spawn_modal, spawn_modal_actions, spawn_modal_button, spawn_modal_header, ButtonVariant,
-    ScrimDismissible,
+    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,
@@ -31,8 +31,8 @@ use crate::ui_theme::{
 /// Number of days surfaced in the daily-challenge calendar row.
 ///
 /// 14 = trailing two weeks ending today. At ~12 px per dot with a 6 px gap
-/// the row is ~246 px wide — well inside the 360 px minimum modal width on
-/// the smallest supported window (800 px).
+/// the row is ~246 px wide — comfortably inside the responsive modal card
+/// even on narrow phone layouts.
 const CALENDAR_DAYS: usize = 14;
 
 /// Diameter of each calendar dot, in pixels.
@@ -146,6 +146,7 @@ fn toggle_profile_screen(
     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);
@@ -161,6 +162,9 @@ fn toggle_profile_screen(
     if !want_open && !want_close {
         return;
     }
+    if want_open && !scrims.is_empty() {
+        return;
+    }
     if let Ok(entity) = screens.single() {
         commands.entity(entity).despawn();
     } else {
@@ -257,7 +261,10 @@ fn spawn_profile_screen(
                     flex_direction: FlexDirection::Row,
                     align_items: AlignItems::Center,
                     column_gap: Val::Px(10.0),
-                    margin: UiRect { bottom: Val::Px(4.0), ..default() },
+                    margin: UiRect {
+                        bottom: Val::Px(4.0),
+                        ..default()
+                    },
                     ..default()
                 })
                 .with_children(|row| {
@@ -275,7 +282,13 @@ fn spawn_profile_screen(
                         ));
                     } else {
                         // Initials fallback: coloured disc with the first letter.
-                        let initial = username.chars().next().unwrap_or('?').to_uppercase().next().unwrap_or('?');
+                        let initial = username
+                            .chars()
+                            .next()
+                            .unwrap_or('?')
+                            .to_uppercase()
+                            .next()
+                            .unwrap_or('?');
                         row.spawn((
                             Node {
                                 width: Val::Px(SIZE),
@@ -335,7 +348,10 @@ fn spawn_profile_screen(
                 let pct = if xp_span == 0 {
                     100u64
                 } else {
-                    xp_done.saturating_mul(100).checked_div(xp_span).unwrap_or(100)
+                    xp_done
+                        .saturating_mul(100)
+                        .checked_div(xp_span)
+                        .unwrap_or(100)
                 };
                 body.spawn((
                     Text::new(format!(
@@ -378,7 +394,10 @@ fn spawn_profile_screen(
                 let records = &ar.0;
                 let unlocked_count = records.iter().filter(|r| r.unlocked).count();
                 body.spawn((
-                    Text::new(format!("{unlocked_count} / {} unlocked", ALL_ACHIEVEMENTS.len())),
+                    Text::new(format!(
+                        "{unlocked_count} / {} unlocked",
+                        ALL_ACHIEVEMENTS.len()
+                    )),
                     font_row.clone(),
                     TextColor(ACCENT_PRIMARY),
                 ));
@@ -533,7 +552,11 @@ fn spawn_daily_calendar(
                 // accent border) regardless of completion; past days use a
                 // subtle border so the row reads as a row of pills, not a
                 // strip of bare squares.
-                let border_color = if is_today { ACCENT_PRIMARY } else { BORDER_STRONG };
+                let border_color = if is_today {
+                    ACCENT_PRIMARY
+                } else {
+                    BORDER_STRONG
+                };
                 let border_width = if is_today { 2.0 } else { 0.0 };
                 row.spawn((
                     DailyCalendarDot {
@@ -569,9 +592,7 @@ fn calendar_dot_color(completed: bool) -> Color {
 fn sync_info(backend: &SyncBackend) -> (&'static str, String) {
     match backend {
         SyncBackend::Local => ("Local", "—".to_string()),
-        SyncBackend::SolitaireServer { username, .. } => {
-            ("Solitaire Server", username.clone())
-        }
+        SyncBackend::SolitaireServer { username, .. } => ("Solitaire Server", username.clone()),
     }
 }
 
@@ -641,6 +662,25 @@ mod tests {
         );
     }
 
+    #[test]
+    fn pressing_p_does_not_stack_profile_over_existing_modal_scrim() {
+        let mut app = headless_app();
+        app.world_mut().spawn(ModalScrim);
+        app.world_mut()
+            .resource_mut::<ButtonInput<KeyCode>>()
+            .press(KeyCode::KeyP);
+        app.update();
+
+        assert_eq!(
+            app.world_mut()
+                .query::<&ProfileScreen>()
+                .iter(app.world())
+                .count(),
+            0,
+            "Profile should not open when another modal scrim already exists"
+        );
+    }
+
     #[test]
     fn profile_modal_body_is_scrollable() {
         let mut app = headless_app();

solitaire_engine/src/progress_plugin.rs

@@ -9,7 +9,7 @@ use std::path::PathBuf;
 
 use bevy::prelude::*;
 use solitaire_data::{
-    load_progress_from, progress_file_path, save_progress_to, xp_for_win, PlayerProgress,
+    PlayerProgress, load_progress_from, progress_file_path, save_progress_to, xp_for_win,
 };
 
 use crate::events::{GameWonEvent, XpAwardedEvent};
@@ -74,9 +74,7 @@ impl Plugin for ProgressPlugin {
             .add_message::<GameWonEvent>()
             .add_systems(
                 Update,
-                award_xp_on_win
-                    .after(GameMutation)
-                    .in_set(ProgressUpdate),
+                award_xp_on_win.after(GameMutation).in_set(ProgressUpdate),
             );
     }
 }
@@ -102,9 +100,10 @@ fn award_xp_on_win(
             });
         }
         if let Some(target) = &path.0
-            && let Err(e) = save_progress_to(target, &progress.0) {
-                warn!("failed to save progress: {e}");
-            }
+            && let Err(e) = save_progress_to(target, &progress.0)
+        {
+            warn!("failed to save progress: {e}");
+        }
     }
 }
 
@@ -183,7 +182,10 @@ mod tests {
     fn crossing_500_xp_fires_levelup_event() {
         let mut app = headless_app();
         // Pre-load 480 XP so a 75-XP win pushes us over the 500 boundary.
-        app.world_mut().resource_mut::<ProgressResource>().0.total_xp = 480;
+        app.world_mut()
+            .resource_mut::<ProgressResource>()
+            .0
+            .total_xp = 480;
 
         app.world_mut().write_message(GameWonEvent {
             score: 500,
@@ -233,7 +235,10 @@ mod tests {
     #[test]
     fn levelup_event_total_xp_matches_progress_resource() {
         let mut app = headless_app();
-        app.world_mut().resource_mut::<ProgressResource>().0.total_xp = 480;
+        app.world_mut()
+            .resource_mut::<ProgressResource>()
+            .0
+            .total_xp = 480;
 
         app.world_mut().write_message(GameWonEvent {
             score: 500,
@@ -255,13 +260,11 @@ mod tests {
         // score=0 in the event (Zen keeps score at 0), time=300 (no speed bonus),
         // undo_count=0 so no-undo bonus applies: expected 50+25=75.
         let mut app = headless_app();
-        app.world_mut()
-            .resource_mut::<GameStateResource>()
-            .0
-            .mode = solitaire_core::game_state::GameMode::Zen;
+        app.world_mut().resource_mut::<GameStateResource>().0.mode =
+            solitaire_core::game_state::GameMode::Zen;
 
         app.world_mut().write_message(GameWonEvent {
-            score: 0,        // Zen mode keeps score at 0
+            score: 0, // Zen mode keeps score at 0
             time_seconds: 300,
         });
         app.update();

solitaire_engine/src/radial_menu.rs

@@ -42,8 +42,8 @@
 //! real `PrimaryWindow` / camera, since `MinimalPlugins` provides
 //! neither.
 
-use bevy::input::touch::Touches;
 use bevy::input::ButtonInput;
+use bevy::input::touch::Touches;
 use bevy::math::Vec2;
 use bevy::prelude::*;
 use bevy::window::PrimaryWindow;
@@ -52,13 +52,15 @@ use solitaire_core::game_state::GameState;
 use solitaire_core::pile::PileType;
 use solitaire_core::rules::{can_place_on_foundation, can_place_on_tableau};
 
-use crate::card_plugin::{TABLEAU_FACEDOWN_FAN_FRAC, TABLEAU_FAN_FRAC};
+use crate::card_plugin::TABLEAU_FACEDOWN_FAN_FRAC;
 use crate::events::MoveRequestEvent;
-use crate::layout::{Layout, LayoutResource};
+use crate::layout::{Layout, LayoutResource, TABLEAU_FAN_FRAC};
 use crate::pause_plugin::PausedResource;
 use crate::resources::{DragState, GameStateResource};
 use crate::settings_plugin::SettingsResource;
-use crate::ui_theme::{ACCENT_PRIMARY, BORDER_STRONG, BORDER_SUBTLE, BORDER_SUBTLE_HC, STATE_SUCCESS};
+use crate::ui_theme::{
+    ACCENT_PRIMARY, BORDER_STRONG, BORDER_SUBTLE, BORDER_SUBTLE_HC, STATE_SUCCESS,
+};
 
 /// Seconds a finger must be held on a face-up card (without crossing the
 /// drag threshold) before the radial menu opens. Matches Android's long-press
@@ -219,7 +221,10 @@ pub fn radial_anchor_for_index(centre: Vec2, count: usize, index: usize, radius:
     // index 0 sits at 12 o'clock and increasing indices sweep right.
     let frac = (index as f32) / (count as f32);
     let angle = std::f32::consts::TAU * frac;
-    Vec2::new(centre.x + radius * angle.sin(), centre.y + radius * angle.cos())
+    Vec2::new(
+        centre.x + radius * angle.sin(),
+        centre.y + radius * angle.cos(),
+    )
 }
 
 /// Returns `(hit?, index)` — whether `cursor` falls within any icon's
@@ -363,7 +368,12 @@ fn build_radial_destinations(centre: Vec2, dests: Vec<PileType>) -> Vec<(PileTyp
     dests
         .into_iter()
         .enumerate()
-        .map(|(i, d)| (d, radial_anchor_for_index(centre, count, i, RADIAL_RADIUS_PX)))
+        .map(|(i, d)| {
+            (
+                d,
+                radial_anchor_for_index(centre, count, i, RADIAL_RADIUS_PX),
+            )
+        })
         .collect()
 }
 
@@ -493,7 +503,9 @@ fn radial_open_on_long_press(
     let Some(touch) = touches.iter().find(|t| t.id() == active_id) else {
         return;
     };
-    let Some((camera, cam_xf)) = cameras.single().ok() else { return };
+    let Some((camera, cam_xf)) = cameras.single().ok() else {
+        return;
+    };
     let Some(world) = camera.viewport_to_world_2d(cam_xf, touch.position()).ok() else {
         return;
     };
@@ -668,7 +680,11 @@ fn radial_redraw_overlay(
     for (i, (_pile, anchor)) in legal_destinations.iter().enumerate() {
         let focused = *hovered_index == Some(i);
         let scale = if focused { RADIAL_HOVER_SCALE } else { 1.0 };
-        let fill = if focused { STATE_SUCCESS } else { ACCENT_PRIMARY };
+        let fill = if focused {
+            STATE_SUCCESS
+        } else {
+            ACCENT_PRIMARY
+        };
         let outline = radial_rim_outline(focused, high_contrast);
 
         commands
@@ -758,10 +774,18 @@ mod tests {
         g.piles.get_mut(&PileType::Stock).unwrap().cards.clear();
         g.piles.get_mut(&PileType::Waste).unwrap().cards.clear();
         for slot in 0..4_u8 {
-            g.piles.get_mut(&PileType::Foundation(slot)).unwrap().cards.clear();
+            g.piles
+                .get_mut(&PileType::Foundation(slot))
+                .unwrap()
+                .cards
+                .clear();
         }
         for i in 0..7_usize {
-            g.piles.get_mut(&PileType::Tableau(i)).unwrap().cards.clear();
+            g.piles
+                .get_mut(&PileType::Tableau(i))
+                .unwrap()
+                .cards
+                .clear();
         }
         // Ace of Clubs on Tableau(0).
         g.piles
@@ -784,10 +808,18 @@ mod tests {
         g.piles.get_mut(&PileType::Stock).unwrap().cards.clear();
         g.piles.get_mut(&PileType::Waste).unwrap().cards.clear();
         for slot in 0..4_u8 {
-            g.piles.get_mut(&PileType::Foundation(slot)).unwrap().cards.clear();
+            g.piles
+                .get_mut(&PileType::Foundation(slot))
+                .unwrap()
+                .cards
+                .clear();
         }
         for i in 0..7_usize {
-            g.piles.get_mut(&PileType::Tableau(i)).unwrap().cards.clear();
+            g.piles
+                .get_mut(&PileType::Tableau(i))
+                .unwrap()
+                .cards
+                .clear();
         }
         g.piles
             .get_mut(&PileType::Tableau(0))
@@ -804,7 +836,12 @@ mod tests {
 
     fn install_resources(app: &mut App, state: GameState, layout_window: Vec2, cursor: Vec2) {
         app.insert_resource(GameStateResource(state));
-        app.insert_resource(LayoutResource(compute_layout(layout_window, 0.0, 0.0, true)));
+        app.insert_resource(LayoutResource(compute_layout(
+            layout_window,
+            0.0,
+            0.0,
+            true,
+        )));
         app.world_mut().resource_mut::<RadialCursorOverride>().0 = Some(cursor);
     }
 
@@ -867,13 +904,19 @@ mod tests {
     fn radial_hovered_index_inside_box_returns_index() {
         let anchors = vec![Vec2::new(100.0, 0.0), Vec2::new(0.0, 100.0)];
         // Cursor squarely inside icon 1's box.
-        assert_eq!(radial_hovered_index(Vec2::new(0.0, 100.0), &anchors), Some(1));
+        assert_eq!(
+            radial_hovered_index(Vec2::new(0.0, 100.0), &anchors),
+            Some(1)
+        );
     }
 
     #[test]
     fn radial_hovered_index_outside_returns_none() {
         let anchors = vec![Vec2::new(100.0, 0.0), Vec2::new(0.0, 100.0)];
-        assert_eq!(radial_hovered_index(Vec2::new(500.0, 500.0), &anchors), None);
+        assert_eq!(
+            radial_hovered_index(Vec2::new(500.0, 500.0), &anchors),
+            None
+        );
     }
 
     #[test]
@@ -888,7 +931,10 @@ mod tests {
         let dests = legal_destinations_for_card(&card, &PileType::Tableau(0), &g);
         // Ace can be placed on every empty foundation. We only need
         // the count to be ≥ 1 and the source pile to be excluded.
-        assert!(!dests.is_empty(), "Ace must have at least one legal destination");
+        assert!(
+            !dests.is_empty(),
+            "Ace must have at least one legal destination"
+        );
         assert!(!dests.contains(&PileType::Tableau(0)));
     }
 
@@ -921,7 +967,10 @@ mod tests {
 
         install_resources(&mut app, ace_only_state(), layout_window, ace_pos);
         // Initial state — Idle.
-        assert_eq!(*app.world().resource::<RightClickRadialState>(), RightClickRadialState::Idle);
+        assert_eq!(
+            *app.world().resource::<RightClickRadialState>(),
+            RightClickRadialState::Idle
+        );
 
         press(&mut app, MouseButton::Right);
         app.update();
@@ -939,9 +988,11 @@ mod tests {
                 assert_eq!(count, 1);
                 assert_eq!(cards, vec![100]);
                 assert!(!legal_destinations.is_empty());
-                assert!(legal_destinations
-                    .iter()
-                    .any(|(p, _)| matches!(p, PileType::Foundation(_))));
+                assert!(
+                    legal_destinations
+                        .iter()
+                        .any(|(p, _)| matches!(p, PileType::Foundation(_)))
+                );
             }
             other => panic!("expected Active, got {other:?}"),
         }
@@ -962,7 +1013,9 @@ mod tests {
 
         // Capture the destination chosen — pull anchor[0] from the state.
         let (dest_pile, anchor) = match app.world().resource::<RightClickRadialState>() {
-            RightClickRadialState::Active { legal_destinations, .. } => legal_destinations[0].clone(),
+            RightClickRadialState::Active {
+                legal_destinations, ..
+            } => legal_destinations[0].clone(),
             _ => panic!("expected Active"),
         };
 
@@ -983,7 +1036,10 @@ mod tests {
         assert_eq!(evt.to, dest_pile);
         assert_eq!(evt.count, 1);
         // State must return to Idle.
-        assert_eq!(*app.world().resource::<RightClickRadialState>(), RightClickRadialState::Idle);
+        assert_eq!(
+            *app.world().resource::<RightClickRadialState>(),
+            RightClickRadialState::Idle
+        );
     }
 
     /// Releasing the right button far from any icon must clear state
@@ -1001,7 +1057,8 @@ mod tests {
         assert!(app.world().resource::<RightClickRadialState>().is_active());
 
         // Move cursor far away — well outside every icon's hit-box.
-        app.world_mut().resource_mut::<RadialCursorOverride>().0 = Some(Vec2::new(10_000.0, 10_000.0));
+        app.world_mut().resource_mut::<RadialCursorOverride>().0 =
+            Some(Vec2::new(10_000.0, 10_000.0));
         app.update();
 
         clear_buttons(&mut app);
@@ -1010,7 +1067,10 @@ mod tests {
 
         let events = collect_move_events(&mut app);
         assert!(events.is_empty(), "no MoveRequestEvent on outside-release");
-        assert_eq!(*app.world().resource::<RightClickRadialState>(), RightClickRadialState::Idle);
+        assert_eq!(
+            *app.world().resource::<RightClickRadialState>(),
+            RightClickRadialState::Idle
+        );
     }
 
     /// Pressing Escape while the radial is active must cancel cleanly,
@@ -1034,7 +1094,10 @@ mod tests {
 
         let events = collect_move_events(&mut app);
         assert!(events.is_empty(), "no MoveRequestEvent on Escape cancel");
-        assert_eq!(*app.world().resource::<RightClickRadialState>(), RightClickRadialState::Idle);
+        assert_eq!(
+            *app.world().resource::<RightClickRadialState>(),
+            RightClickRadialState::Idle
+        );
     }
 
     /// Right-clicking on a face-down card must NOT open the radial.

solitaire_engine/src/replay_overlay.rs

@@ -26,25 +26,25 @@
 use bevy::prelude::*;
 use chrono::Datelike;
 
+use crate::events::{DrawRequestEvent, MoveRequestEvent, StateChangedEvent, UndoRequestEvent};
 use crate::font_plugin::FontResource;
 use crate::layout::LayoutResource;
 use crate::platform::SHOW_KEYBOARD_ACCELERATORS;
-use crate::events::{DrawRequestEvent, MoveRequestEvent, StateChangedEvent, UndoRequestEvent};
 use crate::replay_playback::{
-    step_backwards_replay_playback, step_replay_playback, stop_replay_playback,
-    toggle_pause_replay_playback, ReplayPlaybackState,
+    ReplayPlaybackState, step_backwards_replay_playback, step_replay_playback,
+    stop_replay_playback, toggle_pause_replay_playback,
 };
-use solitaire_core::card::{Card, Rank, Suit};
-use solitaire_core::game_state::GameState;
-use solitaire_core::pile::PileType;
-use solitaire_data::ReplayMove;
 use crate::resources::GameStateResource;
-use crate::ui_modal::{spawn_modal_button, ButtonVariant};
+use crate::ui_modal::{ButtonVariant, spawn_modal_button};
 use crate::ui_theme::{
     ACCENT_PRIMARY, BG_ELEVATED_HI, BORDER_SUBTLE, HighContrastBackground, HighContrastBorder,
     STATE_SUCCESS, STATE_SUCCESS_HC, TEXT_PRIMARY, TEXT_PRIMARY_HC, TEXT_SECONDARY, TYPE_BODY,
     TYPE_CAPTION, TYPE_HEADLINE, VAL_SPACE_1, VAL_SPACE_2, VAL_SPACE_4, Z_DROP_OVERLAY,
 };
+use solitaire_core::card::{Card, Rank, Suit};
+use solitaire_core::game_state::GameState;
+use solitaire_core::pile::PileType;
+use solitaire_data::ReplayMove;
 
 // ---------------------------------------------------------------------------
 // Z-index — see `ui_theme::Z_MODAL_SCRIM` (200) for the next layer above.
@@ -866,9 +866,7 @@ fn spawn_overlay(
                     ..default()
                 })
                 .with_children(|row| {
-                    for (i, (label, pct)) in
-                        labels.iter().zip(positions.iter()).enumerate()
-                    {
+                    for (i, (label, pct)) in labels.iter().zip(positions.iter()).enumerate() {
                         // Endpoints flush to the row's edges; middle
                         // three labels use the `translateX(-50%)`
                         // pattern for Bevy 0.18 UI: a fixed-width
@@ -1080,10 +1078,7 @@ fn spawn_overlay(
             for offset in (1..=MOVE_LOG_PREV_ROWS as u8).rev() {
                 panel.spawn((
                     ReplayOverlayMoveLogPrevRow { offset },
-                    Text::new(format_kth_recent_row(
-                        state,
-                        offset as usize + 1,
-                    )),
+                    Text::new(format_kth_recent_row(state, offset as usize + 1)),
                     TextFont {
                         font: font_handle_for_move_log.clone(),
                         font_size: TYPE_BODY,
@@ -1574,7 +1569,11 @@ fn format_move_body(m: &ReplayMove) -> String {
 fn format_move_log_header(state: &ReplayPlaybackState) -> String {
     match state {
         ReplayPlaybackState::Playing { replay, cursor, .. } => {
-            format!("\u{258C} MOVE LOG \u{00B7} {}/{}", cursor, replay.moves.len())
+            format!(
+                "\u{258C} MOVE LOG \u{00B7} {}/{}",
+                cursor,
+                replay.moves.len()
+            )
         }
         ReplayPlaybackState::Completed => "\u{258C} MOVE LOG \u{00B7} COMPLETE".to_string(),
         ReplayPlaybackState::Inactive => String::new(),
@@ -1661,19 +1660,19 @@ fn format_active_move_row(state: &ReplayPlaybackState) -> String {
 /// follows and disambiguates from an ambiguous "T".
 fn format_rank_short(rank: Rank) -> &'static str {
     match rank {
-        Rank::Ace   => "A",
-        Rank::Two   => "2",
+        Rank::Ace => "A",
+        Rank::Two => "2",
         Rank::Three => "3",
-        Rank::Four  => "4",
-        Rank::Five  => "5",
-        Rank::Six   => "6",
+        Rank::Four => "4",
+        Rank::Five => "5",
+        Rank::Six => "6",
         Rank::Seven => "7",
         Rank::Eight => "8",
-        Rank::Nine  => "9",
-        Rank::Ten   => "T",
-        Rank::Jack  => "J",
+        Rank::Nine => "9",
+        Rank::Ten => "T",
+        Rank::Jack => "J",
         Rank::Queen => "Q",
-        Rank::King  => "K",
+        Rank::King => "K",
     }
 }
 
@@ -1682,10 +1681,10 @@ fn format_rank_short(rank: Rank) -> &'static str {
 /// the bundled FiraMono on Android (verified on Pixel 7 / API 34).
 fn format_suit_glyph(suit: Suit) -> &'static str {
     match suit {
-        Suit::Spades   => "\u{2660}", // ♠
-        Suit::Hearts   => "\u{2665}", // ♥
+        Suit::Spades => "\u{2660}",   // ♠
+        Suit::Hearts => "\u{2665}",   // ♥
         Suit::Diamonds => "\u{2666}", // ♦
-        Suit::Clubs    => "\u{2663}", // ♣
+        Suit::Clubs => "\u{2663}",    // ♣
     }
 }
 
@@ -1694,7 +1693,7 @@ fn format_suit_glyph(suit: Suit) -> &'static str {
 fn format_card_short(card: Option<&Card>) -> String {
     match card {
         Some(c) => format!("{}{}", format_rank_short(c.rank), format_suit_glyph(c.suit)),
-        None    => "--".to_string(),
+        None => "--".to_string(),
     }
 }
 
@@ -1704,7 +1703,8 @@ fn format_card_short(card: Option<&Card>) -> String {
 /// (matching the visual left-to-right order on screen).
 fn format_foundations_row(game: &GameState) -> String {
     let slots: [String; 4] = std::array::from_fn(|i| {
-        let top = game.piles
+        let top = game
+            .piles
             .get(&PileType::Foundation(i as u8))
             .and_then(|p| p.cards.last());
         format_card_short(top)
@@ -1716,11 +1716,13 @@ fn format_foundations_row(game: &GameState) -> String {
 /// Renders as `STK:N WST:X♠` where N is the stock card count and
 /// X♠ is the top waste card (or `--` when the waste pile is empty).
 fn format_stock_waste_row(game: &GameState) -> String {
-    let stock_count = game.piles
+    let stock_count = game
+        .piles
         .get(&PileType::Stock)
         .map(|p| p.cards.len())
         .unwrap_or(0);
-    let waste_top = game.piles
+    let waste_top = game
+        .piles
         .get(&PileType::Waste)
         .and_then(|p| p.cards.last());
     format!("STK:{} WST:{}", stock_count, format_card_short(waste_top))
@@ -2023,7 +2025,8 @@ mod tests {
     /// they can drive every state transition deterministically.
     fn headless_app() -> App {
         let mut app = App::new();
-        app.add_plugins(MinimalPlugins).add_plugins(ReplayOverlayPlugin);
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(ReplayOverlayPlugin);
         app.init_resource::<ReplayPlaybackState>();
         app
     }
@@ -2619,13 +2622,11 @@ mod tests {
             .next()
             .expect("WIN MOVE marker must carry HighContrastBackground");
         assert_eq!(
-            marker.default_color,
-            STATE_SUCCESS,
+            marker.default_color, STATE_SUCCESS,
             "default colour must be STATE_SUCCESS"
         );
         assert_eq!(
-            marker.hc_color,
-            STATE_SUCCESS_HC,
+            marker.hc_color, STATE_SUCCESS_HC,
             "HC colour must be STATE_SUCCESS_HC (brighter lime, not gray)"
         );
     }
@@ -2851,10 +2852,8 @@ mod tests {
 
         let mut texts = scrub_notch_label_texts(&mut app);
         texts.sort();
-        let mut expected: Vec<String> = scrub_notch_labels()
-            .iter()
-            .map(|s| s.to_string())
-            .collect();
+        let mut expected: Vec<String> =
+            scrub_notch_labels().iter().map(|s| s.to_string()).collect();
         expected.sort();
         assert_eq!(
             texts, expected,
@@ -3144,7 +3143,10 @@ mod tests {
             secs_to_next: 0.5,
             paused: false,
         };
-        assert_eq!(format_move_log_header(&playing), "\u{258C} MOVE LOG \u{00B7} 3/10");
+        assert_eq!(
+            format_move_log_header(&playing),
+            "\u{258C} MOVE LOG \u{00B7} 3/10"
+        );
         assert_eq!(
             format_move_log_header(&ReplayPlaybackState::Completed),
             "\u{258C} MOVE LOG \u{00B7} COMPLETE",
@@ -3622,8 +3624,7 @@ mod tests {
         app.update();
 
         let world = app.world_mut();
-        let mut q = world
-            .query_filtered::<&TextColor, With<ReplayOverlayMoveLogActiveRow>>();
+        let mut q = world.query_filtered::<&TextColor, With<ReplayOverlayMoveLogActiveRow>>();
         let color = q
             .iter(world)
             .next()
@@ -3945,10 +3946,7 @@ mod tests {
                     *cursor, 1,
                     "→ must advance the cursor by exactly one while paused",
                 );
-                assert!(
-                    *paused,
-                    "→ must leave the paused flag untouched",
-                );
+                assert!(*paused, "→ must leave the paused flag untouched",);
             }
             other => panic!("expected Playing, got {other:?}"),
         }
@@ -4001,10 +3999,7 @@ mod tests {
                     *cursor, 2,
                     "← must decrement the cursor by exactly one while paused",
                 );
-                assert!(
-                    *paused,
-                    "← must leave the paused flag untouched",
-                );
+                assert!(*paused, "← must leave the paused flag untouched",);
             }
             other => panic!("expected Playing, got {other:?}"),
         }
@@ -4044,9 +4039,9 @@ mod tests {
         app.init_resource::<ButtonInput<KeyCode>>();
         // Drive each frame as a SCRUB_REPEAT_INTERVAL_SECS step so
         // every update past the just_pressed crosses the threshold.
-        app.insert_resource(TimeUpdateStrategy::ManualDuration(
-            Duration::from_secs_f32(SCRUB_REPEAT_INTERVAL_SECS),
-        ));
+        app.insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_secs_f32(
+            SCRUB_REPEAT_INTERVAL_SECS,
+        )));
         // Start paused at cursor 0 so there's room to step forward.
         set_state(&mut app, pressed_paused_state(10, 0));
         app.update();
@@ -4094,9 +4089,9 @@ mod tests {
         // Drive sub-threshold ticks so the accumulator builds but
         // never fires while held.
         let half_interval = SCRUB_REPEAT_INTERVAL_SECS * 0.5;
-        app.insert_resource(TimeUpdateStrategy::ManualDuration(
-            Duration::from_secs_f32(half_interval),
-        ));
+        app.insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_secs_f32(
+            half_interval,
+        )));
         set_state(&mut app, pressed_paused_state(10, 5));
         app.update();
 
@@ -4280,29 +4275,29 @@ mod tests {
     /// character except Ten which maps to `"T"`.
     #[test]
     fn format_rank_short_all_ranks() {
-        assert_eq!(format_rank_short(Rank::Ace),   "A");
-        assert_eq!(format_rank_short(Rank::Two),   "2");
+        assert_eq!(format_rank_short(Rank::Ace), "A");
+        assert_eq!(format_rank_short(Rank::Two), "2");
         assert_eq!(format_rank_short(Rank::Three), "3");
-        assert_eq!(format_rank_short(Rank::Four),  "4");
-        assert_eq!(format_rank_short(Rank::Five),  "5");
-        assert_eq!(format_rank_short(Rank::Six),   "6");
+        assert_eq!(format_rank_short(Rank::Four), "4");
+        assert_eq!(format_rank_short(Rank::Five), "5");
+        assert_eq!(format_rank_short(Rank::Six), "6");
         assert_eq!(format_rank_short(Rank::Seven), "7");
         assert_eq!(format_rank_short(Rank::Eight), "8");
-        assert_eq!(format_rank_short(Rank::Nine),  "9");
-        assert_eq!(format_rank_short(Rank::Ten),   "T");
-        assert_eq!(format_rank_short(Rank::Jack),  "J");
+        assert_eq!(format_rank_short(Rank::Nine), "9");
+        assert_eq!(format_rank_short(Rank::Ten), "T");
+        assert_eq!(format_rank_short(Rank::Jack), "J");
         assert_eq!(format_rank_short(Rank::Queen), "Q");
-        assert_eq!(format_rank_short(Rank::King),  "K");
+        assert_eq!(format_rank_short(Rank::King), "K");
     }
 
     /// `format_suit_glyph` returns the FiraMono-covered Unicode suit
     /// glyphs for each `Suit` variant (U+2660–U+2666 confirmed on Android).
     #[test]
     fn format_suit_glyph_all_suits() {
-        assert_eq!(format_suit_glyph(Suit::Spades),   "\u{2660}");
-        assert_eq!(format_suit_glyph(Suit::Hearts),   "\u{2665}");
+        assert_eq!(format_suit_glyph(Suit::Spades), "\u{2660}");
+        assert_eq!(format_suit_glyph(Suit::Hearts), "\u{2665}");
         assert_eq!(format_suit_glyph(Suit::Diamonds), "\u{2666}");
-        assert_eq!(format_suit_glyph(Suit::Clubs),    "\u{2663}");
+        assert_eq!(format_suit_glyph(Suit::Clubs), "\u{2663}");
     }
 
     /// `format_foundations_row` with a freshly-dealt game (all empty).

solitaire_engine/src/replay_playback.rs

@@ -222,10 +222,7 @@ pub fn start_replay_playback(
 /// [`start_replay_playback`] signature — leaves room to hook in
 /// cleanup (e.g. despawning playback-only overlays) without a future
 /// API break.
-pub fn stop_replay_playback(
-    _commands: &mut Commands,
-    state: &mut ResMut<ReplayPlaybackState>,
-) {
+pub fn stop_replay_playback(_commands: &mut Commands, state: &mut ResMut<ReplayPlaybackState>) {
     **state = ReplayPlaybackState::Inactive;
 }
 
@@ -566,9 +563,9 @@ mod tests {
     /// so we drive 200 ms steps and call `update` enough times to pass
     /// the requested duration.
     fn advance_by(app: &mut App, total_secs: f32) {
-        app.insert_resource(TimeUpdateStrategy::ManualDuration(
-            Duration::from_secs_f32(0.2),
-        ));
+        app.insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_secs_f32(
+            0.2,
+        )));
         let ticks = (total_secs / 0.2).ceil() as usize + 1;
         for _ in 0..ticks {
             app.update();
@@ -651,9 +648,7 @@ mod tests {
         let state = app.world().resource::<ReplayPlaybackState>();
         match state {
             ReplayPlaybackState::Playing {
-                cursor,
-                replay: r,
-                ..
+                cursor, replay: r, ..
             } => {
                 assert_eq!(*cursor, 0);
                 assert_eq!(r.seed, replay.seed);
@@ -931,9 +926,9 @@ mod tests {
                 .add_systems(Update, collect_draws);
             start_playback(&mut app, ten_draws_replay());
             app.update();
-            app.insert_resource(TimeUpdateStrategy::ManualDuration(
-                Duration::from_secs_f32(tick_secs),
-            ));
+            app.insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_secs_f32(
+                tick_secs,
+            )));
             let ticks = (total_secs / tick_secs).ceil() as usize + 1;
             for _ in 0..ticks {
                 app.update();

solitaire_engine/src/resources.rs

@@ -145,4 +145,3 @@ impl TokioRuntimeResource {
         Ok(Self(Arc::new(rt)))
     }
 }
-

solitaire_engine/src/safe_area.rs

@@ -108,7 +108,15 @@ fn apply_safe_area_anchors(
     // expects logical pixels (≈ dp). Divide by the window scale factor so
     // the HUD band shifts by the correct number of dp on high-DPI devices.
     let scale = windows.iter().next().map_or(1.0, |w| w.scale_factor());
-    let top_logical = insets.top / scale;
+    let window_height = windows.iter().next().map_or(800.0, |w| w.height());
+    let max_inset = window_height * 0.25;
+    let raw_top = insets.top / scale;
+    if raw_top > max_inset {
+        warn!(
+            "safe_area: top inset {raw_top:.0}px exceeds 25% of window height ({max_inset:.0}px); clamping"
+        );
+    }
+    let top_logical = raw_top.min(max_inset);
     for (anchor, mut node) in &mut q {
         node.top = Val::Px(anchor.base_top + top_logical);
     }
@@ -125,7 +133,15 @@ fn apply_safe_area_bottom_anchors(
         return;
     }
     let scale = windows.iter().next().map_or(1.0, |w| w.scale_factor());
-    let bottom_logical = insets.bottom / scale;
+    let window_height = windows.iter().next().map_or(800.0, |w| w.height());
+    let max_inset = window_height * 0.25;
+    let raw_bottom = insets.bottom / scale;
+    if raw_bottom > max_inset {
+        warn!(
+            "safe_area: bottom inset {raw_bottom:.0}px exceeds 25% of window height ({max_inset:.0}px); clamping"
+        );
+    }
+    let bottom_logical = raw_bottom.min(max_inset);
     for (anchor, mut node) in &mut q {
         node.bottom = Val::Px(anchor.base_bottom + bottom_logical);
     }
@@ -148,7 +164,8 @@ fn apply_safe_area_to_modal_scrims(
         return;
     }
     let scale = windows.iter().next().map_or(1.0, |w| w.scale_factor());
-    let bottom_logical = insets.bottom / scale;
+    let window_height = windows.iter().next().map_or(800.0, |w| w.height());
+    let bottom_logical = (insets.bottom / scale).min(window_height * 0.25);
     for mut node in &mut scrims {
         node.padding.bottom = Val::Px(bottom_logical);
     }
@@ -260,7 +277,7 @@ mod android {
 
     fn query_insets() -> Result<SafeAreaInsets, String> {
         use bevy::android::ANDROID_APP;
-        use jni::{objects::JObject, JavaVM};
+        use jni::{JavaVM, objects::JObject};
 
         let app = ANDROID_APP
             .get()
@@ -353,25 +370,33 @@ mod tests {
 
     #[test]
     fn is_populated_returns_true_for_any_nonzero_edge() {
-        assert!(SafeAreaInsets {
-            top: 24.0,
-            ..Default::default()
-        }
-        .is_populated());
-        assert!(SafeAreaInsets {
-            bottom: 16.0,
-            ..Default::default()
-        }
-        .is_populated());
-        assert!(SafeAreaInsets {
-            left: 8.0,
-            ..Default::default()
-        }
-        .is_populated());
-        assert!(SafeAreaInsets {
-            right: 8.0,
-            ..Default::default()
-        }
-        .is_populated());
+        assert!(
+            SafeAreaInsets {
+                top: 24.0,
+                ..Default::default()
+            }
+            .is_populated()
+        );
+        assert!(
+            SafeAreaInsets {
+                bottom: 16.0,
+                ..Default::default()
+            }
+            .is_populated()
+        );
+        assert!(
+            SafeAreaInsets {
+                left: 8.0,
+                ..Default::default()
+            }
+            .is_populated()
+        );
+        assert!(
+            SafeAreaInsets {
+                right: 8.0,
+                ..Default::default()
+            }
+            .is_populated()
+        );
     }
 }

solitaire_engine/src/selection_plugin.rs

@@ -156,13 +156,11 @@ impl Plugin for SelectionPlugin {
                         .in_set(SelectionKeySet)
                         .before(GameMutation),
                     clear_selection_on_state_change.after(GameMutation),
-                    update_selection_highlight
-                        .after(GameMutation)
-                        .run_if(
-                            resource_changed::<SelectionState>
-                                .or(resource_changed::<KeyboardDragState>)
-                                .or(resource_changed::<crate::GameStateResource>),
-                        ),
+                    update_selection_highlight.after(GameMutation).run_if(
+                        resource_changed::<SelectionState>
+                            .or(resource_changed::<KeyboardDragState>)
+                            .or(resource_changed::<crate::GameStateResource>),
+                    ),
                 ),
             );
     }
@@ -191,10 +189,7 @@ fn cycled_piles() -> Vec<PileType> {
 ///
 /// If `current` is `None` the first available pile is returned.
 /// If `available` is empty, `None` is returned.
-pub fn cycle_next_pile(
-    available: &[PileType],
-    current: Option<&PileType>,
-) -> Option<PileType> {
+pub fn cycle_next_pile(available: &[PileType], current: Option<&PileType>) -> Option<PileType> {
     if available.is_empty() {
         return None;
     }
@@ -227,11 +222,7 @@ pub fn cycle_next_pile(
 ///
 /// Both `current` and `next` must be `Some`; if either is `None` this returns
 /// `false`.
-fn did_wrap(
-    available: &[PileType],
-    current: Option<&PileType>,
-    next: Option<&PileType>,
-) -> bool {
+fn did_wrap(available: &[PileType], current: Option<&PileType>, next: Option<&PileType>) -> bool {
     let (Some(cur), Some(nxt)) = (current, next) else {
         return false;
     };
@@ -306,8 +297,7 @@ fn handle_selection_keys(
         destination_index,
     } = &mut *kbd_drag
     {
-        let shift_held =
-            keys.pressed(KeyCode::ShiftLeft) || keys.pressed(KeyCode::ShiftRight);
+        let shift_held = keys.pressed(KeyCode::ShiftLeft) || keys.pressed(KeyCode::ShiftRight);
 
         // Cycle destinations forward / backward.
         let advance = keys.just_pressed(KeyCode::ArrowRight)
@@ -436,9 +426,7 @@ fn handle_selection_keys(
             return;
         }
         // Priority 2: tableau stack move.
-        let run_len = face_up_run_len(
-            game.0.piles.get(pile).map_or(&[], |p| p.cards.as_slice()),
-        );
+        let run_len = face_up_run_len(game.0.piles.get(pile).map_or(&[], |p| p.cards.as_slice()));
         let bottom_card = game.0.piles.get(pile).and_then(|p| {
             let start = p.cards.len().saturating_sub(run_len);
             p.cards.get(start)
@@ -486,16 +474,13 @@ fn handle_selection_keys(
             return;
         }
         let start = pile_cards.cards.len().saturating_sub(count);
-        let lifted_cards: Vec<u32> =
-            pile_cards.cards[start..].iter().map(|c| c.id).collect();
+        let lifted_cards: Vec<u32> = pile_cards.cards[start..].iter().map(|c| c.id).collect();
         let Some(bottom) = pile_cards.cards.get(start) else {
             return;
         };
         let legal = legal_destinations_for(bottom, source, &game.0, count);
         if legal.is_empty() {
-            info_toast.write(InfoToastEvent(
-                "No legal moves for this card".to_string(),
-            ));
+            info_toast.write(InfoToastEvent("No legal moves for this card".to_string()));
             return;
         }
 
@@ -603,9 +588,10 @@ fn try_foundation_dest(
     for slot in 0..4_u8 {
         let dest = PileType::Foundation(slot);
         if let Some(pile) = game.piles.get(&dest)
-            && can_place_on_foundation(card, pile) {
-                return Some(dest);
-            }
+            && can_place_on_foundation(card, pile)
+        {
+            return Some(dest);
+        }
     }
     None
 }
@@ -831,22 +817,34 @@ mod tests {
         // Press 1: no current selection → first pile, no wrap.
         let sel1 = cycle_next_pile(&available, None);
         assert_eq!(sel1, Some(PileType::Waste));
-        assert!(!did_wrap(&available, None, sel1.as_ref()), "first Tab should not wrap");
+        assert!(
+            !did_wrap(&available, None, sel1.as_ref()),
+            "first Tab should not wrap"
+        );
 
         // Press 2: Waste → Tableau(0), no wrap.
         let sel2 = cycle_next_pile(&available, sel1.as_ref());
         assert_eq!(sel2, Some(PileType::Tableau(0)));
-        assert!(!did_wrap(&available, sel1.as_ref(), sel2.as_ref()), "second Tab should not wrap");
+        assert!(
+            !did_wrap(&available, sel1.as_ref(), sel2.as_ref()),
+            "second Tab should not wrap"
+        );
 
         // Press 3: Tableau(0) → Tableau(1), still no wrap.
         let sel3 = cycle_next_pile(&available, sel2.as_ref());
         assert_eq!(sel3, Some(PileType::Tableau(1)));
-        assert!(!did_wrap(&available, sel2.as_ref(), sel3.as_ref()), "third Tab (T0→T1) should not wrap");
+        assert!(
+            !did_wrap(&available, sel2.as_ref(), sel3.as_ref()),
+            "third Tab (T0→T1) should not wrap"
+        );
 
         // Press 4: Tableau(1) → Waste, this IS the wrap.
         let sel4 = cycle_next_pile(&available, sel3.as_ref());
         assert_eq!(sel4, Some(PileType::Waste));
-        assert!(did_wrap(&available, sel3.as_ref(), sel4.as_ref()), "fourth Tab should wrap back to Waste");
+        assert!(
+            did_wrap(&available, sel3.as_ref(), sel4.as_ref()),
+            "fourth Tab should wrap back to Waste"
+        );
     }
 
     #[test]
@@ -869,9 +867,24 @@ mod tests {
     fn face_up_run_len_all_face_up() {
         use solitaire_core::card::{Card, Rank, Suit};
         let cards = vec![
-            Card { id: 0, suit: Suit::Clubs, rank: Rank::King, face_up: true },
-            Card { id: 1, suit: Suit::Hearts, rank: Rank::Queen, face_up: true },
-            Card { id: 2, suit: Suit::Spades, rank: Rank::Jack, face_up: true },
+            Card {
+                id: 0,
+                suit: Suit::Clubs,
+                rank: Rank::King,
+                face_up: true,
+            },
+            Card {
+                id: 1,
+                suit: Suit::Hearts,
+                rank: Rank::Queen,
+                face_up: true,
+            },
+            Card {
+                id: 2,
+                suit: Suit::Spades,
+                rank: Rank::Jack,
+                face_up: true,
+            },
         ];
         assert_eq!(face_up_run_len(&cards), 3);
     }
@@ -880,10 +893,30 @@ mod tests {
     fn face_up_run_len_mixed_stops_at_face_down() {
         use solitaire_core::card::{Card, Rank, Suit};
         let cards = vec![
-            Card { id: 0, suit: Suit::Clubs, rank: Rank::King, face_up: false },
-            Card { id: 1, suit: Suit::Hearts, rank: Rank::Queen, face_up: false },
-            Card { id: 2, suit: Suit::Spades, rank: Rank::Jack, face_up: true },
-            Card { id: 3, suit: Suit::Diamonds, rank: Rank::Ten, face_up: true },
+            Card {
+                id: 0,
+                suit: Suit::Clubs,
+                rank: Rank::King,
+                face_up: false,
+            },
+            Card {
+                id: 1,
+                suit: Suit::Hearts,
+                rank: Rank::Queen,
+                face_up: false,
+            },
+            Card {
+                id: 2,
+                suit: Suit::Spades,
+                rank: Rank::Jack,
+                face_up: true,
+            },
+            Card {
+                id: 3,
+                suit: Suit::Diamonds,
+                rank: Rank::Ten,
+                face_up: true,
+            },
         ];
         // Only the top two cards are face-up.
         assert_eq!(face_up_run_len(&cards), 2);
@@ -893,8 +926,18 @@ mod tests {
     fn face_up_run_len_top_card_face_down_is_zero() {
         use solitaire_core::card::{Card, Rank, Suit};
         let cards = vec![
-            Card { id: 0, suit: Suit::Clubs, rank: Rank::King, face_up: true },
-            Card { id: 1, suit: Suit::Hearts, rank: Rank::Queen, face_up: false },
+            Card {
+                id: 0,
+                suit: Suit::Clubs,
+                rank: Rank::King,
+                face_up: true,
+            },
+            Card {
+                id: 1,
+                suit: Suit::Hearts,
+                rank: Rank::Queen,
+                face_up: false,
+            },
         ];
         assert_eq!(face_up_run_len(&cards), 0);
     }
@@ -902,9 +945,12 @@ mod tests {
     #[test]
     fn face_up_run_len_single_face_up_card() {
         use solitaire_core::card::{Card, Rank, Suit};
-        let cards = vec![
-            Card { id: 0, suit: Suit::Hearts, rank: Rank::Ace, face_up: true },
-        ];
+        let cards = vec![Card {
+            id: 0,
+            suit: Suit::Hearts,
+            rank: Rank::Ace,
+            face_up: true,
+        }];
         assert_eq!(face_up_run_len(&cards), 1);
     }
 
@@ -956,27 +1002,43 @@ mod tests {
         g.piles.get_mut(&PileType::Stock).unwrap().cards.clear();
         g.piles.get_mut(&PileType::Waste).unwrap().cards.clear();
         for i in 0..7 {
-            g.piles.get_mut(&PileType::Tableau(i)).unwrap().cards.clear();
+            g.piles
+                .get_mut(&PileType::Tableau(i))
+                .unwrap()
+                .cards
+                .clear();
         }
         // Place test cards.
-        g.piles.get_mut(&PileType::Tableau(0)).unwrap().cards.push(Card {
-            id: 100,
-            suit: Suit::Clubs,
-            rank: Rank::Five,
-            face_up: true,
-        });
-        g.piles.get_mut(&PileType::Tableau(1)).unwrap().cards.push(Card {
-            id: 101,
-            suit: Suit::Hearts,
-            rank: Rank::Six,
-            face_up: true,
-        });
-        g.piles.get_mut(&PileType::Tableau(2)).unwrap().cards.push(Card {
-            id: 102,
-            suit: Suit::Diamonds,
-            rank: Rank::Six,
-            face_up: true,
-        });
+        g.piles
+            .get_mut(&PileType::Tableau(0))
+            .unwrap()
+            .cards
+            .push(Card {
+                id: 100,
+                suit: Suit::Clubs,
+                rank: Rank::Five,
+                face_up: true,
+            });
+        g.piles
+            .get_mut(&PileType::Tableau(1))
+            .unwrap()
+            .cards
+            .push(Card {
+                id: 101,
+                suit: Suit::Hearts,
+                rank: Rank::Six,
+                face_up: true,
+            });
+        g.piles
+            .get_mut(&PileType::Tableau(2))
+            .unwrap()
+            .cards
+            .push(Card {
+                id: 102,
+                suit: Suit::Diamonds,
+                rank: Rank::Six,
+                face_up: true,
+            });
         g
     }
 
@@ -1014,17 +1076,32 @@ mod tests {
         app.update();
 
         // Initial state: nothing selected, KeyboardDragState::Idle.
-        assert!(app.world().resource::<SelectionState>().selected_pile.is_none());
-        assert_eq!(*app.world().resource::<KeyboardDragState>(), KeyboardDragState::Idle);
+        assert!(
+            app.world()
+                .resource::<SelectionState>()
+                .selected_pile
+                .is_none()
+        );
+        assert_eq!(
+            *app.world().resource::<KeyboardDragState>(),
+            KeyboardDragState::Idle
+        );
 
         press_key(&mut app, KeyCode::Tab);
         app.update();
 
-        let selected = app.world().resource::<SelectionState>().selected_pile.clone();
+        let selected = app
+            .world()
+            .resource::<SelectionState>()
+            .selected_pile
+            .clone();
         // The cycle order starts at Waste, but Waste is empty so the next
         // available pile (Tableau(0)) is selected.
         assert_eq!(selected, Some(PileType::Tableau(0)));
-        assert_eq!(*app.world().resource::<KeyboardDragState>(), KeyboardDragState::Idle);
+        assert_eq!(
+            *app.world().resource::<KeyboardDragState>(),
+            KeyboardDragState::Idle
+        );
     }
 
     /// Test 2 — Enter while a source is selected lifts the stack.
@@ -1038,8 +1115,9 @@ mod tests {
         app.update();
 
         // Manually focus Tableau(0) so we don't depend on Tab.
-        app.world_mut().resource_mut::<SelectionState>().selected_pile =
-            Some(PileType::Tableau(0));
+        app.world_mut()
+            .resource_mut::<SelectionState>()
+            .selected_pile = Some(PileType::Tableau(0));
 
         press_key(&mut app, KeyCode::Enter);
         app.update();
@@ -1081,8 +1159,9 @@ mod tests {
         let mut app = drag_test_app();
         install_state(&mut app, deterministic_state());
         app.update();
-        app.world_mut().resource_mut::<SelectionState>().selected_pile =
-            Some(PileType::Tableau(0));
+        app.world_mut()
+            .resource_mut::<SelectionState>()
+            .selected_pile = Some(PileType::Tableau(0));
         press_key(&mut app, KeyCode::Enter);
         app.update();
 
@@ -1091,7 +1170,9 @@ mod tests {
         // higher. Verify that the destinations are exactly those tableaus
         // (in cycle order T1 then T2).
         let initial_dests: Vec<PileType> = match app.world().resource::<KeyboardDragState>() {
-            KeyboardDragState::Lifted { legal_destinations, .. } => legal_destinations.clone(),
+            KeyboardDragState::Lifted {
+                legal_destinations, ..
+            } => legal_destinations.clone(),
             _ => panic!("expected Lifted"),
         };
         assert_eq!(
@@ -1109,7 +1190,14 @@ mod tests {
                 rank: Rank::Five,
                 face_up: true,
             };
-            let pile = app.world().resource::<GameStateResource>().0.piles.get(dest).unwrap().clone();
+            let pile = app
+                .world()
+                .resource::<GameStateResource>()
+                .0
+                .piles
+                .get(dest)
+                .unwrap()
+                .clone();
             assert!(
                 can_place_on_tableau(&bottom_card, &pile),
                 "destination {dest:?} must be legal for the lifted stack",
@@ -1118,7 +1206,9 @@ mod tests {
 
         // Initial focused destination = first entry.
         assert_eq!(
-            app.world().resource::<KeyboardDragState>().focused_destination(),
+            app.world()
+                .resource::<KeyboardDragState>()
+                .focused_destination(),
             Some(&PileType::Tableau(1)),
         );
 
@@ -1127,7 +1217,9 @@ mod tests {
         press_key(&mut app, KeyCode::ArrowRight);
         app.update();
         assert_eq!(
-            app.world().resource::<KeyboardDragState>().focused_destination(),
+            app.world()
+                .resource::<KeyboardDragState>()
+                .focused_destination(),
             Some(&PileType::Tableau(2)),
         );
 
@@ -1136,7 +1228,9 @@ mod tests {
         press_key(&mut app, KeyCode::ArrowRight);
         app.update();
         assert_eq!(
-            app.world().resource::<KeyboardDragState>().focused_destination(),
+            app.world()
+                .resource::<KeyboardDragState>()
+                .focused_destination(),
             Some(&PileType::Tableau(1)),
             "destination index must wrap back to 0 after exhausting the list",
         );
@@ -1150,8 +1244,9 @@ mod tests {
         let mut app = drag_test_app();
         install_state(&mut app, deterministic_state());
         app.update();
-        app.world_mut().resource_mut::<SelectionState>().selected_pile =
-            Some(PileType::Tableau(0));
+        app.world_mut()
+            .resource_mut::<SelectionState>()
+            .selected_pile = Some(PileType::Tableau(0));
         press_key(&mut app, KeyCode::Enter);
         app.update();
 
@@ -1194,8 +1289,9 @@ mod tests {
         let mut app = drag_test_app();
         install_state(&mut app, deterministic_state());
         app.update();
-        app.world_mut().resource_mut::<SelectionState>().selected_pile =
-            Some(PileType::Tableau(0));
+        app.world_mut()
+            .resource_mut::<SelectionState>()
+            .selected_pile = Some(PileType::Tableau(0));
         press_key(&mut app, KeyCode::Enter);
         app.update();
         assert!(app.world().resource::<KeyboardDragState>().is_lifted());
@@ -1240,10 +1336,18 @@ mod tests {
             drag.active_touch_id = None;
         }
 
-        let before = app.world().resource::<SelectionState>().selected_pile.clone();
+        let before = app
+            .world()
+            .resource::<SelectionState>()
+            .selected_pile
+            .clone();
         press_key(&mut app, KeyCode::Tab);
         app.update();
-        let after = app.world().resource::<SelectionState>().selected_pile.clone();
+        let after = app
+            .world()
+            .resource::<SelectionState>()
+            .selected_pile
+            .clone();
 
         assert_eq!(
             before, after,
@@ -1258,8 +1362,9 @@ mod tests {
         let mut app = drag_test_app();
         install_state(&mut app, deterministic_state());
         app.update();
-        app.world_mut().resource_mut::<SelectionState>().selected_pile =
-            Some(PileType::Tableau(0));
+        app.world_mut()
+            .resource_mut::<SelectionState>()
+            .selected_pile = Some(PileType::Tableau(0));
         press_key(&mut app, KeyCode::Enter);
         app.update();
 
@@ -1276,7 +1381,10 @@ mod tests {
         press_key(&mut app, KeyCode::Escape);
         app.update();
         assert!(
-            app.world().resource::<SelectionState>().selected_pile.is_none(),
+            app.world()
+                .resource::<SelectionState>()
+                .selected_pile
+                .is_none(),
             "second Esc clears the source selection",
         );
     }

solitaire_engine/src/settings_plugin.rs

@@ -17,13 +17,14 @@ use bevy::ui::{ComputedNode, UiGlobalTransform};
 use bevy::window::{WindowMoved, WindowResized};
 use solitaire_core::game_state::DrawMode;
 use solitaire_data::{
-    load_settings_from, save_settings_to, settings_file_path, settings::Theme, AnimSpeed, Settings,
-    WindowGeometry, REPLAY_MOVE_INTERVAL_STEP_SECS, TIME_BONUS_MULTIPLIER_STEP,
-    TOOLTIP_DELAY_STEP_SECS,
+    AnimSpeed, REPLAY_MOVE_INTERVAL_STEP_SECS, Settings, TIME_BONUS_MULTIPLIER_STEP,
+    TOOLTIP_DELAY_STEP_SECS, WindowGeometry, load_settings_from, save_settings_to, settings::Theme,
+    settings_file_path,
 };
 
 use solitaire_data::settings::SyncBackend;
 
+use crate::assets::user_theme_dir;
 use crate::events::{
     DeleteAccountRequestEvent, InfoToastEvent, ManualSyncRequestEvent, SyncConfigureRequestEvent,
     SyncLogoutRequestEvent, ToggleSettingsRequestEvent,
@@ -31,20 +32,20 @@ use crate::events::{
 use crate::font_plugin::FontResource;
 use crate::progress_plugin::ProgressResource;
 use crate::resources::{SettingsScrollPos, SyncStatus, SyncStatusResource};
-use crate::assets::user_theme_dir;
-use crate::theme::{import_theme, ImportError, ThemeThumbnailCache, ThemeThumbnailPair, refresh_registry};
+use crate::theme::{
+    ImportError, ThemeThumbnailCache, ThemeThumbnailPair, import_theme, refresh_registry,
+};
 use crate::ui_focus::{FocusGroup, FocusRow, Focusable, FocusedButton};
 use crate::ui_modal::{
-    spawn_modal, spawn_modal_actions, spawn_modal_button, spawn_modal_header, ButtonVariant,
-    ModalButton, ModalScrim,
+    ButtonVariant, ModalButton, ModalScrim, spawn_modal, spawn_modal_actions, spawn_modal_button,
+    spawn_modal_header,
 };
-use crate::ui_tooltip::Tooltip;
 use crate::ui_theme::{
     BG_BASE, BG_ELEVATED, BG_ELEVATED_HI, BORDER_SUBTLE, BORDER_SUBTLE_HC, HighContrastBackground,
-    HighContrastBorder,
-    RADIUS_SM, SPACE_2, STATE_SUCCESS, TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY, TYPE_BODY_LG,
-    TYPE_CAPTION, VAL_SPACE_2, VAL_SPACE_3, Z_MODAL_PANEL,
+    HighContrastBorder, RADIUS_SM, SPACE_2, STATE_SUCCESS, TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY,
+    TYPE_BODY_LG, TYPE_CAPTION, VAL_SPACE_2, VAL_SPACE_3, Z_MODAL_PANEL,
 };
+use crate::ui_tooltip::Tooltip;
 
 /// Side length of a swatch button in the card-back / background pickers.
 /// Smaller than the smallest spacing rung so it stays a literal.
@@ -401,10 +402,8 @@ impl Plugin for SettingsPlugin {
                     update_anim_speed_text,
                     update_color_blind_text,
                     update_high_contrast_text,
-                    update_high_contrast_borders
-                        .run_if(resource_changed::<SettingsResource>),
-                    update_high_contrast_backgrounds
-                        .run_if(resource_changed::<SettingsResource>),
+                    update_high_contrast_borders.run_if(resource_changed::<SettingsResource>),
+                    update_high_contrast_backgrounds.run_if(resource_changed::<SettingsResource>),
                     update_reduce_motion_text,
                     update_tooltip_delay_text,
                     update_time_bonus_multiplier_text,
@@ -454,7 +453,12 @@ fn merge_geometry(
     let (x, y) = new_pos
         .or_else(|| existing.map(|g| (g.x, g.y)))
         .unwrap_or((0, 0));
-    Some(WindowGeometry { width, height, x, y })
+    Some(WindowGeometry {
+        width,
+        height,
+        x,
+        y,
+    })
 }
 
 // ---------------------------------------------------------------------------
@@ -527,8 +531,10 @@ 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 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());
@@ -894,14 +900,110 @@ fn handle_settings_buttons(
     mut screen: ResMut<SettingsScreen>,
     path: Res<SettingsStoragePath>,
     mut changed: MessageWriter<SettingsChangedEvent>,
-    mut sfx_text: Query<&mut Text, (With<SfxVolumeText>, Without<MusicVolumeText>, Without<DrawModeText>, Without<ThemeText>, Without<AnimSpeedText>, Without<ColorBlindText>, Without<HighContrastText>, Without<ReduceMotionText>)>,
-    mut music_text: Query<&mut Text, (With<MusicVolumeText>, Without<SfxVolumeText>, Without<DrawModeText>, Without<ThemeText>, Without<AnimSpeedText>, Without<ColorBlindText>, Without<HighContrastText>, Without<ReduceMotionText>)>,
-    mut draw_text: Query<&mut Text, (With<DrawModeText>, Without<SfxVolumeText>, Without<MusicVolumeText>, Without<ThemeText>, Without<AnimSpeedText>, Without<ColorBlindText>, Without<HighContrastText>, Without<ReduceMotionText>)>,
-    mut theme_text: Query<&mut Text, (With<ThemeText>, Without<SfxVolumeText>, Without<MusicVolumeText>, Without<DrawModeText>, Without<AnimSpeedText>, Without<ColorBlindText>, Without<HighContrastText>, Without<ReduceMotionText>)>,
-    mut anim_speed_text: Query<&mut Text, (With<AnimSpeedText>, Without<SfxVolumeText>, Without<MusicVolumeText>, Without<DrawModeText>, Without<ThemeText>, Without<ColorBlindText>, Without<HighContrastText>, Without<ReduceMotionText>)>,
-    mut color_blind_text: Query<&mut Text, (With<ColorBlindText>, Without<SfxVolumeText>, Without<MusicVolumeText>, Without<DrawModeText>, Without<ThemeText>, Without<AnimSpeedText>, Without<HighContrastText>, Without<ReduceMotionText>)>,
-    mut high_contrast_text: Query<&mut Text, (With<HighContrastText>, Without<SfxVolumeText>, Without<MusicVolumeText>, Without<DrawModeText>, Without<ThemeText>, Without<AnimSpeedText>, Without<ColorBlindText>, Without<ReduceMotionText>)>,
-    mut reduce_motion_text: Query<&mut Text, (With<ReduceMotionText>, Without<SfxVolumeText>, Without<MusicVolumeText>, Without<DrawModeText>, Without<ThemeText>, Without<AnimSpeedText>, Without<ColorBlindText>, Without<HighContrastText>)>,
+    mut sfx_text: Query<
+        &mut Text,
+        (
+            With<SfxVolumeText>,
+            Without<MusicVolumeText>,
+            Without<DrawModeText>,
+            Without<ThemeText>,
+            Without<AnimSpeedText>,
+            Without<ColorBlindText>,
+            Without<HighContrastText>,
+            Without<ReduceMotionText>,
+        ),
+    >,
+    mut music_text: Query<
+        &mut Text,
+        (
+            With<MusicVolumeText>,
+            Without<SfxVolumeText>,
+            Without<DrawModeText>,
+            Without<ThemeText>,
+            Without<AnimSpeedText>,
+            Without<ColorBlindText>,
+            Without<HighContrastText>,
+            Without<ReduceMotionText>,
+        ),
+    >,
+    mut draw_text: Query<
+        &mut Text,
+        (
+            With<DrawModeText>,
+            Without<SfxVolumeText>,
+            Without<MusicVolumeText>,
+            Without<ThemeText>,
+            Without<AnimSpeedText>,
+            Without<ColorBlindText>,
+            Without<HighContrastText>,
+            Without<ReduceMotionText>,
+        ),
+    >,
+    mut theme_text: Query<
+        &mut Text,
+        (
+            With<ThemeText>,
+            Without<SfxVolumeText>,
+            Without<MusicVolumeText>,
+            Without<DrawModeText>,
+            Without<AnimSpeedText>,
+            Without<ColorBlindText>,
+            Without<HighContrastText>,
+            Without<ReduceMotionText>,
+        ),
+    >,
+    mut anim_speed_text: Query<
+        &mut Text,
+        (
+            With<AnimSpeedText>,
+            Without<SfxVolumeText>,
+            Without<MusicVolumeText>,
+            Without<DrawModeText>,
+            Without<ThemeText>,
+            Without<ColorBlindText>,
+            Without<HighContrastText>,
+            Without<ReduceMotionText>,
+        ),
+    >,
+    mut color_blind_text: Query<
+        &mut Text,
+        (
+            With<ColorBlindText>,
+            Without<SfxVolumeText>,
+            Without<MusicVolumeText>,
+            Without<DrawModeText>,
+            Without<ThemeText>,
+            Without<AnimSpeedText>,
+            Without<HighContrastText>,
+            Without<ReduceMotionText>,
+        ),
+    >,
+    mut high_contrast_text: Query<
+        &mut Text,
+        (
+            With<HighContrastText>,
+            Without<SfxVolumeText>,
+            Without<MusicVolumeText>,
+            Without<DrawModeText>,
+            Without<ThemeText>,
+            Without<AnimSpeedText>,
+            Without<ColorBlindText>,
+            Without<ReduceMotionText>,
+        ),
+    >,
+    mut reduce_motion_text: Query<
+        &mut Text,
+        (
+            With<ReduceMotionText>,
+            Without<SfxVolumeText>,
+            Without<MusicVolumeText>,
+            Without<DrawModeText>,
+            Without<ThemeText>,
+            Without<AnimSpeedText>,
+            Without<ColorBlindText>,
+            Without<HighContrastText>,
+        ),
+    >,
 ) {
     for (interaction, button) in &interaction_query {
         if *interaction != Interaction::Pressed {
@@ -995,7 +1097,9 @@ fn handle_settings_buttons(
             }
             SettingsButton::TimeBonusDown => {
                 let before = settings.0.time_bonus_multiplier;
-                let after = settings.0.adjust_time_bonus_multiplier(-TIME_BONUS_MULTIPLIER_STEP);
+                let after = settings
+                    .0
+                    .adjust_time_bonus_multiplier(-TIME_BONUS_MULTIPLIER_STEP);
                 if (before - after).abs() > f32::EPSILON {
                     persist(&path, &settings.0);
                     changed.write(SettingsChangedEvent(settings.0.clone()));
@@ -1006,7 +1110,9 @@ fn handle_settings_buttons(
             }
             SettingsButton::TimeBonusUp => {
                 let before = settings.0.time_bonus_multiplier;
-                let after = settings.0.adjust_time_bonus_multiplier(TIME_BONUS_MULTIPLIER_STEP);
+                let after = settings
+                    .0
+                    .adjust_time_bonus_multiplier(TIME_BONUS_MULTIPLIER_STEP);
                 if (before - after).abs() > f32::EPSILON {
                     persist(&path, &settings.0);
                     changed.write(SettingsChangedEvent(settings.0.clone()));
@@ -1085,8 +1191,7 @@ fn handle_settings_buttons(
                 // Text refreshed by `update_analytics_enabled_text` next frame.
             }
             SettingsButton::ToggleSmartDefaultSize => {
-                settings.0.disable_smart_default_size =
-                    !settings.0.disable_smart_default_size;
+                settings.0.disable_smart_default_size = !settings.0.disable_smart_default_size;
                 persist(&path, &settings.0);
                 changed.write(SettingsChangedEvent(settings.0.clone()));
                 // The Text node is refreshed by
@@ -1144,15 +1249,21 @@ fn handle_sync_buttons(
             continue;
         }
         match button {
-            SettingsButton::SyncNow => { manual_sync.write(ManualSyncRequestEvent); }
+            SettingsButton::SyncNow => {
+                manual_sync.write(ManualSyncRequestEvent);
+            }
             SettingsButton::ConnectSync => {
                 // Close settings before the sync-setup modal opens so the
                 // guard in open_sync_setup_modal doesn't block on our own scrim.
                 screen.0 = false;
                 configure_sync.write(SyncConfigureRequestEvent);
             }
-            SettingsButton::DisconnectSync => { logout_sync.write(SyncLogoutRequestEvent); }
-            SettingsButton::DeleteAccount => { delete_account.write(DeleteAccountRequestEvent); }
+            SettingsButton::DisconnectSync => {
+                logout_sync.write(SyncLogoutRequestEvent);
+            }
+            SettingsButton::DeleteAccount => {
+                delete_account.write(DeleteAccountRequestEvent);
+            }
             _ => {}
         }
     }
@@ -1334,10 +1445,11 @@ fn scroll_focus_into_view(
             Err(_) => break,
         }
     }
-    let Some(container) = container_entity else { return };
+    let Some(container) = container_entity else {
+        return;
+    };
 
-    let Ok((mut scroll, container_transform, container_node)) =
-        containers.get_mut(container)
+    let Ok((mut scroll, container_transform, container_node)) = containers.get_mut(container)
     else {
         return;
     };
@@ -1430,10 +1542,12 @@ fn record_window_geometry_changes(
 ) {
     // Read .last() — only the final event matters for persistence; the
     // intermediate sizes/positions are noise during a drag.
-    let new_size = resized
-        .read()
-        .last()
-        .map(|ev| (ev.width.round().max(0.0) as u32, ev.height.round().max(0.0) as u32));
+    let new_size = resized.read().last().map(|ev| {
+        (
+            ev.width.round().max(0.0) as u32,
+            ev.height.round().max(0.0) as u32,
+        )
+    });
     let new_pos = moved.read().last().map(|ev| (ev.position.x, ev.position.y));
 
     if new_size.is_none() && new_pos.is_none() {
@@ -2030,7 +2144,12 @@ fn toggle_row<Marker: Component>(
                 ..default()
             })
             .with_children(|cluster| {
-                cluster.spawn((marker, Text::new(value), value_font, TextColor(TEXT_PRIMARY)));
+                cluster.spawn((
+                    marker,
+                    Text::new(value),
+                    value_font,
+                    TextColor(TEXT_PRIMARY),
+                ));
                 icon_button(cluster, "⇄", action, tooltip, font_res);
             });
         });
@@ -2082,7 +2201,11 @@ fn picker_row(
             let entries: &[usize] = if unlocked.is_empty() { &[0] } else { unlocked };
             for &idx in entries {
                 let is_selected = idx == selected;
-                let bg = if is_selected { STATE_SUCCESS } else { BG_ELEVATED_HI };
+                let bg = if is_selected {
+                    STATE_SUCCESS
+                } else {
+                    BG_ELEVATED_HI
+                };
                 row.spawn((
                     make_button(idx),
                     Button,
@@ -2215,7 +2338,11 @@ fn theme_picker_row(
             ));
             for entry in themes {
                 let is_selected = entry.id == selected_id;
-                let bg = if is_selected { STATE_SUCCESS } else { BG_ELEVATED_HI };
+                let bg = if is_selected {
+                    STATE_SUCCESS
+                } else {
+                    BG_ELEVATED_HI
+                };
                 row.spawn((
                     SettingsButton::SelectTheme(entry.id.clone()),
                     Button,
@@ -2274,16 +2401,14 @@ fn spawn_thumbnail_pair(
             align_items: AlignItems::Center,
             ..default()
         })
-        .with_children(|pair| {
-            match thumbnails {
-                Some(t) if t.is_fully_populated() => {
-                    spawn_thumbnail_image(pair, t.ace.clone());
-                    spawn_thumbnail_image(pair, t.back.clone());
-                }
-                _ => {
-                    spawn_thumbnail_placeholder(pair);
-                    spawn_thumbnail_placeholder(pair);
-                }
+        .with_children(|pair| match thumbnails {
+            Some(t) if t.is_fully_populated() => {
+                spawn_thumbnail_image(pair, t.ace.clone());
+                spawn_thumbnail_image(pair, t.back.clone());
+            }
+            _ => {
+                spawn_thumbnail_placeholder(pair);
+                spawn_thumbnail_placeholder(pair);
             }
         });
 }
@@ -2360,11 +2485,7 @@ fn sync_row(
             HighContrastBorder::with_default(BORDER_SUBTLE),
         ))
         .with_children(|b| {
-            b.spawn((
-                Text::new(label.to_string()),
-                font,
-                TextColor(TEXT_PRIMARY),
-            ));
+            b.spawn((Text::new(label.to_string()), font, TextColor(TEXT_PRIMARY)));
         });
     };
 
@@ -2658,7 +2779,11 @@ fn icon_button(
             HighContrastBorder::with_default(BORDER_SUBTLE),
         ))
         .with_children(|b| {
-            b.spawn((Text::new(label.to_string()), glyph_font, TextColor(TEXT_PRIMARY)));
+            b.spawn((
+                Text::new(label.to_string()),
+                glyph_font,
+                TextColor(TEXT_PRIMARY),
+            ));
         });
 }
 
@@ -2714,7 +2839,10 @@ mod tests {
     #[test]
     fn pressing_right_bracket_increases_volume() {
         let mut app = headless_app();
-        app.world_mut().resource_mut::<SettingsResource>().0.sfx_volume = 0.5;
+        app.world_mut()
+            .resource_mut::<SettingsResource>()
+            .0
+            .sfx_volume = 0.5;
 
         press(&mut app, KeyCode::BracketRight);
         app.update();
@@ -2726,7 +2854,10 @@ mod tests {
     #[test]
     fn clamped_change_does_not_emit_event() {
         let mut app = headless_app();
-        app.world_mut().resource_mut::<SettingsResource>().0.sfx_volume = 1.0;
+        app.world_mut()
+            .resource_mut::<SettingsResource>()
+            .0
+            .sfx_volume = 1.0;
 
         press(&mut app, KeyCode::BracketRight);
         app.update();
@@ -2739,7 +2870,10 @@ mod tests {
     #[test]
     fn volume_clamped_at_zero_does_not_emit_event() {
         let mut app = headless_app();
-        app.world_mut().resource_mut::<SettingsResource>().0.sfx_volume = 0.0;
+        app.world_mut()
+            .resource_mut::<SettingsResource>()
+            .0
+            .sfx_volume = 0.0;
 
         press(&mut app, KeyCode::BracketLeft);
         app.update();
@@ -2749,21 +2883,34 @@ mod tests {
 
         let events = app.world().resource::<Messages<SettingsChangedEvent>>();
         let mut cursor = events.get_cursor();
-        assert_eq!(cursor.read(events).count(), 0, "no event when clamped at floor");
+        assert_eq!(
+            cursor.read(events).count(),
+            0,
+            "no event when clamped at floor"
+        );
     }
 
     #[test]
     fn pressing_o_toggles_settings_screen_flag() {
         let mut app = headless_app();
-        assert!(!app.world().resource::<SettingsScreen>().0, "screen is closed initially");
+        assert!(
+            !app.world().resource::<SettingsScreen>().0,
+            "screen is closed initially"
+        );
 
         press(&mut app, KeyCode::KeyO);
         app.update();
-        assert!(app.world().resource::<SettingsScreen>().0, "O opens settings");
+        assert!(
+            app.world().resource::<SettingsScreen>().0,
+            "O opens settings"
+        );
 
         press(&mut app, KeyCode::KeyO);
         app.update();
-        assert!(!app.world().resource::<SettingsScreen>().0, "second O closes settings");
+        assert!(
+            !app.world().resource::<SettingsScreen>().0,
+            "second O closes settings"
+        );
     }
 
     // cycle_unlocked pure-function tests
@@ -2819,7 +2966,8 @@ mod tests {
             .entity(entity)
             .get::<ScrollPosition>()
             .unwrap()
-            .0.y;
+            .0
+            .y;
         assert_eq!(offset, 0.0, "scroll must not move when panel is closed");
     }
 
@@ -2850,8 +2998,12 @@ mod tests {
             .entity(entity)
             .get::<ScrollPosition>()
             .unwrap()
-            .0.y;
-        assert!((offset - 200.0).abs() < 1e-3, "scrolling down should increase offset_y; got {offset}");
+            .0
+            .y;
+        assert!(
+            (offset - 200.0).abs() < 1e-3,
+            "scrolling down should increase offset_y; got {offset}"
+        );
     }
 
     // -----------------------------------------------------------------------
@@ -3102,7 +3254,12 @@ mod tests {
 
     #[test]
     fn merge_geometry_uses_existing_when_event_components_missing() {
-        let existing = WindowGeometry { width: 1280, height: 800, x: 100, y: 50 };
+        let existing = WindowGeometry {
+            width: 1280,
+            height: 800,
+            x: 100,
+            y: 50,
+        };
         // Position-only event keeps existing size.
         let merged = merge_geometry(Some(existing), None, Some((200, 75))).unwrap();
         assert_eq!(merged.width, 1280);
@@ -3214,7 +3371,10 @@ mod tests {
             .0
             .window_geometry
             .unwrap();
-        assert_eq!(geom.width, 1280, "size must be preserved across a move-only update");
+        assert_eq!(
+            geom.width, 1280,
+            "size must be preserved across a move-only update"
+        );
         assert_eq!(geom.height, 800);
         assert_eq!(geom.x, 250);
         assert_eq!(geom.y, 175);
@@ -3280,7 +3440,11 @@ mod tests {
             .entity(entity)
             .get::<ScrollPosition>()
             .unwrap()
-            .0.y;
-        assert_eq!(offset, 0.0, "scrolling past top must clamp to 0, got {offset}");
+            .0
+            .y;
+        assert_eq!(
+            offset, 0.0,
+            "scrolling past top must clamp to 0, got {offset}"
+        );
     }
 }

solitaire_engine/src/splash_plugin.rs

@@ -45,7 +45,7 @@
 //! progress-bar caption, palette label, eight palette swatches,
 //! version line).
 //!
-//! The trailing "▌ ready_" cursor pulse layers on top of the fade
+//! The trailing "| ready_" cursor pulse layers on top of the fade
 //! by carrying both [`SplashFadableBg`] and [`SplashCursorPulse`]:
 //! [`pulse_splash_cursor`] runs after [`advance_splash`] in the
 //! schedule chain and overwrites the cursor's `BackgroundColor`
@@ -76,8 +76,8 @@ use crate::settings_plugin::SettingsResource;
 use crate::ui_theme::{
     ACCENT_PRIMARY, ACCENT_SECONDARY, BG_BASE, BORDER_SUBTLE, MOTION_SPLASH_FADE_SECS,
     MOTION_SPLASH_TOTAL_SECS, STATE_DANGER, STATE_INFO, STATE_SUCCESS, STATE_WARNING,
-    TEXT_DISABLED, TEXT_PRIMARY, TYPE_CAPTION, TYPE_DISPLAY, VAL_SPACE_1, VAL_SPACE_2,
-    VAL_SPACE_3, VAL_SPACE_5, VAL_SPACE_6, VAL_SPACE_7, Z_SPLASH,
+    TEXT_DISABLED, TEXT_PRIMARY, TYPE_CAPTION, TYPE_DISPLAY, VAL_SPACE_1, VAL_SPACE_2, VAL_SPACE_3,
+    VAL_SPACE_5, VAL_SPACE_6, VAL_SPACE_7, Z_SPLASH,
 };
 
 // ---------------------------------------------------------------------------
@@ -99,17 +99,12 @@ impl Plugin for SplashPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(Startup, spawn_splash).add_systems(
             Update,
-            (
-                dismiss_splash_on_input,
-                advance_splash,
-                pulse_splash_cursor,
-            )
-                .chain(),
+            (dismiss_splash_on_input, advance_splash, pulse_splash_cursor).chain(),
         );
     }
 }
 
-/// Period of the trailing "▌ ready_" pulse cursor, in seconds. ~1 s
+/// Period of the trailing "| ready_" pulse cursor, in seconds. ~1 s
 /// reads as a comfortable terminal-blink cadence — much faster reads
 /// as urgent (alarming on a hold-and-fade screen), much slower reads
 /// as listless. Held as a `const` rather than a token because it's
@@ -157,7 +152,7 @@ struct SplashFadableBg {
     base_color: Color,
 }
 
-/// Marks the trailing pulse cursor on the "▌ ready_" line. Carries
+/// Marks the trailing pulse cursor on the "| ready_" line. Carries
 /// `SplashFadableBg` too so it picks up the global fade-in / hold /
 /// fade-out timeline; [`pulse_splash_cursor`] runs *after*
 /// [`advance_splash`] in the chain and overwrites the
@@ -325,11 +320,7 @@ fn build_scanline_image() -> Image {
     // because `TextureFormat::pixel_size()` returns a `Result` in this
     // Bevy version and a `debug_assert_eq!` shouldn't carry the
     // unwrap noise.
-    debug_assert_eq!(
-        pixels.len(),
-        16,
-        "scanline pixel buffer must be 2x2 RGBA8",
-    );
+    debug_assert_eq!(pixels.len(), 16, "scanline pixel buffer must be 2x2 RGBA8",);
     Image::new(
         Extent3d {
             width: 2,
@@ -376,13 +367,17 @@ fn spawn_header_section(parent: &mut ChildSpawnerCommands, font_handle: &Handle<
         })
         .with_children(|hdr| {
             hdr.spawn((
-                SplashFadable { base_color: ACCENT_PRIMARY },
-                Text::new("\u{258C}"), // ▌ — the Terminal cursor block.
+                SplashFadable {
+                    base_color: ACCENT_PRIMARY,
+                },
+                Text::new("|"), // ASCII terminal cursor.
                 cursor_font,
                 TextColor(transparent(ACCENT_PRIMARY)),
             ));
             hdr.spawn((
-                SplashFadable { base_color: TEXT_PRIMARY },
+                SplashFadable {
+                    base_color: TEXT_PRIMARY,
+                },
                 Text::new("Ferrous Solitaire"),
                 title_font,
                 TextColor(transparent(TEXT_PRIMARY)),
@@ -390,7 +385,9 @@ fn spawn_header_section(parent: &mut ChildSpawnerCommands, font_handle: &Handle<
             // Thin horizontal divider under the wordmark — same hue as
             // every other 1px chrome line in the design system.
             hdr.spawn((
-                SplashFadableBg { base_color: BORDER_SUBTLE },
+                SplashFadableBg {
+                    base_color: BORDER_SUBTLE,
+                },
                 Node {
                     width: Val::Px(192.0),
                     height: Val::Px(1.0),
@@ -399,7 +396,9 @@ fn spawn_header_section(parent: &mut ChildSpawnerCommands, font_handle: &Handle<
                 BackgroundColor(transparent(BORDER_SUBTLE)),
             ));
             hdr.spawn((
-                SplashFadable { base_color: TEXT_DISABLED },
+                SplashFadable {
+                    base_color: TEXT_DISABLED,
+                },
                 Text::new("TERMINAL EDITION"),
                 subtitle_font,
                 TextColor(transparent(TEXT_DISABLED)),
@@ -431,7 +430,7 @@ fn spawn_centre_section(parent: &mut ChildSpawnerCommands, font_handle: &Handle<
         });
 }
 
-/// Boot-log column: three lime check rows + a "▌ ready_" line. Content
+/// Boot-log column: three lime check rows + a "| ready_" line. Content
 /// is fixture text, not driven from real bootstrap state — the splash
 /// is a brand beat, not a real loader. Capped at 480 px width on
 /// desktop (the design-system spec calls 70 % of mobile viewport,
@@ -469,13 +468,17 @@ fn spawn_check_row(parent: &mut ChildSpawnerCommands, line_font: &TextFont, labe
         })
         .with_children(|row| {
             row.spawn((
-                SplashFadable { base_color: STATE_SUCCESS },
+                SplashFadable {
+                    base_color: STATE_SUCCESS,
+                },
                 Text::new("\u{2713}"), // ✓
                 line_font.clone(),
                 TextColor(transparent(STATE_SUCCESS)),
             ));
             row.spawn((
-                SplashFadable { base_color: TEXT_DISABLED },
+                SplashFadable {
+                    base_color: TEXT_DISABLED,
+                },
                 Text::new(label.to_string()),
                 line_font.clone(),
                 TextColor(transparent(TEXT_DISABLED)),
@@ -483,8 +486,8 @@ fn spawn_check_row(parent: &mut ChildSpawnerCommands, line_font: &TextFont, labe
         });
 }
 
-/// "▌ ready_" line — visual signature of "boot complete, awaiting
-/// input". The leading `▌` glyph picks up `TEXT_PRIMARY` rather than
+/// "| ready_" line — visual signature of "boot complete, awaiting
+/// input". The leading `|` glyph picks up `TEXT_PRIMARY` rather than
 /// `ACCENT_PRIMARY` so it doesn't compete with the big accent cursor in
 /// the header; the *trailing* 6×12 px accent pulse Node ([`SplashCursorPulse`])
 /// is what carries the "alive, blinking" signal called for by the
@@ -502,18 +505,22 @@ fn spawn_ready_row(parent: &mut ChildSpawnerCommands, line_font: &TextFont) {
         })
         .with_children(|row| {
             row.spawn((
-                SplashFadable { base_color: TEXT_PRIMARY },
-                Text::new("\u{258C} ready_"), // ▌ ready_
+                SplashFadable {
+                    base_color: TEXT_PRIMARY,
+                },
+                Text::new("| ready_"), // ASCII ready prompt.
                 line_font.clone(),
                 TextColor(transparent(TEXT_PRIMARY)),
             ));
             // Trailing 6×12 accent pulse cursor. Node-with-explicit-
-            // dimensions rather than a `█` text glyph so the size
+            // dimensions rather than a solid-block text glyph so the size
             // doesn't drift with the line font; matches the mockup's
             // 6×12 px spec literally. Pulse animation lives in
             // `pulse_splash_cursor` for testability.
             row.spawn((
-                SplashFadableBg { base_color: ACCENT_PRIMARY },
+                SplashFadableBg {
+                    base_color: ACCENT_PRIMARY,
+                },
                 SplashCursorPulse,
                 Node {
                     width: Val::Px(6.0),
@@ -542,7 +549,9 @@ fn spawn_progress_bar(parent: &mut ChildSpawnerCommands, line_font: &TextFont) {
         .with_children(|bar| {
             // Track.
             bar.spawn((
-                SplashFadableBg { base_color: BORDER_SUBTLE },
+                SplashFadableBg {
+                    base_color: BORDER_SUBTLE,
+                },
                 Node {
                     width: Val::Percent(100.0),
                     height: Val::Px(1.0),
@@ -553,7 +562,9 @@ fn spawn_progress_bar(parent: &mut ChildSpawnerCommands, line_font: &TextFont) {
             .with_children(|track| {
                 // Fill — 100 % of the track width = "complete".
                 track.spawn((
-                    SplashFadableBg { base_color: ACCENT_PRIMARY },
+                    SplashFadableBg {
+                        base_color: ACCENT_PRIMARY,
+                    },
                     Node {
                         width: Val::Percent(100.0),
                         height: Val::Percent(100.0),
@@ -570,7 +581,9 @@ fn spawn_progress_bar(parent: &mut ChildSpawnerCommands, line_font: &TextFont) {
             })
             .with_children(|caption| {
                 caption.spawn((
-                    SplashFadable { base_color: TEXT_DISABLED },
+                    SplashFadable {
+                        base_color: TEXT_DISABLED,
+                    },
                     Text::new("DONE \u{00B7} 247 ASSETS"), // DONE · 247 ASSETS
                     line_font.clone(),
                     TextColor(transparent(TEXT_DISABLED)),
@@ -598,14 +611,18 @@ fn spawn_footer_section(parent: &mut ChildSpawnerCommands, font_handle: &Handle<
         })
         .with_children(|footer| {
             footer.spawn((
-                SplashFadable { base_color: TEXT_DISABLED },
+                SplashFadable {
+                    base_color: TEXT_DISABLED,
+                },
                 Text::new("BASE16-EIGHTIES"),
                 footer_font.clone(),
                 TextColor(transparent(TEXT_DISABLED)),
             ));
             spawn_palette_swatch_row(footer);
             footer.spawn((
-                SplashFadable { base_color: TEXT_DISABLED },
+                SplashFadable {
+                    base_color: TEXT_DISABLED,
+                },
                 Text::new(format!("v{}", env!("CARGO_PKG_VERSION"))),
                 footer_font.clone(),
                 TextColor(transparent(TEXT_DISABLED)),
@@ -838,9 +855,8 @@ fn dismiss_splash_on_input(
     // Jump the age forward to the start of the fade-out so the
     // overlay dissolves cleanly. Saturating arithmetic on Duration
     // means an already-past-fade-out splash stays past fade-out.
-    let fade_out_start = Duration::from_secs_f32(
-        (MOTION_SPLASH_TOTAL_SECS - MOTION_SPLASH_FADE_SECS).max(0.0),
-    );
+    let fade_out_start =
+        Duration::from_secs_f32((MOTION_SPLASH_TOTAL_SECS - MOTION_SPLASH_FADE_SECS).max(0.0));
     for mut age in &mut roots {
         if age.0 < fade_out_start {
             age.0 = fade_out_start;
@@ -879,9 +895,9 @@ mod tests {
     /// Tells `TimePlugin` to advance the virtual clock by `secs` on the
     /// next `app.update()`. Mirrors the helper in `ui_tooltip::tests`.
     fn set_manual_time_step(app: &mut App, secs: f32) {
-        app.insert_resource(TimeUpdateStrategy::ManualDuration(
-            Duration::from_secs_f32(secs),
-        ));
+        app.insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_secs_f32(
+            secs,
+        )));
     }
 
     /// `Time<Virtual>` clamps per-tick deltas to `max_delta` (default
@@ -1056,9 +1072,8 @@ mod tests {
             "alpha mid-hold must be exactly 1.0"
         );
         // Inside fade-out.
-        let mid_fade_out = Duration::from_secs_f32(
-            MOTION_SPLASH_TOTAL_SECS - MOTION_SPLASH_FADE_SECS / 2.0,
-        );
+        let mid_fade_out =
+            Duration::from_secs_f32(MOTION_SPLASH_TOTAL_SECS - MOTION_SPLASH_FADE_SECS / 2.0);
         let mid_out_alpha = splash_alpha(mid_fade_out).unwrap();
         assert!(
             mid_out_alpha < 0.6 && mid_out_alpha > 0.4,
@@ -1097,9 +1112,8 @@ mod tests {
             .next()
             .expect("splash should exist after one post-dismiss tick")
             .0;
-        let fade_out_start = Duration::from_secs_f32(
-            MOTION_SPLASH_TOTAL_SECS - MOTION_SPLASH_FADE_SECS,
-        );
+        let fade_out_start =
+            Duration::from_secs_f32(MOTION_SPLASH_TOTAL_SECS - MOTION_SPLASH_FADE_SECS);
         assert!(
             age >= fade_out_start,
             "after a keypress dismiss the splash must be in fade-out (age >= {fade_out_start:?}); got {age:?}"
@@ -1127,9 +1141,8 @@ mod tests {
             .next()
             .expect("splash should exist after one post-dismiss tick")
             .0;
-        let fade_out_start = Duration::from_secs_f32(
-            MOTION_SPLASH_TOTAL_SECS - MOTION_SPLASH_FADE_SECS,
-        );
+        let fade_out_start =
+            Duration::from_secs_f32(MOTION_SPLASH_TOTAL_SECS - MOTION_SPLASH_FADE_SECS);
         assert!(
             age >= fade_out_start,
             "after a left-click dismiss the splash must be in fade-out; got {age:?}"
@@ -1166,8 +1179,8 @@ mod tests {
             .map(|t| t.0.clone())
             .collect();
         assert!(
-            texts.iter().any(|t| t == "\u{258C}"),
-            "expected the cursor block (▌) on the splash, got: {texts:?}"
+            texts.iter().any(|t| t == "|"),
+            "expected the ASCII cursor (|) on the splash, got: {texts:?}"
         );
         assert!(
             texts.iter().any(|t| t == "Ferrous Solitaire"),
@@ -1320,11 +1333,7 @@ mod tests {
         );
 
         // Trough — sin(TAU * 0.75) = -1 → normalised = 0 → factor = min.
-        let trough = cursor_pulse_factor(
-            Duration::from_secs_f32(period * 3.0 / 4.0),
-            period,
-            min,
-        );
+        let trough = cursor_pulse_factor(Duration::from_secs_f32(period * 3.0 / 4.0), period, min);
         assert!(
             (trough - min).abs() < 1e-5,
             "trough should fall to min ({min}); got {trough}"

solitaire_engine/src/stats_plugin.rs

@@ -8,12 +8,12 @@
 
 use std::path::PathBuf;
 
-use bevy::input::mouse::{MouseScrollUnit, MouseWheel};
 use bevy::input::ButtonInput;
+use bevy::input::mouse::{MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
 use solitaire_data::{
-    load_replay_history_from, load_stats_from, replay_history_path, save_stats_to,
-    stats_file_path, PlayerProgress, Replay, ReplayHistory, StatsExt, StatsSnapshot, WEEKLY_GOALS,
+    PlayerProgress, Replay, ReplayHistory, StatsExt, StatsSnapshot, WEEKLY_GOALS,
+    load_replay_history_from, load_stats_from, replay_history_path, save_stats_to, stats_file_path,
 };
 
 use crate::auto_complete_plugin::AutoCompleteState;
@@ -22,21 +22,20 @@ use crate::events::{
     ForfeitEvent, GameWonEvent, InfoToastEvent, NewGameRequestEvent, ToggleStatsRequestEvent,
     WinStreakMilestoneEvent,
 };
+use crate::font_plugin::FontResource;
 use crate::game_plugin::GameMutation;
 use crate::platform::ClipboardBackendResource;
 use crate::progress_plugin::ProgressResource;
-use crate::font_plugin::FontResource;
 use crate::resources::GameStateResource;
 use crate::time_attack_plugin::TimeAttackResource;
 use crate::ui_modal::{
-    spawn_modal, spawn_modal_actions, spawn_modal_button, spawn_modal_header, ButtonVariant,
-    ModalButton, ScrimDismissible,
+    ButtonVariant, ModalButton, ScrimDismissible, spawn_modal, spawn_modal_actions,
+    spawn_modal_button, spawn_modal_header,
 };
 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, Z_MODAL_PANEL,
 };
 
 /// Bevy resource wrapping the current stats.
@@ -211,10 +210,7 @@ impl Plugin for StatsPlugin {
             // constraints (win_summary_plugin: cache_win_data.before(StatsUpdate)),
             // and a system cannot be both inside a set and individually before a
             // set-level ordering constraint.
-            .add_systems(
-                Update,
-                update_stats_on_new_game.before(GameMutation),
-            )
+            .add_systems(Update, update_stats_on_new_game.before(GameMutation))
             .add_systems(
                 Update,
                 update_stats_on_win.after(GameMutation).in_set(StatsUpdate),
@@ -231,10 +227,7 @@ impl Plugin for StatsPlugin {
             )
             .add_systems(Update, toggle_stats_screen.after(GameMutation))
             .add_systems(Update, handle_stats_close_button)
-            .add_systems(
-                Update,
-                refresh_replay_history_on_win.after(GameMutation),
-            )
+            .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)
             .add_systems(
@@ -247,7 +240,10 @@ impl Plugin for StatsPlugin {
                     .chain(),
             )
             .add_systems(Update, scroll_stats_panel)
-            .add_systems(Update, crate::ui_modal::touch_scroll_panel::<StatsScrollable>);
+            .add_systems(
+                Update,
+                crate::ui_modal::touch_scroll_panel::<StatsScrollable>,
+            );
     }
 }
 
@@ -289,9 +285,11 @@ fn refresh_replay_history_on_win(
     path: Res<LatestReplayPath>,
 ) {
     // Only re-load when at least one win actually fired.
-    if wins.read().next().is_none() {
+    let mut win_events = wins.read();
+    if win_events.next().is_none() {
         return;
     }
+    win_events.for_each(|_| {});
     let Some(p) = path.0.as_deref() else {
         return;
     };
@@ -415,7 +413,11 @@ fn handle_replay_selector_buttons(
     if prev_pressed {
         // Step toward older replays — wrap to the oldest when at the
         // newest (index 0).
-        selected.0 = if selected.0 == 0 { len - 1 } else { selected.0 - 1 };
+        selected.0 = if selected.0 == 0 {
+            len - 1
+        } else {
+            selected.0 - 1
+        };
     }
     if next_pressed {
         // Step toward more recent replays — wrap to the newest when at
@@ -523,31 +525,33 @@ fn update_stats_on_win(
     mut milestone: MessageWriter<WinStreakMilestoneEvent>,
     mut toast: MessageWriter<InfoToastEvent>,
 ) {
-    for ev in events.read() {
-        let prev_streak = stats.0.win_streak_current;
-        stats
-            .0
-            .update_on_win(ev.score, ev.time_seconds, &game.0.draw_mode);
-        // Per-mode best score / fastest win — additive on top of the
-        // lifetime totals tracked by `update_on_win`. TimeAttack is a
-        // no-op inside the helper because it has its own session-level
-        // scoring model.
-        stats
-            .0
-            .update_per_mode_bests(ev.score, ev.time_seconds, game.0.mode);
-        let new_streak = stats.0.win_streak_current;
-        // Fire the streak-milestone event only on the threshold
-        // crossing — `prev < threshold && new >= threshold`. This
-        // guarantees the flourish never retriggers at every win past
-        // the highest milestone.
-        if let Some(crossed) = streak_milestone_crossed(prev_streak, new_streak) {
-            milestone.write(WinStreakMilestoneEvent { streak: crossed });
-            toast.write(InfoToastEvent(format!(
-                "Win streak: {crossed}! \u{1F525}"
-            )));
-        }
-        persist(&path, &stats.0, "win");
+    let mut win_events = events.read();
+    let Some(ev) = win_events.next() else {
+        return;
+    };
+    win_events.for_each(|_| {});
+
+    let prev_streak = stats.0.win_streak_current;
+    stats
+        .0
+        .update_on_win(ev.score, ev.time_seconds, &game.0.draw_mode);
+    // Per-mode best score / fastest win — additive on top of the
+    // lifetime totals tracked by `update_on_win`. TimeAttack is a
+    // no-op inside the helper because it has its own session-level
+    // scoring model.
+    stats
+        .0
+        .update_per_mode_bests(ev.score, ev.time_seconds, game.0.mode);
+    let new_streak = stats.0.win_streak_current;
+    // Fire the streak-milestone event only on the threshold
+    // crossing — `prev < threshold && new >= threshold`. This
+    // guarantees the flourish never retriggers at every win past
+    // the highest milestone.
+    if let Some(crossed) = streak_milestone_crossed(prev_streak, new_streak) {
+        milestone.write(WinStreakMilestoneEvent { streak: crossed });
+        toast.write(InfoToastEvent(format!("Win streak: {crossed}! \u{1F525}")));
     }
+    persist(&path, &stats.0, "win");
 }
 
 /// Returns the milestone value that the player just crossed, if any.
@@ -695,14 +699,46 @@ fn spawn_stats_screen(
     // mix of "0" counters and "—" sentinels (which feels buggy).
     let is_first_launch = stats.games_played == 0;
     let dash = "\u{2014}".to_string();
-    let win_rate_str    = if is_first_launch { dash.clone() } else { format_win_rate(stats) };
-    let played_str      = if is_first_launch { dash.clone() } else { format_stat_value(stats.games_played) };
-    let won_str         = if is_first_launch { dash.clone() } else { format_stat_value(stats.games_won) };
-    let lost_str        = if is_first_launch { dash.clone() } else { format_stat_value(stats.games_lost) };
-    let fastest_str     = if is_first_launch { dash.clone() } else { format_fastest_win(stats.fastest_win_seconds) };
-    let avg_time_str    = if is_first_launch { dash.clone() } else { format_avg_time(stats) };
-    let best_score_str  = if is_first_launch { dash.clone() } else { format_optional_u32(stats.best_single_score) };
-    let best_streak_str = if is_first_launch { dash.clone() } else { format_stat_value(stats.win_streak_best) };
+    let win_rate_str = if is_first_launch {
+        dash.clone()
+    } else {
+        format_win_rate(stats)
+    };
+    let played_str = if is_first_launch {
+        dash.clone()
+    } else {
+        format_stat_value(stats.games_played)
+    };
+    let won_str = if is_first_launch {
+        dash.clone()
+    } else {
+        format_stat_value(stats.games_won)
+    };
+    let lost_str = if is_first_launch {
+        dash.clone()
+    } else {
+        format_stat_value(stats.games_lost)
+    };
+    let fastest_str = if is_first_launch {
+        dash.clone()
+    } else {
+        format_fastest_win(stats.fastest_win_seconds)
+    };
+    let avg_time_str = if is_first_launch {
+        dash.clone()
+    } else {
+        format_avg_time(stats)
+    };
+    let best_score_str = if is_first_launch {
+        dash.clone()
+    } else {
+        format_optional_u32(stats.best_single_score)
+    };
+    let best_streak_str = if is_first_launch {
+        dash.clone()
+    } else {
+        format_stat_value(stats.win_streak_best)
+    };
 
     let font_handle = font_res.map(|f| f.0.clone()).unwrap_or_default();
     let font_section = TextFont {
@@ -771,13 +807,13 @@ fn spawn_stats_screen(
                 ..default()
             })
             .with_children(|grid| {
-                spawn_stat_cell(grid, &win_rate_str,    "Win Rate");
-                spawn_stat_cell(grid, &played_str,      "Games Played");
-                spawn_stat_cell(grid, &won_str,         "Games Won");
-                spawn_stat_cell(grid, &lost_str,        "Games Lost");
-                spawn_stat_cell(grid, &fastest_str,     "Fastest Win");
-                spawn_stat_cell(grid, &avg_time_str,    "Avg Time");
-                spawn_stat_cell(grid, &best_score_str,  "Best Score");
+                spawn_stat_cell(grid, &win_rate_str, "Win Rate");
+                spawn_stat_cell(grid, &played_str, "Games Played");
+                spawn_stat_cell(grid, &won_str, "Games Won");
+                spawn_stat_cell(grid, &lost_str, "Games Lost");
+                spawn_stat_cell(grid, &fastest_str, "Fastest Win");
+                spawn_stat_cell(grid, &avg_time_str, "Avg Time");
+                spawn_stat_cell(grid, &best_score_str, "Best Score");
                 spawn_stat_cell(grid, &best_streak_str, "Best Streak");
             });
 
@@ -829,10 +865,10 @@ fn spawn_stats_screen(
                     TextColor(STATE_INFO),
                 ));
 
-                let level_str     = format_stat_value(p.level);
-                let xp_str        = format_stat_value(p.total_xp as u32);
-                let next_label    = xp_to_next_level_label(p.total_xp, p.level);
-                let daily_str     = format_stat_value(p.daily_challenge_streak);
+                let level_str = format_stat_value(p.level);
+                let xp_str = format_stat_value(p.total_xp as u32);
+                let next_label = xp_to_next_level_label(p.total_xp, p.level);
+                let daily_str = format_stat_value(p.daily_challenge_streak);
                 let challenge_str = challenge_progress_label(p.challenge_index);
 
                 body.spawn(Node {
@@ -846,10 +882,10 @@ fn spawn_stats_screen(
                     ..default()
                 })
                 .with_children(|grid| {
-                    spawn_stat_cell(grid, &level_str,     "Level");
-                    spawn_stat_cell(grid, &xp_str,        "Total XP");
-                    spawn_stat_cell(grid, &next_label,    "Next Level");
-                    spawn_stat_cell(grid, &daily_str,     "Daily Streak");
+                    spawn_stat_cell(grid, &level_str, "Level");
+                    spawn_stat_cell(grid, &xp_str, "Total XP");
+                    spawn_stat_cell(grid, &next_label, "Next Level");
+                    spawn_stat_cell(grid, &daily_str, "Daily Streak");
                     spawn_stat_cell(grid, &challenge_str, "Challenge");
                 });
 
@@ -882,18 +918,19 @@ fn spawn_stats_screen(
 
             // --- Time Attack section ---
             if let Some(ta) = time_attack
-                && ta.active {
-                    let mins = (ta.remaining_secs / 60.0).floor() as u64;
-                    let secs = (ta.remaining_secs % 60.0).floor() as u64;
-                    body.spawn((
-                        Text::new(format!(
-                            "Time Attack \u{2014} {mins}m {secs:02}s left  |  Wins: {}",
-                            ta.wins
-                        )),
-                        font_section.clone(),
-                        TextColor(STATE_WARNING),
-                    ));
-                }
+                && ta.active
+            {
+                let mins = (ta.remaining_secs / 60.0).floor() as u64;
+                let secs = (ta.remaining_secs % 60.0).floor() as u64;
+                body.spawn((
+                    Text::new(format!(
+                        "Time Attack \u{2014} {mins}m {secs:02}s left  |  Wins: {}",
+                        ta.wins
+                    )),
+                    font_section.clone(),
+                    TextColor(STATE_WARNING),
+                ));
+            }
 
             // --- Replay selector ---
             // Prev / Next chips step through the full replay history;
@@ -1197,7 +1234,11 @@ fn xp_to_next_level_label(total_xp: u64, level: u32) -> String {
     };
     let span = xp_next - xp_current;
     let done = total_xp.saturating_sub(xp_current).min(span);
-    let pct = if span == 0 { 100 } else { done.saturating_mul(100).checked_div(span).unwrap_or(100) };
+    let pct = if span == 0 {
+        100
+    } else {
+        done.saturating_mul(100).checked_div(span).unwrap_or(100)
+    };
     let remaining = span - done;
     format!("{remaining} XP ({pct}%)")
 }
@@ -1291,8 +1332,34 @@ mod tests {
         app.update();
 
         let stats = &app.world().resource::<StatsResource>().0;
-        assert_eq!(stats.draw_three_wins, 1, "draw_three_wins must increment for DrawThree mode");
-        assert_eq!(stats.draw_one_wins, 0, "draw_one_wins must not increment for DrawThree mode");
+        assert_eq!(
+            stats.draw_three_wins, 1,
+            "draw_three_wins must increment for DrawThree mode"
+        );
+        assert_eq!(
+            stats.draw_one_wins, 0,
+            "draw_one_wins must not increment for DrawThree mode"
+        );
+    }
+
+    #[test]
+    fn multiple_win_events_in_one_frame_increment_once() {
+        let mut app = headless_app();
+        app.world_mut().write_message(GameWonEvent {
+            score: 1000,
+            time_seconds: 120,
+        });
+        app.world_mut().write_message(GameWonEvent {
+            score: 1500,
+            time_seconds: 90,
+        });
+        app.update();
+
+        let stats = &app.world().resource::<StatsResource>().0;
+        assert_eq!(stats.games_won, 1);
+        assert_eq!(stats.games_played, 1);
+        assert_eq!(stats.best_single_score, 1000);
+        assert_eq!(stats.fastest_win_seconds, 120);
     }
 
     #[test]
@@ -1304,8 +1371,11 @@ mod tests {
             .0
             .move_count = 3;
 
-        app.world_mut()
-            .write_message(NewGameRequestEvent { seed: Some(999), mode: None, confirmed: false });
+        app.world_mut().write_message(NewGameRequestEvent {
+            seed: Some(999),
+            mode: None,
+            confirmed: false,
+        });
         app.update();
 
         let stats = &app.world().resource::<StatsResource>().0;
@@ -1317,8 +1387,11 @@ mod tests {
     #[test]
     fn new_game_without_moves_does_not_record_abandoned() {
         let mut app = headless_app();
-        app.world_mut()
-            .write_message(NewGameRequestEvent { seed: Some(42), mode: None, confirmed: false });
+        app.world_mut().write_message(NewGameRequestEvent {
+            seed: Some(42),
+            mode: None,
+            confirmed: false,
+        });
         app.update();
 
         let stats = &app.world().resource::<StatsResource>().0;
@@ -1629,10 +1702,7 @@ mod tests {
 
         let events = app.world().resource::<Messages<InfoToastEvent>>();
         let mut reader = events.get_cursor();
-        let messages: Vec<&str> = reader
-            .read(events)
-            .map(|e| e.0.as_str())
-            .collect();
+        let messages: Vec<&str> = reader.read(events).map(|e| e.0.as_str()).collect();
 
         assert!(
             messages.contains(&"Streak of 3 broken!"),
@@ -1658,10 +1728,7 @@ mod tests {
 
         let events = app.world().resource::<Messages<InfoToastEvent>>();
         let mut reader = events.get_cursor();
-        let messages: Vec<&str> = reader
-            .read(events)
-            .map(|e| e.0.as_str())
-            .collect();
+        let messages: Vec<&str> = reader.read(events).map(|e| e.0.as_str()).collect();
 
         assert!(
             !messages.iter().any(|m| m.contains("broken")),
@@ -1820,8 +1887,7 @@ mod tests {
         let texts: Vec<String> = q.iter(app.world()).map(|t| t.0.clone()).collect();
         assert_eq!(texts.len(), 1);
         assert_eq!(
-            texts[0],
-            "Replay 1 / 1",
+            texts[0], "Replay 1 / 1",
             "caption must show '1 / 1' for a single-replay history"
         );
     }

solitaire_engine/src/sync_plugin.rs

@@ -14,15 +14,15 @@
 use std::sync::Arc;
 
 use bevy::prelude::*;
-use bevy::tasks::{futures_lite::future, AsyncComputeTaskPool, Task};
+use bevy::tasks::{AsyncComputeTaskPool, Task, futures_lite::future};
 use chrono::Utc;
 use uuid::Uuid;
 
 use solitaire_data::{
-    save_achievements_to, save_progress_to, save_replay_history_to, save_stats_to,
     AchievementRecord, PlayerProgress, Replay, StatsSnapshot, SyncError, SyncProvider,
+    save_achievements_to, save_progress_to, save_replay_history_to, save_stats_to,
 };
-use solitaire_sync::{merge, SyncPayload, SyncResponse};
+use solitaire_sync::{SyncPayload, SyncResponse, merge};
 
 use crate::achievement_plugin::{AchievementsResource, AchievementsStoragePath};
 use crate::events::{
@@ -32,7 +32,9 @@ use crate::events::{
 use crate::game_plugin::RecordingReplay;
 use crate::progress_plugin::{ProgressResource, ProgressStoragePath};
 use crate::resources::{GameStateResource, SyncStatus, SyncStatusResource, TokioRuntimeResource};
-use crate::stats_plugin::{LatestReplayPath, ReplayHistoryResource, StatsResource, StatsStoragePath};
+use crate::stats_plugin::{
+    LatestReplayPath, ReplayHistoryResource, StatsResource, StatsStoragePath,
+};
 
 // ---------------------------------------------------------------------------
 // Public resources
@@ -148,9 +150,7 @@ fn start_pull(
 ) {
     let provider = provider.0.clone();
     let rt = rt.0.clone();
-    let task = AsyncComputeTaskPool::get().spawn(async move {
-        rt.block_on(provider.pull())
-    });
+    let task = AsyncComputeTaskPool::get().spawn(async move { rt.block_on(provider.pull()) });
     task_res.0 = Some(task);
     status.0 = SyncStatus::Syncing;
 }
@@ -173,9 +173,7 @@ fn handle_manual_sync_request(
     }
     let provider = provider.0.clone();
     let rt = rt.0.clone();
-    let task = AsyncComputeTaskPool::get().spawn(async move {
-        rt.block_on(provider.pull())
-    });
+    let task = AsyncComputeTaskPool::get().spawn(async move { rt.block_on(provider.pull()) });
     task_res.0 = Some(task);
     status.0 = SyncStatus::Syncing;
 }
@@ -219,17 +217,20 @@ fn poll_pull_result(
 
             // Persist merged state atomically.
             if let Some(p) = &stats_path.0
-                && let Err(e) = save_stats_to(p, &merged.stats) {
-                    warn!("sync: failed to persist stats: {e}");
-                }
+                && let Err(e) = save_stats_to(p, &merged.stats)
+            {
+                warn!("sync: failed to persist stats: {e}");
+            }
             if let Some(p) = &achievements_path.0
-                && let Err(e) = save_achievements_to(p, &merged.achievements) {
-                    warn!("sync: failed to persist achievements: {e}");
-                }
+                && let Err(e) = save_achievements_to(p, &merged.achievements)
+            {
+                warn!("sync: failed to persist achievements: {e}");
+            }
             if let Some(p) = &progress_path.0
-                && let Err(e) = save_progress_to(p, &merged.progress) {
-                    warn!("sync: failed to persist progress: {e}");
-                }
+                && let Err(e) = save_progress_to(p, &merged.progress)
+            {
+                warn!("sync: failed to persist progress: {e}");
+            }
 
             // Update in-world resources.
             let now = Utc::now();
@@ -342,9 +343,8 @@ fn push_replay_on_win(
         );
         let provider = provider.0.clone();
         let rt = rt.0.clone();
-        let task = AsyncComputeTaskPool::get().spawn(async move {
-            rt.block_on(provider.push_replay(&replay))
-        });
+        let task = AsyncComputeTaskPool::get()
+            .spawn(async move { rt.block_on(provider.push_replay(&replay)) });
         // If a previous upload is still in flight, drop it — the most
         // recent win is the one whose share link the player will care
         // about. Bevy's `Task` Drop cancels cooperatively.
@@ -520,10 +520,7 @@ mod tests {
         // Status is either Syncing (task still running) or LastSynced (resolved).
         let status = &app.world().resource::<SyncStatusResource>().0;
         assert!(
-            matches!(
-                status,
-                SyncStatus::Syncing | SyncStatus::LastSynced(_)
-            ),
+            matches!(status, SyncStatus::Syncing | SyncStatus::LastSynced(_)),
             "status should be Syncing or LastSynced, got {status:?}"
         );
     }
@@ -539,8 +536,7 @@ mod tests {
         // mirrors the auto-save flake fix and turns this test from
         // "pass on a fast machine" into "pass on any machine that
         // makes meaningful progress".
-        let deadline =
-            std::time::Instant::now() + std::time::Duration::from_secs(5);
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
         loop {
             app.update();
             if matches!(
@@ -565,8 +561,7 @@ mod tests {
     fn pull_failure_fires_warning_toast() {
         use bevy::ecs::message::Messages;
         let mut app = headless_app_with(FailingProvider);
-        let deadline =
-            std::time::Instant::now() + std::time::Duration::from_secs(5);
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
         loop {
             app.update();
             if matches!(
@@ -590,17 +585,16 @@ mod tests {
 
     #[test]
     fn build_payload_sets_nil_user_id() {
-        let payload = build_payload(
-            &StatsSnapshot::default(),
-            &[],
-            &PlayerProgress::default(),
-        );
+        let payload = build_payload(&StatsSnapshot::default(), &[], &PlayerProgress::default());
         assert_eq!(payload.user_id, Uuid::nil());
     }
 
     #[test]
     fn build_payload_clones_stats() {
-        let stats = StatsSnapshot { games_played: 42, ..Default::default() };
+        let stats = StatsSnapshot {
+            games_played: 42,
+            ..Default::default()
+        };
         let payload = build_payload(&stats, &[], &PlayerProgress::default());
         assert_eq!(payload.stats.games_played, 42);
     }
@@ -615,12 +609,11 @@ mod tests {
     fn upload_result_writes_share_url_into_replay_and_persists() {
         use solitaire_core::game_state::{DrawMode, GameMode};
         use solitaire_data::{
-            load_replay_history_from, save_replay_history_to, Replay, ReplayHistory,
+            Replay, ReplayHistory, load_replay_history_from, save_replay_history_to,
         };
 
         let mut app = headless_app_with(NoOpProvider);
-        let path = std::env::temp_dir()
-            .join("solitaire_test_replay_share_url_persist.json");
+        let path = std::env::temp_dir().join("solitaire_test_replay_share_url_persist.json");
         let _ = std::fs::remove_file(&path);
 
         // Seed the in-memory history with a single replay carrying no
@@ -649,9 +642,7 @@ mod tests {
             let url = url.clone();
             async move { Ok::<String, SyncError>(url) }
         });
-        app.world_mut()
-            .resource_mut::<PendingReplayUpload>()
-            .0 = Some(task);
+        app.world_mut().resource_mut::<PendingReplayUpload>().0 = Some(task);
 
         // Pump frames until the polling system observes the task as
         // ready and clears `PendingReplayUpload`.

solitaire_engine/src/sync_setup_plugin.rs

@@ -37,13 +37,13 @@ use std::sync::Arc;
 use bevy::input::ButtonState;
 use bevy::input::keyboard::KeyboardInput;
 use bevy::prelude::*;
-use bevy::tasks::{futures_lite::future, AsyncComputeTaskPool, Task};
+use bevy::tasks::{AsyncComputeTaskPool, Task, futures_lite::future};
 use solitaire_data::{
-    auth_tokens::{delete_tokens, store_tokens},
-    settings::SyncBackend,
-    save_settings_to,
-    sync_client::{LocalOnlyProvider, SolitaireServerClient},
     SyncError,
+    auth_tokens::{delete_tokens, store_tokens},
+    save_settings_to,
+    settings::SyncBackend,
+    sync_client::{LocalOnlyProvider, SolitaireServerClient},
 };
 
 use crate::avatar_plugin::AvatarFetchEvent;
@@ -53,15 +53,16 @@ use crate::events::{
 };
 use crate::font_plugin::FontResource;
 use crate::platform::SHOW_KEYBOARD_ACCELERATORS;
-use crate::settings_plugin::{SettingsPanel, SettingsResource, SettingsScreen, SettingsStoragePath};
 use crate::resources::TokioRuntimeResource;
+use crate::settings_plugin::{
+    SettingsPanel, SettingsResource, SettingsScreen, SettingsStoragePath,
+};
 use crate::sync_plugin::SyncProviderResource;
-use crate::ui_modal::{spawn_modal, ModalScrim};
+use crate::ui_modal::{ModalScrim, spawn_modal};
 use crate::ui_theme::{
-    ACCENT_PRIMARY, BG_ELEVATED, BG_ELEVATED_HI,
-    BORDER_SUBTLE, HighContrastBorder, RADIUS_SM, STATE_DANGER, TEXT_DISABLED,
-    TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY, TYPE_BODY_LG, TYPE_CAPTION, VAL_SPACE_2, VAL_SPACE_3,
-    VAL_SPACE_4, Z_MODAL_PANEL,
+    ACCENT_PRIMARY, BG_ELEVATED, BG_ELEVATED_HI, BORDER_SUBTLE, HighContrastBorder, RADIUS_SM,
+    STATE_DANGER, TEXT_DISABLED, TEXT_PRIMARY, TEXT_SECONDARY, TYPE_BODY, TYPE_BODY_LG,
+    TYPE_CAPTION, VAL_SPACE_2, VAL_SPACE_3, VAL_SPACE_4, Z_MODAL_PANEL,
 };
 
 // ---------------------------------------------------------------------------
@@ -213,7 +214,14 @@ fn open_sync_setup_modal(
     // Exclude SettingsPanel: the Connect button closes settings in the same
     // frame it fires SyncConfigureRequestEvent, but Bevy despawns are deferred
     // so the settings scrim still exists in the world during this system.
-    other_modal_scrims: Query<(), (With<ModalScrim>, Without<SyncSetupScreen>, Without<SettingsPanel>)>,
+    other_modal_scrims: Query<
+        (),
+        (
+            With<ModalScrim>,
+            Without<SyncSetupScreen>,
+            Without<SettingsPanel>,
+        ),
+    >,
     mut commands: Commands,
     mut focused: ResMut<SyncFocusedField>,
     font_res: Option<Res<FontResource>>,
@@ -237,7 +245,12 @@ fn handle_text_input(
     screen: Query<(), With<SyncSetupScreen>>,
     mut key_events: MessageReader<KeyboardInput>,
     mut focused: ResMut<SyncFocusedField>,
-    mut fields: Query<(&SyncFieldKind, &mut SyncFieldBuffer, &mut Text, &mut TextColor)>,
+    mut fields: Query<(
+        &SyncFieldKind,
+        &mut SyncFieldBuffer,
+        &mut Text,
+        &mut TextColor,
+    )>,
     pending: Res<PendingAuthTask>,
 ) {
     if screen.is_empty() || pending.task.is_some() {
@@ -316,12 +329,8 @@ fn handle_auth_button(
     mut error_nodes: Query<(&mut Text, &mut TextColor), With<SyncAuthError>>,
     mut busy_nodes: Query<&mut Visibility, With<SyncBusyOverlay>>,
 ) {
-    let login_clicked = login_q
-        .iter()
-        .any(|i| *i == Interaction::Pressed);
-    let register_clicked = register_q
-        .iter()
-        .any(|i| *i == Interaction::Pressed);
+    let login_clicked = login_q.iter().any(|i| *i == Interaction::Pressed);
+    let register_clicked = register_q.iter().any(|i| *i == Interaction::Pressed);
 
     if !login_clicked && !register_clicked {
         return;
@@ -505,8 +514,8 @@ fn handle_cancel(
     screen: Query<Entity, With<SyncSetupScreen>>,
     mut commands: Commands,
 ) {
-    let cancelled = cancel_q.iter().any(|i| *i == Interaction::Pressed)
-        || keys.just_pressed(KeyCode::Escape);
+    let cancelled =
+        cancel_q.iter().any(|i| *i == Interaction::Pressed) || keys.just_pressed(KeyCode::Escape);
     if !cancelled || screen.is_empty() {
         return;
     }
@@ -582,8 +591,8 @@ fn handle_delete_cancel(
     screen: Query<Entity, With<DeleteConfirmScreen>>,
     mut commands: Commands,
 ) {
-    let cancelled = cancel_q.iter().any(|i| *i == Interaction::Pressed)
-        || keys.just_pressed(KeyCode::Escape);
+    let cancelled =
+        cancel_q.iter().any(|i| *i == Interaction::Pressed) || keys.just_pressed(KeyCode::Escape);
     if !cancelled || screen.is_empty() {
         return;
     }
@@ -610,9 +619,9 @@ fn handle_delete_confirm(
     }
     let provider = provider.0.clone();
     let rt = rt.0.clone();
-    pending.0 = Some(AsyncComputeTaskPool::get().spawn(async move {
-        rt.block_on(provider.delete_account())
-    }));
+    pending.0 = Some(
+        AsyncComputeTaskPool::get().spawn(async move { rt.block_on(provider.delete_account()) }),
+    );
 }
 
 /// Polls the in-flight delete-account task. On success fires `SyncLogoutRequestEvent`.
@@ -677,7 +686,7 @@ fn spawn_sync_setup_modal(commands: &mut Commands, font_res: Option<&FontResourc
                 SyncFieldKind::Url,
                 "Server URL",
                 "https://your-server.example.com",
-                true,   // focused initially
+                true, // focused initially
                 font_res,
             );
             spawn_field(
@@ -783,7 +792,11 @@ fn spawn_field(
                     ..default()
                 },
                 BackgroundColor(BG_ELEVATED),
-                BorderColor::all(if focused { ACCENT_PRIMARY } else { BORDER_SUBTLE }),
+                BorderColor::all(if focused {
+                    ACCENT_PRIMARY
+                } else {
+                    BORDER_SUBTLE
+                }),
                 HighContrastBorder::with_default(BORDER_SUBTLE),
             ))
             .with_children(|border| {
@@ -806,7 +819,11 @@ fn spawn_action_button<M: Component>(
     primary: bool,
     font_res: Option<&FontResource>,
 ) {
-    let bg = if primary { ACCENT_PRIMARY } else { BG_ELEVATED_HI };
+    let bg = if primary {
+        ACCENT_PRIMARY
+    } else {
+        BG_ELEVATED_HI
+    };
     let fg = TEXT_PRIMARY;
     parent
         .spawn((
@@ -820,7 +837,11 @@ fn spawn_action_button<M: Component>(
                 ..default()
             },
             BackgroundColor(bg),
-            BorderColor::all(if primary { ACCENT_PRIMARY } else { BORDER_SUBTLE }),
+            BorderColor::all(if primary {
+                ACCENT_PRIMARY
+            } else {
+                BORDER_SUBTLE
+            }),
         ))
         .with_children(|b| {
             b.spawn((

solitaire_engine/src/table_plugin.rs

@@ -11,11 +11,11 @@ use solitaire_core::pile::PileType;
 
 use crate::events::{HintVisualEvent, StateChangedEvent};
 use crate::hud_plugin::HudVisibility;
-use crate::layout::{compute_layout, Layout, LayoutResource, LayoutSystem};
-use crate::safe_area::SafeAreaInsets;
-use crate::resources::GameStateResource;
 #[cfg(test)]
 use crate::layout::TABLE_COLOUR;
+use crate::layout::{Layout, LayoutResource, LayoutSystem, compute_layout};
+use crate::resources::GameStateResource;
+use crate::safe_area::SafeAreaInsets;
 use crate::settings_plugin::{SettingsChangedEvent, SettingsResource};
 use crate::ui_theme::TEXT_PRIMARY;
 #[cfg(test)]
@@ -101,7 +101,9 @@ fn load_background_images(asset_server: Option<Res<AssetServer>>, mut commands:
     let Some(asset_server) = asset_server else {
         // AssetServer absent (e.g. MinimalPlugins in tests) — insert an
         // empty set so setup_table can proceed using a default handle.
-        commands.insert_resource(BackgroundImageSet { handles: Vec::new() });
+        commands.insert_resource(BackgroundImageSet {
+            handles: Vec::new(),
+        });
         return;
     };
     let handles = (0..5)
@@ -118,8 +120,8 @@ fn load_background_images(asset_server: Option<Res<AssetServer>>, mut commands:
 fn theme_colour(theme: &Theme) -> Color {
     match theme {
         Theme::Green => Color::srgb(TABLE_COLOUR[0], TABLE_COLOUR[1], TABLE_COLOUR[2]),
-        Theme::Blue  => Color::srgb(0.059, 0.196, 0.322),
-        Theme::Dark  => Color::srgb(0.08, 0.08, 0.10),
+        Theme::Blue => Color::srgb(0.059, 0.196, 0.322),
+        Theme::Dark => Color::srgb(0.08, 0.08, 0.10),
     }
 }
 
@@ -171,10 +173,12 @@ fn setup_table(
         ));
     }
 
-    let (window_size, scale) = windows.iter().next().map_or(
-        (Vec2::new(1280.0, 800.0), 1.0f32),
-        |w| (default_window_size(w), w.scale_factor()),
-    );
+    let (window_size, scale) = windows
+        .iter()
+        .next()
+        .map_or((Vec2::new(1280.0, 800.0), 1.0f32), |w| {
+            (default_window_size(w), w.scale_factor())
+        });
     // Safe-area insets arrive from JNI asynchronously; they are almost always
     // 0 here (populated ~frame 2-3). on_safe_area_changed fires when they
     // arrive and issues a synthetic WindowResized to re-snap all game objects.
@@ -249,10 +253,10 @@ fn apply_theme_on_settings_change(
 /// Matches the same ASCII convention used by `CardPlugin` for card labels.
 pub fn suit_symbol(suit: &Suit) -> &'static str {
     match suit {
-        Suit::Spades   => "S",
-        Suit::Hearts   => "H",
+        Suit::Spades => "S",
+        Suit::Hearts => "H",
         Suit::Diamonds => "D",
-        Suit::Clubs    => "C",
+        Suit::Clubs => "C",
     }
 }
 
@@ -291,7 +295,10 @@ fn spawn_pile_markers(commands: &mut Commands, layout: &Layout) {
                 entity.with_children(|b| {
                     b.spawn((
                         Text2d::new("K"),
-                        TextFont { font_size, ..default() },
+                        TextFont {
+                            font_size,
+                            ..default()
+                        },
                         TextColor(TEXT_PRIMARY.with_alpha(0.35)),
                         Transform::from_xyz(0.0, 0.0, 0.1),
                     ));
@@ -301,7 +308,10 @@ fn spawn_pile_markers(commands: &mut Commands, layout: &Layout) {
                 entity.with_children(|b| {
                     b.spawn((
                         Text2d::new("A"),
-                        TextFont { font_size, ..default() },
+                        TextFont {
+                            font_size,
+                            ..default()
+                        },
                         TextColor(TEXT_PRIMARY.with_alpha(0.35)),
                         Transform::from_xyz(0.0, 0.0, 0.1),
                     ));
@@ -375,7 +385,9 @@ fn on_safe_area_changed(
     windows: Query<(Entity, &Window)>,
     mut resize_events: MessageWriter<WindowResized>,
 ) {
-    let Some(safe_area) = safe_area else { return; };
+    let Some(safe_area) = safe_area else {
+        return;
+    };
     if !safe_area.is_changed() {
         return;
     }
@@ -597,18 +609,18 @@ mod tests {
     #[test]
     fn all_three_themes_produce_distinct_colours() {
         let green = theme_colour(&Theme::Green);
-        let blue  = theme_colour(&Theme::Blue);
-        let dark  = theme_colour(&Theme::Dark);
+        let blue = theme_colour(&Theme::Blue);
+        let dark = theme_colour(&Theme::Dark);
         assert_ne!(green, blue, "Green and Blue must differ");
         assert_ne!(green, dark, "Green and Dark must differ");
-        assert_ne!(blue,  dark, "Blue and Dark must differ");
+        assert_ne!(blue, dark, "Blue and Dark must differ");
     }
 
     #[test]
     fn effective_background_index_0_matches_theme_colour() {
         for theme in [Theme::Green, Theme::Blue, Theme::Dark] {
             let expected = theme_colour(&theme);
-            let actual   = effective_background_colour(&theme, 0);
+            let actual = effective_background_colour(&theme, 0);
             assert_eq!(
                 expected, actual,
                 "index 0 must always return the theme colour for {:?}",
@@ -623,7 +635,10 @@ mod tests {
         let theme_green = theme_colour(&Theme::Green);
         for idx in 1..=3 {
             let eff = effective_background_colour(&Theme::Green, idx);
-            assert_ne!(eff, theme_green, "index {idx} must override the theme colour");
+            assert_ne!(
+                eff, theme_green,
+                "index {idx} must override the theme colour"
+            );
         }
     }
 
@@ -643,10 +658,10 @@ mod tests {
 
     #[test]
     fn suit_symbol_returns_correct_letters() {
-        assert_eq!(suit_symbol(&Suit::Spades),   "S");
-        assert_eq!(suit_symbol(&Suit::Hearts),   "H");
+        assert_eq!(suit_symbol(&Suit::Spades), "S");
+        assert_eq!(suit_symbol(&Suit::Hearts), "H");
         assert_eq!(suit_symbol(&Suit::Diamonds), "D");
-        assert_eq!(suit_symbol(&Suit::Clubs),    "C");
+        assert_eq!(suit_symbol(&Suit::Clubs), "C");
     }
 
     // -----------------------------------------------------------------------
@@ -730,12 +745,29 @@ mod tests {
     /// `hint_pile_highlight_rgb_tracks_state_warning_token`.
     #[test]
     fn hint_pile_highlight_colour_is_gold() {
-        let Srgba { red, green, blue, .. } = HINT_PILE_HIGHLIGHT_COLOUR.to_srgba();
-        assert!(red >= 0.7, "gold hint colour must have red ≥ 0.7, got {red}");
-        assert!(green >= 0.5, "gold hint colour must have green ≥ 0.5, got {green}");
-        assert!(blue <= 0.6, "gold hint colour must have blue ≤ 0.6, got {blue}");
-        assert!(red > blue, "gold hint colour must be warmer than cool, got r={red} b={blue}");
-        assert!(green > blue, "gold hint colour must be warmer than cool, got g={green} b={blue}");
+        let Srgba {
+            red, green, blue, ..
+        } = HINT_PILE_HIGHLIGHT_COLOUR.to_srgba();
+        assert!(
+            red >= 0.7,
+            "gold hint colour must have red ≥ 0.7, got {red}"
+        );
+        assert!(
+            green >= 0.5,
+            "gold hint colour must have green ≥ 0.5, got {green}"
+        );
+        assert!(
+            blue <= 0.6,
+            "gold hint colour must have blue ≤ 0.6, got {blue}"
+        );
+        assert!(
+            red > blue,
+            "gold hint colour must be warmer than cool, got r={red} b={blue}"
+        );
+        assert!(
+            green > blue,
+            "gold hint colour must be warmer than cool, got g={green} b={blue}"
+        );
     }
 
     #[test]

solitaire_engine/src/theme/importer.rs

@@ -45,10 +45,10 @@ use thiserror::Error;
 
 use bevy::math::UVec2;
 
-use crate::assets::{rasterize_svg, user_theme_dir, SvgLoaderError};
+use crate::assets::{SvgLoaderError, rasterize_svg, user_theme_dir};
 
-use super::manifest::{ManifestError, ThemeManifest};
 use super::ThemeMetaError;
+use super::manifest::{ManifestError, ThemeManifest};
 
 /// Hard cap on the *uncompressed* total of all archive entries. Set
 /// generously high relative to a realistic 53-SVG theme (~1–2 MB at
@@ -100,9 +100,7 @@ pub enum ImportError {
 
     /// The archive's declared total uncompressed size exceeds
     /// [`MAX_ARCHIVE_BYTES`]. Checked *before* extraction.
-    #[error(
-        "archive declares {total} uncompressed bytes, exceeds the {limit}-byte limit"
-    )]
+    #[error("archive declares {total} uncompressed bytes, exceeds the {limit}-byte limit")]
     Oversized { total: u64, limit: u64 },
 
     /// No `theme.ron` at the archive root.
@@ -168,10 +166,7 @@ pub fn import_theme(zip_path: &Path) -> Result<ThemeId, ImportError> {
 /// Tests use this directly with a `tempfile::TempDir` so they can
 /// exercise the full extraction path without touching the global
 /// [`crate::assets::user_dir::set_user_theme_dir`] override.
-pub fn import_theme_into(
-    zip_path: &Path,
-    target_root: &Path,
-) -> Result<ThemeId, ImportError> {
+pub fn import_theme_into(zip_path: &Path, target_root: &Path) -> Result<ThemeId, ImportError> {
     let file = File::open(zip_path)?;
     let mut archive = zip::ZipArchive::new(file)?;
 
@@ -189,11 +184,9 @@ pub fn import_theme_into(
     required.push(manifest.back.clone());
     for path in &required {
         let bytes = read_archive_entry(&mut archive, path)?;
-        rasterize_svg(&bytes, SVG_VALIDATION_SIZE).map_err(|source| {
-            ImportError::InvalidSvg {
-                path: path.to_string_lossy().into_owned(),
-                source,
-            }
+        rasterize_svg(&bytes, SVG_VALIDATION_SIZE).map_err(|source| ImportError::InvalidSvg {
+            path: path.to_string_lossy().into_owned(),
+            source,
         })?;
     }
 
@@ -288,8 +281,7 @@ fn is_safe_relative_path(p: &Path) -> bool {
     if p.is_absolute() {
         return false;
     }
-    p.components()
-        .all(|c| matches!(c, Component::Normal(_)))
+    p.components().all(|c| matches!(c, Component::Normal(_)))
 }
 
 /// Reads `theme.ron` from the archive root and parses it.
@@ -373,11 +365,9 @@ fn write_archive_entry<R: io::Read + io::Seek>(
         }
         Err(e) => return Err(ImportError::OpenArchive(e)),
     };
-    let safe = entry
-        .enclosed_name()
-        .ok_or_else(|| ImportError::ZipSlip {
-            path: name.to_owned(),
-        })?;
+    let safe = entry.enclosed_name().ok_or_else(|| ImportError::ZipSlip {
+        path: name.to_owned(),
+    })?;
     if !is_safe_relative_path(&safe) {
         return Err(ImportError::ZipSlip {
             path: name.to_owned(),
@@ -457,8 +447,8 @@ mod tests {
     use std::io::Write;
 
     use tempfile::TempDir;
-    use zip::write::SimpleFileOptions;
     use zip::CompressionMethod;
+    use zip::write::SimpleFileOptions;
 
     use crate::theme::manifest::ThemeManifest;
     use crate::theme::{CardKey, ThemeMeta};
@@ -516,11 +506,8 @@ mod tests {
     /// given manifest id.
     fn write_valid_zip(zip_path: &Path, id: &str) {
         let manifest = full_manifest(id);
-        let manifest_ron = ron::ser::to_string_pretty(
-            &manifest,
-            ron::ser::PrettyConfig::default(),
-        )
-        .expect("ron serialise");
+        let manifest_ron = ron::ser::to_string_pretty(&manifest, ron::ser::PrettyConfig::default())
+            .expect("ron serialise");
         let mut entries: Vec<(String, Vec<u8>)> = Vec::with_capacity(54);
         entries.push((MANIFEST_NAME.to_owned(), manifest_ron.into_bytes()));
         entries.push(("back.svg".to_owned(), TEST_SVG.to_vec()));
@@ -530,8 +517,10 @@ mod tests {
                 TEST_SVG.to_vec(),
             ));
         }
-        let entries_ref: Vec<(&str, Vec<u8>)> =
-            entries.iter().map(|(k, v)| (k.as_str(), v.clone())).collect();
+        let entries_ref: Vec<(&str, Vec<u8>)> = entries
+            .iter()
+            .map(|(k, v)| (k.as_str(), v.clone()))
+            .collect();
         write_zip(zip_path, &entries_ref);
     }
 
@@ -570,10 +559,7 @@ mod tests {
 
         let target = TempDir::new().expect("target");
         let err = import_theme_into(&zip_path, target.path()).expect_err("expected error");
-        assert!(
-            matches!(err, ImportError::MissingManifest),
-            "got {err:?}"
-        );
+        assert!(matches!(err, ImportError::MissingManifest), "got {err:?}");
         assert!(
             target.path().read_dir().unwrap().next().is_none(),
             "target untouched"
@@ -588,11 +574,8 @@ mod tests {
         let mut manifest = full_manifest("incomplete");
         // Drop one face so validation surfaces MissingFaces.
         manifest.faces.remove("hearts_ace");
-        let manifest_ron = ron::ser::to_string_pretty(
-            &manifest,
-            ron::ser::PrettyConfig::default(),
-        )
-        .expect("ron serialise");
+        let manifest_ron = ron::ser::to_string_pretty(&manifest, ron::ser::PrettyConfig::default())
+            .expect("ron serialise");
 
         let mut entries: Vec<(String, Vec<u8>)> = Vec::new();
         entries.push((MANIFEST_NAME.to_owned(), manifest_ron.into_bytes()));
@@ -603,8 +586,10 @@ mod tests {
                 TEST_SVG.to_vec(),
             ));
         }
-        let entries_ref: Vec<(&str, Vec<u8>)> =
-            entries.iter().map(|(k, v)| (k.as_str(), v.clone())).collect();
+        let entries_ref: Vec<(&str, Vec<u8>)> = entries
+            .iter()
+            .map(|(k, v)| (k.as_str(), v.clone()))
+            .collect();
         write_zip(&zip_path, &entries_ref);
 
         let target = TempDir::new().expect("target");
@@ -633,18 +618,12 @@ mod tests {
         let huge = vec![0u8; (MAX_ARCHIVE_BYTES + 1) as usize];
         write_zip(
             &zip_path,
-            &[
-                (MANIFEST_NAME, b"".to_vec()),
-                ("filler.bin", huge),
-            ],
+            &[(MANIFEST_NAME, b"".to_vec()), ("filler.bin", huge)],
         );
 
         let target = TempDir::new().expect("target");
         let err = import_theme_into(&zip_path, target.path()).expect_err("expected error");
-        assert!(
-            matches!(err, ImportError::Oversized { .. }),
-            "got {err:?}"
-        );
+        assert!(matches!(err, ImportError::Oversized { .. }), "got {err:?}");
         assert!(
             target.path().read_dir().unwrap().next().is_none(),
             "target untouched"
@@ -686,11 +665,8 @@ mod tests {
         // Manifest is well-formed and validates, but we omit one of
         // the SVGs from the archive to trigger the MissingFile path.
         let manifest = full_manifest("missing_file_theme");
-        let manifest_ron = ron::ser::to_string_pretty(
-            &manifest,
-            ron::ser::PrettyConfig::default(),
-        )
-        .expect("ron serialise");
+        let manifest_ron = ron::ser::to_string_pretty(&manifest, ron::ser::PrettyConfig::default())
+            .expect("ron serialise");
 
         let mut entries: Vec<(String, Vec<u8>)> = Vec::new();
         entries.push((MANIFEST_NAME.to_owned(), manifest_ron.into_bytes()));
@@ -706,8 +682,10 @@ mod tests {
                 TEST_SVG.to_vec(),
             ));
         }
-        let entries_ref: Vec<(&str, Vec<u8>)> =
-            entries.iter().map(|(k, v)| (k.as_str(), v.clone())).collect();
+        let entries_ref: Vec<(&str, Vec<u8>)> = entries
+            .iter()
+            .map(|(k, v)| (k.as_str(), v.clone()))
+            .collect();
         write_zip(&zip_path, &entries_ref);
 
         let target = TempDir::new().expect("target");

solitaire_engine/src/theme/manifest.rs

@@ -92,7 +92,12 @@ mod tests {
 
     fn full_face_map() -> HashMap<String, PathBuf> {
         CardKey::all()
-            .map(|k| (k.manifest_name(), PathBuf::from(format!("{}.svg", k.manifest_name()))))
+            .map(|k| {
+                (
+                    k.manifest_name(),
+                    PathBuf::from(format!("{}.svg", k.manifest_name())),
+                )
+            })
             .collect()
     }
 
@@ -167,11 +172,8 @@ mod tests {
             back: PathBuf::from("back.svg"),
             faces: full_face_map(),
         };
-        let serialised = ron::ser::to_string_pretty(
-            &m,
-            ron::ser::PrettyConfig::default(),
-        )
-        .expect("serde_ron");
+        let serialised =
+            ron::ser::to_string_pretty(&m, ron::ser::PrettyConfig::default()).expect("serde_ron");
         let parsed: ThemeManifest = ron::from_str(&serialised).expect("ron parse");
         assert_eq!(parsed.meta, m.meta);
         assert_eq!(parsed.back, m.back);

solitaire_engine/src/theme/mod.rs

@@ -28,15 +28,15 @@ use thiserror::Error;
 
 use solitaire_core::card::{Rank, Suit};
 
-pub use importer::{import_theme, import_theme_into, ImportError, ThemeId};
+pub use importer::{ImportError, ThemeId, import_theme, import_theme_into};
 pub use loader::{CardThemeLoader, CardThemeLoaderError};
 pub use manifest::ThemeManifest;
 pub use plugin::{
-    ensure_theme_thumbnails, set_theme, ActiveTheme, ThemePlugin, ThemeThumbnailCache,
-    ThemeThumbnailPair, THEME_THUMBNAIL_HEIGHT_PX, THEME_THUMBNAIL_WIDTH_PX,
+    ActiveTheme, THEME_THUMBNAIL_HEIGHT_PX, THEME_THUMBNAIL_WIDTH_PX, ThemePlugin,
+    ThemeThumbnailCache, ThemeThumbnailPair, ensure_theme_thumbnails, set_theme,
 };
 pub use registry::{
-    build_registry, refresh_registry, ThemeEntry, ThemeRegistry, ThemeRegistryPlugin,
+    ThemeEntry, ThemeRegistry, ThemeRegistryPlugin, build_registry, refresh_registry,
 };
 
 /// Hashable lookup key into [`CardTheme::faces`].
@@ -62,8 +62,18 @@ impl CardKey {
     pub fn all() -> impl Iterator<Item = CardKey> {
         const SUITS: [Suit; 4] = [Suit::Clubs, Suit::Diamonds, Suit::Hearts, Suit::Spades];
         const RANKS: [Rank; 13] = [
-            Rank::Ace, Rank::Two, Rank::Three, Rank::Four, Rank::Five, Rank::Six,
-            Rank::Seven, Rank::Eight, Rank::Nine, Rank::Ten, Rank::Jack, Rank::Queen,
+            Rank::Ace,
+            Rank::Two,
+            Rank::Three,
+            Rank::Four,
+            Rank::Five,
+            Rank::Six,
+            Rank::Seven,
+            Rank::Eight,
+            Rank::Nine,
+            Rank::Ten,
+            Rank::Jack,
+            Rank::Queen,
             Rank::King,
         ];
         SUITS

solitaire_engine/src/theme/plugin.rs

@@ -194,8 +194,7 @@ fn sync_card_image_set_with_active_theme(
     // Consume asset events — covers the normal first-load path.
     for ev in events.read() {
         let id = match ev {
-            AssetEvent::LoadedWithDependencies { id }
-            | AssetEvent::Modified { id } => *id,
+            AssetEvent::LoadedWithDependencies { id } | AssetEvent::Modified { id } => *id,
             _ => continue,
         };
         if id == active_id {
@@ -245,9 +244,19 @@ fn sync_card_image_set_with_active_theme(
 fn apply_theme_to_card_image_set(theme: &CardTheme, image_set: &mut CardImageSet) {
     for suit in [Suit::Clubs, Suit::Diamonds, Suit::Hearts, Suit::Spades] {
         for rank in [
-            Rank::Ace, Rank::Two, Rank::Three, Rank::Four, Rank::Five,
-            Rank::Six, Rank::Seven, Rank::Eight, Rank::Nine, Rank::Ten,
-            Rank::Jack, Rank::Queen, Rank::King,
+            Rank::Ace,
+            Rank::Two,
+            Rank::Three,
+            Rank::Four,
+            Rank::Five,
+            Rank::Six,
+            Rank::Seven,
+            Rank::Eight,
+            Rank::Nine,
+            Rank::Ten,
+            Rank::Jack,
+            Rank::Queen,
+            Rank::King,
         ] {
             if let Some(handle) = theme.faces.get(&CardKey::new(suit, rank)) {
                 image_set.faces[suit_index(suit)][rank_index(rank)] = handle.clone();
@@ -348,10 +357,7 @@ fn read_theme_preview_svg_bytes(theme_id: &str, filename: &str) -> Option<Vec<u8
 /// [`Handle::default`] if rasterisation fails (malformed SVG, etc.) so
 /// the picker can render a placeholder for broken themes without
 /// crashing.
-fn rasterize_preview_to_handle(
-    svg_bytes: &[u8],
-    images: &mut Assets<Image>,
-) -> Handle<Image> {
+fn rasterize_preview_to_handle(svg_bytes: &[u8], images: &mut Assets<Image>) -> Handle<Image> {
     let target = UVec2::new(THEME_THUMBNAIL_WIDTH_PX, THEME_THUMBNAIL_HEIGHT_PX);
     match rasterize_svg(svg_bytes, target) {
         Ok(image) => images.add(image),
@@ -365,10 +371,7 @@ fn rasterize_preview_to_handle(
 /// Builds a [`ThemeThumbnailPair`] for a single theme. Either handle
 /// is [`Handle::default`] when the matching SVG could not be located
 /// or rasterised.
-fn generate_thumbnail_pair_for(
-    theme_id: &str,
-    images: &mut Assets<Image>,
-) -> ThemeThumbnailPair {
+fn generate_thumbnail_pair_for(theme_id: &str, images: &mut Assets<Image>) -> ThemeThumbnailPair {
     let ace = read_theme_preview_svg_bytes(theme_id, PREVIEW_FACE_FILENAME)
         .map(|b| rasterize_preview_to_handle(&b, images))
         .unwrap_or_default();
@@ -543,8 +546,14 @@ mod tests {
         );
         // And the underlying images must actually exist in the assets
         // collection — the handles are real, not dangling.
-        assert!(images.get(&pair.ace).is_some(), "ace image must be inserted");
-        assert!(images.get(&pair.back).is_some(), "back image must be inserted");
+        assert!(
+            images.get(&pair.ace).is_some(),
+            "ace image must be inserted"
+        );
+        assert!(
+            images.get(&pair.back).is_some(),
+            "back image must be inserted"
+        );
     }
 
     /// Test 2: when a theme is registered but its preview SVGs are not

solitaire_engine/src/theme/registry.rs

@@ -21,11 +21,12 @@
 
 use std::path::Path;
 
+use bevy::log::warn;
 use bevy::prelude::{App, Plugin, Resource, Startup};
 use serde::Deserialize;
 
 use super::ThemeMeta;
-use crate::assets::{user_theme_dir, DARK_THEME_MANIFEST_URL};
+use crate::assets::{DARK_THEME_MANIFEST_URL, user_theme_dir};
 
 /// One entry in the [`ThemeRegistry`] — the data the picker UI needs
 /// to render a row and load the theme on selection.
@@ -143,7 +144,7 @@ fn classic_entry() -> ThemeEntry {
 /// Walks `user_dir`, treating every immediate subdirectory as a
 /// candidate theme. A subdirectory contributes one entry if and only
 /// if it contains a `theme.ron` whose `meta` block parses cleanly and
-/// passes `ThemeMeta::validate`. Failed candidates are silently
+/// passes `ThemeMeta::validate`. Failed candidates are warned and
 /// skipped — broken themes don't poison discovery.
 fn discover_user_themes(user_dir: &Path) -> Vec<ThemeEntry> {
     let mut out = Vec::new();
@@ -184,9 +185,29 @@ struct ManifestMetaOnly {
 /// [`ThemeEntry`]. Returns `None` for any I/O / parse / validation
 /// failure — discovery is best-effort.
 fn read_meta_only(manifest_path: &Path) -> Option<ThemeEntry> {
-    let bytes = std::fs::read(manifest_path).ok()?;
-    let parsed: ManifestMetaOnly = ron::de::from_bytes(&bytes).ok()?;
-    parsed.meta.validate().ok()?;
+    let theme_id = manifest_path
+        .parent()
+        .and_then(Path::file_name)
+        .and_then(|name| name.to_str())
+        .unwrap_or("<unknown>");
+    let bytes = match std::fs::read(manifest_path) {
+        Ok(bytes) => bytes,
+        Err(e) => {
+            warn!("Skipping theme '{}': {}", theme_id, e);
+            return None;
+        }
+    };
+    let parsed: ManifestMetaOnly = match ron::de::from_bytes(&bytes) {
+        Ok(parsed) => parsed,
+        Err(e) => {
+            warn!("Skipping theme '{}': {}", theme_id, e);
+            return None;
+        }
+    };
+    if let Err(e) = parsed.meta.validate() {
+        warn!("Skipping theme '{}': {}", theme_id, e);
+        return None;
+    }
     let id = parsed.meta.id.clone();
     let display_name = parsed.meta.name.clone();
     let manifest_url = format!("themes://{id}/theme.ron");
@@ -270,9 +291,7 @@ mod tests {
 
     #[test]
     fn nonexistent_user_dir_still_yields_bundled_entries() {
-        let registry = build_registry(Path::new(
-            "/definitely/not/a/real/path/should/not/panic",
-        ));
+        let registry = build_registry(Path::new("/definitely/not/a/real/path/should/not/panic"));
         assert_eq!(registry.len(), BUNDLED_COUNT);
         assert!(registry.find("classic").is_some());
         assert!(registry.find("dark").is_some());
@@ -332,7 +351,11 @@ mod tests {
         write_manifest(&theme_dir, "../etc/passwd", "Evil");
 
         let registry = build_registry(tmp.path());
-        assert_eq!(registry.len(), BUNDLED_COUNT, "escape attempt must not register");
+        assert_eq!(
+            registry.len(),
+            BUNDLED_COUNT,
+            "escape attempt must not register"
+        );
         assert!(registry.find("classic").is_some());
     }
 

solitaire_engine/src/time_attack_plugin.rs

@@ -27,8 +27,8 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use bevy::prelude::*;
 use solitaire_core::game_state::GameMode;
 use solitaire_data::{
-    delete_time_attack_session_at, load_time_attack_session_from, save_time_attack_session_to,
-    time_attack_session_path, TimeAttackSession,
+    TimeAttackSession, delete_time_attack_session_at, load_time_attack_session_from,
+    save_time_attack_session_to, time_attack_session_path,
 };
 
 use crate::challenge_plugin::CHALLENGE_UNLOCK_LEVEL;
@@ -155,9 +155,10 @@ fn handle_start_time_attack_request(
     // resuming whatever the disk happened to hold. Failures here are
     // logged but never fatal.
     if let Some(p) = path.as_ref().and_then(|r| r.0.as_deref())
-        && let Err(e) = delete_time_attack_session_at(p) {
-            warn!("time_attack_session: failed to delete stale session: {e}");
-        }
+        && let Err(e) = delete_time_attack_session_at(p)
+    {
+        warn!("time_attack_session: failed to delete stale session: {e}");
+    }
     new_game.write(NewGameRequestEvent {
         seed: None,
         mode: Some(GameMode::TimeAttack),
@@ -167,34 +168,34 @@ fn handle_start_time_attack_request(
 
 fn advance_time_attack(
     time: Res<Time>,
+    game: Res<GameStateResource>,
     mut session: ResMut<TimeAttackResource>,
     mut ended: MessageWriter<TimeAttackEndedEvent>,
     paused: Option<Res<crate::pause_plugin::PausedResource>>,
     path: Option<Res<TimeAttackSessionPath>>,
-    home_screens: Query<(), With<crate::home_plugin::HomeScreen>>,
-    win_overlays: Query<(), With<crate::win_summary_plugin::WinSummaryOverlay>>,
+    modal_scrims: Query<(), With<crate::ui_modal::ModalScrim>>,
 ) {
     if !session.active {
         return;
     }
-    // Pause the countdown while Home, the Pause overlay, or the Win Summary
-    // overlay is visible — the player should not lose time while reading results
-    // or navigating menus.
-    if paused.is_some_and(|p| p.0) || !home_screens.is_empty() || !win_overlays.is_empty() {
+    // No shared screen-state enum currently covers every overlay. Pause the
+    // countdown whenever gameplay is blocked by a modal, the pause flag, or a
+    // just-won board state.
+    if paused.is_some_and(|p| p.0) || game.0.is_won || !modal_scrims.is_empty() {
         return;
     }
-    session.remaining_secs -= time.delta_secs();
+    session.remaining_secs = (session.remaining_secs - time.delta_secs()).max(0.0);
     if session.remaining_secs <= 0.0 {
         let wins = session.wins;
         session.active = false;
-        session.remaining_secs = 0.0;
         ended.write(TimeAttackEndedEvent { wins });
         // Session ended naturally — delete the persisted file so the next
         // launch sees no in-progress session.
         if let Some(p) = path.as_ref().and_then(|r| r.0.as_deref())
-            && let Err(e) = delete_time_attack_session_at(p) {
-                warn!("time_attack_session: failed to delete on expiry: {e}");
-            }
+            && let Err(e) = delete_time_attack_session_at(p)
+        {
+            warn!("time_attack_session: failed to delete on expiry: {e}");
+        }
     }
 }
 
@@ -324,6 +325,16 @@ mod tests {
         input.press(KeyCode::KeyT);
     }
 
+    fn advance_by(app: &mut App, total_secs: f32) {
+        app.insert_resource(bevy::time::TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(0.2),
+        ));
+        let ticks = (total_secs / 0.2).ceil() as usize + 1;
+        for _ in 0..ticks {
+            app.update();
+        }
+    }
+
     #[test]
     fn pressing_t_below_unlock_level_is_ignored() {
         let mut app = headless_app();
@@ -359,17 +370,15 @@ mod tests {
     }
 
     #[test]
-    fn timer_expiry_fires_ended_event_and_clears_active() {
+    fn timer_expiry_clamps_to_zero_and_fires_ended_event() {
         let mut app = headless_app();
-        // Set the session to an already-expired state (remaining < 0).
-        // MinimalPlugins time delta is nonzero so we skip the intermediate
-        // 0.001-remaining step to avoid a double-fire.
         *app.world_mut().resource_mut::<TimeAttackResource>() = TimeAttackResource {
             active: true,
-            remaining_secs: -1.0,
+            remaining_secs: 0.3,
             wins: 5,
         };
-        app.update();
+
+        advance_by(&mut app, 0.4);
 
         let session = app.world().resource::<TimeAttackResource>();
         assert!(!session.active);
@@ -382,6 +391,33 @@ mod tests {
         assert_eq!(fired[0].wins, 5);
     }
 
+    #[test]
+    fn modal_overlay_pauses_session_timer() {
+        let mut app = headless_app();
+        app.world_mut().spawn(crate::ui_modal::ModalScrim);
+        *app.world_mut().resource_mut::<TimeAttackResource>() = TimeAttackResource {
+            active: true,
+            remaining_secs: 5.0,
+            wins: 2,
+        };
+
+        advance_by(&mut app, 0.4);
+
+        let session = app.world().resource::<TimeAttackResource>();
+        assert!(
+            session.active,
+            "session must stay active while a modal is open"
+        );
+        assert_eq!(session.remaining_secs, 5.0);
+
+        let events = app.world().resource::<Messages<TimeAttackEndedEvent>>();
+        let mut cursor = events.get_cursor();
+        assert!(
+            cursor.read(events).next().is_none(),
+            "TimeAttackEndedEvent must not fire while a modal is open"
+        );
+    }
+
     #[test]
     fn win_during_session_increments_wins_and_auto_deals() {
         let mut app = headless_app();
@@ -462,10 +498,13 @@ mod tests {
         };
         app.update();
 
-        // remaining_secs must not have been reset to 0.0 (pause blocked the update).
+        // remaining_secs must not have been clamped to 0.0 (pause blocked the update).
         let session = app.world().resource::<TimeAttackResource>();
         assert!(session.active, "session must still be active while paused");
-        assert!(session.remaining_secs < 0.0, "remaining_secs must not change while paused");
+        assert!(
+            session.remaining_secs < 0.0,
+            "remaining_secs must not change while paused"
+        );
 
         // No ended event must have been emitted.
         let events = app.world().resource::<Messages<TimeAttackEndedEvent>>();
@@ -509,8 +548,7 @@ mod tests {
         // and we load immediately, so wall-clock elapsed is ~0 and the
         // restored remaining_secs should match what we wrote within a tiny
         // epsilon (allowing for the test taking a few seconds to run).
-        let loaded =
-            load_time_attack_session_from(&path).expect("file should exist after exit");
+        let loaded = load_time_attack_session_from(&path).expect("file should exist after exit");
         assert!(
             (loaded.remaining_secs - 240.0).abs() < 5.0,
             "remaining_secs must round-trip within 5 s tolerance, got {}",
@@ -527,8 +565,11 @@ mod tests {
     fn exit_clears_persisted_file_when_no_active_session() {
         let path = tmp_ta_path("exit_clear");
         // Pre-create a stale file.
-        std::fs::write(&path, b"{\"remaining_secs\":100.0,\"wins\":1,\"saved_at_unix_secs\":0}")
-            .expect("write stale");
+        std::fs::write(
+            &path,
+            b"{\"remaining_secs\":100.0,\"wins\":1,\"saved_at_unix_secs\":0}",
+        )
+        .expect("write stale");
         assert!(path.exists());
 
         let mut app = headless_app();
@@ -537,7 +578,10 @@ mod tests {
         app.world_mut().write_message(AppExit::Success);
         app.update();
 
-        assert!(!path.exists(), "stale file must be deleted on exit when session is inactive");
+        assert!(
+            !path.exists(),
+            "stale file must be deleted on exit when session is inactive"
+        );
     }
 
     /// `auto_save_time_attack_session` writes the session once the
@@ -557,10 +601,15 @@ mod tests {
             wins: 2,
         };
         // Pre-seed the timer past the threshold so the very next update fires the save.
-        app.insert_resource(TimeAttackAutoSaveTimer(TIME_ATTACK_AUTO_SAVE_INTERVAL_SECS + 0.1));
+        app.insert_resource(TimeAttackAutoSaveTimer(
+            TIME_ATTACK_AUTO_SAVE_INTERVAL_SECS + 0.1,
+        ));
         app.update();
 
-        assert!(path.exists(), "auto-save file must exist after timer crosses threshold");
+        assert!(
+            path.exists(),
+            "auto-save file must exist after timer crosses threshold"
+        );
         let loaded = load_time_attack_session_from(&path).expect("session must load");
         assert_eq!(loaded.wins, 2);
 
@@ -578,10 +627,15 @@ mod tests {
         let mut app = headless_app();
         app.insert_resource(TimeAttackSessionPath(Some(path.clone())));
         // Session stays at default (inactive). Timer is past threshold.
-        app.insert_resource(TimeAttackAutoSaveTimer(TIME_ATTACK_AUTO_SAVE_INTERVAL_SECS + 0.1));
+        app.insert_resource(TimeAttackAutoSaveTimer(
+            TIME_ATTACK_AUTO_SAVE_INTERVAL_SECS + 0.1,
+        ));
         app.update();
 
-        assert!(!path.exists(), "auto-save must not fire when session is inactive");
+        assert!(
+            !path.exists(),
+            "auto-save must not fire when session is inactive"
+        );
     }
 
     /// Starting a fresh session must delete any stale persisted file so a
@@ -591,8 +645,11 @@ mod tests {
     fn starting_new_session_deletes_stale_persisted_file() {
         let path = tmp_ta_path("start_clears");
         // Pre-create a stale file.
-        std::fs::write(&path, b"{\"remaining_secs\":42.0,\"wins\":99,\"saved_at_unix_secs\":0}")
-            .expect("write stale");
+        std::fs::write(
+            &path,
+            b"{\"remaining_secs\":42.0,\"wins\":99,\"saved_at_unix_secs\":0}",
+        )
+        .expect("write stale");
 
         let mut app = headless_app();
         app.insert_resource(TimeAttackSessionPath(Some(path.clone())));
@@ -602,7 +659,10 @@ mod tests {
         press_t(&mut app);
         app.update();
 
-        assert!(!path.exists(), "stale persisted file must be cleared at session start");
+        assert!(
+            !path.exists(),
+            "stale persisted file must be cleared at session start"
+        );
 
         // And the live resource must reflect a fresh session, not the stale data.
         let session = app.world().resource::<TimeAttackResource>();
@@ -622,8 +682,11 @@ mod tests {
     fn session_expiry_deletes_persisted_file() {
         let path = tmp_ta_path("expiry_clears");
         // Pre-create a file that simulates the auto-save's prior write.
-        std::fs::write(&path, b"{\"remaining_secs\":1.0,\"wins\":7,\"saved_at_unix_secs\":0}")
-            .expect("write");
+        std::fs::write(
+            &path,
+            b"{\"remaining_secs\":1.0,\"wins\":7,\"saved_at_unix_secs\":0}",
+        )
+        .expect("write");
         assert!(path.exists());
 
         let mut app = headless_app();
@@ -637,7 +700,10 @@ mod tests {
 
         app.update();
 
-        assert!(!path.exists(), "persisted file must be deleted on natural expiry");
+        assert!(
+            !path.exists(),
+            "persisted file must be deleted on natural expiry"
+        );
         let session = app.world().resource::<TimeAttackResource>();
         assert!(!session.active);
     }

solitaire_engine/src/ui_focus.rs

@@ -140,11 +140,7 @@ impl Plugin for UiFocusPlugin {
             // resource.
             .add_systems(
                 PostUpdate,
-                (
-                    attach_focusable_to_modal_buttons,
-                    auto_focus_on_modal_open,
-                )
-                    .chain(),
+                (attach_focusable_to_modal_buttons, auto_focus_on_modal_open).chain(),
             )
             .add_systems(
                 Update,
@@ -433,11 +429,7 @@ fn handle_focus_keys(
         // it matches the visual left → right layout.
         let row_cycle: Vec<Entity> = siblings
             .iter()
-            .filter(|e| {
-                focusables
-                    .get(*e)
-                    .is_ok_and(|(_, disabled)| !disabled)
-            })
+            .filter(|e| focusables.get(*e).is_ok_and(|(_, disabled)| !disabled))
             .collect();
         if !row_cycle.is_empty()
             && let Some(idx) = row_cycle.iter().position(|e| *e == target)
@@ -465,23 +457,23 @@ fn handle_focus_keys(
     //   1. Any modal open  ⇒ Modal(topmost scrim)
     //   2. Any Hud-grouped focusable hovered ⇒ Hud
     //   3. Otherwise ⇒ no-op
-    let active_group: FocusGroup = if let Some(active_scrim) = scrims.iter().max_by_key(|e| e.index()) {
-        // Pick the topmost modal as the active group. With multiple
-        // modals stacked (Pause + Forfeit confirm) the most-recently-
-        // spawned scrim has the highest entity index — same heuristic
-        // Phase 1 used.
-        FocusGroup::Modal(active_scrim)
-    } else if hud_interactions.iter().any(|(_, interaction, focusable)| {
-        matches!(interaction, Interaction::Hovered) && focusable.group == FocusGroup::Hud
-    }) {
-        FocusGroup::Hud
-    } else {
-        return;
-    };
+    let active_group: FocusGroup =
+        if let Some(active_scrim) = scrims.iter().max_by_key(|e| e.index()) {
+            // Pick the topmost modal as the active group. With multiple
+            // modals stacked (Pause + Forfeit confirm) the most-recently-
+            // spawned scrim has the highest entity index — same heuristic
+            // Phase 1 used.
+            FocusGroup::Modal(active_scrim)
+        } else if hud_interactions.iter().any(|(_, interaction, focusable)| {
+            matches!(interaction, Interaction::Hovered) && focusable.group == FocusGroup::Hud
+        }) {
+            FocusGroup::Hud
+        } else {
+            return;
+        };
 
     let tab_pressed = keys.just_pressed(KeyCode::Tab);
-    let activate_pressed =
-        keys.just_pressed(KeyCode::Enter) || keys.just_pressed(KeyCode::Space);
+    let activate_pressed = keys.just_pressed(KeyCode::Enter) || keys.just_pressed(KeyCode::Space);
 
     if !tab_pressed && !activate_pressed {
         return;
@@ -657,28 +649,37 @@ fn update_focus_overlay(
 mod tests {
     use super::*;
     use crate::ui_modal::{
-        spawn_modal, spawn_modal_actions, spawn_modal_button, ButtonVariant, UiModalPlugin,
+        ButtonVariant, UiModalPlugin, spawn_modal, spawn_modal_actions, spawn_modal_button,
     };
 
     #[test]
     fn focus_ring_pulse_factor_at_zero_is_mid_point() {
         // sin(0) = 0 → factor = 0.825 (mid of [0.65, 1.0]).
         let f = focus_ring_pulse_factor(0.0);
-        assert!((f - 0.825).abs() < 1e-5, "factor at t=0 should be 0.825, got {f}");
+        assert!(
+            (f - 0.825).abs() < 1e-5,
+            "factor at t=0 should be 0.825, got {f}"
+        );
     }
 
     #[test]
     fn focus_ring_pulse_factor_peaks_at_quarter_period() {
         // sin(τ/4) = 1 → factor = 1.0.
         let f = focus_ring_pulse_factor(MOTION_FOCUS_PULSE_SECS / 4.0);
-        assert!((f - 1.0).abs() < 1e-4, "factor at peak should be 1.0, got {f}");
+        assert!(
+            (f - 1.0).abs() < 1e-4,
+            "factor at peak should be 1.0, got {f}"
+        );
     }
 
     #[test]
     fn focus_ring_pulse_factor_troughs_at_three_quarter_period() {
         // sin(3τ/4) = -1 → factor = 0.65.
         let f = focus_ring_pulse_factor(MOTION_FOCUS_PULSE_SECS * 3.0 / 4.0);
-        assert!((f - 0.65).abs() < 1e-4, "factor at trough should be 0.65, got {f}");
+        assert!(
+            (f - 0.65).abs() < 1e-4,
+            "factor at trough should be 0.65, got {f}"
+        );
     }
 
     #[test]
@@ -755,12 +756,16 @@ mod tests {
         // `auto_focus_on_modal_open` execute.
         app.update();
 
-        let mut a_query = app.world_mut().query_filtered::<Entity, With<TestButtonA>>();
+        let mut a_query = app
+            .world_mut()
+            .query_filtered::<Entity, With<TestButtonA>>();
         let a = a_query
             .iter(app.world())
             .next()
             .expect("button A should have been spawned");
-        let mut b_query = app.world_mut().query_filtered::<Entity, With<TestButtonB>>();
+        let mut b_query = app
+            .world_mut()
+            .query_filtered::<Entity, With<TestButtonB>>();
         let b = b_query
             .iter(app.world())
             .next()
@@ -807,11 +812,17 @@ mod tests {
         };
         app.update();
 
-        let mut q_a = app.world_mut().query_filtered::<Entity, With<TestButtonA>>();
+        let mut q_a = app
+            .world_mut()
+            .query_filtered::<Entity, With<TestButtonA>>();
         let a = q_a.iter(app.world()).next().expect("A spawned");
-        let mut q_b = app.world_mut().query_filtered::<Entity, With<TestButtonB>>();
+        let mut q_b = app
+            .world_mut()
+            .query_filtered::<Entity, With<TestButtonB>>();
         let b = q_b.iter(app.world()).next().expect("B spawned");
-        let mut q_c = app.world_mut().query_filtered::<Entity, With<TestButtonC>>();
+        let mut q_c = app
+            .world_mut()
+            .query_filtered::<Entity, With<TestButtonC>>();
         let c = q_c.iter(app.world()).next().expect("C spawned");
         (scrim, a, b, c)
     }
@@ -864,10 +875,7 @@ mod tests {
     /// Crucially this system has **no** ordering relationship with
     /// `UiFocusPlugin`'s chain — exactly the situation that surfaces the
     /// "focus arrives one frame late" bug in production.
-    fn spawn_modal_via_system(
-        mut commands: Commands,
-        mut trigger: ResMut<SpawnModalTrigger>,
-    ) {
+    fn spawn_modal_via_system(mut commands: Commands, mut trigger: ResMut<SpawnModalTrigger>) {
         if !trigger.0 {
             return;
         }

solitaire_engine/src/ui_modal.rs

@@ -58,11 +58,11 @@ use crate::font_plugin::FontResource;
 use crate::platform::SHOW_KEYBOARD_ACCELERATORS;
 use crate::settings_plugin::SettingsResource;
 use crate::ui_theme::{
-    scaled_duration, 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,
+    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,
 };
 
 // ---------------------------------------------------------------------------
@@ -193,7 +193,10 @@ where
         .spawn((
             plugin_marker,
             ModalScrim,
-            ModalEntering { elapsed: 0.0, duration },
+            ModalEntering {
+                elapsed: 0.0,
+                duration,
+            },
             Node {
                 position_type: PositionType::Absolute,
                 left: Val::Px(0.0),
@@ -227,11 +230,11 @@ where
                 Node {
                     flex_direction: FlexDirection::Column,
                     row_gap: VAL_SPACE_4,
+                    width: Val::Percent(90.0),
                     padding: UiRect::all(VAL_SPACE_5),
                     border: UiRect::all(Val::Px(1.0)),
                     border_radius: BorderRadius::all(Val::Px(RADIUS_LG)),
                     max_width: Val::Px(720.0),
-                    min_width: Val::Px(360.0),
                     align_items: AlignItems::Stretch,
                     ..default()
                 },
@@ -295,12 +298,7 @@ pub fn spawn_modal_body_text(
         font_size: TYPE_BODY_LG,
         ..default()
     };
-    parent.spawn((
-        ModalBody,
-        Text::new(text.into()),
-        font,
-        TextColor(color),
-    ));
+    parent.spawn((ModalBody, Text::new(text.into()), font, TextColor(color)));
 }
 
 /// Spawns the bottom actions row — flex-row with primary right-aligned.
@@ -343,7 +341,11 @@ pub fn spawn_modal_button<M: Component>(
     variant: ButtonVariant,
     font_res: Option<&FontResource>,
 ) {
-    let hotkey = if SHOW_KEYBOARD_ACCELERATORS { hotkey } else { None };
+    let hotkey = if SHOW_KEYBOARD_ACCELERATORS {
+        hotkey
+    } else {
+        None
+    };
     let font_handle = font_res.map(|f| f.0.clone()).unwrap_or_default();
     let font_label = TextFont {
         font: font_handle.clone(),
@@ -517,7 +519,10 @@ pub fn apply_modal_enter_speed(
 pub fn advance_modal_enter(
     time: Res<Time>,
     mut commands: Commands,
-    mut scrims: Query<(Entity, &mut ModalEntering, &mut BackgroundColor, &Children), With<ModalScrim>>,
+    mut scrims: Query<
+        (Entity, &mut ModalEntering, &mut BackgroundColor, &Children),
+        With<ModalScrim>,
+    >,
     mut cards: Query<&mut Transform, With<ModalCard>>,
 ) {
     let dt = time.delta_secs();
@@ -653,10 +658,7 @@ pub fn dismiss_modal_on_scrim_click(
 /// paint system.
 #[allow(clippy::type_complexity)]
 pub fn paint_modal_buttons(
-    mut buttons: Query<
-        (&Interaction, &ModalButton, &mut BackgroundColor),
-        Changed<Interaction>,
-    >,
+    mut buttons: Query<(&Interaction, &ModalButton, &mut BackgroundColor), Changed<Interaction>>,
 ) {
     for (interaction, modal_button, mut bg) in &mut buttons {
         bg.0 = match interaction {
@@ -687,7 +689,12 @@ impl Plugin for UiModalPlugin {
         // before advance computes `t`.
         app.add_systems(
             Update,
-            (apply_modal_enter_speed, advance_modal_enter, paint_modal_buttons).chain(),
+            (
+                apply_modal_enter_speed,
+                advance_modal_enter,
+                paint_modal_buttons,
+            )
+                .chain(),
         );
         // Click-outside-to-dismiss is independent of the open
         // animation chain — it reads `just_pressed(Left)` and runs
@@ -774,6 +781,11 @@ mod tests {
             (card_scale - MODAL_ENTER_START_SCALE).abs() < 1e-6,
             "card should spawn at MODAL_ENTER_START_SCALE; got {card_scale}"
         );
+
+        let card_node = card_node_of(&app, scrim);
+        assert_eq!(card_node.width, Val::Percent(90.0));
+        assert_eq!(card_node.max_width, Val::Px(720.0));
+        assert_eq!(card_node.min_width, Val::Auto);
     }
 
     /// After enough simulated ticks for `elapsed >= duration`, the
@@ -817,23 +829,42 @@ mod tests {
         );
     }
 
+    /// Returns the `Entity` of the first `ModalCard` child of the given
+    /// scrim.
+    fn card_entity_of(world: &World, scrim: Entity) -> Entity {
+        let children = world
+            .entity(scrim)
+            .get::<Children>()
+            .expect("scrim should have a card child");
+        children
+            .iter()
+            .find(|child| world.entity(*child).get::<ModalCard>().is_some())
+            .expect("scrim should have a ModalCard child")
+    }
+
+    /// Returns the `Node` of the first `ModalCard` child of the given
+    /// scrim.
+    fn card_node_of(app: &App, scrim: Entity) -> &Node {
+        let world = app.world();
+        let card = card_entity_of(world, scrim);
+        world
+            .entity(card)
+            .get::<Node>()
+            .expect("ModalCard child should have a Node")
+    }
+
     /// Returns the X-component of the first `ModalCard` child of the
     /// given scrim's `Transform::scale`. All three components are kept
     /// in sync by the system so reading X is sufficient.
     fn card_scale_of(app: &mut App, scrim: Entity) -> f32 {
         let world = app.world();
-        let children = world
-            .entity(scrim)
-            .get::<Children>()
-            .expect("scrim should have a card child");
-        for child in children.iter() {
-            if let Some(t) = world.entity(child).get::<Transform>()
-                && world.entity(child).get::<ModalCard>().is_some()
-            {
-                return t.scale.x;
-            }
-        }
-        panic!("no ModalCard child with a Transform under scrim {scrim:?}");
+        let card = card_entity_of(world, scrim);
+        world
+            .entity(card)
+            .get::<Transform>()
+            .expect("ModalCard child should have a Transform")
+            .scale
+            .x
     }
 
     /// Tells `TimePlugin` to advance the clock by `secs` on the next
@@ -844,9 +875,9 @@ mod tests {
     fn set_manual_time_step(app: &mut App, secs: f32) {
         use bevy::time::TimeUpdateStrategy;
         use std::time::Duration;
-        app.insert_resource(TimeUpdateStrategy::ManualDuration(
-            Duration::from_secs_f32(secs),
-        ));
+        app.insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_secs_f32(
+            secs,
+        )));
     }
 
     // -----------------------------------------------------------------------
@@ -871,10 +902,26 @@ mod tests {
     fn cursor_is_inside_rect_outside_returns_false() {
         let centre = Vec2::new(200.0, 150.0);
         let size = Vec2::new(100.0, 60.0);
-        assert!(!cursor_is_inside_rect(Vec2::new(149.0, 150.0), centre, size)); // left
-        assert!(!cursor_is_inside_rect(Vec2::new(251.0, 150.0), centre, size)); // right
-        assert!(!cursor_is_inside_rect(Vec2::new(200.0, 119.0), centre, size)); // above
-        assert!(!cursor_is_inside_rect(Vec2::new(200.0, 181.0), centre, size)); // below
+        assert!(!cursor_is_inside_rect(
+            Vec2::new(149.0, 150.0),
+            centre,
+            size
+        )); // left
+        assert!(!cursor_is_inside_rect(
+            Vec2::new(251.0, 150.0),
+            centre,
+            size
+        )); // right
+        assert!(!cursor_is_inside_rect(
+            Vec2::new(200.0, 119.0),
+            centre,
+            size
+        )); // above
+        assert!(!cursor_is_inside_rect(
+            Vec2::new(200.0, 181.0),
+            centre,
+            size
+        )); // below
     }
 
     /// Builds a headless app capable of running
@@ -966,9 +1013,7 @@ mod tests {
     /// `MinimalPlugins` doesn't run the input clear pass, so we mark
     /// the clear by hand on the resource between presses.
     fn press_left_mouse(app: &mut App) {
-        let mut input = app
-            .world_mut()
-            .resource_mut::<ButtonInput<MouseButton>>();
+        let mut input = app.world_mut().resource_mut::<ButtonInput<MouseButton>>();
         input.clear();
         input.press(MouseButton::Left);
     }
@@ -1068,4 +1113,3 @@ mod tests {
         );
     }
 }
-

solitaire_engine/src/ui_theme.rs

@@ -294,7 +294,10 @@ impl HighContrastBackground {
     /// Convenience constructor — HC colour defaults to
     /// [`BORDER_SUBTLE_HC`].
     pub const fn with_default(default_color: bevy::prelude::Color) -> Self {
-        Self { default_color, hc_color: BORDER_SUBTLE_HC }
+        Self {
+            default_color,
+            hc_color: BORDER_SUBTLE_HC,
+        }
     }
 
     /// Constructor for sites whose HC colour differs from the standard
@@ -305,7 +308,10 @@ impl HighContrastBackground {
         default_color: bevy::prelude::Color,
         hc_color: bevy::prelude::Color,
     ) -> Self {
-        Self { default_color, hc_color }
+        Self {
+            default_color,
+            hc_color,
+        }
     }
 }
 
@@ -621,7 +627,9 @@ mod tests {
     /// honest if someone tweaks values later.
     #[test]
     fn spacing_scale_is_a_4_multiple_geometric_progression() {
-        for v in [SPACE_1, SPACE_2, SPACE_3, SPACE_4, SPACE_5, SPACE_6, SPACE_7] {
+        for v in [
+            SPACE_1, SPACE_2, SPACE_3, SPACE_4, SPACE_5, SPACE_6, SPACE_7,
+        ] {
             assert!(v > 0.0, "spacing tokens must be positive");
             assert!(
                 (v.rem_euclid(4.0)).abs() < f32::EPSILON,
@@ -633,7 +641,13 @@ mod tests {
     /// Type scale is monotonically decreasing display → caption.
     #[test]
     fn type_scale_is_monotonically_decreasing() {
-        let scale = [TYPE_DISPLAY, TYPE_HEADLINE, TYPE_BODY_LG, TYPE_BODY, TYPE_CAPTION];
+        let scale = [
+            TYPE_DISPLAY,
+            TYPE_HEADLINE,
+            TYPE_BODY_LG,
+            TYPE_BODY,
+            TYPE_CAPTION,
+        ];
         for window in scale.windows(2) {
             assert!(
                 window[0] > window[1],

solitaire_engine/src/ui_tooltip.rs

@@ -93,10 +93,7 @@ impl Plugin for UiTooltipPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<TooltipState>()
             .add_systems(Startup, spawn_tooltip_overlay)
-            .add_systems(
-                Update,
-                (track_tooltip_hover, show_or_hide_tooltip).chain(),
-            );
+            .add_systems(Update, (track_tooltip_hover, show_or_hide_tooltip).chain());
     }
 }
 
@@ -222,10 +219,7 @@ fn spawn_tooltip_overlay(
 /// reveal delay.
 fn track_tooltip_hover(
     time: Res<Time>,
-    interactions: Query<
-        (Entity, &Interaction, Option<&Tooltip>),
-        Changed<Interaction>,
-    >,
+    interactions: Query<(Entity, &Interaction, Option<&Tooltip>), Changed<Interaction>>,
     mut state: ResMut<TooltipState>,
 ) {
     for (entity, interaction, tooltip) in &interactions {
@@ -407,9 +401,9 @@ mod tests {
     /// `app.update()`. Mirrors the helper in `ui_modal::tests` and
     /// `hud_plugin::tests`.
     fn set_manual_time_step(app: &mut App, secs: f32) {
-        app.insert_resource(TimeUpdateStrategy::ManualDuration(
-            Duration::from_secs_f32(secs),
-        ));
+        app.insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_secs_f32(
+            secs,
+        )));
     }
 
     /// Reads the current overlay visibility. Panics if the singleton is
@@ -440,18 +434,12 @@ mod tests {
     fn spawn_hovered_tooltip(app: &mut App, label: &'static str) -> Entity {
         let id = app
             .world_mut()
-            .spawn((
-                Node::default(),
-                Interaction::Hovered,
-                Tooltip::new(label),
-            ))
+            .spawn((Node::default(), Interaction::Hovered, Tooltip::new(label)))
             .id();
         // Mark the Interaction Changed by re-inserting it. `Changed`
         // requires component mutation since the previous tick; spawn
         // already counts, but a follow-up insert is the explicit signal.
-        app.world_mut()
-            .entity_mut(id)
-            .insert(Interaction::Hovered);
+        app.world_mut().entity_mut(id).insert(Interaction::Hovered);
         id
     }
 
@@ -536,9 +524,7 @@ mod tests {
 
         // Unhover. `track_tooltip_hover` clears the state on the next
         // tick because the entity transitions Hovered → None.
-        app.world_mut()
-            .entity_mut(target)
-            .insert(Interaction::None);
+        app.world_mut().entity_mut(target).insert(Interaction::None);
         app.update();
 
         assert!(
@@ -590,12 +576,18 @@ mod tests {
     #[test]
     fn tooltip_should_show_respects_delay() {
         // delay == 0 ("Instant"): any elapsed (including zero) shows.
-        assert!(tooltip_should_show(0.0, 0.0), "instant delay must show on first tick");
+        assert!(
+            tooltip_should_show(0.0, 0.0),
+            "instant delay must show on first tick"
+        );
         assert!(tooltip_should_show(0.5, 0.0));
 
         // Standard non-zero delay.
         assert!(!tooltip_should_show(0.4, 0.5), "elapsed < delay must hide");
-        assert!(tooltip_should_show(0.5, 0.5), "elapsed == delay must show (boundary)");
+        assert!(
+            tooltip_should_show(0.5, 0.5),
+            "elapsed == delay must show (boundary)"
+        );
         assert!(tooltip_should_show(0.6, 0.5), "elapsed > delay must show");
 
         // Larger delay (max-end of the slider).

solitaire_engine/src/weekly_goals_plugin.rs

@@ -5,8 +5,8 @@
 use bevy::prelude::*;
 use chrono::Local;
 use solitaire_data::{
-    current_iso_week_key, save_progress_to, weekly_goal_by_id, WeeklyGoalContext, WEEKLY_GOALS,
-    WEEKLY_GOAL_XP,
+    WEEKLY_GOAL_XP, WEEKLY_GOALS, WeeklyGoalContext, current_iso_week_key, save_progress_to,
+    weekly_goal_by_id,
 };
 
 use crate::events::{GameWonEvent, XpAwardedEvent};
@@ -51,9 +51,10 @@ fn roll_weekly_goals_on_startup(
     let week_key = current_iso_week_key(Local::now().date_naive());
     if progress.0.roll_weekly_goals_if_new_week(&week_key)
         && let Some(target) = &path.0
-            && let Err(e) = save_progress_to(target, &progress.0) {
-                warn!("failed to save progress after weekly reset on startup: {e}");
-            }
+        && let Err(e) = save_progress_to(target, &progress.0)
+    {
+        warn!("failed to save progress after weekly reset on startup: {e}");
+    }
 }
 
 fn evaluate_weekly_goals(
@@ -114,9 +115,10 @@ fn evaluate_weekly_goals(
 
     if any_change
         && let Some(target) = &path.0
-            && let Err(e) = save_progress_to(target, &progress.0) {
-                warn!("failed to save progress after weekly goal update: {e}");
-            }
+        && let Err(e) = save_progress_to(target, &progress.0)
+    {
+        warn!("failed to save progress after weekly goal update: {e}");
+    }
 }
 
 /// Resolve a goal id to its description (used for toasts).
@@ -196,10 +198,14 @@ mod tests {
         // keeping the XP delta predictable.
         {
             let mut p = app.world_mut().resource_mut::<ProgressResource>();
-            p.0.weekly_goal_progress.insert("weekly_3_fast".to_string(), 2);
-            p.0.weekly_goal_progress.insert("weekly_1_under_five".to_string(), 1);
-            p.0.weekly_goal_progress.insert("weekly_5_wins".to_string(), 5);
-            p.0.weekly_goal_progress.insert("weekly_3_no_undo".to_string(), 3);
+            p.0.weekly_goal_progress
+                .insert("weekly_3_fast".to_string(), 2);
+            p.0.weekly_goal_progress
+                .insert("weekly_1_under_five".to_string(), 1);
+            p.0.weekly_goal_progress
+                .insert("weekly_5_wins".to_string(), 5);
+            p.0.weekly_goal_progress
+                .insert("weekly_3_no_undo".to_string(), 3);
         }
         // Match the current ISO week key so roll_weekly_goals doesn't clear it.
         let key = current_iso_week_key(Local::now().date_naive());
@@ -263,7 +269,10 @@ mod tests {
     fn weekly_bonus_xp_fires_levelup_when_threshold_crossed() {
         let mut app = headless_app();
         // Set XP just below the first level boundary (500) so the 75-XP bonus crosses it.
-        app.world_mut().resource_mut::<ProgressResource>().0.total_xp = 430;
+        app.world_mut()
+            .resource_mut::<ProgressResource>()
+            .0
+            .total_xp = 430;
         // Pre-set goal to 2/3 so the next fast win completes it.
         app.world_mut()
             .resource_mut::<ProgressResource>()
@@ -285,7 +294,10 @@ mod tests {
         let events = app.world().resource::<Messages<LevelUpEvent>>();
         let mut cursor = events.get_cursor();
         let fired: Vec<_> = cursor.read(events).copied().collect();
-        assert!(!fired.is_empty(), "LevelUpEvent must fire when weekly bonus pushes past a level threshold");
+        assert!(
+            !fired.is_empty(),
+            "LevelUpEvent must fire when weekly bonus pushes past a level threshold"
+        );
     }
 
     #[test]

solitaire_engine/src/win_summary_plugin.rs

@@ -26,11 +26,11 @@ use crate::settings_plugin::SettingsResource;
 use crate::stats_plugin::{StatsResource, StatsUpdate};
 use crate::ui_modal::ModalScrim;
 use crate::ui_theme::{
-    scaled_duration, ACCENT_PRIMARY, BG_BASE, BG_ELEVATED, MOTION_SCORE_BREAKDOWN_FADE_SECS,
+    ACCENT_PRIMARY, BG_BASE, BG_ELEVATED, MOTION_SCORE_BREAKDOWN_FADE_SECS,
     MOTION_SCORE_BREAKDOWN_STAGGER_SECS, MOTION_WIN_SHAKE_AMPLITUDE, MOTION_WIN_SHAKE_SECS,
     RADIUS_LG, RADIUS_MD, SCRIM, STATE_INFO, STATE_SUCCESS, STATE_WARNING, TEXT_PRIMARY,
     TEXT_SECONDARY, TYPE_BODY, TYPE_BODY_LG, TYPE_DISPLAY, TYPE_HEADLINE, VAL_SPACE_2, VAL_SPACE_3,
-    Z_WIN_CASCADE,
+    Z_WIN_CASCADE, scaled_duration,
 };
 
 // ---------------------------------------------------------------------------
@@ -227,9 +227,7 @@ impl Plugin for WinSummaryPlugin {
             // the player's old personal-best values before `StatsPlugin` overwrites them.
             .add_systems(
                 Update,
-                cache_win_data
-                    .after(GameMutation)
-                    .before(StatsUpdate),
+                cache_win_data.after(GameMutation).before(StatsUpdate),
             )
             .add_systems(
                 Update,
@@ -282,7 +280,7 @@ pub const SCORE_NO_UNDO_BONUS: i32 = 25;
 /// Time bonus ({m:ss})         +{time_bonus}
 /// No-undo bonus               +{no_undo_bonus}
 /// Mode multiplier ({mode} ×N) ×{multiplier}
-/// ─────────────────────────────────
+/// -----------------
 /// Total                        {total}
 /// ```
 ///
@@ -351,10 +349,17 @@ impl ScoreBreakdown {
         } else {
             scaled.clamp(i32::MIN as f32, i32::MAX as f32) as i32
         };
-        let no_undo_bonus = if undo_count == 0 { SCORE_NO_UNDO_BONUS } else { 0 };
+        let no_undo_bonus = if undo_count == 0 {
+            SCORE_NO_UNDO_BONUS
+        } else {
+            0
+        };
         let multiplier = match mode {
             GameMode::Zen => 0.0,
-            GameMode::Classic | GameMode::Challenge | GameMode::TimeAttack | GameMode::Difficulty(_) => 1.0,
+            GameMode::Classic
+            | GameMode::Challenge
+            | GameMode::TimeAttack
+            | GameMode::Difficulty(_) => 1.0,
         };
         Self {
             base,
@@ -549,10 +554,9 @@ fn spawn_win_summary_after_delay(
         // intensity is left at its design-token value because amplitude
         // does not benefit from "fast" / "instant" scaling — at Instant
         // speed the duration is zero anyway, suppressing the shake.
-        let speed = settings.as_ref().map_or(
-            solitaire_data::AnimSpeed::Normal,
-            |s| s.0.animation_speed,
-        );
+        let speed = settings
+            .as_ref()
+            .map_or(solitaire_data::AnimSpeed::Normal, |s| s.0.animation_speed);
         let scaled = scaled_duration(SHAKE_DURATION_SECS, speed);
         shake.remaining = scaled;
         shake.total = scaled;
@@ -632,25 +636,16 @@ fn handle_win_summary_buttons(
                 new_game.write(NewGameRequestEvent::default());
             }
             WinSummaryButton::WatchReplay => {
-                let latest = history
-                    .as_ref()
-                    .and_then(|h| h.0.replays.last())
-                    .cloned();
+                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,
-                        );
+                        crate::replay_playback::start_replay_playback(&mut commands, pb, replay);
                     }
                     (Some(_), None) => {
-                        toast.write(InfoToastEvent(
-                            "Replay playback not available".to_string(),
-                        ));
+                        toast.write(InfoToastEvent("Replay playback not available".to_string()));
                     }
                     (None, _) => {
                         toast.write(InfoToastEvent("No replay saved yet".to_string()));
@@ -710,7 +705,11 @@ fn apply_screen_shake(
     // Decay factor: 1.0 at start, 0.0 at end. Falls back to the design-token
     // duration if `total` is zero (older armings or test setups that bypass
     // `spawn_win_summary_after_delay`) so we never divide by zero.
-    let total = if shake.total > 0.0 { shake.total } else { SHAKE_DURATION_SECS };
+    let total = if shake.total > 0.0 {
+        shake.total
+    } else {
+        SHAKE_DURATION_SECS
+    };
     let decay = shake.remaining / total;
     let elapsed = time.elapsed_secs();
     let offset_x = (elapsed * 47.0).sin() * shake.intensity * decay;
@@ -792,7 +791,10 @@ fn spawn_overlay(
                 // Heading
                 card.spawn((
                     Text::new("You Won!"),
-                    TextFont { font_size: TYPE_DISPLAY, ..default() },
+                    TextFont {
+                        font_size: TYPE_DISPLAY,
+                        ..default()
+                    },
                     TextColor(ACCENT_PRIMARY),
                 ));
 
@@ -800,7 +802,10 @@ fn spawn_overlay(
                 if let Some(level) = challenge_level {
                     card.spawn((
                         Text::new(format!("Challenge {level} complete!")),
-                        TextFont { font_size: TYPE_HEADLINE, ..default() },
+                        TextFont {
+                            font_size: TYPE_HEADLINE,
+                            ..default()
+                        },
                         TextColor(STATE_INFO),
                     ));
                 }
@@ -810,7 +815,10 @@ fn spawn_overlay(
                 if pending.new_record {
                     card.spawn((
                         Text::new("New Record!"),
-                        TextFont { font_size: TYPE_HEADLINE, ..default() },
+                        TextFont {
+                            font_size: TYPE_HEADLINE,
+                            ..default()
+                        },
                         TextColor(STATE_WARNING),
                     ));
                 }
@@ -822,14 +830,20 @@ fn spawn_overlay(
                 // Time
                 card.spawn((
                     Text::new(format!("Time: {}", format_win_time(pending.time_seconds))),
-                    TextFont { font_size: TYPE_HEADLINE, ..default() },
+                    TextFont {
+                        font_size: TYPE_HEADLINE,
+                        ..default()
+                    },
                     TextColor(TEXT_PRIMARY),
                 ));
 
                 // XP total
                 card.spawn((
                     Text::new(format!("XP earned: +{}", pending.xp)),
-                    TextFont { font_size: TYPE_BODY_LG, ..default() },
+                    TextFont {
+                        font_size: TYPE_BODY_LG,
+                        ..default()
+                    },
                     TextColor(STATE_SUCCESS),
                 ));
 
@@ -837,7 +851,10 @@ fn spawn_overlay(
                 if !pending.xp_detail.is_empty() {
                     card.spawn((
                         Text::new(pending.xp_detail.clone()),
-                        TextFont { font_size: 15.0, ..default() },
+                        TextFont {
+                            font_size: 15.0,
+                            ..default()
+                        },
                         TextColor(TEXT_SECONDARY),
                     ));
                 }
@@ -874,7 +891,10 @@ fn spawn_overlay(
                     .with_children(|b| {
                         b.spawn((
                             Text::new("Watch Replay"),
-                            TextFont { font_size: TYPE_BODY_LG, ..default() },
+                            TextFont {
+                                font_size: TYPE_BODY_LG,
+                                ..default()
+                            },
                             TextColor(ACCENT_PRIMARY),
                         ));
                     });
@@ -894,7 +914,10 @@ fn spawn_overlay(
                     .with_children(|b| {
                         b.spawn((
                             Text::new("Play Again  \u{21B5}"),
-                            TextFont { font_size: TYPE_BODY_LG, ..default() },
+                            TextFont {
+                                font_size: TYPE_BODY_LG,
+                                ..default()
+                            },
                             TextColor(BG_BASE),
                         ));
                     });
@@ -915,7 +938,10 @@ const MAX_ACHIEVEMENTS_SHOWN: usize = 3;
 fn spawn_achievements_section(card: &mut ChildSpawnerCommands, names: &[String]) {
     card.spawn((
         Text::new("Achievements Unlocked"),
-        TextFont { font_size: TYPE_BODY_LG, ..default() },
+        TextFont {
+            font_size: TYPE_BODY_LG,
+            ..default()
+        },
         TextColor(ACCENT_PRIMARY),
     ));
 
@@ -923,7 +949,10 @@ fn spawn_achievements_section(card: &mut ChildSpawnerCommands, names: &[String])
     for name in &names[..shown] {
         card.spawn((
             Text::new(format!("  {name}")),
-            TextFont { font_size: 16.0, ..default() },
+            TextFont {
+                font_size: 16.0,
+                ..default()
+            },
             TextColor(TEXT_PRIMARY),
         ));
     }
@@ -932,7 +961,10 @@ fn spawn_achievements_section(card: &mut ChildSpawnerCommands, names: &[String])
     if overflow > 0 {
         card.spawn((
             Text::new(format!("  ...and {overflow} more")),
-            TextFont { font_size: 15.0, ..default() },
+            TextFont {
+                font_size: 15.0,
+                ..default()
+            },
             TextColor(TEXT_SECONDARY),
         ));
     }
@@ -1019,11 +1051,11 @@ fn spawn_score_breakdown(
         row_index += 1;
     }
 
-    // 5. Separator — em-dashes spanning the visual width.
+    // 5. Separator — ASCII dashes spanning the visual width.
     spawn_breakdown_row(
         card,
-        "─────────────────",
-        "─────".to_string(),
+        "-----------------",
+        "-----".to_string(),
         TEXT_SECONDARY,
         anim_speed,
         stagger * row_index as f32,
@@ -1091,13 +1123,19 @@ fn spawn_breakdown_row(
         // Label — left-aligned.
         row.spawn((
             Text::new(label.to_string()),
-            TextFont { font_size: TYPE_BODY, ..default() },
+            TextFont {
+                font_size: TYPE_BODY,
+                ..default()
+            },
             TextColor(label_color_with_alpha),
         ));
         // Value — right-aligned via the parent's JustifyContent::SpaceBetween.
         row.spawn((
             Text::new(value),
-            TextFont { font_size: TYPE_BODY, ..default() },
+            TextFont {
+                font_size: TYPE_BODY,
+                ..default()
+            },
             TextColor(value_color_with_alpha),
         ));
     });
@@ -1170,7 +1208,10 @@ mod tests {
         app.add_plugins(MinimalPlugins)
             .add_plugins(WinSummaryPlugin)
             .insert_resource(StatsResource(StatsSnapshot::default()))
-            .insert_resource(GameStateResource(GameState::new(0, solitaire_core::game_state::DrawMode::DrawOne)))
+            .insert_resource(GameStateResource(GameState::new(
+                0,
+                solitaire_core::game_state::DrawMode::DrawOne,
+            )))
             .insert_resource(ProgressResource(PlayerProgress::default()));
         app.update();
         app
@@ -1282,17 +1323,18 @@ mod tests {
         app.update();
 
         // Confirm it was recorded.
-        assert_eq!(
-            app.world().resource::<SessionAchievements>().names.len(),
-            1
-        );
+        assert_eq!(app.world().resource::<SessionAchievements>().names.len(), 1);
 
         // Fire NewGameRequestEvent — should clear the list.
-        app.world_mut().write_message(NewGameRequestEvent::default());
+        app.world_mut()
+            .write_message(NewGameRequestEvent::default());
         app.update();
 
         assert!(
-            app.world().resource::<SessionAchievements>().names.is_empty(),
+            app.world()
+                .resource::<SessionAchievements>()
+                .names
+                .is_empty(),
             "session achievements must be cleared on NewGameRequestEvent"
         );
     }
@@ -1332,7 +1374,10 @@ mod tests {
         app.update();
 
         assert!(
-            app.world().resource::<SessionAchievements>().names.is_empty(),
+            app.world()
+                .resource::<SessionAchievements>()
+                .names
+                .is_empty(),
             "session achievements must be cleared when a mode-switch NewGameRequestEvent fires"
         );
     }
@@ -1341,15 +1386,20 @@ mod tests {
     fn cache_win_data_sets_score_and_time() {
         let mut app = make_app();
 
-        app.world_mut()
-            .write_message(GameWonEvent { score: 1234, time_seconds: 90 });
+        app.world_mut().write_message(GameWonEvent {
+            score: 1234,
+            time_seconds: 90,
+        });
         app.update();
 
         let pending = app.world().resource::<WinSummaryPending>();
         assert_eq!(pending.score, 1234);
         assert_eq!(pending.time_seconds, 90);
         // 90s < 120s → speed bonus present; default game has undo_count=0 → no-undo bonus present.
-        assert!(!pending.xp_detail.is_empty(), "xp_detail must be populated on GameWonEvent");
+        assert!(
+            !pending.xp_detail.is_empty(),
+            "xp_detail must be populated on GameWonEvent"
+        );
         assert!(pending.xp_detail.contains("+50 base"));
     }
 
@@ -1357,7 +1407,10 @@ mod tests {
     fn cache_win_data_sets_xp_from_xp_awarded_event() {
         let mut app = make_app();
 
-        app.world_mut().write_message(GameWonEvent { score: 0, time_seconds: 0 });
+        app.world_mut().write_message(GameWonEvent {
+            score: 0,
+            time_seconds: 0,
+        });
         app.world_mut().write_message(XpAwardedEvent { amount: 75 });
         app.update();
 
@@ -1369,12 +1422,17 @@ mod tests {
     fn game_won_event_arms_screen_shake() {
         let mut app = make_app();
 
-        app.world_mut()
-            .write_message(GameWonEvent { score: 0, time_seconds: 0 });
+        app.world_mut().write_message(GameWonEvent {
+            score: 0,
+            time_seconds: 0,
+        });
         app.update();
 
         let shake = app.world().resource::<ScreenShakeResource>();
-        assert!(shake.remaining > 0.0, "shake must be armed after GameWonEvent");
+        assert!(
+            shake.remaining > 0.0,
+            "shake must be armed after GameWonEvent"
+        );
     }
 
     // -----------------------------------------------------------------------
@@ -1387,8 +1445,10 @@ mod tests {
         // Any positive-score win should be flagged as a new record.
         let mut app = make_app();
 
-        app.world_mut()
-            .write_message(GameWonEvent { score: 500, time_seconds: 120 });
+        app.world_mut().write_message(GameWonEvent {
+            score: 500,
+            time_seconds: 120,
+        });
         app.update();
 
         let pending = app.world().resource::<WinSummaryPending>();
@@ -1405,12 +1465,17 @@ mod tests {
         }
 
         // Score 500 beats previous best of 400.
-        app.world_mut()
-            .write_message(GameWonEvent { score: 500, time_seconds: 300 });
+        app.world_mut().write_message(GameWonEvent {
+            score: 500,
+            time_seconds: 300,
+        });
         app.update();
 
         let pending = app.world().resource::<WinSummaryPending>();
-        assert!(pending.new_record, "beating best score should set new_record");
+        assert!(
+            pending.new_record,
+            "beating best score should set new_record"
+        );
     }
 
     #[test]
@@ -1423,12 +1488,17 @@ mod tests {
         }
 
         // Score 500 does not beat 800, but time 100 < 200.
-        app.world_mut()
-            .write_message(GameWonEvent { score: 500, time_seconds: 100 });
+        app.world_mut().write_message(GameWonEvent {
+            score: 500,
+            time_seconds: 100,
+        });
         app.update();
 
         let pending = app.world().resource::<WinSummaryPending>();
-        assert!(pending.new_record, "beating fastest time should set new_record");
+        assert!(
+            pending.new_record,
+            "beating fastest time should set new_record"
+        );
     }
 
     #[test]
@@ -1441,8 +1511,10 @@ mod tests {
         }
 
         // Score 500 < 800 and time 120 > 60 — neither record broken.
-        app.world_mut()
-            .write_message(GameWonEvent { score: 500, time_seconds: 120 });
+        app.world_mut().write_message(GameWonEvent {
+            score: 500,
+            time_seconds: 120,
+        });
         app.update();
 
         let pending = app.world().resource::<WinSummaryPending>();
@@ -1472,8 +1544,10 @@ mod tests {
                 GameState::new_with_mode(1, DrawMode::DrawOne, GameMode::Challenge);
         }
 
-        app.world_mut()
-            .write_message(GameWonEvent { score: 0, time_seconds: 0 });
+        app.world_mut().write_message(GameWonEvent {
+            score: 0,
+            time_seconds: 0,
+        });
         app.update();
 
         let pending = app.world().resource::<WinSummaryPending>();
@@ -1488,8 +1562,10 @@ mod tests {
     fn classic_win_leaves_challenge_level_none() {
         let mut app = make_app();
         // Default game mode is Classic — challenge_level should stay None.
-        app.world_mut()
-            .write_message(GameWonEvent { score: 0, time_seconds: 0 });
+        app.world_mut().write_message(GameWonEvent {
+            score: 0,
+            time_seconds: 0,
+        });
         app.update();
 
         let pending = app.world().resource::<WinSummaryPending>();
@@ -1519,8 +1595,10 @@ mod tests {
             game.0.undo_count = 2;
         }
 
-        app.world_mut()
-            .write_message(GameWonEvent { score: 0, time_seconds: 0 });
+        app.world_mut().write_message(GameWonEvent {
+            score: 0,
+            time_seconds: 0,
+        });
         app.update();
 
         let pending = app.world().resource::<WinSummaryPending>();
@@ -1552,7 +1630,10 @@ mod tests {
     fn score_breakdown_zen_mode_zeros_total() {
         let bd = ScoreBreakdown::compute(500, 60, 0, GameMode::Zen, 1.0);
         assert!((bd.multiplier - 0.0).abs() < f32::EPSILON);
-        assert!(bd.shows_multiplier_row(), "Zen ×0 must display the multiplier row");
+        assert!(
+            bd.shows_multiplier_row(),
+            "Zen ×0 must display the multiplier row"
+        );
         assert_eq!(bd.total(), 0);
     }
 
@@ -1616,7 +1697,10 @@ mod tests {
     #[test]
     fn score_breakdown_applies_time_bonus_multiplier() {
         let raw = compute_time_bonus(120);
-        assert_eq!(raw, 5833, "sanity-check raw bonus before testing the multiplier");
+        assert_eq!(
+            raw, 5833,
+            "sanity-check raw bonus before testing the multiplier"
+        );
 
         let bd = ScoreBreakdown::compute(0, 120, 0, GameMode::Classic, 0.5);
         let expected = ((raw as f32) * 0.5).round() as i32;
@@ -1712,9 +1796,27 @@ mod tests {
         // Frame 1: `time.delta` is 0 (first frame), so only row0
         // (delay = 0) should reveal.
         app.update();
-        assert!(app.world().entity(row0).get::<ScoreBreakdownRow>().unwrap().revealed);
-        assert!(!app.world().entity(row1).get::<ScoreBreakdownRow>().unwrap().revealed);
-        assert!(!app.world().entity(row2).get::<ScoreBreakdownRow>().unwrap().revealed);
+        assert!(
+            app.world()
+                .entity(row0)
+                .get::<ScoreBreakdownRow>()
+                .unwrap()
+                .revealed
+        );
+        assert!(
+            !app.world()
+                .entity(row1)
+                .get::<ScoreBreakdownRow>()
+                .unwrap()
+                .revealed
+        );
+        assert!(
+            !app.world()
+                .entity(row2)
+                .get::<ScoreBreakdownRow>()
+                .unwrap()
+                .revealed
+        );
 
         // Advance time by one stagger interval — row1 should reveal.
         {
@@ -1722,8 +1824,20 @@ mod tests {
             time.advance_by(std::time::Duration::from_secs_f32(stagger + 0.001));
         }
         app.update();
-        assert!(app.world().entity(row1).get::<ScoreBreakdownRow>().unwrap().revealed);
-        assert!(!app.world().entity(row2).get::<ScoreBreakdownRow>().unwrap().revealed);
+        assert!(
+            app.world()
+                .entity(row1)
+                .get::<ScoreBreakdownRow>()
+                .unwrap()
+                .revealed
+        );
+        assert!(
+            !app.world()
+                .entity(row2)
+                .get::<ScoreBreakdownRow>()
+                .unwrap()
+                .revealed
+        );
 
         // Advance again — row2 should reveal.
         {
@@ -1731,7 +1845,13 @@ mod tests {
             time.advance_by(std::time::Duration::from_secs_f32(stagger + 0.001));
         }
         app.update();
-        assert!(app.world().entity(row2).get::<ScoreBreakdownRow>().unwrap().revealed);
+        assert!(
+            app.world()
+                .entity(row2)
+                .get::<ScoreBreakdownRow>()
+                .unwrap()
+                .revealed
+        );
     }
 
     /// Under `AnimSpeed::Instant`, breakdown rows must spawn already

solitaire_engine/tests/card_face_svg_pin.rs

@@ -19,7 +19,7 @@
 //! shifts that don't affect what a player sees.
 
 use solitaire_engine::assets::card_face_svg::{
-    back_svg, face_svg, rank_filename, suit_filename, ALL_RANKS, ALL_SUITS, BACK_ACCENTS, TARGET,
+    ALL_RANKS, ALL_SUITS, BACK_ACCENTS, TARGET, back_svg, face_svg, rank_filename, suit_filename,
 };
 use solitaire_engine::assets::rasterize_svg;
 
@@ -145,7 +145,9 @@ fn compute_actual_hashes() -> Vec<(String, u64)> {
 
 fn hash_rasterised(svg: &str) -> u64 {
     let image = rasterize_svg(svg.as_bytes(), TARGET).expect("rasterise card SVG");
-    let bytes = image.data.expect("rasterised image carries RGBA pixel data");
+    let bytes = image
+        .data
+        .expect("rasterised image carries RGBA pixel data");
     fnv1a(&bytes)
 }
 

solitaire_engine/tests/icon_svg_pin.rs

@@ -15,7 +15,7 @@
 //! `card_face_svg_pin.rs`.
 
 use bevy::math::UVec2;
-use solitaire_engine::assets::icon_svg::{icon_svg, ICON_SIZES};
+use solitaire_engine::assets::icon_svg::{ICON_SIZES, icon_svg};
 use solitaire_engine::assets::rasterize_svg;
 
 const EXPECTED: &[(u32, u64)] = &[
@@ -50,10 +50,7 @@ fn rasterised_icon_bytes_match_pinned_hashes() {
     for ((actual_size, actual_hash), (expected_size, expected_hash)) in
         actual.iter().zip(EXPECTED.iter())
     {
-        assert_eq!(
-            actual_size, expected_size,
-            "icon-size order drifted",
-        );
+        assert_eq!(actual_size, expected_size, "icon-size order drifted",);
         if actual_hash != expected_hash {
             mismatches.push(format!(
                 "  icon_{actual_size}: actual 0x{actual_hash:016x}  expected 0x{expected_hash:016x}",
@@ -87,7 +84,9 @@ fn compute_actual_hashes() -> Vec<(u32, u64)> {
 fn hash_rasterised(svg: &str, size: u32) -> u64 {
     let target = UVec2::new(size, size);
     let image = rasterize_svg(svg.as_bytes(), target).expect("rasterise icon SVG");
-    let bytes = image.data.expect("rasterised image carries RGBA pixel data");
+    let bytes = image
+        .data
+        .expect("rasterised image carries RGBA pixel data");
     fnv1a(&bytes)
 }
 

solitaire_server/src/auth.rs

@@ -1,22 +1,17 @@
 //! Authentication handlers: register, login, refresh, delete account,
 //! current-user profile, and avatar upload.
 
-use axum::{
-    body::Bytes,
-    extract::State,
-    http::HeaderMap,
-    Json,
-};
+use axum::{Json, body::Bytes, extract::State, http::HeaderMap};
 use bcrypt::{hash, verify};
 use chrono::Utc;
-use jsonwebtoken::{encode, EncodingKey, Header};
+use jsonwebtoken::{EncodingKey, Header, encode};
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::{
-    error::AppError,
-    middleware::{validate_refresh_token, AuthenticatedUser, Claims},
     AppState,
+    error::AppError,
+    middleware::{AuthenticatedUser, Claims, validate_refresh_token},
 };
 
 // ---------------------------------------------------------------------------
@@ -92,8 +87,12 @@ pub fn make_access_token(user_id: &str, secret: &str) -> Result<String, AppError
         kind: "access".to_string(),
         jti: None,
     };
-    encode(&Header::default(), &claims, &EncodingKey::from_secret(secret.as_bytes()))
-        .map_err(|e| AppError::Internal(e.to_string()))
+    encode(
+        &Header::default(),
+        &claims,
+        &EncodingKey::from_secret(secret.as_bytes()),
+    )
+    .map_err(|e| AppError::Internal(e.to_string()))
 }
 
 /// Encode a JWT refresh token (30-day expiry) for `user_id`.
@@ -109,8 +108,12 @@ pub fn make_refresh_token(user_id: &str, secret: &str) -> Result<(String, String
         kind: "refresh".to_string(),
         jti: Some(jti.clone()),
     };
-    let token = encode(&Header::default(), &claims, &EncodingKey::from_secret(secret.as_bytes()))
-        .map_err(|e| AppError::Internal(e.to_string()))?;
+    let token = encode(
+        &Header::default(),
+        &claims,
+        &EncodingKey::from_secret(secret.as_bytes()),
+    )
+    .map_err(|e| AppError::Internal(e.to_string()))?;
     Ok((token, jti))
 }
 
@@ -176,13 +179,11 @@ pub async fn register(
 
     // Check for duplicate username. SQLite returns TEXT as nullable so we
     // flatten the Option<Option<String>> produced by fetch_optional.
-    let existing: Option<String> = sqlx::query_scalar!(
-        "SELECT id FROM users WHERE username = ?",
-        username
-    )
-    .fetch_optional(&state.pool)
-    .await?
-    .flatten();
+    let existing: Option<String> =
+        sqlx::query_scalar!("SELECT id FROM users WHERE username = ?", username)
+            .fetch_optional(&state.pool)
+            .await?
+            .flatten();
 
     if existing.is_some() {
         tracing::warn!(username = %username, "register: username already taken");
@@ -228,8 +229,12 @@ pub async fn login(
     .await?;
 
     let row = row.ok_or(AppError::InvalidCredentials)?;
-    let row_id = row.id.ok_or_else(|| AppError::Internal("user id missing".into()))?;
-    let row_hash = row.password_hash.ok_or_else(|| AppError::Internal("password hash missing".into()))?;
+    let row_id = row
+        .id
+        .ok_or_else(|| AppError::Internal("user id missing".into()))?;
+    let row_hash = row
+        .password_hash
+        .ok_or_else(|| AppError::Internal("password hash missing".into()))?;
 
     let valid = verify(&body.password, &row_hash)?;
     if !valid {
@@ -266,13 +271,11 @@ pub async fn refresh(
 
     // Verify this jti is still live (not yet consumed or from a deleted account).
     // SQLite TEXT columns are always nullable in sqlx; flatten the double-Option.
-    let exists: Option<String> = sqlx::query_scalar!(
-        "SELECT jti FROM refresh_tokens WHERE jti = ?",
-        jti
-    )
-    .fetch_optional(&state.pool)
-    .await?
-    .flatten();
+    let exists: Option<String> =
+        sqlx::query_scalar!("SELECT jti FROM refresh_tokens WHERE jti = ?", jti)
+            .fetch_optional(&state.pool)
+            .await?
+            .flatten();
 
     if exists.is_none() {
         return Err(AppError::Unauthorized);
@@ -361,12 +364,14 @@ pub async fn upload_avatar(
         .to_string();
     let ext = match mime.as_str() {
         "image/jpeg" | "image/jpg" => "jpg",
-        "image/png"  => "png",
+        "image/png" => "png",
         "image/webp" => "webp",
-        "image/gif"  => "gif",
-        _ => return Err(AppError::BadRequest(
-            "avatar must be image/jpeg, image/png, image/webp, or image/gif".into(),
-        )),
+        "image/gif" => "gif",
+        _ => {
+            return Err(AppError::BadRequest(
+                "avatar must be image/jpeg, image/png, image/webp, or image/gif".into(),
+            ));
+        }
     };
     if body.len() > AVATAR_MAX_BYTES {
         return Err(AppError::BadRequest("avatar must be ≤ 1 MB".into()));
@@ -402,12 +407,10 @@ pub async fn upload_avatar(
     .execute(&state.pool)
     .await?;
 
-    let username: Option<String> = sqlx::query_scalar!(
-        "SELECT username FROM users WHERE id = ?",
-        user.user_id
-    )
-    .fetch_optional(&state.pool)
-    .await?;
+    let username: Option<String> =
+        sqlx::query_scalar!("SELECT username FROM users WHERE id = ?", user.user_id)
+            .fetch_optional(&state.pool)
+            .await?;
 
     Ok(Json(MeResponse {
         id: user.user_id,
@@ -442,13 +445,11 @@ pub async fn reset_password(
         )));
     }
 
-    let user_id: Option<String> = sqlx::query_scalar!(
-        "SELECT id FROM users WHERE username = ?",
-        username
-    )
-    .fetch_optional(pool)
-    .await?
-    .flatten();
+    let user_id: Option<String> =
+        sqlx::query_scalar!("SELECT id FROM users WHERE username = ?", username)
+            .fetch_optional(pool)
+            .await?
+            .flatten();
 
     let user_id =
         user_id.ok_or_else(|| AppError::NotFound(format!("user '{username}' not found")))?;
@@ -475,7 +476,7 @@ pub async fn reset_password(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use jsonwebtoken::{decode, DecodingKey, Validation};
+    use jsonwebtoken::{DecodingKey, Validation, decode};
 
     const TEST_SECRET: &str = "test_secret_for_unit_tests_only";
 
@@ -556,11 +557,11 @@ mod tests {
 
     #[test]
     fn username_chars_ok_rejects_special_chars() {
-        assert!(!username_chars_ok("ali ce"));   // space
-        assert!(!username_chars_ok("ali-ce"));   // hyphen
-        assert!(!username_chars_ok("ali.ce"));   // dot
-        assert!(!username_chars_ok("ali@ce"));   // at
-        assert!(!username_chars_ok("ali!ce"));   // exclamation
+        assert!(!username_chars_ok("ali ce")); // space
+        assert!(!username_chars_ok("ali-ce")); // hyphen
+        assert!(!username_chars_ok("ali.ce")); // dot
+        assert!(!username_chars_ok("ali@ce")); // at
+        assert!(!username_chars_ok("ali!ce")); // exclamation
     }
 
     #[test]

solitaire_server/src/challenge.rs

@@ -6,12 +6,12 @@
 //! generated on first request for that date, then stored in the database
 //! so subsequent calls return the same value.
 
-use axum::{extract::State, Json};
+use axum::{Json, extract::State};
 use chrono::Utc;
 
 use solitaire_sync::ChallengeGoal;
 
-use crate::{error::AppError, AppState};
+use crate::{AppState, error::AppError};
 
 // ---------------------------------------------------------------------------
 // Seed generation
@@ -115,7 +115,9 @@ pub async fn daily_challenge(
     .await?;
 
     if let Some(r) = row {
-        let json = r.goal_json.ok_or_else(|| AppError::Internal("missing goal_json".into()))?;
+        let json = r
+            .goal_json
+            .ok_or_else(|| AppError::Internal("missing goal_json".into()))?;
         let goal: ChallengeGoal = serde_json::from_str(&json)?;
         return Ok(Json(goal));
     }
@@ -148,7 +150,9 @@ pub async fn daily_challenge(
     .fetch_one(&state.pool)
     .await?;
 
-    let stored_json = stored.goal_json.ok_or_else(|| AppError::Internal("missing goal_json after insert".into()))?;
+    let stored_json = stored
+        .goal_json
+        .ok_or_else(|| AppError::Internal("missing goal_json after insert".into()))?;
     let stored_goal: ChallengeGoal = serde_json::from_str(&stored_json)?;
     Ok(Json(stored_goal))
 }
@@ -165,13 +169,22 @@ mod tests {
 
     #[test]
     fn hash_date_differs_across_adjacent_days() {
-        assert_ne!(hash_date_to_u64("2026-04-26"), hash_date_to_u64("2026-04-27"));
-        assert_ne!(hash_date_to_u64("2026-04-26"), hash_date_to_u64("2026-04-25"));
+        assert_ne!(
+            hash_date_to_u64("2026-04-26"),
+            hash_date_to_u64("2026-04-27")
+        );
+        assert_ne!(
+            hash_date_to_u64("2026-04-26"),
+            hash_date_to_u64("2026-04-25")
+        );
     }
 
     #[test]
     fn hash_date_differs_across_years() {
-        assert_ne!(hash_date_to_u64("2026-01-01"), hash_date_to_u64("2027-01-01"));
+        assert_ne!(
+            hash_date_to_u64("2026-01-01"),
+            hash_date_to_u64("2027-01-01")
+        );
     }
 
     #[test]
@@ -217,7 +230,10 @@ mod tests {
     fn generate_goal_all_variants_have_sane_ranges() {
         for variant_idx in 0u64..6 {
             let g = generate_goal("2026-04-26", variant_idx);
-            assert!(!g.description.is_empty(), "variant {variant_idx}: description must not be empty");
+            assert!(
+                !g.description.is_empty(),
+                "variant {variant_idx}: description must not be empty"
+            );
             if let Some(t) = g.max_time_secs {
                 assert!(
                     (60..=3600).contains(&t),

solitaire_server/src/error.rs

@@ -1,9 +1,9 @@
 //! Application-level error type with automatic HTTP response conversion.
 
 use axum::{
+    Json,
     http::StatusCode,
     response::{IntoResponse, Response},
-    Json,
 };
 use serde_json::json;
 use thiserror::Error;
@@ -63,19 +63,31 @@ impl IntoResponse for AppError {
             AppError::NotFound(msg) => (StatusCode::NOT_FOUND, msg.clone()),
             AppError::Database(e) => {
                 tracing::error!("database error: {e}");
-                (StatusCode::INTERNAL_SERVER_ERROR, "internal server error".to_string())
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    "internal server error".to_string(),
+                )
             }
             AppError::BcryptError(e) => {
                 tracing::error!("bcrypt error: {e}");
-                (StatusCode::INTERNAL_SERVER_ERROR, "internal server error".to_string())
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    "internal server error".to_string(),
+                )
             }
             AppError::Json(e) => {
                 tracing::error!("json error: {e}");
-                (StatusCode::INTERNAL_SERVER_ERROR, "internal server error".to_string())
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    "internal server error".to_string(),
+                )
             }
             AppError::Internal(msg) => {
                 tracing::error!("internal error: {msg}");
-                (StatusCode::INTERNAL_SERVER_ERROR, "internal server error".to_string())
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    "internal server error".to_string(),
+                )
             }
         };
 

solitaire_server/src/leaderboard.rs

@@ -3,13 +3,13 @@
 //! `GET  /api/leaderboard`       — list all opted-in entries (requires auth).
 //! `POST /api/leaderboard/opt-in` — opt in and set / update display name.
 
-use axum::{extract::State, Json};
+use axum::{Json, extract::State};
 use chrono::Utc;
 use serde::Deserialize;
 
 use solitaire_sync::LeaderboardEntry;
 
-use crate::{error::AppError, middleware::AuthenticatedUser, AppState};
+use crate::{AppState, error::AppError, middleware::AuthenticatedUser};
 
 // ---------------------------------------------------------------------------
 // Request shapes
@@ -118,7 +118,9 @@ pub async fn opt_in(
 ) -> Result<Json<serde_json::Value>, AppError> {
     let display_name = body.display_name.trim();
     if display_name.is_empty() {
-        return Err(AppError::BadRequest("display_name must not be empty".into()));
+        return Err(AppError::BadRequest(
+            "display_name must not be empty".into(),
+        ));
     }
     if display_name.chars().count() > DISPLAY_NAME_MAX {
         return Err(AppError::BadRequest(format!(
@@ -197,9 +199,9 @@ mod tests {
     fn leaderboard_entries_sorted_by_score_descending() {
         let mut entries = [
             entry("Charlie", Some(1_200)),
-            entry("Alice",   Some(8_000)),
-            entry("Bob",     Some(3_500)),
-            entry("Dave",    None),        // no score — should rank last
+            entry("Alice", Some(8_000)),
+            entry("Bob", Some(3_500)),
+            entry("Dave", None), // no score — should rank last
         ];
 
         // Mirrors the SQL sort:
@@ -214,10 +216,22 @@ mod tests {
         });
 
         // Scored entries first, in descending order.
-        assert_eq!(entries[0].display_name, "Alice",   "highest scorer must be first");
-        assert_eq!(entries[1].display_name, "Bob",     "second-highest scorer must be second");
-        assert_eq!(entries[2].display_name, "Charlie", "lowest scorer must be third");
+        assert_eq!(
+            entries[0].display_name, "Alice",
+            "highest scorer must be first"
+        );
+        assert_eq!(
+            entries[1].display_name, "Bob",
+            "second-highest scorer must be second"
+        );
+        assert_eq!(
+            entries[2].display_name, "Charlie",
+            "lowest scorer must be third"
+        );
         // Null-score entry sinks to the bottom.
-        assert_eq!(entries[3].display_name, "Dave",    "entry with no score must rank last");
+        assert_eq!(
+            entries[3].display_name, "Dave",
+            "entry with no score must rank last"
+        );
     }
 }

solitaire_server/src/lib.rs

@@ -15,22 +15,22 @@ pub mod sync;
 pub use auth::reset_password;
 
 use axum::{
+    Router,
     extract::DefaultBodyLimit,
     http::{HeaderValue, Request},
     middleware as axum_middleware,
     response::{Html, Response},
     routing::{delete, get, post, put},
-    Router,
 };
 
-use jsonwebtoken::{decode, DecodingKey, Validation};
+use jsonwebtoken::{DecodingKey, Validation, decode};
 use sqlx::SqlitePool;
 use std::sync::Arc;
 use tower_governor::{
+    GovernorLayer,
     errors::GovernorError,
     governor::GovernorConfigBuilder,
     key_extractor::{KeyExtractor, SmartIpKeyExtractor},
-    GovernorLayer,
 };
 use tower_http::services::ServeDir;
 
@@ -59,9 +59,7 @@ impl KeyExtractor for UserIdKeyExtractor {
             return Ok(user_id);
         }
         // Fall back to IP so unauthenticated bursts don't bypass throttling.
-        SmartIpKeyExtractor
-            .extract(req)
-            .map(|ip| ip.to_string())
+        SmartIpKeyExtractor.extract(req).map(|ip| ip.to_string())
     }
 }
 
@@ -258,18 +256,12 @@ const CSP: &str = concat!(
 async fn security_headers(req: Request<axum::body::Body>, next: axum_middleware::Next) -> Response {
     let mut res = next.run(req).await;
     let headers = res.headers_mut();
-    headers.insert(
-        "Content-Security-Policy",
-        HeaderValue::from_static(CSP),
-    );
+    headers.insert("Content-Security-Policy", HeaderValue::from_static(CSP));
     headers.insert(
         "X-Content-Type-Options",
         HeaderValue::from_static("nosniff"),
     );
-    headers.insert(
-        "X-Frame-Options",
-        HeaderValue::from_static("DENY"),
-    );
+    headers.insert("X-Frame-Options", HeaderValue::from_static("DENY"));
     res
 }
 

solitaire_server/src/main.rs

@@ -31,12 +31,12 @@
 //! echo "new_password" | ./solitaire_server --reset-password alice
 //! ```
 
-use solitaire_server::{build_router, AppState};
-use sqlx::{sqlite::SqliteConnectOptions, SqlitePool};
+use solitaire_server::{AppState, build_router};
+use sqlx::{SqlitePool, sqlite::SqliteConnectOptions};
 use std::{
     io::{self, BufRead},
-    str::FromStr,
     net::SocketAddr,
+    str::FromStr,
 };
 
 #[tokio::main]
@@ -135,7 +135,5 @@ async fn run_server() {
         .await
         .expect("failed to bind TCP listener");
 
-    axum::serve(listener, app)
-        .await
-        .expect("server error");
+    axum::serve(listener, app).await.expect("server error");
 }

solitaire_server/src/middleware.rs

@@ -10,10 +10,10 @@ use axum::{
     middleware::Next,
     response::Response,
 };
-use jsonwebtoken::{decode, DecodingKey, Validation};
+use jsonwebtoken::{DecodingKey, Validation, decode};
 use serde::{Deserialize, Serialize};
 
-use crate::{error::AppError, AppState};
+use crate::{AppState, error::AppError};
 
 /// The claims encoded in our JWTs.
 #[derive(Debug, Serialize, Deserialize)]
@@ -50,8 +50,7 @@ pub async fn require_auth(
     mut req: Request,
     next: Next,
 ) -> Result<Response, AppError> {
-    let token = extract_bearer_token(req.headers())
-        .ok_or(AppError::Unauthorized)?;
+    let token = extract_bearer_token(req.headers()).ok_or(AppError::Unauthorized)?;
 
     let claims = validate_access_token(&token, &state.jwt_secret)?;
 
@@ -75,8 +74,7 @@ pub fn validate_access_token(token: &str, secret: &str) -> Result<Claims, AppErr
     let mut validation = Validation::default();
     validation.validate_exp = true;
 
-    let data = decode::<Claims>(token, &key, &validation)
-        .map_err(|_| AppError::Unauthorized)?;
+    let data = decode::<Claims>(token, &key, &validation).map_err(|_| AppError::Unauthorized)?;
 
     if data.claims.kind != "access" {
         return Err(AppError::Unauthorized);
@@ -91,8 +89,7 @@ pub fn validate_refresh_token(token: &str, secret: &str) -> Result<Claims, AppEr
     let mut validation = Validation::default();
     validation.validate_exp = true;
 
-    let data = decode::<Claims>(token, &key, &validation)
-        .map_err(|_| AppError::Unauthorized)?;
+    let data = decode::<Claims>(token, &key, &validation).map_err(|_| AppError::Unauthorized)?;
 
     if data.claims.kind != "refresh" {
         return Err(AppError::Unauthorized);
@@ -129,7 +126,7 @@ mod tests {
     use super::*;
     use axum::http::{HeaderMap, HeaderValue};
     use chrono::Utc;
-    use jsonwebtoken::{encode, EncodingKey, Header};
+    use jsonwebtoken::{EncodingKey, Header, encode};
 
     const SECRET: &str = "test_secret_for_middleware_unit_tests_only";
 
@@ -141,7 +138,12 @@ mod tests {
             kind: kind.to_string(),
             jti: None,
         };
-        encode(&Header::default(), &claims, &EncodingKey::from_secret(SECRET.as_bytes())).unwrap()
+        encode(
+            &Header::default(),
+            &claims,
+            &EncodingKey::from_secret(SECRET.as_bytes()),
+        )
+        .unwrap()
     }
 
     // -----------------------------------------------------------------------
@@ -155,7 +157,10 @@ mod tests {
             "Authorization",
             HeaderValue::from_static("Bearer my.jwt.token"),
         );
-        assert_eq!(extract_bearer_token(&headers), Some("my.jwt.token".to_string()));
+        assert_eq!(
+            extract_bearer_token(&headers),
+            Some("my.jwt.token".to_string())
+        );
     }
 
     #[test]
@@ -188,7 +193,8 @@ mod tests {
     #[test]
     fn validate_access_token_accepts_valid_access_token() {
         let token = make_token("user-abc", "access", 3600);
-        let claims = validate_access_token(&token, SECRET).expect("should accept valid access token");
+        let claims =
+            validate_access_token(&token, SECRET).expect("should accept valid access token");
         assert_eq!(claims.sub, "user-abc");
         assert_eq!(claims.kind, "access");
     }
@@ -197,7 +203,10 @@ mod tests {
     fn validate_access_token_rejects_refresh_token() {
         let token = make_token("user-abc", "refresh", 3600);
         let result = validate_access_token(&token, SECRET);
-        assert!(result.is_err(), "refresh token must be rejected by access validator");
+        assert!(
+            result.is_err(),
+            "refresh token must be rejected by access validator"
+        );
     }
 
     #[test]
@@ -212,7 +221,10 @@ mod tests {
     fn validate_access_token_rejects_wrong_secret() {
         let token = make_token("user-abc", "access", 3600);
         let result = validate_access_token(&token, "wrong_secret");
-        assert!(result.is_err(), "token signed with different secret must be rejected");
+        assert!(
+            result.is_err(),
+            "token signed with different secret must be rejected"
+        );
     }
 
     // -----------------------------------------------------------------------
@@ -222,7 +234,8 @@ mod tests {
     #[test]
     fn validate_refresh_token_accepts_valid_refresh_token() {
         let token = make_token("user-xyz", "refresh", 86400);
-        let claims = validate_refresh_token(&token, SECRET).expect("should accept valid refresh token");
+        let claims =
+            validate_refresh_token(&token, SECRET).expect("should accept valid refresh token");
         assert_eq!(claims.sub, "user-xyz");
         assert_eq!(claims.kind, "refresh");
     }
@@ -231,7 +244,10 @@ mod tests {
     fn validate_refresh_token_rejects_access_token() {
         let token = make_token("user-xyz", "access", 86400);
         let result = validate_refresh_token(&token, SECRET);
-        assert!(result.is_err(), "access token must be rejected by refresh validator");
+        assert!(
+            result.is_err(),
+            "access token must be rejected by refresh validator"
+        );
     }
 
     #[test]