Author	SHA1	Message	Date
Libby	7760219b7c	CultCache: [CultIndex] is unique at commit and load; [CultRole] names a selection role; replicas apply a commit's changes as one batch (#90)	2026-11-11 03:48:08 +00:00
Meta Vens	62ebba4ab5	R-AO: shared vector for two-in-target shared-key resolution ... Adds citer-both-in-target to the shared fixture, the first row in file (and row-order) to cite "dup-key" through Design - both leaf_a and leaf_b at that key are in Design's declared target, unlike citer_narrow's narrow_ref above it (only ever one in-target candidate). Adds the matching vector case to both runtimes' case lists and regenerates both written vector files (CULTNET_WRITE_VECTORS=1), so cross-runtime agreement on this shape is pinned by the parity check, not just asserted per-runtime. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-09-23 07:18:11 +02:00
Meta Vens	b9db8702d2	R-AF/R-AJ: C# parity vectors and the ordering-composition tests they needed ... R-AF: registers ParityCiterNarrow (citer_narrow's C# type, [CultIndex "narrow_ref"] so its role matches the fixture/Rust spelling), adds Keys-scoped vectors pinning both shapes from Soul's table - a shared key where the only candidate is out of target refuses evaluation-time (expectedEvaluationRefusal, a narrow addition to the vector schema distinct from the door-only expectedRefusalField - not R-Z/R-AH's page-bytes harness), and one where an in-target row shares a key with an out-of-target row and must still resolve. Landing these exposed a real, pre-existing cross-runtime scope difference in R-W unrelated to R-AF: Rust checked every declared reference on a row regardless of the citation's requested role; C#'s ReferenceMembers(descriptor, citation.Role) narrows by role first. Fixed on the Rust side (previous commit); hop_by_role_cites_exact_id and cites_target_by_name_alias keep an explicit Keys scope here anyway as belt-and-suspenders. Also corrects S-12's last stale comment: cites_target_by_name_alias's "Confirmed cross-runtime defect" note was already false - the alias port fixed it - and still called it confirmed. R-AJ: CultNetSelectionSurvivorTests.cs's row-tiebreak fixture (Evaluator_BreaksAnOrdinalTieBySchemaIdThenRecordKeyInBothDirections) was degenerate - probed by hand-reverting the source and swapping the tiebreak's two ThenBy calls, it still passed, because whether the old 3-row fixture discriminated the swap depended on which of SelLeafA's/ SelLeafB's real schema ids happened to sort first, and on this repo's ids it didn't. Rewritten to assign row keys relative to the schema ids discovered at runtime (low-sorting schema gets the high-sorting key and vice versa) so the two candidate orderings are always the exact reverse of each other; reprobed the same mutant afterward and it now fails. Adds a direct EdgesFor test (constructing FullEvaluation/EdgeMatch by hand) pinning "From.Key before Role" in the five-key edge tiebreak - the two existing EdgesFor tests each tie one of those two components, so neither could tell a Role-first mutant from the rule. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-09-23 04:43:25 +02:00
Meta Vens	b1932d95ed	Add the two pending cites-refusal parity vectors, now that C# refuses them ... Item 1 of the fix-batch-3 brief: check whether CultNetSelection.Validate refuses a cites.target.schemaId that CultNetSchemaAliasMatching cannot resolve. It already does (CultNetSelection.cs:389-394), landed by an earlier Hands pass on this branch (the "C# matrix Hands", after the parity table in the spec was captured) - so no production code changed here. What was still missing: SelectionParityVectorTests.RefusalCases() had a comment explaining why refuses_unmatched_cites_target_schema stayed "Rust-only", dated before that door check landed. The comment was stale and the vector was never added. Added it, plus refuses_cites_target_by_hash_shaped_alias (Self's ruling 2026-09-22: "the C# reference's alias rule is the rule" - C# only resolves a name-form alias, so a hash-shaped cites.target.schemaId is exactly the same unresolved-target case and must refuse at the same field). RefusalCases() now takes the fixture's schemas dictionary to reach schemas["leaf_a"].HashAlias. Verified on Yggdrasil: dotnet test tests/GameCult.Networking.Tests -c Release --filter FullyQualifiedName~SelectionParityVectorTests (the existing cross-runtime reader against the committed rs-written.json still passes, so this change does not depend on anything the Rust Hands owns). Regenerated contracts/cultnet/interop/selection-vectors.cs-written.json with CULTNET_WRITE_VECTORS=1: both new refusal vectors are present and both refuse at "cites.target.schemaId" as expected before being committed as vectors (WriteSelectionVectors's own Assert.Throws gate). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-09-22 19:22:18 +02:00
Meta Vens	3317dddf46	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
Meta Vens	3d32c67821	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
Meta Vens	00f4c02dd7	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
Meta Vens	b090ca97f9	CultNet selection cut1, commit 3: the Rust runtime ... docs/cultnet-selection-cut.md section 6/7: packages/cultnet-rs/src/selection.rs (new) - the Rust spelling of the vocabulary at wire parity with the corrected C# reference (e5348d3), matching D7: no cultcache-rs knowledge, the row owner supplies declared values and edges through two traits. - Wire types: Selection, FieldPredicate, Citation, Incoming, RecordRef, Edge, RawDocumentHeader, SelectionDocumentRecord (the v1 full-shape record, distinct from v0's CultNetRawDocumentRecord, which lacks schemaName/schemaVersion/ schemaContentHash - a pre-existing v0 gap this cut does not touch). SelectionOperator mirrors CultNetSelectionOperator for evaluator ergonomics; FieldPredicate.op stays a raw wire string, never a serde-tagged union. - canonical_number module (Q-J, section 2 "Numbers"): is_canonical (a hand-rolled digit-grammar parser, no regex dependency added), canonicalize_decimal_digits, expand_scientific_notation, compare (sign, then integer length, then digits, then padded fraction - no f64 anywhere), and render_i64/render_u64/render_f64/render_f32 for a Row implementer's own rendering. probe_f64_display_never_uses_exponent_notation empirically verifies the map's claim about Rust's f64 Display (confirmed true) rather than trusting it. - Row/RowSet traits (D7): schema_id, record_key, ordinal, values, number (canonical string, never f64), references for Row; all_schema_ids, declared_indexes, declared_roles, is_numeric, target_leaves for RowSet. A blanket `impl<T: Row> Row for &T` lets sorted/filtered slices of references satisfy generic bounds without an extra copy. - validate (S1 door refusals), matches (D6 single-row fast path, hop-bearing selections assert via debug_assert since Rust has no exception type to mirror C#'s InvalidOperationException), select (order/hop/cursor/paging, D9's reference_outside_target refusal, S23's per-row match - never through a unique-index map, because there is none here to begin with). - Cursor: mint/parse/digest is this runtime's own internal algorithm (a cursor is opaque and never crosses runtimes - each server answers its own pages), not a byte-for-byte port of the reference's; what must match is the *rule* (asOf + last position + a digest bound to the selection), which it does, pinned by RS-CursorStale-Revert/Loosening and RS-CursorDigest-Revert. - contracts.rs: three v1 CultNetMessage variants (SnapshotRequestV1, DatabaseSubscribeV1, SnapshotResponseRawV1) matching the C# messages' field-for-field shape. SnapshotResponseRawV1 carries binary payloads (documents[].payload, edges[].payload), so it is routed through the existing raw JSON-bypass path (parse_raw_cultnet_schema_message/ encode_raw_cultnet_schema_message) alongside v0's DocumentPutRaw/ SnapshotResponseRaw, with its own require_*/encode_* helpers for SelectionDocumentRecord, RawDocumentHeader, Edge and RecordRef. SnapshotRequestV1/DatabaseSubscribeV1 carry no binary and use the ordinary serde_json-intermediate path. No message-layer selection semantics validation here, matching the reference (CultNetSchemaMessageSerialization.cs only deserializes; a server calls selection::validate against its own RowSet before evaluating). - snapshot_query.rs (D3/D4): serve_read_only_raw_snapshot's two hand-rolled allowlist filters collapse into one call to selection::matches over a lowered v0 Selection, through a minimal RawSnapshotRow wrapper whose ordinal/values/number/references are unreachable (the lowered selection never sets fields/cites/cited, so matches_schema_keys_fields never calls them) - documented, not hidden. Ruling (Self, 2026-09-22, docs/cultnet-selection-cut.md commit 2 fix batch, mirrored here per the coordinator's mid-task instruction rather than C#'s pre-fix spelling as it stood at e5348d3): - validate refuses an empty-but-present schemas/keys list (already had this) and now also refuses any individual entry that is empty or whitespace (fields[i]-style names: schemas[i]/keys[i]). - The evaluator never sees []; matches_schema_keys_fields does not special-case an empty list as "no filter" (it never did here - that C# fallback, CultNetSelectionEvaluator.cs:84 pre-fix, was never mirrored into Rust). - snapshot_query.rs's v0 lowering gets its own cleaning, owned by the lowering and not the evaluator: lower_v0_list turns an empty or all-blank v0 schemaIds/recordKeys list into None before it ever reaches validate or select. Tests: cultnet-rs 173 passed, 0 failed (was 111 baseline #[test]s pre-cut; +62 across lib unit tests, tests/selection.rs and tests/cultnet.rs). cultcache-rs unmodified, 64 passed, 0 failed (untouched by this commit - confirmed unaffected). GameCult.Networking.Tests (the new SelectionParityVectorTests.cs file, compiled but not yet fully exercised - see below) builds clean. Mutation harness (tools/eureka-mutations.ps1, scripts/mutate-cultnet- selection-rust.entries.ps1): 22 entries against src/selection.rs and src/snapshot_query.rs, all KILLED, M0 green. Covers: S1's empty-list and new blank-entry refusals (schemas and keys, revert x4), order/descending (revert), cursor staleness (revert + loosening) and digest (revert), S7's incoming negation (revert + loosening), S16's le/ge boundaries (revert x2), S18's reference_outside_target (revert), Q-J's door regex and -0 exclusion (revert x2), Q-J's comparator integer-length and sign (revert x2), Q-J's integer-through-float64 renderer, decimal trailing-zero stripping and exponent expansion (revert x3, the last two pinned via direct canonical_number unit tests since render_f64 itself cannot reach exponent notation given Rust's Display contract - verified, not assumed), and the new v0-lowering rule (revert). Negative grep: `rg -n "untagged" packages/cultnet-rs/src packages/cultcache-rs/src` empty. Not included here, landing as commit 4 once ready: the committed parity vector files (contracts/cultnet/interop/selection-vectors.{cs,rs}-written.json). Both directions already work for six evaluated selections and the [] door-refusal case; the blank-key-entry refusal vector cannot be generated from the C# side yet because the parallel C# fix batch implementing that door check (docs/cultnet-selection-cut.md, "Self's rulings...for the commit 2 fix batch") has not landed on this branch as of this commit. Rust's own tests (validation_refuses_a_blank_entry_in_schemas_or_keys, serve_read_only_raw_snapshot_lowers_an_empty_or_blank_v0_schema_list_to_no_filter) already pin both new rules independently of C#. Structural delta: packages/cultnet-rs/src/selection.rs +1407 (new), contracts.rs +616/-21, snapshot_query.rs +76/-21 (net +55, collapsing the fifth selector engine into one call), lib.rs +2, tests/cultnet.rs +67 (new v0-lowering test), tests/selection.rs +900 (new, evaluator tests + vector machinery), scripts/mutate-cultnet-selection-rust.entries.ps1 +233 (new), tests/GameCult.Networking.Tests/SelectionParityVectorTests.cs +296 (new). Against section 14's ~430-line estimate for selection.rs+contracts.rs: the two together land at ~2000 lines added, well over estimate - the map's own §14 correction already flagged commits 0/1 running roughly 2x estimate for the same reason (the hop's incoming index, the cursor, and per-field door messages cost more than the prose assumed), and the v1 raw-message handling (SelectionDocumentRecord/RawDocumentHeader/Edge require_*/encode_* helpers, ~400 lines) was not separately budgeted at all. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-09-22 05:31:19 +02:00