CultLib/contracts/cultnet/interop/selection-vectors.cs-written.json

334 lines
16 KiB
JSON
Raw Normal View History

CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
{
"vectors": [
{
"name": "any_of_plus_ge_conjunction",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzwKZmaWVsZHOShKVpbmRleKRraW5kom9wpmFueV9vZqZ2YWx1ZXORpndlYXBvbqZudW1iZXLAhKVpbmRleKRtYXNzom9womdlpnZhbHVlc8CmbnVtYmVyoTWlY2l0ZXPApWNpdGVkwKpwcm9qZWN0aW9upmhlYWRlcqpkZXNjZW5kaW5nwqVsaW1pdMCmY3Vyc29ywA==",
"asOf": 1,
"expectedRefusalField": null,
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"expectedIds": [
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/a-eq"
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
],
"matched": 1,
"hasNext": false,
"expectedEdges": []
},
{
"name": "descending_with_limit",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzwKZmaWVsZHPApWNpdGVzwKVjaXRlZMCqcHJvamVjdGlvbqZoZWFkZXKqZGVzY2VuZGluZ8OlbGltaXQDpmN1cnNvcsA=",
"asOf": 1,
"expectedRefusalField": null,
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"expectedIds": [
"sha256:9d0bc9aebc3619b07aabf564f98667afde41444c1b866661d777687d443608dc/citer-both-in-target",
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/aa-tie-schema",
"sha256:b1f2407d0227a79dcbffdf7ea317f827eec64be38a3f61b7d4e99e81e3b24b42/zz-tie-schema"
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
],
"matched": 18,
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"hasNext": true,
"expectedEdges": []
},
{
"name": "gt_numeric_boundary",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzwKZmaWVsZHORhKVpbmRleKRtYXNzom9womd0pnZhbHVlc8CmbnVtYmVyoTGlY2l0ZXPApWNpdGVkwKpwcm9qZWN0aW9upmhlYWRlcqpkZXNjZW5kaW5nwqVsaW1pdMCmY3Vyc29ywA==",
"asOf": 1,
"expectedRefusalField": null,
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"expectedIds": [
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/a-lo",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/a-eq",
"sha256:b1f2407d0227a79dcbffdf7ea317f827eec64be38a3f61b7d4e99e81e3b24b42/b-hi",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/tie-mass"
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
],
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
"matched": 4,
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"hasNext": false,
"expectedEdges": []
},
{
"name": "incoming_exists_true",
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"selectionMessagePackBase64": "iadzY2hlbWFzkdlHc2hhMjU2OmZmMzVmM2Q5ZDZkZTNmMTA2NmI5MzY5ZTczZmU2Yzc2NDhlODgzNjhkMThlZmMyMjc1Yzk5NDczMGNkODRjZmaka2V5c8CmZmllbGRzwKVjaXRlc8ClY2l0ZWSCpHJvbGWmRGVzaWdupmV4aXN0c8OqcHJvamVjdGlvbqZoZWFkZXKqZGVzY2VuZGluZ8KlbGltaXTApmN1cnNvcsA=",
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"asOf": 1,
"expectedRefusalField": null,
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"expectedIds": [
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/a-eq",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/dup-key"
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
],
"matched": 2,
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"hasNext": false,
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
"expectedEdges": [
{
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"fromId": "sha256:9d0bc9aebc3619b07aabf564f98667afde41444c1b866661d777687d443608dc/citer-1",
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
"role": "Design",
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"toId": "sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/a-eq",
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
"payloadBase64": null
},
{
"fromId": "sha256:9d0bc9aebc3619b07aabf564f98667afde41444c1b866661d777687d443608dc/citer-both-in-target",
"role": "Design",
"toId": "sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/dup-key",
"payloadBase64": null
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
}
]
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
},
{
"name": "incoming_negation",
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"selectionMessagePackBase64": "iadzY2hlbWFzkdlHc2hhMjU2OmZmMzVmM2Q5ZDZkZTNmMTA2NmI5MzY5ZTczZmU2Yzc2NDhlODgzNjhkMThlZmMyMjc1Yzk5NDczMGNkODRjZmaka2V5c8CmZmllbGRzwKVjaXRlc8ClY2l0ZWSCpHJvbGWmRGVzaWdupmV4aXN0c8KqcHJvamVjdGlvbqZoZWFkZXKqZGVzY2VuZGluZ8KlbGltaXTApmN1cnNvcsA=",
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"asOf": 1,
"expectedRefusalField": null,
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"expectedIds": [
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/a-lo",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/shared-1",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/shared-3",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/tie-mass",
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/-row",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/\uD83D\uDE02-row",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/aa-tie-schema"
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
],
"matched": 7,
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"hasNext": false,
"expectedEdges": []
},
{
"name": "shared_index_value_three_rows",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzwKZmaWVsZHORhKVpbmRleKRraW5kom9wpmFueV9vZqZ2YWx1ZXORpnNoYXJlZKZudW1iZXLApWNpdGVzwKVjaXRlZMCqcHJvamVjdGlvbqZoZWFkZXKqZGVzY2VuZGluZ8KlbGltaXTApmN1cnNvcsA=",
"asOf": 1,
"expectedRefusalField": null,
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"expectedIds": [
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/shared-1",
"sha256:b1f2407d0227a79dcbffdf7ea317f827eec64be38a3f61b7d4e99e81e3b24b42/shared-2",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/shared-3"
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
],
"matched": 3,
"hasNext": false,
"expectedEdges": []
},
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
{
"name": "float_tie_exact_ge",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzwKZmaWVsZHORhKVpbmRleKRtYXNzom9womdlpnZhbHVlc8CmbnVtYmVyqjIyMzM3NTkuMjWlY2l0ZXPApWNpdGVkwKpwcm9qZWN0aW9upmhlYWRlcqpkZXNjZW5kaW5nwqVsaW1pdMCmY3Vyc29ywA==",
"asOf": 1,
"expectedRefusalField": null,
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
"expectedIds": [
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/tie-mass"
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
],
"matched": 1,
"hasNext": false,
"expectedEdges": []
},
{
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"name": "hop_by_role_cites_exact_id",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzkadjaXRlci0xpmZpZWxkc8ClY2l0ZXOCpnRhcmdldIKoc2NoZW1hSWTZR3NoYTI1NjpmZjM1ZjNkOWQ2ZGUzZjEwNjZiOTM2OWU3M2ZlNmM3NjQ4ZTg4MzY4ZDE4ZWZjMjI3NWM5OTQ3MzBjZDg0Y2ZmqXJlY29yZEtleaRhLWVxpHJvbGWmRGVzaWdupWNpdGVkwKpwcm9qZWN0aW9upmhlYWRlcqpkZXNjZW5kaW5nwqVsaW1pdMCmY3Vyc29ywA==",
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
"asOf": 1,
"expectedRefusalField": null,
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
"expectedIds": [
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"sha256:9d0bc9aebc3619b07aabf564f98667afde41444c1b866661d777687d443608dc/citer-1"
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
],
"matched": 1,
"hasNext": false,
"expectedEdges": [
{
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"fromId": "sha256:9d0bc9aebc3619b07aabf564f98667afde41444c1b866661d777687d443608dc/citer-1",
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
"role": "Design",
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"toId": "sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/a-eq",
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
"payloadBase64": null
}
]
},
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
{
"name": "cites_target_by_name_alias",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzkadjaXRlci0xpmZpZWxkc8ClY2l0ZXOCpnRhcmdldIKoc2NoZW1hSWSpbGVhZl9hLnY5qXJlY29yZEtleaRhLWVxpHJvbGWmRGVzaWdupWNpdGVkwKpwcm9qZWN0aW9upmhlYWRlcqpkZXNjZW5kaW5nwqVsaW1pdMCmY3Vyc29ywA==",
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"asOf": 1,
"expectedRefusalField": null,
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"expectedIds": [
"sha256:9d0bc9aebc3619b07aabf564f98667afde41444c1b866661d777687d443608dc/citer-1"
],
"matched": 1,
"hasNext": false,
"expectedEdges": [
{
"fromId": "sha256:9d0bc9aebc3619b07aabf564f98667afde41444c1b866661d777687d443608dc/citer-1",
"role": "Design",
"toId": "sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/a-eq",
"payloadBase64": null
}
]
},
{
"name": "schemas_by_name_alias",
"selectionMessagePackBase64": "iadzY2hlbWFzkalsZWFmX2Eudjmka2V5c8CmZmllbGRzwKVjaXRlc8ClY2l0ZWTAqnByb2plY3Rpb26maGVhZGVyqmRlc2NlbmRpbmfCpWxpbWl0wKZjdXJzb3LA",
"asOf": 1,
"expectedRefusalField": null,
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"expectedIds": [
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/a-lo",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/a-eq",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/shared-1",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/shared-3",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/tie-mass",
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/-row",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/\uD83D\uDE02-row",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/dup-key",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/aa-tie-schema"
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
],
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"matched": 9,
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"hasNext": false,
"expectedEdges": []
},
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
{
"name": "astral_key_code_point_order",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzwKZmaWVsZHORhKVpbmRleKRraW5kom9wpmFueV9vZqZ2YWx1ZXORp3VuaWNvZGWmbnVtYmVywKVjaXRlc8ClY2l0ZWTAqnByb2plY3Rpb26maGVhZGVyqmRlc2NlbmRpbmfCpWxpbWl0wKZjdXJzb3LA",
"asOf": 1,
"expectedRefusalField": null,
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
"expectedIds": [
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/-row",
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/\uD83D\uDE02-row"
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
],
"matched": 2,
"hasNext": false,
"expectedEdges": []
},
{
"name": "header_projection",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzwKZmaWVsZHORhKVpbmRleKRraW5kom9wpmFueV9vZqZ2YWx1ZXORp3VuaWNvZGWmbnVtYmVywKVjaXRlc8ClY2l0ZWTAqnByb2plY3Rpb26maGVhZGVyqmRlc2NlbmRpbmfCpWxpbWl0wKZjdXJzb3LA",
"asOf": 1,
"expectedRefusalField": null,
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
"expectedIds": [
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/-row",
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/\uD83D\uDE02-row"
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
],
"matched": 2,
"hasNext": false,
"expectedEdges": []
},
{
"name": "document_projection",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzwKZmaWVsZHORhKVpbmRleKRraW5kom9wpmFueV9vZqZ2YWx1ZXORp3VuaWNvZGWmbnVtYmVywKVjaXRlc8ClY2l0ZWTAqnByb2plY3Rpb26oZG9jdW1lbnSqZGVzY2VuZGluZ8KlbGltaXTApmN1cnNvcsA=",
"asOf": 1,
"expectedRefusalField": null,
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
"expectedIds": [
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/-row",
CultNet selection cut1: the shared C#/Rust parity fixture Reconciles the two Hands' independently-regenerated parity vectors (Soul's whole-cut pass, F3): the C# fixture used schema *names* ("leaf_a") as literal ids, the Rust fixture used invented fake sha256-shaped ids - every vector carrying an id failed when read by the other runtime. Adds contracts/cultnet/interop/selection-vectors.fixture.json: the one row set both writers now build from, keyed by each schema's real SHA-256 content-hash id exactly as CultDocumentRegistry computes it (dumped via a temporary DumpFixtureSchemaIds run). Carries the rows either runtime needs - astral/BMP-private-use keys, a float tie, cites/cited, a cites target reached by alias - plus two DIFFERENT alias forms, because the two runtimes' alias matchers key off different descriptor attributes and no single candidate resolves through both (see the fixture's "//aliases" note and the report). Rewrites SelectionParityVectorTests.cs to load the fixture instead of hand-building rows (BuildFixture/BuildExtendedFixture deleted), assert the fixture's declared schema ids still match what the registry computes (fails loudly on drift instead of silently comparing wrong ids), and use the real schema id (not SchemaName) as a row's cross-runtime identity. Also fixes a real bug this file carried since before the shared fixture: both the writer and the reader compared `evaluation.Rows.Count` (the page size) against "matched" instead of `evaluation.TotalMatched` (the total, per R-G) - selections with a Limit were writing/checking the wrong number. The reader now collects every vector's mismatch instead of stopping at the first one, so a real parity defect is reported in full. Regenerates selection-vectors.cs-written.json from the shared fixture. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:33:29 +02:00
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/\uD83D\uDE02-row"
CultNet selection cut1 fix batch: regenerate the C#-written parity vectors Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json under R-B/R-C/R-D/R-E/R-I. SelectionParityVectorTests.cs: the six original cases' fixture (BuildFixture) is left untouched, because SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference reads the already-committed selection-vectors.rs-written.json against it, and a new row reachable by an unfiltered or loosely-filtered case (descending_with_limit, gt_numeric_boundary) would silently change that case's expected page. The fix-batch rows and cases live in a new BuildExtendedFixture/Cases set, additive over BuildFixture, used only by WriteSelectionVectors: - float_tie_exact_ge: a row at 2233759.25f, on the round-to-even tie R-D's exact BigInteger rendering fixes (its canonical decimal is "2233759.25" regardless of which shortest form a runtime's ToString would have picked). - cites_target_by_alias: cites.target.schemaId given as "leaf_a" (ParityLeafA's SchemaName) against a-eq's real content-hash SchemaId, exercising R-E's alias-matched cites (the pre-fix code required an exact SchemaId match and this always missed). - astral_key_code_point_order: two rows sharing one ordinal, keyed by a BMP private-use character (U+E000) and an astral character (U+1F602, surrogate pair 😂), pinning R-C's code-point tiebreak order. - header_projection/document_projection: the same hop-bearing match set under each projection. Known-expected failure: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference fails against the currently-committed selection-vectors.rs-written.json (incoming_exists_true's edge count) because that file predates R-B and was not touched here - the parallel Rust Hands owns it. Re-run once it regenerates. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 09:40:18 +02:00
],
"matched": 2,
"hasNext": false,
"expectedEdges": []
},
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
{
"name": "row_tiebreak_schema_id_before_record_key_at_tied_ordinal",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzwKZmaWVsZHORhKVpbmRleKRraW5kom9wpmFueV9vZqZ2YWx1ZXORqnRpZS1zY2hlbWGmbnVtYmVywKVjaXRlc8ClY2l0ZWTAqnByb2plY3Rpb26maGVhZGVyqmRlc2NlbmRpbmfCpWxpbWl0wKZjdXJzb3LA",
"asOf": 1,
"expectedRefusalField": null,
"expectedEvaluationRefusal": null,
"expectedIds": [
"sha256:b1f2407d0227a79dcbffdf7ea317f827eec64be38a3f61b7d4e99e81e3b24b42/zz-tie-schema",
"sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/aa-tie-schema"
],
"matched": 2,
"hasNext": false,
"expectedEdges": []
},
{
"name": "shared_key_narrow_ref_resolves_leaf_within_target",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzkbVuYXJyb3ctY2l0ZXItYWNjZXB0ZWSmZmllbGRzwKVjaXRlc4KmdGFyZ2V0gqhzY2hlbWFJZNlHc2hhMjU2OmZmMzVmM2Q5ZDZkZTNmMTA2NmI5MzY5ZTczZmU2Yzc2NDhlODgzNjhkMThlZmMyMjc1Yzk5NDczMGNkODRjZmapcmVjb3JkS2V5p2R1cC1rZXmkcm9sZapuYXJyb3dfcmVmpWNpdGVkwKpwcm9qZWN0aW9upmhlYWRlcqpkZXNjZW5kaW5nwqVsaW1pdMCmY3Vyc29ywA==",
"asOf": 1,
"expectedRefusalField": null,
"expectedEvaluationRefusal": null,
"expectedIds": [
"sha256:ee192f6526a8f8cdec7044551aa2c8e28c612426766bb270605023bc94e2614d/narrow-citer-accepted"
],
"matched": 1,
"hasNext": false,
"expectedEdges": [
{
"fromId": "sha256:ee192f6526a8f8cdec7044551aa2c8e28c612426766bb270605023bc94e2614d/narrow-citer-accepted",
"role": "narrow_ref",
"toId": "sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/dup-key",
"payloadBase64": null
}
]
},
{
"name": "shared_key_design_resolves_the_first_in_target_candidate_in_row_order",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzkbRjaXRlci1ib3RoLWluLXRhcmdldKZmaWVsZHPApWNpdGVzgqZ0YXJnZXSCqHNjaGVtYUlk2UdzaGEyNTY6ZmYzNWYzZDlkNmRlM2YxMDY2YjkzNjllNzNmZTZjNzY0OGU4ODM2OGQxOGVmYzIyNzVjOTk0NzMwY2Q4NGNmZqlyZWNvcmRLZXmnZHVwLWtleaRyb2xlpkRlc2lnbqVjaXRlZMCqcHJvamVjdGlvbqZoZWFkZXKqZGVzY2VuZGluZ8KlbGltaXTApmN1cnNvcsA=",
"asOf": 1,
"expectedRefusalField": null,
"expectedEvaluationRefusal": null,
"expectedIds": [
"sha256:9d0bc9aebc3619b07aabf564f98667afde41444c1b866661d777687d443608dc/citer-both-in-target"
],
"matched": 1,
"hasNext": false,
"expectedEdges": [
{
"fromId": "sha256:9d0bc9aebc3619b07aabf564f98667afde41444c1b866661d777687d443608dc/citer-both-in-target",
"role": "Design",
"toId": "sha256:ff35f3d9d6de3f1066b9369e73fe6c7648e88368d18efc2275c994730cd84cff/dup-key",
"payloadBase64": null
}
]
},
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
{
"name": "refuses_empty_schemas_list",
"selectionMessagePackBase64": "iadzY2hlbWFzkKRrZXlzwKZmaWVsZHPApWNpdGVzwKVjaXRlZMCqcHJvamVjdGlvbqZoZWFkZXKqZGVzY2VuZGluZ8KlbGltaXTApmN1cnNvcsA=",
"asOf": 1,
"expectedRefusalField": "schemas",
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"expectedIds": [],
"matched": 0,
"hasNext": false,
"expectedEdges": []
},
{
"name": "refuses_blank_key_entry",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzkqRhLWVxoyAgIKZmaWVsZHPApWNpdGVzwKVjaXRlZMCqcHJvamVjdGlvbqZoZWFkZXKqZGVzY2VuZGluZ8KlbGltaXTApmN1cnNvcsA=",
"asOf": 1,
"expectedRefusalField": "keys",
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
"expectedIds": [],
"matched": 0,
"hasNext": false,
"expectedEdges": []
},
{
"name": "refuses_unmatched_cites_target_schema",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzwKZmaWVsZHPApWNpdGVzgqZ0YXJnZXSCqHNjaGVtYUlkvHNoYTI1Njpub3QtYS1kZWNsYXJlZC1zY2hlbWGpcmVjb3JkS2V5pGEtZXGkcm9sZcClY2l0ZWTAqnByb2plY3Rpb26maGVhZGVyqmRlc2NlbmRpbmfCpWxpbWl0wKZjdXJzb3LA",
"asOf": 1,
"expectedRefusalField": "cites.target.schemaId",
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
"expectedIds": [],
"matched": 0,
"hasNext": false,
"expectedEdges": []
},
{
"name": "refuses_cites_target_by_hash_shaped_alias",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzwKZmaWVsZHPApWNpdGVzgqZ0YXJnZXSCqHNjaGVtYUlk2UpzaGEyNTY6ZmYzNWYzZDlkNmRlM2YxMDY2YjkzNjllNzNmZTZjNzY0OGU4ODM2OGQxOGVmYzIyNzVjOTk0NzMwY2Q4NGNmZi52MalyZWNvcmRLZXmkYS1lcaRyb2xlwKVjaXRlZMCqcHJvamVjdGlvbqZoZWFkZXKqZGVzY2VuZGluZ8KlbGltaXTApmN1cnNvcsA=",
"asOf": 1,
"expectedRefusalField": "cites.target.schemaId",
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
"expectedEvaluationRefusal": null,
"expectedIds": [],
"matched": 0,
"hasNext": false,
"expectedEdges": []
},
{
"name": "shared_key_narrow_ref_refuses_when_only_candidate_is_outside_target",
"selectionMessagePackBase64": "iadzY2hlbWFzwKRrZXlzkbRuYXJyb3ctY2l0ZXItcmVmdXNlZKZmaWVsZHPApWNpdGVzgqZ0YXJnZXSCqHNjaGVtYUlk2UdzaGEyNTY6ZmYzNWYzZDlkNmRlM2YxMDY2YjkzNjllNzNmZTZjNzY0OGU4ODM2OGQxOGVmYzIyNzVjOTk0NzMwY2Q4NGNmZqlyZWNvcmRLZXmrbmFycm93LW9ubHmkcm9sZapuYXJyb3dfcmVmpWNpdGVkwKpwcm9qZWN0aW9upmhlYWRlcqpkZXNjZW5kaW5nwqVsaW1pdMCmY3Vyc29ywA==",
"asOf": 1,
"expectedRefusalField": null,
"expectedEvaluationRefusal": "reference_outside_target",
"expectedIds": [],
"matched": 0,
"hasNext": false,
"expectedEdges": []
CultNet selection cut1, commit 4: the parity vectors, and the ruling this branch landed under Two things landed on this branch while commit 3 was in flight, both addressed here rather than left for the vectors to paper over: **Self's ruling, 2026-09-22 (commit 2 fix batch, 568e8e3/021e3f1): empty lists, blank entries, and v0's own cleaning.** Rust already refused an empty schemas/keys list (inherited from before the ruling); it now also matches the reference's three further decisions exactly, not just in spirit: - The door's refusal field is the plain list name ("schemas"/"keys"), not an indexed "schemas[i]" - selection::validate's SelectionInvalid.field now matches CultNetSelectionInvalidException("schemas", schema, ...) literally, because the parity vectors compare this string across runtimes. - snapshot_query.rs's lower_v0_list now deduplicates a mixed list the same way CultNetV0SelectionLowering.Lower does (Distinct(StringComparer.Ordinal) - order-preserving, first occurrence wins), not just blank-filters it. A new test (serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter, extended) pins the dedup case directly. - Two mutation entries (RS-EmptySchemas-Revert, RS-EmptyKeys-Revert) added for the door's original empty-list refusal, which had tests but no mutation coverage before this commit. **S12: the two-way parity vectors**, contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json, eight vectors each: the six evaluated selections from commit 3 (any_of+ge conjunction, descending+limit, gt boundary, cited exists true/false, three rows sharing one index value) plus two door-refusal vectors added for this ruling - `refuses_empty_schemas_list` (schemas: []) and `refuses_blank_key_entry` (keys: ["a-eq", " "]) - which decode their selection bytes and assert `validate`/`Validate` refuses at exactly the named field, never evaluating. The blank-key vector could not be generated before this commit: the door rule it exercises did not exist in the reference until 568e8e3 landed. `cites`-based hop vectors are deliberately absent (documented in both test files): MatchesCitation compares Citation.Target.SchemaId against the reference's real SHA-256 schema id exactly, with no SchemaName fallback, and this fixture pair has no way to agree on that hash across runtimes; `cited` (role/existence, matched by record key alone) is the hop direction both sides can cross-check, so incoming_exists_true/incoming_negation carry that coverage instead. Both reader tests pass: SelectionVectorsWrittenByRustDecodeAndEvaluateIdenticallyInTheReference (C#) and selection_vectors_written_by_the_reference_decode_and_evaluate_identically_in_rust (Rust), each judging the other runtime's file. **The remaining mutation matrix.** Of the coordinator's named set (S1, S2, S6, S9-S15, S17, S20, S23): S1 was already covered (RS-EmptySchemas/Keys, RS-BlankSchema/Key); S2 (any_of matches membership, RS-S2-Revert) and S6 (cites.role filters the hop, RS-S6-Revert) are newly covered - S6 needed a new fixture (cites_role_excludes_a_second_reference_at_the_same_target) because base_rows()'s citer-1 only ever carries one reference, so a mutant dropping the role filter had nothing else to wrongly match and survived against the original hops_one_edge_by_declared_role test; that finding is recorded in-line as a comment, not silently swapped for an easier mutant. S9-S15 (subscription reconcile, v0-lowering-of-subscribe) do not apply: D7 - no Rust caller subscribes in this cut, so there is no subscription client to mutate. S17 (inherited alias reaches every leaf) does not apply either: Rust's toy Row/RowSet has no inheritance to begin with - both leaves in the fixture declare "mass" independently, which is the Rust spelling of the same guarantee, already exercised throughout the suite without a dedicated mutant (there is no shared base-type discovery path to revert). S20 (edges only for a hopping selection) was investigated and found structurally vacuous in Rust as built: `edges` is only ever populated inside the cites/cited branches, so a mutant on the has_hop() gate cannot produce a different observable result for a non-hopping selection - no entry added; a real gap would need the evaluator's structure to change first. S23 (matches every row sharing an index value, never a cache's unique-index winner) has no revertable bug surface: Rust's Row/RowSet never had a unique-index map to begin with (D7), so this is pinned by construction, not by a mutation-testable rule; matches_every_row_sharing_an_index_value still exists as a positive test naming it. **A pre-existing, unrelated flaky test, found and worked around, not fixed.** tests/cultnet.rs's reactive_document_coalesces_direct_same_schema_alias_member_writes fails consistently when the mutation harness runs the full tests/cultnet.rs binary (both default-parallel and RUST_TEST_THREADS=1), but passes 5/5 in isolation and passes in a plain `cargo test -p cultnet-rs` run - state pollution from another test in that binary under the harness's specific invocation path, not a race this campaign's code participates in (nothing here touches reactive_document machinery). RS-V0Lowering-Revert's Command is narrowed to `cargo test --test cultnet serve_read_only_raw_snapshot` (filtering both M0 and the entry's own run to this campaign's test) so the suite does not depend on that unrelated test's health; the flake itself is reported here as a finding, not patched. Tests: cultnet-rs 174 passed, 0 failed (default parallel run). GameCult.Networking.Tests 196 passed, 1 skipped (WriteSelectionVectors, env-gated), 0 failed. Mutation harness: 24 entries (was 22 in commit 3; +RS-S2-Revert, +RS-S6-Revert; RS-BlankSchema/BlankKey and RS-V0Lowering-Revert's anchors and field-name assertions updated to match the landed fix batch's exact spelling), all KILLED, M0 green. Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Structural delta, this commit only: 6 files changed, +108/-23 (selection.rs +15/-9 field-name fix; snapshot_query.rs +25/-14 dedup; tests/cultnet.rs +21 dedup test; tests/selection.rs +35/-2 S6 fixture and field-name fixes; scripts/mutate-cultnet-selection-rust.entries.ps1 +33/-4 two new entries plus three corrected anchors/commands; SelectionParityVectorTests.cs +2/-1 field name), plus the two committed vector JSON files (~90 lines each, new). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 06:55:52 +02:00
}
]
R-AF/R-AJ: shared parity fixture rows and regenerated vector files The fixture had zero duplicate record keys across its ten rows and no ordinal tied across two different schemas - both shapes this fix batch's rulings needed and neither runtime's parity vectors ever covered. R-AF adds a "citer_narrow" schema (real SHA-256 id, computed the same way CultDocumentRegistry does - a probe run against a type matching the eventual C# type's exact namespace/nesting confirmed it) whose one reference targets leaf_a only, plus rows for both shapes from Soul's table: a lone out-of-target row at a key (refuses), and two rows sharing a key where only one is in-target (accepts, resolving the in-target one regardless of row order). Also drops "targetSchema" from every reference entry: it was never anything but documentation (SelectionParityVectorTests.BuildDocument and cultnet-rs's build_row both already read only targetKey) and keeping a field the wire does not actually have would contradict the rule R-AF just established. R-AJ adds a tied-ordinal pair across leaf_a and leaf_b, with keys chosen opposite to the real schema ids (probed) on purpose, so a schemaId-first order and a recordKey-first order are forced to disagree regardless of which real id happens to sort first - see the row-tiebreak test this enables. selection-vectors.cs-written.json and selection-vectors.rs-written.json are regenerated from the new fixture (CULTNET_WRITE_VECTORS=1 on both sides) and cross-checked in both directions locally. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-23 04:43:02 +02:00
}