gameplay: port temporary event construction

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

@@ -176,6 +176,62 @@ fn run() -> Result<String, String> {
                 map_clients_json(&c)
             ))
         }
+        "event" => {
+            if w.len() != 6 {
+                return Err("invalid event input".into());
+            }
+            let init = 0x13579bdf;
+            let mut e = EventRecord {
+                kind: init,
+                trajectory: [init; 3],
+                origin: [init; 3],
+                velocity: [init; 3],
+                caller_time: init,
+                owner: init,
+                field400: init,
+                flags: w[5],
+                current_origin: [init; 3],
+                class_token: init,
+                class_hash: init,
+                event_time: init as i32,
+                free_after_event: init,
+            };
+            let link = temporary_event(&mut e, w[..3].try_into().unwrap(), w[3], w[4] as i32)
+                .map_err(|e| format!("{e:?}"))?;
+            let f = object(
+                &[
+                    4, 12, 16, 20, 24, 28, 32, 36, 40, 44, 84, 140, 400, 424, 488, 492, 496, 536,
+                    540, 568, 572,
+                ],
+                &[
+                    e.kind,
+                    e.trajectory[0],
+                    e.trajectory[1],
+                    e.trajectory[2],
+                    e.origin[0],
+                    e.origin[1],
+                    e.origin[2],
+                    e.velocity[0],
+                    e.velocity[1],
+                    e.velocity[2],
+                    e.caller_time,
+                    e.owner,
+                    e.field400,
+                    e.flags,
+                    e.current_origin[0],
+                    e.current_origin[1],
+                    e.current_origin[2],
+                    e.class_token,
+                    e.class_hash,
+                    e.event_time as u32,
+                    e.free_after_event,
+                ],
+            );
+            Ok(format!(
+                "{{\"fields\":{f},\"link\":{}}}",
+                link == EventIntent::Link
+            ))
+        }
         _ => Err("unknown command".into()),
     }
 }

crates/urt-gameplay/src/transition.rs

@@ -371,3 +371,129 @@ mod normal_tests {
         assert_eq!(mark_connecting(&mut c, 1), Err(Error::InvalidCount));
     }
 }
+
+/// Word-level source record. Class token97191 identifies the original tempEntity
+/// string; runtime code must resolve metadata rather than use it as a native pointer.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct EventRecord {
+    pub kind: u32,
+    pub trajectory: [u32; 3],
+    pub origin: [u32; 3],
+    pub velocity: [u32; 3],
+    pub caller_time: u32,
+    pub owner: u32,
+    pub field400: u32,
+    pub flags: u32,
+    pub current_origin: [u32; 3],
+    pub class_token: u32,
+    pub class_hash: u32,
+    pub event_time: i32,
+    pub free_after_event: u32,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum EventIntent {
+    Link,
+}
+pub fn temporary_event(
+    record: &mut EventRecord,
+    origin: [u32; 3],
+    kind: u32,
+    now: i32,
+) -> Result<EventIntent, Error> {
+    let mut snap = [0; 3];
+    for j in 0..3 {
+        let x = f32::from_bits(origin[j]);
+        if !x.is_finite() || !(-2147483648.0..2147483648.0).contains(&x) {
+            return Err(Error::FloatDomain);
+        }
+        snap[j] = ((x as i32) as f32).to_bits();
+    }
+    record.kind = kind.wrapping_add(19);
+    record.class_token = 97191;
+    record.class_hash = 662184166;
+    record.event_time = now;
+    record.free_after_event = 1;
+    record.origin = snap;
+    record.current_origin = snap;
+    record.trajectory = [0; 3];
+    record.velocity = [0; 3];
+    Ok(EventIntent::Link)
+}
+#[cfg(test)]
+mod event_tests {
+    use super::*;
+    fn allocated() -> EventRecord {
+        EventRecord {
+            kind: 7,
+            trajectory: [7; 3],
+            origin: [7; 3],
+            velocity: [7; 3],
+            caller_time: 42,
+            owner: 99,
+            field400: 13,
+            flags: 16,
+            current_origin: [7; 3],
+            class_token: 7,
+            class_hash: 7,
+            event_time: 7,
+            free_after_event: 7,
+        }
+    }
+    #[test]
+    fn snapped_origin_preserves_allocator_and_caller_fields() {
+        let mut e = allocated();
+        assert_eq!(
+            temporary_event(
+                &mut e,
+                [1.9f32.to_bits(), (-1.9f32).to_bits(), (-0.0f32).to_bits()],
+                u32::MAX,
+                i32::MIN
+            ),
+            Ok(EventIntent::Link)
+        );
+        assert_eq!(e.kind, 18);
+        assert_eq!(e.origin, [1.0f32.to_bits(), (-1.0f32).to_bits(), 0]);
+        assert_eq!(e.current_origin, e.origin);
+        assert_eq!(
+            (e.flags, e.caller_time, e.owner, e.field400),
+            (16, 42, 99, 13)
+        );
+        assert_eq!(
+            (
+                e.class_token,
+                e.class_hash,
+                e.event_time,
+                e.free_after_event
+            ),
+            (97191, 662184166, i32::MIN, 1)
+        );
+    }
+    #[test]
+    fn invalid_conversion_rejects_before_mutation() {
+        for v in [
+            f32::NAN,
+            f32::INFINITY,
+            f32::NEG_INFINITY,
+            2147483648.0,
+            -2147483904.0,
+        ] {
+            let mut e = allocated();
+            let old = e.clone();
+            assert_eq!(
+                temporary_event(&mut e, [0, v.to_bits(), 0], 69, 1000),
+                Err(Error::FloatDomain)
+            );
+            assert_eq!(e, old);
+        }
+        let mut e = allocated();
+        assert!(
+            temporary_event(
+                &mut e,
+                [(-2147483648.0f32).to_bits(), 2147483520.0f32.to_bits(), 0],
+                69,
+                0
+            )
+            .is_ok()
+        );
+    }
+}

docs/FINDINGS.md

@@ -1556,3 +1556,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-852:** 144 original 277695/278138 cases recover tempEntity metadata, wrapped event kind+19, CVFI/CVIF origin snapping, trajectory/current-origin writes and link order. Five invalid float domains reject. Allocator flags424 and caller-owned84/140 are preserved; allocation277165 and native linking remain supplied/captured. [Evidence](research/QVM_EVENT_CONSTRUCT.md).
+
+
+**RE-853:** Rust matches 144 original temporary-event cases, including exact snap words, event-kind wrapping, metadata and preservation of allocator/caller fields. Five invalid source domains reject atomically in Rust. Allocation and native linking remain caller-owned; source class tokens require runtime metadata resolution. [Evidence](research/RUST_EVENT_CONSTRUCT.md).

docs/PROVISIONAL_TODO.md

@@ -1547,7 +1547,7 @@ RE-842: 150 continuous 7805 fixtures now execute actual tie, readiness, begin-tr
 RE-843: Rust composes recovered tie, readiness, begin and exit-log policies with prior exit timers/limits across150 continuous source fixtures. Atomic staged updates preserve shared pending/client state; reset and lower-level world/I/O effects remain explicit intentions. Source branch labels are independently classified by the tested composition oracle; captured requests and actual final source state supply effect parity. Full runtime completion remains open. [Evidence](research/RUST_INTERMISSION_FLOW.md).
 
 
-- [ ] RE-844: Recover next-map/respawn/camera/publication/event allocation effects, broaden pointer/identity fixtures, and integrate ranking→intermission→scoreboard runtime traces. [Scope](research/QVM_INTERMISSION_BATCH.md).
+- [x] RE-844–853: Recover bounded camera, map-reset and event-construction policies; deeper native/runtime work continues under RE-854. [Batch evidence](research/QVM_CAMERA_MAP_EVENT_BATCH.md).
 
 
 RE-844: 72 original 6575 fixtures recover entity/player origin and view-angle copies, velocity clear, movement type5 and cleared entity/client fields. Coherent byte copies preserve arbitrary float words, including NaN payloads; two entity-to-client targets prove indirection. Mode/field4324 gates converge without extra effects. Native renderer/camera integration remains open. Full runtime completion remains open. [Evidence](research/QVM_CAMERA_PLACE.md).
@@ -1575,3 +1575,9 @@ RE-851: Rust matches 48 original normal-reset cases with separate pre-map score
 
 
 RE-852: 144 original 277695/278138 cases recover tempEntity metadata, wrapped event kind+19, CVFI/CVIF origin snapping, trajectory/current-origin writes and link order. Five invalid float domains reject. Allocator flags424 and caller-owned84/140 are preserved; allocation277165 and native linking remain supplied/captured. Full runtime completion remains open. [Evidence](research/QVM_EVENT_CONSTRUCT.md).
+
+
+RE-853: Rust matches 144 original temporary-event cases, including exact snap words, event-kind wrapping, metadata and preservation of allocator/caller fields. Five invalid source domains reject atomically in Rust. Allocation and native linking remain caller-owned; source class tokens require runtime metadata resolution. Full runtime completion remains open. [Evidence](research/RUST_EVENT_CONSTRUCT.md).
+
+
+- [ ] RE-854: Compose recovered camera/map/event policies into intermission flows; recover searches, angles, commands, allocation, respawn and publication; validate actual macOS/Linux runtime traces. [Scope](research/QVM_CAMERA_MAP_EVENT_BATCH.md).

docs/RESEARCH_LEDGER.md

@@ -1938,3 +1938,12 @@ Rust matches 48 original normal-reset cases with separate pre-map score reset an
 ## 2026-10-27 — RE-852 Original temporary event construction and origin snapping
 
 144 original 277695/278138 cases recover tempEntity metadata, wrapped event kind+19, CVFI/CVIF origin snapping, trajectory/current-origin writes and link order. Five invalid float domains reject. Allocator flags424 and caller-owned84/140 are preserved; allocation277165 and native linking remain supplied/captured. Focused `cargo xtask test-group event-construct` 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-853 Rust temporary event construction and ownership boundaries
+
+Rust matches 144 original temporary-event cases, including exact snap words, event-kind wrapping, metadata and preservation of allocator/caller fields. Five invalid source domains reject atomically in Rust. Allocation and native linking remain caller-owned; source class tokens require runtime metadata resolution. Focused `cargo xtask test-group rust-event-construct` 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-853 final review: targeted xtask registry regression passes for all five source-report parity edges, transition module selection and the shared intermission mode-classifier dependency. Added batch evidence, validation cadence and RE-854 integration/native follow-ups.
+
+Batch RE-844–853 boundary: the single `cargo xtask test-full --since 15d7fcac` run passed after commit ten: 1,668 Python tests, 147 Rust tests (assets 10, gameplay 109, xtask 28), 46 deterministic report producers, storage policy, 414 documentation files and whitespace checks. No generated report drift; validation notes amended into task ten. Original assets unchanged.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1584,7 +1584,7 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 - [x] RE-843 Rust composed exit and intermission state machine ([evidence](research/RUST_INTERMISSION_FLOW.md)).
 
 
-- [ ] RE-844: Recover next-map/respawn/camera/publication/event allocation effects, broaden pointer/identity fixtures, and integrate ranking→intermission→scoreboard runtime traces. [Scope](research/QVM_INTERMISSION_BATCH.md).
+- [x] RE-844–853: Recover bounded camera, map-reset and event-construction policies; deeper native/runtime work continues under RE-854. [Batch evidence](research/QVM_CAMERA_MAP_EVENT_BATCH.md).
 
 
 - [x] RE-844 Original intermission camera placement and client indirection ([evidence](research/QVM_CAMERA_PLACE.md)).
@@ -1612,3 +1612,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-852 Original temporary event construction and origin snapping ([evidence](research/QVM_EVENT_CONSTRUCT.md)).
+
+
+- [x] RE-853 Rust temporary event construction and ownership boundaries ([evidence](research/RUST_EVENT_CONSTRUCT.md)).
+
+
+- [ ] RE-854: Compose recovered camera/map/event policies into intermission flows; recover searches, angles, commands, allocation, respawn and publication; validate actual macOS/Linux runtime traces. [Scope](research/QVM_CAMERA_MAP_EVENT_BATCH.md).

docs/TESTING.md

@@ -138,3 +138,8 @@ Use `cargo xtask test-group <name>` with `format-float`, `rust-format-float`, `e
 ## Exit predicate and intermission groups
 
 Focused source/Rust pairs: `exit-predicate`/`rust-exit-predicate`, `intermission-ready`/`rust-intermission-ready`, `intermission-begin`/`rust-intermission-begin`, `exit-log`/`rust-exit-log`, and `intermission-flow`/`rust-intermission-flow`. Run `cargo xtask test-group <name>` before the task commit. The scoped intermission executable has its own adapter inputs; common module changes select every intermission consumer and scoped gameplay test-count metadata. The registry regression verifies source-report edges and module selection. Run one `test-full --since <batch-base>` after ten commits. See the [batch contracts and boundaries](research/QVM_INTERMISSION_BATCH.md).
+
+
+## Camera, map and event groups
+
+Focused source/Rust pairs: `camera-place`/`rust-camera-place`, `camera-select`/`rust-camera-select`, `nextmap-series`/`rust-nextmap-series`, `nextmap-reset`/`rust-nextmap-reset`, and `event-construct`/`rust-event-construct`. Invoke `cargo xtask test-group <name>` before each task commit. The scoped transition adapter covers each word-level contract; Rust groups also run scoped gameplay tests and refresh their test-count metadata. The registry regression verifies source-report edges, transition module consumers and the shared mode-classifier dependency. Continue one full suite after ten commits. [Batch contracts and boundaries](research/QVM_CAMERA_MAP_EVENT_BATCH.md).

docs/research/QVM_CAMERA_MAP_EVENT_BATCH.md

@@ -0,0 +1,44 @@
+# Camera, next-map and event construction: RE-844–853
+
+Five original source contracts now have matching Rust ports. This batch recovers concrete world-record mutations and ordered intentions; complete runtime, renderer and native side-effect parity remain open.
+
+| Task | Evidence |
+| --- | --- |
+| RE-844 | [6575 intermission camera placement](QVM_CAMERA_PLACE.md) |
+| RE-845 | [Rust camera placement](RUST_CAMERA_PLACE.md) |
+| RE-846 | [6717 camera selection and target direction](QVM_CAMERA_SELECT.md) |
+| RE-847 | [Rust view selection](RUST_CAMERA_SELECT.md) |
+| RE-848 | [6939 team-series branch](QVM_NEXTMAP_SERIES.md) |
+| RE-849 | [Rust series policy](RUST_NEXTMAP_SERIES.md) |
+| RE-850 | [6939 normal reset suffix](QVM_NEXTMAP_RESET.md) |
+| RE-851 | [Rust staged normal reset](RUST_NEXTMAP_RESET.md) |
+| RE-852 | [277695 temporary event and 278138 origin setter](QVM_EVENT_CONSTRUCT.md) |
+| RE-853 | [Rust temporary event construction](RUST_EVENT_CONSTRUCT.md) |
+
+## Findings and evidence limits
+
+Camera placement has 72 coherent byte/word fixtures. It copies the camera position into entity and resolved-player origins, copies view angles, zeros velocity, sets movement type 5 and clears the observed entity/player fields. Both apparent mode/field 4324 gates reach the same body. Raw NaN payloads, infinities and signed zero copy exactly. Two distinct entity-to-client pointers exercise indirection; the Rust API accepts a resolved mutable client. This does not establish arbitrary pointer alias behavior or renderer integration.
+
+View selection has 36 fixtures covering absent selection, absent target key, failed target lookup and found target. Original source copies selected or supplied-fallback view vectors and computes f32 target-minus-origin. Rust returns ordered search/fallback/aim intentions and exact finite direction words. The selector results and fallback 168114 writes are supplied. The original 62944 angle converter is captured without modifying angles, so this is not complete aiming or camera setup.
+
+The series branch has 300 cases. It handles only positive phase and team-classified modes. A nonzero option requests restart unless both flag bits 2 and 4 are set. Otherwise it saves second then first score, clears active scores/pending/blocked/phase, removes those flags, and requests formatted configstrings 1005 and 2 plus downstream work. Actual 33715 mode classification executes. The original format strings are `%d` and `1 %i %i`; 70458 output is supplied as distinct pointers. The normal branch stops at 7070 in this report.
+
+The normal suffix has 48 cases. After captured 122230/7188 calls, it clears round/blocked/global scores and connected-client scores; mode 9 additionally clears fields 304/308. A snapshot at captured 249007 proves those changes happen before the second loop changes connected state 2 to 1. Pending, phase, series flags and saved scores remain untouched. Rust exposes separate preparation and post-map connection APIs so real map-child mutations can occur between stages. Fixture parity assumes those captured children do not mutate state.
+
+The temporary-event constructor has 144 valid cases and five invalid float-domain rejections. Actual 277695 and 278138 execute against a supplied allocator record. Origin components truncate through CVFI/CVIF, normalizing negative zero, and feed both trajectory base and current origin. The constructor zeros trajectory time/type/duration and velocity, writes wrapped kind + 19, the `tempEntity` class token/hash, clock 568 and free flag 572, then requests syscall−31. It preserves allocator flags 424 and caller-owned fields 84/140. This does not prove the real allocator supplies flags 16. Rust validates conversion before changing its record, then returns a link intention; invalid-domain atomic rejection is a deliberate safe boundary. Original class token 97191 is source metadata, not a portable native pointer.
+
+## Validation
+
+Each task used its focused cargo xtask group before its own commit; affected reports regenerated twice and relevant Python plus scoped gameplay Rust tests passed. Storage, documentation links and whitespace guards ran throughout. The registry regression verifies all five source-report-to-Rust edges, transition module selection and the shared intermission mode-classifier dependency. The single full-suite run after commit ten, `cargo xtask test-full --since 15d7fcac`, passed: 1,668 Python tests and 147 Rust tests (assets 10, gameplay 109, xtask 28). All 46 affected report producers regenerated twice deterministically. Storage policy, links across 414 documentation files and whitespace checks passed. No generated reports changed. Validation notes were amended into task ten.
+
+Use `cargo xtask test-group <name>` with `camera-place`, `rust-camera-place`, `camera-select`, `rust-camera-select`, `nextmap-series`, `rust-nextmap-series`, `nextmap-reset`, `rust-nextmap-reset`, `event-construct` or `rust-event-construct`.
+
+## Next work: RE-854
+
+- [ ] Recover actual 276433/276586 searches, 168114 fallback selection and 62944 direction-to-angle conversion.
+- [ ] Compose 6717 and 6575 into begin-intermission source/Rust flows, including client-pointer alias fixtures and actual camera/respawn state ownership.
+- [ ] Recover 122230/7188/249007 and 256248/256651 command/map effects, then compose complete 6939 into readiness and runtime handling.
+- [ ] Recover 277165 allocation/initialization, resolve class metadata portably and integrate 277695 with mode 9 caller fields and real linking/event lifetime.
+- [ ] Recover respawn 175123 and slow setup 156523, and execute publication 6328 with verified formatter/configstring/network ownership.
+- [ ] Integrate ranking→exit/intermission→camera/map/event→scoreboard state, compare real game/native traces, and continue legacy trace audits.
+- [ ] Validate actual macOS/Linux Bevy/Solari gameplay and rendering. These bounded Rust policies do not establish full-game completion.

docs/research/README.md

@@ -1150,3 +1150,8 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-852: Original temporary event construction and origin snapping](QVM_EVENT_CONSTRUCT.md).
+
+
+[RE-853: Rust temporary event construction and ownership boundaries](RUST_EVENT_CONSTRUCT.md).
+
+- [RE-844–853 camera, map and event batch evidence and next work](QVM_CAMERA_MAP_EVENT_BATCH.md).

docs/research/RUST_EVENT_CONSTRUCT.md

@@ -0,0 +1,7 @@
+# Rust temporary event construction and ownership boundaries
+
+RE-853. Reproduce with `python3 scripts/analyze_rust_event_construct.py`; focused validation: `cargo xtask test-group rust-event-construct`. [Machine report](rust-event-construct.json).
+
+Rust matches 144 original temporary-event cases, including exact snap words, event-kind wrapping, metadata and preservation of allocator/caller fields. Five invalid source domains reject atomically in Rust. Allocation and native linking remain caller-owned; source class tokens require runtime metadata resolution.
+
+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": 107,
+  "rust_unit_tests": 109,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_event_construct.py

@@ -0,0 +1,16 @@
+#!/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):
+ a=s['input'];return [*a['origin'],a['kind'],a['now'],a['flags']]
+def project(s):return {'fields':s['fields'],'link':s['requests'][-1]['target']==-31}
+def main():
+ b=binary();p=Path('docs/research/qvm-event-construct.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'event',encode(s))})
+ rejected=[]
+ for bad in json.loads(data)['rejections']:
+  r=invoke(b,'event',[*bad['origin'],69,1000,16],check=False);assert r.returncode!=0;rejected.append({'origin':bad['origin'],'exit_code':r.returncode,'error':r.stderr.strip()})
+ write_json(Path('docs/research/rust-event-construct.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'rejections':rejected,'limits':'Rust matches 144 original temporary-event cases, including exact snap words, event-kind wrapping, metadata and preservation of allocator/caller fields. Five invalid source domains reject atomically in Rust. Allocation and native linking remain caller-owned; source class tokens require runtime metadata resolution.'})
+if __name__=='__main__':main()

scripts/test_rust_event_construct.py

@@ -0,0 +1,11 @@
+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-event-construct.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'])
+  self.assertEqual(len(r['rejections']),5)
+  for p in r['rejections']:self.assertNotEqual(p['exit_code'],0);self.assertEqual(p['error'],'FloatDomain')
+ def test_source_identity(self):
+  r=json.loads(Path('docs/research/rust-event-construct.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

@@ -2320,3 +2320,16 @@ report	scripts/analyze_qvm_event_construct.py	docs/research/qvm-event-construct.
 edge	docs/research/qvm-event-construct.json	scripts/test_qvm_event_construct.py
 group	event-construct	scripts/analyze_qvm_event_construct.py
 edge	scripts/analyze_qvm_event_construct.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_event_construct.py
+edge	Cargo.lock	scripts/analyze_rust_event_construct.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_event_construct.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_event_construct.py
+edge	crates/urt-gameplay/src/transition.rs	scripts/analyze_rust_event_construct.py
+edge	crates/urt-gameplay/src/bin/urt-transition.rs	scripts/analyze_rust_event_construct.py
+edge	docs/research/qvm-event-construct.json	scripts/analyze_rust_event_construct.py
+group	rust-event-construct	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_event_construct.py
+report	scripts/analyze_rust_event_construct.py	docs/research/rust-event-construct.json
+edge	docs/research/rust-event-construct.json	scripts/test_rust_event_construct.py
+group	rust-event-construct	scripts/analyze_rust_event_construct.py
+edge	scripts/analyze_rust_event_construct.py	scripts/analyze_qvm_resumer_audit.py

xtask/src/lib.rs

@@ -1049,6 +1049,8 @@ mod integration_tests {
             ("exit_prefix", "exit_prefix"),
             ("exit_rules", "exit_class"),
             ("intermission", "intermission_flow"),
+            ("intermission", "nextmap_series"),
+            ("transition", "event_construct"),
             ("leaderboard", "leaderboard"),
             ("recipient_wire", "recipient_wire"),
         ] {
@@ -1109,6 +1111,11 @@ mod integration_tests {
             ("qvm-intermission-begin", "intermission_begin"),
             ("qvm-exit-log", "exit_log"),
             ("qvm-intermission-flow", "intermission_flow"),
+            ("qvm-camera-place", "camera_place"),
+            ("qvm-camera-select", "camera_select"),
+            ("qvm-nextmap-series", "nextmap_series"),
+            ("qvm-nextmap-reset", "nextmap_reset"),
+            ("qvm-event-construct", "event_construct"),
         ] {
             let selected = plan(
                 &g,