gameplay: port recovered byte formatter

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

@@ -394,6 +394,63 @@ fn run() -> Result<(), String> {
                 second.cached_ping as u32
             );
         }
+        "qvm-format" if w.len() >= 2 && w[0] <= 4096 && w[1] <= 64 => {
+            let len = w[0] as usize;
+            let n = w[1] as usize;
+            if w.len() < 2 + len {
+                return Err("missing format".into());
+            }
+            let bytes = |v: &[u32]| -> Result<Vec<u8>, String> {
+                v.iter()
+                    .map(|v| u8::try_from(*v).map_err(|_| "invalid byte".into()))
+                    .collect()
+            };
+            let template = bytes(&w[2..2 + len])?;
+            let mut pos = 2 + len;
+            let mut storage = vec![];
+            let mut tags = vec![];
+            for _ in 0..n {
+                let tag = *w.get(pos).ok_or("missing argument")?;
+                pos += 1;
+                match tag {
+                    0 => {
+                        let v = *w.get(pos).ok_or("missing word")?;
+                        pos += 1;
+                        tags.push((0, v, 0));
+                    }
+                    1 => {
+                        let len = *w.get(pos).ok_or("missing byte length")? as usize;
+                        pos += 1;
+                        if len > 32768 || w.len() - pos < len {
+                            return Err("invalid argument length".into());
+                        }
+                        storage.push(bytes(&w[pos..pos + len])?);
+                        pos += len;
+                        tags.push((1, 0, storage.len() - 1));
+                    }
+                    2 => tags.push((2, 0, 0)),
+                    _ => return Err("invalid argument type".into()),
+                }
+            }
+            if pos != w.len() {
+                return Err("trailing format words".into());
+            }
+            let args: Vec<_> = tags
+                .iter()
+                .map(|(t, v, i)| match t {
+                    0 => urt_gameplay::qvm_format::Argument::Word(*v as i32),
+                    1 => urt_gameplay::qvm_format::Argument::Bytes(Some(&storage[*i])),
+                    _ => urt_gameplay::qvm_format::Argument::Bytes(None),
+                })
+                .collect();
+            let out = urt_gameplay::qvm_format::render(&template, &args)
+                .map_err(|e| format!("unsupported input: {e:?}"))?;
+            println!(
+                "{{\"cstring_hex\":\"{}\",\"count\":{}}}",
+                out.iter().map(|v| format!("{v:02x}")).collect::<String>(),
+                out.len() - 1
+            );
+        }
         "scoreboard-stream" if w.len() >= 6 && w[4] <= 64 && w[5] <= 64 => {
             let n = w[4] as usize;
             let count = w[5] as usize;

crates/urt-gameplay/src/lib.rs

@@ -165,3 +165,5 @@ pub mod ranking_population;
 pub mod scoreboard;
 
 pub mod scoreboard_wire;
+
+pub mod qvm_format;

crates/urt-gameplay/src/qvm_format.rs

@@ -0,0 +1,183 @@
+//! Recovered37914 integer/string/character subset. This is not host printf.
+#[derive(Clone, Copy, Debug)]
+pub enum Argument<'a> {
+    Word(i32),
+    Bytes(Option<&'a [u8]>),
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Error {
+    Malformed,
+    Argument,
+    Limit,
+    PaddingDomain,
+    UnsupportedFloat,
+}
+/// Preserve original wrapping-negation/remainder behavior, including INT_MIN.
+pub fn decimal(value: i32) -> Vec<u8> {
+    let mut x = if value < 0 {
+        value.wrapping_neg()
+    } else {
+        value
+    };
+    let mut digits = vec![];
+    loop {
+        digits.push((48 + x % 10) as u8);
+        x /= 10;
+        if x == 0 {
+            break;
+        }
+    }
+    if value < 0 {
+        digits.push(b'-');
+    }
+    digits.reverse();
+    digits
+}
+fn append(out: &mut Vec<u8>, data: &[u8]) -> Result<(), Error> {
+    if out.len() + data.len() > 32768 {
+        return Err(Error::Limit);
+    }
+    out.extend_from_slice(data);
+    Ok(())
+}
+/// Flags/width/precision follow source dispatch. Strings always trail-pad;
+/// integer precision is ignored; unknown conversions emit a word's low byte.
+pub fn render(template: &[u8], arguments: &[Argument<'_>]) -> Result<Vec<u8>, Error> {
+    let end = template
+        .iter()
+        .position(|b| *b == 0)
+        .unwrap_or(template.len());
+    let t = &template[..end];
+    let mut out = vec![];
+    let mut i = 0;
+    let mut arg = 0;
+    while i < t.len() {
+        if t[i] != b'%' {
+            append(&mut out, &t[i..i + 1])?;
+            i += 1;
+            continue;
+        }
+        i += 1;
+        let mut left = false;
+        let mut zero = false;
+        while i < t.len() && [b'-', b'0'].contains(&t[i]) {
+            left |= t[i] == b'-';
+            zero |= t[i] == b'0';
+            i += 1;
+        }
+        let mut width = 0usize;
+        while i < t.len() && t[i].is_ascii_digit() {
+            width = width
+                .checked_mul(10)
+                .and_then(|v| v.checked_add((t[i] - b'0') as usize))
+                .ok_or(Error::Limit)?;
+            if width > 4096 {
+                return Err(Error::Limit);
+            }
+            i += 1;
+        }
+        let mut precision = None;
+        if i < t.len() && t[i] == b'.' {
+            i += 1;
+            let mut n = 0usize;
+            while i < t.len() && t[i].is_ascii_digit() {
+                n = n
+                    .checked_mul(10)
+                    .and_then(|v| v.checked_add((t[i] - b'0') as usize))
+                    .ok_or(Error::Limit)?;
+                if n > 4096 {
+                    return Err(Error::Limit);
+                }
+                i += 1;
+            }
+            precision = Some(n);
+        }
+        let spec = *t.get(i).ok_or(Error::Malformed)?;
+        i += 1;
+        if spec == b'%' {
+            append(&mut out, b"%")?;
+            continue;
+        }
+        if spec == b'f' {
+            return Err(Error::UnsupportedFloat);
+        }
+        let value = arguments.get(arg).ok_or(Error::Argument)?;
+        arg += 1;
+        if [b'd', b'i', b'p'].contains(&spec) {
+            let Argument::Word(value) = value else {
+                return Err(Error::Argument);
+            };
+            let digits = decimal(*value);
+            if left && width < digits.len() {
+                return Err(Error::PaddingDomain);
+            }
+            let padding = vec![if zero { b'0' } else { b' ' }; width.saturating_sub(digits.len())];
+            if !left {
+                append(&mut out, &padding)?;
+            }
+            append(&mut out, &digits)?;
+            if left {
+                append(&mut out, &padding)?;
+            }
+        } else if spec == b's' {
+            let Argument::Bytes(value) = value else {
+                return Err(Error::Argument);
+            };
+            let (bytes, precision) = match value {
+                None => (b"(null)".as_slice(), None),
+                Some(v) => (*v, precision),
+            };
+            let length = bytes.iter().position(|b| *b == 0).unwrap_or(bytes.len());
+            let length = precision.map_or(length, |n| n.min(length));
+            append(&mut out, &bytes[..length])?;
+            append(&mut out, &vec![b' '; width.saturating_sub(length)])?;
+        } else {
+            let Argument::Word(value) = value else {
+                return Err(Error::Argument);
+            };
+            append(&mut out, &[*value as u8])?;
+        }
+    }
+    out.push(0);
+    Ok(out)
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn source_padding_precision_and_unknown_dispatch() {
+        assert_eq!(
+            render(
+                b"%05i/%8.2s/%q",
+                &[
+                    Argument::Word(-12),
+                    Argument::Bytes(Some(b"ABCDE")),
+                    Argument::Word(321)
+                ]
+            )
+            .unwrap(),
+            b"00-12/AB      /A\0"
+        );
+        assert_eq!(
+            render(b"%.0s", &[Argument::Bytes(None)]).unwrap(),
+            b"(null)\0"
+        );
+    }
+    #[test]
+    fn wrapping_minimum_and_embedded_character_nul() {
+        assert_ne!(decimal(i32::MIN), b"-2147483648");
+        assert_eq!(render(b"%cX", &[Argument::Word(0)]).unwrap(), [0, 88, 0]);
+        assert_eq!(decimal(-1), b"-1");
+    }
+    #[test]
+    fn unsupported_or_unsafe_domains_reject() {
+        assert_eq!(
+            render(b"%-1i", &[Argument::Word(123)]),
+            Err(Error::PaddingDomain)
+        );
+        assert_eq!(render(b"%", &[]), Err(Error::Malformed));
+        assert_eq!(render(b"%f", &[]), Err(Error::UnsupportedFloat));
+        assert_eq!(render(b"%s", &[Argument::Word(0)]), Err(Error::Argument));
+        assert_eq!(render(b"%99999i", &[Argument::Word(1)]), Err(Error::Limit));
+    }
+}

docs/FINDINGS.md

@@ -1448,3 +1448,6 @@ RE-802–811 adds opt-in coherent memory, original string/scoreboard control flo
 
 
 **RE-816:** Replacing the standard-decimal boundary with actual37914 exposes signed-minimum byte differences; prior modeled results remain explicitly separate. [Evidence](research/QVM_SCOREBOARD_FORMATTER.md).
+
+
+**RE-817:** Rust now matches actual37914 rather than host printf for decimal/string/character dispatch, including signed-minimum, null precision and padding quirks. [Evidence](research/RUST_QVM_FORMAT.md).

docs/PROVISIONAL_TODO.md

@@ -1458,3 +1458,6 @@ RE-815: 37914 now executes original dispatch tables and integer/string children;
 
 
 RE-816: Replacing the standard-decimal boundary with actual37914 exposes signed-minimum byte differences; prior modeled results remain explicitly separate. Full runtime completion remains open. [Evidence](research/QVM_SCOREBOARD_FORMATTER.md).
+
+
+RE-817: Rust now matches actual37914 rather than host printf for decimal/string/character dispatch, including signed-minimum, null precision and padding quirks. Full runtime completion remains open. [Evidence](research/RUST_QVM_FORMAT.md).

docs/RESEARCH_LEDGER.md

@@ -1748,3 +1748,8 @@ After exactly ten task commits from `744c236f`, the single `cargo xtask test-ful
 ## 2026-10-27 — RE-816 Scoreboard packets with actual original formatter execution
 
 Replacing the standard-decimal boundary with actual37914 exposes signed-minimum byte differences; prior modeled results remain explicitly separate. Focused `cargo xtask test-group scoreboard-formatter` passes (5 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-27 — RE-817 Rust recovered formatter subset with original byte quirks
+
+Rust now matches actual37914 rather than host printf for decimal/string/character dispatch, including signed-minimum, null precision and padding quirks. Focused `cargo xtask test-group rust-qvm-format` 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

@@ -1498,3 +1498,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-816 Scoreboard packets with actual original formatter execution ([evidence](research/QVM_SCOREBOARD_FORMATTER.md)).
+
+
+- [x] RE-817 Rust recovered formatter subset with original byte quirks ([evidence](research/RUST_QVM_FORMAT.md)).

docs/research/README.md

@@ -1038,3 +1038,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-816: Scoreboard packets with actual original formatter execution](QVM_SCOREBOARD_FORMATTER.md).
+
+
+[RE-817: Rust recovered formatter subset with original byte quirks](RUST_QVM_FORMAT.md).

docs/research/RUST_QVM_FORMAT.md

@@ -0,0 +1,7 @@
+# Rust recovered formatter subset with original byte quirks
+
+RE-817. Reproduce with `python3 scripts/analyze_rust_qvm_format.py`; focused validation: `cargo xtask test-group rust-qvm-format`. [Machine report](rust-qvm-format.json).
+
+A typed byte-oriented formatter reproduces55 original-QVM fixtures exactly. Unit tests cover negative zero padding, string trailing padding, ignored null precision, unknown conversion low bytes and embedded character NUL. Unsafe narrow-left padding, malformed arguments, float formatting and output/width limits reject explicitly. This stage leaves scoreboard packet integration to the next task.
+
+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": 71,
+  "rust_unit_tests": 74,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

docs/research/rust-qvm-format.json

@@ -0,0 +1,615 @@
+{
+  "limits": "Rust recovered37914 integer/string/character subset matches55 complete original-QVM cases, including signed minimum and nonstandard flags. Float, unsafe narrow-left padding, malformed/unknown varargs reject explicitly; no native host printf claim.",
+  "probes": [
+    {
+      "rust": {
+        "count": 11,
+        "cstring_hex": "2d2e2f2c292c282d2a2c2800"
+      },
+      "source": {
+        "count": 11,
+        "cstring_hex": "2d2e2f2c292c282d2a2c2800"
+      },
+      "template": "%i"
+    },
+    {
+      "rust": {
+        "count": 3,
+        "cstring_hex": "2d313200"
+      },
+      "source": {
+        "count": 3,
+        "cstring_hex": "2d313200"
+      },
+      "template": "%i"
+    },
+    {
+      "rust": {
+        "count": 1,
+        "cstring_hex": "3000"
+      },
+      "source": {
+        "count": 1,
+        "cstring_hex": "3000"
+      },
+      "template": "%i"
+    },
+    {
+      "rust": {
+        "count": 3,
+        "cstring_hex": "31323300"
+      },
+      "source": {
+        "count": 3,
+        "cstring_hex": "31323300"
+      },
+      "template": "%i"
+    },
+    {
+      "rust": {
+        "count": 10,
+        "cstring_hex": "3231343734383336343700"
+      },
+      "source": {
+        "count": 10,
+        "cstring_hex": "3231343734383336343700"
+      },
+      "template": "%i"
+    },
+    {
+      "rust": {
+        "count": 11,
+        "cstring_hex": "2d2e2f2c292c282d2a2c2800"
+      },
+      "source": {
+        "count": 11,
+        "cstring_hex": "2d2e2f2c292c282d2a2c2800"
+      },
+      "template": "%d"
+    },
+    {
+      "rust": {
+        "count": 3,
+        "cstring_hex": "2d313200"
+      },
+      "source": {
+        "count": 3,
+        "cstring_hex": "2d313200"
+      },
+      "template": "%d"
+    },
+    {
+      "rust": {
+        "count": 1,
+        "cstring_hex": "3000"
+      },
+      "source": {
+        "count": 1,
+        "cstring_hex": "3000"
+      },
+      "template": "%d"
+    },
+    {
+      "rust": {
+        "count": 3,
+        "cstring_hex": "31323300"
+      },
+      "source": {
+        "count": 3,
+        "cstring_hex": "31323300"
+      },
+      "template": "%d"
+    },
+    {
+      "rust": {
+        "count": 10,
+        "cstring_hex": "3231343734383336343700"
+      },
+      "source": {
+        "count": 10,
+        "cstring_hex": "3231343734383336343700"
+      },
+      "template": "%d"
+    },
+    {
+      "rust": {
+        "count": 11,
+        "cstring_hex": "2d2e2f2c292c282d2a2c2800"
+      },
+      "source": {
+        "count": 11,
+        "cstring_hex": "2d2e2f2c292c282d2a2c2800"
+      },
+      "template": "%p"
+    },
+    {
+      "rust": {
+        "count": 3,
+        "cstring_hex": "2d313200"
+      },
+      "source": {
+        "count": 3,
+        "cstring_hex": "2d313200"
+      },
+      "template": "%p"
+    },
+    {
+      "rust": {
+        "count": 1,
+        "cstring_hex": "3000"
+      },
+      "source": {
+        "count": 1,
+        "cstring_hex": "3000"
+      },
+      "template": "%p"
+    },
+    {
+      "rust": {
+        "count": 3,
+        "cstring_hex": "31323300"
+      },
+      "source": {
+        "count": 3,
+        "cstring_hex": "31323300"
+      },
+      "template": "%p"
+    },
+    {
+      "rust": {
+        "count": 10,
+        "cstring_hex": "3231343734383336343700"
+      },
+      "source": {
+        "count": 10,
+        "cstring_hex": "3231343734383336343700"
+      },
+      "template": "%p"
+    },
+    {
+      "rust": {
+        "count": 11,
+        "cstring_hex": "2d2e2f2c292c282d2a2c2800"
+      },
+      "source": {
+        "count": 11,
+        "cstring_hex": "2d2e2f2c292c282d2a2c2800"
+      },
+      "template": "%05i"
+    },
+    {
+      "rust": {
+        "count": 5,
+        "cstring_hex": "30302d313200"
+      },
+      "source": {
+        "count": 5,
+        "cstring_hex": "30302d313200"
+      },
+      "template": "%05i"
+    },
+    {
+      "rust": {
+        "count": 5,
+        "cstring_hex": "303030303000"
+      },
+      "source": {
+        "count": 5,
+        "cstring_hex": "303030303000"
+      },
+      "template": "%05i"
+    },
+    {
+      "rust": {
+        "count": 5,
+        "cstring_hex": "303031323300"
+      },
+      "source": {
+        "count": 5,
+        "cstring_hex": "303031323300"
+      },
+      "template": "%05i"
+    },
+    {
+      "rust": {
+        "count": 10,
+        "cstring_hex": "3231343734383336343700"
+      },
+      "source": {
+        "count": 10,
+        "cstring_hex": "3231343734383336343700"
+      },
+      "template": "%05i"
+    },
+    {
+      "rust": {
+        "count": 12,
+        "cstring_hex": "2d2e2f2c292c282d2a2c282000"
+      },
+      "source": {
+        "count": 12,
+        "cstring_hex": "2d2e2f2c292c282d2a2c282000"
+      },
+      "template": "%-12i"
+    },
+    {
+      "rust": {
+        "count": 12,
+        "cstring_hex": "2d313220202020202020202000"
+      },
+      "source": {
+        "count": 12,
+        "cstring_hex": "2d313220202020202020202000"
+      },
+      "template": "%-12i"
+    },
+    {
+      "rust": {
+        "count": 12,
+        "cstring_hex": "30202020202020202020202000"
+      },
+      "source": {
+        "count": 12,
+        "cstring_hex": "30202020202020202020202000"
+      },
+      "template": "%-12i"
+    },
+    {
+      "rust": {
+        "count": 12,
+        "cstring_hex": "31323320202020202020202000"
+      },
+      "source": {
+        "count": 12,
+        "cstring_hex": "31323320202020202020202000"
+      },
+      "template": "%-12i"
+    },
+    {
+      "rust": {
+        "count": 12,
+        "cstring_hex": "32313437343833363437202000"
+      },
+      "source": {
+        "count": 12,
+        "cstring_hex": "32313437343833363437202000"
+      },
+      "template": "%-12i"
+    },
+    {
+      "rust": {
+        "count": 11,
+        "cstring_hex": "2d2e2f2c292c282d2a2c2800"
+      },
+      "source": {
+        "count": 11,
+        "cstring_hex": "2d2e2f2c292c282d2a2c2800"
+      },
+      "template": "%.2i"
+    },
+    {
+      "rust": {
+        "count": 3,
+        "cstring_hex": "2d313200"
+      },
+      "source": {
+        "count": 3,
+        "cstring_hex": "2d313200"
+      },
+      "template": "%.2i"
+    },
+    {
+      "rust": {
+        "count": 1,
+        "cstring_hex": "3000"
+      },
+      "source": {
+        "count": 1,
+        "cstring_hex": "3000"
+      },
+      "template": "%.2i"
+    },
+    {
+      "rust": {
+        "count": 3,
+        "cstring_hex": "31323300"
+      },
+      "source": {
+        "count": 3,
+        "cstring_hex": "31323300"
+      },
+      "template": "%.2i"
+    },
+    {
+      "rust": {
+        "count": 10,
+        "cstring_hex": "3231343734383336343700"
+      },
+      "source": {
+        "count": 10,
+        "cstring_hex": "3231343734383336343700"
+      },
+      "template": "%.2i"
+    },
+    {
+      "rust": {
+        "count": 0,
+        "cstring_hex": "00"
+      },
+      "source": {
+        "count": 0,
+        "cstring_hex": "00"
+      },
+      "template": "%s"
+    },
+    {
+      "rust": {
+        "count": 1,
+        "cstring_hex": "4100"
+      },
+      "source": {
+        "count": 1,
+        "cstring_hex": "4100"
+      },
+      "template": "%s"
+    },
+    {
+      "rust": {
+        "count": 5,
+        "cstring_hex": "414243444500"
+      },
+      "source": {
+        "count": 5,
+        "cstring_hex": "414243444500"
+      },
+      "template": "%s"
+    },
+    {
+      "rust": {
+        "count": 3,
+        "cstring_hex": "fffefd00"
+      },
+      "source": {
+        "count": 3,
+        "cstring_hex": "fffefd00"
+      },
+      "template": "%s"
+    },
+    {
+      "rust": {
+        "count": 6,
+        "cstring_hex": "286e756c6c2900"
+      },
+      "source": {
+        "count": 6,
+        "cstring_hex": "286e756c6c2900"
+      },
+      "template": "%s"
+    },
+    {
+      "rust": {
+        "count": 12,
+        "cstring_hex": "20202020202020202020202000"
+      },
+      "source": {
+        "count": 12,
+        "cstring_hex": "20202020202020202020202000"
+      },
+      "template": "%12s"
+    },
+    {
+      "rust": {
+        "count": 12,
+        "cstring_hex": "41202020202020202020202000"
+      },
+      "source": {
+        "count": 12,
+        "cstring_hex": "41202020202020202020202000"
+      },
+      "template": "%12s"
+    },
+    {
+      "rust": {
+        "count": 12,
+        "cstring_hex": "41424344452020202020202000"
+      },
+      "source": {
+        "count": 12,
+        "cstring_hex": "41424344452020202020202000"
+      },
+      "template": "%12s"
+    },
+    {
+      "rust": {
+        "count": 12,
+        "cstring_hex": "fffefd20202020202020202000"
+      },
+      "source": {
+        "count": 12,
+        "cstring_hex": "fffefd20202020202020202000"
+      },
+      "template": "%12s"
+    },
+    {
+      "rust": {
+        "count": 12,
+        "cstring_hex": "286e756c6c2920202020202000"
+      },
+      "source": {
+        "count": 12,
+        "cstring_hex": "286e756c6c2920202020202000"
+      },
+      "template": "%12s"
+    },
+    {
+      "rust": {
+        "count": 0,
+        "cstring_hex": "00"
+      },
+      "source": {
+        "count": 0,
+        "cstring_hex": "00"
+      },
+      "template": "%.2s"
+    },
+    {
+      "rust": {
+        "count": 1,
+        "cstring_hex": "4100"
+      },
+      "source": {
+        "count": 1,
+        "cstring_hex": "4100"
+      },
+      "template": "%.2s"
+    },
+    {
+      "rust": {
+        "count": 2,
+        "cstring_hex": "414200"
+      },
+      "source": {
+        "count": 2,
+        "cstring_hex": "414200"
+      },
+      "template": "%.2s"
+    },
+    {
+      "rust": {
+        "count": 2,
+        "cstring_hex": "fffe00"
+      },
+      "source": {
+        "count": 2,
+        "cstring_hex": "fffe00"
+      },
+      "template": "%.2s"
+    },
+    {
+      "rust": {
+        "count": 6,
+        "cstring_hex": "286e756c6c2900"
+      },
+      "source": {
+        "count": 6,
+        "cstring_hex": "286e756c6c2900"
+      },
+      "template": "%.2s"
+    },
+    {
+      "rust": {
+        "count": 8,
+        "cstring_hex": "202020202020202000"
+      },
+      "source": {
+        "count": 8,
+        "cstring_hex": "202020202020202000"
+      },
+      "template": "%08.2s"
+    },
+    {
+      "rust": {
+        "count": 8,
+        "cstring_hex": "412020202020202000"
+      },
+      "source": {
+        "count": 8,
+        "cstring_hex": "412020202020202000"
+      },
+      "template": "%08.2s"
+    },
+    {
+      "rust": {
+        "count": 8,
+        "cstring_hex": "414220202020202000"
+      },
+      "source": {
+        "count": 8,
+        "cstring_hex": "414220202020202000"
+      },
+      "template": "%08.2s"
+    },
+    {
+      "rust": {
+        "count": 8,
+        "cstring_hex": "fffe20202020202000"
+      },
+      "source": {
+        "count": 8,
+        "cstring_hex": "fffe20202020202000"
+      },
+      "template": "%08.2s"
+    },
+    {
+      "rust": {
+        "count": 8,
+        "cstring_hex": "286e756c6c29202000"
+      },
+      "source": {
+        "count": 8,
+        "cstring_hex": "286e756c6c29202000"
+      },
+      "template": "%08.2s"
+    },
+    {
+      "rust": {
+        "count": 0,
+        "cstring_hex": "00"
+      },
+      "source": {
+        "count": 0,
+        "cstring_hex": "00"
+      },
+      "template": ""
+    },
+    {
+      "rust": {
+        "count": 13,
+        "cstring_hex": "706c61696e206c69746572616c00"
+      },
+      "source": {
+        "count": 13,
+        "cstring_hex": "706c61696e206c69746572616c00"
+      },
+      "template": "plain literal"
+    },
+    {
+      "rust": {
+        "count": 5,
+        "cstring_hex": "253a413a4200"
+      },
+      "source": {
+        "count": 5,
+        "cstring_hex": "253a413a4200"
+      },
+      "template": "%%:%c:%q"
+    },
+    {
+      "rust": {
+        "count": 3,
+        "cstring_hex": "0020ff00"
+      },
+      "source": {
+        "count": 3,
+        "cstring_hex": "0020ff00"
+      },
+      "template": "%c %c"
+    },
+    {
+      "rust": {
+        "count": 18,
+        "cstring_hex": "68656c6c6f202d3132202f2041202573204200"
+      },
+      "source": {
+        "count": 18,
+        "cstring_hex": "68656c6c6f202d3132202f2041202573204200"
+      },
+      "template": "hello %i / %s"
+    }
+  ],
+  "rejections": [
+    2
+  ],
+  "source_report": "docs/research/qvm-formatter.json",
+  "source_report_sha256": "05948658242afbba756f1c33448be002c60cc73b2a108ec605140ec4b39de31d"
+}

scripts/analyze_rust_qvm_format.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+import hashlib,json
+from pathlib import Path
+from rust_lifecycle_support import binary,result,invoke
+from analyze_qvm import write_json
+
+def encode(p):
+    t=p['template'].encode();out=[len(t),len(p['arguments']),*t]
+    for a in p['arguments']:
+        if 'word' in a:out += [0,a['word']]
+        elif 'null' in a:out += [2]
+        else:b=bytes.fromhex(a['bytes_hex']);out += [1,len(b),*b]
+    return out
+
+def main():
+    b=binary();p=Path('docs/research/qvm-formatter.json');data=p.read_bytes();rows=[]
+    for s in json.loads(data)['probes']:rows.append({'template':s['template'],'source':{'cstring_hex':s['output_hex'],'count':s['count']},'rust':result(b,'qvm-format',encode(s))})
+    bad=invoke(b,'qvm-format',encode({'template':'%-1i','arguments':[{'word':123}]}),check=False);assert bad.returncode
+    write_json(Path('docs/research/rust-qvm-format.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'rejections':[bad.returncode],'limits':'Rust recovered37914 integer/string/character subset matches55 complete original-QVM cases, including signed minimum and nonstandard flags. Float, unsafe narrow-left padding, malformed/unknown varargs reject explicitly; no native host printf claim.'})
+if __name__=='__main__':main()

scripts/test_rust_qvm_format.py

@@ -0,0 +1,9 @@
+import hashlib,json,unittest
+from pathlib import Path
+class RustQvmFormatTests(unittest.TestCase):
+    def test_exact_original_formatter_bytes_and_counts(self):
+        r=json.loads(Path('docs/research/rust-qvm-format.json').read_text());self.assertEqual(len(r['probes']),55)
+        for p in r['probes']:self.assertEqual(p['rust'],p['source'],p['template'])
+    def test_identity_and_padding_domain_rejection(self):
+        r=json.loads(Path('docs/research/rust-qvm-format.json').read_text());self.assertEqual(hashlib.sha256(Path(r['source_report']).read_bytes()).hexdigest(),r['source_report_sha256']);self.assertTrue(all(r['rejections']))
+if __name__=='__main__':unittest.main()

xtask/checks.tsv

@@ -1987,3 +1987,16 @@ report	scripts/analyze_qvm_scoreboard_formatter.py	docs/research/qvm-scoreboard-
 edge	docs/research/qvm-scoreboard-formatter.json	scripts/test_qvm_scoreboard_formatter.py
 group	scoreboard-formatter	scripts/analyze_qvm_scoreboard_formatter.py
 edge	scripts/analyze_qvm_scoreboard_formatter.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_qvm_format.py
+edge	Cargo.lock	scripts/analyze_rust_qvm_format.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_qvm_format.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_qvm_format.py
+edge	crates/urt-gameplay/src/bin/urt-lifecycle.rs	scripts/analyze_rust_qvm_format.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_qvm_format.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_qvm_format.py
+group	rust-qvm-format	scripts/analyze_rust_health_impulse.py
+report	scripts/analyze_rust_qvm_format.py	docs/research/rust-qvm-format.json
+edge	docs/research/rust-qvm-format.json	scripts/test_rust_qvm_format.py
+group	rust-qvm-format	scripts/analyze_rust_qvm_format.py
+edge	scripts/analyze_rust_qvm_format.py	scripts/analyze_qvm_resumer_audit.py

xtask/src/lib.rs

@@ -1045,6 +1045,7 @@ mod integration_tests {
             ("ranking_population", "ranking_population"),
             ("scoreboard", "scoreboard"),
             ("scoreboard_wire", "scoreboard_rows"),
+            ("qvm_format", "qvm_format"),
             ("leaderboard", "leaderboard"),
             ("recipient_wire", "recipient_wire"),
         ] {