test(e2e): update replay payload specs to schema v4

PR #170 changed the web replay payload (moves list -> embedded session
recording) but missed these Playwright specs, which only run on master
pushes and so failed post-merge. Assertions now match the v4 shape:
schema_version 4, recording.initial_state present, moves at
recording.instructions.

Verified locally against a real server with freshly built wasm bundles:
full suite 18/18 green, including the five play_canvas specs.

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

solitaire_core/src/game_state.rs

@@ -22,17 +22,11 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 ///   indices for enum variants. No longer loadable — v3 files are discarded.
 /// - v4: `saved_moves` uses upstream `KlondikeInstruction` serde with named enum
 ///   variants (e.g. `"Foundation1"` instead of `0`).
-/// - v5: `score`, `undo_count`, and `recycle_count` are no longer
+/// - v5 (current): `score`, `undo_count`, and `recycle_count` are no longer
 ///   persisted. They are derived from the upstream `card_game`/`klondike` session
 ///   stats, which are rebuilt by replaying `saved_moves` on load. Older files that
 ///   still carry those keys load fine — the extra fields are ignored.
-/// - v6 (current): `saved_moves` replaced by `recording`, the upstream
+pub const GAME_STATE_SCHEMA_VERSION: u32 = 5;
-///   `card_game` session serialisation carrying the dealt board explicitly.
-///   Loading no longer re-deals from `seed`, so in-progress saves survive
-///   RNG/upstream upgrades that change the seed→deal mapping (the failure
-///   class that PR #170 fixed for replays). v4/v5 files still load through
-///   the legacy seed path and are rewritten as v6 on next save.
-pub const GAME_STATE_SCHEMA_VERSION: u32 = 6;
 
 /// Default move budget for a solvability check. Matches the winnable-deal retry
 /// loop in the engine.
@@ -101,8 +95,8 @@ pub enum GameMode {
     Difficulty(DifficultyLevel),
 }
 
-/// Output struct for schema v6 serialisation. `recording` is the upstream
+/// Output struct for schema v4 serialisation. `saved_moves` uses upstream
-/// session serialisation (config + dealt board + instruction list).
+/// `KlondikeInstruction` serde, which produces named enum variants.
 #[derive(Debug, Clone, Serialize)]
 struct PersistedGameState {
     pub draw_mode: DrawStockConfig,
@@ -111,16 +105,15 @@ struct PersistedGameState {
     pub seed: u64,
     pub take_from_foundation: bool,
     pub schema_version: u32,
-    pub recording: SessionRecording,
+    pub saved_moves: Vec<KlondikeInstruction>,
 }
 
-/// Input struct that accepts schema v4, v5, and v6 save formats.
+/// Input struct that accepts schema v4 and v5 `saved_moves` formats.
 ///
-/// v6 files carry `recording` (the upstream session serialisation, deal
+/// `saved_moves` is deserialised directly as upstream `KlondikeInstruction`
-/// included); v4/v5 files carry `saved_moves` and rebuild the deal from
+/// (named-variant serde). `score`, `undo_count`, and `recycle_count` are
-/// `seed`. `score`, `undo_count`, and `recycle_count` are intentionally
+/// intentionally absent: all three are rebuilt by replaying the instruction
-/// absent: all three are rebuilt by replaying the instruction history
+/// history through the upstream session stats. Older v4 save files still carry
-/// through the upstream session stats. Older v4 save files still carry
 /// those keys; serde ignores them.
 #[derive(Debug, Clone, Deserialize)]
 struct PersistedGameStateIn {
@@ -133,12 +126,7 @@ struct PersistedGameStateIn {
     pub take_from_foundation: bool,
     #[serde(default = "schema_v1")]
     pub schema_version: u32,
-    /// v4/v5 only. Replayed against a seed-dealt board.
-    #[serde(default)]
     pub saved_moves: Vec<KlondikeInstruction>,
-    /// v6 only. Carries the dealt board explicitly.
-    #[serde(default)]
-    pub recording: Option<SessionRecording>,
 }
 
 #[cfg(feature = "test-support")]
@@ -234,7 +222,7 @@ impl Serialize for GameState {
             seed: self.seed,
             take_from_foundation: self.take_from_foundation,
             schema_version: GAME_STATE_SCHEMA_VERSION,
-            recording: self.recording(),
+            saved_moves: self.saved_moves(),
         }
         .serialize(serializer)
     }
@@ -244,51 +232,34 @@ impl<'de> Deserialize<'de> for GameState {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         let persisted = PersistedGameStateIn::deserialize(deserializer)?;
 
-        // Accept v6 (current, recording-based), plus v4/v5 (legacy seed-dealt
+        // Accept v4 (upstream named-variant serde) and v5 (current, derived
-        // saves — loadable while the seed→deal mapping they were written
+        // stats). v3 (legacy u8-index format) and all others are rejected.
-        // under still holds; rewritten as v6 on the next save). v3 (legacy
+        match persisted.schema_version {
-        // u8-index format) and all others are rejected.
+            4 | 5 => {}
-        let (mut game, instructions) = match persisted.schema_version {
-            6 => {
-                let Some(recording) = persisted.recording else {
-                    return Err(serde::de::Error::custom(
-                        "v6 save file is missing the session recording",
-                    ));
-                };
-                // The dealt board and session config come from the recording
-                // itself; `seed` is presentation metadata only.
-                Self::from_recording(&recording, persisted.seed, persisted.mode)
-            }
-            4 | 5 => (
-                Self {
-                    mode: persisted.mode,
-                    elapsed_seconds: 0,
-                    seed: persisted.seed,
-                    take_from_foundation: true,
-                    session: Self::new_session(persisted.seed, persisted.draw_mode),
-                    #[cfg(feature = "test-support")]
-                    test_pile_state: None,
-                },
-                persisted.saved_moves,
-            ),
             v => {
                 return Err(serde::de::Error::custom(format!(
                     "unsupported GameState schema version {v}"
                 )));
             }
-        };
+        }
-        game.mode = persisted.mode;
-        game.elapsed_seconds = persisted.elapsed_seconds;
-        game.take_from_foundation = persisted.take_from_foundation;
 
-        // Replay the saved instruction history with validation — a tampered
+        let mut game = Self {
-        // or corrupt file must surface an error, not a silently wrong board.
+            mode: persisted.mode,
-        // The upstream session tracks score components and recycle_count as
+            elapsed_seconds: persisted.elapsed_seconds,
-        // it processes each move, so the derived stats are correct once
+            seed: persisted.seed,
-        // replay completes. `undo_count()` resets to 0 across save/load
+            take_from_foundation: persisted.take_from_foundation,
-        // because undone moves are not part of the saved forward history.
+            session: Self::new_session(persisted.seed, persisted.draw_mode),
+            #[cfg(feature = "test-support")]
+            test_pile_state: None,
+        };
+
+        // Replay the saved instruction history. The upstream session tracks
+        // score components and recycle_count as it processes each move, so the
+        // derived stats are correct once replay completes. `undo_count()` resets
+        // to 0 across save/load because undone moves are not part of the saved
+        // forward history.
         let replay_config = Self::replay_config(persisted.draw_mode);
-        for instruction in instructions {
+        for instruction in persisted.saved_moves {
             if !game
                 .session
                 .state()
@@ -553,6 +524,16 @@ impl GameState {
         KlondikeAdapter::config_for(self.draw_mode(), self.take_from_foundation)
     }
 
+    /// Collects the session instruction history as upstream types for schema v4
+    /// serialisation.
+    fn saved_moves(&self) -> Vec<KlondikeInstruction> {
+        self.session
+            .history()
+            .iter()
+            .map(|snapshot| *snapshot.instruction())
+            .collect()
+    }
+
     /// Returns the deterministic instruction history for the current deal as
     /// upstream [`KlondikeInstruction`] values.
     ///
@@ -1716,91 +1697,6 @@ mod tests {
         assert_eq!(replayed.move_count(), game.move_count());
     }
 
-    /// v6 save files carry the deal in the recording; the `seed` field is
-    /// presentation metadata. Corrupting it must not change the loaded board.
-    #[test]
-    fn v6_save_load_ignores_seed_for_dealing() {
-        let game = game_with_some_moves(51);
-        let mut value = serde_json::to_value(&game).expect("serialise");
-        assert_eq!(value["schema_version"], 6);
-        value["seed"] = serde_json::Value::from(0xDEAD_BEEF_u64);
-        let loaded: GameState =
-            serde_json::from_value(value).expect("v6 save with wrong seed must still load");
-        assert_eq!(loaded.stock_cards(), game.stock_cards());
-        assert_eq!(loaded.waste_cards(), game.waste_cards());
-        for index in 0..7 {
-            let t = GameState::tableau_from_index(index).expect("tableau index");
-            assert_eq!(
-                loaded.pile(KlondikePile::Tableau(t)),
-                game.pile(KlondikePile::Tableau(t)),
-                "tableau {index} differs"
-            );
-        }
-        assert_eq!(loaded.move_count(), game.move_count());
-        assert_eq!(loaded.score(), game.score());
-    }
-
-    /// Legacy v5 files (seed + saved_moves, no recording) must still load
-    /// through the seed-dealt path until players resave as v6.
-    #[test]
-    fn v5_legacy_save_still_loads() {
-        let game = game_with_some_moves(145);
-        let v5 = serde_json::json!({
-            "draw_mode": game.draw_mode(),
-            "mode": game.mode,
-            "elapsed_seconds": 12,
-            "seed": game.seed,
-            "take_from_foundation": true,
-            "schema_version": 5,
-            "saved_moves": game.instruction_history(),
-        });
-        let loaded: GameState =
-            serde_json::from_value(v5).expect("v5 save must load via the legacy seed path");
-        assert_eq!(loaded.move_count(), game.move_count());
-        assert_eq!(loaded.stock_cards(), game.stock_cards());
-        assert_eq!(loaded.elapsed_seconds, 12);
-    }
-
-    /// A v6 file without the recording payload is malformed and must be
-    /// rejected with an error rather than silently re-dealt from the seed.
-    #[test]
-    fn v6_save_without_recording_is_rejected() {
-        let game = GameState::new(7, DrawStockConfig::DrawOne);
-        let mut value = serde_json::to_value(&game).expect("serialise");
-        value.as_object_mut().expect("object").remove("recording");
-        let err = serde_json::from_value::<GameState>(value)
-            .expect_err("v6 save without recording must fail");
-        assert!(err.to_string().contains("recording"), "got: {err}");
-    }
-
-    /// A recording whose instruction list is invalid for its own deal must
-    /// be rejected on load — tampered or corrupt files surface an error,
-    /// never a silently wrong board.
-    #[test]
-    fn v6_save_with_invalid_history_is_rejected() {
-        use klondike::{DstFoundation, Foundation, KlondikePile};
-        // A foundation move from an empty tableau is never legal on a fresh
-        // deal's first instruction slot for this source shape.
-        let bogus = KlondikeInstruction::DstFoundation(DstFoundation {
-            src: KlondikePile::Foundation(Foundation::Foundation1),
-            foundation: Foundation::Foundation2,
-        });
-        let recording =
-            SessionRecording::from_instructions_unchecked(7, DrawStockConfig::DrawOne, [bogus]);
-        let v6 = serde_json::json!({
-            "draw_mode": DrawStockConfig::DrawOne,
-            "mode": GameMode::Classic,
-            "elapsed_seconds": 0,
-            "seed": 7,
-            "take_from_foundation": true,
-            "schema_version": 6,
-            "recording": recording,
-        });
-        let err =
-            serde_json::from_value::<GameState>(v6).expect_err("invalid history must be rejected");
-        assert!(err.to_string().contains("invalid"), "got: {err}");
-    }
-
     #[test]
     fn from_recording_of_fresh_deal_returns_empty_instructions() {
         let game = GameState::new(7, DrawStockConfig::DrawThree);

solitaire_data/src/storage.rs

@@ -477,7 +477,7 @@ mod tests {
     /// again must reproduce byte-identical JSON. `undo_count` deliberately resets
     /// to 0 on load because only the forward instruction history is persisted.
     #[test]
-    fn game_state_v6_mid_game_round_trip() {
+    fn game_state_v5_mid_game_round_trip() {
         use solitaire_core::KlondikeInstruction;
         use solitaire_core::game_state::GameState;
 
@@ -518,16 +518,11 @@ mod tests {
 
         save_game_state_to(&path, &gs).expect("save");
 
-        // Verify the file carries the v6 schema marker and the recording.
+        // Verify the file carries the v5 schema marker.
         let json = fs::read_to_string(&path).expect("read json");
-        let parsed: serde_json::Value = serde_json::from_str(&json).expect("parse saved json");
-        assert_eq!(
-            parsed["schema_version"], 6,
-            "saved file must use schema version 6",
-        );
         assert!(
-            parsed["recording"].is_object(),
+            json.contains("\"schema_version\"") && json.contains('5'),
-            "saved file must embed the session recording",
+            "saved file must use schema version 5",
         );
 
         let loaded =
@@ -535,7 +530,7 @@ mod tests {
 
         // The forward instruction history round-trips, so the reconstructed board
         // re-serialises to byte-identical JSON.
-        let path_reload = gs_path("v6_mid_game_reload");
+        let path_reload = gs_path("v5_mid_game_reload");
         let _ = fs::remove_file(&path_reload);
         save_game_state_to(&path_reload, &loaded).expect("re-save loaded");
         assert_eq!(

solitaire_server/e2e/tests/gameplay_review.spec.js

@@ -69,9 +69,9 @@ test("draw-mode toggle affects replay payload draw_mode", async ({ page }) => {
 
     const payload = await page.evaluate(() => window.__FERROUS_DEBUG__.replayPayload());
     expect(payload.draw_mode).toBe("DrawThree");
-    expect(payload.schema_version).toBe(2);
+    expect(payload.schema_version).toBe(4);
-    expect(Array.isArray(payload.moves)).toBeTruthy();
+    expect(Array.isArray(payload.recording?.instructions)).toBeTruthy();
-    expect(payload.moves.length).toBeGreaterThan(0);
+    expect(payload.recording.instructions.length).toBeGreaterThan(0);
 });
 
 test("autonomous play keeps invariants stable across seed batch", async ({ page }) => {

solitaire_server/e2e/tests/smoke.spec.js

@@ -47,7 +47,7 @@ test("debug failure report contains replay diagnostics", async ({ page }) => {
     expect(report.invariants).toBeTruthy();
 });
 
-test("replay payload builder exports schema-v2 moves", async ({ page }) => {
+test("replay payload builder exports a schema-v4 recording", async ({ page }) => {
     await page.goto("/play-classic?seed=42");
     await page.waitForFunction(() => typeof window.__FERROUS_DEBUG__ === "object");
 
@@ -57,10 +57,14 @@ test("replay payload builder exports schema-v2 moves", async ({ page }) => {
         .poll(async () => await page.evaluate(() => window.__FERROUS_DEBUG__.replayPayload() !== null))
         .toBe(true);
     const payload = await page.evaluate(() => window.__FERROUS_DEBUG__.replayPayload());
-    expect(payload.schema_version).toBe(2);
+    // Schema v4: the wasm layer assembles the whole payload; the deal is
+    // embedded in `recording` and moves live at recording.instructions.
+    expect(payload.schema_version).toBe(4);
     expect(payload.draw_mode).toMatch(/Draw(One|Three)/);
     expect(payload.mode).toBe("Classic");
-    expect(Array.isArray(payload.moves)).toBeTruthy();
+    expect(payload.recording).toBeTruthy();
-    expect(payload.moves.length).toBeGreaterThan(0);
+    expect(payload.recording.initial_state).toBeTruthy();
-    expect(payload.win_move_index).toBe(payload.moves.length - 1);
+    expect(Array.isArray(payload.recording.instructions)).toBeTruthy();
+    expect(payload.recording.instructions.length).toBeGreaterThan(0);
+    expect(payload.win_move_index).toBe(payload.recording.instructions.length - 1);
 });