gameplay: port staged map reset

crates/urt-gameplay/src/bin/urt-transition.rs

@@ -147,6 +147,35 @@ fn run() -> Result<String, String> {
                 map_json(&s)
             ))
         }
+        "reset" => {
+            if w.len() < 13 {
+                return Err("missing reset header".into());
+            }
+            let mut s = map_state(&w[..11]);
+            let count = w[11] as usize;
+            let n = w[12] as usize;
+            if n > 64 || w.len() != 13 + 5 * n {
+                return Err("invalid reset count".into());
+            }
+            let mut c = w[13..]
+                .chunks_exact(5)
+                .map(|v| 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<_>>();
+            prepare_normal(&mut s, &mut c, count).map_err(|e| format!("{e:?}"))?;
+            let mid = map_clients_json(&c);
+            mark_connecting(&mut c, count).map_err(|e| format!("{e:?}"))?;
+            Ok(format!(
+                "{{\"state\":{},\"middle\":{mid},\"clients\":{},\"effects\":[122230,7188,249007]}}",
+                map_json(&s),
+                map_clients_json(&c)
+            ))
+        }
         _ => Err("unknown command".into()),
     }
 }
@@ -209,3 +238,22 @@ fn map_json(s: &MapState) -> String {
             .join(",")
     )
 }
+
+fn map_clients_json(c: &[MapClient]) -> String {
+    format!(
+        "[{}]",
+        c.iter()
+            .map(|c| object(
+                &[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/transition.rs

@@ -271,3 +271,103 @@ mod series_tests {
         assert_eq!(series(&mut s), SeriesAction::Normal);
     }
 }
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct MapClient {
+    pub score: i32,
+    pub field304: i32,
+    pub field308: i32,
+    pub connection: i32,
+    pub class: i32,
+}
+fn map_count(clients: &[MapClient], count: usize) -> Result<(), Error> {
+    if clients.len() > 64 || count > clients.len() {
+        Err(Error::InvalidCount)
+    } else {
+        Ok(())
+    }
+}
+/// Apply after external122230/7188, before external249007. Dispatch remains caller-owned.
+pub fn prepare_normal(
+    state: &mut MapState,
+    clients: &mut [MapClient],
+    count: usize,
+) -> Result<(), Error> {
+    map_count(clients, count)?;
+    state.round = 0;
+    state.blocked = 0;
+    state.scores = [0; 2];
+    for c in clients.iter_mut().take(count) {
+        if c.connection == 2 {
+            c.score = 0;
+            if state.mode == 9 {
+                c.field304 = 0;
+                c.field308 = 0;
+            }
+        }
+    }
+    Ok(())
+}
+/// Apply after the map-change child, to its resulting client state.
+pub fn mark_connecting(clients: &mut [MapClient], count: usize) -> Result<(), Error> {
+    map_count(clients, count)?;
+    for c in clients.iter_mut().take(count) {
+        if c.connection == 2 {
+            c.connection = 1;
+        }
+    }
+    Ok(())
+}
+#[cfg(test)]
+mod normal_tests {
+    use super::*;
+    #[test]
+    fn staged_clear_preserves_pending_and_unconnected() {
+        let mut s = MapState {
+            mode: 9,
+            pending: 17,
+            phase: 2,
+            round: 9,
+            scores: [5, 7],
+            ..Default::default()
+        };
+        let mut c = [
+            MapClient {
+                connection: 2,
+                score: 8,
+                field304: 4,
+                field308: 5,
+                class: 20,
+            },
+            MapClient {
+                connection: 1,
+                score: 6,
+                ..Default::default()
+            },
+        ];
+        prepare_normal(&mut s, &mut c, 2).unwrap();
+        assert_eq!(
+            (c[0].score, c[0].field304, c[0].field308, c[0].connection),
+            (0, 0, 0, 2)
+        );
+        assert_eq!(
+            (s.pending, s.phase, s.round, s.scores, c[1].score),
+            (17, 2, 0, [0, 0], 6)
+        );
+        c[0].connection = 0;
+        mark_connecting(&mut c, 2).unwrap();
+        assert_eq!(c[0].connection, 0);
+    }
+    #[test]
+    fn invalid_normal_count_is_atomic() {
+        let mut s = MapState {
+            blocked: 7,
+            ..Default::default()
+        };
+        let old = s.clone();
+        let mut c = [];
+        assert_eq!(prepare_normal(&mut s, &mut c, 1), Err(Error::InvalidCount));
+        assert_eq!(s, old);
+        assert_eq!(mark_connecting(&mut c, 1), Err(Error::InvalidCount));
+    }
+}

docs/FINDINGS.md

@@ -1550,3 +1550,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-850:** 48 original 6939 suffix cases recover round/blocked/global score clears, connected-client score resets, extra mode9 field304/308 resets, then connection2→1 after captured249007. A mid-call snapshot proves ordering; pending, phase, series flags and saved scores remain unchanged. Actual map/command children remain captured. [Evidence](research/QVM_NEXTMAP_RESET.md).
+
+
+**RE-851:** Rust matches 48 original normal-reset cases with separate pre-map score reset and post-map connection transition APIs. The adapter captures a no-op map child; production callers can apply its real mutations between stages. Safe count errors preserve state, and pending/phase/series data remain unchanged. [Evidence](research/RUST_NEXTMAP_RESET.md).

docs/PROVISIONAL_TODO.md

@@ -1569,3 +1569,6 @@ RE-849: Rust matches 300 original series-branch cases, reusing the verified mode
 
 
 RE-850: 48 original 6939 suffix cases recover round/blocked/global score clears, connected-client score resets, extra mode9 field304/308 resets, then connection2→1 after captured249007. A mid-call snapshot proves ordering; pending, phase, series flags and saved scores remain unchanged. Actual map/command children remain captured. Full runtime completion remains open. [Evidence](research/QVM_NEXTMAP_RESET.md).
+
+
+RE-851: Rust matches 48 original normal-reset cases with separate pre-map score reset and post-map connection transition APIs. The adapter captures a no-op map child; production callers can apply its real mutations between stages. Safe count errors preserve state, and pending/phase/series data remain unchanged. Full runtime completion remains open. [Evidence](research/RUST_NEXTMAP_RESET.md).

docs/RESEARCH_LEDGER.md

@@ -1928,3 +1928,8 @@ Rust matches 300 original series-branch cases, reusing the verified mode classif
 ## 2026-10-27 — RE-850 Original normal next-map reset staging and connection changes
 
 48 original 6939 suffix cases recover round/blocked/global score clears, connected-client score resets, extra mode9 field304/308 resets, then connection2→1 after captured249007. A mid-call snapshot proves ordering; pending, phase, series flags and saved scores remain unchanged. Actual map/command children remain captured. Focused `cargo xtask test-group nextmap-reset` 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-851 Rust staged normal map reset policy
+
+Rust matches 48 original normal-reset cases with separate pre-map score reset and post-map connection transition APIs. The adapter captures a no-op map child; production callers can apply its real mutations between stages. Safe count errors preserve state, and pending/phase/series data remain unchanged. Focused `cargo xtask test-group rust-nextmap-reset` 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.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1606,3 +1606,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-850 Original normal next-map reset staging and connection changes ([evidence](research/QVM_NEXTMAP_RESET.md)).
+
+
+- [x] RE-851 Rust staged normal map reset policy ([evidence](research/RUST_NEXTMAP_RESET.md)).

docs/research/README.md

@@ -1144,3 +1144,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-850: Original normal next-map reset staging and connection changes](QVM_NEXTMAP_RESET.md).
+
+
+[RE-851: Rust staged normal map reset policy](RUST_NEXTMAP_RESET.md).

docs/research/RUST_NEXTMAP_RESET.md

@@ -0,0 +1,7 @@
+# Rust staged normal map reset policy
+
+RE-851. Reproduce with `python3 scripts/analyze_rust_nextmap_reset.py`; focused validation: `cargo xtask test-group rust-nextmap-reset`. [Machine report](rust-nextmap-reset.json).
+
+Rust matches 48 original normal-reset cases with separate pre-map score reset and post-map connection transition APIs. The adapter captures a no-op map child; production callers can apply its real mutations between stages. Safe count errors preserve state, and pending/phase/series data remain unchanged.
+
+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": 105,
+  "rust_unit_tests": 107,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_nextmap_reset.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+import hashlib,json
+from pathlib import Path
+from rust_transition_support import binary,result,invoke
+from analyze_qvm import write_json
+def encode(s):return [s['before'][k] for k in ['phase','option','flags','mode','first','second','blocked','pending','saved_second','saved_first','round']]+[s['input']['max_clients'],len(s['clients_before']),*[c[str(o)] for c in s['clients_before'] for o in [248,304,308,468,696]]]
+def project(s):return {k:s[k] for k in ['state','middle','clients']}|{'effects':[r['target'] for r in s['requests']]}
+def main():
+ b=binary();p=Path('docs/research/qvm-nextmap-reset.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'reset',encode(s))})
+ write_json(Path('docs/research/rust-nextmap-reset.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust matches 48 original normal-reset cases with separate pre-map score reset and post-map connection transition APIs. The adapter captures a no-op map child; production callers can apply its real mutations between stages. Safe count errors preserve state, and pending/phase/series data remain unchanged.'})
+if __name__=='__main__':main()

scripts/test_rust_nextmap_reset.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-nextmap-reset.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-nextmap-reset.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

@@ -2303,3 +2303,16 @@ report	scripts/analyze_qvm_nextmap_reset.py	docs/research/qvm-nextmap-reset.json
 edge	docs/research/qvm-nextmap-reset.json	scripts/test_qvm_nextmap_reset.py
 group	nextmap-reset	scripts/analyze_qvm_nextmap_reset.py
 edge	scripts/analyze_qvm_nextmap_reset.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_nextmap_reset.py
+edge	Cargo.lock	scripts/analyze_rust_nextmap_reset.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_nextmap_reset.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_nextmap_reset.py
+edge	crates/urt-gameplay/src/transition.rs	scripts/analyze_rust_nextmap_reset.py
+edge	crates/urt-gameplay/src/bin/urt-transition.rs	scripts/analyze_rust_nextmap_reset.py
+edge	docs/research/qvm-nextmap-reset.json	scripts/analyze_rust_nextmap_reset.py
+group	rust-nextmap-reset	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_nextmap_reset.py
+report	scripts/analyze_rust_nextmap_reset.py	docs/research/rust-nextmap-reset.json
+edge	docs/research/rust-nextmap-reset.json	scripts/test_rust_nextmap_reset.py
+group	rust-nextmap-reset	scripts/analyze_rust_nextmap_reset.py
+edge	scripts/analyze_rust_nextmap_reset.py	scripts/analyze_qvm_resumer_audit.py