gameplay: resolve duration command persistence

crates/urt-gameplay/src/bin/urt-filter-commands.rs

@@ -149,6 +149,111 @@ fn main() {
             let out = remove_filter_command(&mut rows, &text, issuer, &mut ring).unwrap();
             println!("{}", command_json(out, &rows, n, ring, 0));
         }
+        "duration-export" => println!("{}", duration_export(&w)),
         _ => panic!("unknown policy"),
     }
 }
+
+fn exported_json(p: Option<urt_gameplay::filter_lifecycle::FilterExport>) -> String {
+    let Some(p) = p else {
+        return r#"{"events":[],"formats":[],"buffer":"7374616c65"}"#.into();
+    };
+    use urt_gameplay::filter_lifecycle::FilterFileEffect;
+    let events = p
+        .effects()
+        .iter()
+        .map(|e| match e {
+            FilterFileEffect::Print(t) => format!(r#"{{"op":"print","text":"{}"}}"#, hex(t)),
+            FilterFileEffect::Open { path, mode } => {
+                format!(r#"{{"op":"open","path":"{}","mode":{}}}"#, hex(path), mode)
+            }
+            FilterFileEffect::Write { handle, bytes } => format!(
+                r#"{{"op":"write","handle":{},"text":"{}"}}"#,
+                handle,
+                hex(bytes)
+            ),
+            FilterFileEffect::Close(h) => format!(r#"{{"op":"close","handle":{}}}"#, h),
+        })
+        .collect::<Vec<_>>()
+        .join(",");
+    let formats = p
+        .lines
+        .iter()
+        .map(|l| format!("\"{}\"", hex(l)))
+        .collect::<Vec<_>>()
+        .join(",");
+    format!(
+        r#"{{"events":[{}],"formats":[{}],"buffer":"{}"}}"#,
+        events,
+        formats,
+        hex(&p.text)
+    )
+}
+fn duration_export(w: &[u32]) -> String {
+    let mut p = 4;
+    let address = blob(w, &mut p);
+    let duration = blob(w, &mut p);
+    assert_eq!(p, w.len());
+    let fields = [13, w[0], 0, 4, 5, 126, 6, 0, 0];
+    let issuer = if w[1] == u32::MAX {
+        None
+    } else {
+        Some(w[1] as i32)
+    };
+    let mut ring = w[2];
+    let mut rows = [
+        FilterRecord {
+            mask: u32::MAX,
+            comparison: 0x04030201,
+            metadata: 77,
+        },
+        FilterRecord {
+            mask: u32::MAX,
+            comparison: 0x04030201,
+            metadata: 88,
+        },
+    ];
+    let out = resolved_filter_duration(
+        &mut rows, &address, &duration, &fields, issuer, &mut ring, w[3],
+    )
+    .unwrap();
+    let exported = out
+        .export
+        .map(|p| exported_json(Some(p)))
+        .unwrap_or_default();
+    let out = out.command;
+    use urt_gameplay::filter_loading::FilterDurationEffect;
+    let events = out
+        .effects
+        .iter()
+        .map(|e| match e {
+            FilterDurationEffect::Console(t) => {
+                format!(r#"{{"op":"console","text":"{}"}}"#, hex(t))
+            }
+            FilterDurationEffect::Send { recipient, text } => format!(
+                r#"{{"op":"send","recipient":{},"text":"{}"}}"#,
+                recipient,
+                hex(text)
+            ),
+            FilterDurationEffect::Time => r#"{"op":"time"}"#.into(),
+            FilterDurationEffect::Metadata { text, value } => format!(
+                r#"{{"op":"metadata","text":"{}","metadata":{},"save":1}}"#,
+                hex(text),
+                value
+            ),
+        })
+        .collect::<Vec<String>>()
+        .join(",");
+    let updates = out
+        .update
+        .map(|p| children_json(&[p.into()]))
+        .unwrap_or_default();
+    format!(
+        r#"{{"events":[{}],"updates":[{}],"ring":{},"rows":[{}],"exported":[{}]}}"#,
+        events,
+        updates,
+        ring,
+        rows.into_iter().map(row_json).collect::<Vec<_>>().join(","),
+        exported
+    )
+}

crates/urt-gameplay/src/filter_commands.rs

@@ -340,3 +340,90 @@ mod remove_tests {
         assert_eq!(ring, 7);
     }
 }
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ResolvedFilterDuration {
+    pub command: crate::filter_loading::FilterDuration,
+    pub export: Option<crate::filter_lifecycle::FilterExport>,
+}
+/// Compose252213/252127/252500, resolving a successful save request into exact
+/// export bytes/effects while retaining captured native time/handle replies.
+pub fn resolved_filter_duration(
+    records: &mut [FilterRecord],
+    address: &[u8],
+    duration: &[u8],
+    fields: &[u32; 9],
+    issuer: Option<i32>,
+    ring: &mut u32,
+    handle: u32,
+) -> Result<ResolvedFilterDuration, Error> {
+    let mut staged = records.to_vec();
+    let mut counter = *ring;
+    let command = crate::filter_loading::filter_duration(
+        &mut staged,
+        address,
+        duration,
+        fields,
+        issuer,
+        &mut counter,
+    )?;
+    let export = if command.update.as_ref().is_some_and(|p| p.export) {
+        crate::filter_lifecycle::export_filters(&staged, handle)?
+    } else {
+        None
+    };
+    records.copy_from_slice(&staged);
+    *ring = counter;
+    Ok(ResolvedFilterDuration { command, export })
+}
+#[cfg(test)]
+mod duration_export_tests {
+    use super::*;
+    #[test]
+    fn first_duplicate_updates_then_both_export_in_order_through_zero_handle() {
+        let row = FilterRecord {
+            mask: u32::MAX,
+            comparison: 0x04030201,
+            metadata: 7,
+        };
+        let mut rows = [row, FilterRecord { metadata: 8, ..row }];
+        let mut ring = 9;
+        let p = resolved_filter_duration(&mut rows, b"1.2.3.4", b"5", &[0; 9], None, &mut ring, 0)
+            .unwrap();
+        let export = p.export.unwrap();
+        assert_eq!(export.text, b"1.2.3.4:5\n1.2.3.4:8\n");
+        assert_eq!(export.handle, 0);
+        assert_eq!(ring, 9);
+        assert!(p.command.update.unwrap().export);
+    }
+    #[test]
+    fn usage_miss_and_unsupported_domains_do_not_export_or_partially_mutate() {
+        let row = FilterRecord {
+            mask: u32::MAX,
+            comparison: 0x04030201,
+            metadata: 7,
+        };
+        let mut rows = [row];
+        let mut ring = u32::MAX;
+        assert!(
+            resolved_filter_duration(&mut rows, b"", b"5", &[0; 9], Some(2), &mut ring, 7)
+                .unwrap()
+                .export
+                .is_none()
+        );
+        assert_eq!(ring, 0);
+        assert!(
+            resolved_filter_duration(&mut rows, b"2.3.4.5", b"5", &[0; 9], None, &mut ring, 7)
+                .unwrap()
+                .export
+                .is_none()
+        );
+        assert_eq!(rows, [row]);
+        assert!(
+            resolved_filter_duration(&mut rows, &[b'1'; 128], b"5", &[0; 9], None, &mut ring, 7)
+                .is_err()
+        );
+        assert_eq!(rows, [row]);
+        assert_eq!(ring, 0);
+    }
+}

docs/FINDINGS.md

@@ -1849,3 +1849,5 @@ RE-956: Twenty-four actual253245 wrappers compose actual253296 removal and sourc
 RE-957: Rust matches24 original removal-wrapper cases, preserving exact client/console usage, formatter wrap, first-match duplicate/sentinel mutations, child diagnostics and conditional export. The API leaves caller table length and userinfo selector ownership untouched. Unit tests cover empty-input child suppression, duplicate metadata retention, ordinary parser failure and atomic unsupported-token rejection. Native effects remain captured plans. [Evidence](research/RUST_FILTER_REMOVE_COMMAND.md).
 
 RE-958: Eighty actual252213/252127/252500 compositions resolve the prior captured export request into source-generated bytes and ordered print/open/write/close effects. Duplicate metadata updates only the first row, then export serializes both rows in order. Usage, invalid parsing and absent matches skip export. Supplied zero handles still reach write/close; time/network/file execution remains captured or supplied. [Evidence](research/QVM_FILTER_DURATION_EXPORT.md).
+
+RE-959: Rust matches80 original duration/update/export compositions, deriving exact file payloads and typed effects from a successful metadata save request. Duplicate order, zero handles, usage/miss export suppression and formatter counters are retained. Unit tests cover first-row update with two-row export and atomic unsupported-domain rejection. Native time/file/network execution remains supplied or captured. [Evidence](research/RUST_FILTER_DURATION_EXPORT.md).

docs/PROVISIONAL_TODO.md

@@ -1899,3 +1899,5 @@ RE-944–953 completed bounded time/expiry/loading/duration and export/reload co
 - [x] RE-957 Rust remove-filter wrapper and source usage effects ([evidence](research/RUST_FILTER_REMOVE_COMMAND.md)).
 
 - [x] RE-958 Original duration command with metadata and export resolved ([evidence](research/QVM_FILTER_DURATION_EXPORT.md)).
+
+- [x] RE-959 Rust duration command with resolved persistence plan ([evidence](research/RUST_FILTER_DURATION_EXPORT.md)).

docs/RESEARCH_LEDGER.md

@@ -2501,3 +2501,7 @@ Rust matches24 original removal-wrapper cases, preserving exact client/console u
 ## 2026-10-28 — RE-958 Original duration command with metadata and export resolved
 
 Eighty actual252213/252127/252500 compositions resolve the prior captured export request into source-generated bytes and ordered print/open/write/close effects. Duplicate metadata updates only the first row, then export serializes both rows in order. Usage, invalid parsing and absent matches skip export. Supplied zero handles still reach write/close; time/network/file execution remains captured or supplied. Focused `cargo xtask test-group qvm-filter-duration-export` passes with deterministic report regeneration, relevant regressions and storage/documentation/whitespace checks. Full suite deferred to the tenth-commit boundary. Original assets unchanged; native IO effects remain captured.
+
+## 2026-10-28 — RE-959 Rust duration command with resolved persistence plan
+
+Rust matches80 original duration/update/export compositions, deriving exact file payloads and typed effects from a successful metadata save request. Duplicate order, zero handles, usage/miss export suppression and formatter counters are retained. Unit tests cover first-row update with two-row export and atomic unsupported-domain rejection. Native time/file/network execution remains supplied or captured. Focused `cargo xtask test-group rust-filter-duration-export` passes with deterministic report regeneration, relevant regressions and storage/documentation/whitespace checks. Full suite deferred to the tenth-commit boundary. Original assets unchanged; native IO effects remain captured.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1936,3 +1936,5 @@ RE-944–953 recover bounded time, expiry, loading, duration and persistence rou
 - [x] RE-957 Rust remove-filter wrapper and source usage effects ([evidence](research/RUST_FILTER_REMOVE_COMMAND.md)).
 
 - [x] RE-958 Original duration command with metadata and export resolved ([evidence](research/QVM_FILTER_DURATION_EXPORT.md)).
+
+- [x] RE-959 Rust duration command with resolved persistence plan ([evidence](research/RUST_FILTER_DURATION_EXPORT.md)).

docs/research/README.md

@@ -1471,3 +1471,5 @@ The extension collector adds five focused tests for native tail calls, command-r
 - [RE-957: Rust remove-filter wrapper and source usage effects](RUST_FILTER_REMOVE_COMMAND.md).
 
 - [RE-958: Original duration command with metadata and export resolved](QVM_FILTER_DURATION_EXPORT.md).
+
+- [RE-959: Rust duration command with resolved persistence plan](RUST_FILTER_DURATION_EXPORT.md).

docs/research/RUST_FILTER_DURATION_EXPORT.md

@@ -0,0 +1,5 @@
+# Rust duration command with resolved persistence plan
+
+RE-959. Focused validation: `cargo xtask test-group rust-filter-duration-export`. [Machine report](rust-filter-duration-export.json).
+
+Rust matches80 original duration/update/export compositions, deriving exact file payloads and typed effects from a successful metadata save request. Duplicate order, zero handles, usage/miss export suppression and formatter counters are retained. Unit tests cover first-row update with two-row export and atomic unsupported-domain rejection. Native time/file/network execution remains supplied or captured.

docs/research/rust-health-impulse.json

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

scripts/analyze_rust_filter_duration_export.py

@@ -0,0 +1,17 @@
+"""Compare recovered Rust policy with original QVM fixtures."""
+import hashlib,json,os,subprocess
+from pathlib import Path
+from analyze_qvm import write_json
+from rust_lifecycle_support import result
+
+def main():
+ subprocess.run(['cargo','build','--offline','--package','urt-gameplay','--bin','urt-filter-commands'],check=True,capture_output=True)
+ binary=Path(os.environ.get('CARGO_TARGET_DIR','target'))/'debug'/'urt-filter-commands'
+ path=Path('docs/research/qvm-filter-duration-export.json');data=path.read_bytes();probes=[]
+ for p in json.loads(data)['probes']:
+  probes.append(dict(source={k:p[k] for k in ['events', 'updates', 'ring', 'rows', 'exported']},rust=result(binary,'duration-export',encode(p['input']))))
+ write_json(Path('docs/research/rust-filter-duration-export.json'),dict(source_report=str(path),source_report_sha256=hashlib.sha256(data).hexdigest(),probes=probes,limits='Finite source/Rust contract parity; native time/file/network replies remain supplied or captured.'))
+
+def encode(a):
+ ip=bytes.fromhex(a['address']);d=bytes.fromhex(a['duration']);return [a['now'],a['client'],a['ring'],a['handle'],len(ip),*ip,len(d),*d]
+if __name__=='__main__':main()

scripts/test_rust_filter_duration_export.py

@@ -0,0 +1,9 @@
+import hashlib,json,unittest
+from pathlib import Path
+class PortTests(unittest.TestCase):
+ def test_original_parity(self):
+  r=json.loads(Path('docs/research/rust-filter-duration-export.json').read_text());self.assertGreaterEqual(len(r['probes']),12)
+  for p in r['probes']:self.assertEqual(p['source'],p['rust'])
+ def test_identity(self):
+  r=json.loads(Path('docs/research/rust-filter-duration-export.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

@@ -3354,3 +3354,21 @@ report	scripts/analyze_qvm_filter_duration_export.py	docs/research/qvm-filter-du
 edge	docs/research/qvm-filter-duration-export.json	scripts/test_qvm_filter_duration_export.py
 group	qvm-filter-duration-export	scripts/analyze_qvm_filter_duration_export.py
 edge	scripts/analyze_qvm_filter_duration_export.py	scripts/analyze_qvm_resumer_audit.py
+report	scripts/analyze_rust_filter_duration_export.py	docs/research/rust-filter-duration-export.json
+edge	docs/research/rust-filter-duration-export.json	scripts/test_rust_filter_duration_export.py
+group	rust-filter-duration-export	scripts/analyze_rust_filter_duration_export.py
+edge	scripts/analyze_rust_filter_duration_export.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_filter_duration_export.py
+edge	Cargo.lock	scripts/analyze_rust_filter_duration_export.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_filter_duration_export.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_filter_duration_export.py
+edge	crates/urt-gameplay/src/filter_loading.rs	scripts/analyze_rust_filter_duration_export.py
+edge	crates/urt-gameplay/src/filter_lifecycle.rs	scripts/analyze_rust_filter_duration_export.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_filter_duration_export.py
+edge	crates/urt-gameplay/src/bin/urt-filter-loading.rs	scripts/analyze_rust_filter_duration_export.py
+edge	crates/urt-gameplay/src/qvm_format.rs	scripts/analyze_rust_filter_duration_export.py
+edge	docs/research/qvm-filter-duration-export.json	scripts/analyze_rust_filter_duration_export.py
+group	rust-filter-duration-export	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_filter_duration_export.py
+edge	crates/urt-gameplay/src/filter_commands.rs	scripts/analyze_rust_filter_duration_export.py
+edge	crates/urt-gameplay/src/bin/urt-filter-commands.rs	scripts/analyze_rust_filter_duration_export.py