test(e2e): read v4 recording.instructions in cycle regression gate

The cycle regression gate still read payload.moves, which schema v4
removed in favour of recording.instructions, so every game reported
replay_history_mismatch:0/N and games_with_issues tripped the
--require-zero-issues gate on master (runs 587/594/596).

Verified locally: 12-game gate run reports 0 issues.

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

solitaire_core/src/game_state.rs

@@ -22,11 +22,17 @@ 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 (current): `score`, `undo_count`, and `recycle_count` are no longer
+/// - v5: `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.
-pub const GAME_STATE_SCHEMA_VERSION: u32 = 5;
+/// - v6 (current): `saved_moves` replaced by `recording`, the upstream
+///   `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.
@@ -95,8 +101,8 @@ pub enum GameMode {
     Difficulty(DifficultyLevel),
 }
 
-/// Output struct for schema v4 serialisation. `saved_moves` uses upstream
+/// Output struct for schema v6 serialisation. `recording` is the upstream
-/// `KlondikeInstruction` serde, which produces named enum variants.
+/// session serialisation (config + dealt board + instruction list).
 #[derive(Debug, Clone, Serialize)]
 struct PersistedGameState {
     pub draw_mode: DrawStockConfig,
@@ -105,15 +111,16 @@ struct PersistedGameState {
     pub seed: u64,
     pub take_from_foundation: bool,
     pub schema_version: u32,
-    pub saved_moves: Vec<KlondikeInstruction>,
+    pub recording: SessionRecording,
 }
 
-/// Input struct that accepts schema v4 and v5 `saved_moves` formats.
+/// Input struct that accepts schema v4, v5, and v6 save formats.
 ///
-/// `saved_moves` is deserialised directly as upstream `KlondikeInstruction`
+/// v6 files carry `recording` (the upstream session serialisation, deal
-/// (named-variant serde). `score`, `undo_count`, and `recycle_count` are
+/// included); v4/v5 files carry `saved_moves` and rebuild the deal from
-/// intentionally absent: all three are rebuilt by replaying the instruction
+/// `seed`. `score`, `undo_count`, and `recycle_count` are intentionally
-/// history through the upstream session stats. Older v4 save files still carry
+/// absent: all three are rebuilt by replaying the instruction history
+/// through the upstream session stats. Older v4 save files still carry
 /// those keys; serde ignores them.
 #[derive(Debug, Clone, Deserialize)]
 struct PersistedGameStateIn {
@@ -126,7 +133,12 @@ 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")]
@@ -222,7 +234,7 @@ impl Serialize for GameState {
             seed: self.seed,
             take_from_foundation: self.take_from_foundation,
             schema_version: GAME_STATE_SCHEMA_VERSION,
-            saved_moves: self.saved_moves(),
+            recording: self.recording(),
         }
         .serialize(serializer)
     }
@@ -232,34 +244,51 @@ impl<'de> Deserialize<'de> for GameState {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         let persisted = PersistedGameStateIn::deserialize(deserializer)?;
 
-        // Accept v4 (upstream named-variant serde) and v5 (current, derived
+        // Accept v6 (current, recording-based), plus v4/v5 (legacy seed-dealt
-        // stats). v3 (legacy u8-index format) and all others are rejected.
+        // saves — loadable while the seed→deal mapping they were written
-        match persisted.schema_version {
+        // under still holds; rewritten as v6 on the next save). v3 (legacy
-            4 | 5 => {}
+        // u8-index format) and all others are rejected.
+        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}"
                 )));
             }
-        }
-
-        let mut game = Self {
-            mode: persisted.mode,
-            elapsed_seconds: persisted.elapsed_seconds,
-            seed: persisted.seed,
-            take_from_foundation: persisted.take_from_foundation,
-            session: Self::new_session(persisted.seed, persisted.draw_mode),
-            #[cfg(feature = "test-support")]
-            test_pile_state: None,
         };
+        game.mode = persisted.mode;
+        game.elapsed_seconds = persisted.elapsed_seconds;
+        game.take_from_foundation = persisted.take_from_foundation;
 
-        // Replay the saved instruction history. The upstream session tracks
+        // Replay the saved instruction history with validation — a tampered
-        // score components and recycle_count as it processes each move, so the
+        // or corrupt file must surface an error, not a silently wrong board.
-        // derived stats are correct once replay completes. `undo_count()` resets
+        // The upstream session tracks score components and recycle_count as
-        // to 0 across save/load because undone moves are not part of the saved
+        // it processes each move, so the derived stats are correct once
-        // forward history.
+        // 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 persisted.saved_moves {
+        for instruction in instructions {
             if !game
                 .session
                 .state()
@@ -461,32 +490,6 @@ impl GameState {
         self.session.stats().stats().recycle_count()
     }
 
-    /// Number of cards moved onto foundations this game, read from the
-    /// upstream session stats. Cumulative like [`Self::recycle_count`] —
-    /// not rolled back on undo.
-    pub fn move_to_foundation_count(&self) -> u32 {
-        self.session.stats().stats().move_to_foundation_count()
-    }
-
-    /// Number of stacks moved onto tableaus (from stock or another tableau)
-    /// this game, read from the upstream session stats. Cumulative — not
-    /// rolled back on undo.
-    pub fn move_to_tableau_count(&self) -> u32 {
-        self.session.stats().stats().move_to_tableau_count()
-    }
-
-    /// Number of cards taken back off a foundation this game, read from the
-    /// upstream session stats. Cumulative — not rolled back on undo.
-    pub fn move_from_foundation_count(&self) -> u32 {
-        self.session.stats().stats().move_from_foundation_count()
-    }
-
-    /// Number of face-down cards revealed (flipped up) this game, read from
-    /// the upstream session stats. Cumulative — not rolled back on undo.
-    pub fn flip_up_count(&self) -> u32 {
-        self.session.stats().stats().flip_up_bonus_count()
-    }
-
     /// Total moves made this game (draws, recycles, and card moves), derived
     /// from the session's instruction history length.
     pub fn move_count(&self) -> u32 {
@@ -550,16 +553,6 @@ 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.
     ///
@@ -1723,6 +1716,91 @@ 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_v5_mid_game_round_trip() {
+    fn game_state_v6_mid_game_round_trip() {
         use solitaire_core::KlondikeInstruction;
         use solitaire_core::game_state::GameState;
 
@@ -518,11 +518,16 @@ mod tests {
 
         save_game_state_to(&path, &gs).expect("save");
 
-        // Verify the file carries the v5 schema marker.
+        // Verify the file carries the v6 schema marker and the recording.
         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!(
-            json.contains("\"schema_version\"") && json.contains('5'),
+            parsed["recording"].is_object(),
-            "saved file must use schema version 5",
+            "saved file must embed the session recording",
         );
 
         let loaded =
@@ -530,7 +535,7 @@ mod tests {
 
         // The forward instruction history round-trips, so the reconstructed board
         // re-serialises to byte-identical JSON.
-        let path_reload = gs_path("v5_mid_game_reload");
+        let path_reload = gs_path("v6_mid_game_reload");
         let _ = fs::remove_file(&path_reload);
         save_game_state_to(&path_reload, &loaded).expect("re-save loaded");
         assert_eq!(

solitaire_engine/src/win_summary_plugin.rs

@@ -18,7 +18,7 @@
 //! shake duration elapses.
 
 use bevy::prelude::*;
-use solitaire_core::game_state::{GameMode, GameState};
+use solitaire_core::game_state::GameMode;
 use solitaire_core::scoring::compute_time_bonus;
 use solitaire_data::AnimSpeed;
 
@@ -93,40 +93,6 @@ pub struct WinSummaryPending {
     /// score-breakdown reveal can format the mode-multiplier row
     /// (e.g. `Zen ×0.0`, `Classic ×1.0`).
     pub mode: GameMode,
-    /// Per-move-type recap of the winning game, e.g.
-    /// `"21 to foundation · 14 tableau moves · 9 flips · 1 recycle"`.
-    /// Built from the upstream session counters at win time; empty when
-    /// every counter is zero (synthesised test wins).
-    pub move_detail: String,
-}
-
-/// Formats the per-move-type recap line for the win modal from the
-/// upstream session counters. Zero-valued components are omitted so the
-/// line stays short; returns an empty string when nothing was counted
-/// (only possible for synthesised test wins).
-fn build_move_detail(game: &GameState) -> String {
-    let mut parts: Vec<String> = Vec::new();
-    let foundation = game.move_to_foundation_count();
-    if foundation > 0 {
-        parts.push(format!("{foundation} to foundation"));
-    }
-    let tableau = game.move_to_tableau_count();
-    if tableau > 0 {
-        parts.push(format!("{tableau} tableau moves"));
-    }
-    let flips = game.flip_up_count();
-    if flips > 0 {
-        parts.push(format!("{flips} flips"));
-    }
-    let recycles = game.recycle_count();
-    if recycles > 0 {
-        parts.push(format!("{recycles} recycles"));
-    }
-    let returns = game.move_from_foundation_count();
-    if returns > 0 {
-        parts.push(format!("{returns} foundation returns"));
-    }
-    parts.join(" \u{00B7} ")
 }
 
 /// Builds a human-readable XP breakdown string for the win modal.
@@ -526,7 +492,6 @@ fn cache_win_data(
         pending.challenge_level = challenge_level;
         pending.undo_count = game.0.undo_count();
         pending.mode = game.0.mode;
-        pending.move_detail = build_move_detail(&game.0);
 
         if is_new_record {
             toast.write(InfoToastEvent("New Record!".to_string()));
@@ -948,18 +913,6 @@ fn spawn_overlay(
                     ));
                 }
 
-                // Move-type recap (same quiet styling as the XP breakdown)
-                if !pending.move_detail.is_empty() {
-                    card.spawn((
-                        Text::new(pending.move_detail.clone()),
-                        TextFont {
-                            font_size: 15.0,
-                            ..default()
-                        },
-                        TextColor(TEXT_SECONDARY),
-                    ));
-                }
-
                 // Achievements unlocked this game — at most 3 shown explicitly;
                 // excess is summarised with "...and N more".
                 if !session.names.is_empty() {
@@ -1335,49 +1288,6 @@ mod tests {
         assert_eq!(p.mode, GameMode::Classic);
     }
 
-    #[test]
-    fn build_move_detail_fresh_game_is_empty() {
-        let game = GameState::new(42, solitaire_core::DrawStockConfig::DrawOne);
-        assert!(
-            build_move_detail(&game).is_empty(),
-            "no moves yet, so the recap line must be empty"
-        );
-    }
-
-    #[test]
-    fn build_move_detail_reports_played_move_types() {
-        use solitaire_core::KlondikeInstruction;
-        // Drive a real deal forward so the upstream counters accumulate:
-        // prefer foundation moves, then anything else, drawing as needed.
-        let mut game = GameState::new(42, solitaire_core::DrawStockConfig::DrawOne);
-        for _ in 0..80 {
-            let instructions = game.possible_instructions();
-            let next = instructions
-                .iter()
-                .copied()
-                .find(|i| matches!(i, KlondikeInstruction::DstFoundation(_)))
-                .or_else(|| instructions.into_iter().next());
-            match next {
-                Some(i) => {
-                    let _ = game.apply_instruction(i);
-                }
-                None => break,
-            }
-            if game.move_to_foundation_count() > 0 && game.move_to_tableau_count() > 0 {
-                break;
-            }
-        }
-        let detail = build_move_detail(&game);
-        assert!(
-            detail.contains("to foundation"),
-            "seed 42 reaches a foundation move within 80 plies; got: {detail}"
-        );
-        assert!(
-            !detail.contains("0 "),
-            "zero-valued components must be omitted; got: {detail}"
-        );
-    }
-
     #[test]
     fn build_xp_detail_slow_win_with_undo() {
         // 300s >= 120s → no speed bonus; undo used → no no-undo bonus.

solitaire_server/e2e/scripts/cycle_metrics.js

@@ -206,7 +206,9 @@ async function main() {
                     invariant_ok: !!snap?.invariants?.state_ok,
                     history_len: Array.isArray(snap?.move_history) ? snap.move_history.length : null,
                     replay_payload_present: payload !== null,
-                    replay_moves_len: Array.isArray(payload?.moves) ? payload.moves.length : 0,
+                    replay_moves_len: Array.isArray(payload?.recording?.instructions)
+                        ? payload.recording.instructions.length
+                        : 0,
                 };
             }, { stepCap: maxSteps, policyName: policy, maxVisits: maxVisitsPerState });
 

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);
 });

solitaire_server/web/replay.js

@@ -315,9 +315,10 @@ btnPlay.addEventListener("click", () => {
     }, STEP_INTERVAL_MS);
 });
 
-/// Step the player back one move via the wasm-side seek (rewinds to the
+/// Step the player back one move. Re-creates the ReplayPlayer and fast-
-/// recorded deal and fast-forwards internally), then renders once so the
+/// forwards to (step_idx - 1) without rendering intermediate frames, then
-/// CSS transition animates each card to its previous position.
+/// renders once so the CSS transition animates each card to its previous
+/// position.
 function stepBack() {
     if (!player || player.step_idx() === 0) return;
     if (playInterval) {
@@ -325,7 +326,12 @@ function stepBack() {
         playInterval = null;
         btnPlay.textContent = "▶ Play";
     }
-    render(player.seek(player.step_idx() - 1));
+    const target = player.step_idx() - 1;
+    player = new ReplayPlayer(replayJson);
+    for (let i = 0; i < target; i++) {
+        player.step();
+    }
+    render(player.state());
     btnPrev.disabled = player.step_idx() === 0;
     btnRestart.disabled = player.step_idx() === 0;
     btnStep.disabled = false;

solitaire_wasm/src/lib.rs

@@ -110,9 +110,6 @@ impl From<&(Card, bool)> for CardSnapshot {
 #[wasm_bindgen]
 pub struct ReplayPlayer {
     game: GameState,
-    /// The recorded deal before any instruction, kept so [`Self::seek_native`]
-    /// can rewind without reparsing the replay JSON.
-    initial: GameState,
     moves: Vec<KlondikeInstruction>,
     step_idx: usize,
 }
@@ -147,30 +144,12 @@ impl ReplayPlayer {
         // the current build maps seeds to deals.
         let (game, moves) = GameState::from_recording(&replay.recording, replay.seed, replay.mode);
         Ok(Self {
-            initial: game.clone(),
             game,
             moves,
             step_idx: 0,
         })
     }
 
-    /// Jump to `step` (clamped to the move count): the board state after
-    /// `step` moves have been applied. Rewinds by resetting to the stored
-    /// initial deal, then fast-forwards — a few hundred instruction
-    /// applications, microseconds in practice.
-    pub fn seek_native(&mut self, step: usize) -> Result<StateSnapshot, MoveError> {
-        let target = step.min(self.moves.len());
-        if target < self.step_idx {
-            self.game = self.initial.clone();
-            self.step_idx = 0;
-        }
-        while self.step_idx < target {
-            self.game.apply_instruction(self.moves[self.step_idx])?;
-            self.step_idx += 1;
-        }
-        Ok(self.snapshot())
-    }
-
     /// Apply the next move. Returns `Ok(None)` once the list is exhausted.
     pub fn step_native(&mut self) -> Result<Option<StateSnapshot>, MoveError> {
         if self.step_idx >= self.moves.len() {
@@ -257,25 +236,6 @@ impl ReplayPlayer {
         }
     }
 
-    /// Jump directly to `step` moves applied (clamped to the move count)
-    /// and return the snapshot there. Backwards seeks rewind to the
-    /// recorded deal and fast-forward, so any position is O(replay length)
-    /// at worst — no JSON reparse, no intermediate renders.
-    ///
-    /// Throws `"replay_desync"` if a recorded move is illegal during the
-    /// fast-forward (corrupt recording).
-    pub fn seek(&mut self, step: usize) -> Result<JsValue, JsValue> {
-        match self.seek_native(step) {
-            Ok(snap) => {
-                serde_wasm_bindgen::to_value(&snap).map_err(|e| JsValue::from_str(&e.to_string()))
-            }
-            Err(e) => {
-                log_replay_move_error(&e);
-                Err(JsValue::from_str("replay_desync"))
-            }
-        }
-    }
-
     /// Total number of moves the replay contains.
     pub fn total_steps(&self) -> usize {
         self.moves.len()
@@ -1102,57 +1062,6 @@ mod tests {
         assert_eq!(orig["stock"], repl["stock"], "stock deal must match");
     }
 
-    /// `seek` must land on exactly the state produced by stepping — both
-    /// forwards (fast-forward from the current position) and backwards
-    /// (rewind to the recorded deal, then fast-forward).
-    #[test]
-    fn seek_matches_stepping_in_both_directions() {
-        let mut game = SolitaireGame {
-            game: GameState::new_with_mode(51, DrawStockConfig::DrawOne, GameMode::Classic),
-        };
-        for _ in 0..24 {
-            let legal_moves = game.legal_moves_native();
-            if legal_moves.is_empty() {
-                break;
-            }
-            let idx = pick_move_index(&legal_moves).unwrap_or_default();
-            game.apply_legal_move_native(idx).expect("advance game");
-        }
-        let replay_json = game
-            .replay_export_native(60, "2026-07-10")
-            .expect("export replay");
-
-        let mut stepped = ReplayPlayer::from_json(&replay_json).expect("player A");
-        let mut seeker = ReplayPlayer::from_json(&replay_json).expect("player B");
-        let total = stepped.total_steps();
-        assert!(total >= 4, "test needs a few moves, got {total}");
-
-        // Forward: step A to k, seek B to k, compare snapshots.
-        let k = total / 2;
-        for _ in 0..k {
-            stepped.step_native().expect("step").expect("mid-replay");
-        }
-        let sought = seeker.seek_native(k).expect("seek forward");
-        assert_eq!(sought, stepped.snapshot(), "forward seek diverged at {k}");
-
-        // Backward: seek B to k - 2 and compare against a fresh stepper.
-        let back = k - 2;
-        let mut fresh = ReplayPlayer::from_json(&replay_json).expect("player C");
-        for _ in 0..back {
-            fresh.step_native().expect("step").expect("mid-replay");
-        }
-        let sought_back = seeker.seek_native(back).expect("seek backward");
-        assert_eq!(
-            sought_back,
-            fresh.snapshot(),
-            "backward seek diverged at {back}"
-        );
-
-        // Clamping: past-the-end seeks stop at the final state.
-        let end = seeker.seek_native(usize::MAX).expect("seek to end");
-        assert_eq!(end.step_idx, total);
-    }
-
     #[test]
     fn debug_api_autonomous_seed_batch_smoke() {
         for seed in 0_u64..128_u64 {