gameplay: compose normal map command flow

crates/urt-gameplay/src/bin/urt-map-commands.rs

@@ -79,6 +79,64 @@ fn run() -> Result<String, String> {
                 map_effects_json(&r.effects)
             ))
         }
+        "flow" => {
+            if w.len() < 17 {
+                return Err("missing flow header".into());
+            }
+            let mut state = map_state(&w[..11]);
+            let mut rotation = Rotation {
+                enabled: w[11] as i32,
+                cursor: w[12] as i32,
+                limit: w[13] as i32,
+                filename: b"previous.cfg".to_vec(),
+            };
+            let n = w[16] as usize;
+            if n > 64 || w.len() < 17 + 5 * n {
+                return Err("invalid flow count".into());
+            }
+            let mut clients = w[17..17 + 5 * n]
+                .chunks_exact(5)
+                .map(|v| urt_gameplay::transition::MapClient {
+                    score: v[0] as i32,
+                    field304: v[1] as i32,
+                    field308: v[2] as i32,
+                    connection: v[3] as i32,
+                    class: v[4] as i32,
+                })
+                .collect::<Vec<_>>();
+            let mut p = 17 + 5 * n;
+            let updated = bytes(&w, &mut p)?;
+            let mut mirror = bytes(&w, &mut p)?;
+            let current = bytes(&w, &mut p)?;
+            if p != w.len() {
+                return Err("trailing flow words".into());
+            }
+            let changes = if w[15] != 0 { vec![(0, 0)] } else { vec![] };
+            let out = normal_next_map(
+                &mut state,
+                &mut rotation,
+                &mut mirror,
+                &mut clients,
+                NormalInputs {
+                    count: w[14] as usize,
+                    updated_filename: &updated,
+                    engine_map: &current,
+                    connection_changes: &changes,
+                },
+            )
+            .map_err(|e| format!("{e:?}"))?;
+            Ok(format!(
+                "{{\"state\":{},\"cursor\":{},\"filename\":\"{}\",\"mirror\":\"{}\",\"middle\":{},\"clients\":{},\"rotation_operations\":{},\"map_operations\":{}}}",
+                map_json(&state),
+                rotation.cursor as u32,
+                hex(&rotation.filename),
+                hex(&mirror),
+                clients_json(&out.middle),
+                clients_json(&clients),
+                rotation_json(&out.rotation),
+                map_effects_json(&out.selection.effects)
+            ))
+        }
         _ => Err("unknown command".into()),
     }
 }
@@ -111,3 +169,69 @@ fn map_effects_json(e: &[MapEffect]) -> String {
             .join(",")
     )
 }
+
+fn map_state(v: &[u32]) -> urt_gameplay::transition::MapState {
+    urt_gameplay::transition::MapState {
+        phase: v[0] as i32,
+        option: v[1] as i32,
+        flags: v[2],
+        mode: v[3] as i32,
+        scores: [v[4] as i32, v[5] as i32],
+        blocked: v[6] as i32,
+        pending: v[7] as i32,
+        saved: [v[8] as i32, v[9] as i32],
+        round: v[10] as i32,
+    }
+}
+fn map_json(s: &urt_gameplay::transition::MapState) -> String {
+    let keys = [
+        "phase",
+        "option",
+        "flags",
+        "mode",
+        "first",
+        "second",
+        "blocked",
+        "pending",
+        "saved_second",
+        "saved_first",
+        "round",
+    ];
+    let values = [
+        s.phase as u32,
+        s.option as u32,
+        s.flags,
+        s.mode as u32,
+        s.scores[0] as u32,
+        s.scores[1] as u32,
+        s.blocked as u32,
+        s.pending as u32,
+        s.saved[0] as u32,
+        s.saved[1] as u32,
+        s.round as u32,
+    ];
+    format!(
+        "{{{}}}",
+        keys.iter()
+            .zip(values)
+            .map(|(k, v)| format!("\"{k}\":{v}"))
+            .collect::<Vec<_>>()
+            .join(",")
+    )
+}
+fn clients_json(c: &[urt_gameplay::transition::MapClient]) -> String {
+    format!(
+        "[{}]",
+        c.iter()
+            .map(|c| format!(
+                "{{\"248\":{},\"304\":{},\"308\":{},\"468\":{},\"696\":{}}}",
+                c.score as u32,
+                c.field304 as u32,
+                c.field308 as u32,
+                c.connection as u32,
+                c.class as u32
+            ))
+            .collect::<Vec<_>>()
+            .join(",")
+    )
+}

crates/urt-gameplay/src/map_commands.rs

@@ -161,3 +161,160 @@ mod select_tests {
         assert_eq!(select_map(&[1; 4097], b"x"), Err(Error::BytesTooLong));
     }
 }
+
+pub struct NormalInputs<'a> {
+    pub count: usize,
+    pub updated_filename: &'a [u8],
+    pub engine_map: &'a [u8],
+    pub connection_changes: &'a [(usize, i32)],
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct NormalFlow {
+    pub rotation: Vec<RotationEffect>,
+    pub selection: MapSelection,
+    pub middle: Vec<crate::transition::MapClient>,
+}
+/// Compose recovered normal6939 children. External callbacks are supplied inputs
+/// and ordered intentions; the final scan observes supplied249007 connections.
+pub fn normal_next_map(
+    state: &mut crate::transition::MapState,
+    rotation: &mut Rotation,
+    mirror: &mut Vec<u8>,
+    clients: &mut [crate::transition::MapClient],
+    input: NormalInputs<'_>,
+) -> Result<NormalFlow, Error> {
+    if state.phase > 0 && crate::intermission::team_mode(state.mode) {
+        return Err(Error::ModeMismatch);
+    }
+    if clients.len() > 64
+        || input.count > clients.len()
+        || input
+            .connection_changes
+            .iter()
+            .any(|(j, _)| *j >= clients.len())
+    {
+        return Err(Error::InvalidCount);
+    }
+    let mut s = state.clone();
+    let mut r = rotation.clone();
+    let mut c = clients.to_vec();
+    let effects = advance_rotation(&mut r, input.updated_filename)?;
+    let selection = select_map(mirror, input.engine_map)?;
+    crate::transition::prepare_normal(&mut s, &mut c, input.count)
+        .map_err(|_| Error::InvalidCount)?;
+    let middle = c.clone();
+    for (j, v) in input.connection_changes {
+        c[*j].connection = *v;
+    }
+    crate::transition::mark_connecting(&mut c, input.count).map_err(|_| Error::InvalidCount)?;
+    *state = s;
+    *rotation = r;
+    *mirror = selection.mirror.clone();
+    clients.copy_from_slice(&c);
+    Ok(NormalFlow {
+        rotation: effects,
+        selection,
+        middle,
+    })
+}
+#[cfg(test)]
+mod normal_flow_tests {
+    use super::*;
+    use crate::transition::{MapClient, MapState};
+    #[test]
+    fn child_connection_override_and_command_state() {
+        let mut s = MapState {
+            phase: 2,
+            mode: 9,
+            scores: [5, -7],
+            blocked: 123,
+            pending: 321,
+            ..Default::default()
+        };
+        let mut r = Rotation {
+            enabled: 1,
+            cursor: 1,
+            limit: 2,
+            filename: b"previous".to_vec(),
+        };
+        let mut mirror = b"cycle".to_vec();
+        let mut c = [MapClient {
+            score: 4,
+            field304: 5,
+            field308: 6,
+            connection: 2,
+            class: 9,
+        }; 2];
+        let out = normal_next_map(
+            &mut s,
+            &mut r,
+            &mut mirror,
+            &mut c,
+            NormalInputs {
+                count: 2,
+                updated_filename: b"out",
+                engine_map: b"current",
+                connection_changes: &[(0, 0)],
+            },
+        )
+        .unwrap();
+        assert_eq!(
+            (
+                out.middle[0].score,
+                out.middle[0].field304,
+                out.middle[0].connection
+            ),
+            (0, 0, 2)
+        );
+        assert_eq!((c[0].connection, c[1].connection), (0, 1));
+        assert_eq!(
+            (s.scores, s.blocked, s.pending, s.phase),
+            ([0, 0], 0, 321, 2)
+        );
+        assert_eq!(out.selection.command, Some(b"map cycle\n".to_vec()));
+        assert_eq!(mirror, b"cycle");
+        assert_eq!(r.filename, b"out");
+    }
+    #[test]
+    fn reject_series_and_bad_callback_without_mutation() {
+        let mut s = MapState {
+            phase: 1,
+            mode: 3,
+            ..Default::default()
+        };
+        let old = s.clone();
+        let mut r = Rotation {
+            enabled: 1,
+            cursor: 1,
+            limit: 2,
+            filename: vec![],
+        };
+        let before = r.clone();
+        let mut mirror = vec![];
+        let mut c = [];
+        let input = NormalInputs {
+            count: 0,
+            updated_filename: b"out",
+            engine_map: b"x",
+            connection_changes: &[],
+        };
+        assert_eq!(
+            normal_next_map(&mut s, &mut r, &mut mirror, &mut c, input),
+            Err(Error::ModeMismatch)
+        );
+        assert_eq!(s, old);
+        assert_eq!(r, before);
+        s.phase = 0;
+        let input = NormalInputs {
+            count: 0,
+            updated_filename: b"out",
+            engine_map: b"x",
+            connection_changes: &[(0, 0)],
+        };
+        assert_eq!(
+            normal_next_map(&mut s, &mut r, &mut mirror, &mut c, input),
+            Err(Error::InvalidCount)
+        );
+        assert_eq!(r, before);
+    }
+}

docs/FINDINGS.md

@@ -1609,10 +1609,13 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 **RE-869:** Rust matches192 original rotation cases, preserving signed cursor wrap, enable/threshold gating, refreshed filename C-string handling and ordered refresh/write/clear/reset intentions. Engine refresh input is explicit; invalid refreshed data rejects before boundary mutations. Native callbacks remain unimplemented. [Evidence](research/RUST_ROTATION_ADVANCE.md).
 
 
-**RE-870:** 90 original7188 cases compose actual strlen, bounded-copy wrapper and original formatter. A nonempty override mirror records current engine mapname in g_nextCycleMap, copies the override into a127-byte local command buffer, requests engine g_NextMap clear and emits mode2 map command. VM mirror bytes remain unchanged; engine/native-copy and lower effects remain supplied/captured. [Evidence](research/QVM_MAP_SELECT.md).
+**RE-870:** 90 original7188 cases compose actual strlen, bounded-copy wrapper and original formatter. A nonempty override mirror records current engine mapname in g_nextCycleMap, copies the override into a128-byte local map-name buffer (127-byte payload), requests engine g_NextMap clear and emits mode2 map command. VM mirror bytes remain unchanged; engine/native-copy and lower effects remain supplied/captured. [Evidence](research/QVM_MAP_SELECT.md).
 
 
 **RE-871:** Rust matches90 original map-selection cases with empty/NUL mirror gates,127-byte engine-mapname truncation, raw non-UTF8 bytes, unchanged VM mirror and exact truncated-override mode2 map command text. The typed effect order matches source cvar/read/command requests. Engine callbacks, native copy and actual command dispatch remain outside the port. [Evidence](research/RUST_MAP_SELECT.md).
 
 
 **RE-872:** 192 actual6939 normal-path cases compose recovered rotation, map selection, mode classification, copy and formatter bodies on shared state. Optional supplied249007 connection changes prove the final scan sees child mutations. Cvar/engine bytes, native copy and lower callback/runtime effects remain explicit boundaries. [Evidence](research/QVM_NORMAL_MAP_FLOW.md).
+
+
+**RE-873:** Rust matches192 original normal6939 cases, staging rotation, override map-command intentions, global/client resets and post-callback connection changes atomically. The API refuses team-series inputs and invalid callback indices. VM mirrors/pending/series data remain source-faithful; native callbacks, engine refresh and runtime integration remain open. [Evidence](research/RUST_NORMAL_MAP_FLOW.md).

docs/PROVISIONAL_TODO.md

@@ -1613,7 +1613,7 @@ RE-862: 96 continuous setup→placement cases now execute class-hash, field/stri
 RE-863: Rust matches all96 composed source setup/placement fixtures across searches, actual RNG state transitions, checked angle-math transcripts and resolved player indirection. Fallible resolution stages RNG before committing it and performs placement only after success. Fallback selection and native math parity remain explicit boundaries; intermission/respawn/runtime integration is still open. Full runtime completion remains open. [Evidence](research/RUST_CAMERA_WORLD.md).
 
 
-- [ ] RE-864: Recover fallback/native math, compose camera into respawn/intermission, resolve map/allocation/publication effects and validate actual macOS/Linux game traces. [Scope](research/QVM_CAMERA_WORLD_BATCH.md).
+- [x] RE-864–873: Recover fallback spawn/camera and normal map command/reset contracts. Remaining native/runtime scope continues under RE-874. [Evidence](research/QVM_SPAWN_MAP_COMMAND_BATCH.md).
 
 
 RE-864: 112 original168114 cases execute actual class-hash search and RNG, recovering stable farthest-first insertion,64-entry cap, far-half draw at8+, first-class fallback when blocked, +9 Z and a no-spawn fatal boundary. Telefrag answers and finite sqrt remain supplied; collision/native/runtime parity is open. Full runtime completion remains open. [Evidence](research/QVM_SPAWN_FALLBACK.md).
@@ -1634,10 +1634,16 @@ RE-868: 192 original122230 cases execute actual strlen and recover signed counte
 RE-869: Rust matches192 original rotation cases, preserving signed cursor wrap, enable/threshold gating, refreshed filename C-string handling and ordered refresh/write/clear/reset intentions. Engine refresh input is explicit; invalid refreshed data rejects before boundary mutations. Native callbacks remain unimplemented. Full runtime completion remains open. [Evidence](research/RUST_ROTATION_ADVANCE.md).
 
 
-RE-870: 90 original7188 cases compose actual strlen, bounded-copy wrapper and original formatter. A nonempty override mirror records current engine mapname in g_nextCycleMap, copies the override into a127-byte local command buffer, requests engine g_NextMap clear and emits mode2 map command. VM mirror bytes remain unchanged; engine/native-copy and lower effects remain supplied/captured. Full runtime completion remains open. [Evidence](research/QVM_MAP_SELECT.md).
+RE-870: 90 original7188 cases compose actual strlen, bounded-copy wrapper and original formatter. A nonempty override mirror records current engine mapname in g_nextCycleMap, copies the override into a128-byte local map-name buffer (127-byte payload), requests engine g_NextMap clear and emits mode2 map command. VM mirror bytes remain unchanged; engine/native-copy and lower effects remain supplied/captured. Full runtime completion remains open. [Evidence](research/QVM_MAP_SELECT.md).
 
 
 RE-871: Rust matches90 original map-selection cases with empty/NUL mirror gates,127-byte engine-mapname truncation, raw non-UTF8 bytes, unchanged VM mirror and exact truncated-override mode2 map command text. The typed effect order matches source cvar/read/command requests. Engine callbacks, native copy and actual command dispatch remain outside the port. Full runtime completion remains open. [Evidence](research/RUST_MAP_SELECT.md).
 
 
 RE-872: 192 actual6939 normal-path cases compose recovered rotation, map selection, mode classification, copy and formatter bodies on shared state. Optional supplied249007 connection changes prove the final scan sees child mutations. Cvar/engine bytes, native copy and lower callback/runtime effects remain explicit boundaries. Full runtime completion remains open. [Evidence](research/QVM_NORMAL_MAP_FLOW.md).
+
+
+RE-873: Rust matches192 original normal6939 cases, staging rotation, override map-command intentions, global/client resets and post-callback connection changes atomically. The API refuses team-series inputs and invalid callback indices. VM mirrors/pending/series data remain source-faithful; native callbacks, engine refresh and runtime integration remain open. Full runtime completion remains open. [Evidence](research/RUST_NORMAL_MAP_FLOW.md).
+
+
+- [ ] RE-874: Recover telefrag/native math, respawn/slow setup, lower map/rotation callbacks, allocation/publication and actual macOS/Linux runtime integration. [Scope](research/QVM_SPAWN_MAP_COMMAND_BATCH.md).

docs/RESEARCH_LEDGER.md

@@ -2061,3 +2061,12 @@ Rust matches90 original map-selection cases with empty/NUL mirror gates,127-byte
 ## 2026-10-27 — RE-872 Original normal next-map flow with recovered command children
 
 192 actual6939 normal-path cases compose recovered rotation, map selection, mode classification, copy and formatter bodies on shared state. Optional supplied249007 connection changes prove the final scan sees child mutations. Cvar/engine bytes, native copy and lower callback/runtime effects remain explicit boundaries. Focused `cargo xtask test-group normal-map-flow` passes (5 Python tests); selected reports regenerate twice deterministically, with storage, documentation links and whitespace guards. Full suite deferred to task ten. Original assets unchanged; source fixtures do not establish complete native/runtime parity.
+
+
+## 2026-10-27 — RE-873 Rust recovered normal next-map command and reset composition
+
+Rust matches192 original normal6939 cases, staging rotation, override map-command intentions, global/client resets and post-callback connection changes atomically. The API refuses team-series inputs and invalid callback indices. VM mirrors/pending/series data remain source-faithful; native callbacks, engine refresh and runtime integration remain open. Focused `cargo xtask test-group rust-normal-map-flow` passes (9 Python tests); selected reports regenerate twice deterministically, with storage, documentation links and whitespace guards. Full suite deferred to task ten. Original assets unchanged; source fixtures do not establish complete native/runtime parity.
+
+RE-873 final review: targeted xtask dependency-registry regression passes for all five parity report edges and shared camera/transition/intermission/map module consumers. Added the batch findings and RE-874 native/runtime follow-ups.
+
+Batch RE-864–873 boundary: the single `cargo xtask test-full --since 171bd705` run after commit ten passed with the flake-declared Nix Python: 1,708 Python tests, 169 Rust tests (assets 10, gameplay 129, xtask 30), 56 deterministic producers, storage policy, 436 documentation files and whitespace guards. No generated report drift. Validation notes were amended into task ten; original assets unchanged.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1650,7 +1650,7 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 - [x] RE-863 Rust composed camera world selection and placement ([evidence](research/RUST_CAMERA_WORLD.md)).
 
 
-- [ ] RE-864: Recover fallback/native math, compose camera into respawn/intermission, resolve map/allocation/publication effects and validate actual macOS/Linux game traces. [Scope](research/QVM_CAMERA_WORLD_BATCH.md).
+- [x] RE-864–873: Recover fallback spawn/camera and normal map command/reset contracts. Remaining native/runtime scope continues under RE-874. [Evidence](research/QVM_SPAWN_MAP_COMMAND_BATCH.md).
 
 
 - [x] RE-864 Original fallback spawn distance ranking and selection ([evidence](research/QVM_SPAWN_FALLBACK.md)).
@@ -1678,3 +1678,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-872 Original normal next-map flow with recovered command children ([evidence](research/QVM_NORMAL_MAP_FLOW.md)).
+
+
+- [x] RE-873 Rust recovered normal next-map command and reset composition ([evidence](research/RUST_NORMAL_MAP_FLOW.md)).
+
+
+- [ ] RE-874: Recover telefrag/native math, respawn/slow setup, lower map/rotation callbacks, allocation/publication and actual macOS/Linux runtime integration. [Scope](research/QVM_SPAWN_MAP_COMMAND_BATCH.md).

docs/TESTING.md

@@ -152,3 +152,8 @@ Focused source/Rust pairs: `camera-place`/`rust-camera-place`, `camera-select`/`
 ## Entity search and composed world camera groups
 
 Use the source/Rust pairs `entity-hash`/`rust-entity-hash`, `entity-field`/`rust-entity-field`, `target-pick`/`rust-target-pick`, `camera-angles`/`rust-camera-angles` and `camera-world`/`rust-camera-world`. Run them inside the flake shell. Registry regression checks report, module and shared transition dependencies; Rust groups refresh scoped gameplay test counts. Git hooks require the flake's absolute Nix-store `PYTHON` and refuse to fall back to system Python. Run `storage` after hook changes and one full suite after ten commits. [Batch evidence and limits](research/QVM_CAMERA_WORLD_BATCH.md).
+
+
+## Fallback spawn and normal map-command groups
+
+Source/Rust pairs: `spawn-fallback`/`rust-spawn-fallback`, `camera-spawn`/`rust-camera-spawn`, `rotation-advance`/`rust-rotation-advance`, `map-select`/`rust-map-select`, and `normal-map-flow`/`rust-normal-map-flow`. Run one group per `cargo xtask test-group <name>` invocation with the flake's explicit PYTHON. Groups regenerate dependency closure; Rust groups include scoped gameplay tests/test-count metadata. Registry regression checks parity edges, module consumers and shared transition/intermission dependencies. Continue focused checks per task and one full run after ten commits. [Batch evidence and native boundaries](research/QVM_SPAWN_MAP_COMMAND_BATCH.md).

docs/research/QVM_MAP_SELECT.md

@@ -2,6 +2,6 @@
 
 RE-870. Reproduce with `python3 scripts/analyze_qvm_map_select.py`; focused validation: `cargo xtask test-group map-select`. [Machine report](qvm-map-select.json).
 
-90 original7188 cases compose actual strlen, bounded-copy wrapper and original formatter. A nonempty override mirror records current engine mapname in g_nextCycleMap, copies the override into a127-byte local command buffer, requests engine g_NextMap clear and emits mode2 map command. VM mirror bytes remain unchanged; engine/native-copy and lower effects remain supplied/captured.
+90 original7188 cases compose actual strlen, bounded-copy wrapper and original formatter. A nonempty override mirror records current engine mapname in g_nextCycleMap, copies the override into a128-byte local map-name buffer (127-byte payload), requests engine g_NextMap clear and emits mode2 map command. VM mirror bytes remain unchanged; engine/native-copy and lower effects remain supplied/captured.
 
 Original executable/native runtime and complete Linux/macOS Rust/Bevy/Solari acceptance remain unverified.

docs/research/QVM_ROTATION_ADVANCE.md

@@ -5,3 +5,5 @@ RE-868. Reproduce with `python3 scripts/analyze_qvm_rotation_advance.py`; focuse
 192 original122230 cases execute actual strlen and recover signed counter wrapping, threshold priority and refresh→optional filename callback/clear→reset order. Engine-5 refresh writes are supplied explicitly, including empty, NUL and high-byte filenames. Actual122143/121987 callbacks and native runtime ownership remain open.
 
 Original executable/native runtime and complete Linux/macOS Rust/Bevy/Solari acceptance remain unverified.
+
+The observed clear target is the cvar `bot_interbreedwrite`. Counter meaning is kept conservative; this contract does not establish a map-list rotation model or execute the bot-related callbacks.

docs/research/QVM_SPAWN_MAP_COMMAND_BATCH.md

@@ -0,0 +1,44 @@
+# Fallback spawn and normal map commands: RE-864–873
+
+This batch replaces the camera fallback stand-in with original instruction execution and composes normal next-map command children with their shared reset state. Rust ports match the finite source contracts; telefrag, engine refresh, native math/copy and lower callbacks remain explicit boundaries.
+
+| Task | Evidence |
+| --- | --- |
+| RE-864 | [168114 fallback distance ranking and selection](QVM_SPAWN_FALLBACK.md) |
+| RE-865 | [Rust fallback spawn selection](RUST_SPAWN_FALLBACK.md) |
+| RE-866 | [Camera setup with actual fallback](QVM_CAMERA_SPAWN.md) |
+| RE-867 | [Rust composed fallback camera](RUST_CAMERA_SPAWN.md) |
+| RE-868 | [122230 cursor and refreshed filename policy](QVM_ROTATION_ADVANCE.md) |
+| RE-869 | [Rust rotation callback intentions](RUST_ROTATION_ADVANCE.md) |
+| RE-870 | [7188 override command, copy and original formatter](QVM_MAP_SELECT.md) |
+| RE-871 | [Rust override command ownership](RUST_MAP_SELECT.md) |
+| RE-872 | [6939 normal path with actual command children](QVM_NORMAL_MAP_FLOW.md) |
+| RE-873 | [Rust normal map command/reset composition](RUST_NORMAL_MAP_FLOW.md) |
+
+## Findings and evidence boundaries
+
+Fallback selection has 112 cases. Actual 168114 searches class hash −103258081 through recovered 276433, skips supplied telefrag results, and inserts accepted candidates in stable descending f32 distance order. It keeps 64; the grid reaches 80 entities so this cap is exercised after class filtering. At 8 or more candidates, RNG 36717 selects modulo floor(count/2); below 8 it uses the entire set. A match always consumes one draw, even with one candidate. If every class match is blocked, it chooses the first class match without a draw; no class match reaches captured fatal 2319. It copies spawn angles and adds 9 to origin Z. Source sqrt responses are modeled and checked by Rust transcripts; actual collision/native math and unsafe pointer domains remain open.
+
+The 128 camera fixtures execute 6717→6575 with actual 168114 fallback and the previously recovered searches, RNG and angle bodies. They combine fallback and existing intermission-camera branches with two entity-to-player pointers. Rust stages selection and places only after successful resolution. Telefrag inputs remain caller-provided; no-spawn handling is a typed error rather than executing original fatal termination.
+
+Rotation has 192 cases. The observed write cvar is `bot_interbreedwrite`; the cursor is retained as a raw control counter rather than assumed to represent a map list. Original 122230 increments an enabled signed cursor with word wrapping, tests its threshold, then requests engine−5 refresh of the write cvar before inspecting its string through actual 36038. Only a refreshed nonempty filename requests 122143 and a cvar clear; 121987 follows either way at the boundary. VM filename bytes remain the refreshed value after the captured engine clear. Actual 122143/121987 behavior and engine ownership remain open.
+
+Map selection has 90 cases and executes actual 7188, strlen, bounded-copy wrapper 69338, alternating formatter 70458 and formatter 37914. The nonempty override mirror branch reads the current engine mapname (127 bytes), sets g_nextCycleMap to that current name, then copies the override mirror into the local 128-byte command buffer. It requests an engine g_NextMap clear and emits mode 2 `map <override>\n`, truncated to 127 override bytes. The VM mirror remains unchanged until a future engine refresh. Empty mirror delegates 221662; its supplied return does not affect this body. Tests verify copy direction, NUL padding, unchanged guards/mirror, raw high bytes and exact original formatter output. Engine buffer writes, native−103 copy and actual cvar/command dispatch remain supplied/modeled/captured.
+
+The final 192 cases execute the actual 6939 normal path with recovered 122230/7188 and mode classifier 33715, combining command order with global/client resets. A middle snapshot and optional supplied 249007 connection change prove the final state 2→1 scan observes callback mutations. Rust composes the same phases atomically with explicit supplied connection updates, rejects team-series inputs and invalid callback indices, and preserves pending/phase/series data. Native 249007 and downstream callbacks still remain open.
+
+## Validation
+
+All Python execution in this batch uses the already-resolved Nix Python 3.13.15 declared by flake.nix; PYTHON is explicit for xtask, nested scripts and Git hooks. No macOS Command Line Tools Python is used. Each task passed focused cargo xtask validation before its own commit, with deterministic double report regeneration, relevant Python/scoped gameplay Rust tests, storage, documentation links and whitespace checks. The registry regression verifies all five source-report parity edges, camera/map module consumers and shared transition/intermission dependencies. The single full-suite run after commit ten, `cargo xtask test-full --since 171bd705`, passed with the flake-declared Python: 1,708 Python tests and 169 Rust tests (assets 10, gameplay 129, xtask 30). All 56 affected report producers regenerated twice deterministically. Storage policy, links across 436 documentation files and whitespace checks passed. There was no generated report drift; notes were amended into task ten.
+
+Use `cargo xtask test-group <name>` with `spawn-fallback`, `rust-spawn-fallback`, `camera-spawn`, `rust-camera-spawn`, `rotation-advance`, `rust-rotation-advance`, `map-select`, `rust-map-select`, `normal-map-flow` or `rust-normal-map-flow`, in the flake tool environment.
+
+## Next work: RE-874
+
+- [ ] Recover 167638 telefrag/collision queries and compare actual native sqrt/atan2; broaden spawn aliases, unsupported domains and original fatal semantics.
+- [ ] Compose recovered camera fallback into actual 175123 respawn and 156523 slow setup, then the complete begin-intermission flow.
+- [ ] Recover 122143/121987 rotation callbacks, 221662 fallback map selection and 249007 post-map state/command behavior.
+- [ ] Compose complete 6939 series/normal handling into readiness, with real engine cvar refresh and command ownership.
+- [ ] Recover 277165 allocation/initialization and integrate event caller-owned fields, native linking and lifetime.
+- [ ] Execute 6328 publication and real formatting/configstring/network work; integrate ranking→intermission→camera/map/event→scoreboard state.
+- [ ] Validate actual macOS/Linux Bevy/Solari gameplay/rendering and continue legacy tracer audits. These policies do not establish full-game completion.

docs/research/README.md

@@ -1214,3 +1214,8 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-872: Original normal next-map flow with recovered command children](QVM_NORMAL_MAP_FLOW.md).
+
+
+[RE-873: Rust recovered normal next-map command and reset composition](RUST_NORMAL_MAP_FLOW.md).
+
+- [RE-864–873 fallback spawn and normal map command batch](QVM_SPAWN_MAP_COMMAND_BATCH.md).

docs/research/RUST_NORMAL_MAP_FLOW.md

@@ -0,0 +1,7 @@
+# Rust recovered normal next-map command and reset composition
+
+RE-873. Reproduce with `python3 scripts/analyze_rust_normal_map_flow.py`; focused validation: `cargo xtask test-group rust-normal-map-flow`. [Machine report](rust-normal-map-flow.json).
+
+Rust matches192 original normal6939 cases, staging rotation, override map-command intentions, global/client resets and post-callback connection changes atomically. The API refuses team-series inputs and invalid callback indices. VM mirrors/pending/series data remain source-faithful; native callbacks, engine refresh and runtime integration remain open.
+
+Original executable/native runtime and complete Linux/macOS Rust/Bevy/Solari acceptance remain unverified.

docs/research/rust-health-impulse.json

@@ -2985,7 +2985,7 @@
       "exit_code": 2
     }
   ],
-  "rust_unit_tests": 127,
+  "rust_unit_tests": 129,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_normal_map_flow.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+import hashlib,json
+from pathlib import Path
+from rust_map_commands_support import binary,result,invoke
+from analyze_qvm import write_json
+from rust_map_commands_support import blob
+def encode(s):
+ a=s['input'];out=[s['before'][k] for k in ['phase','option','flags','mode','first','second','blocked','pending','saved_second','saved_first','round']];out.extend([a['enabled'],a['cursor'],2,a['max_clients'],int(a['disconnect']),len(s['clients_before'])]);out.extend(c[str(o)] for c in s['clients_before'] for o in [248,304,308,468,696]);out.extend([*blob(a['updated']),*blob(a['mirror']),*blob(b'current_map'.hex())]);return out
+def project(s):return {k:s[k] for k in ['state','cursor','filename','mirror','middle','clients']}|{'rotation_operations':s['parts']['rotation']['operations'],'map_operations':s['parts']['map']['operations']}
+
+def main():
+ b=binary();p=Path('docs/research/qvm-normal-map-flow.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'flow',encode(s))})
+ write_json(Path('docs/research/rust-normal-map-flow.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust matches192 original normal6939 cases, staging rotation, override map-command intentions, global/client resets and post-callback connection changes atomically. The API refuses team-series inputs and invalid callback indices. VM mirrors/pending/series data remain source-faithful; native callbacks, engine refresh and runtime integration remain open.'})
+if __name__=='__main__':main()

scripts/test_rust_normal_map_flow.py

@@ -0,0 +1,9 @@
+import hashlib,json,unittest
+from pathlib import Path
+class PortTests(unittest.TestCase):
+ def test_all_original_cases(self):
+  r=json.loads(Path('docs/research/rust-normal-map-flow.json').read_text());src=json.loads(Path(r['source_report']).read_text());self.assertEqual(len(r['probes']),len(src['probes']));self.assertGreater(len(r['probes']),20)
+  for p in r['probes']:self.assertEqual(p['rust'],p['source'])
+ def test_source_identity(self):
+  r=json.loads(Path('docs/research/rust-normal-map-flow.json').read_text());self.assertEqual(hashlib.sha256(Path(r['source_report']).read_bytes()).hexdigest(),r['source_report_sha256'])
+if __name__=='__main__':unittest.main()

xtask/checks.tsv

@@ -2501,3 +2501,18 @@ report	scripts/analyze_qvm_normal_map_flow.py	docs/research/qvm-normal-map-flow.
 edge	docs/research/qvm-normal-map-flow.json	scripts/test_qvm_normal_map_flow.py
 group	normal-map-flow	scripts/analyze_qvm_normal_map_flow.py
 edge	scripts/analyze_qvm_normal_map_flow.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_normal_map_flow.py
+edge	Cargo.lock	scripts/analyze_rust_normal_map_flow.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_normal_map_flow.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_normal_map_flow.py
+edge	crates/urt-gameplay/src/map_commands.rs	scripts/analyze_rust_normal_map_flow.py
+edge	crates/urt-gameplay/src/bin/urt-map-commands.rs	scripts/analyze_rust_normal_map_flow.py
+edge	docs/research/qvm-normal-map-flow.json	scripts/analyze_rust_normal_map_flow.py
+group	rust-normal-map-flow	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_normal_map_flow.py
+edge	crates/urt-gameplay/src/transition.rs	scripts/analyze_rust_normal_map_flow.py
+edge	crates/urt-gameplay/src/intermission.rs	scripts/analyze_rust_normal_map_flow.py
+report	scripts/analyze_rust_normal_map_flow.py	docs/research/rust-normal-map-flow.json
+edge	docs/research/rust-normal-map-flow.json	scripts/test_rust_normal_map_flow.py
+group	rust-normal-map-flow	scripts/analyze_rust_normal_map_flow.py
+edge	scripts/analyze_rust_normal_map_flow.py	scripts/analyze_qvm_resumer_audit.py

xtask/src/lib.rs

@@ -1106,6 +1106,11 @@ mod integration_tests {
             ("transition", "event_construct"),
             ("transition", "camera_world"),
             ("camera_world", "camera_world"),
+            ("camera_world", "camera_spawn"),
+            ("map_commands", "normal_map_flow"),
+            ("transition", "camera_spawn"),
+            ("transition", "normal_map_flow"),
+            ("intermission", "normal_map_flow"),
             ("leaderboard", "leaderboard"),
             ("recipient_wire", "recipient_wire"),
         ] {
@@ -1176,6 +1181,11 @@ mod integration_tests {
             ("qvm-target-pick", "target_pick"),
             ("qvm-camera-angles", "camera_angles"),
             ("qvm-camera-world", "camera_world"),
+            ("qvm-spawn-fallback", "spawn_fallback"),
+            ("qvm-camera-spawn", "camera_spawn"),
+            ("qvm-rotation-advance", "rotation_advance"),
+            ("qvm-map-select", "map_select"),
+            ("qvm-normal-map-flow", "normal_map_flow"),
         ] {
             let selected = plan(
                 &g,