gameplay: integrate post-map session persistence

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

@@ -208,6 +208,29 @@ fn run() -> Result<String, String> {
                 out.ring_advance
             ))
         }
+        "post-session" => {
+            if w.len() != 210 {
+                return Err("invalid post session input".into());
+            }
+            let count = w[0] as i32;
+            let mutation = w[1];
+            let indices = w[2..66].iter().map(|v| *v as usize).collect::<Vec<_>>();
+            let flags = std::array::from_fn(|j| w[66 + j] as i32);
+            let mut clients = w[130..210]
+                .chunks_exact(10)
+                .map(|v| SessionClient {
+                    connection: v[0] as i32,
+                    values: std::array::from_fn(|j| v[1 + j] as i32),
+                    ignore: flags,
+                })
+                .collect::<Vec<_>>();
+            let out = persist_post_map(&mut clients, count, &indices, |j, c| {
+                apply_session_change(mutation, j, c);
+                Ok(())
+            })
+            .map_err(|e| format!("{e:?}"))?;
+            Ok(post_session_json(&out, &clients))
+        }
         _ => Err("unknown command".into()),
     }
 }
@@ -264,3 +287,45 @@ fn sets_json(sets: &[(Vec<u8>, Vec<u8>)]) -> String {
             .join(",")
     )
 }
+
+fn apply_session_change(mutation: u32, j: usize, c: &mut [SessionClient]) {
+    match mutation {
+        1 => c[j].connection = 0,
+        2 => {
+            if j + 1 < c.len() {
+                c[j + 1].connection = 2
+            }
+        }
+        3 => c[j].values[0] = 777 + j as i32,
+        _ => {}
+    }
+}
+fn post_session_json(out: &PostSession, c: &[SessionClient]) -> String {
+    let calls = out
+        .calls
+        .iter()
+        .map(|(k, j, v)| {
+            vec![
+                if *k == PostMapChild::First {
+                    246746
+                } else {
+                    246963
+                },
+                *j as u32,
+                *v as u32,
+            ]
+        })
+        .collect::<Vec<_>>();
+    let values = c
+        .iter()
+        .map(|c| c.values.map(|v| v as u32).to_vec())
+        .collect::<Vec<_>>();
+    format!(
+        "{{\"calls\":{},\"sets\":{},\"connections\":{},\"values\":{},\"ring\":{}}}",
+        nested(&calls),
+        sets_json(&out.sets),
+        list(&c.iter().map(|c| c.connection as u32).collect::<Vec<_>>()),
+        nested(&values),
+        out.ring_advance
+    )
+}

crates/urt-gameplay/src/native_policy.rs

@@ -458,3 +458,95 @@ mod session_tests {
         );
     }
 }
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SessionClient {
+    pub connection: i32,
+    pub values: [i32; 9],
+    pub ignore: [i32; 64],
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PostSession {
+    pub calls: Vec<(PostMapChild, usize, i32)>,
+    pub sets: Vec<(Vec<u8>, Vec<u8>)>,
+    pub ring_advance: u32,
+}
+/// Compose249007 and246963. First-child effects are supplied, applied before
+/// serialization, and staged together with client changes on callback errors.
+pub fn persist_post_map<F: FnMut(usize, &mut [SessionClient]) -> Result<(), Error>>(
+    clients: &mut [SessionClient],
+    count: i32,
+    entity_clients: &[usize],
+    mut first: F,
+) -> Result<PostSession, Error> {
+    let n = count.max(0) as usize;
+    if clients.len() > 64 || n > clients.len() || entity_clients.len() < n {
+        return Err(Error::InvalidCount);
+    }
+    if entity_clients[..n].iter().any(|j| *j >= 64) {
+        return Err(Error::InvalidIndex);
+    }
+    let mut staged = clients.to_vec();
+    let mut out = PostSession {
+        calls: vec![],
+        sets: vec![],
+        ring_advance: 0,
+    };
+    for j in 0..n {
+        if staged[j].connection != 2 {
+            continue;
+        }
+        out.calls
+            .push((PostMapChild::First, j, staged[j].connection));
+        first(j, &mut staged)?;
+        out.calls
+            .push((PostMapChild::Second, j, staged[j].connection));
+        let written = session_write(
+            j,
+            count,
+            staged[j].values,
+            entity_clients,
+            &staged[j].ignore,
+        )?;
+        out.sets.extend(written.sets);
+        out.ring_advance = out.ring_advance.wrapping_add(written.ring_advance);
+    }
+    clients.clone_from_slice(&staged);
+    Ok(out)
+}
+#[cfg(test)]
+mod post_session_tests {
+    use super::*;
+    fn client() -> SessionClient {
+        SessionClient {
+            connection: 2,
+            values: [0; 9],
+            ignore: [0; 64],
+        }
+    }
+    #[test]
+    fn callback_fields_and_disconnect_persist() {
+        let mut c = [client()];
+        let out = persist_post_map(&mut c, 1, &[0], |j, c| {
+            c[j].connection = 0;
+            c[j].values[0] = 77;
+            Ok(())
+        })
+        .unwrap();
+        assert_eq!(out.sets[0].1, b"77,0,0,0,0,0,0,0,0");
+        assert_eq!(out.calls[1], (PostMapChild::Second, 0, 0));
+    }
+    #[test]
+    fn callback_error_is_atomic() {
+        let mut c = [client()];
+        let before = c.clone();
+        assert_eq!(
+            persist_post_map(&mut c, 1, &[0], |j, c| {
+                c[j].connection = 0;
+                Err(Error::InvalidInput)
+            }),
+            Err(Error::InvalidInput)
+        );
+        assert_eq!(c, before);
+    }
+}

docs/FINDINGS.md

@@ -1670,3 +1670,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-890:** 64 continuous249007/246963 compositions execute session cvar serialization after the captured246746 child. Supplied first-child disconnection still allows persistence; later activation affects dispatch, and changed session fields are serialized immediately. Source formatter ring carries between clients. Native first-child behavior, engine cvars and count/base changes remain open. [Evidence](research/QVM_POST_MAP_SESSION.md).
+
+
+**RE-891:** Rust matches64 original249007/246963 compositions, including first-child disconnect/activation/field updates, exact cvar bytes and carried formatter-ring advance. Client changes stage atomically on typed callback errors. The first child and engine storage remain caller-owned; native effects and count/base mutation are outside this contract. [Evidence](research/RUST_POST_MAP_SESSION.md).

docs/PROVISIONAL_TODO.md

@@ -1701,3 +1701,6 @@ RE-889: Rust matches60 actual246963 byte-for-byte cvar fixtures, preserving reco
 
 
 RE-890: 64 continuous249007/246963 compositions execute session cvar serialization after the captured246746 child. Supplied first-child disconnection still allows persistence; later activation affects dispatch, and changed session fields are serialized immediately. Source formatter ring carries between clients. Native first-child behavior, engine cvars and count/base changes remain open. Full runtime completion remains open. [Evidence](research/QVM_POST_MAP_SESSION.md).
+
+
+RE-891: Rust matches64 original249007/246963 compositions, including first-child disconnect/activation/field updates, exact cvar bytes and carried formatter-ring advance. Client changes stage atomically on typed callback errors. The first child and engine storage remain caller-owned; native effects and count/base mutation are outside this contract. Full runtime completion remains open. [Evidence](research/RUST_POST_MAP_SESSION.md).

docs/RESEARCH_LEDGER.md

@@ -2160,3 +2160,8 @@ Rust matches60 actual246963 byte-for-byte cvar fixtures, preserving recovered in
 ## 2026-10-28 — RE-890 Original post-map dispatch with session persistence
 
 64 continuous249007/246963 compositions execute session cvar serialization after the captured246746 child. Supplied first-child disconnection still allows persistence; later activation affects dispatch, and changed session fields are serialized immediately. Source formatter ring carries between clients. Native first-child behavior, engine cvars and count/base changes remain open. Focused `cargo xtask test-group qvm-post-map-session` passes (4 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-891 Rust post-map persistence composition
+
+Rust matches64 original249007/246963 compositions, including first-child disconnect/activation/field updates, exact cvar bytes and carried formatter-ring advance. Client changes stage atomically on typed callback errors. The first child and engine storage remain caller-owned; native effects and count/base mutation are outside this contract. Focused `cargo xtask test-group rust-post-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.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1738,3 +1738,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-890 Original post-map dispatch with session persistence ([evidence](research/QVM_POST_MAP_SESSION.md)).
+
+
+- [x] RE-891 Rust post-map persistence composition ([evidence](research/RUST_POST_MAP_SESSION.md)).

docs/research/README.md

@@ -1273,3 +1273,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-890: Original post-map dispatch with session persistence](QVM_POST_MAP_SESSION.md).
+
+
+[RE-891: Rust post-map persistence composition](RUST_POST_MAP_SESSION.md).

docs/research/RUST_POST_MAP_SESSION.md

@@ -0,0 +1,7 @@
+# Rust post-map persistence composition
+
+RE-891. Reproduce with `python3 scripts/analyze_rust_post_map_session.py`; focused validation: `cargo xtask test-group rust-post-map-session`. [Machine report](rust-post-map-session.json).
+
+Rust matches64 original249007/246963 compositions, including first-child disconnect/activation/field updates, exact cvar bytes and carried formatter-ring advance. Client changes stage atomically on typed callback errors. The first child and engine storage remain caller-owned; native effects and count/base mutation are outside this contract.
+
+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": 145,
+  "rust_unit_tests": 147,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_post_map_session.py

@@ -0,0 +1,14 @@
+#!/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 [a['count'],a['mutation'],*a['indices'],*a['flags'],*[v for connection,values in zip(a['connections'],a['values']) for v in [connection,*values]]]
+def project(s):return {k:s[k] for k in ['calls','sets','connections','values','ring']}
+
+def main():
+ b=binary();p=Path('docs/research/qvm-post-map-session.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'post-session',encode(s))})
+ write_json(Path('docs/research/rust-post-map-session.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust matches64 original249007/246963 compositions, including first-child disconnect/activation/field updates, exact cvar bytes and carried formatter-ring advance. Client changes stage atomically on typed callback errors. The first child and engine storage remain caller-owned; native effects and count/base mutation are outside this contract.'})
+if __name__=='__main__':main()

scripts/test_rust_post_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-post-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-post-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

@@ -2671,3 +2671,17 @@ report	scripts/analyze_qvm_post_map_session.py	docs/research/qvm-post-map-sessio
 edge	docs/research/qvm-post-map-session.json	scripts/test_qvm_post_map_session.py
 group	qvm-post-map-session	scripts/analyze_qvm_post_map_session.py
 edge	scripts/analyze_qvm_post_map_session.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_post_map_session.py
+edge	Cargo.lock	scripts/analyze_rust_post_map_session.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_post_map_session.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_post_map_session.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_post_map_session.py
+edge	crates/urt-gameplay/src/bin/urt-native-policy.rs	scripts/analyze_rust_post_map_session.py
+edge	docs/research/qvm-post-map-session.json	scripts/analyze_rust_post_map_session.py
+group	rust-post-map-session	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_post_map_session.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_post_map_session.py
+report	scripts/analyze_rust_post_map_session.py	docs/research/rust-post-map-session.json
+edge	docs/research/rust-post-map-session.json	scripts/test_rust_post_map_session.py
+group	rust-post-map-session	scripts/analyze_rust_post_map_session.py
+edge	scripts/analyze_rust_post_map_session.py	scripts/analyze_qvm_resumer_audit.py