gameplay: port method counter updates

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

@@ -105,6 +105,68 @@ fn run() -> Result<(), String> {
                 refresh
             );
         }
+        "classify" if w.len() == 1 => {
+            println!(
+                "{{\"slot\":{}}}",
+                urt_gameplay::method_stats::slot(w[0] as i32)
+                    .map(i32::from)
+                    .unwrap_or(-1)
+            );
+        }
+        "stats" if w.len() == 4 && w[1] <= 1 && w[3] <= 1 => {
+            use std::collections::BTreeMap;
+            use urt_gameplay::method_stats::{Side, apply, plan};
+            let p = plan(w[0] as i32, w[1] != 0, w[3] != 0);
+            let mut actor: BTreeMap<u32, u32> = p
+                .increments
+                .iter()
+                .filter(|(s, _)| *s == Side::Actor)
+                .map(|(_, o)| (*o, w[2]))
+                .collect();
+            let mut victim: BTreeMap<u32, u32> = p
+                .increments
+                .iter()
+                .filter(|(s, _)| *s == Side::Victim)
+                .map(|(_, o)| (*o, w[2]))
+                .collect();
+            let p = apply(w[0] as i32, w[1] != 0, w[3] != 0, &mut actor, &mut victim)
+                .map_err(|e| format!("unsupported input: {e:?}"))?;
+            let mut increments = p.increments;
+            increments.sort();
+            let changes: Vec<_> = increments
+                .iter()
+                .map(|(side, o)| {
+                    format!(
+                        "{{\"client\":\"{}\",\"offset\":{},\"before\":{},\"after\":{}}}",
+                        if *side == Side::Actor {
+                            "actor"
+                        } else {
+                            "victim"
+                        },
+                        o,
+                        w[2],
+                        if *side == Side::Actor {
+                            actor[o]
+                        } else {
+                            victim[o]
+                        }
+                    )
+                })
+                .collect();
+            let mut calls = vec![];
+            if p.aggregate_pair {
+                calls.push(279720);
+            }
+            if p.report {
+                calls.extend([279586, 279586, 285227, 283622]);
+            }
+            let calls: Vec<_> = calls.iter().map(|c| c.to_string()).collect();
+            println!(
+                "{{\"changes\":[{}],\"calls\":[{}]}}",
+                changes.join(","),
+                calls.join(",")
+            );
+        }
         _ => return Err("unsupported contract or arguments".into()),
     }
     Ok(())

crates/urt-gameplay/src/lib.rs

@@ -146,6 +146,7 @@ mod tests {
 }
 
 pub mod intercept_animation;
+pub mod method_stats;
 pub mod mode10;
 pub mod protected;
 pub mod score;

crates/urt-gameplay/src/method_stats.rs

@@ -0,0 +1,167 @@
+//! Numeric278733/278834 counters; aggregation/reporting remains caller work.
+use std::collections::BTreeMap;
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Side {
+    Victim,
+    Actor,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Plan {
+    pub increments: Vec<(Side, u32)>,
+    pub aggregate_pair: bool,
+    pub report: bool,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum StatsError {
+    MissingCounter,
+}
+pub fn slot(method: i32) -> Option<u8> {
+    Some(match method {
+        14 => 9,
+        15 => 8,
+        16 => 11,
+        17 => 5,
+        18 => 4,
+        19 => 2,
+        20 => 0,
+        21 => 7,
+        28 => 6,
+        30 => 1,
+        36 => 10,
+        38 => 3,
+        39 => 12,
+        40 => 13,
+        41 => 14,
+        42 => 15,
+        43 => 16,
+        44 => 17,
+        45 => 18,
+        _ => return None,
+    })
+}
+/// All participants are existing clients with valid source IDs. Self aliases
+/// resolve to the actor's storage; an absent actor exits before any requests.
+pub fn plan(method: i32, self_hit: bool, actor_absent: bool) -> Plan {
+    use Side::{Actor, Victim};
+    let mut result = Plan {
+        increments: vec![],
+        aggregate_pair: false,
+        report: !actor_absent,
+    };
+    if actor_absent {
+        return result;
+    }
+    let victim = if self_hit { Actor } else { Victim };
+    if let Some(slot) = slot(method) {
+        result.increments = vec![
+            (Actor, 916 + 76 * u32::from(slot)),
+            (victim, 920 + 76 * u32::from(slot)),
+        ];
+        result.aggregate_pair = true;
+        return result;
+    }
+    let single = match method {
+        0..=5 | 8 | 9 => Some(2512),
+        6 => Some(2488),
+        7 => Some(2492),
+        31 => Some(2504),
+        32 | 33 | 35 => Some(2508),
+        47 => Some(2496),
+        22 if self_hit => Some(2460),
+        25 if self_hit => Some(2452),
+        _ => None,
+    };
+    if let Some(offset) = single {
+        result.increments.push((victim, offset));
+        return result;
+    }
+    let pair = match method {
+        12 => Some((2396, 2468)),
+        13 => Some((2400, 2472)),
+        22 => Some((2384, 2456)),
+        23 => Some((2408, 2480)),
+        24 => Some((2404, 2476)),
+        25 => Some((2376, 2448)),
+        34 => Some((2428, 2500)),
+        37 => Some((2392, 2464)),
+        48 => Some((2412, 2484)),
+        _ => None,
+    };
+    if let Some((a, v)) = pair {
+        result.increments = vec![(Actor, a), (victim, v)];
+        result.aggregate_pair = method != 34;
+    }
+    result
+}
+/// Validate storage before mutation, then apply source wrapping increments.
+/// The returned plan describes reporting intent without executing callbacks.
+pub fn apply(
+    method: i32,
+    self_hit: bool,
+    actor_absent: bool,
+    actor: &mut BTreeMap<u32, u32>,
+    victim: &mut BTreeMap<u32, u32>,
+) -> Result<Plan, StatsError> {
+    let p = plan(method, self_hit, actor_absent);
+    for (side, offset) in &p.increments {
+        if !(if *side == Side::Actor {
+            &*actor
+        } else {
+            &*victim
+        })
+        .contains_key(offset)
+        {
+            return Err(StatsError::MissingCounter);
+        }
+    }
+    for (side, offset) in &p.increments {
+        let counters = if *side == Side::Actor {
+            &mut *actor
+        } else {
+            &mut *victim
+        };
+        let v = counters.get_mut(offset).unwrap();
+        *v = v.wrapping_add(1);
+    }
+    Ok(p)
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn all_slots_and_invalid_signed_extremes() {
+        let slots: std::collections::BTreeSet<_> = (0..50).filter_map(slot).collect();
+        assert_eq!(slots, (0..19).collect());
+        assert_eq!(slot(i32::MIN), None);
+        assert_eq!(slot(i32::MAX), None);
+    }
+    #[test]
+    fn self_alias_and_fallback_exceptions() {
+        assert_eq!(plan(22, true, false).increments, vec![(Side::Actor, 2460)]);
+        assert_eq!(plan(25, true, false).increments, vec![(Side::Actor, 2452)]);
+        assert!(!plan(34, false, false).aggregate_pair);
+        assert!(plan(20, false, false).aggregate_pair);
+    }
+    #[test]
+    fn apply_wraps_and_keeps_other_counters() {
+        let mut actor = BTreeMap::from([(916, u32::MAX), (999, 17)]);
+        let mut victim = BTreeMap::from([(920, 3)]);
+        apply(20, false, false, &mut actor, &mut victim).unwrap();
+        assert_eq!(actor, BTreeMap::from([(916, 0), (999, 17)]));
+        assert_eq!(victim[&920], 4);
+    }
+    #[test]
+    fn absent_actor_and_missing_storage_do_not_partially_mutate() {
+        let mut a = BTreeMap::from([(916, 4)]);
+        let mut v = BTreeMap::new();
+        assert_eq!(
+            apply(20, false, false, &mut a, &mut v),
+            Err(StatsError::MissingCounter)
+        );
+        assert_eq!(a[&916], 4);
+        let p = apply(20, false, true, &mut a, &mut v).unwrap();
+        assert!(!p.report);
+        assert!(p.increments.is_empty());
+        assert_eq!(a[&916], 4);
+    }
+}

docs/ASSET_PIPELINE_TODO.md

@@ -925,3 +925,6 @@ Research progress: RE-753 [report](research/QVM_MODE10_RESOLVED.md); original as
 
 
 Research progress: RE-754 [report](research/RUST_SCORE_UPDATE.md); original assets unchanged.
+
+
+Research progress: RE-755 [report](research/RUST_METHOD_STATS.md); original assets unchanged.

docs/FINDINGS.md

@@ -1271,3 +1271,6 @@ RE-725–734 batch: [health, contact and Rust impulse findings](research/QVM_HEA
 
 
 **RE-754 — Rust wrapping score primitive and ranking request contract:** Rust player/team score updates and ranking-request decisions match67 source fixtures, with explicit active team-index rejection. [Evidence](research/RUST_SCORE_UPDATE.md).
+
+
+**RE-755 — Rust method classification wrapping counters and reporting intent:** Rust classification and method-counter mutation now match53 mapping and205 counter fixtures, including self aliases and wrapping increments. [Evidence](research/RUST_METHOD_STATS.md).

docs/PROVISIONAL_TODO.md

@@ -1263,3 +1263,6 @@ Research progress: RE-753 [report](research/QVM_MODE10_RESOLVED.md); full native
 
 
 Research progress: RE-754 [report](research/RUST_SCORE_UPDATE.md); full native/platform/game scope remains open.
+
+
+Research progress: RE-755 [report](research/RUST_METHOD_STATS.md); full native/platform/game scope remains open.

docs/RESEARCH_LEDGER.md

@@ -1422,3 +1422,8 @@ Additional RE-753 shared-health regression: `cargo xtask test-group health` pass
 ## 2026-10-21 — RE-754 Rust wrapping score primitive and ranking request contract
 
 Rust player/team score updates and ranking-request decisions match67 source fixtures, with explicit active team-index rejection. Focused `cargo xtask test-group gameplay` passes (16 Python tests); selected reports regenerate twice byte-identically, with storage, links and whitespace guards. New report: 33247 bytes. Full-suite validation is deferred to the tenth batch commit. Rust gameplay crate changed; focused gameplay regenerates all five parity contracts and scoped package tests, without requesting workspace/full-suite tests.
+
+
+## 2026-10-21 — RE-755 Rust method classification wrapping counters and reporting intent
+
+Rust classification and method-counter mutation now match53 mapping and205 counter fixtures, including self aliases and wrapping increments. Focused `cargo xtask test-group gameplay` passes (19 Python tests); selected reports regenerate twice byte-identically, with storage, links and whitespace guards. New report: 172131 bytes. Full-suite validation is deferred to the tenth batch commit. Rust gameplay crate changed; focused gameplay regenerates six parity contracts and scoped gameplay tests. No workspace/full-suite run before commit ten.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1306,3 +1306,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-754 Rust wrapping score primitive and ranking request contract ([report](research/RUST_SCORE_UPDATE.md)).
+
+
+- [x] RE-755 Rust method classification wrapping counters and reporting intent ([report](research/RUST_METHOD_STATS.md)).

docs/research/README.md

@@ -861,3 +861,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-754: Rust wrapping score primitive and ranking request contract](RUST_SCORE_UPDATE.md).
+
+
+[RE-755: Rust method classification wrapping counters and reporting intent](RUST_METHOD_STATS.md).

docs/research/RUST_METHOD_STATS.md

@@ -0,0 +1,7 @@
+# Rust method classification wrapping counters and reporting intent
+
+RE-755. Reproduce with `python3 scripts/analyze_rust_method_stats.py`; validate with `cargo xtask test-group gameplay`. See the [machine report](rust-method-stats.json).
+
+Added typed counter ownership, source method mapping, numeric offset plans and transactional storage validation before wrapping mutation. Four Rust unit tests cover complete slot range, fallback self exceptions, untouched counters, overflow, absent actor and missing storage. The adapter checks exact changes and reporting intent against source; aggregate/report callbacks and numeric field-to-runtime data migration 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": 22,
+  "rust_unit_tests": 26,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_method_stats.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+"""Rust method classification and wrapping counter plans against source fixtures."""
+import hashlib,json
+from pathlib import Path
+from rust_lifecycle_support import binary,result
+from analyze_qvm import write_json
+
+def main():
+    b=binary();path=Path('docs/research/qvm-method-stat-updates.json');data=path.read_bytes();rows=[]
+    for p in json.loads(data)['probes']:
+        a=p['input'];args=[a['method'],int(a['self']),a['initial'],int(a.get('actor_absent',False))];e={'changes':p['changes'],'calls':[c['target'] for c in p['requests']]};rows.append({'input':a,'source':e,'rust':result(b,'stats',args)})
+    slots=Path('docs/research/qvm-method-stat-slots.json');raw=slots.read_bytes();classification=[{'method':p['method'],'source_slot':p['slot'],'rust':result(b,'classify',[p['method']])} for p in json.loads(raw)['probes']]
+    write_json(Path('docs/research/rust-method-stats.json'),{'source_reports':{str(path):hashlib.sha256(data).hexdigest(),str(slots):hashlib.sha256(raw).hexdigest()},'probes':rows,'classification':classification,'limits':'Rust numeric classification matches53 source fixtures; counter mutation/reporting intent matches205 source fixtures including self alias and wrapping. Existing actor/victim clients and valid IDs required. Actual callback/report/aggregation effects and platform/native parity remain open. Missing counter storage rejects before mutation.'})
+if __name__=='__main__':main()

scripts/test_rust_method_stats.py

@@ -0,0 +1,17 @@
+import hashlib,json,unittest
+from pathlib import Path
+from test_qvm_method_stat_updates import expected
+from test_qvm_method_stat_slots import SLOTS
+class RustMethodStatsTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):cls.r=json.loads(Path('docs/research/rust-method-stats.json').read_text())
+    def test_all_source_counter_mutations_and_request_intents(self):
+        self.assertEqual(len(self.r['probes']),205)
+        for p in self.r['probes']:
+            self.assertEqual(p['rust'],p['source'],p['input']);changes,calls=expected(p['input']);self.assertEqual(p['rust'],{'changes':changes,'calls':calls})
+    def test_source_classification_and_independent_mapping(self):
+        self.assertEqual(len(self.r['classification']),53)
+        for p in self.r['classification']:self.assertEqual(p['rust']['slot'],p['source_slot']);self.assertEqual(p['source_slot'],SLOTS.get(p['method'],-1))
+    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

@@ -1252,3 +1252,13 @@ edge	crates/urt-gameplay/src/score.rs	scripts/analyze_rust_health_impulse.py
 group	gameplay	scripts/analyze_rust_score_update.py
 report	scripts/analyze_rust_score_update.py	docs/research/rust-score-update.json
 edge	docs/research/rust-score-update.json	scripts/test_rust_score_update.py
+edge	Cargo.toml	scripts/analyze_rust_method_stats.py
+edge	Cargo.lock	scripts/analyze_rust_method_stats.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_method_stats.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_method_stats.py
+edge	crates/urt-gameplay/src/method_stats.rs	scripts/analyze_rust_method_stats.py
+edge	crates/urt-gameplay/src/bin/urt-lifecycle.rs	scripts/analyze_rust_method_stats.py
+edge	crates/urt-gameplay/src/method_stats.rs	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_method_stats.py
+report	scripts/analyze_rust_method_stats.py	docs/research/rust-method-stats.json
+edge	docs/research/rust-method-stats.json	scripts/test_rust_method_stats.py