gameplay: port filter insertion mutation semantics

crates/urt-gameplay/src/bin/urt-native-policy.rs

@@ -1133,6 +1133,52 @@ fn run() -> Result<String, String> {
                 out.ring_advance
             ))
         }
+        "filter-insert" => {
+            if w.len() < 3 || w[0] > 5 {
+                return Err("invalid insert header".into());
+            }
+            let mut p = 2;
+            let text = input_blob(&w, &mut p)?.ok_or("null filter")?;
+            if p != w.len() {
+                return Err("trailing insert words".into());
+            }
+            let (mut count, mut records) = filter_fixture(w[0]);
+            let before_count = count;
+            let prior = records.clone();
+            let out = insert_filter(&mut records, &mut count, &text, w[1] as i32)
+                .map_err(|e| format!("{e:?}"))?;
+            let diagnostics = out
+                .diagnostics
+                .iter()
+                .map(|d| match d {
+                    FilterDiagnostic::Full => r#"{"op":"full"}"#.into(),
+                    FilterDiagnostic::BadAddress(text) => {
+                        format!(r#"{{"op":"bad-address","text":"{}"}}"#, hex(text))
+                    }
+                })
+                .collect::<Vec<String>>()
+                .join(",");
+            let row = |r: FilterRecord| list(&[r.mask, r.comparison, r.metadata]);
+            let before = out.slot.map(|j| row(prior[j])).unwrap_or("null".into());
+            let after = out.slot.map(|j| row(records[j])).unwrap_or("null".into());
+            let mut hash = 14695981039346656037u64;
+            for r in &records {
+                for word in [r.mask, r.comparison, r.metadata] {
+                    for byte in word.to_le_bytes() {
+                        hash = (hash ^ byte as u64).wrapping_mul(1099511628211);
+                    }
+                }
+            }
+            Ok(format!(
+                r#"{{"result":{},"slot":{},"parsed":{},"diagnostics":[{diagnostics}],"exports":{},"before_count":{before_count},"count":{count},"before":{before},"after":{after},"checksum":{hash}}}"#,
+                u32::from(out.result),
+                out.slot.map(|j| j.to_string()).unwrap_or("null".into()),
+                out.parsed
+                    .map(|v| u32::from(v).to_string())
+                    .unwrap_or("null".into()),
+                if out.export { "[252500]" } else { "[]" }
+            ))
+        }
         _ => Err("unknown command".into()),
     }
 }
@@ -1619,3 +1665,34 @@ fn notices_json(sends: &[TeamNotice]) -> String {
             .join(",")
     )
 }
+
+fn filter_fixture(profile: u32) -> (usize, Vec<FilterRecord>) {
+    let n = if profile == 0 {
+        0
+    } else if profile >= 4 {
+        4096
+    } else {
+        3
+    };
+    let mut rows = (0..n)
+        .map(|j| FilterRecord {
+            mask: u32::MAX,
+            comparison: j as u32 + 1,
+            metadata: 100 + j as u32,
+        })
+        .collect::<Vec<_>>();
+    if matches!(profile, 2 | 4) {
+        rows[0].comparison = u32::MAX;
+    }
+    if profile == 3 {
+        rows[1].comparison = u32::MAX;
+    }
+    if n < 4096 {
+        rows.push(FilterRecord {
+            mask: 0x11223344,
+            comparison: 0x55667788,
+            metadata: 0x99aabbcc,
+        });
+    }
+    (n, rows)
+}

crates/urt-gameplay/src/native_policy.rs

@@ -3109,3 +3109,151 @@ mod resolved_complete_tests {
         assert_eq!(selector, 0);
     }
 }
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct FilterRecord {
+    pub mask: u32,
+    pub comparison: u32,
+    pub metadata: u32,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum FilterDiagnostic {
+    Full,
+    BadAddress(Vec<u8>),
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct FilterInsert {
+    pub result: bool,
+    pub slot: Option<usize>,
+    pub parsed: Option<bool>,
+    pub diagnostics: Vec<FilterDiagnostic>,
+    pub export: bool,
+}
+/// Original252304 safe token subset: missing components remain wildcarded;
+/// a sole * is wildcard, other digit/* tokens use numeric-prefix conversion.
+fn parse_filter(text: &[u8]) -> Result<Result<(u32, u32), Vec<u8>>, Error> {
+    let text = cbytes(text);
+    if text.len() > 1024 {
+        return Err(Error::InvalidInput);
+    }
+    let (mut p, mut mask, mut value) = (0, [0u8; 4], [0u8; 4]);
+    for j in 0..4 {
+        if p >= text.len() || !(text[p].is_ascii_digit() || text[p] == b'*') {
+            return Ok(Err(text[p..].to_vec()));
+        }
+        let start = p;
+        while p < text.len() && (text[p].is_ascii_digit() || text[p] == b'*') {
+            p += 1;
+        }
+        let token = &text[start..p];
+        if token.len() >= 128 {
+            return Err(Error::InvalidInput);
+        }
+        if token != b"*" {
+            value[j] = signed_prefix(token) as u8;
+            mask[j] = 255;
+        }
+        if p == text.len() {
+            break;
+        }
+        p += 1;
+    }
+    Ok(Ok((u32::from_le_bytes(mask), u32::from_le_bytes(value))))
+}
+/// Original252829 mutates on parser failure: append count persists, comparison
+/// becomes-1, and optional export is still requested. Unsupported domains stage
+/// no writes; normal full-capacity refusal is a false result with a diagnostic.
+pub fn insert_filter(
+    records: &mut [FilterRecord],
+    count: &mut usize,
+    text: &[u8],
+    save: i32,
+) -> Result<FilterInsert, Error> {
+    if *count > 4096 || *count > records.len() || records.len() > 4096 {
+        return Err(Error::InvalidCount);
+    }
+    let slot = records[..*count]
+        .iter()
+        .position(|v| v.comparison == u32::MAX)
+        .unwrap_or(*count);
+    if slot == *count && *count == 4096 {
+        return Ok(FilterInsert {
+            result: false,
+            slot: None,
+            parsed: None,
+            diagnostics: vec![FilterDiagnostic::Full],
+            export: false,
+        });
+    }
+    if slot >= records.len() {
+        return Err(Error::InvalidCount);
+    }
+    let parsed = parse_filter(text)?;
+    let appended = slot == *count;
+    let (success, diagnostics) = match parsed {
+        Ok((mask, comparison)) => {
+            records[slot] = FilterRecord {
+                mask,
+                comparison,
+                metadata: u32::MAX,
+            };
+            (true, vec![])
+        }
+        Err(remaining) => {
+            records[slot].comparison = u32::MAX;
+            (false, vec![FilterDiagnostic::BadAddress(remaining)])
+        }
+    };
+    if appended {
+        *count += 1;
+    }
+    Ok(FilterInsert {
+        result: true,
+        slot: Some(slot),
+        parsed: Some(success),
+        diagnostics,
+        export: save != 0,
+    })
+}
+#[cfg(test)]
+mod filter_insert_tests {
+    use super::*;
+    #[test]
+    fn invalid_parse_keeps_growth_and_export() {
+        let mut r = [FilterRecord {
+            mask: 7,
+            comparison: 8,
+            metadata: 9,
+        }];
+        let mut n = 0;
+        let out = insert_filter(&mut r, &mut n, b"bad", 1).unwrap();
+        assert!(out.result);
+        assert_eq!(out.parsed, Some(false));
+        assert!(out.export);
+        assert_eq!(n, 1);
+        assert_eq!(
+            r[0],
+            FilterRecord {
+                mask: 7,
+                comparison: u32::MAX,
+                metadata: 9
+            }
+        );
+    }
+    #[test]
+    fn unsupported_token_is_atomic() {
+        let mut r = [FilterRecord {
+            mask: 7,
+            comparison: 8,
+            metadata: 9,
+        }];
+        let before = r;
+        let mut n = 0;
+        assert_eq!(
+            insert_filter(&mut r, &mut n, &vec![b'1'; 128], 0),
+            Err(Error::InvalidInput)
+        );
+        assert_eq!(r, before);
+        assert_eq!(n, 0);
+    }
+}

docs/FINDINGS.md

@@ -1796,3 +1796,6 @@ RE-813–822 replaces the scoreboard decimal assumption with actual37914 executi
 
 
 **RE-932:** 132 actual252829/252304/37159 cases recover first-hole reuse, append/count growth,4096 capacity, wildcard/numeric masks, modulo-byte values and permissive separators. Parsing failure still returns outer success1, marks comparison-1 and preserves other fields; count growth is not rolled back. Successful insert sets metadata-1. Optional252500 export is requested even after parse failure; full-capacity refusal skips it. Full-table scans execute with a bounded262144-instruction budget. Table/export/network provenance and malformed counts remain open. [Evidence](research/QVM_FILTER_INSERT.md).
+
+
+**RE-933:** Rust matches132 original252829/252304 table cases including4096-capacity scans, first-hole reuse, wildcard/numeric masks and comparison-1 sentinel behavior. Parser failure retains count growth and requests optional export, matching the source. Typed malformed counts/token-overflow domains reject atomically. Export body252500, live table writers and native network acceptance remain open. [Evidence](research/RUST_FILTER_INSERT.md).

docs/PROVISIONAL_TODO.md

@@ -1839,3 +1839,9 @@ RE-931: Rust matches96 complete source173979/161744/182896 compositions, includi
 
 
 RE-932: 132 actual252829/252304/37159 cases recover first-hole reuse, append/count growth,4096 capacity, wildcard/numeric masks, modulo-byte values and permissive separators. Parsing failure still returns outer success1, marks comparison-1 and preserves other fields; count growth is not rolled back. Successful insert sets metadata-1. Optional252500 export is requested even after parse failure; full-capacity refusal skips it. Full-table scans execute with a bounded262144-instruction budget. Table/export/network provenance and malformed counts remain open. Full runtime completion remains open. [Evidence](research/QVM_FILTER_INSERT.md).
+
+
+RE-933: Rust matches132 original252829/252304 table cases including4096-capacity scans, first-hole reuse, wildcard/numeric masks and comparison-1 sentinel behavior. Parser failure retains count growth and requests optional export, matching the source. Typed malformed counts/token-overflow domains reject atomically. Export body252500, live table writers and native network acceptance remain open. Full runtime completion remains open. [Evidence](research/RUST_FILTER_INSERT.md).
+
+
+RE-924–933 completed bounded bot settings, announcement, connect-child composition and filter insertion contracts. RE-934 tracks bot setup/userinfo/filter export, native resource/network acceptance and complete runtime integration. [Batch and next work](research/QVM_BOT_ANNOUNCEMENT_FILTER_BATCH.md).

docs/RESEARCH_LEDGER.md

@@ -2390,3 +2390,10 @@ Rust matches96 complete source173979/161744/182896 compositions, including setti
 ## 2026-10-28 — RE-932 Original address-filter table insertion and wildcard parser
 
 132 actual252829/252304/37159 cases recover first-hole reuse, append/count growth,4096 capacity, wildcard/numeric masks, modulo-byte values and permissive separators. Parsing failure still returns outer success1, marks comparison-1 and preserves other fields; count growth is not rolled back. Successful insert sets metadata-1. Optional252500 export is requested even after parse failure; full-capacity refusal skips it. Full-table scans execute with a bounded262144-instruction budget. Table/export/network provenance and malformed counts remain open. Focused `cargo xtask test-group qvm-filter-insert` passes (4 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-28 — RE-933 Rust filter insertion and non-rollback semantics
+
+Rust matches132 original252829/252304 table cases including4096-capacity scans, first-hole reuse, wildcard/numeric masks and comparison-1 sentinel behavior. Parser failure retains count growth and requests optional export, matching the source. Typed malformed counts/token-overflow domains reject atomically. Export body252500, live table writers and native network acceptance remain open. Focused `cargo xtask test-group rust-filter-insert` 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.
+
+Batch RE-924–933 boundary: the single `cargo xtask test-full --since bc3e7621` run after commit ten passed with the flake-declared Nix Python: 1,798 Python tests, 225 Rust tests (assets 10, gameplay 185, xtask 30), 42 deterministic report producers, storage policy, 502 documentation files and whitespace guards. No generated report drift. Validation notes were amended into task ten; original assets unchanged. See [batch findings and next work](research/QVM_BOT_ANNOUNCEMENT_FILTER_BATCH.md).

docs/REVERSE_ENGINEERING_TODO.md

@@ -1848,7 +1848,7 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 - [x] RE-923 Rust complete connect policy composition ([evidence](research/RUST_CONNECT_COMPLETE.md)).
 
 
-- [ ] RE-924 Recover bot/userinfo/team/ranking callback bodies, filter writers and native engine acceptance, with remaining scalar/alias and full runtime integration ([next work](research/QVM_CONNECT_POLICY_BATCH.md)).
+- [ ] Follow-up after RE-923: recover bot/userinfo/team/ranking callback bodies, filter writers and native engine acceptance, with remaining scalar/alias and full runtime integration ([next work](research/QVM_CONNECT_POLICY_BATCH.md)).
 
 
 - [x] RE-924 Original bot settings admission wrapper ([evidence](research/QVM_BOT_SETTINGS.md)).
@@ -1876,3 +1876,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-932 Original address-filter table insertion and wildcard parser ([evidence](research/QVM_FILTER_INSERT.md)).
+
+
+- [x] RE-933 Rust filter insertion and non-rollback semantics ([evidence](research/RUST_FILTER_INSERT.md)).
+
+
+- [ ] RE-934 Recover bot setup/userinfo/filter-export internals, native resource/network acceptance and remaining runtime integration ([next work](research/QVM_BOT_ANNOUNCEMENT_FILTER_BATCH.md)).

docs/TESTING.md

@@ -172,3 +172,6 @@ RE-904–913 adds focused groups `qvm-session-init`, `rust-session-init`, `qvm-p
 
 
 RE-914–923 adds `qvm-byte-compare`, `rust-byte-compare`, `qvm-address-filter`, `rust-address-filter`, `qvm-connect-admission`, `rust-connect-admission`, `qvm-connect-tail`, `rust-connect-tail`, `qvm-connect-complete` and `rust-connect-complete`. Invoke one group per command. Full validation after task ten uses `cargo xtask test-full --since 2b1ac7ec` with explicit flake-declared Nix PYTHON. [Bounded connect evidence](research/QVM_CONNECT_POLICY_BATCH.md).
+
+
+RE-924–933 adds `qvm-bot-settings`, `rust-bot-settings`, `qvm-team-announcement`, `rust-team-announcement`, `qvm-resolved-connect-tail`, `rust-resolved-connect-tail`, `qvm-resolved-connect-complete`, `rust-resolved-connect-complete`, `qvm-filter-insert` and `rust-filter-insert`. Use one group per invocation. Full validation after task ten uses `cargo xtask test-full --since bc3e7621` with explicit flake-declared Nix PYTHON. [Callback/filter evidence](research/QVM_BOT_ANNOUNCEMENT_FILTER_BATCH.md).

docs/research/QVM_BOT_ANNOUNCEMENT_FILTER_BATCH.md

@@ -0,0 +1,51 @@
+# Connect children and filter insertion: RE-924–933
+
+Ten separately committed tasks recover concrete callback bodies, integrate them into connect policies, and recover filter-table insertion across822 paired source/Rust cases. Native125185 bot setup,171668 userinfo mutation, ranking, engine/network/IO and filter export252500 remain explicit supplied/captured boundaries. This evidence does not establish native multiplayer acceptance or complete gameplay.
+
+| Task | Evidence | Cases |
+| --- | --- | ---: |
+| RE-924 | [Bot161744 settings/drop wrapper](QVM_BOT_SETTINGS.md) | 288 |
+| RE-925 | [Rust bot setup record](RUST_BOT_SETTINGS.md) | 288 |
+| RE-926 | [Announcement182896](QVM_TEAM_ANNOUNCEMENT.md) | 162 |
+| RE-927 | [Rust exact announcements](RUST_TEAM_ANNOUNCEMENT.md) | 162 |
+| RE-928 | [Suffix with recovered children](QVM_RESOLVED_CONNECT_TAIL.md) | 144 |
+| RE-929 | [Rust composed suffix children](RUST_RESOLVED_CONNECT_TAIL.md) | 144 |
+| RE-930 | [Whole connect with recovered children](QVM_RESOLVED_CONNECT_COMPLETE.md) | 96 |
+| RE-931 | [Rust whole connect child policies](RUST_RESOLVED_CONNECT_COMPLETE.md) | 96 |
+| RE-932 | [Filter252829 insertion/252304 parser](QVM_FILTER_INSERT.md) | 132 |
+| RE-933 | [Rust filter insertion semantics](RUST_FILTER_INSERT.md) | 132 |
+
+## Bot setup wrapper and announcement semantics
+
+Actual161744 requests native userinfo, then looks up characterfile, skill and team through actual70503. It copies characterfile/team into144-byte fields with143 logical bytes plus NUL padding; the four bytes between those fields contain the raw f32 result of actual37144/36779 skill conversion. This292-byte settings record, client slot and restart argument reach125185. A nonzero supplied result becomes1; zero captures native -17 drop with exact BotAISetupClient failed text, then returns0. Fixtures include long/raw-byte strings, negative/prefix skills, restart values and negative nonzero setup replies. Setup125185 internals, botlib allocations and engine drop acceptance remain open.
+
+Actual182896 is an announcement body, with no team-selection mutation. Teams0/1/2 broadcast `ccprint "5" "name" "team"`; team3 broadcasts spectator text only when the supplied previous team differs from3. Other team values do nothing. Original70458/37914 performs formatting, including raw name bytes and wrapping global23708. Native sends are captured. Earlier event/API labels Join and choice identify this historical request boundary; the parameter is previous-team context, not a new team choice.
+
+The144 suffix and96 whole-caller fixtures replace the supplied161744 boolean and captured182896 request with these original bodies. Parent control flow, client/entity state, messages and persistence timing remain identical to the earlier caller fixtures. New evidence includes actual bot settings records and drop requests, the additional three userinfo-selector toggles per bot wrapper, precise team broadcasts and extra formatter advancement. The separate child records attach to parent Bot/Join markers. Rust derives these pure supplied-snapshot policies without executing native effects. Actual setup, arbitrary userinfo mutations and ranking/network/logging callbacks still need integration.
+
+## Filter table mutation
+
+Actual252829 scans comparison words for the first -1 hole, otherwise appends and increments count36275948, with an exact4096-capacity refusal. It calls actual252304 to parse the input. That parser initializes four mask/value bytes, accepts digit/* tokens separated by any single separator, uses sole * as wildcard, and otherwise applies original signed integer-prefix conversion then stores the low byte. Missing components remain wildcarded; empty/trailing-invalid components fail. Masks/values are little-endian words. Very long integer tokens, malformed counts and raw pointer/token overflow outside the verified safe subset remain open.
+
+On parse success, the selected record receives mask/value and metadata-1. On parse failure, comparison becomes-1 while mask/metadata remain as before; an already-grown count is not rolled back. The outer routine returns1 even for this parser failure and requests optional252500 export. A full-capacity refusal returns0 and skips export. Fixtures cover empty/append/reused-hole/full-capacity tables, wildcard and mixed tokens, invalid text and255.255.255.255. The latter comparison word equals the hole sentinel; this ambiguity is preserved rather than reinterpreted. Export body252500 and its treatment of sentinels remain open.
+
+Full4096-entry source scans use a bounded262144-instruction budget; table-wide FNV-1a checksums and before/after record snapshots verify untouched entries as well as the selected slot. Rust requires explicit table storage/count, stages unsupported domains without mutation, and preserves normal parse-failure mutation/export semantics. Its safe token domain rejects128-byte component tokens before the original scratch-buffer boundary. This is not strict IP validation or a native network filter implementation.
+
+## Validation
+
+Each task ran focused `cargo xtask test-group <name>` before its own commit, including deterministic double regeneration, relevant source/Rust parity, scoped gameplay tests and storage/documentation/whitespace guards. Groups are qvm-bot-settings, rust-bot-settings, qvm-team-announcement, rust-team-announcement, qvm-resolved-connect-tail, rust-resolved-connect-tail, qvm-resolved-connect-complete, rust-resolved-connect-complete, qvm-filter-insert and rust-filter-insert. Shared parent policies received focused regression checks.
+
+Dependency-selection regression coverage includes all five new source/Rust report pairs, native_policy consumers and formatting dependencies. Existing health/session import smoke checks remain intact. Every Python process uses the resolved Nix runtime declared by flake.nix, with explicit PYTHON for xtask and Git hooks. Original assets are unchanged.
+
+After task ten, the single `cargo xtask test-full --since bc3e7621` run passed: 1,798 Python tests, 225 Rust tests (assets 10, gameplay 185, xtask 30), 42 deterministic report producers, storage policy, documentation links across 502 files and whitespace guards. Report regeneration left no drift. These validation notes are amended into task ten, preserving ten task commits for the batch.
+
+## Next work: RE-934
+
+- [ ] Recover125185 bot setup internals and native botlib resource/failure ownership, then compose them with161744 and whole connect.
+- [ ] Recover171668 userinfo parsing/sanitization/state mutation and all related callbacks; compose actual5864 ranking/publication and native network effects.
+- [ ] Recover252500 filter export and related removal/expiry/table writers; verify comparison-1 sentinel ambiguity, malformed counts/token overflow and live network provenance.
+- [ ] Attach real cvar/file/network adapters and validate actual connect/reload/failure behavior on macOS/Linux, preserving observed operation order.
+- [ ] Extend scanner/string/alias domains and trace actual caller scratch provenance.
+- [ ] Compose series6939/readiness, native commands, bot rotation/genetics and221662 map-list parsing.
+- [ ] Replace supplied spatial-query answers with native broadphase/world collision, and complete respawn/intermission/event/scoreboard integration.
+- [ ] Validate actual Linux/macOS Rust/Bevy/Solari gameplay/rendering. Full-game completion remains open.

docs/research/QVM_CONNECT_POLICY_BATCH.md

@@ -43,7 +43,7 @@ Every task ran focused `cargo xtask test-group <name>` before its own commit, wi
 
 Dependency-selection regression coverage includes the five new source/Rust report pairs, native_policy consumers and intermission/formatting dependencies. The existing health/session helper import smoke check remains in place. Every Python process uses the resolved Nix runtime declared by flake.nix, with explicit PYTHON for xtask and Git hooks. After commit ten, `cargo xtask test-full --since 2b1ac7ec` passed on its first full attempt: 1,783 Python tests and216 Rust tests (assets10, gameplay176, xtask30). All32 affected report producers regenerated twice deterministically. Storage policy, links across491 documentation files and whitespace checks passed with no generated-report drift. Validation notes were amended into task ten.
 
-## Next work: RE-924
+## Follow-up work (expanded by RE-924–933)
 
 - [ ] Recover161744 bot admission,171668 userinfo mutation and182896 team-join callback bodies, then compose them with173979 and actual5864 ranking/publication.
 - [ ] Recover address-filter table writers and native IP/userinfo provenance; verify partial-address stack provenance, aliases, malformed counts and live configuration changes.
@@ -53,3 +53,5 @@ Dependency-selection regression coverage includes the five new source/Rust repor
 - [ ] Replace supplied spatial-query answers with recovered native broadphase/world collision and compare native math.
 - [ ] Compose complete respawn/intermission, event lifetime and scoreboard/network execution.
 - [ ] Validate actual Linux/macOS Rust/Bevy/Solari gameplay/rendering. Full-game completion remains open.
+
+[RE-924–933](QVM_BOT_ANNOUNCEMENT_FILTER_BATCH.md) recovers bot settings, announcement and filter-insertion bodies and composes the connect children. Its RE-934 list supersedes the historical follow-up list above.

docs/research/README.md

@@ -1411,3 +1411,9 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-932: Original address-filter table insertion and wildcard parser](QVM_FILTER_INSERT.md).
+
+
+[RE-933: Rust filter insertion and non-rollback semantics](RUST_FILTER_INSERT.md).
+
+
+[RE-924–933 bot/announcement/filter batch](QVM_BOT_ANNOUNCEMENT_FILTER_BATCH.md).

docs/research/RUST_FILTER_INSERT.md

@@ -0,0 +1,7 @@
+# Rust filter insertion and non-rollback semantics
+
+RE-933. Reproduce with `python3 scripts/analyze_rust_filter_insert.py`; focused validation: `cargo xtask test-group rust-filter-insert`. [Machine report](rust-filter-insert.json).
+
+Rust matches132 original252829/252304 table cases including4096-capacity scans, first-hole reuse, wildcard/numeric masks and comparison-1 sentinel behavior. Parser failure retains count growth and requests optional export, matching the source. Typed malformed counts/token-overflow domains reject atomically. Export body252500, live table writers and native network acceptance remain open.
+
+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": 183,
+  "rust_unit_tests": 185,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_filter_insert.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+import hashlib,json
+from pathlib import Path
+from rust_native_policy_support import binary,result,invoke
+from analyze_qvm import write_json
+def encode(s):
+ a=s['input'];text=bytes.fromhex(a['text']);return [a['profile'],a['save'],len(text),*text]
+def project(s):return {k:s[k] for k in ['result','slot','parsed','diagnostics','exports','before_count','count','before','after','checksum']}
+
+def main():
+ b=binary();p=Path('docs/research/qvm-filter-insert.json');data=p.read_bytes();rows=[]
+ for s in json.loads(data)['probes']:rows.append({'source':project(s),'rust':result(b,'filter-insert',encode(s))})
+ write_json(Path('docs/research/rust-filter-insert.json'),{'source_report':str(p),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust matches132 original252829/252304 table cases including4096-capacity scans, first-hole reuse, wildcard/numeric masks and comparison-1 sentinel behavior. Parser failure retains count growth and requests optional export, matching the source. Typed malformed counts/token-overflow domains reject atomically. Export body252500, live table writers and native network acceptance remain open.'})
+if __name__=='__main__':main()

scripts/test_rust_filter_insert.py

@@ -0,0 +1,9 @@
+import hashlib,json,unittest
+from pathlib import Path
+class PortTests(unittest.TestCase):
+ def test_all_original_cases(self):
+  r=json.loads(Path('docs/research/rust-filter-insert.json').read_text());src=json.loads(Path(r['source_report']).read_text());self.assertEqual(len(r['probes']),len(src['probes']));self.assertGreater(len(r['probes']),20)
+  for p in r['probes']:self.assertEqual(p['rust'],p['source'])
+ def test_source_identity(self):
+  r=json.loads(Path('docs/research/rust-filter-insert.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

@@ -3092,3 +3092,16 @@ group	qvm-filter-insert	scripts/analyze_qvm_filter_insert.py
 edge	scripts/analyze_qvm_filter_insert.py	scripts/analyze_qvm_resumer_audit.py
 edge	scripts/qvm_filter_insert_oracle.py	scripts/analyze_qvm_resumer_audit.py
 edge	scripts/qvm_filter_update_support.py	scripts/analyze_qvm_resumer_audit.py
+edge	Cargo.toml	scripts/analyze_rust_filter_insert.py
+edge	Cargo.lock	scripts/analyze_rust_filter_insert.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_filter_insert.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_filter_insert.py
+edge	crates/urt-gameplay/src/native_policy.rs	scripts/analyze_rust_filter_insert.py
+edge	crates/urt-gameplay/src/bin/urt-native-policy.rs	scripts/analyze_rust_filter_insert.py
+edge	docs/research/qvm-filter-insert.json	scripts/analyze_rust_filter_insert.py
+group	rust-filter-insert	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_filter_insert.py
+report	scripts/analyze_rust_filter_insert.py	docs/research/rust-filter-insert.json
+edge	docs/research/rust-filter-insert.json	scripts/test_rust_filter_insert.py
+group	rust-filter-insert	scripts/analyze_rust_filter_insert.py
+edge	scripts/analyze_rust_filter_insert.py	scripts/analyze_qvm_resumer_audit.py

xtask/src/lib.rs

@@ -1123,6 +1123,12 @@ mod integration_tests {
             ("native_policy", "connect_tail"),
             ("native_policy", "connect_complete"),
             ("intermission", "connect_complete"),
+            ("native_policy", "bot_settings"),
+            ("native_policy", "team_announcement"),
+            ("native_policy", "resolved_connect_tail"),
+            ("native_policy", "resolved_connect_complete"),
+            ("native_policy", "filter_insert"),
+            ("qvm_format", "resolved_connect_complete"),
             ("protected", "protected_update"),
             ("mode10", "mode10_entry"),
             ("intercept_animation", "mode10_animation"),
@@ -1207,6 +1213,11 @@ mod integration_tests {
             ("qvm-connect-admission", "connect_admission"),
             ("qvm-connect-tail", "connect_tail"),
             ("qvm-connect-complete", "connect_complete"),
+            ("qvm-bot-settings", "bot_settings"),
+            ("qvm-team-announcement", "team_announcement"),
+            ("qvm-resolved-connect-tail", "resolved_connect_tail"),
+            ("qvm-resolved-connect-complete", "resolved_connect_complete"),
+            ("qvm-filter-insert", "filter_insert"),
             ("qvm-rank-small-sort", "rank_sort"),
             ("qvm-rank-large-sort", "rank_sort"),
             ("qvm-ranking-complete", "ranking_complete"),