style(service): format replay bundle projection

Author: nosam1998

crates/apps/gfa-server/src/event_tests.rs

@@ -114,17 +114,46 @@ async fn event_http_pages_round_trip_across_restart_and_redact_internal_fork_met
 }
 
 #[tokio::test]
-async fn replay_bundle_matches_paged_events_without_exposing_private_inputs() -> Result<(), ServerError> {
+async fn replay_bundle_matches_paged_events_without_exposing_private_inputs(
+) -> Result<(), ServerError> {
     let directory = tempfile::tempdir()?;
     let app = fixture(&config(&directory)).await?;
-    let (_, created) = call(&app.router,"POST","/v1/matches",json!({"game_id":"tictactoe","seed":42}),None).await?;
+    let (_, created) = call(
+        &app.router,
+        "POST",
+        "/v1/matches",
+        json!({"game_id":"tictactoe","seed":42}),
+        None,
+    )
+    .await?;
     let id = created["match_id"].as_str().ok_or("id")?;
-    call(&app.router,"POST",&format!("/v1/matches/{id}/actions"),json!({"seat":0,"turn":0,"action":"r2c2","reasoning":"Center"}),None).await?;
-    let (_, replay) = call(&app.router,"GET",&format!("/v1/matches/{id}/replay?seat=0"),Value::Null,None).await?;
-    let (_, page) = call(&app.router,"GET",&format!("/v1/matches/{id}/events?seat=0"),Value::Null,None).await?;
-    assert_eq!(replay["game_id"],"tictactoe");
-    assert_eq!(replay["revision"],page["revision"]);
-    assert_eq!(replay["events"],page["events"]);
+    call(
+        &app.router,
+        "POST",
+        &format!("/v1/matches/{id}/actions"),
+        json!({"seat":0,"turn":0,"action":"r2c2","reasoning":"Center"}),
+        None,
+    )
+    .await?;
+    let (_, replay) = call(
+        &app.router,
+        "GET",
+        &format!("/v1/matches/{id}/replay?seat=0"),
+        Value::Null,
+        None,
+    )
+    .await?;
+    let (_, page) = call(
+        &app.router,
+        "GET",
+        &format!("/v1/matches/{id}/events?seat=0"),
+        Value::Null,
+        None,
+    )
+    .await?;
+    assert_eq!(replay["game_id"], "tictactoe");
+    assert_eq!(replay["revision"], page["revision"]);
+    assert_eq!(replay["events"], page["events"]);
     assert!(replay["config"].is_object());
     assert!(replay.get("seed").is_none() && replay.get("initial_state").is_none());
     assert!(replay["events"][0].get("initial_state").is_none());

crates/domain/gfa-service/src/events.rs

@@ -44,7 +44,13 @@ impl GameService {
         let end = start
             .saturating_add(query.limit as usize)
             .min(record.events.len());
-        let events = project(&record, &rebuilt, viewer, start..end, &mut ReplayBudget::default())?;
+        let events = project(
+            &record,
+            &rebuilt,
+            viewer,
+            start..end,
+            &mut ReplayBudget::default(),
+        )?;
         Ok(EventPage {
             match_id: id.into(),
             revision: record.events.len() as u64,
@@ -99,85 +105,105 @@ fn project_action(
 }
 
 /// Bound the full bundle while paginated events remain available for large histories.
-pub(crate) struct ReplayBudget { remaining: usize }
+pub(crate) struct ReplayBudget {
+    remaining: usize,
+}
 
 impl Default for ReplayBudget {
-    fn default() -> Self { Self { remaining: 16 * 1024 * 1024 - 4096 } }
+    fn default() -> Self {
+        Self {
+            remaining: 16 * 1024 * 1024 - 4096,
+        }
+    }
 }
 
 impl ReplayBudget {
     pub(crate) fn include(&mut self, value: &impl serde::Serialize) -> Result<(), ApiError> {
-        let size = serde_json::to_vec(value).map_err(|e| error::engine(e.into()))?.len().saturating_add(2);
-        self.remaining = self.remaining.checked_sub(size).ok_or_else(|| ApiError::new(
-            "REPLAY_TOO_LARGE", "Replay exceeds the 16 MiB response budget",
-            "Read paginated /events to export this history in bounded chunks.",
-        ))?;
+        let size = serde_json::to_vec(value)
+            .map_err(|e| error::engine(e.into()))?
+            .len()
+            .saturating_add(2);
+        self.remaining = self.remaining.checked_sub(size).ok_or_else(|| {
+            ApiError::new(
+                "REPLAY_TOO_LARGE",
+                "Replay exceeds the 16 MiB response budget",
+                "Read paginated /events to export this history in bounded chunks.",
+            )
+        })?;
         Ok(())
     }
 }
 
 pub(crate) fn project(
-    record: &MatchRecord, rebuilt: &replay::Reconstructed, viewer: Viewer,
-    range: std::ops::Range<usize>, budget: &mut ReplayBudget,
+    record: &MatchRecord,
+    rebuilt: &replay::Reconstructed,
+    viewer: Viewer,
+    range: std::ops::Range<usize>,
+    budget: &mut ReplayBudget,
 ) -> Result<Vec<RecordedEvent>, ApiError> {
     let first = rebuilt.frames.first().ok_or_else(error::corrupt)?;
     // Same-turn controls only change Frame metadata. The engine state at index
     // zero remains the pristine start, so no second puzzle generation is needed.
     let initial = replay::Frame {
-        state:first.state.clone(), turn:0, terminated:false, truncated:false,
-        outcome:None, draw_offer:None,
-    }.project(&record.id, rebuilt.game.as_ref(), viewer)?;
-        let perfect = rebuilt.game.spec().information == Information::Perfect;
-        let finished = rebuilt.current()?.ended();
-        let mut events = Vec::new();
-        for (offset, event) in record.events[range.clone()].iter().enumerate() {
-            let event = match event {
-                MatchEvent::MatchCreated(origin) => EventData::Created {
-                    game_id: origin.game_id.clone(),
-                    engine_version: origin.engine_version.clone(),
-                    config: rebuilt
-                        .game
-                        .normalize_config(&origin.config)
-                        .map_err(error::engine)?,
-                    seed: (viewer == Viewer::Omniscient).then_some(origin.seed),
-                    initial_state: (viewer == Viewer::Omniscient).then(|| first.state.clone()),
-                    seats: crate::seats::assignments(origin, initial.returns.len()),
-                    assists: origin.assists.clone(),
-                    initial: Box::new(initial.clone()),
-                    at_ms: origin.created_at_ms,
-                },
-                MatchEvent::Action(action) => project_action(action, viewer, perfect, finished)?,
-                MatchEvent::ForkedFrom { source, .. } => EventData::ForkedFrom {
-                    source: source.clone(),
-                },
-                MatchEvent::Resigned { turn, seat, at_ms } => EventData::Resigned {
-                    turn: *turn,
-                    seat: *seat,
-                    at_ms: *at_ms,
-                },
-                MatchEvent::DrawOffered { turn, seat, at_ms } => EventData::DrawOffered {
-                    turn: *turn,
-                    seat: *seat,
-                    at_ms: *at_ms,
-                },
-                MatchEvent::MatchFinished {
-                    turn,
-                    returns,
-                    terminated,
-                    truncated,
-                } => EventData::Finished {
-                    turn: *turn,
-                    returns: returns.clone(),
-                    terminated: *terminated,
-                    truncated: *truncated,
-                },
-            };
-            let projected = RecordedEvent {
-                sequence: (range.start + offset) as u64,
-                event,
-            };
-            budget.include(&projected)?;
-            events.push(projected);
-        }
+        state: first.state.clone(),
+        turn: 0,
+        terminated: false,
+        truncated: false,
+        outcome: None,
+        draw_offer: None,
+    }
+    .project(&record.id, rebuilt.game.as_ref(), viewer)?;
+    let perfect = rebuilt.game.spec().information == Information::Perfect;
+    let finished = rebuilt.current()?.ended();
+    let mut events = Vec::new();
+    for (offset, event) in record.events[range.clone()].iter().enumerate() {
+        let event = match event {
+            MatchEvent::MatchCreated(origin) => EventData::Created {
+                game_id: origin.game_id.clone(),
+                engine_version: origin.engine_version.clone(),
+                config: rebuilt
+                    .game
+                    .normalize_config(&origin.config)
+                    .map_err(error::engine)?,
+                seed: (viewer == Viewer::Omniscient).then_some(origin.seed),
+                initial_state: (viewer == Viewer::Omniscient).then(|| first.state.clone()),
+                seats: crate::seats::assignments(origin, initial.returns.len()),
+                assists: origin.assists.clone(),
+                initial: Box::new(initial.clone()),
+                at_ms: origin.created_at_ms,
+            },
+            MatchEvent::Action(action) => project_action(action, viewer, perfect, finished)?,
+            MatchEvent::ForkedFrom { source, .. } => EventData::ForkedFrom {
+                source: source.clone(),
+            },
+            MatchEvent::Resigned { turn, seat, at_ms } => EventData::Resigned {
+                turn: *turn,
+                seat: *seat,
+                at_ms: *at_ms,
+            },
+            MatchEvent::DrawOffered { turn, seat, at_ms } => EventData::DrawOffered {
+                turn: *turn,
+                seat: *seat,
+                at_ms: *at_ms,
+            },
+            MatchEvent::MatchFinished {
+                turn,
+                returns,
+                terminated,
+                truncated,
+            } => EventData::Finished {
+                turn: *turn,
+                returns: returns.clone(),
+                terminated: *terminated,
+                truncated: *truncated,
+            },
+        };
+        let projected = RecordedEvent {
+            sequence: (range.start + offset) as u64,
+            event,
+        };
+        budget.include(&projected)?;
+        events.push(projected);
+    }
     Ok(events)
 }

crates/domain/gfa-service/src/service.rs

@@ -313,27 +313,46 @@ impl GameService {
         let record = self.record(id).await?;
         let replay = replay::reconstruct(&self.registry, &record)?;
         let origin = record.origin().ok_or_else(error::corrupt)?;
-        let config = replay.game.normalize_config(&origin.config).map_err(error::engine)?;
+        let config = replay
+            .game
+            .normalize_config(&origin.config)
+            .map_err(error::engine)?;
         let mut budget = crate::events::ReplayBudget::default();
         budget.include(&config)?;
         let initial_state = if viewer == Viewer::Omniscient {
-            let state = replay.frames.first().ok_or_else(error::corrupt)?.state.clone();
+            let state = replay
+                .frames
+                .first()
+                .ok_or_else(error::corrupt)?
+                .state
+                .clone();
             budget.include(&state)?;
             Some(state)
-        } else { None };
+        } else {
+            None
+        };
         let mut states = Vec::new();
         for frame in &replay.frames {
             let state = frame.project(id, replay.game.as_ref(), viewer)?;
             budget.include(&state)?;
             states.push(state);
         }
-        let events = crate::events::project(&record, &replay, viewer, 0..record.events.len(), &mut budget)?;
+        let events = crate::events::project(
+            &record,
+            &replay,
+            viewer,
+            0..record.events.len(),
+            &mut budget,
+        )?;
         let ancestors = self.fork_ancestors(&record).await?;
         budget.include(&ancestors)?;
         Ok(Replay {
-            game_id:origin.game_id.clone(), config,
-            seed:(viewer == Viewer::Omniscient).then_some(origin.seed),
-            initial_state, revision:record.events.len() as u64, events,
+            game_id: origin.game_id.clone(),
+            config,
+            seed: (viewer == Viewer::Omniscient).then_some(origin.seed),
+            initial_state,
+            revision: record.events.len() as u64,
+            events,
             match_id: id.into(),
             engine_version: replay.game.spec().engine_version,
             states,

crates/domain/gfa-service/src/tests.rs

@@ -1609,33 +1609,67 @@ fn replay_bundle_contains_projected_events_and_privileged_reconstruction_inputs(
     use gfa_api_types::EventData;
     let (service, _) = fixture()?;
     let initial = run(service.create_match(create("counter"), Viewer::Player(0)))?;
-    run(service.make_move(&initial.match_id, action(0,json!(1)),None))?;
-    run(service.make_move(&initial.match_id, action(1,json!(2)),None))?;
+    run(service.make_move(&initial.match_id, action(0, json!(1)), None))?;
+    run(service.make_move(&initial.match_id, action(1, json!(2)), None))?;
     let public = run(service.get_replay(&initial.match_id, Viewer::Player(0)))?;
     assert_eq!(public.game_id, "counter");
     assert_eq!(public.config, json!({}));
     assert_eq!(public.revision, 3);
     assert_eq!(public.events.len(), 3);
     assert!(public.seed.is_none() && public.initial_state.is_none());
-    assert!(matches!(public.events[0].event, EventData::Created { seed:None, initial_state:None, .. }));
-    assert!(matches!(public.events[2].event, EventData::Action { action:None, reasoning:None, .. }));
+    assert!(matches!(
+        public.events[0].event,
+        EventData::Created {
+            seed: None,
+            initial_state: None,
+            ..
+        }
+    ));
+    assert!(matches!(
+        public.events[2].event,
+        EventData::Action {
+            action: None,
+            reasoning: None,
+            ..
+        }
+    ));
     let full = run(service.get_replay(&initial.match_id, Viewer::Omniscient))?;
     assert_eq!(full.seed, Some(7));
     let game = service.registry.get("counter")?;
     let mut state = full.initial_state.clone().ok_or("initial engine state")?;
-    assert_eq!(game.observe(&state, Viewer::Omniscient)?, full.states[0].observation);
+    assert_eq!(
+        game.observe(&state, Viewer::Omniscient)?,
+        full.states[0].observation
+    );
     for event in &full.events {
-        if let EventData::Action { seat, action:Some(action), .. } = &event.event {
+        if let EventData::Action {
+            seat,
+            action: Some(action),
+            ..
+        } = &event.event
+        {
             state = game.apply(&state, *seat, &action.json)?.0;
         }
     }
-    assert_eq!(game.observe(&state, Viewer::Omniscient)?, full.states.last().ok_or("last")?.observation);
-    let child = run(service.fork_match(&initial.match_id, fork_request(1,false), ForkAccess {
-        viewer:Viewer::Player(1), owns_parent:true, full_state:false,
-    }))?;
+    assert_eq!(
+        game.observe(&state, Viewer::Omniscient)?,
+        full.states.last().ok_or("last")?.observation
+    );
+    let child = run(service.fork_match(
+        &initial.match_id,
+        fork_request(1, false),
+        ForkAccess {
+            viewer: Viewer::Player(1),
+            owns_parent: true,
+            full_state: false,
+        },
+    ))?;
     let fork = run(service.get_replay(&child.state.match_id, Viewer::Omniscient))?;
     assert!(matches!(fork.events[0].event, EventData::ForkedFrom { .. }));
-    assert_eq!(game.observe(&fork.initial_state.ok_or("fork state")?, Viewer::Omniscient)?, fork.states[0].observation);
+    assert_eq!(
+        game.observe(&fork.initial_state.ok_or("fork state")?, Viewer::Omniscient)?,
+        fork.states[0].observation
+    );
     assert_eq!(fork.ancestors.len(), 1);
     Ok(())
 }