gameplay: add in-memory persistence round trips

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

@@ -653,6 +653,66 @@ fn run() -> Result<String, String> {
                 command
             ))
         }
+        "roundtrip" => {
+            if w.len() < 85 {
+                return Err("missing roundtrip header".into());
+            }
+            let n = w[5] as usize;
+            if n > 64 || w.len() != 85 + n {
+                return Err("invalid roundtrip count".into());
+            }
+            let mut engine = MemoryPersistence::default();
+            let mut target = RestoreState {
+                values: [0; 9],
+                ignore: [2; 64],
+                position: [0; 6],
+            };
+            let mut selector = 0;
+            let indices = w[85..].iter().map(|v| *v as usize).collect::<Vec<_>>();
+            let out = persistence_roundtrip(
+                RoundtripInput {
+                    position: PositionInput {
+                        mode: w[0] as i32,
+                        enabled: 1,
+                        slot: w[1] as usize,
+                        userinfo: b"\\cl_guid\\ID",
+                        mapname: b"ut4_test",
+                        name: b"PLAYER",
+                        values: w[79..85].try_into().unwrap(),
+                        handle: w[2],
+                    },
+                    flags: w[3],
+                    values: std::array::from_fn(|j| w[6 + j] as i32),
+                    ignore: std::array::from_fn(|j| w[15 + j] as i32),
+                    entity_clients: &indices,
+                    scratch: [w[4]; 5],
+                    read_handle: 7,
+                },
+                &mut target,
+                &mut engine,
+                &mut selector,
+            )
+            .map_err(|e| format!("{e:?}"))?;
+            let file = engine
+                .files
+                .values()
+                .next()
+                .map(|v| format!("\"{}\"", hex(v)))
+                .unwrap_or("null".into());
+            Ok(format!(
+                "{{\"saved\":{},\"sets\":{},\"file\":{},\"values\":{},\"ignore\":{},\"origin\":{},\"scan_result\":{},\"cvars\":{},\"load_events\":{},\"ring\":{},\"info_ring\":{selector}}}",
+                position_events(&out.saved.events),
+                sets_json(&out.written.sets),
+                file,
+                list(&target.values.map(|v| v as u32)),
+                list(&target.ignore.map(|v| v as u32)),
+                list(&target.position),
+                out.restored.scan_result,
+                sets_json(&out.restored.cvars),
+                position_events(&out.restored.position.io.events),
+                out.ring_advance
+            ))
+        }
         _ => Err("unknown command".into()),
     }
 }

crates/urt-gameplay/src/native_policy.rs

@@ -902,6 +902,7 @@ pub struct PositionIo {
     pub events: Vec<PositionEvent>,
     pub ring_advance: u32,
 }
+#[derive(Clone, Copy)]
 pub struct PositionInput<'a> {
     pub mode: i32,
     pub enabled: i32,
@@ -1719,3 +1720,177 @@ mod normal_persist_tests {
         assert_eq!(ring, 1);
     }
 }
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct MemoryPersistence {
+    pub cvars: std::collections::BTreeMap<Vec<u8>, Vec<u8>>,
+    pub files: std::collections::BTreeMap<Vec<u8>, Vec<u8>>,
+}
+impl MemoryPersistence {
+    /// Apply a single captured saved-position write sequence to an in-memory
+    /// transcript. This owns bytes, not native handles or operating-system files.
+    pub fn apply_position(&mut self, io: &PositionIo) {
+        let mut path = None;
+        for e in &io.events {
+            match e {
+                PositionEvent::Open { path: p, mode: 1 } => path = Some(p.clone()),
+                PositionEvent::Write { data, .. } => {
+                    if let Some(p) = &path {
+                        self.files.insert(p.clone(), data.clone());
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+    pub fn apply_sets(&mut self, sets: &[(Vec<u8>, Vec<u8>)]) {
+        self.cvars.extend(sets.iter().cloned());
+    }
+}
+pub struct RoundtripInput<'a> {
+    pub position: PositionInput<'a>,
+    pub flags: u32,
+    pub values: [i32; 9],
+    pub ignore: [i32; 64],
+    pub entity_clients: &'a [usize],
+    pub scratch: [u32; 5],
+    pub read_handle: u32,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PersistenceRoundtrip {
+    pub saved: PositionIo,
+    pub written: SessionWrite,
+    pub restored: RestoredSession,
+    pub ring_advance: u32,
+}
+pub fn persistence_roundtrip(
+    input: RoundtripInput<'_>,
+    target: &mut RestoreState,
+    engine: &mut MemoryPersistence,
+    info_ring: &mut u32,
+) -> Result<PersistenceRoundtrip, Error> {
+    if input.entity_clients.len() > 64 {
+        return Err(Error::InvalidCount);
+    }
+    let mut staged_target = target.clone();
+    let mut staged_engine = engine.clone();
+    let mut selector = *info_ring;
+    let context = input.position;
+    let saved = save_position(context, &mut selector)?;
+    let written = session_write(
+        context.slot,
+        input.entity_clients.len() as i32,
+        input.values,
+        input.entity_clients,
+        &input.ignore,
+    )?;
+    staged_engine.apply_position(&saved);
+    staged_engine.apply_sets(&written.sets);
+    let mut unused = 0;
+    let raw = cbytes(context.userinfo);
+    let guid = info_lookup(
+        Some(&raw[..raw.len().min(1023)]),
+        Some(b"cl_guid"),
+        &mut unused,
+    )?;
+    let path = position_path(context.mapname, &guid.value);
+    let file = staged_engine.files.get(&path).cloned();
+    let data = file.as_deref().unwrap_or_default();
+    let length = if file.is_some() {
+        i32::try_from(data.len()).map_err(|_| Error::InvalidInput)?
+    } else {
+        -1
+    };
+    let mut load = context;
+    load.handle = if file.is_some() { input.read_handle } else { 0 };
+    let session = staged_engine
+        .cvars
+        .get(format!("session{}", context.slot).as_bytes())
+        .cloned()
+        .unwrap_or_default();
+    let ignored = staged_engine
+        .cvars
+        .get(format!("sessIgnore{}", context.slot).as_bytes())
+        .cloned()
+        .unwrap_or_default();
+    let restored = restore_session(
+        &mut staged_target,
+        RestoreInput {
+            flags: input.flags,
+            session: &session,
+            ignore_text: &ignored,
+            scratch: input.scratch,
+            position: load,
+            file_length: length,
+            file_data: data,
+        },
+        &mut selector,
+    )?;
+    let ring_advance = saved.ring_advance + written.ring_advance + restored.ring_advance;
+    *target = staged_target;
+    *engine = staged_engine;
+    *info_ring = selector;
+    Ok(PersistenceRoundtrip {
+        saved,
+        written,
+        restored,
+        ring_advance,
+    })
+}
+#[cfg(test)]
+mod memory_persistence_tests {
+    use super::*;
+    #[test]
+    fn zero_handle_open_does_not_create_file() {
+        let mut engine = MemoryPersistence::default();
+        engine.apply_position(&PositionIo {
+            events: vec![PositionEvent::Open {
+                path: b"x".to_vec(),
+                mode: 1,
+            }],
+            ring_advance: 1,
+        });
+        assert!(engine.files.is_empty());
+    }
+    #[test]
+    fn rejected_indices_do_not_commit_engine_or_selector() {
+        let mut engine = MemoryPersistence::default();
+        let old = engine.clone();
+        let mut target = RestoreState {
+            values: [0; 9],
+            ignore: [2; 64],
+            position: [0; 6],
+        };
+        let before = target.clone();
+        let mut selector = 0;
+        assert_eq!(
+            persistence_roundtrip(
+                RoundtripInput {
+                    position: PositionInput {
+                        mode: 0,
+                        enabled: 1,
+                        slot: 0,
+                        userinfo: b"",
+                        mapname: b"m",
+                        name: b"n",
+                        values: [0; 6],
+                        handle: 0
+                    },
+                    flags: 0,
+                    values: [0; 9],
+                    ignore: [0; 64],
+                    entity_clients: &[64],
+                    scratch: [0; 5],
+                    read_handle: 7
+                },
+                &mut target,
+                &mut engine,
+                &mut selector
+            ),
+            Err(Error::InvalidIndex)
+        );
+        assert_eq!(engine, old);
+        assert_eq!(target, before);
+        assert_eq!(selector, 0);
+    }
+}

docs/FINDINGS.md

@@ -1730,3 +1730,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-910:** 144 finite original246746/246963/247219/246554 compositions feed actual captured cvar/file bytes into a fresh destination snapshot. Negative and INT_MIN integer formatting is deliberately not assumed invertible; original partial scanner writes and supplied scratch are preserved. Ignore entries accumulate over the destination table, and six-float file prefixes survive appended names. The engine is a supplied in-memory transcript, not a native filesystem or real map reload. [Evidence](research/QVM_PERSISTENCE_ROUNDTRIP.md).
+
+
+**RE-911:** Rust matches144 original save/session-write/restore/read compositions using owned in-memory cvar/file bytes. Partial integer parsing and caller scratch preserve the observed non-invertibility of negative/INT_MIN session text; file prefixes and ignore accumulation remain exact. Engine/destination/selector changes stage atomically on errors. This adapter does not own native handles or perform OS file IO. [Evidence](research/RUST_PERSISTENCE_ROUNDTRIP.md).

docs/PROVISIONAL_TODO.md

@@ -1767,3 +1767,6 @@ RE-909: Rust matches64 original normal transitions with actual saved-file and cv
 
 
 RE-910: 144 finite original246746/246963/247219/246554 compositions feed actual captured cvar/file bytes into a fresh destination snapshot. Negative and INT_MIN integer formatting is deliberately not assumed invertible; original partial scanner writes and supplied scratch are preserved. Ignore entries accumulate over the destination table, and six-float file prefixes survive appended names. The engine is a supplied in-memory transcript, not a native filesystem or real map reload. Full runtime completion remains open. [Evidence](research/QVM_PERSISTENCE_ROUNDTRIP.md).
+
+
+RE-911: Rust matches144 original save/session-write/restore/read compositions using owned in-memory cvar/file bytes. Partial integer parsing and caller scratch preserve the observed non-invertibility of negative/INT_MIN session text; file prefixes and ignore accumulation remain exact. Engine/destination/selector changes stage atomically on errors. This adapter does not own native handles or perform OS file IO. Full runtime completion remains open. [Evidence](research/RUST_PERSISTENCE_ROUNDTRIP.md).

docs/RESEARCH_LEDGER.md

@@ -2270,3 +2270,8 @@ Rust matches64 original normal transitions with actual saved-file and cvar child
 ## 2026-10-28 — RE-910 Original write-to-restore persistence round trip
 
 144 finite original246746/246963/247219/246554 compositions feed actual captured cvar/file bytes into a fresh destination snapshot. Negative and INT_MIN integer formatting is deliberately not assumed invertible; original partial scanner writes and supplied scratch are preserved. Ignore entries accumulate over the destination table, and six-float file prefixes survive appended names. The engine is a supplied in-memory transcript, not a native filesystem or real map reload. Focused `cargo xtask test-group qvm-persistence-roundtrip` 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-911 Rust in-memory persistence round trip
+
+Rust matches144 original save/session-write/restore/read compositions using owned in-memory cvar/file bytes. Partial integer parsing and caller scratch preserve the observed non-invertibility of negative/INT_MIN session text; file prefixes and ignore accumulation remain exact. Engine/destination/selector changes stage atomically on errors. This adapter does not own native handles or perform OS file IO. Focused `cargo xtask test-group rust-persistence-roundtrip` 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

@@ -1804,3 +1804,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-910 Original write-to-restore persistence round trip ([evidence](research/QVM_PERSISTENCE_ROUNDTRIP.md)).
+
+
+- [x] RE-911 Rust in-memory persistence round trip ([evidence](research/RUST_PERSISTENCE_ROUNDTRIP.md)).

docs/research/README.md

@@ -1339,3 +1339,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-910: Original write-to-restore persistence round trip](QVM_PERSISTENCE_ROUNDTRIP.md).
+
+
+[RE-911: Rust in-memory persistence round trip](RUST_PERSISTENCE_ROUNDTRIP.md).

docs/research/RUST_PERSISTENCE_ROUNDTRIP.md

@@ -0,0 +1,7 @@
+# Rust in-memory persistence round trip
+
+RE-911. Reproduce with `python3 scripts/analyze_rust_persistence_roundtrip.py`; focused validation: `cargo xtask test-group rust-persistence-roundtrip`. [Machine report](rust-persistence-roundtrip.json).
+
+Rust matches144 original save/session-write/restore/read compositions using owned in-memory cvar/file bytes. Partial integer parsing and caller scratch preserve the observed non-invertibility of negative/INT_MIN session text; file prefixes and ignore accumulation remain exact. Engine/destination/selector changes stage atomically on errors. This adapter does not own native handles or perform OS file IO.
+
+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": 163,
+  "rust_unit_tests": 165,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_persistence_roundtrip.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['mode'],a['slot'],7 if a['opened'] else 0,a['flag'],a['scratch'],len(a['indices']),*a['values'],*a['ignore'],*a['origin'],*a['indices']]
+def project(s):return {k:s[k] for k in ['saved','sets','file','values','ignore','origin','scan_result','cvars','ring','info_ring']}|{'load_events':s['load']['events']}
+
+def main():
+ b=binary();p=Path('docs/research/qvm-persistence-roundtrip.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'roundtrip',encode(s))})
+ write_json(Path('docs/research/rust-persistence-roundtrip.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust matches144 original save/session-write/restore/read compositions using owned in-memory cvar/file bytes. Partial integer parsing and caller scratch preserve the observed non-invertibility of negative/INT_MIN session text; file prefixes and ignore accumulation remain exact. Engine/destination/selector changes stage atomically on errors. This adapter does not own native handles or perform OS file IO.'})
+if __name__=='__main__':main()

scripts/test_rust_persistence_roundtrip.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-persistence-roundtrip.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-persistence-roundtrip.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

@@ -2868,3 +2868,18 @@ report	scripts/analyze_qvm_persistence_roundtrip.py	docs/research/qvm-persistenc
 edge	docs/research/qvm-persistence-roundtrip.json	scripts/test_qvm_persistence_roundtrip.py
 group	qvm-persistence-roundtrip	scripts/analyze_qvm_persistence_roundtrip.py
 edge	scripts/analyze_qvm_persistence_roundtrip.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_persistence_roundtrip.py
+edge	Cargo.lock	scripts/analyze_rust_persistence_roundtrip.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_persistence_roundtrip.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_persistence_roundtrip.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_persistence_roundtrip.py
+edge	crates/urt-gameplay/src/bin/urt-native-policy.rs	scripts/analyze_rust_persistence_roundtrip.py
+edge	docs/research/qvm-persistence-roundtrip.json	scripts/analyze_rust_persistence_roundtrip.py
+group	rust-persistence-roundtrip	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_persistence_roundtrip.py
+edge	crates/urt-gameplay/src/intermission.rs	scripts/analyze_rust_persistence_roundtrip.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_persistence_roundtrip.py
+report	scripts/analyze_rust_persistence_roundtrip.py	docs/research/rust-persistence-roundtrip.json
+edge	docs/research/rust-persistence-roundtrip.json	scripts/test_rust_persistence_roundtrip.py
+group	rust-persistence-roundtrip	scripts/analyze_rust_persistence_roundtrip.py
+edge	scripts/analyze_rust_persistence_roundtrip.py	scripts/analyze_qvm_resumer_audit.py