gameplay: port session initialization ownership

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

@@ -507,6 +507,47 @@ fn run() -> Result<String, String> {
                     .unwrap_or("null".into())
             ))
         }
+        "session-init" => {
+            if w.len() < 9 {
+                return Err("missing init header".into());
+            }
+            let mut p = 9;
+            let info = input_blob(&w, &mut p)?.ok_or("null info")?;
+            let mut raw = input_blob(&w, &mut p)?.ok_or("null raw")?;
+            if p != w.len() {
+                return Err("trailing init words".into());
+            }
+            let mut selector = 0;
+            let out = initialize_session(
+                &mut raw,
+                InitializeInput {
+                    enabled: 1,
+                    mapname: b"ut4_test",
+                    file_length: 11,
+                    file_data: b"9,8,7,6,5,4",
+                    mode: w[0] as i32,
+                    slot: w[1] as usize,
+                    limit: w[2] as i32,
+                    occupancy: w[3] as i32,
+                    seconds: w[4] as i32,
+                    clock: w[5] as i32,
+                    ticks: w[6],
+                    handle: w[7],
+                    client_id: w[8],
+                    userinfo: &info,
+                },
+                &mut selector,
+            )
+            .map_err(|e| format!("{e:?}"))?;
+            Ok(format!(
+                "{{\"raw\":\"{}\",\"sets\":{},\"ring\":{},\"info_ring\":{selector},\"diagnostics\":[{}],\"load_events\":{}}}",
+                hex(&raw),
+                sets_json(&out.session.sets),
+                out.ring_advance,
+                list(&out.diagnostic),
+                position_events(&out.load.io.events)
+            ))
+        }
         _ => Err("unknown command".into()),
     }
 }

crates/urt-gameplay/src/native_policy.rs

@@ -1332,3 +1332,169 @@ mod restore_tail_tests {
         assert_eq!(out.words[5], 6f32.to_bits());
     }
 }
+
+pub const SESSION_BYTES: usize = 944;
+fn raw_word(raw: &[u8], offset: usize) -> u32 {
+    u32::from_le_bytes(raw[offset..offset + 4].try_into().unwrap())
+}
+fn raw_store(raw: &mut [u8], offset: usize, value: u32) {
+    raw[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
+}
+pub struct InitializeInput<'a> {
+    pub mode: i32,
+    pub slot: usize,
+    pub userinfo: &'a [u8],
+    pub limit: i32,
+    pub occupancy: i32,
+    pub seconds: i32,
+    pub clock: i32,
+    pub ticks: u32,
+    pub handle: u32,
+    pub client_id: u32,
+    pub enabled: i32,
+    pub mapname: &'a [u8],
+    pub file_length: i32,
+    pub file_data: &'a [u8],
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct InitializedSession {
+    pub load: PositionLoad,
+    pub session: SessionWrite,
+    pub diagnostic: [u32; 3],
+    pub ring_advance: u32,
+}
+/// Original247520 with explicit raw-field ownership. Byte clears preserve the
+/// other three bytes; only successful position load replaces saved coordinates.
+pub fn initialize_session(
+    raw: &mut [u8],
+    input: InitializeInput<'_>,
+    info_ring: &mut u32,
+) -> Result<InitializedSession, Error> {
+    if raw.len() != SESSION_BYTES || input.slot >= 64 {
+        return Err(Error::InvalidCount);
+    }
+    let mut bytes = raw.to_vec();
+    let mut selector = *info_ring;
+    let team = if crate::intermission::team_mode(input.mode) {
+        let old = raw_word(&bytes, 0);
+        if old == 0 { 3 } else { old }
+    } else {
+        let t = info_lookup(Some(input.userinfo), Some(b"team"), &mut selector)?;
+        if t.value.first() == Some(&b's') || input.limit > 0 && input.occupancy >= input.limit {
+            3
+        } else {
+            0
+        }
+    };
+    raw_store(&mut bytes, 0, team);
+    raw_store(&mut bytes, 8, input.clock as u32);
+    raw_store(&mut bytes, 12, 1);
+    let timeout = if input.seconds != 0 {
+        input.seconds.wrapping_mul(1000)
+    } else {
+        60000
+    };
+    raw_store(&mut bytes, 44, input.clock.wrapping_add(timeout) as u32);
+    for offset in [48, 52, 56, 64, 104, 492, 592, 612, 616, 644] {
+        raw_store(&mut bytes, offset, 0);
+    }
+    raw_store(&mut bytes, 60, input.ticks);
+    bytes[68..104].fill(0);
+    bytes[68] = b' ';
+    for offset in [108, 236, 496, 528, 560] {
+        bytes[offset] = 0;
+    }
+    bytes[684..940].fill(0);
+    let values = std::array::from_fn(|j| raw_word(&bytes, 620 + 4 * j));
+    let loaded = load_position(
+        PositionInput {
+            mode: input.mode,
+            enabled: input.enabled,
+            slot: input.slot,
+            userinfo: input.userinfo,
+            mapname: input.mapname,
+            name: b"",
+            values,
+            handle: input.handle,
+        },
+        input.file_length,
+        input.file_data,
+        &mut selector,
+    )?;
+    for (j, v) in loaded.values.iter().enumerate() {
+        raw_store(&mut bytes, 620 + 4 * j, *v);
+    }
+    let fields = [0, 60, 48, 44, 52, 56, 612, 616, 644].map(|o| raw_word(&bytes, o) as i32);
+    let session = session_write(input.slot, 0, fields, &[], &[0; 64])?;
+    let ring_advance = session.ring_advance + loaded.io.ring_advance;
+    raw.copy_from_slice(&bytes);
+    *info_ring = selector;
+    Ok(InitializedSession {
+        load: loaded,
+        session,
+        diagnostic: [83576, input.client_id, input.ticks],
+        ring_advance,
+    })
+}
+#[cfg(test)]
+mod init_tests {
+    use super::*;
+    #[test]
+    fn byte_clear_preserves_neighbor_bytes() {
+        let mut raw = vec![0xdd; SESSION_BYTES];
+        let mut ring = 0;
+        let out = initialize_session(
+            &mut raw,
+            InitializeInput {
+                enabled: 1,
+                mapname: b"ut4_test",
+                file_length: 11,
+                file_data: b"9,8,7,6,5,4",
+                mode: 3,
+                slot: 0,
+                userinfo: b"",
+                limit: 0,
+                occupancy: 0,
+                seconds: 0,
+                clock: 7,
+                ticks: 9,
+                handle: 0,
+                client_id: 2,
+            },
+            &mut ring,
+        )
+        .unwrap();
+        assert_eq!(&raw[108..112], &[0, 0xdd, 0xdd, 0xdd]);
+        assert_eq!(raw_word(&raw, 44), 60007);
+        assert_eq!(out.session.sets[1].1, b"");
+    }
+    #[test]
+    fn bad_raw_domain_does_not_change_selector() {
+        let mut raw = [];
+        let mut ring = 1;
+        assert_eq!(
+            initialize_session(
+                &mut raw,
+                InitializeInput {
+                    enabled: 1,
+                    mapname: b"ut4_test",
+                    file_length: 11,
+                    file_data: b"9,8,7,6,5,4",
+                    mode: 0,
+                    slot: 0,
+                    userinfo: b"",
+                    limit: 0,
+                    occupancy: 0,
+                    seconds: 0,
+                    clock: 0,
+                    ticks: 0,
+                    handle: 0,
+                    client_id: 0
+                },
+                &mut ring
+            ),
+            Err(Error::InvalidCount)
+        );
+        assert_eq!(ring, 1);
+    }
+}

docs/FINDINGS.md

@@ -1712,3 +1712,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-904:** 96 actual247520 compositions execute team classification, userinfo lookup, bounded copy, saved-position load and session serialization. Team/default/capacity policy, wrapping timeout arithmetic, native tick snapshot, byte-only versus word clears,36-byte text initialization and64 ignored-client clears are recovered. Existing position fields persist unless the recovered load succeeds. Diagnostic7259 and engine/file operations remain captured/supplied; caller authentication and post-initialization behavior remain open. [Evidence](research/QVM_SESSION_INIT.md).
+
+
+**RE-905:** Rust matches96 original247520 initialization/load/write cases, preserving raw byte/word clears, timeout wrapping, team/capacity selection,64 ignore clears and immediate session cvar bytes. Existing coordinates survive failed/suppressed loads. Engine clock/userinfo/files and diagnostic logging remain supplied/intended; caller behavior and native lifecycle remain open. [Evidence](research/RUST_SESSION_INIT.md).

docs/PROVISIONAL_TODO.md

@@ -1749,3 +1749,6 @@ RE-894–903 completed bounded userinfo/scanner/saved-file/session-restore sourc
 
 
 RE-904: 96 actual247520 compositions execute team classification, userinfo lookup, bounded copy, saved-position load and session serialization. Team/default/capacity policy, wrapping timeout arithmetic, native tick snapshot, byte-only versus word clears,36-byte text initialization and64 ignored-client clears are recovered. Existing position fields persist unless the recovered load succeeds. Diagnostic7259 and engine/file operations remain captured/supplied; caller authentication and post-initialization behavior remain open. Full runtime completion remains open. [Evidence](research/QVM_SESSION_INIT.md).
+
+
+RE-905: Rust matches96 original247520 initialization/load/write cases, preserving raw byte/word clears, timeout wrapping, team/capacity selection,64 ignore clears and immediate session cvar bytes. Existing coordinates survive failed/suppressed loads. Engine clock/userinfo/files and diagnostic logging remain supplied/intended; caller behavior and native lifecycle remain open. Full runtime completion remains open. [Evidence](research/RUST_SESSION_INIT.md).

docs/RESEARCH_LEDGER.md

@@ -2240,3 +2240,8 @@ After the tenth commit, `cargo xtask test-full --since 6e01995b` passed with the
 ## 2026-10-28 — RE-904 Original session initialization and immediate persistence
 
 96 actual247520 compositions execute team classification, userinfo lookup, bounded copy, saved-position load and session serialization. Team/default/capacity policy, wrapping timeout arithmetic, native tick snapshot, byte-only versus word clears,36-byte text initialization and64 ignored-client clears are recovered. Existing position fields persist unless the recovered load succeeds. Diagnostic7259 and engine/file operations remain captured/supplied; caller authentication and post-initialization behavior remain open. Focused `cargo xtask test-group qvm-session-init` 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-905 Rust session initialization and raw-field ownership
+
+Rust matches96 original247520 initialization/load/write cases, preserving raw byte/word clears, timeout wrapping, team/capacity selection,64 ignore clears and immediate session cvar bytes. Existing coordinates survive failed/suppressed loads. Engine clock/userinfo/files and diagnostic logging remain supplied/intended; caller behavior and native lifecycle remain open. Focused `cargo xtask test-group rust-session-init` 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

@@ -1786,3 +1786,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-904 Original session initialization and immediate persistence ([evidence](research/QVM_SESSION_INIT.md)).
+
+
+- [x] RE-905 Rust session initialization and raw-field ownership ([evidence](research/RUST_SESSION_INIT.md)).

docs/research/README.md

@@ -1321,3 +1321,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-904: Original session initialization and immediate persistence](QVM_SESSION_INIT.md).
+
+
+[RE-905: Rust session initialization and raw-field ownership](RUST_SESSION_INIT.md).

docs/research/RUST_SESSION_INIT.md

@@ -0,0 +1,7 @@
+# Rust session initialization and raw-field ownership
+
+RE-905. Reproduce with `python3 scripts/analyze_rust_session_init.py`; focused validation: `cargo xtask test-group rust-session-init`. [Machine report](rust-session-init.json).
+
+Rust matches96 original247520 initialization/load/write cases, preserving raw byte/word clears, timeout wrapping, team/capacity selection,64 ignore clears and immediate session cvar bytes. Existing coordinates survive failed/suppressed loads. Engine clock/userinfo/files and diagnostic logging remain supplied/intended; caller behavior and native lifecycle 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": 159,
+  "rust_unit_tests": 161,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_session_init.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 blob(s):return [len(bytes.fromhex(s)),*bytes.fromhex(s)]
+def encode(s):
+ a=s['input'];return [a['mode'],a['slot'],a['limit'],a['occupancy'],a['seconds'],a['now'],a['ticks'],a['handle'],17+a['slot'],*blob(a['info']),*blob(a['before'])]
+def project(s):return {k:s[k] for k in ['raw','ring','info_ring','diagnostics']}|{'sets':s['parts']['session']['sets'],'load_events':s['parts']['load']['events']}
+
+def main():
+ b=binary();p=Path('docs/research/qvm-session-init.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'session-init',encode(s))})
+ write_json(Path('docs/research/rust-session-init.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust matches96 original247520 initialization/load/write cases, preserving raw byte/word clears, timeout wrapping, team/capacity selection,64 ignore clears and immediate session cvar bytes. Existing coordinates survive failed/suppressed loads. Engine clock/userinfo/files and diagnostic logging remain supplied/intended; caller behavior and native lifecycle remain open.'})
+if __name__=='__main__':main()

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

@@ -2807,3 +2807,18 @@ report	scripts/analyze_qvm_session_init.py	docs/research/qvm-session-init.json
 edge	docs/research/qvm-session-init.json	scripts/test_qvm_session_init.py
 group	qvm-session-init	scripts/analyze_qvm_session_init.py
 edge	scripts/analyze_qvm_session_init.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_session_init.py
+edge	Cargo.lock	scripts/analyze_rust_session_init.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_session_init.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_session_init.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_session_init.py
+edge	crates/urt-gameplay/src/bin/urt-native-policy.rs	scripts/analyze_rust_session_init.py
+edge	docs/research/qvm-session-init.json	scripts/analyze_rust_session_init.py
+group	rust-session-init	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_session_init.py
+edge	crates/urt-gameplay/src/intermission.rs	scripts/analyze_rust_session_init.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_session_init.py
+report	scripts/analyze_rust_session_init.py	docs/research/rust-session-init.json
+edge	docs/research/rust-session-init.json	scripts/test_rust_session_init.py
+group	rust-session-init	scripts/analyze_rust_session_init.py
+edge	scripts/analyze_rust_session_init.py	scripts/analyze_qvm_resumer_audit.py