gameplay: port recipient numeric payloads

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

@@ -269,6 +269,51 @@ fn run() -> Result<(), String> {
                 values.join(",")
             );
         }
+        "payload" if w.len() == 44 && w[0] <= 1 && w[1] <= 1 => {
+            use urt_gameplay::recipient_payload::{Client, Presence, prepare};
+            let client = |v: &[u32], entity_flags: u32| Client {
+                pm_flags: v[0],
+                health: v[2] as i32,
+                protected_flags: v[3],
+                score: v[4] as i32,
+                deaths: v[5] as i32,
+                packed: v[6],
+                field308: v[7] as i32,
+                ping: v[8] as i32,
+                connection: v[9] as i32,
+                entered: v[10] as i32,
+                class: v[11] as i32,
+                awards: v[12] as i32,
+                field3692: v[13] as i32,
+                special: v[14] as i32,
+                follow: v[15] as i32,
+                extra_time: v[16] as i32,
+                cached_ping: v[17] as i32,
+                entity_flags,
+            };
+            let mut first = client(&w[8..26], w[6]);
+            let mut second = client(&w[26..], w[7]);
+            let presence = |bits: u32| Presence {
+                present: bits & 1 != 0,
+                in_use: bits & 2 != 0,
+                client: bits & 4 != 0,
+            };
+            let p = prepare(
+                w[0] != 0,
+                [presence(w[3]), presence(w[4]), presence(w[5])],
+                w[1] != 0,
+                w[2] as i32,
+                &mut first,
+                &mut second,
+            );
+            let values:Vec<_>=p.iter().map(|r|format!("{{\"score\":{},\"ping\":{},\"minutes\":{},\"status\":{},\"deaths\":{},\"field3692\":{},\"packed_low\":{},\"packed_high\":{},\"field308\":{},\"awards\":{},\"class\":{}}}",r.score,r.ping,r.minutes,r.status,r.deaths,r.field3692,r.packed_low,r.packed_high,r.field308,r.awards,r.class)).collect();
+            println!(
+                "{{\"payloads\":[{}],\"cached\":[{},{}]}}",
+                values.join(","),
+                first.cached_ping as u32,
+                second.cached_ping as u32
+            );
+        }
         _ => return Err("unsupported contract or arguments".into()),
     }
     Ok(())

crates/urt-gameplay/src/lib.rs

@@ -150,6 +150,7 @@ pub mod method_stats;
 pub mod mode10;
 pub mod protected;
 pub mod recent_awards;
+pub mod recipient_payload;
 pub mod record_clear;
 pub mod score;
 pub mod stat_totals;

crates/urt-gameplay/src/recipient_payload.rs

@@ -0,0 +1,210 @@
+//! Numeric179736/180087 projection and cache effects; no string serialization.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Client {
+    pub pm_flags: u32,
+    pub health: i32,
+    pub protected_flags: u32,
+    pub score: i32,
+    pub deaths: i32,
+    pub packed: u32,
+    pub field308: i32,
+    pub ping: i32,
+    pub connection: i32,
+    pub entered: i32,
+    pub class: i32,
+    pub awards: i32,
+    pub field3692: i32,
+    pub special: i32,
+    pub follow: i32,
+    pub extra_time: i32,
+    pub cached_ping: i32,
+    pub entity_flags: u32,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Presence {
+    pub present: bool,
+    pub in_use: bool,
+    pub client: bool,
+}
+impl Presence {
+    fn valid(self) -> bool {
+        self.present && self.in_use && self.client
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Numeric {
+    pub score: i32,
+    pub ping: i32,
+    pub minutes: i32,
+    pub status: i32,
+    pub deaths: i32,
+    pub field3692: i32,
+    pub packed_low: i32,
+    pub packed_high: i32,
+    pub field308: i32,
+    pub awards: i32,
+    pub class: i32,
+}
+pub fn project(c: &mut Client, now: i32) -> Numeric {
+    let mut ping = if c.connection == 2 {
+        c.ping.min(999)
+    } else {
+        999
+    };
+    if c.follow != 0 && c.pm_flags & 1024 != 0 {
+        ping = c.cached_ping;
+    } else {
+        c.cached_ping = ping;
+    }
+    if c.entity_flags & 8 != 0 {
+        ping = -1;
+    }
+    let status = if c.special != 0 {
+        2
+    } else if c.follow != 0 || c.health <= 0 || c.protected_flags & 16384 != 0 {
+        1
+    } else {
+        0
+    };
+    Numeric {
+        score: c.score,
+        ping,
+        minutes: now.wrapping_sub(c.entered).wrapping_add(c.extra_time) / 60000,
+        status,
+        deaths: c.deaths,
+        field3692: c.field3692,
+        packed_low: (c.packed & 255) as i32,
+        packed_high: (c.packed as i32) >> 8,
+        field308: c.field308,
+        awards: c.awards,
+        class: if (0..=20).contains(&c.class) {
+            c.class
+        } else {
+            0
+        },
+    }
+}
+/// Single uses participants0/1; pair uses0/1/2. Repeated client storage is
+/// projected in source order through the same mutable first-client state.
+pub fn prepare(
+    pair: bool,
+    participants: [Presence; 3],
+    same_client: bool,
+    now: i32,
+    first: &mut Client,
+    second: &mut Client,
+) -> Vec<Numeric> {
+    let count = if pair { 3 } else { 2 };
+    if !participants[..count].iter().all(|p| p.valid()) {
+        return vec![];
+    }
+    let mut payload = vec![project(first, now)];
+    if pair {
+        payload.push(project(if same_client { first } else { second }, now));
+    }
+    payload
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn client() -> Client {
+        Client {
+            pm_flags: 0,
+            health: 100,
+            protected_flags: 0,
+            score: 7,
+            deaths: 3,
+            packed: 0x800001ff,
+            field308: 17,
+            ping: 1500,
+            connection: 2,
+            entered: 1000,
+            class: 20,
+            awards: 4,
+            field3692: 9,
+            special: 0,
+            follow: 0,
+            extra_time: 60000,
+            cached_ping: 77,
+            entity_flags: 0,
+        }
+    }
+    #[test]
+    fn cache_freeze_then_publication_override() {
+        let mut c = client();
+        c.follow = 1;
+        c.pm_flags = 1024;
+        c.entity_flags = 8;
+        assert_eq!(project(&mut c, 121000).ping, -1);
+        assert_eq!(c.cached_ping, 77);
+        c.follow = 0;
+        assert_eq!(project(&mut c, 121000).ping, -1);
+        assert_eq!(c.cached_ping, 999);
+        c.entity_flags = 0;
+        c.ping = -5;
+        assert_eq!(project(&mut c, 121000).ping, -5);
+        assert_eq!(c.cached_ping, -5);
+    }
+    #[test]
+    fn status_priority_class_and_connection() {
+        let mut c = client();
+        c.connection = 1;
+        c.health = 0;
+        c.special = 1;
+        c.class = 21;
+        let p = project(&mut c, 121000);
+        assert_eq!((p.ping, p.status, p.class), (999, 2, 0));
+        c.special = 0;
+        assert_eq!(project(&mut c, 121000).status, 1);
+        c.health = 100;
+        assert_eq!(project(&mut c, 121000).status, 0);
+    }
+    #[test]
+    fn wrapped_time_and_signed_packed_word() {
+        let mut c = client();
+        c.entered = i32::MAX;
+        c.extra_time = 0;
+        let p = project(&mut c, i32::MIN);
+        assert_eq!(p.minutes, 0);
+        assert_eq!((p.packed_low, p.packed_high), (255, -8388607));
+    }
+    #[test]
+    fn all_presence_gates_and_alias_order() {
+        let valid = Presence {
+            present: true,
+            in_use: true,
+            client: true,
+        };
+        for j in 0..3 {
+            for bad in [
+                Presence {
+                    present: false,
+                    ..valid
+                },
+                Presence {
+                    in_use: false,
+                    ..valid
+                },
+                Presence {
+                    client: false,
+                    ..valid
+                },
+            ] {
+                let mut ps = [valid; 3];
+                ps[j] = bad;
+                let mut a = client();
+                let mut b = client();
+                let before = (a, b);
+                assert!(prepare(true, ps, false, 121000, &mut a, &mut b).is_empty());
+                assert_eq!((a, b), before);
+            }
+        }
+        let mut a = client();
+        let mut b = client();
+        let before = b;
+        let p = prepare(true, [valid; 3], true, 121000, &mut a, &mut b);
+        assert_eq!(p.len(), 2);
+        assert_eq!(p[0], p[1]);
+        assert_eq!(b, before);
+    }
+}

docs/ASSET_PIPELINE_TODO.md

@@ -958,3 +958,6 @@ Research progress: RE-765 [report](research/RUST_STAT_TOTALS.md); original asset
 
 
 Research progress: RE-766 [report](research/RUST_RECENT_AWARDS.md); original assets unchanged.
+
+
+Research progress: RE-767 [report](research/RUST_RECIPIENT_PAYLOAD.md); original assets unchanged.

docs/FINDINGS.md

@@ -1304,3 +1304,6 @@ RE-725–734 batch: [health, contact and Rust impulse findings](research/QVM_HEA
 
 
 **RE-766 — Rust recent record awards timestamp gates and alias storage:** Rust recent-record awards match68 source fixtures, preserving future ages, wrapped clocks, ID gates and index64 award/count aliasing. [Evidence](research/RUST_RECENT_AWARDS.md).
+
+
+**RE-767 — Rust recipient numeric projection and reporting batch handoff:** Rust recipient participant gates, numeric fields and cache effects match72 single and73 pair source fixtures, including self aliases. [Evidence](research/RUST_RECIPIENT_PAYLOAD.md).

docs/PROVISIONAL_TODO.md

@@ -1299,3 +1299,9 @@ Research progress: RE-765 [report](research/RUST_STAT_TOTALS.md); full native/pl
 
 
 Research progress: RE-766 [report](research/RUST_RECENT_AWARDS.md); full native/platform/game scope remains open.
+
+
+Research progress: RE-767 [report](research/RUST_RECIPIENT_PAYLOAD.md); full native/platform/game scope remains open.
+
+
+RE-758–767 batch validation:1473 Python and80 Rust tests pass after ten independently committed tasks. Totals/ratios, team counters, recent awards, recipient numeric bodies and ranking setup have finite source evidence; Rust adds totals/ratios, recent-award records and recipient numeric/cache contracts. Ranking sort/publication, real serialization, full runtime ownership, native parity, Linux and interactive Bevy/Solari acceptance remain open.

docs/RESEARCH_LEDGER.md

@@ -1486,3 +1486,15 @@ Rust totals and normalized ratios match80 total,28 ratio and38 signed-divisor so
 ## 2026-10-21 — RE-766 Rust recent record awards timestamp gates and alias storage
 
 Rust recent-record awards match68 source fixtures, preserving future ages, wrapped clocks, ID gates and index64 award/count aliasing. Focused `cargo xtask test-group gameplay` passes (28 Python tests); selected reports regenerate twice byte-identically, with storage, links and whitespace guards. New report: 143080 bytes. Full-suite validation is deferred to the tenth batch commit. Rust gameplay crate changed; focused gameplay regenerates nine parity contracts and scoped package tests. Full workspace suite remains deferred to commit ten.
+
+
+## 2026-10-21 — RE-767 Rust recipient numeric projection and reporting batch handoff
+
+Rust recipient participant gates, numeric fields and cache effects match72 single and73 pair source fixtures, including self aliases. Focused `cargo xtask test-group gameplay` passes (31 Python tests); selected reports regenerate twice byte-identically, with storage, links and whitespace guards. New report: 312484 bytes. Full-suite validation is deferred to the tenth batch commit. Rust gameplay and registry integration tests changed. Focused gameplay covers ten parity reports and scoped package tests. The full suite runs once after commit ten, then documentation is amended with its outcome.
+
+Additional RE-767 selector verification: scoped `cargo test --offline --package xtask` passes28 tests. Registry integration confirms totals, recent-award and recipient-payload module edits select their parity reports/tests and the impulse-owned package test-count metadata without fallback.
+
+
+## 2026-10-21 — RE-758–767 full batch validation
+
+Exactly ten task commits follow baseline `27a7f96f`. Every completed task passed focused `cargo xtask test-group` checks before its final commit; no full suite ran between those task commits. After commit ten, the single `cargo xtask test-full --since 27a7f96f` run passed1473 Python tests (519+357+352+245) and80 Rust tests (10 assets,42 gameplay,28 xtask). Seventeen affected report producers regenerated twice byte-identically. Storage policy, documentation links across326 files and whitespace guards passed. Generated outputs matched committed reports and the working tree was clean after validation. The tenth commit is amended only to record this result. Original assets remain unchanged. Ranking sort/publication, actual text serialization, statistic leaderboards, full lifecycle/runtime composition, original native parity, Linux and interactive Bevy/Solari gameplay remain open.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1311,7 +1311,7 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 - [x] RE-755 Rust method classification wrapping counters and reporting intent ([report](research/RUST_METHOD_STATS.md)).
 
 
-- [ ] RE-757 Recover ranking/recipient/stat-report children, compose actual lifecycle from full health/contact/shared-pellet entry, establish owned Rust runtime events/counters and validate native/macOS/Linux Bevy/Solari gameplay. See the [next tasks](research/QVM_SCORE_STATS_RUST_BATCH.md#remaining-limits-and-next-tasks).
+- [ ] RE-757 Partially advanced by RE-758–767 ([batch](research/QVM_REPORTING_RUST_BATCH.md)); recover remaining ranking/recipient/stat-report children, compose actual lifecycle from full health/contact/shared-pellet entry, establish owned Rust runtime events/counters and validate native/macOS/Linux Bevy/Solari gameplay. See the [next tasks](research/QVM_SCORE_STATS_RUST_BATCH.md#remaining-limits-and-next-tasks).
 
 
 - [x] RE-756 Rust cross client clearing and score statistics batch handoff ([report](research/RUST_CROSS_CLIENT_CLEAR.md)).
@@ -1342,3 +1342,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-766 Rust recent record awards timestamp gates and alias storage ([report](research/RUST_RECENT_AWARDS.md)).
+
+
+- [ ] RE-768 Complete ranking sort/publication and recipient serialization/stat-leaderboard children, compose recovered effects through full health/contact/shared-pellet callers, establish owned Rust runtime state/events and validate original native/macOS/Linux Bevy/Solari gameplay. See the [next tasks](research/QVM_REPORTING_RUST_BATCH.md#remaining-limits-and-next-tasks).
+
+
+- [x] RE-767 Rust recipient numeric projection and reporting batch handoff ([report](research/RUST_RECIPIENT_PAYLOAD.md)).

docs/TESTING.md

@@ -98,3 +98,7 @@ Gameplay module changes have explicit edges to their parity adapters and to the
 ## Score, statistics and recipient groups
 
 Use `cargo xtask test-group score`, `notifications`, `stat-slots`, `stat-updates`, or `record-clear` for individual recovered contracts. `resolved-protected` and `resolved-mode10` exercise actual child composition; `health` follows shared dependencies for a broader focused regression. `gameplay` now covers seven Rust parity contracts, including score, method counters and cross-client clearing. Explicit module edges also refresh the impulse-owned scoped package test-count metadata. The registry integration test verifies those edges. Continue focused checks before each task commit and one `test-full --since <batch-base>` run after ten commits. See the [score/statistics batch](research/QVM_SCORE_STATS_RUST_BATCH.md) for fixture and native boundaries.
+
+## Totals, reporting and ranking setup groups
+
+Focused groups now include `stat-totals`, `stat-ratios`, `team-counters`, `recent-awards`, `recipient-single`, `recipient-pair` and `ranking-setup`. Recipient groups cover numeric source body boundaries with explicit text/native stand-ins. `gameplay` runs ten Rust parity adapters and scoped gameplay package tests, including totals/ratios, recent awards and recipient projection. Explicit module edges and registry integration tests also refresh the package test-count metadata. Continue focused checks before each commit and one full-suite run after ten commits. See the [reporting batch](research/QVM_REPORTING_RUST_BATCH.md) for evidence limits.

docs/research/QVM_REPORTING_RUST_BATCH.md

@@ -0,0 +1,43 @@
+# Totals, reporting and ranking setup batch
+
+RE-758–767 continues from `27a7f96f` with ten independently committed tasks. The objective remains complete Rust/Bevy/Solari gameplay on macOS and Linux. This batch advances bounded QVM contracts and three Rust simulation primitives; it does not establish original executable parity or a playable runtime.
+
+| Task | Scope | Evidence |
+| --- | --- | --- |
+| RE-758 | Complete statistic total functions and20-slot field inclusion | [Totals](QVM_STAT_TOTALS.md) |
+| RE-759 | Complete divisor and normalized ratio publication with actual totals | [Ratios](QVM_STAT_RATIOS.md) |
+| RE-760 | Complete same-team pair counters and participant gates | [Team counters](QVM_TEAM_COUNTERS.md) |
+| RE-761 | Complete recent-record awards with timestamp/count/index64 aliases | [Awards](QVM_RECENT_AWARDS.md) |
+| RE-762 | Single recipient numeric body, gates and cached ping | [Single payload](QVM_RECIPIENT_SINGLE.md) |
+| RE-763 | Pair recipient numeric body, gates and cache aliases | [Pair payload](QVM_RECIPIENT_PAIR.md) |
+| RE-764 | Ranking reset/client scan through the sorting boundary | [Ranking setup](QVM_RANKING_SETUP.md) |
+| RE-765 | Rust totals, divisor and ratio primitives | [Rust totals](RUST_STAT_TOTALS.md) |
+| RE-766 | Rust recent-record awards and log ID intents | [Rust awards](RUST_RECENT_AWARDS.md) |
+| RE-767 | Rust recipient gates, numeric fields and cache effects | [Rust payload](RUST_RECIPIENT_PAYLOAD.md) |
+
+The totals read20 slot counters although method classification currently maps19 slots. First legacy totals exclude indices13/17; second totals exclude17. Addition wraps. The divisor scans down from the signed maximum: mixed signs can still reduce, but a zero input or nonpositive signed maximum returns1. Rust uses Euclid with the same guards. Ratio publication preserves source float32 conversion/division order and zero-denominator behavior.
+
+Recent-record awards accept index64 and preserve the alias between pair64 count and the3032 award word. Eligibility uses count at least40 and wrapped signed age at most30000, with no added nonnegative-age condition. Only64 recipient slots are scanned. Logs remain returned/captured intents rather than executed formatting.
+
+Recipient numeric bodies cap ping above999, retain negative ping, optionally reuse follow-cache data and apply the entity-bit publication override after cache handling. Status precedence, wrapped elapsed minutes, signed packed fields and class bounds0..20 are independently checked. Pair aliases are processed in source order. Initial unaligned literal-copy setup is excluded from the source body boundaries; strlen lengths are supplied and copy/format/send effects remain captured. These are numeric payload/cache contracts, not serialized-text or networking parity.
+
+Ranking5864 setup resets and counts clients, stores a scan-order enrolled list and the first two active slots, and stops before sorting35095/comparator5441. Sort ordering, tie handling, rank assignment and publication remain open. The first two active slots include entity-bit8 clients; human team counts exclude them.
+
+## Validation cadence
+
+Focused `cargo xtask test-group` checks precede each task commit. Selected reports regenerate twice, followed by affected tests, storage/link checks and whitespace guards. Single-recipient regression also checks compatibility of the shared pair helper. Rust gameplay groups run scoped package tests and ten parity reports. After commit ten, the single `cargo xtask test-full --since 27a7f96f` run passed1473 Python tests and80 Rust tests (10 assets,42 gameplay,28 xtask). Seventeen affected report producers regenerated twice byte-identically; storage, documentation links across326 files and whitespace guards passed. Generated outputs matched committed reports and the working tree was clean. This documentation-only result is recorded by amending the tenth commit.
+
+## Remaining limits and next tasks
+
+1. Recover sorting35095/comparator5441 and the remaining5864 ranking assignment/publication branches.
+2. Execute the recipient literal/copy/strlen/formatting boundaries with original text, and verify exact serialized command payloads.
+3. Recover283622 statistic leaderboard selection and its284555/284610 dependencies.
+4. Compose actual279720/279586/285227 and recipient numeric bodies into the existing complete stat/lifecycle callers while retaining unresolved boundaries.
+5. Compose actual protected completion from full health mutation, including null attacker and original low-page reads.
+6. Extend actual health/contact/shared293732 and successful295018 pellet aggregation through all recovered lifecycle state.
+7. Establish owned Rust counters, events, record lifetimes, recipient identities, inventory resets and obituary serialization in a runtime.
+8. Continue original native executable/DLL/library parity and loader ownership.
+9. Connect assets, simulation and world collision to macOS/Linux Bevy runtime validation.
+10. Port rendering/materials to Solari and verify interactive full-game acceptance on both platforms.
+
+RE-757 remains partially advanced. Native, Linux, rendering and full gameplay acceptance remain open.

docs/research/README.md

@@ -894,3 +894,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-766: Rust recent record awards timestamp gates and alias storage](RUST_RECENT_AWARDS.md).
+
+
+[RE-767: Rust recipient numeric projection and reporting batch handoff](RUST_RECIPIENT_PAYLOAD.md).

docs/research/RUST_RECIPIENT_PAYLOAD.md

@@ -0,0 +1,7 @@
+# Rust recipient numeric projection and reporting batch handoff
+
+RE-767. Reproduce with `python3 scripts/analyze_rust_recipient_payload.py`; validate with `cargo xtask test-group gameplay`. See the [machine report](rust-recipient-payload.json).
+
+Added typed presence/client/numeric payload contracts, source-order cache projection and pointer/client/in-use gates. Four Rust unit tests cover cache freezing/override, negative ping, status/class/connection rules, wrapped time, signed packed fields and all participant gates/alias order. Registry integration verifies all three new module selections. See the [batch handoff](QVM_REPORTING_RUST_BATCH.md) for literal-copy/serialization/native boundaries and next tasks.
+
+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": 38,
+  "rust_unit_tests": 42,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_recipient_payload.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+"""Rust numeric recipient projection/cache/gates against both QVM bodies."""
+import hashlib,json
+from pathlib import Path
+from rust_lifecycle_support import binary,result
+from qvm_recipient_payload_support import FIELDS
+from analyze_qvm import write_json
+KEYS=['score','ping','minutes','status','deaths','field3692','packed_low','packed_high','field308','awards','class']
+
+def presence(present,active,client):return int(bool(present))+2*int(bool(active))+4*int(bool(client))
+
+def main():
+    b=binary();paths=[Path('docs/research/qvm-recipient-single.json'),Path('docs/research/qvm-recipient-pair.json')];sources={};rows=[]
+    for pair,path in enumerate(paths):
+        data=path.read_bytes();sources[str(path)]=hashlib.sha256(data).hexdigest()
+        for p in json.loads(data)['probes']:
+            a=p['input'];first=presence(not a.get('null'),a.get('active',1),a.get('client',True));recipient=presence(not a.get('null_recipient'),a.get('recipient_active',1),a.get('recipient_client',True));second=presence(not a.get('null_second'),a.get('second_active',1),a.get('second_client',True));ps=[first,second,recipient] if pair else [first,recipient,7];args=[pair,int(a.get('self',False)),a.get('now',121000),*ps,a.get('entity_flags',0),a.get('second_entity_flags',0),*[c[str(o)] for c in p['initial_clients'] for o in FIELDS]];formats=[r for r in p['requests'] if r['target']==70458];payloads=[]
+            if formats:
+                for offset in ([16,68] if pair else [16]):payloads.append({key:formats[0]['arguments'][str(offset+4*j)] for j,key in enumerate(KEYS)})
+            expected={'payloads':payloads,'cached':[c['6160'] for c in p['final_clients']]};rows.append({'pair':bool(pair),'input':a,'initial_clients':p['initial_clients'],'source':expected,'rust':result(b,'payload',args)})
+    write_json(Path('docs/research/rust-recipient-payload.json'),{'source_reports':sources,'probes':rows,'limits':'Rust numeric participant gates, payload fields and ping-cache effects match72 single and73 pair source fixtures. Alias order preserved. QVM literal-copy setup and actual string/copy/format/send effects remain excluded/captured; no serialized/network/native/platform parity.'})
+if __name__=='__main__':main()

scripts/test_rust_recipient_payload.py

@@ -0,0 +1,19 @@
+import hashlib,json,unittest
+from pathlib import Path
+from test_qvm_recipient_single import numeric
+class RustRecipientPayloadTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):cls.r=json.loads(Path('docs/research/rust-recipient-payload.json').read_text())
+    def test_all_source_numeric_fields_cache_and_presence_gates(self):
+        self.assertEqual(len(self.r['probes']),145)
+        for p in self.r['probes']:self.assertEqual(p['rust'],p['source'],(p['pair'],p['input']))
+    def test_independent_active_projection_and_alias_order(self):
+        for p in self.r['probes']:
+            if not p['source']['payloads']:continue
+            a=p['input'];clients=[dict(c) for c in p['initial_clients']];fields=[]
+            for j in range(2 if p['pair'] else 1):
+                selected=0 if j==0 or a.get('self') else 1;cache,row=numeric(clients[selected],a.get('entity_flags' if selected==0 else 'second_entity_flags',0),a.get('now',121000));clients[selected]['6160']=cache&0xffffffff;fields.append(row)
+            self.assertEqual(p['rust'],{'payloads':fields,'cached':[c['6160'] for c in clients]})
+    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

@@ -1313,3 +1313,13 @@ edge	crates/urt-gameplay/src/recent_awards.rs	scripts/analyze_rust_health_impuls
 group	gameplay	scripts/analyze_rust_recent_awards.py
 report	scripts/analyze_rust_recent_awards.py	docs/research/rust-recent-awards.json
 edge	docs/research/rust-recent-awards.json	scripts/test_rust_recent_awards.py
+edge	Cargo.toml	scripts/analyze_rust_recipient_payload.py
+edge	Cargo.lock	scripts/analyze_rust_recipient_payload.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_recipient_payload.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_recipient_payload.py
+edge	crates/urt-gameplay/src/recipient_payload.rs	scripts/analyze_rust_recipient_payload.py
+edge	crates/urt-gameplay/src/bin/urt-lifecycle.rs	scripts/analyze_rust_recipient_payload.py
+edge	crates/urt-gameplay/src/recipient_payload.rs	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_recipient_payload.py
+report	scripts/analyze_rust_recipient_payload.py	docs/research/rust-recipient-payload.json
+edge	docs/research/rust-recipient-payload.json	scripts/test_rust_recipient_payload.py

xtask/src/lib.rs

@@ -1037,6 +1037,9 @@ mod integration_tests {
             ("score", "score_update"),
             ("method_stats", "method_stats"),
             ("record_clear", "cross_client_clear"),
+            ("stat_totals", "stat_totals"),
+            ("recent_awards", "recent_awards"),
+            ("recipient_payload", "recipient_payload"),
         ] {
             let selected = plan(
                 &g,