gameplay: port raw ranking contracts

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

@@ -314,6 +314,53 @@ fn run() -> Result<(), String> {
                 second.cached_ping as u32
             );
         }
+        "rank-compare" if w.len() == 21 => {
+            let client = |v: &[u32]| 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,
+            };
+            println!(
+                "{{\"result\":{}}}",
+                urt_gameplay::ranking::compare(w[0] as i32, client(&w[1..11]), client(&w[11..]))
+            );
+        }
+        "rank-words" if w.len() >= 4 && w[3] <= 6 => {
+            let n = w[3] as usize;
+            if w.len() != 4 + 11 * n {
+                return Err("invalid ranking words".into());
+            }
+            let client = |v: &[u32]| 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,
+            };
+            let clients: Vec<_> = w[4 + n..].chunks_exact(10).map(client).collect();
+            let order: Vec<_> = w[4..4 + n].iter().map(|v| *v as usize).collect();
+            let ranks = urt_gameplay::ranking::rank_words(
+                w[0] as i32,
+                &clients,
+                &order,
+                [w[1] as i32, w[2] as i32],
+            )
+            .map_err(|e| format!("unsupported input: {e:?}"))?;
+            let ranks: Vec<_> = ranks.iter().map(|v| v.to_string()).collect();
+            println!("{{\"ranks\":[{}]}}", ranks.join(","));
+        }
         _ => return Err("unsupported contract or arguments".into()),
     }
     Ok(())

crates/urt-gameplay/src/lib.rs

@@ -149,6 +149,7 @@ pub mod intercept_animation;
 pub mod method_stats;
 pub mod mode10;
 pub mod protected;
+pub mod ranking;
 pub mod recent_awards;
 pub mod recipient_payload;
 pub mod record_clear;

crates/urt-gameplay/src/ranking.rs

@@ -0,0 +1,236 @@
+//! Source5441 raw comparator and5864 finite eligible-client rank publication.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Client {
+    pub spectator_state: i32,
+    pub follow_index: i32,
+    pub connection: i32,
+    pub team: i32,
+    pub spectator_time: i32,
+    pub time: i32,
+    pub class: i32,
+    pub score: i32,
+    pub deaths: i32,
+    pub awards: i32,
+}
+/// Raw source result deliberately does not implement Ord: two deferred or
+/// connecting clients can compare+1 in both directions, including self.
+pub fn compare(mode: i32, a: Client, b: Client) -> i32 {
+    if a.spectator_state == 3 || a.follow_index < 0 {
+        return 1;
+    }
+    if b.spectator_state == 3 || b.follow_index < 0 {
+        return -1;
+    }
+    if a.connection == 1 {
+        return 1;
+    }
+    if b.connection == 1 {
+        return -1;
+    }
+    let cmp = |x: i32, y: i32| {
+        if x < y {
+            -1
+        } else if x > y {
+            1
+        } else {
+            0
+        }
+    };
+    if a.team == 3 && b.team == 3 {
+        return cmp(a.spectator_time, b.spectator_time);
+    }
+    if a.team == 3 {
+        return 1;
+    }
+    if b.team == 3 {
+        return -1;
+    }
+    if mode == 9 {
+        return if a.time != 0 && b.time == 0 {
+            -1
+        } else if a.time == 0 && b.time != 0 {
+            1
+        } else {
+            cmp(a.time, b.time)
+        };
+    }
+    if mode == 11 && a.class != b.class {
+        return -cmp(a.class, b.class);
+    }
+    if a.score != b.score {
+        return -cmp(a.score, b.score);
+    }
+    if a.deaths != b.deaths {
+        return cmp(a.deaths, b.deaths);
+    }
+    if mode >= 3 && mode != 9 && mode != 11 {
+        return -cmp(a.awards, b.awards);
+    }
+    0
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RankError {
+    UnsupportedParticipant,
+    InvalidOrder,
+}
+/// Caller supplies a complete ordering. This primitive does not execute a sort
+/// or publication callbacks. Source parity fixtures use eligible n<7 clients.
+pub fn rank_words(
+    mode: i32,
+    clients: &[Client],
+    order: &[usize],
+    scores: [i32; 2],
+) -> Result<Vec<u32>, RankError> {
+    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()];
+    if order.len() != clients.len() {
+        return Err(RankError::InvalidOrder);
+    }
+    for &id in order {
+        if id >= clients.len() || seen[id] {
+            return Err(RankError::InvalidOrder);
+        }
+        seen[id] = true;
+    }
+    if mode >= 3 && mode != 9 && mode != 11 {
+        return Ok(vec![
+            if scores[0] == scores[1] {
+                2
+            } else if scores[0] > scores[1] {
+                0
+            } else {
+                1
+            };
+            clients.len()
+        ]);
+    }
+    let mut result = vec![0; clients.len()];
+    let mut base = 0;
+    let mut previous = None;
+    for (j, &id) in order.iter().enumerate() {
+        let c = clients[id];
+        let key = if mode == 9 {
+            c.time
+        } else if mode == 11 {
+            c.class
+        } else {
+            c.score
+        };
+        if j == 0 || Some(key) != previous {
+            base = j as u32;
+            result[id] = base;
+        } else {
+            result[order[j - 1]] = base | 16384;
+            result[id] = base | 16384;
+        }
+        previous = Some(key);
+    }
+    Ok(result)
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn client() -> Client {
+        Client {
+            spectator_state: 0,
+            follow_index: 0,
+            connection: 2,
+            team: 1,
+            spectator_time: 0,
+            time: 0,
+            class: 0,
+            score: 0,
+            deaths: 0,
+            awards: 0,
+        }
+    }
+    #[test]
+    fn raw_prefilter_quirks_remain_nonordering() {
+        let c = Client {
+            spectator_state: 3,
+            ..client()
+        };
+        assert_eq!(compare(0, c, c), 1);
+        let c = Client {
+            connection: 1,
+            ..client()
+        };
+        assert_eq!(compare(0, c, c), 1);
+    }
+    #[test]
+    fn special_modes_and_signed_priorities() {
+        let a = Client {
+            time: -1,
+            class: 2,
+            score: i32::MIN,
+            awards: i32::MAX,
+            ..client()
+        };
+        let b = Client {
+            score: i32::MAX,
+            ..client()
+        };
+        assert_eq!(compare(9, a, b), -1);
+        assert_eq!(compare(11, a, b), -1);
+        assert_eq!(compare(0, a, b), 1);
+        assert_eq!(
+            compare(
+                3,
+                a,
+                Client {
+                    score: i32::MIN,
+                    ..b
+                }
+            ),
+            -1
+        );
+    }
+    #[test]
+    fn ties_and_global_team_result_words() {
+        let c = [
+            Client {
+                score: 5,
+                ..client()
+            },
+            Client {
+                score: 5,
+                ..client()
+            },
+            client(),
+        ];
+        assert_eq!(
+            rank_words(0, &c, &[0, 1, 2], [0, 0]).unwrap(),
+            [16384, 16384, 2]
+        );
+        assert_eq!(rank_words(3, &c, &[0, 1, 2], [1, 1]).unwrap(), [2, 2, 2]);
+    }
+    #[test]
+    fn invalid_permutation_and_participants_reject() {
+        let c = [client(), client()];
+        assert_eq!(
+            rank_words(0, &c, &[0, 0], [0, 0]),
+            Err(RankError::InvalidOrder)
+        );
+        assert_eq!(
+            rank_words(0, &c, &[0, 2], [0, 0]),
+            Err(RankError::InvalidOrder)
+        );
+        assert_eq!(
+            rank_words(
+                0,
+                &[Client {
+                    team: 3,
+                    ..client()
+                }],
+                &[0],
+                [0, 0]
+            ),
+            Err(RankError::UnsupportedParticipant)
+        );
+    }
+}

docs/ASSET_PIPELINE_TODO.md

@@ -982,3 +982,6 @@ Research progress: RE-774 [report](research/QVM_LEADERBOARD_CATEGORIES.md); orig
 
 
 Research progress: RE-775 [report](research/QVM_RECIPIENT_WIRE.md); original assets unchanged.
+
+
+Research progress: RE-776 [report](research/RUST_RANKING.md); original assets unchanged.

docs/FINDINGS.md

@@ -1328,3 +1328,6 @@ RE-725–734 batch: [health, contact and Rust impulse findings](research/QVM_HEA
 
 
 **RE-775 — Original recipient command templates and bounded byte serialization model:** Original scoress/scoresd templates carry12 numeric fields plus a name per participant;69338 requests31-byte strncpy then forces the32nd byte to zero. [Evidence](research/QVM_RECIPIENT_WIRE.md).
+
+
+**RE-776 — Rust raw comparator and eligible rank publication primitives:** Rust raw comparator and rank words match232 comparator and48 eligible complete-ranking source fixtures without imposing Ord on non-ordering prefilters. [Evidence](research/RUST_RANKING.md).

docs/PROVISIONAL_TODO.md

@@ -1326,3 +1326,6 @@ Research progress: RE-774 [report](research/QVM_LEADERBOARD_CATEGORIES.md); full
 
 
 Research progress: RE-775 [report](research/QVM_RECIPIENT_WIRE.md); full native/platform/game scope remains open.
+
+
+Research progress: RE-776 [report](research/RUST_RANKING.md); full native/platform/game scope remains open.

docs/RESEARCH_LEDGER.md

@@ -1533,3 +1533,8 @@ Exactly ten task commits follow baseline `27a7f96f`. Every completed task passed
 ## 2026-10-21 — RE-775 Original recipient command templates and bounded byte serialization model
 
 Original scoress/scoresd templates carry12 numeric fields plus a name per participant;69338 requests31-byte strncpy then forces the32nd byte to zero. Focused `cargo xtask test-group recipient-wire` passes (3 Python tests); selected reports regenerate twice byte-identically, with storage, links and whitespace guards. New report: 120583 bytes. Full-suite validation is deferred to the tenth batch commit. No original assets, Rust runtime or shared VM evaluator changed.
+
+
+## 2026-10-21 — RE-776 Rust raw comparator and eligible rank publication primitives
+
+Rust raw comparator and rank words match232 comparator and48 eligible complete-ranking source fixtures without imposing Ord on non-ordering prefilters. Focused `cargo xtask test-group gameplay` passes (34 Python tests); selected reports regenerate twice byte-identically, with storage, links and whitespace guards. New report: 97961 bytes. Full-suite validation is deferred to the tenth batch commit. Rust gameplay crate changed; focused gameplay regenerates eleven parity contracts and scoped package tests. Full suite remains deferred until task ten.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1372,3 +1372,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-775 Original recipient command templates and bounded byte serialization model ([report](research/QVM_RECIPIENT_WIRE.md)).
+
+
+- [x] RE-776 Rust raw comparator and eligible rank publication primitives ([report](research/RUST_RANKING.md)).

docs/research/README.md

@@ -918,3 +918,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-775: Original recipient command templates and bounded byte serialization model](QVM_RECIPIENT_WIRE.md).
+
+
+[RE-776: Rust raw comparator and eligible rank publication primitives](RUST_RANKING.md).

docs/research/RUST_RANKING.md

@@ -0,0 +1,7 @@
+# Rust raw comparator and eligible rank publication primitives
+
+RE-776. Reproduce with `python3 scripts/analyze_rust_ranking.py`; validate with `cargo xtask test-group gameplay`. See the [machine report](rust-ranking.json).
+
+Added typed ranking clients, raw source comparator and caller-ordered rank publication with permutation/participant validation. Four Rust unit tests cover prefilter quirks, signed and special-mode priorities, ties/team words and invalid domains. Actual aligned small sorting remains in source evidence; Rust sorting, publication callbacks, larger client domains and native/platform parity remain open.
+
+No original executable/full VM/native world collision or rendering runs. Supplied callback/native responses and fixture domains remain explicit; complete macOS/Linux Rust/Bevy/Solari gameplay remains open.

docs/research/rust-health-impulse.json

@@ -2985,7 +2985,7 @@
       "exit_code": 2
     }
   ],
-  "rust_unit_tests": 42,
+  "rust_unit_tests": 46,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_ranking.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+"""Rust raw comparator and eligible rank words against source fixtures."""
+import hashlib,json
+from pathlib import Path
+from qvm_rank_compare_support import FIELDS,DEFAULT
+from rust_lifecycle_support import binary,result
+from analyze_qvm import write_json
+
+def words(c):return [c.get(str(o),DEFAULT[o]) for o in FIELDS]
+
+def main():
+    b=binary();path=Path('docs/research/qvm-rank-comparator.json');raw=path.read_bytes();rank=Path('docs/research/qvm-ranking-complete.json');data=rank.read_bytes();rows=[];ranks=[]
+    for p in json.loads(raw)['probes']:
+        a=p['input'];rows.append({'input':a,'source':p['result'],'rust':result(b,'rank-compare',[a['mode'],*words(a['first']),*words(a['second'])])})
+    for p in json.loads(data)['probes']:
+        a=p['input'];args=[a['mode'],*a['team_scores'],len(a['clients']),*p['order'],*[v for c in a['clients'] for v in words(c)]];ranks.append({'input':a,'order':p['order'],'source':p['ranks'],'rust':result(b,'rank-words',args)})
+    write_json(Path('docs/research/rust-ranking.json'),{'source_reports':{str(path):hashlib.sha256(raw).hexdigest(),str(rank):hashlib.sha256(data).hexdigest()},'probes':rows,'rank_probes':ranks,'limits':'Rust raw comparator matches232 source cases; rank words match48 eligible n<7 source compositions. No Rust Ord or native sort is claimed. Caller owns order; invalid permutation/unsupported participant rejects. Ranking callbacks, large sort and native/platform/runtime parity remain open.'})
+if __name__=='__main__':main()

scripts/test_rust_ranking.py

@@ -0,0 +1,15 @@
+import hashlib,json,unittest
+from pathlib import Path
+from test_qvm_rank_comparator import compare
+class RustRankingTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):cls.r=json.loads(Path('docs/research/rust-ranking.json').read_text())
+    def test_source_raw_compare_and_independent_oracle(self):
+        self.assertEqual(len(self.r['probes']),232)
+        for p in self.r['probes']:a=p['input'];self.assertEqual(p['rust']['result'],p['source']);self.assertEqual(p['source'],compare(a['mode'],a['first'],a['second']))
+    def test_source_rank_words_and_tie_flags(self):
+        self.assertEqual(len(self.r['rank_probes']),48)
+        for p in self.r['rank_probes']:self.assertEqual(p['rust']['ranks'],p['source'])
+    def test_source_identity(self):
+        for path,sha in self.r['source_reports'].items():self.assertEqual(hashlib.sha256(Path(path).read_bytes()).hexdigest(),sha)
+if __name__=='__main__':unittest.main()

xtask/checks.tsv

@@ -1344,3 +1344,13 @@ group	leaderboard-categories	scripts/analyze_qvm_leaderboard_categories.py
 report	scripts/analyze_qvm_recipient_wire.py	docs/research/qvm-recipient-wire.json
 edge	docs/research/qvm-recipient-wire.json	scripts/test_qvm_recipient_wire.py
 group	recipient-wire	scripts/analyze_qvm_recipient_wire.py
+edge	Cargo.toml	scripts/analyze_rust_ranking.py
+edge	Cargo.lock	scripts/analyze_rust_ranking.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_ranking.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_ranking.py
+edge	crates/urt-gameplay/src/ranking.rs	scripts/analyze_rust_ranking.py
+edge	crates/urt-gameplay/src/bin/urt-lifecycle.rs	scripts/analyze_rust_ranking.py
+edge	crates/urt-gameplay/src/ranking.rs	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_ranking.py
+report	scripts/analyze_rust_ranking.py	docs/research/rust-ranking.json
+edge	docs/research/rust-ranking.json	scripts/test_rust_ranking.py