gameplay: port source ranking sort

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

@@ -1,4 +1,18 @@
 use urt_gameplay::protected::{ProtectedState, update};
+fn ranking_client(v: &[u32]) -> urt_gameplay::ranking::Client {
+    urt_gameplay::ranking::Client {
+        spectator_state: v[0] as i32,
+        follow_index: v[1] as i32,
+        connection: v[2] as i32,
+        team: v[3] as i32,
+        spectator_time: v[4] as i32,
+        time: v[5] as i32,
+        class: v[6] as i32,
+        score: v[7] as i32,
+        deaths: v[8] as i32,
+        awards: v[9] as i32,
+    }
+}
 fn main() {
     if let Err(e) = run() {
         eprintln!("{e}");
@@ -314,6 +328,23 @@ fn run() -> Result<(), String> {
                 second.cached_ping as u32
             );
         }
+        "rank-sort" if w.len() >= 2 && w[1] <= 64 => {
+            let n = w[1] as usize;
+            if w.len() != 2 + 11 * n {
+                return Err("invalid rank sort words".into());
+            }
+            let mut ids: Vec<_> = w[2..2 + n].iter().map(|v| *v as usize).collect();
+            let clients: Vec<_> = w[2 + n..].chunks_exact(10).map(ranking_client).collect();
+            urt_gameplay::rank_sort::sort(w[0] as i32, &clients, &mut ids)
+                .map_err(|e| format!("unsupported input: {e:?}"))?;
+            println!(
+                "{{\"order\":[{}]}}",
+                ids.iter()
+                    .map(|v| v.to_string())
+                    .collect::<Vec<_>>()
+                    .join(",")
+            );
+        }
         "rank-compare" if w.len() == 21 => {
             let client = |v: &[u32]| urt_gameplay::ranking::Client {
                 spectator_state: v[0] as i32,

crates/urt-gameplay/src/lib.rs

@@ -157,3 +157,5 @@ pub mod recipient_wire;
 pub mod record_clear;
 pub mod score;
 pub mod stat_totals;
+
+pub mod rank_sort;

crates/urt-gameplay/src/rank_sort.rs

@@ -0,0 +1,187 @@
+//! QVM35095 aligned four-byte ranking sort. No Rust Ord assumption.
+use crate::ranking::{Client, RankError, compare};
+
+fn median(a: &[usize], c: &[Client], mode: i32, x: usize, y: usize, z: usize) -> usize {
+    let cmp = |i: usize, j: usize| compare(mode, c[a[i]], c[a[j]]);
+    if cmp(x, y) < 0 {
+        if cmp(y, z) < 0 {
+            y
+        } else if cmp(x, z) < 0 {
+            z
+        } else {
+            x
+        }
+    } else if cmp(y, z) > 0 {
+        y
+    } else if cmp(x, z) < 0 {
+        x
+    } else {
+        z
+    }
+}
+fn insertion(a: &mut [usize], clients: &[Client], mode: i32) {
+    for i in 1..a.len() {
+        let mut j = i;
+        while j > 0 && compare(mode, clients[a[j - 1]], clients[a[j]]) > 0 {
+            a.swap(j - 1, j);
+            j -= 1;
+        }
+    }
+}
+fn block_swap(a: &mut [usize], x: usize, y: usize, n: usize) {
+    for i in 0..n {
+        a.swap(x + i, y + i);
+    }
+}
+pub(crate) fn source_sort(mut a: &mut [usize], c: &[Client], mode: i32) {
+    loop {
+        let n = a.len();
+        if n < 7 {
+            insertion(a, c, mode);
+            return;
+        }
+        let mut mid = n / 2;
+        if n > 7 {
+            let (mut first, mut last) = (0, n - 1);
+            if n > 40 {
+                let d = n / 8;
+                first = median(a, c, mode, 0, d, 2 * d);
+                mid = median(a, c, mode, mid - d, mid, mid + d);
+                last = median(a, c, mode, last - 2 * d, last - d, last);
+            }
+            mid = median(a, c, mode, first, mid, last);
+        }
+        a.swap(0, mid);
+        let (mut pa, mut pb) = (1usize, 1usize);
+        let (mut pc, mut pd) = ((n - 1) as isize, (n - 1) as isize);
+        let mut swapped = false;
+        loop {
+            while (pb as isize) <= pc {
+                let r = compare(mode, c[a[pb]], c[a[0]]);
+                if r > 0 {
+                    break;
+                }
+                if r == 0 {
+                    a.swap(pa, pb);
+                    pa += 1;
+                    swapped = true;
+                }
+                pb += 1;
+            }
+            while (pb as isize) <= pc {
+                let r = compare(mode, c[a[pc as usize]], c[a[0]]);
+                if r < 0 {
+                    break;
+                }
+                if r == 0 {
+                    a.swap(pc as usize, pd as usize);
+                    pd -= 1;
+                    swapped = true;
+                }
+                pc -= 1;
+            }
+            if (pb as isize) > pc {
+                break;
+            }
+            a.swap(pb, pc as usize);
+            pb += 1;
+            pc -= 1;
+            swapped = true;
+        }
+        if !swapped {
+            insertion(a, c, mode);
+            return;
+        }
+        let r = pa.min(pb - pa);
+        block_swap(a, 0, pb - r, r);
+        let right = (pd - pc) as usize;
+        let r = right.min(n - 1 - pd as usize);
+        block_swap(a, pb, n - r, r);
+        let left = pb - pa;
+        if left > 1 {
+            source_sort(&mut a[..left], c, mode);
+        }
+        if right <= 1 {
+            return;
+        }
+        a = &mut a[n - right..];
+    }
+}
+/// Eligible connected non-spectators only. The order must be a complete
+/// permutation of at most64 clients. Equal-key ordering follows source swaps.
+pub fn sort(mode: i32, clients: &[Client], order: &mut [usize]) -> Result<(), RankError> {
+    if clients.len() > 64 || order.len() != clients.len() {
+        return Err(RankError::InvalidOrder);
+    }
+    if clients
+        .iter()
+        .any(|c| c.connection != 2 || c.team == 3 || c.spectator_state == 3 || c.follow_index < 0)
+    {
+        return Err(RankError::UnsupportedParticipant);
+    }
+    let mut seen = vec![false; clients.len()];
+    for &id in order.iter() {
+        if id >= clients.len() || seen[id] {
+            return Err(RankError::InvalidOrder);
+        }
+        seen[id] = true;
+    }
+    source_sort(order, clients, mode);
+    Ok(())
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn client(score: i32) -> Client {
+        Client {
+            spectator_state: 0,
+            follow_index: 0,
+            connection: 2,
+            team: 1,
+            spectator_time: 0,
+            time: score,
+            class: score,
+            score,
+            deaths: 0,
+            awards: 0,
+        }
+    }
+    #[test]
+    fn signed_extremes_and_partition_sizes() {
+        for n in [0, 1, 6, 7, 8, 40, 41, 64] {
+            let mut c: Vec<_> = (0..n).map(|i| client(i as i32 % 5)).collect();
+            if n > 1 {
+                c[0].score = i32::MIN;
+                c[1].score = i32::MAX;
+            }
+            let mut ids: Vec<_> = (0..n).rev().collect();
+            sort(0, &c, &mut ids).unwrap();
+            assert!(ids.windows(2).all(|w| c[w[0]].score >= c[w[1]].score));
+            let mut permutation = ids;
+            permutation.sort_unstable();
+            assert_eq!(permutation, (0..n).collect::<Vec<_>>());
+        }
+    }
+    #[test]
+    fn equal_keys_keep_source_unstable_pivot_swap() {
+        let c = vec![client(0); 7];
+        let mut ids: Vec<_> = (0..7).collect();
+        sort(0, &c, &mut ids).unwrap();
+        assert_eq!(ids, [3, 1, 2, 0, 4, 5, 6]);
+    }
+    #[test]
+    fn rejects_without_mutating_invalid_or_unsupported_input() {
+        let c = vec![client(0); 2];
+        let mut ids = [0, 0];
+        assert_eq!(sort(0, &c, &mut ids), Err(RankError::InvalidOrder));
+        assert_eq!(ids, [0, 0]);
+        let mut c = c;
+        c[0].connection = 1;
+        let mut ids = [1, 0];
+        assert_eq!(
+            sort(0, &c, &mut ids),
+            Err(RankError::UnsupportedParticipant)
+        );
+        assert_eq!(ids, [1, 0]);
+    }
+}

docs/FINDINGS.md

@@ -1379,3 +1379,6 @@ RE-780–789 exposes and bounds legacy resumer timing/byte-state flaws, migrates
 
 
 **RE-793:** Ranking count globals follow connection/team/bot gates, but deferred records can move active clients out of the positional prefix that receives rank words. [Evidence](research/QVM_RANKING_POPULATION.md).
+
+
+**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).

docs/PROVISIONAL_TODO.md

@@ -1383,3 +1383,6 @@ RE-792: 5864 now composes actual35095 sorting and rank writes over80 larger elig
 
 
 RE-793: Ranking count globals follow connection/team/bot gates, but deferred records can move active clients out of the positional prefix that receives rank words. Full runtime completion remains open. [Evidence](research/QVM_RANKING_POPULATION.md).
+
+
+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).

docs/RESEARCH_LEDGER.md

@@ -1629,3 +1629,8 @@ Both resumers can synchronize new and changed child words into byte lanes withou
 ## 2026-10-26 — RE-793 Mixed ranking populations and positional rank-prefix behavior
 
 Ranking count globals follow connection/team/bot gates, but deferred records can move active clients out of the positional prefix that receives rank words. Focused `cargo xtask test-group ranking-population` 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.
+
+
+## 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.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1429,3 +1429,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-793 Mixed ranking populations and positional rank-prefix behavior ([evidence](research/QVM_RANKING_POPULATION.md)).
+
+
+- [x] RE-794 Rust source-shaped aligned ranking sort with exact tie order ([evidence](research/RUST_RANK_SORT.md)).

docs/research/README.md

@@ -969,3 +969,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-793: Mixed ranking populations and positional rank-prefix behavior](QVM_RANKING_POPULATION.md).
+
+
+[RE-794: Rust source-shaped aligned ranking sort with exact tie order](RUST_RANK_SORT.md).

docs/research/RUST_RANK_SORT.md

@@ -0,0 +1,7 @@
+# Rust source-shaped aligned ranking sort with exact tie order
+
+RE-794. Reproduce with `python3 scripts/analyze_rust_rank_sort.py`; focused validation: `cargo xtask test-group rust-rank-sort`. [Machine report](rust-rank-sort.json).
+
+The Rust implementation follows source pivot selection, equal-key partition swaps, insertion fallback, left recursion and right tail iteration.140 original-QVM fixtures check exact resulting order rather than merely equivalent sorted keys. Unit tests cover partition boundaries, signed score extremes, original equal-key pivot permutation and rejection without mutation. Public inputs remain eligible complete permutations with at most64 clients. Mixed raw comparator behavior is reserved for a separate audited composition.
+
+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": 54,
+  "rust_unit_tests": 57,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_rank_sort.py

@@ -0,0 +1,20 @@
+#!/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 filename in ['qvm-rank-small-sort','qvm-rank-large-sort']:
+        path=Path('docs/research/'+filename+'.json');data=path.read_bytes();sources[str(path)]=hashlib.sha256(data).hexdigest()
+        for p in json.loads(data)['probes']:
+            c=p['clients'];order=p['initial'];r=result(b,'rank-sort',[p['mode'],len(order),*order,*[v for row in c[:len(order)] for v in words(row)]]) if len(c)==len(order) else None
+            # Small fixtures keep six seed records even for shorter arrays.
+            if r is None:
+                used=sorted(set(order));remap={v:j for j,v in enumerate(used)};r=result(b,'rank-sort',[p['mode'],len(used),*[remap[v] for v in order],*[v for j in used for v in words(c[j])]]);r['order']=[used[j] for j in r['order']]
+            rows.append({'mode':p['mode'],'initial':order,'source':p['final'],'rust':r,'clients':c})
+    bad=invoke(b,'rank-sort',[0,1,0,*words({'468':1})],check=False);assert bad.returncode!=0
+    write_json(Path('docs/research/rust-rank-sort.json'),{'source_reports':sources,'probes':rows,'rejections':[bad.returncode],'limits':'Rust source-shaped35095 word-index sort, exact source order including unstable ties across140 fixtures. Eligible complete permutations only; mixed raw prefilters, native ABI and full ranking publication remain outside this API.'})
+if __name__=='__main__':main()

scripts/test_rust_rank_sort.py

@@ -0,0 +1,12 @@
+import hashlib,json,unittest
+from pathlib import Path
+class RustRankSortTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):cls.r=json.loads(Path('docs/research/rust-rank-sort.json').read_text())
+    def test_exact_source_order_including_tie_permutations(self):
+        self.assertEqual(len(self.r['probes']),140)
+        for p in self.r['probes']:self.assertEqual(p['rust']['order'],p['source'],(p['mode'],p['initial']))
+    def test_source_identity_and_domain_rejection(self):
+        for path,sha in self.r['source_reports'].items():self.assertEqual(hashlib.sha256(Path(path).read_bytes()).hexdigest(),sha)
+        self.assertTrue(all(v!=0 for v in self.r['rejections']))
+if __name__=='__main__':unittest.main()

xtask/checks.tsv

@@ -1792,3 +1792,18 @@ group	ranking-population	scripts/analyze_qvm_ranking_population.py
 edge	scripts/analyze_qvm_ranking_population.py	scripts/analyze_qvm_resumer_audit.py
 
 group	ranking-population	scripts/analyze_qvm_rank_large_sort.py
+edge	Cargo.toml	scripts/analyze_rust_rank_sort.py
+edge	Cargo.lock	scripts/analyze_rust_rank_sort.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_rank_sort.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_rank_sort.py
+edge	crates/urt-gameplay/src/bin/urt-lifecycle.rs	scripts/analyze_rust_rank_sort.py
+edge	crates/urt-gameplay/src/rank_sort.rs	scripts/analyze_rust_rank_sort.py
+edge	crates/urt-gameplay/src/ranking.rs	scripts/analyze_rust_rank_sort.py
+edge	crates/urt-gameplay/src/rank_sort.rs	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_rank_sort.py
+
+group	rust-rank-sort	scripts/analyze_rust_health_impulse.py
+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

xtask/src/lib.rs

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