gameplay: integrate normal map session persistence

crates/urt-gameplay/src/bin/urt-native-policy.rs

@@ -231,6 +231,116 @@ fn run() -> Result<String, String> {
             .map_err(|e| format!("{e:?}"))?;
             Ok(post_session_json(&out, &clients))
         }
+        "normal-session" => {
+            if w.len() != 256 || w[15] != 8 {
+                return Err("invalid normal session input".into());
+            }
+            let mut map = map_state(&w[..11]);
+            let mut rotation = urt_gameplay::map_commands::Rotation {
+                enabled: 1,
+                cursor: 1,
+                limit: 2,
+                filename: b"previous.cfg".to_vec(),
+            };
+            let mut mirror = if w[14] != 0 {
+                b"cycle".to_vec()
+            } else {
+                vec![]
+            };
+            let mut clients = w[16..56]
+                .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 flags = std::array::from_fn(|j| w[192 + j] as i32);
+            let mut sessions = w[56..128]
+                .chunks_exact(9)
+                .map(|v| SessionClient {
+                    connection: 0,
+                    values: std::array::from_fn(|j| v[j] as i32),
+                    ignore: flags,
+                })
+                .collect::<Vec<_>>();
+            let indices = w[128..192].iter().map(|v| *v as usize).collect::<Vec<_>>();
+            let out = normal_map_session(
+                NormalSessionState {
+                    map: &mut map,
+                    rotation: &mut rotation,
+                    mirror: &mut mirror,
+                    clients: &mut clients,
+                    sessions: &mut sessions,
+                },
+                NormalSessionInput {
+                    maximum: w[11] as usize,
+                    level_count: w[12] as i32,
+                    updated_filename: b"",
+                    engine_map: b"current_map",
+                    entity_clients: &indices,
+                },
+                |j, c| {
+                    apply_session_change(w[13], j, c);
+                    Ok(())
+                },
+            )
+            .map_err(|e| format!("{e:?}"))?;
+            let after = clients
+                .iter()
+                .map(|c| {
+                    vec![
+                        c.score as u32,
+                        c.field304 as u32,
+                        c.field308 as u32,
+                        c.connection as u32,
+                        c.class as u32,
+                    ]
+                })
+                .collect::<Vec<_>>();
+            let values = sessions
+                .iter()
+                .map(|c| c.values.map(|v| v as u32).to_vec())
+                .collect::<Vec<_>>();
+            let calls = out
+                .persistence
+                .calls
+                .iter()
+                .map(|(k, j, v)| {
+                    vec![
+                        if *k == PostMapChild::First {
+                            246746
+                        } else {
+                            246963
+                        },
+                        *j as u32,
+                        *v as u32,
+                    ]
+                })
+                .collect::<Vec<_>>();
+            let command = out
+                .normal
+                .selection
+                .command
+                .as_ref()
+                .map(|v| format!("\"{}\"", hex(v)))
+                .unwrap_or("null".into());
+            Ok(format!(
+                "{{\"state\":{},\"clients_after\":{},\"values\":{},\"ring\":{},\"mirror\":\"{}\",\"middle\":{},\"post_calls\":{},\"sets\":{},\"command\":{},\"rotation_ops\":{}}}",
+                map_json(&map),
+                nested(&after),
+                nested(&values),
+                u32::from(w[14] != 0) + out.persistence.ring_advance,
+                hex(&mirror),
+                clients_json(&out.normal.middle[..4]),
+                nested(&calls),
+                sets_json(&out.persistence.sets),
+                command,
+                rotation_ops(&out.normal.rotation)
+            ))
+        }
         _ => Err("unknown command".into()),
     }
 }
@@ -329,3 +439,69 @@ fn post_session_json(out: &PostSession, c: &[SessionClient]) -> String {
         out.ring_advance
     )
 }
+
+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/native_policy.rs

@@ -550,3 +550,144 @@ mod post_session_tests {
         assert_eq!(c, before);
     }
 }
+
+pub struct NormalSessionInput<'a> {
+    pub maximum: usize,
+    pub level_count: i32,
+    pub updated_filename: &'a [u8],
+    pub engine_map: &'a [u8],
+    pub entity_clients: &'a [usize],
+}
+pub struct NormalSessionState<'a> {
+    pub map: &'a mut crate::transition::MapState,
+    pub rotation: &'a mut crate::map_commands::Rotation,
+    pub mirror: &'a mut Vec<u8>,
+    pub clients: &'a mut [crate::transition::MapClient],
+    pub sessions: &'a mut [SessionClient],
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct NormalSession {
+    pub normal: crate::map_commands::NormalFlow,
+    pub persistence: PostSession,
+}
+/// Stage normal map intentions, score reset, live-level persistence dispatch,
+/// and the final max-client connection scan. First-child session effects are
+/// supplied; external engine actions remain returned intentions.
+pub fn normal_map_session<F: FnMut(usize, &mut [SessionClient]) -> Result<(), Error>>(
+    state: NormalSessionState<'_>,
+    input: NormalSessionInput<'_>,
+    first: F,
+) -> Result<NormalSession, Error> {
+    if state.map.phase > 0 && crate::intermission::team_mode(state.map.mode) {
+        return Err(Error::InvalidInput);
+    }
+    if state.clients.len() > 64
+        || state.clients.len() != state.sessions.len()
+        || input.maximum > state.clients.len()
+    {
+        return Err(Error::InvalidCount);
+    }
+    let mut map = state.map.clone();
+    let mut rotation = state.rotation.clone();
+    let mut clients = state.clients.to_vec();
+    let mut sessions = state.sessions.to_vec();
+    let operations = crate::map_commands::advance_rotation(&mut rotation, input.updated_filename)
+        .map_err(|_| Error::InvalidInput)?;
+    let selection = crate::map_commands::select_map(state.mirror, input.engine_map)
+        .map_err(|_| Error::InvalidInput)?;
+    crate::transition::prepare_normal(&mut map, &mut clients, input.maximum)
+        .map_err(|_| Error::InvalidCount)?;
+    let middle = clients.clone();
+    for (s, c) in sessions.iter_mut().zip(&clients) {
+        s.connection = c.connection;
+    }
+    let persistence = persist_post_map(
+        &mut sessions,
+        input.level_count,
+        input.entity_clients,
+        first,
+    )?;
+    for (s, c) in sessions.iter().zip(&mut clients) {
+        c.connection = s.connection;
+    }
+    crate::transition::mark_connecting(&mut clients, input.maximum)
+        .map_err(|_| Error::InvalidCount)?;
+    for (s, c) in sessions.iter_mut().zip(&clients) {
+        s.connection = c.connection;
+    }
+    *state.map = map;
+    *state.rotation = rotation;
+    *state.mirror = selection.mirror.clone();
+    state.clients.copy_from_slice(&clients);
+    state.sessions.clone_from_slice(&sessions);
+    Ok(NormalSession {
+        normal: crate::map_commands::NormalFlow {
+            rotation: operations,
+            selection,
+            middle,
+        },
+        persistence,
+    })
+}
+#[cfg(test)]
+mod normal_session_tests {
+    use super::*;
+    use crate::{
+        map_commands::Rotation,
+        transition::{MapClient, MapState},
+    };
+    #[test]
+    fn bad_level_count_preserves_all_state() {
+        let mut map = MapState {
+            phase: 2,
+            mode: 9,
+            ..Default::default()
+        };
+        let before = map.clone();
+        let mut rotation = Rotation {
+            enabled: 1,
+            cursor: 1,
+            limit: 2,
+            filename: b"old".to_vec(),
+        };
+        let old = rotation.clone();
+        let mut mirror = b"cycle".to_vec();
+        let mut clients = [MapClient {
+            score: 7,
+            field304: 8,
+            field308: 9,
+            connection: 2,
+            class: 1,
+        }];
+        let c = clients;
+        let mut sessions = [SessionClient {
+            connection: 2,
+            values: [0; 9],
+            ignore: [0; 64],
+        }];
+        let s = sessions.clone();
+        let result = normal_map_session(
+            NormalSessionState {
+                map: &mut map,
+                rotation: &mut rotation,
+                mirror: &mut mirror,
+                clients: &mut clients,
+                sessions: &mut sessions,
+            },
+            NormalSessionInput {
+                maximum: 1,
+                level_count: 2,
+                updated_filename: b"new",
+                engine_map: b"current",
+                entity_clients: &[0, 0],
+            },
+            |_, _| Ok(()),
+        );
+        assert_eq!(result, Err(Error::InvalidCount));
+        assert_eq!(map, before);
+        assert_eq!(rotation, old);
+        assert_eq!(mirror, b"cycle");
+        assert_eq!(clients, c);
+        assert_eq!(sessions, s);
+    }
+}

docs/FINDINGS.md

@@ -1676,3 +1676,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-892:** 64 actual6939 normal-path compositions execute122230/7188/249007/246963 and recovered formatter/string bodies on shared state. Distinct max-clients and level counts prove reset, persistence dispatch and final state2-to1 scan use their own bounds. First-child disconnect/activation/session-field effects are supplied and observed before persistence and final scan. Bot children, map-list fallback221662, first client child246746 and engine behavior remain explicit boundaries. [Evidence](research/QVM_NORMAL_MAP_SESSION.md).
+
+
+**RE-893:** Rust matches64 continuous original6939/249007/246963 compositions. Independent max-clients/live-level bounds preserve score-reset, session-write and final connection-scan ordering; supplied first-child field/connection changes are staged with global/cvar intentions. Invalid counts reject without partial state commits. Native first child, bot/map-list callbacks and engine persistence remain open. [Evidence](research/RUST_NORMAL_MAP_SESSION.md).

docs/PROVISIONAL_TODO.md

@@ -1707,3 +1707,9 @@ RE-891: Rust matches64 original249007/246963 compositions, including first-child
 
 
 RE-892: 64 actual6939 normal-path compositions execute122230/7188/249007/246963 and recovered formatter/string bodies on shared state. Distinct max-clients and level counts prove reset, persistence dispatch and final state2-to1 scan use their own bounds. First-child disconnect/activation/session-field effects are supplied and observed before persistence and final scan. Bot children, map-list fallback221662, first client child246746 and engine behavior remain explicit boundaries. Full runtime completion remains open. [Evidence](research/QVM_NORMAL_MAP_SESSION.md).
+
+
+RE-893: Rust matches64 continuous original6939/249007/246963 compositions. Independent max-clients/live-level bounds preserve score-reset, session-write and final connection-scan ordering; supplied first-child field/connection changes are staged with global/cvar intentions. Invalid counts reject without partial state commits. Native first child, bot/map-list callbacks and engine persistence remain open. Full runtime completion remains open. [Evidence](research/RUST_NORMAL_MAP_SESSION.md).
+
+
+RE-884–893 completed bounded queried spawn/camera and map persistence compositions. RE-894 tracks saved-position behavior, restore, native collision and full runtime integration. [Batch and remaining tasks](research/QVM_QUERIED_PERSISTENCE_BATCH.md).

docs/RESEARCH_LEDGER.md

@@ -2170,3 +2170,13 @@ Rust matches64 original249007/246963 compositions, including first-child disconn
 ## 2026-10-28 — RE-892 Original normal map flow with session persistence
 
 64 actual6939 normal-path compositions execute122230/7188/249007/246963 and recovered formatter/string bodies on shared state. Distinct max-clients and level counts prove reset, persistence dispatch and final state2-to1 scan use their own bounds. First-child disconnect/activation/session-field effects are supplied and observed before persistence and final scan. Bot children, map-list fallback221662, first client child246746 and engine behavior remain explicit boundaries. Focused `cargo xtask test-group qvm-normal-map-session` passes (8 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-28 — RE-893 Rust normal map transition with session persistence
+
+Rust matches64 continuous original6939/249007/246963 compositions. Independent max-clients/live-level bounds preserve score-reset, session-write and final connection-scan ordering; supplied first-child field/connection changes are staged with global/cvar intentions. Invalid counts reject without partial state commits. Native first child, bot/map-list callbacks and engine persistence remain open. Focused `cargo xtask test-group rust-normal-map-session` 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-884–893 full batch validation (2026-10-28)
+
+After the tenth commit, `cargo xtask test-full --since b9a94452` passed with the flake-declared Nix Python: 1,738 Python tests,188 Rust tests (assets10, gameplay148, xtask30),33 affected report producers regenerated twice deterministically, storage policy,458 documentation link checks and whitespace guards. No generated-report drift. Ten task commits sinceb9a94452; results are amended into the tenth commit. [Findings and next work](research/QVM_QUERIED_PERSISTENCE_BATCH.md).

docs/REVERSE_ENGINEERING_TODO.md

@@ -1716,7 +1716,7 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 - [x] RE-883 Rust composed bot rotation and callback ownership ([evidence](research/RUST_BOT_ROTATION.md)).
 
 
-- [ ] RE-884 Integrate recovered overlap and post-map/bot callbacks into complete map/camera flows, confirm native botlib behavior, and validate actual Linux/macOS gameplay ([next tasks](research/QVM_BOT_COLLISION_BATCH.md)).
+- [ ] Follow-up after RE-883: integrate recovered overlap and post-map/bot callbacks into complete map/camera flows, confirm native botlib behavior, and validate actual Linux/macOS gameplay ([next tasks](research/QVM_BOT_COLLISION_BATCH.md)).
 
 
 - [x] RE-884 Original fallback spawn with actual overlap queries ([evidence](research/QVM_QUERIED_SPAWN.md)).
@@ -1744,3 +1744,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-892 Original normal map flow with session persistence ([evidence](research/QVM_NORMAL_MAP_SESSION.md)).
+
+
+- [x] RE-893 Rust normal map transition with session persistence ([evidence](research/RUST_NORMAL_MAP_SESSION.md)).
+
+
+- [ ] RE-894 Recover saved-position/session restore/native collision and complete map/intermission/runtime ownership ([next tasks](research/QVM_QUERIED_PERSISTENCE_BATCH.md)).

docs/TESTING.md

@@ -160,3 +160,6 @@ Source/Rust pairs: `spawn-fallback`/`rust-spawn-fallback`, `camera-spawn`/`rust-
 
 
 RE-874–883 adds focused groups `qvm-bot-best`, `rust-bot-best`, `qvm-bot-breed`, `rust-bot-breed`, `qvm-post-map-clients`, `rust-post-map-clients`, `qvm-spawn-overlap`, `rust-spawn-overlap`, `qvm-bot-rotation` and `rust-bot-rotation`. Invoke one group per `cargo xtask test-group <name>`. Source/Rust report identity and native_policy dependencies are covered by the registry regression. Full validation at the tenth-commit boundary uses `cargo xtask test-full --since 40af75ff` in the flake tool environment with explicit Nix-store PYTHON.
+
+
+RE-884–893 adds focused groups `qvm-queried-spawn`, `rust-queried-spawn`, `qvm-queried-camera`, `rust-queried-camera`, `qvm-session-write`, `rust-session-write`, `qvm-post-map-session`, `rust-post-map-session`, `qvm-normal-map-session` and `rust-normal-map-session`. Invoke one group per `cargo xtask test-group <name>`. Full batch validation after task ten uses `cargo xtask test-full --since b9a94452` with explicit flake-declared Nix PYTHON. [Evidence and limits](research/QVM_QUERIED_PERSISTENCE_BATCH.md).

docs/research/QVM_BOT_COLLISION_BATCH.md

@@ -25,7 +25,7 @@ The shared-state rotation fixtures execute122230,122143,121987 and36038. Enabled
 
 Post-map249007 iterates level count34992524, distinct from the max-clients cvar used in other paths. Each state2 client dispatches246746 followed by246963. Its second call remains unconditional even if the first disconnects that client. Supplied activation of later clients changes later dispatch. Rust supports this ordering through typed callbacks; callback changes to the count/base pointer, the two child bodies and engine integration remain open.
 
-Spawn167638 adds six original f32 bounds constants to origin fields92/96/100, then requests native -33 with capacity1024. Any returned entity with nonzero pointer at offset520 causes an immediate true result. No health/team/activity check occurs in this body. Fixtures include repeated indices, negative/zero counts, signed nonzero client words, f32 rounding and a blocking client in the last of1024 results. Actual spatial query answers remain supplied. Rust validates finite bounds and positive result counts/indices before scanning; malformed native inputs are outside the source parity domain. This query is not yet integrated into fallback/camera/world collision.
+Spawn167638 adds six original f32 bounds constants to origin fields92/96/100, then requests native -33 with capacity1024. Any returned entity with nonzero pointer at offset520 causes an immediate true result. No health/team/activity check occurs in this body. Fixtures include repeated indices, negative/zero counts, signed nonzero client words, f32 rounding and a blocking client in the last of1024 results. Actual spatial query answers remain supplied. Rust validates finite bounds and positive result counts/indices before scanning; malformed native inputs are outside the source parity domain. The next batch integrates this query into fallback and camera fixtures; native world collision remains open.
 
 ## Validation and storage
 
@@ -33,7 +33,7 @@ Each task used focused `cargo xtask test-group <name>` before its own commit, in
 
 All Python processes use the already-resolved Nix Python declared by flake.nix, with explicit PYTHON inherited by xtask and Git hooks. Original assets remain in .cache; no asset payload was changed. After commit ten, `cargo xtask test-full --since 40af75ff` passed once: 1,723 Python tests and180 Rust tests (assets10, gameplay140, xtask30). All64 affected report producers regenerated twice deterministically. Storage policy, links across447 documentation files and whitespace checks passed, with no generated report drift. These validation notes were amended into task ten.
 
-## Next work: RE-884
+## Follow-up work (expanded by RE-884–893)
 
 - [ ] Integrate actual167638 overlap into actual168114 fallback and6717 camera fixtures; preserve query order, short-circuiting and query-result ownership.
 - [ ] Connect Rust overlap queries to fallback selection through a typed spatial-query interface; then validate actual native broadphase and world collision.
@@ -43,3 +43,5 @@ All Python processes use the already-resolved Nix Python declared by flake.nix,
 - [ ] Reuse existing allocator277165/initializer277125 research when composing event construction, linking and lifetime; expand unsupported capacity/alias domains instead of duplicating existing work.
 - [ ] Compose camera/respawn175123/slow setup156523 into complete begin-intermission, and join ranking, scoreboard publication and real network/configstrings.
 - [ ] Validate Linux/macOS native gameplay and Bevy/Solari rendering. Full playable-game completion remains open.
+
+[RE-884–893](QVM_QUERIED_PERSISTENCE_BATCH.md) completes the bounded fallback/camera and normal persistence compositions. Its RE-894 list supersedes the historical follow-up list above.

docs/research/QVM_QUERIED_PERSISTENCE_BATCH.md

@@ -0,0 +1,53 @@
+# Queried spawn/camera and map persistence: RE-884–893
+
+Ten separately committed tasks compose recovered QVM routines and their Rust policies across collision and session boundaries. The five source fixture sets contain380 cases, each compared against Rust. Native collision queries, math, engine cvars and the first post-map client child remain explicit supplied/captured boundaries. This batch does not establish a complete playable game.
+
+| Task | Evidence | Cases |
+| --- | --- | ---: |
+| RE-884 | [Actual fallback168114 with167638 queries](QVM_QUERIED_SPAWN.md) | 64 |
+| RE-885 | [Rust queried fallback](RUST_QUERIED_SPAWN.md) | 64 |
+| RE-886 | [Actual camera6717/fallback/placement6575](QVM_QUERIED_CAMERA.md) | 128 |
+| RE-887 | [Rust lazy queried camera](RUST_QUERIED_CAMERA.md) | 128 |
+| RE-888 | [Session246963 and bounded ignore-list serialization](QVM_SESSION_WRITE.md) | 60 |
+| RE-889 | [Rust exact session bytes](RUST_SESSION_WRITE.md) | 60 |
+| RE-890 | [Post-map249007 with actual persistence](QVM_POST_MAP_SESSION.md) | 64 |
+| RE-891 | [Rust post-map persistence](RUST_POST_MAP_SESSION.md) | 64 |
+| RE-892 | [Normal6939 with post-map persistence](QVM_NORMAL_MAP_SESSION.md) | 64 |
+| RE-893 | [Rust normal map/session composition](RUST_NORMAL_MAP_SESSION.md) | 64 |
+
+## Collision and camera ownership
+
+Actual168114 now invokes actual167638 rather than receiving precomputed blocked booleans. Each matching active class requests a box query before its distance calculation. Empty and nonclient responses allow ranking; a nonzero client pointer blocks the candidate. Duplicate results, all-blocked fallback, no class, the64-candidate cap, RNG state and exact output words are checked. Supplied native -33 lists include entity900 (no client) and901 (nonzero client); these are explicit engine fixtures, not a spatial index implementation.
+
+The Rust query callback follows that same per-candidate boundary instead of eagerly querying every world entity. Filtered classes issue no queries, and callback/domain errors preserve RNG. Existing callers with booleans retain their original API and fixtures. Query side effects outside the returned/staged state cannot be rolled back; the typed subset borrows a stable world and supplied client-word slice.
+
+Continuous6717/168114/167638/6575 fixtures verify setup, fallback selection and player placement. Primary intermission cameras bypass spatial queries completely; fallback cameras query only their matching spawn classes. Rust preserves query order, checked math transcripts, RNG, views, target selection and both player slots. Native broadphase/math, respawn and the complete begin-intermission flow remain open.
+
+## Session bytes and callback timing
+
+Original246963 writes sessionN with source formatter70458/37914. The raw integer fields are offsets3096,3156,3144,3140 and3148; offsets3152,3708,3712 and3740 normalize to0/1. Names are descriptive session metadata until their producers/restore semantics are verified. Rust uses recovered decimal behavior, including the original nonstandard INT_MIN bytes, rather than host formatting.
+
+sessIgnoreN traverses entity records, derives client indices from pointers at offset520 using stride6336, and reads the target client's table at3780+4*index. Only flag exactly1 is appended as `index,`; duplicates remain. Iteration stops at the level count or64, whichever comes first; negative counts scan nothing. Actual70031/36038/69338 concatenate into128 bytes including NUL, saturating at127 data bytes, even in the middle of a decimal token. Formatter-ring advancement continues after saturation. Native memset/strncpy are modeled, while formatter/string QVM bodies execute and engine cvar writes are captured.
+
+The fixture initializer reads the packed original string region without padding individual literals into adjacent strings. The independent byte oracle caught an initial synthetic padding overlap before commit; the corrected source image preserves the original neighboring format strings. This is fixture initialization, not a patch to the game binary.
+
+Post-map249007 executes actual246963 after a supplied246746 callback. A disconnect in the first child leaves the second child unconditional. Activation of later clients affects dispatch, and changed session metadata is serialized immediately. Source formatter state carries between clients. Rust stages callback/session state on errors and returns ordered cvar intentions. It holds the client count/base stable; arbitrary native aliasing and the actual first child remain outside this contract.
+
+The normal6939 composition separates max-client bounds from the live level count. Score/global reset occurs before post-map persistence; the final max-client state2-to1 scan occurs afterwards. Tests independently vary both counts and verify callback disconnect/activation, metadata updates, mode9 resets, map-command bytes, VM mirror preservation and formatter-ring carry. Rust stages map, rotation, mirror, client and session state together. Engine command/cvar dispatch remains represented by intentions; bot callback internals and221662 map-list selection are still omitted here.
+
+## Validation
+
+Focused `cargo xtask test-group <name>` ran before each task commit, with deterministic double report regeneration, relevant source/Rust parity, scoped gameplay tests and storage/documentation/whitespace guards. The ten groups are qvm-queried-spawn, rust-queried-spawn, qvm-queried-camera, rust-queried-camera, qvm-session-write, rust-session-write, qvm-post-map-session, rust-post-map-session, qvm-normal-map-session and rust-normal-map-session. Existing spawn/camera and normal-map callers received focused regression checks when shared helpers changed.
+
+Dependency-selection regression coverage includes all five source/Rust report pairs, camera/native-policy consumers, and the transition, formatting and map-command dependencies of normal session composition. Python uses only the resolved Nix runtime declared by flake.nix, with explicit PYTHON for xtask and Git hooks. No original asset payload changed. After commit ten, `cargo xtask test-full --since b9a94452` passed once: 1,738 Python tests and188 Rust tests (assets10, gameplay148, xtask30). All33 affected report producers regenerated twice deterministically. Storage policy, links across458 documentation files and whitespace checks passed with no generated-report drift. These notes were amended into task ten.
+
+## Next work: RE-894
+
+- [ ] Recover246746 saved-position behavior, actual userinfo70503 lookup, GUID/map path generation, floating formatter70386, native file write/close and ownership/error branches.
+- [ ] Recover session restore and clear246938 callers; trace each metadata producer and ignore-table mutation, validating persistence across an actual map reload.
+- [ ] Support and verify callback changes to client count/base, entity-client aliases, malformed native query results and collision query side effects across selection.
+- [ ] Replace supplied -33 answers with recovered native broadphase/world collision; compare actual native sqrt/atan2 and connect scene lifecycle to the typed query interface.
+- [ ] Integrate recovered bot rotation with the new persistence path, and recover native botlib selection/write/mutation behavior.
+- [ ] Recover221662 map-list parsing and compose it with7188, normal/series6939 and readiness, including real engine cvar refresh and command dispatch.
+- [ ] Compose respawn175123/slow setup156523 and complete begin-intermission, plus allocator/event lifetime and real ranking/scoreboard/network integration.
+- [ ] Validate actual Linux/macOS Rust/Bevy/Solari gameplay and rendering. Cross-platform game completion remains open.

docs/research/README.md

@@ -1279,3 +1279,9 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-892: Original normal map flow with session persistence](QVM_NORMAL_MAP_SESSION.md).
+
+
+[RE-893: Rust normal map transition with session persistence](RUST_NORMAL_MAP_SESSION.md).
+
+
+[RE-884–893 queried spawn/camera and persistence batch](QVM_QUERIED_PERSISTENCE_BATCH.md).

docs/research/RUST_NORMAL_MAP_SESSION.md

@@ -0,0 +1,7 @@
+# Rust normal map transition with session persistence
+
+RE-893. Reproduce with `python3 scripts/analyze_rust_normal_map_session.py`; focused validation: `cargo xtask test-group rust-normal-map-session`. [Machine report](rust-normal-map-session.json).
+
+Rust matches64 continuous original6939/249007/246963 compositions. Independent max-clients/live-level bounds preserve score-reset, session-write and final connection-scan ordering; supplied first-child field/connection changes are staged with global/cvar intentions. Invalid counts reject without partial state commits. Native first child, bot/map-list callbacks and engine persistence 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": 147,
+  "rust_unit_tests": 148,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_normal_map_session.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+import hashlib,json
+from pathlib import Path
+from rust_native_policy_support import binary,result,invoke
+from analyze_qvm import write_json
+def encode(s):
+ a=s['input'];return [*[s['before'][k] for k in ['phase','option','flags','mode','first','second','blocked','pending','saved_second','saved_first','round']],a['maximum'],a['count'],a['mutation'],int(a['override']),8,*[v for row in a['clients'] for v in row],*[v for row in a['values'] for v in row],*a['indices'],*a['flags']]
+def project(s):
+ out={k:s[k] for k in ['state','clients_after','values','ring','mirror','middle']};out.update(post_calls=s['parts']['post']['calls'],sets=s['parts']['post']['sets'],command=next((o['text'] for o in s['parts']['map']['operations'] if o['op']=='command'),None),rotation_ops=s['parts']['rotation']['operations']);return out
+
+def main():
+ b=binary();p=Path('docs/research/qvm-normal-map-session.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'normal-session',encode(s))})
+ write_json(Path('docs/research/rust-normal-map-session.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust matches64 continuous original6939/249007/246963 compositions. Independent max-clients/live-level bounds preserve score-reset, session-write and final connection-scan ordering; supplied first-child field/connection changes are staged with global/cvar intentions. Invalid counts reject without partial state commits. Native first child, bot/map-list callbacks and engine persistence remain open.'})
+if __name__=='__main__':main()

scripts/test_rust_normal_map_session.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-session.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-session.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

@@ -2690,3 +2690,20 @@ report	scripts/analyze_qvm_normal_map_session.py	docs/research/qvm-normal-map-se
 edge	docs/research/qvm-normal-map-session.json	scripts/test_qvm_normal_map_session.py
 group	qvm-normal-map-session	scripts/analyze_qvm_normal_map_session.py
 edge	scripts/analyze_qvm_normal_map_session.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_normal_map_session.py
+edge	Cargo.lock	scripts/analyze_rust_normal_map_session.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_normal_map_session.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_normal_map_session.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_normal_map_session.py
+edge	crates/urt-gameplay/src/bin/urt-native-policy.rs	scripts/analyze_rust_normal_map_session.py
+edge	docs/research/qvm-normal-map-session.json	scripts/analyze_rust_normal_map_session.py
+group	rust-normal-map-session	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_normal_map_session.py
+edge	crates/urt-gameplay/src/transition.rs	scripts/analyze_rust_normal_map_session.py
+edge	crates/urt-gameplay/src/map_commands.rs	scripts/analyze_rust_normal_map_session.py
+edge	crates/urt-gameplay/src/intermission.rs	scripts/analyze_rust_normal_map_session.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_normal_map_session.py
+report	scripts/analyze_rust_normal_map_session.py	docs/research/rust-normal-map-session.json
+edge	docs/research/rust-normal-map-session.json	scripts/test_rust_normal_map_session.py
+group	rust-normal-map-session	scripts/analyze_rust_normal_map_session.py
+edge	scripts/analyze_rust_normal_map_session.py	scripts/analyze_qvm_resumer_audit.py

xtask/src/lib.rs

@@ -1089,6 +1089,16 @@ mod integration_tests {
             ("native_policy", "post_map_clients"),
             ("native_policy", "spawn_overlap"),
             ("native_policy", "bot_rotation"),
+            ("camera_world", "queried_spawn"),
+            ("camera_world", "queried_camera"),
+            ("native_policy", "queried_spawn"),
+            ("native_policy", "queried_camera"),
+            ("native_policy", "session_write"),
+            ("native_policy", "post_map_session"),
+            ("native_policy", "normal_map_session"),
+            ("map_commands", "normal_map_session"),
+            ("transition", "normal_map_session"),
+            ("qvm_format", "normal_map_session"),
             ("protected", "protected_update"),
             ("mode10", "mode10_entry"),
             ("intercept_animation", "mode10_animation"),
@@ -1153,6 +1163,11 @@ mod integration_tests {
             ("qvm-post-map-clients", "post_map_clients"),
             ("qvm-spawn-overlap", "spawn_overlap"),
             ("qvm-bot-rotation", "bot_rotation"),
+            ("qvm-queried-spawn", "queried_spawn"),
+            ("qvm-queried-camera", "queried_camera"),
+            ("qvm-session-write", "session_write"),
+            ("qvm-post-map-session", "post_map_session"),
+            ("qvm-normal-map-session", "normal_map_session"),
             ("qvm-rank-small-sort", "rank_sort"),
             ("qvm-rank-large-sort", "rank_sort"),
             ("qvm-ranking-complete", "ranking_complete"),