gameplay: port formatter wrapper policies

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

@@ -394,7 +394,20 @@ fn run() -> Result<(), String> {
                 second.cached_ping as u32
             );
         }
-        "qvm-format" if w.len() >= 2 && w[0] <= 4096 && w[1] <= 64 => {
+        "qvm-format" | "qvm-format-bounded" | "qvm-format-ring" => {
+            let parameter = if kind == "qvm-format" {
+                0
+            } else {
+                *w.first().ok_or("missing wrapper parameter")?
+            };
+            let w = if kind == "qvm-format" {
+                w.as_slice()
+            } else {
+                &w[1..]
+            };
+            if w.len() < 2 || w[0] > 4096 || w[1] > 64 {
+                return Err("invalid format shape".into());
+            }
             let len = w[0] as usize;
             let n = w[1] as usize;
             if w.len() < 2 + len {
@@ -443,13 +456,41 @@ fn run() -> Result<(), String> {
                     _ => 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
-            );
+            if kind == "qvm-format-bounded" {
+                let p = urt_gameplay::qvm_format::bounded(&template, &args, parameter as usize)
+                    .map_err(|e| format!("unsupported input: {e:?}"))?;
+                println!(
+                    "{{\"buffer_hex\":\"{}\",\"return_count\":{},\"warning\":{}}}",
+                    p.bytes
+                        .iter()
+                        .map(|v| format!("{v:02x}"))
+                        .collect::<String>(),
+                    p.return_count,
+                    p.warning
+                );
+            } else if kind == "qvm-format-ring" {
+                let mut counter = parameter;
+                let (index, bytes) = urt_gameplay::qvm_format::ring(&template, &args, &mut counter)
+                    .map_err(|e| format!("unsupported input: {e:?}"))?;
+                let end = bytes.iter().position(|b| *b == 0).unwrap();
+                println!(
+                    "{{\"cstring_hex\":\"{}\",\"index\":{},\"counter\":{}}}",
+                    bytes[..=end]
+                        .iter()
+                        .map(|v| format!("{v:02x}"))
+                        .collect::<String>(),
+                    index,
+                    counter
+                );
+            } else {
+                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;

crates/urt-gameplay/src/qvm_format.rs

@@ -141,10 +141,65 @@ pub fn render(template: &[u8], arguments: &[Argument<'_>]) -> Result<Vec<u8>, Er
     out.push(0);
     Ok(out)
 }
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Bounded {
+    pub bytes: Vec<u8>,
+    pub return_count: usize,
+    pub warning: bool,
+}
+/// Source70386 success/clipping path with explicit native strncpy byte policy.
+/// Fatal32000 and diagnostic side effects are represented by rejection/flag.
+pub fn bounded(template: &[u8], args: &[Argument<'_>], capacity: usize) -> Result<Bounded, Error> {
+    if !(1..=32000).contains(&capacity) {
+        return Err(Error::Limit);
+    }
+    let raw = render(template, args)?;
+    let count = raw.len() - 1;
+    if count >= 32000 {
+        return Err(Error::Limit);
+    }
+    let visible = raw.iter().position(|b| *b == 0).unwrap();
+    let copied = visible.min(capacity - 1);
+    let mut bytes = vec![0; capacity];
+    bytes[..copied].copy_from_slice(&raw[..copied]);
+    Ok(Bounded {
+        bytes,
+        return_count: count.min(capacity - 1),
+        warning: count >= capacity,
+    })
+}
+/// Source70458 successful alternating-buffer contract. Error-side-effect timing
+/// and native storage ownership are excluded; valid outputs retain opaque bytes.
+pub fn ring(
+    template: &[u8],
+    args: &[Argument<'_>],
+    counter: &mut u32,
+) -> Result<(u32, Vec<u8>), Error> {
+    let bytes = render(template, args)?;
+    let index = *counter & 1;
+    *counter = counter.wrapping_add(1);
+    Ok((index, bytes))
+}
 #[cfg(test)]
 mod tests {
     use super::*;
     #[test]
+    fn bounded_count_can_exceed_visible_length() {
+        let p = bounded(b"%c/AB", &[Argument::Word(0)], 3).unwrap();
+        assert_eq!(p.bytes, [0, 0, 0]);
+        assert_eq!(p.return_count, 2);
+        assert!(p.warning);
+        assert_eq!(bounded(b"abc", &[], 0), Err(Error::Limit));
+    }
+    #[test]
+    fn ring_wrap_and_successive_slots() {
+        let mut c = u32::MAX;
+        let a = ring(b"%s", &[Argument::Bytes(None)], &mut c).unwrap();
+        let b = ring(b"X", &[], &mut c).unwrap();
+        assert_eq!((a.0, b.0, c), (1, 0, 1));
+        assert_eq!(a.1, b"(null)\0");
+    }
+    #[test]
     fn source_padding_precision_and_unknown_dispatch() {
         assert_eq!(
             render(

docs/FINDINGS.md

@@ -1457,3 +1457,6 @@ RE-802–811 adds opt-in coherent memory, original string/scoreboard control flo
 
 
 **RE-819:** 70386 warns at count>=capacity, returns the clipped count and copies a guaranteed terminal NUL; embedded NUL separates reported count from visible string length. [Evidence](research/QVM_FORMAT_WRAPPERS.md).
+
+
+**RE-820:** Rust matches original clipping counts, visible bytes, warning thresholds and alternating buffer counters across56 wrapper cases. [Evidence](research/RUST_FORMAT_WRAPPERS.md).

docs/PROVISIONAL_TODO.md

@@ -1467,3 +1467,6 @@ RE-818: Rust scoreboard construction now uses recovered decimal/format semantics
 
 
 RE-819: 70386 warns at count>=capacity, returns the clipped count and copies a guaranteed terminal NUL; embedded NUL separates reported count from visible string length. Full runtime completion remains open. [Evidence](research/QVM_FORMAT_WRAPPERS.md).
+
+
+RE-820: Rust matches original clipping counts, visible bytes, warning thresholds and alternating buffer counters across56 wrapper cases. Full runtime completion remains open. [Evidence](research/RUST_FORMAT_WRAPPERS.md).

docs/RESEARCH_LEDGER.md

@@ -1763,3 +1763,8 @@ Rust scoreboard construction now uses recovered decimal/format semantics, replac
 ## 2026-10-27 — RE-819 Original bounded formatter clipping diagnostics and output-ring policy
 
 70386 warns at count>=capacity, returns the clipped count and copies a guaranteed terminal NUL; embedded NUL separates reported count from visible string length. Focused `cargo xtask test-group format-wrappers` 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-820 Rust bounded and rotating formatter wrapper contracts
+
+Rust matches original clipping counts, visible bytes, warning thresholds and alternating buffer counters across56 wrapper cases. Focused `cargo xtask test-group rust-format-wrappers` passes (11 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

@@ -1507,3 +1507,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-819 Original bounded formatter clipping diagnostics and output-ring policy ([evidence](research/QVM_FORMAT_WRAPPERS.md)).
+
+
+- [x] RE-820 Rust bounded and rotating formatter wrapper contracts ([evidence](research/RUST_FORMAT_WRAPPERS.md)).

docs/research/README.md

@@ -1047,3 +1047,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-819: Original bounded formatter clipping diagnostics and output-ring policy](QVM_FORMAT_WRAPPERS.md).
+
+
+[RE-820: Rust bounded and rotating formatter wrapper contracts](RUST_FORMAT_WRAPPERS.md).

docs/research/RUST_FORMAT_WRAPPERS.md

@@ -0,0 +1,7 @@
+# Rust bounded and rotating formatter wrapper contracts
+
+RE-820. Reproduce with `python3 scripts/analyze_rust_format_wrappers.py`; focused validation: `cargo xtask test-group rust-format-wrappers`. [Machine report](rust-format-wrappers.json).
+
+Typed bounded and ring APIs compose the recovered byte formatter. Embedded NUL handling preserves the difference between rendered count and visible C-string length. Unit tests check truncation, invalid capacity and successive wrap/slot behavior; existing55 formatter parity cases rerun after CLI parser reuse. Native storage, warning effects and fatal/error-side-effect timing remain outside this contract.
+
+Original executable/native runtime and complete Linux/macOS Rust/Bevy/Solari acceptance remain unverified.

docs/research/rust-format-wrappers.json

@@ -0,0 +1,681 @@
+{
+  "bounded": [
+    {
+      "rust": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "2d00",
+        "return_count": 1,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "2d00",
+        "return_count": 1,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "2d313200",
+        "return_count": 3,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "2d313200",
+        "return_count": 3,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "2d31320000000000",
+        "return_count": 3,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "2d31320000000000",
+        "return_count": 3,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "2d31320000000000000000000000000000000000000000000000000000000000",
+        "return_count": 3,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "2d31320000000000000000000000000000000000000000000000000000000000",
+        "return_count": 3,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "3000",
+        "return_count": 1,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "3000",
+        "return_count": 1,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "30302d00",
+        "return_count": 3,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "30302d00",
+        "return_count": 3,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "30302d3132000000",
+        "return_count": 5,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "30302d3132000000",
+        "return_count": 5,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "30302d3132000000000000000000000000000000000000000000000000000000",
+        "return_count": 5,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "30302d3132000000000000000000000000000000000000000000000000000000",
+        "return_count": 5,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "4100",
+        "return_count": 1,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "4100",
+        "return_count": 1,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "41420000",
+        "return_count": 2,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "41420000",
+        "return_count": 2,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "4142000000000000",
+        "return_count": 2,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "4142000000000000",
+        "return_count": 2,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "4142000000000000000000000000000000000000000000000000000000000000",
+        "return_count": 2,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "4142000000000000000000000000000000000000000000000000000000000000",
+        "return_count": 2,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "6100",
+        "return_count": 1,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "6100",
+        "return_count": 1,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "61626300",
+        "return_count": 3,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "61626300",
+        "return_count": 3,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "6162634142434400",
+        "return_count": 7,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "6162634142434400",
+        "return_count": 7,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "6162634142434445464700000000000000000000000000000000000000000000",
+        "return_count": 10,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "6162634142434445464700000000000000000000000000000000000000000000",
+        "return_count": 10,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "0000",
+        "return_count": 1,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "0000",
+        "return_count": 1,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "00000000",
+        "return_count": 3,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "00000000",
+        "return_count": 3,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "0000000000000000",
+        "return_count": 7,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "0000000000000000",
+        "return_count": 7,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "0000000000000000000000000000000000000000000000000000000000000000",
+        "return_count": 13,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "0000000000000000000000000000000000000000000000000000000000000000",
+        "return_count": 13,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "2500",
+        "return_count": 1,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "2500",
+        "return_count": 1,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "25000000",
+        "return_count": 1,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "25000000",
+        "return_count": 1,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "2500000000000000",
+        "return_count": 1,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "2500000000000000",
+        "return_count": 1,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "2500000000000000000000000000000000000000000000000000000000000000",
+        "return_count": 1,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "2500000000000000000000000000000000000000000000000000000000000000",
+        "return_count": 1,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "00",
+        "return_count": 0,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "2800",
+        "return_count": 1,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "2800",
+        "return_count": 1,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "286e7500",
+        "return_count": 3,
+        "warning": true
+      },
+      "source": {
+        "buffer_hex": "286e7500",
+        "return_count": 3,
+        "warning": true
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "286e756c6c290000",
+        "return_count": 6,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "286e756c6c290000",
+        "return_count": 6,
+        "warning": false
+      }
+    },
+    {
+      "rust": {
+        "buffer_hex": "286e756c6c290000000000000000000000000000000000000000000000000000",
+        "return_count": 6,
+        "warning": false
+      },
+      "source": {
+        "buffer_hex": "286e756c6c290000000000000000000000000000000000000000000000000000",
+        "return_count": 6,
+        "warning": false
+      }
+    }
+  ],
+  "limits": "Rust successful/clipping70386 and rotating70458 wrapper semantics match56 actual-QVM fixtures. Native strncpy bytes modeled; warnings represented as flags and fatal/error-side-effect behavior excluded.",
+  "rings": [
+    {
+      "rust": {
+        "counter": 1,
+        "cstring_hex": "2d313200",
+        "index": 0
+      },
+      "source": {
+        "counter": 1,
+        "cstring_hex": "2d313200",
+        "index": 0
+      }
+    },
+    {
+      "rust": {
+        "counter": 2,
+        "cstring_hex": "2d313200",
+        "index": 1
+      },
+      "source": {
+        "counter": 2,
+        "cstring_hex": "2d313200",
+        "index": 1
+      }
+    },
+    {
+      "rust": {
+        "counter": 0,
+        "cstring_hex": "2d313200",
+        "index": 1
+      },
+      "source": {
+        "counter": 0,
+        "cstring_hex": "2d313200",
+        "index": 1
+      }
+    },
+    {
+      "rust": {
+        "counter": 1,
+        "cstring_hex": "30302d313200",
+        "index": 0
+      },
+      "source": {
+        "counter": 1,
+        "cstring_hex": "30302d313200",
+        "index": 0
+      }
+    },
+    {
+      "rust": {
+        "counter": 2,
+        "cstring_hex": "30302d313200",
+        "index": 1
+      },
+      "source": {
+        "counter": 2,
+        "cstring_hex": "30302d313200",
+        "index": 1
+      }
+    },
+    {
+      "rust": {
+        "counter": 0,
+        "cstring_hex": "30302d313200",
+        "index": 1
+      },
+      "source": {
+        "counter": 0,
+        "cstring_hex": "30302d313200",
+        "index": 1
+      }
+    },
+    {
+      "rust": {
+        "counter": 1,
+        "cstring_hex": "414200",
+        "index": 0
+      },
+      "source": {
+        "counter": 1,
+        "cstring_hex": "414200",
+        "index": 0
+      }
+    },
+    {
+      "rust": {
+        "counter": 2,
+        "cstring_hex": "414200",
+        "index": 1
+      },
+      "source": {
+        "counter": 2,
+        "cstring_hex": "414200",
+        "index": 1
+      }
+    },
+    {
+      "rust": {
+        "counter": 0,
+        "cstring_hex": "414200",
+        "index": 1
+      },
+      "source": {
+        "counter": 0,
+        "cstring_hex": "414200",
+        "index": 1
+      }
+    },
+    {
+      "rust": {
+        "counter": 1,
+        "cstring_hex": "6162634142434445464700",
+        "index": 0
+      },
+      "source": {
+        "counter": 1,
+        "cstring_hex": "6162634142434445464700",
+        "index": 0
+      }
+    },
+    {
+      "rust": {
+        "counter": 2,
+        "cstring_hex": "6162634142434445464700",
+        "index": 1
+      },
+      "source": {
+        "counter": 2,
+        "cstring_hex": "6162634142434445464700",
+        "index": 1
+      }
+    },
+    {
+      "rust": {
+        "counter": 0,
+        "cstring_hex": "6162634142434445464700",
+        "index": 1
+      },
+      "source": {
+        "counter": 0,
+        "cstring_hex": "6162634142434445464700",
+        "index": 1
+      }
+    },
+    {
+      "rust": {
+        "counter": 1,
+        "cstring_hex": "00",
+        "index": 0
+      },
+      "source": {
+        "counter": 1,
+        "cstring_hex": "00",
+        "index": 0
+      }
+    },
+    {
+      "rust": {
+        "counter": 2,
+        "cstring_hex": "00",
+        "index": 1
+      },
+      "source": {
+        "counter": 2,
+        "cstring_hex": "00",
+        "index": 1
+      }
+    },
+    {
+      "rust": {
+        "counter": 0,
+        "cstring_hex": "00",
+        "index": 1
+      },
+      "source": {
+        "counter": 0,
+        "cstring_hex": "00",
+        "index": 1
+      }
+    },
+    {
+      "rust": {
+        "counter": 1,
+        "cstring_hex": "2500",
+        "index": 0
+      },
+      "source": {
+        "counter": 1,
+        "cstring_hex": "2500",
+        "index": 0
+      }
+    },
+    {
+      "rust": {
+        "counter": 2,
+        "cstring_hex": "2500",
+        "index": 1
+      },
+      "source": {
+        "counter": 2,
+        "cstring_hex": "2500",
+        "index": 1
+      }
+    },
+    {
+      "rust": {
+        "counter": 0,
+        "cstring_hex": "2500",
+        "index": 1
+      },
+      "source": {
+        "counter": 0,
+        "cstring_hex": "2500",
+        "index": 1
+      }
+    },
+    {
+      "rust": {
+        "counter": 1,
+        "cstring_hex": "286e756c6c2900",
+        "index": 0
+      },
+      "source": {
+        "counter": 1,
+        "cstring_hex": "286e756c6c2900",
+        "index": 0
+      }
+    },
+    {
+      "rust": {
+        "counter": 2,
+        "cstring_hex": "286e756c6c2900",
+        "index": 1
+      },
+      "source": {
+        "counter": 2,
+        "cstring_hex": "286e756c6c2900",
+        "index": 1
+      }
+    },
+    {
+      "rust": {
+        "counter": 0,
+        "cstring_hex": "286e756c6c2900",
+        "index": 1
+      },
+      "source": {
+        "counter": 0,
+        "cstring_hex": "286e756c6c2900",
+        "index": 1
+      }
+    }
+  ],
+  "source_report": "docs/research/qvm-format-wrappers.json",
+  "source_report_sha256": "ea796cc59eced38b448d46ad71a03331bb1ee799ea9ed0cfc8afe9ecfc739bd5"
+}

docs/research/rust-health-impulse.json

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

scripts/analyze_rust_format_wrappers.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+import hashlib,json
+from pathlib import Path
+from analyze_rust_qvm_format import encode
+from rust_lifecycle_support import binary,result
+from analyze_qvm import write_json
+
+def main():
+    b=binary();p=Path('docs/research/qvm-format-wrappers.json');data=p.read_bytes();r=json.loads(data);rows=[];rings=[]
+    for s in r['bounded']:rows.append({'source':{'buffer_hex':s['buffer_hex'],'return_count':s['return_count'],'warning':bool(s['diagnostics'])},'rust':result(b,'qvm-format-bounded',[s['capacity'],*encode(s)])})
+    for s in r['rings']:rings.append({'source':{'cstring_hex':s['cstring_hex'],'index':int(s['pointer']!=35032232),'counter':s['after']},'rust':result(b,'qvm-format-ring',[s['before'],*encode(s)])})
+    write_json(Path('docs/research/rust-format-wrappers.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'bounded':rows,'rings':rings,'limits':'Rust successful/clipping70386 and rotating70458 wrapper semantics match56 actual-QVM fixtures. Native strncpy bytes modeled; warnings represented as flags and fatal/error-side-effect behavior excluded.'})
+if __name__=='__main__':main()

scripts/test_rust_format_wrappers.py

@@ -0,0 +1,9 @@
+import hashlib,json,unittest
+from pathlib import Path
+class RustFormatWrapperTests(unittest.TestCase):
+    def test_all_original_wrapper_outputs(self):
+        r=json.loads(Path('docs/research/rust-format-wrappers.json').read_text());self.assertEqual((len(r['bounded']),len(r['rings'])),(35,21))
+        for p in r['bounded']+r['rings']:self.assertEqual(p['rust'],p['source'])
+    def test_source_identity(self):
+        r=json.loads(Path('docs/research/rust-format-wrappers.json').read_text());self.assertEqual(hashlib.sha256(Path(r['source_report']).read_bytes()).hexdigest(),r['source_report_sha256'])
+if __name__=='__main__':unittest.main()

xtask/checks.tsv

@@ -2025,3 +2025,16 @@ report	scripts/analyze_qvm_format_wrappers.py	docs/research/qvm-format-wrappers.
 edge	docs/research/qvm-format-wrappers.json	scripts/test_qvm_format_wrappers.py
 group	format-wrappers	scripts/analyze_qvm_format_wrappers.py
 edge	scripts/analyze_qvm_format_wrappers.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_format_wrappers.py
+edge	Cargo.lock	scripts/analyze_rust_format_wrappers.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_format_wrappers.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_format_wrappers.py
+edge	crates/urt-gameplay/src/bin/urt-lifecycle.rs	scripts/analyze_rust_format_wrappers.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_format_wrappers.py
+group	gameplay	scripts/analyze_rust_format_wrappers.py
+group	rust-format-wrappers	scripts/analyze_rust_qvm_format.py
+group	rust-format-wrappers	scripts/analyze_rust_health_impulse.py
+report	scripts/analyze_rust_format_wrappers.py	docs/research/rust-format-wrappers.json
+edge	docs/research/rust-format-wrappers.json	scripts/test_rust_format_wrappers.py
+group	rust-format-wrappers	scripts/analyze_rust_format_wrappers.py
+edge	scripts/analyze_rust_format_wrappers.py	scripts/analyze_qvm_resumer_audit.py