gameplay: integrate lazy camera collision queries

crates/urt-gameplay/src/bin/urt-camera-world.rs

@@ -503,6 +503,165 @@ fn run() -> Result<String, String> {
                 array(&out.view.angles)
             ))
         }
+        "queried-camera" => {
+            if w.len() < 9 || w[1] > 1 || w[2] > 1024 {
+                return Err("invalid camera header".into());
+            }
+            let mut state = w[0];
+            let slot = w[1] as usize;
+            let n = w[2] as usize;
+            let _fallback = urt_gameplay::transition::View {
+                origin: w[3..6].try_into().unwrap(),
+                angles: w[6..9].try_into().unwrap(),
+            };
+            let mut p = 9;
+            let mut world = vec![];
+            for _ in 0..n {
+                let v = w.get(p..p + 9).ok_or("missing world record")?;
+                p += 9;
+                let class = HashEntity {
+                    in_use: v[0] as i32,
+                    class_present: v[1] != 0,
+                    class_hash: v[2],
+                };
+                let origin = v[3..6].try_into().unwrap();
+                let angles = v[6..9].try_into().unwrap();
+                let aim = blob(&w, &mut p)?;
+                let label = blob(&w, &mut p)?;
+                world.push(WorldEntity {
+                    class,
+                    origin,
+                    angles,
+                    aim,
+                    label,
+                });
+            }
+            let blocked = w
+                .get(p..p + n)
+                .ok_or("missing telefrag flags")?
+                .iter()
+                .map(|v| *v != 0)
+                .collect::<Vec<_>>();
+            p += n;
+            let bound_words = w.get(p..p + 6).ok_or("missing query bounds")?;
+            p += 6;
+            let bounds = std::array::from_fn(|h| {
+                std::array::from_fn(|j| f32::from_bits(bound_words[h * 3 + j]))
+            });
+            let mut queries = vec![];
+            let mut client_words = vec![0; 1024];
+            client_words[901] = u32::MAX;
+            let mut math = math_calls(&w, &mut p)?;
+            if p != w.len() {
+                return Err("trailing camera words".into());
+            }
+            let mut entity = urt_gameplay::transition::CameraEntity {
+                origin: [0x12345678; 3],
+                clear: [0x12345678; 6],
+            };
+            let blank = urt_gameplay::transition::CameraPlayer {
+                movement: 0xaabbccdd,
+                origin: [0xaabbccdd; 3],
+                velocity: [0xaabbccdd; 3],
+                field104: 0xaabbccdd,
+                angles: [0xaabbccdd; 3],
+                mode3108: 0xaabbccdd,
+                field4324: 0xaabbccdd,
+            };
+            let mut clients = [blank.clone(), blank];
+            let (out, spawn) = configure_camera_queried(
+                &world,
+                &mut state,
+                &mut math,
+                &mut entity,
+                &mut clients[slot],
+                SpawnQueryWorld {
+                    bounds,
+                    client_words: &client_words,
+                },
+                |j, b| {
+                    let indices = query_results(j, if blocked[j] { 2 } else { 0 });
+                    queries.push(query_json(j, b, &indices));
+                    Ok(indices)
+                },
+            )
+            .map_err(|e| format!("{e:?}"))?;
+            math.finish().map_err(|e| format!("{e:?}"))?;
+            let e = word_object(
+                &[4, 8, 92, 96, 100, 156, 160, 180, 460],
+                &[
+                    entity.clear[0],
+                    entity.clear[1],
+                    entity.origin[0],
+                    entity.origin[1],
+                    entity.origin[2],
+                    entity.clear[2],
+                    entity.clear[3],
+                    entity.clear[4],
+                    entity.clear[5],
+                ],
+            );
+            let clients = clients
+                .iter()
+                .map(|p| {
+                    word_object(
+                        &[4, 20, 24, 28, 32, 36, 40, 104, 152, 156, 160, 3108, 4324],
+                        &[
+                            p.movement,
+                            p.origin[0],
+                            p.origin[1],
+                            p.origin[2],
+                            p.velocity[0],
+                            p.velocity[1],
+                            p.velocity[2],
+                            p.field104,
+                            p.angles[0],
+                            p.angles[1],
+                            p.angles[2],
+                            p.mode3108,
+                            p.field4324,
+                        ],
+                    )
+                })
+                .collect::<Vec<_>>()
+                .join(",");
+            let effects = out
+                .effects
+                .iter()
+                .map(|e| match e {
+                    CameraEffect::FindClass => 276433,
+                    CameraEffect::Fallback => 168114,
+                    CameraEffect::PickTarget => 276586,
+                    CameraEffect::Angles => 62944,
+                })
+                .collect::<Vec<_>>();
+            let matches = out.matches.iter().map(|j| *j as u32).collect::<Vec<_>>();
+            let diagnostic = match out.diagnostic {
+                None => "null",
+                Some(TargetDiagnostic::Null) => "\"null\"",
+                Some(TargetDiagnostic::Missing) => "\"missing\"",
+            };
+            let spawn_index = spawn.as_ref().map(|v| v.index as i32).unwrap_or(-1);
+            let spawn_candidates = array(
+                &spawn
+                    .as_ref()
+                    .map(|v| v.candidates.iter().map(|j| *j as u32).collect::<Vec<_>>())
+                    .unwrap_or_default(),
+            );
+            let payload = format!(
+                "{{\"spawn_index\":{spawn_index},\"spawn_candidates\":{spawn_candidates},\"class_index\":{},\"target_index\":{},\"rng_state\":{state},\"matches\":{},\"diagnostic\":{diagnostic},\"effects\":{},\"view\":{{\"origin\":{},\"angles\":{}}},\"entity\":{e},\"clients\":[{clients}]}}",
+                out.class_index.map(|j| j as i32).unwrap_or(-1),
+                out.target_index.map(|j| j as i32).unwrap_or(-1),
+                array(&matches),
+                array(&effects),
+                array(&out.view.origin),
+                array(&out.view.angles)
+            );
+            Ok(format!(
+                "{{\"camera\":{payload},\"queries\":[{}]}}",
+                queries.join(",")
+            ))
+        }
         _ => Err("unknown command".into()),
     }
 }

crates/urt-gameplay/src/camera_world.rs

@@ -737,6 +737,19 @@ pub fn configure_camera_with_spawns<M: AngleMath>(
     if blocked.len() != world.len() {
         return Err(Error::InvalidCount);
     }
+    configure_camera_with_spawn_check(world, state, math, entity, player, |j, _| Ok(blocked[j]))
+}
+pub fn configure_camera_with_spawn_check<
+    M: AngleMath,
+    F: FnMut(usize, &SpawnEntity) -> Result<bool, Error>,
+>(
+    world: &[WorldEntity],
+    state: &mut u32,
+    math: &mut M,
+    entity: &mut crate::transition::CameraEntity,
+    player: &mut crate::transition::CameraPlayer,
+    mut check: F,
+) -> Result<(CameraResolution, Option<SpawnSelection>), Error> {
     let classes = world.iter().map(|e| e.class).collect::<Vec<_>>();
     if find_class(&classes, world.len(), None, (-2104846030i32) as u32)?.is_some() {
         return Ok((
@@ -756,15 +769,14 @@ pub fn configure_camera_with_spawns<M: AngleMath>(
     }
     let spawns = world
         .iter()
-        .zip(blocked)
-        .map(|(e, b)| SpawnEntity {
+        .map(|e| SpawnEntity {
             class: e.class,
-            blocked: *b,
+            blocked: false,
             origin: e.origin,
             angles: e.angles,
         })
         .collect::<Vec<_>>();
-    let selected = fallback_spawn(&spawns, [0; 3], state, math)?;
+    let selected = fallback_spawn_with_check(&spawns, [0; 3], state, math, &mut check)?;
     let camera = CameraResolution {
         class_index: None,
         target_index: None,
@@ -952,3 +964,73 @@ mod query_spawn_tests {
         assert_eq!(state, 7);
     }
 }
+
+pub fn configure_camera_queried<
+    M: AngleMath,
+    F: FnMut(usize, crate::native_policy::SpawnBox) -> Result<Vec<usize>, Error>,
+>(
+    world: &[WorldEntity],
+    state: &mut u32,
+    math: &mut M,
+    entity: &mut crate::transition::CameraEntity,
+    player: &mut crate::transition::CameraPlayer,
+    scene: SpawnQueryWorld<'_>,
+    mut query: F,
+) -> Result<(CameraResolution, Option<SpawnSelection>), Error> {
+    configure_camera_with_spawn_check(world, state, math, entity, player, |j, e| {
+        overlap_check(j, e, scene, &mut query)
+    })
+}
+#[cfg(test)]
+mod queried_camera_tests {
+    use super::*;
+    #[test]
+    fn primary_camera_never_queries() {
+        let world = [WorldEntity {
+            class: HashEntity {
+                in_use: 1,
+                class_present: true,
+                class_hash: (-2104846030i32) as u32,
+            },
+            origin: [0; 3],
+            angles: [0; 3],
+            aim: None,
+            label: None,
+        }];
+        let mut rng = 7;
+        let mut e = crate::transition::CameraEntity {
+            origin: [8; 3],
+            clear: [9; 6],
+        };
+        let mut p = crate::transition::CameraPlayer {
+            movement: 7,
+            origin: [7; 3],
+            velocity: [7; 3],
+            field104: 7,
+            angles: [7; 3],
+            mode3108: 7,
+            field4324: 7,
+        };
+        let mut called = false;
+        let (_, spawn) = configure_camera_queried(
+            &world,
+            &mut rng,
+            &mut HostMath,
+            &mut e,
+            &mut p,
+            SpawnQueryWorld {
+                bounds: [[f32::NAN; 3]; 2],
+                client_words: &[],
+            },
+            |_, _| {
+                called = true;
+                Err(Error::InvalidCount)
+            },
+        )
+        .unwrap();
+        assert!(!called);
+        assert!(spawn.is_none());
+        assert_eq!(rng, 7);
+        assert_eq!(e.origin, [0; 3]);
+    }
+}

docs/FINDINGS.md

@@ -1658,3 +1658,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-886:** 128 coherent6717/168114/167638/6575 cases execute box construction and client filtering inside camera fallback. Existing primary cameras issue no spatial queries; fallback class matches issue ordered native -33 requests. Result/view/player fields and checked math match the prior boolean-boundary fixtures. Native broadphase and math remain supplied; respawn and complete intermission/runtime remain open. [Evidence](research/QVM_QUERIED_CAMERA.md).
+
+
+**RE-887:** Rust matches128 original continuous camera/queried-fallback/placement cases, including exact query order and primary-camera bypass. Spatial callbacks use the same recovered box/filter policy as standalone fallback. Existing camera/spawn APIs retain their contracts; native broadphase/math and complete respawn/intermission remain open. [Evidence](research/RUST_QUERIED_CAMERA.md).

docs/PROVISIONAL_TODO.md

@@ -1689,3 +1689,6 @@ RE-885: Rust matches64 original168114/167638 compositions and their ordered box
 
 
 RE-886: 128 coherent6717/168114/167638/6575 cases execute box construction and client filtering inside camera fallback. Existing primary cameras issue no spatial queries; fallback class matches issue ordered native -33 requests. Result/view/player fields and checked math match the prior boolean-boundary fixtures. Native broadphase and math remain supplied; respawn and complete intermission/runtime remain open. Full runtime completion remains open. [Evidence](research/QVM_QUERIED_CAMERA.md).
+
+
+RE-887: Rust matches128 original continuous camera/queried-fallback/placement cases, including exact query order and primary-camera bypass. Spatial callbacks use the same recovered box/filter policy as standalone fallback. Existing camera/spawn APIs retain their contracts; native broadphase/math and complete respawn/intermission remain open. Full runtime completion remains open. [Evidence](research/RUST_QUERIED_CAMERA.md).

docs/RESEARCH_LEDGER.md

@@ -2140,3 +2140,8 @@ Rust matches64 original168114/167638 compositions and their ordered box query tr
 ## 2026-10-28 — RE-886 Original camera placement with queried fallback
 
 128 coherent6717/168114/167638/6575 cases execute box construction and client filtering inside camera fallback. Existing primary cameras issue no spatial queries; fallback class matches issue ordered native -33 requests. Result/view/player fields and checked math match the prior boolean-boundary fixtures. Native broadphase and math remain supplied; respawn and complete intermission/runtime remain open. Focused `cargo xtask test-group qvm-queried-camera` 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-887 Rust camera with lazy spatial queries
+
+Rust matches128 original continuous camera/queried-fallback/placement cases, including exact query order and primary-camera bypass. Spatial callbacks use the same recovered box/filter policy as standalone fallback. Existing camera/spawn APIs retain their contracts; native broadphase/math and complete respawn/intermission remain open. Focused `cargo xtask test-group rust-queried-camera` passes (13 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

@@ -1726,3 +1726,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-886 Original camera placement with queried fallback ([evidence](research/QVM_QUERIED_CAMERA.md)).
+
+
+- [x] RE-887 Rust camera with lazy spatial queries ([evidence](research/RUST_QUERIED_CAMERA.md)).

docs/research/README.md

@@ -1261,3 +1261,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-886: Original camera placement with queried fallback](QVM_QUERIED_CAMERA.md).
+
+
+[RE-887: Rust camera with lazy spatial queries](RUST_QUERIED_CAMERA.md).

docs/research/RUST_QUERIED_CAMERA.md

@@ -0,0 +1,7 @@
+# Rust camera with lazy spatial queries
+
+RE-887. Reproduce with `python3 scripts/analyze_rust_queried_camera.py`; focused validation: `cargo xtask test-group rust-queried-camera`. [Machine report](rust-queried-camera.json).
+
+Rust matches128 original continuous camera/queried-fallback/placement cases, including exact query order and primary-camera bypass. Spatial callbacks use the same recovered box/filter policy as standalone fallback. Existing camera/spawn APIs retain their contracts; native broadphase/math and complete respawn/intermission 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": 142,
+  "rust_unit_tests": 143,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_queried_camera.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+import hashlib,json
+from pathlib import Path
+from rust_camera_world_support import binary,result,invoke
+from analyze_qvm import write_json
+from analyze_rust_camera_spawn import encode as old_encode,project as old_project
+def encode(s):
+ out=old_encode(s);pos=len(out)-1-4*len(s['math']);out[pos:pos]=s['bounds'];return out
+def project(s):return {'camera':old_project(s),'queries':[{k:v for k,v in q.items() if k!='trace_sha256'} for q in s['queries']]}
+
+def main():
+ b=binary();p=Path('docs/research/qvm-queried-camera.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'queried-camera',encode(s))})
+ write_json(Path('docs/research/rust-queried-camera.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust matches128 original continuous camera/queried-fallback/placement cases, including exact query order and primary-camera bypass. Spatial callbacks use the same recovered box/filter policy as standalone fallback. Existing camera/spawn APIs retain their contracts; native broadphase/math and complete respawn/intermission remain open.'})
+if __name__=='__main__':main()

scripts/test_rust_queried_camera.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-queried-camera.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-queried-camera.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

@@ -2632,3 +2632,19 @@ report	scripts/analyze_qvm_queried_camera.py	docs/research/qvm-queried-camera.js
 edge	docs/research/qvm-queried-camera.json	scripts/test_qvm_queried_camera.py
 group	qvm-queried-camera	scripts/analyze_qvm_queried_camera.py
 edge	scripts/analyze_qvm_queried_camera.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_queried_camera.py
+edge	Cargo.lock	scripts/analyze_rust_queried_camera.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_queried_camera.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_queried_camera.py
+edge	crates/urt-gameplay/src/camera_world.rs	scripts/analyze_rust_queried_camera.py
+edge	crates/urt-gameplay/src/bin/urt-camera-world.rs	scripts/analyze_rust_queried_camera.py
+edge	docs/research/qvm-queried-camera.json	scripts/analyze_rust_queried_camera.py
+group	rust-queried-camera	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_queried_camera.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_queried_camera.py
+group	rust-queried-camera	scripts/analyze_rust_camera_spawn.py
+group	rust-queried-camera	scripts/analyze_rust_camera_world.py
+report	scripts/analyze_rust_queried_camera.py	docs/research/rust-queried-camera.json
+edge	docs/research/rust-queried-camera.json	scripts/test_rust_queried_camera.py
+group	rust-queried-camera	scripts/analyze_rust_queried_camera.py
+edge	scripts/analyze_rust_queried_camera.py	scripts/analyze_qvm_resumer_audit.py