gameplay: integrate queried fallback spawn selection

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

@@ -305,6 +305,65 @@ fn run() -> Result<String, String> {
             }
         }
 
+        "queried-spawn" => {
+            if w.len() < 5 || w[4] > 1024 {
+                return Err("invalid spawn header".into());
+            }
+            let mut state = w[0];
+            let avoid = w[1..4].try_into().unwrap();
+            let n = w[4] as usize;
+            let mut p = 5;
+            let world = spawn_records(&w, &mut 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 profile = *w.get(p).ok_or("missing query profile")?;
+            p += 1;
+            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 spawn words".into());
+            }
+            let r = fallback_spawn_queried(
+                &world,
+                avoid,
+                &mut state,
+                &mut math,
+                SpawnQueryWorld {
+                    bounds,
+                    client_words: &client_words,
+                },
+                |j, b| {
+                    let indices = query_results(j, profile);
+                    queries.push(query_json(j, b, &indices));
+                    Ok(indices)
+                },
+            );
+            math.finish().map_err(|e| format!("{e:?}"))?;
+            let payload = match r {
+                Ok(r) => Ok(format!(
+                    "{{\"result\":{},\"rng_state\":{state},\"fatal\":false,\"candidates\":{},\"distances\":{},\"origin\":{},\"angles\":{}}}",
+                    r.index,
+                    array(&r.candidates.iter().map(|j| *j as u32).collect::<Vec<_>>()),
+                    array(&r.distances),
+                    array(&r.view.origin),
+                    array(&r.view.angles)
+                )),
+                Err(Error::NoSpawn) => Ok(format!(
+                    "{{\"result\":-1,\"rng_state\":{state},\"fatal\":true,\"candidates\":[],\"distances\":[],\"origin\":[305419896,305419896,305419896],\"angles\":[305419896,305419896,305419896]}}"
+                )),
+                Err(e) => Err(format!("{e:?}")),
+            }?;
+            Ok(format!(
+                "{{\"queries\":[{}],\"selection\":{payload}}}",
+                queries.join(",")
+            ))
+        }
+
         "spawn-camera" => {
             if w.len() < 9 || w[1] > 1 || w[2] > 1024 {
                 return Err("invalid camera header".into());
@@ -536,3 +595,28 @@ fn spawn_records(w: &[u32], p: &mut usize, n: usize) -> Result<Vec<SpawnEntity>,
     }
     Ok(c)
 }
+
+fn query_results(j: usize, profile: u32) -> Vec<usize> {
+    match profile {
+        0 => vec![],
+        1 => vec![900],
+        2 => vec![900, 901],
+        _ => {
+            if j % 2 == 1 {
+                vec![901]
+            } else {
+                vec![900, 900]
+            }
+        }
+    }
+}
+fn query_json(j: usize, b: urt_gameplay::native_policy::SpawnBox, indices: &[usize]) -> String {
+    format!(
+        "{{\"index\":{j},\"mins\":{},\"maxs\":{},\"capacity\":{},\"indices\":{},\"blocked\":{}}}",
+        array(&b.mins.map(f32::to_bits)),
+        array(&b.maxs.map(f32::to_bits)),
+        b.capacity,
+        array(&indices.iter().map(|v| *v as u32).collect::<Vec<_>>()),
+        u32::from(indices.contains(&901))
+    )
+}

crates/urt-gameplay/src/camera_world.rs

@@ -599,6 +599,20 @@ pub fn fallback_spawn<M: AngleMath>(
     avoid: [u32; 3],
     state: &mut u32,
     math: &mut M,
+) -> Result<SpawnSelection, Error> {
+    fallback_spawn_with_check(world, avoid, state, math, |_, e| Ok(e.blocked))
+}
+/// Run overlap checks only at the original class-filter boundary, interleaved
+/// with each accepted candidate's distance evaluation.
+pub fn fallback_spawn_with_check<
+    M: AngleMath,
+    F: FnMut(usize, &SpawnEntity) -> Result<bool, Error>,
+>(
+    world: &[SpawnEntity],
+    avoid: [u32; 3],
+    state: &mut u32,
+    math: &mut M,
+    mut blocked: F,
 ) -> Result<SpawnSelection, Error> {
     bounds(world.len(), world.len(), None)?;
     let mut ranked = vec![];
@@ -611,7 +625,7 @@ pub fn fallback_spawn<M: AngleMath>(
             continue;
         }
         first.get_or_insert(j);
-        if e.blocked {
+        if blocked(j, e)? {
             continue;
         }
         let mut d = [0f32; 3];
@@ -834,3 +848,107 @@ mod composed_spawn_tests {
         assert_eq!(state, 9);
     }
 }
+
+#[derive(Clone, Copy)]
+pub struct SpawnQueryWorld<'a> {
+    pub bounds: [[f32; 3]; 2],
+    pub client_words: &'a [u32],
+}
+fn overlap_check<F: FnMut(usize, crate::native_policy::SpawnBox) -> Result<Vec<usize>, Error>>(
+    j: usize,
+    e: &SpawnEntity,
+    scene: SpawnQueryWorld<'_>,
+    query: &mut F,
+) -> Result<bool, Error> {
+    let bounds = crate::native_policy::spawn_box(e.origin.map(f32::from_bits), scene.bounds)
+        .map_err(|_| Error::FloatDomain)?;
+    let results = query(j, bounds)?;
+    crate::native_policy::spawn_overlap(
+        &results,
+        i32::try_from(results.len()).map_err(|_| Error::InvalidCount)?,
+        scene.client_words,
+    )
+    .map_err(|_| Error::InvalidCount)
+}
+pub fn fallback_spawn_queried<
+    M: AngleMath,
+    F: FnMut(usize, crate::native_policy::SpawnBox) -> Result<Vec<usize>, Error>,
+>(
+    world: &[SpawnEntity],
+    avoid: [u32; 3],
+    state: &mut u32,
+    math: &mut M,
+    scene: SpawnQueryWorld<'_>,
+    mut query: F,
+) -> Result<SpawnSelection, Error> {
+    fallback_spawn_with_check(world, avoid, state, math, |j, e| {
+        overlap_check(j, e, scene, &mut query)
+    })
+}
+#[cfg(test)]
+mod query_spawn_tests {
+    use super::*;
+    #[test]
+    fn filtered_entities_do_not_query() {
+        let e = SpawnEntity {
+            class: HashEntity {
+                in_use: 0,
+                class_present: true,
+                class_hash: (-103258081i32) as u32,
+            },
+            blocked: false,
+            origin: [0; 3],
+            angles: [0; 3],
+        };
+        let mut state = 7;
+        let mut queried = false;
+        assert_eq!(
+            fallback_spawn_queried(
+                &[e],
+                [0; 3],
+                &mut state,
+                &mut HostMath,
+                SpawnQueryWorld {
+                    bounds: [[0.; 3]; 2],
+                    client_words: &[]
+                },
+                |_, _| {
+                    queried = true;
+                    Ok(vec![])
+                }
+            ),
+            Err(Error::NoSpawn)
+        );
+        assert!(!queried);
+        assert_eq!(state, 7);
+    }
+    #[test]
+    fn query_error_preserves_rng() {
+        let e = SpawnEntity {
+            class: HashEntity {
+                in_use: 1,
+                class_present: true,
+                class_hash: (-103258081i32) as u32,
+            },
+            blocked: false,
+            origin: [0; 3],
+            angles: [0; 3],
+        };
+        let mut state = 7;
+        assert_eq!(
+            fallback_spawn_queried(
+                &[e],
+                [0; 3],
+                &mut state,
+                &mut HostMath,
+                SpawnQueryWorld {
+                    bounds: [[0.; 3]; 2],
+                    client_words: &[]
+                },
+                |_, _| Ok(vec![0])
+            ),
+            Err(Error::InvalidCount)
+        );
+        assert_eq!(state, 7);
+    }
+}

docs/FINDINGS.md

@@ -1652,3 +1652,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-884:** 64 actual168114/167638 compositions replace supplied telefrag booleans with original query/filter execution. Native -33 spatial result lists are supplied, including empty/nonclient/blocked/mixed/duplicate results. Class filtering determines query order; accepted candidates then consume modeled sqrt before RNG, preserving64-cap and all-blocked/no-spawn behavior. Native broadphase, math and runtime ownership remain open. [Evidence](research/QVM_QUERIED_SPAWN.md).
+
+
+**RE-885:** Rust matches64 original168114/167638 compositions and their ordered box query transcripts. The typed spatial-query callback runs only after class filtering and before each candidate distance. Existing boolean-based callers retain behavior. Query/domain errors preserve RNG; native broadphase/math and external callback effects remain open. [Evidence](research/RUST_QUERIED_SPAWN.md).

docs/PROVISIONAL_TODO.md

@@ -1683,3 +1683,6 @@ Next batch RE-884: integrate collision queries and recovered callbacks; recover
 
 
 RE-884: 64 actual168114/167638 compositions replace supplied telefrag booleans with original query/filter execution. Native -33 spatial result lists are supplied, including empty/nonclient/blocked/mixed/duplicate results. Class filtering determines query order; accepted candidates then consume modeled sqrt before RNG, preserving64-cap and all-blocked/no-spawn behavior. Native broadphase, math and runtime ownership remain open. Full runtime completion remains open. [Evidence](research/QVM_QUERIED_SPAWN.md).
+
+
+RE-885: Rust matches64 original168114/167638 compositions and their ordered box query transcripts. The typed spatial-query callback runs only after class filtering and before each candidate distance. Existing boolean-based callers retain behavior. Query/domain errors preserve RNG; native broadphase/math and external callback effects remain open. Full runtime completion remains open. [Evidence](research/RUST_QUERIED_SPAWN.md).

docs/RESEARCH_LEDGER.md

@@ -2130,3 +2130,8 @@ After the tenth commit, `cargo xtask test-full --since 40af75ff` passed with the
 ## 2026-10-28 — RE-884 Original fallback spawn with actual overlap queries
 
 64 actual168114/167638 compositions replace supplied telefrag booleans with original query/filter execution. Native -33 spatial result lists are supplied, including empty/nonclient/blocked/mixed/duplicate results. Class filtering determines query order; accepted candidates then consume modeled sqrt before RNG, preserving64-cap and all-blocked/no-spawn behavior. Native broadphase, math and runtime ownership remain open. Focused `cargo xtask test-group qvm-queried-spawn` passes (10 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-885 Rust queried fallback spawn policy
+
+Rust matches64 original168114/167638 compositions and their ordered box query transcripts. The typed spatial-query callback runs only after class filtering and before each candidate distance. Existing boolean-based callers retain behavior. Query/domain errors preserve RNG; native broadphase/math and external callback effects remain open. Focused `cargo xtask test-group rust-queried-spawn` passes (11 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

@@ -1720,3 +1720,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-884 Original fallback spawn with actual overlap queries ([evidence](research/QVM_QUERIED_SPAWN.md)).
+
+
+- [x] RE-885 Rust queried fallback spawn policy ([evidence](research/RUST_QUERIED_SPAWN.md)).

docs/research/README.md

@@ -1255,3 +1255,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-884: Original fallback spawn with actual overlap queries](QVM_QUERIED_SPAWN.md).
+
+
+[RE-885: Rust queried fallback spawn policy](RUST_QUERIED_SPAWN.md).

docs/research/RUST_QUERIED_SPAWN.md

@@ -0,0 +1,7 @@
+# Rust queried fallback spawn policy
+
+RE-885. Reproduce with `python3 scripts/analyze_rust_queried_spawn.py`; focused validation: `cargo xtask test-group rust-queried-spawn`. [Machine report](rust-queried-spawn.json).
+
+Rust matches64 original168114/167638 compositions and their ordered box query transcripts. The typed spatial-query callback runs only after class filtering and before each candidate distance. Existing boolean-based callers retain behavior. Query/domain errors preserve RNG; native broadphase/math and external callback effects 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": 140,
+  "rust_unit_tests": 142,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_queried_spawn.py

@@ -0,0 +1,19 @@
+#!/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 qvm_spawn_support import entities
+def encode(s):
+ a=s['input'];c=entities(a['count'],a['pattern']);out=[a['seed'],*a['avoid'],len(c)]
+ for e in c:out.extend([e['active'],e['name'],e['hash'],0,*e['origin'],*e['angles']])
+ out.extend([*a['bounds'],a['profile'],len(s['math'])])
+ for m in s['math']:out.extend([m['target'],m['arguments']['8'],0,m['result']])
+ return out
+def project(s):return {'selection':{k:s[k] for k in ['result','rng_state','fatal','candidates','distances','origin','angles']},'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-spawn.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'queried-spawn',encode(s))})
+ write_json(Path('docs/research/rust-queried-spawn.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust matches64 original168114/167638 compositions and their ordered box query transcripts. The typed spatial-query callback runs only after class filtering and before each candidate distance. Existing boolean-based callers retain behavior. Query/domain errors preserve RNG; native broadphase/math and external callback effects remain open.'})
+if __name__=='__main__':main()

scripts/test_rust_queried_spawn.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-spawn.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-spawn.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

@@ -2612,3 +2612,18 @@ edge	docs/research/qvm-queried-spawn.json	scripts/test_qvm_queried_spawn.py
 group	qvm-queried-spawn	scripts/analyze_qvm_queried_spawn.py
 edge	scripts/analyze_qvm_queried_spawn.py	scripts/analyze_qvm_resumer_audit.py
 edge	scripts/qvm_spawn_query_support.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_queried_spawn.py
+edge	Cargo.lock	scripts/analyze_rust_queried_spawn.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_queried_spawn.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_queried_spawn.py
+edge	crates/urt-gameplay/src/camera_world.rs	scripts/analyze_rust_queried_spawn.py
+edge	crates/urt-gameplay/src/bin/urt-camera-world.rs	scripts/analyze_rust_queried_spawn.py
+edge	docs/research/qvm-queried-spawn.json	scripts/analyze_rust_queried_spawn.py
+group	rust-queried-spawn	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_queried_spawn.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_queried_spawn.py
+group	rust-queried-spawn	scripts/analyze_rust_spawn_fallback.py
+report	scripts/analyze_rust_queried_spawn.py	docs/research/rust-queried-spawn.json
+edge	docs/research/rust-queried-spawn.json	scripts/test_rust_queried_spawn.py
+group	rust-queried-spawn	scripts/analyze_rust_queried_spawn.py
+edge	scripts/analyze_rust_queried_spawn.py	scripts/analyze_qvm_resumer_audit.py