gameplay: compose eligible ranking

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

@@ -328,6 +328,29 @@ fn run() -> Result<(), String> {
                 second.cached_ping as u32
             );
         }
+        "rank-compose" if w.len() >= 4 && w[3] <= 64 => {
+            let n = w[3] as usize;
+            if w.len() != 4 + 10 * n {
+                return Err("invalid composed ranking words".into());
+            }
+            let clients: Vec<_> = w[4..].chunks_exact(10).map(ranking_client).collect();
+            let (order, ranks) =
+                urt_gameplay::ranking::ranked(w[0] as i32, &clients, [w[1] as i32, w[2] as i32])
+                    .map_err(|e| format!("unsupported input: {e:?}"))?;
+            println!(
+                "{{\"order\":[{}],\"ranks\":[{}]}}",
+                order
+                    .iter()
+                    .map(|v| v.to_string())
+                    .collect::<Vec<_>>()
+                    .join(","),
+                ranks
+                    .iter()
+                    .map(|v| v.to_string())
+                    .collect::<Vec<_>>()
+                    .join(",")
+            );
+        }
         "rank-sort" if w.len() >= 2 && w[1] <= 64 => {
             let n = w[1] as usize;
             if w.len() != 2 + 11 * n {
@@ -363,7 +386,7 @@ fn run() -> Result<(), String> {
                 urt_gameplay::ranking::compare(w[0] as i32, client(&w[1..11]), client(&w[11..]))
             );
         }
-        "rank-words" if w.len() >= 4 && w[3] <= 6 => {
+        "rank-words" if w.len() >= 4 && w[3] <= 64 => {
             let n = w[3] as usize;
             if w.len() != 4 + 11 * n {
                 return Err("invalid ranking words".into());

crates/urt-gameplay/src/ranking.rs

@@ -74,7 +74,7 @@ pub enum RankError {
     InvalidOrder,
 }
 /// Caller supplies a complete ordering. This primitive does not execute a sort
-/// or publication callbacks. Source parity fixtures use eligible n<7 clients.
+/// or publication callbacks. Source parity fixtures include eligible populations through64 clients.
 pub fn rank_words(
     mode: i32,
     clients: &[Client],
@@ -132,6 +132,18 @@ pub fn rank_words(
     }
     Ok(result)
 }
+/// Complete eligible-client sorting and rank-word composition. Publication
+/// callbacks and runtime/global ownership remain the caller's responsibility.
+pub fn ranked(
+    mode: i32,
+    clients: &[Client],
+    scores: [i32; 2],
+) -> Result<(Vec<usize>, Vec<u32>), RankError> {
+    let mut order: Vec<_> = (0..clients.len()).collect();
+    crate::rank_sort::sort(mode, clients, &mut order)?;
+    let ranks = rank_words(mode, clients, &order, scores)?;
+    Ok((order, ranks))
+}
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -150,6 +162,24 @@ mod tests {
         }
     }
     #[test]
+    fn composed_rank_sort_handles64_and_global_team_result() {
+        let c: Vec<_> = (0..64)
+            .map(|j| Client {
+                score: j % 2,
+                ..client()
+            })
+            .collect();
+        let (order, ranks) = ranked(0, &c, [0, 0]).unwrap();
+        assert!(order[..32].iter().all(|j| j % 2 == 1));
+        assert!(
+            ranks
+                .iter()
+                .enumerate()
+                .all(|(j, &v)| v == if j % 2 == 1 { 16384 } else { 16384 | 32 })
+        );
+        assert_eq!(ranked(3, &c, [1, 2]).unwrap().1, vec![1; 64]);
+    }
+    #[test]
     fn raw_prefilter_quirks_remain_nonordering() {
         let c = Client {
             spectator_state: 3,

docs/FINDINGS.md

@@ -1382,3 +1382,6 @@ RE-780–789 exposes and bounds legacy resumer timing/byte-state flaws, migrates
 
 
 **RE-794:** Rust now executes the recovered insertion/partition/median/ninther sort without assuming comparator Ord; source parity includes unstable tie permutations. [Evidence](research/RUST_RANK_SORT.md).
+
+
+**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).

docs/PROVISIONAL_TODO.md

@@ -1386,3 +1386,6 @@ RE-793: Ranking count globals follow connection/team/bot gates, but deferred rec
 
 
 RE-794: Rust now executes the recovered insertion/partition/median/ninther sort without assuming comparator Ord; source parity includes unstable tie permutations. Full runtime completion remains open. [Evidence](research/RUST_RANK_SORT.md).
+
+
+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).

docs/RESEARCH_LEDGER.md

@@ -1634,3 +1634,8 @@ Ranking count globals follow connection/team/bot gates, but deferred records can
 ## 2026-10-26 — RE-794 Rust source-shaped aligned ranking sort with exact tie order
 
 Rust now executes the recovered insertion/partition/median/ninther sort without assuming comparator Ord; source parity includes unstable tie permutations. Focused `cargo xtask test-group rust-rank-sort` 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-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.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1432,3 +1432,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-794 Rust source-shaped aligned ranking sort with exact tie order ([evidence](research/RUST_RANK_SORT.md)).
+
+
+- [x] RE-795 Rust eligible ranking composition through64 clients ([evidence](research/RUST_RANKING_COMPLETE.md)).

docs/research/README.md

@@ -972,3 +972,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-794: Rust source-shaped aligned ranking sort with exact tie order](RUST_RANK_SORT.md).
+
+
+[RE-795: Rust eligible ranking composition through64 clients](RUST_RANKING_COMPLETE.md).

docs/research/RUST_RANKING_COMPLETE.md

@@ -0,0 +1,7 @@
+# Rust eligible ranking composition through64 clients
+
+RE-795. Reproduce with `python3 scripts/analyze_rust_ranking_complete.py`; focused validation: `cargo xtask test-group rust-ranking-complete`. [Machine report](rust-ranking-complete.json).
+
+The public ranked function owns sorting rather than requiring a precomputed order. Source parity covers both earlier48 small and80 larger caller fixtures, including zero participants, partial ties, all team-score outcomes and mode-specific keys. A64-client unit test independently checks tied ranks and team results. The CLI rank-word primitive accepts the now-verified larger eligible domain. Mixed-population collection and publication/native side effects remain separate contracts.
+
+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": 57,
+  "rust_unit_tests": 58,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_ranking_complete.py

@@ -0,0 +1,16 @@
+#!/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-complete','qvm-ranking-large-caller']:
+        p=Path('docs/research/'+name+'.json');data=p.read_bytes();sources[str(p)]=hashlib.sha256(data).hexdigest()
+        for row in json.loads(data)['probes']:
+            a=row['input'];c=a['clients'];rows.append({'input':a,'source_order':row['order'],'source_ranks':row['ranks'],'rust':result(b,'rank-compose',[a['mode'],*a['team_scores'],len(c),*[v for client in c for v in words(client)]])})
+    bad=invoke(b,'rank-compose',[0,0,0,1,*words({'3096':3})],check=False);assert bad.returncode
+    write_json(Path('docs/research/rust-ranking-complete.json'),{'source_reports':sources,'probes':rows,'rejections':[bad.returncode],'limits':'Rust source sort plus rank words matches128 complete5864 eligible compositions through64 clients, exact order and rank flags. Publication, collection of mixed clients and native/runtime ownership excluded.'})
+if __name__=='__main__':main()

scripts/test_rust_ranking_complete.py

@@ -0,0 +1,12 @@
+import hashlib,json,unittest
+from pathlib import Path
+from test_qvm_ranking_large_caller import ranks
+class RustRankingCompleteTests(unittest.TestCase):
+    def test_source_order_rank_and_independent_tie_oracle(self):
+        ps=json.loads(Path('docs/research/rust-ranking-complete.json').read_text())['probes'];self.assertEqual(len(ps),128)
+        for p in ps:a=p['input'];self.assertEqual(p['rust']['order'],p['source_order']);self.assertEqual(p['rust']['ranks'],p['source_ranks']);self.assertEqual(p['rust']['ranks'],ranks(a['mode'],a['clients'],p['source_order'],a['team_scores']))
+    def test_identity_and_unsupported_domain(self):
+        r=json.loads(Path('docs/research/rust-ranking-complete.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

@@ -1807,3 +1807,16 @@ report	scripts/analyze_rust_rank_sort.py	docs/research/rust-rank-sort.json
 edge	docs/research/rust-rank-sort.json	scripts/test_rust_rank_sort.py
 group	rust-rank-sort	scripts/analyze_rust_rank_sort.py
 edge	scripts/analyze_rust_rank_sort.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_ranking_complete.py
+edge	Cargo.lock	scripts/analyze_rust_ranking_complete.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_ranking_complete.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_ranking_complete.py
+edge	crates/urt-gameplay/src/bin/urt-lifecycle.rs	scripts/analyze_rust_ranking_complete.py
+edge	crates/urt-gameplay/src/rank_sort.rs	scripts/analyze_rust_ranking_complete.py
+edge	crates/urt-gameplay/src/ranking.rs	scripts/analyze_rust_ranking_complete.py
+group	gameplay	scripts/analyze_rust_ranking_complete.py
+group	rust-ranking-complete	scripts/analyze_rust_health_impulse.py
+report	scripts/analyze_rust_ranking_complete.py	docs/research/rust-ranking-complete.json
+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