gameplay: port ranking population scan

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

@@ -13,6 +13,19 @@ fn ranking_client(v: &[u32]) -> urt_gameplay::ranking::Client {
         awards: v[9] as i32,
     }
 }
+fn population_json(p: &urt_gameplay::ranking_population::Population) -> String {
+    format!(
+        "{{\"34992848\":{},\"34992852\":{},\"34992580\":{},\"34992584\":{},\"34992588\":{},\"34994928\":{},\"34997012\":{},\"34997016\":{}}}",
+        p.first[0],
+        p.first[1],
+        p.order.len(),
+        p.nonspectators,
+        p.playing,
+        p.humans,
+        p.team_humans[0],
+        p.team_humans[1]
+    )
+}
 fn main() {
     if let Err(e) = run() {
         eprintln!("{e}");
@@ -328,6 +341,31 @@ fn run() -> Result<(), String> {
                 second.cached_ping as u32
             );
         }
+        "rank-population" if !w.is_empty() && w[0] <= 64 => {
+            let n = w[0] as usize;
+            if w.len() != 1 + 11 * n {
+                return Err("invalid population words".into());
+            }
+            let slots: Vec<_> = w[1..]
+                .chunks_exact(11)
+                .map(|v| urt_gameplay::ranking_population::Slot {
+                    client: ranking_client(v),
+                    entity_flags: v[10],
+                    rank: 77,
+                })
+                .collect();
+            let p = urt_gameplay::ranking_population::collect(&slots)
+                .map_err(|e| format!("unsupported input: {e:?}"))?;
+            println!(
+                "{{\"order\":[{}],\"globals\":{}}}",
+                p.order
+                    .iter()
+                    .map(|v| v.to_string())
+                    .collect::<Vec<_>>()
+                    .join(","),
+                population_json(&p)
+            );
+        }
         "rank-compose" if w.len() >= 4 && w[3] <= 64 => {
             let n = w[3] as usize;
             if w.len() != 4 + 10 * n {

crates/urt-gameplay/src/lib.rs

@@ -159,3 +159,5 @@ pub mod score;
 pub mod stat_totals;
 
 pub mod rank_sort;
+
+pub mod ranking_population;

crates/urt-gameplay/src/ranking_population.rs

@@ -0,0 +1,115 @@
+//! QVM5864 collection before sorting. Entity bot flag affects human counts only.
+use crate::ranking::Client;
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Slot {
+    pub client: Client,
+    pub entity_flags: u32,
+    pub rank: u32,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Population {
+    pub order: Vec<usize>,
+    pub first: [i32; 2],
+    pub nonspectators: usize,
+    pub playing: usize,
+    pub humans: usize,
+    pub team_humans: [usize; 2],
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PopulationError {
+    TooManyClients,
+}
+/// Source scan order. Connecting clients are collected; spectators contribute
+/// only to connected count. First two playing slots can include bots.
+pub fn collect(slots: &[Slot]) -> Result<Population, PopulationError> {
+    if slots.len() > 64 {
+        return Err(PopulationError::TooManyClients);
+    }
+    let mut p = Population {
+        order: vec![],
+        first: [-1, -1],
+        nonspectators: 0,
+        playing: 0,
+        humans: 0,
+        team_humans: [0, 0],
+    };
+    for (id, s) in slots.iter().enumerate() {
+        let c = s.client;
+        if c.connection == 0 {
+            continue;
+        }
+        p.order.push(id);
+        if c.team == 3 {
+            continue;
+        }
+        p.nonspectators += 1;
+        if c.connection != 2 {
+            continue;
+        }
+        p.playing += 1;
+        if s.entity_flags & 8 == 0 {
+            p.humans += 1;
+            if c.team == 1 {
+                p.team_humans[0] += 1;
+            } else if c.team == 2 {
+                p.team_humans[1] += 1;
+            }
+        }
+        if p.first[0] == -1 {
+            p.first[0] = id as i32;
+        } else if p.first[1] == -1 {
+            p.first[1] = id as i32;
+        }
+    }
+    Ok(p)
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn slot(state: i32, team: i32, flags: u32) -> Slot {
+        Slot {
+            client: Client {
+                spectator_state: 0,
+                follow_index: 0,
+                connection: state,
+                team,
+                spectator_time: 0,
+                time: 0,
+                class: 0,
+                score: 0,
+                deaths: 0,
+                awards: 0,
+            },
+            entity_flags: flags,
+            rank: 77,
+        }
+    }
+    #[test]
+    fn bots_and_connecting_spectators_have_distinct_counts() {
+        let s = [
+            slot(2, 1, 8),
+            slot(1, 1, 0),
+            slot(2, 3, 0),
+            slot(0, 2, 0),
+            slot(2, 2, 0),
+        ];
+        let p = collect(&s).unwrap();
+        assert_eq!(p.order, [0, 1, 2, 4]);
+        assert_eq!(p.first, [0, 4]);
+        assert_eq!(
+            (p.nonspectators, p.playing, p.humans, p.team_humans),
+            (3, 2, 1, [0, 1])
+        );
+    }
+    #[test]
+    fn boundary_and_scan_local_reset() {
+        assert_eq!(collect(&[]).unwrap().first, [-1, -1]);
+        let s = vec![slot(2, 1, 0); 64];
+        assert_eq!(collect(&s).unwrap().playing, 64);
+        assert_eq!(
+            collect(&vec![slot(2, 1, 0); 65]),
+            Err(PopulationError::TooManyClients)
+        );
+        assert_eq!(collect(&[]).unwrap().order, []);
+    }
+}

docs/FINDINGS.md

@@ -1385,3 +1385,6 @@ RE-780–789 exposes and bounds legacy resumer timing/byte-state flaws, migrates
 
 
 **RE-795:** Rust composes recovered source sorting and rank writes, matching exact order and tied/team rank words for128 full caller fixtures. [Evidence](research/RUST_RANKING_COMPLETE.md).
+
+
+**RE-796:** Rust reproduces source collection, first-playing identifiers and bot/team counters across185 setup and complete caller fixtures. [Evidence](research/RUST_RANKING_POPULATION.md).

docs/PROVISIONAL_TODO.md

@@ -1389,3 +1389,6 @@ RE-794: Rust now executes the recovered insertion/partition/median/ninther sort
 
 
 RE-795: Rust composes recovered source sorting and rank writes, matching exact order and tied/team rank words for128 full caller fixtures. Full runtime completion remains open. [Evidence](research/RUST_RANKING_COMPLETE.md).
+
+
+RE-796: Rust reproduces source collection, first-playing identifiers and bot/team counters across185 setup and complete caller fixtures. Full runtime completion remains open. [Evidence](research/RUST_RANKING_POPULATION.md).

docs/RESEARCH_LEDGER.md

@@ -1639,3 +1639,8 @@ Rust now executes the recovered insertion/partition/median/ninther sort without
 ## 2026-10-26 — RE-795 Rust eligible ranking composition through64 clients
 
 Rust composes recovered source sorting and rank writes, matching exact order and tied/team rank words for128 full caller fixtures. Focused `cargo xtask test-group rust-ranking-complete` 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.
+
+
+## 2026-10-26 — RE-796 Rust ranking population collection and all eight count globals
+
+Rust reproduces source collection, first-playing identifiers and bot/team counters across185 setup and complete caller fixtures. Focused `cargo xtask test-group rust-ranking-population` 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

@@ -1435,3 +1435,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-795 Rust eligible ranking composition through64 clients ([evidence](research/RUST_RANKING_COMPLETE.md)).
+
+
+- [x] RE-796 Rust ranking population collection and all eight count globals ([evidence](research/RUST_RANKING_POPULATION.md)).

docs/research/README.md

@@ -975,3 +975,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-795: Rust eligible ranking composition through64 clients](RUST_RANKING_COMPLETE.md).
+
+
+[RE-796: Rust ranking population collection and all eight count globals](RUST_RANKING_POPULATION.md).

docs/research/RUST_RANKING_POPULATION.md

@@ -0,0 +1,7 @@
+# Rust ranking population collection and all eight count globals
+
+RE-796. Reproduce with `python3 scripts/analyze_rust_ranking_population.py`; focused validation: `cargo xtask test-group rust-ranking-population`. [Machine report](rust-ranking-population.json).
+
+A semantic Slot/Population API models the source scan without engine addresses. The research CLI maps its fields back to all eight observed globals. Independent tests cover connection/team gates, scan membership, bots in the first-playing slots, reset behavior, empty populations and64/65 boundaries. The original negative count case is represented by an empty Rust slice, with no unsafe ABI/count claim. Sorting and publication remain separate.
+
+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": 58,
+  "rust_unit_tests": 60,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_ranking_population.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+import hashlib,json
+from pathlib import Path
+from analyze_rust_ranking import words
+from rust_lifecycle_support import binary,result,invoke
+from analyze_qvm import write_json
+
+def main():
+    b=binary();rows=[];sources={}
+    for name in ['qvm-ranking-setup','qvm-ranking-large-caller','qvm-ranking-population']:
+        p=Path('docs/research/'+name+'.json');data=p.read_bytes();sources[str(p)]=hashlib.sha256(data).hexdigest()
+        for row in json.loads(data)['probes']:
+            c=row['input']['clients']
+            if name=='qvm-ranking-setup':c=[{'468':v['state'],'3096':v['team'],'flags':v['flags']} for v in c]
+            r=result(b,'rank-population',[len(c),*[v for client in c for v in [*words(client),client.get('flags',0)]]]);rows.append({'clients':c,'source_globals':row['globals'],'rust':r})
+    bad=invoke(b,'rank-population',[65],check=False);assert bad.returncode
+    write_json(Path('docs/research/rust-ranking-population.json'),{'source_reports':sources,'probes':rows,'rejections':[bad.returncode],'limits':'Rust5864 collection matches185 setup/full source fixtures. Source negative count fixture represented as an empty safe Rust slice; no raw pointer/count ABI claim. All count globals and scan order checked independently; no sorting/publication here.'})
+if __name__=='__main__':main()

scripts/test_rust_ranking_population.py

@@ -0,0 +1,12 @@
+import hashlib,json,unittest
+from pathlib import Path
+from test_qvm_ranking_population import globals_for
+class RustPopulationTests(unittest.TestCase):
+    def test_source_globals_and_independent_membership(self):
+        r=json.loads(Path('docs/research/rust-ranking-population.json').read_text());self.assertEqual(len(r['probes']),185)
+        for p in r['probes']:c=p['clients'];self.assertEqual(p['rust']['globals'],p['source_globals']);self.assertEqual(p['rust']['globals'],globals_for(c));self.assertEqual(p['rust']['order'],[j for j,v in enumerate(c) if v.get('468',2)!=0])
+    def test_identity_and_limit(self):
+        r=json.loads(Path('docs/research/rust-ranking-population.json').read_text())
+        for p,h in r['source_reports'].items():self.assertEqual(hashlib.sha256(Path(p).read_bytes()).hexdigest(),h)
+        self.assertTrue(all(r['rejections']))
+if __name__=='__main__':unittest.main()

xtask/checks.tsv

@@ -1820,3 +1820,16 @@ report	scripts/analyze_rust_ranking_complete.py	docs/research/rust-ranking-compl
 edge	docs/research/rust-ranking-complete.json	scripts/test_rust_ranking_complete.py
 group	rust-ranking-complete	scripts/analyze_rust_ranking_complete.py
 edge	scripts/analyze_rust_ranking_complete.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_ranking_population.py
+edge	Cargo.lock	scripts/analyze_rust_ranking_population.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_ranking_population.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_ranking_population.py
+edge	crates/urt-gameplay/src/bin/urt-lifecycle.rs	scripts/analyze_rust_ranking_population.py
+edge	crates/urt-gameplay/src/ranking_population.rs	scripts/analyze_rust_ranking_population.py
+edge	crates/urt-gameplay/src/ranking_population.rs	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_ranking_population.py
+group	rust-ranking-population	scripts/analyze_rust_health_impulse.py
+report	scripts/analyze_rust_ranking_population.py	docs/research/rust-ranking-population.json
+edge	docs/research/rust-ranking-population.json	scripts/test_rust_ranking_population.py
+group	rust-ranking-population	scripts/analyze_rust_ranking_population.py
+edge	scripts/analyze_rust_ranking_population.py	scripts/analyze_qvm_resumer_audit.py

xtask/src/lib.rs

@@ -1042,6 +1042,7 @@ mod integration_tests {
             ("recipient_payload", "recipient_payload"),
             ("ranking", "ranking"),
             ("rank_sort", "rank_sort"),
+            ("ranking_population", "ranking_population"),
             ("leaderboard", "leaderboard"),
             ("recipient_wire", "recipient_wire"),
         ] {