build(deps): bump wit-parser from 0.247.0 to 0.256.0 - #268
Closed
dependabot[bot] wants to merge 2015 commits into
Closed
build(deps): bump wit-parser from 0.247.0 to 0.256.0#268dependabot[bot] wants to merge 2015 commits into
dependabot[bot] wants to merge 2015 commits into
Conversation
…adth
The comment-preservation overlay runs on exactly one path — `export()` over a
tree a previous run wrote — and every gate that generated into a clean directory
was blind to it. The two classes that shipped there were pinned afterwards BY
NAME, two files and two shapes, which is coverage that cannot see a third of
either; the one corpus-scale overlay gate does SELF-preserve
(`preserve(content, content)`), a no-op for any comment whether or not a real
regen would strand it.
So this asks the same questions of every `tests/corpus/*.cddl` fixture, naming
no file in advance. Three legs, `--wasm=true`:
- a static floor over FRESH trees for a comment sharing its row with code — the
trap SOURCE, catchable before any deletion exists. Lexer-grade through a new
`comment_preserve::comments_sharing_a_code_row`, because this corpus emits a
URL inside a string literal and a `/*` inside an own-line banner, and a
`line.find("//")` scan calls both comments;
- a rule-DELETION variant regenerated IN PLACE, failing on any
`cddl-codegen:unpreserved-comment`. Deletion by whole LINES rather than by the
`cddl` crate's AST span: a rule's DSL directives live in the `;` comment
trailing it, so an AST-span deletion leaves `; @used_as_key` behind to
re-attach to a different rule — a variant that still generates while meaning
something else;
- a canonical `cddl-codegen:replace` user EDIT stubbing a `self`-only body: the
block must apply rather than strand, and a second regen must reach a
byte-identical fixed point. The compile half is its own `full` gate, because
`unused import` is a WARNING no assertion about exit-0 generation can see, and
because nested cargo per fixture is a different cost class.
Both gates are `#[ignore]`d and registered. The generation sweep is `local` on
its measurement (40 s: six worker THREADS over generator subprocesses — threads,
not sibling `#[test]` shards, because every `#[ignore]`d test owes a registry
entry and six shards would be six gates for one question); the compile gate is
`full`, MANUAL_HEAVY and gate-cached (159 s cold).
Every leg is proven RED first: a planted trailing comment in `static/error.rs`,
the real pre-fix `Int::from_str` trap (`faed09cf`), a deliberately drifted
recorded original, and a disabled post-overlay re-prune — which turned exactly
the 5 import-orphaning cells red on `unused import:
std::collections::BTreeMap`.
Vacuity is the standing risk, so each leg counts what it exercised and asserts a
floor below the measured run: 577 files scanned, 89 deletion cells (6 deleting a
`@used_as_key` rule), 91 edit cells (89 in a per-type surface, 5 orphaning an
import), 88 compile cells.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…sidual The entry was the layer's own spec — both variant families, the cheaper static floor, the `@used_as_key` shaping note — and the layer is built (`regen_over_prior_output_corpus` + its compile sibling, `7b21547d`), so the spec text goes and what is genuinely future-facing stays. That residual is the sweep's ONE emission profile. It generates `--wasm=true` and nothing else, which is the profile both known trap instances lived in; `--preserve-encodings` emits a whole file the sweep never sees (`cbor_encodings.rs`) and json adds a tree of its own. The signal is written on the dimension the deferred cost actually grows: not "someone wants more profiles" but a SECOND trap instance in a file the default profile does not emit — at which point the profile that produced it is the one to add, rather than all of them. The recur-first FIRED-triggers list drops the entry with it, since its trigger is no longer an unbuilt work item. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
A cache-hit run of `regen_over_prior_output_corpus_compiles` still pays the per-cell generation, the replace-block injection and the lockfile preflight, so "159 s" alone reads as the price of a re-run when it is the price of a cold scratch root. Measured ~90 s fully cache-hit (88 of 88 cells), on the same terms its `component_corpus_compiles` neighbour states both numbers. The `fast`-tier wall in tests/timings.json moved on its own sliding-window rule during these runs; the digest and the spans derived from it are one commit, per tests/README.md § "Measured gate durations". Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
The sweep's first cut generated one profile, and the profile it did not generate emits a FILE it does not: `cbor_encodings.rs`, one struct per rule that carries encodings. A per-rule surface is precisely where a comment on a deletable row would live, and nothing else looks for one there — so the cheapest legs (one extra generation per fixture each) now sweep the default and preserve profiles both. The edit leg stays on the default: a replace block costs three generations, and its compile gate nested cargo per fixture. Measured 55 s, up from 40 s, which keeps the gate at `local` with room. Counts roughly double where they should: 1320 files scanned (was 577), 177 deletion cells (was 89), 12 of them deleting a `@used_as_key` rule (was 6); the floors follow. Green on the new surface — no trap in `cbor_encodings.rs`. A secondary profile's GENERATION verdict is deliberately not this gate's to own. `feature_corpus_compiles` gates that both ways through `EXPECTED_GENERATION_FAIL`, where a listed pair that starts generating fails as a stale pin; here a fixture that will not generate under preserve is a recorded SKIP (today, `dsl_ignore`), so the ownership stays single. The roadmap residual narrows with it: two profiles of four, and the edit leg's one, with the trigger re-aimed at a sentinel in a file NEITHER swept profile emits. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…ll tier's wall follows The cycle's new full-tier gate `regen_over_prior_output_corpus` records a warm median of 55.0s (n=3) — its first, so the span that reported it as unmeasured now names a number. The tier's own wall moves 33m4s -> 40m43s (n=16): the gate is new work in the tier rather than a slowdown of existing work, and the per-gate medians either held or moved within noise. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…e rest row's key domain become cells Twelve `[[contain]]` cells, no new fixtures: each sub-batch's regression defense already lives generator-side, and a cell's `example` IS its probe input. - The `any`-arm POSITION axis (role.choice-member): a non-last bare `any` (unsupported, PERMANENT by decision — a green flip is a regression, per README § "Gotchas"), the last-position bare arm, and a tagged `#6.n(any)` in a non-last position. Position and tagging are the two axes that flip the verdict, and now each is a cell rather than a sentence. - The fixed-value KINDs the enumeration still owed: a nint constant and a tag-wrapped fixed form as ARRAY-rep group-choice arms, a type choice whose fixed arms share a CBOR major type, and the nint MEMBER cell. Every one spells its DISPATCH PATH from the emitted deserialize — type-match for the two arm kinds, brute-force try-each-arm for `true / null / tstr` and for a last-position bare `any` — because the two sites emit independently and a kind proven on one certifies nothing about the other. - The rest row's KEY-DOMAIN axis (role.occurrence-target): named-rule, `bytes` and `nint` domains supported, the float-containing and null-admitting domains rejected. The generator's boundary moved along this axis in 2026-08; until now no cell could state where it sits, so a consumer had no way to ask. Probed at HEAD before authoring: the seven supported shapes generate, compile and round-trip under the default and `--preserve-encodings` profiles, generate under the json flags, and their `--wasm` crates check clean; the three rejected shapes exit 1 with the messages their generator-side pins assert. Both oracles accept all twelve examples. No panic, no silent-wrong. The source entries prune with the delivery: the `any`-arm entry and the rest-row key-domain entry retire whole; the fixed-value KINDs entry narrows to its one residual, the FLOAT kind in both positions. The arm-classification entry stays — enumerating arm positions is not the same act as getting their rejection evidence, and its signal is still an arm-position reject vector. Verdicts land on the next evidence mint; the new cells render `?` in the grid until then. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
… a new oracle gap The cycle-13 registration chain over 0fb4fd1's cells, everything downstream of the two full verify.ts passes: - Evidence: all 12 verdicts minted exactly as the pre-probes predicted — 9 supported (round-trips, wasm round-trips, json+preserve emission green), 3 graceful refusals, both oracles corroborating every example. Eight supported rows carry fresh decode-foreign vectors; the nint member cell adds the hand constraint pair (accept 8120 / reject 8121, "Expected fixed value -1 found -2" verbatim from the decoder), taking the fixed-value MEMBER family to 16 cells and the enforcement spans to 69 vectors over 49 rows. - The projections follow: reject-catalog snap (+3 rows, all error (graceful)), matrix_supported (+9) / matrix_reject (+3) fixtures, COVERAGE.md (the occurrence-target memberkey.type1 and prelude.any grid cells resolve ? -> half-supported), the generated Limitations block, and the status-header spans (286 annotations). - The arm-classification entry's reopening signal did NOT fire, now verified rather than reasoned: 21 arm-role catalog rows post-mint, zero reject vectors, zero class= — the mint writes accepts and re-certifies pre-existing hand pins only, and the one hand vector added here sits on a MEMBER role. The floor-scope pins for the three new choice rows record their own limits, including the same-major blind spot ({3,7} satisfiable by one major-7 accept when true and null share the major); ruled comment-sufficient — the decode-foreign floor is corroboration-side by the catalog's contract, and per-arm evidence is execution-gated in the emitted round-trip (the row carries f5 AND f6 regardless). - The tagged-any cell's note stops claiming a pin that never executed the shape: the two robustness fixtures spell the BARE arm only, and the pins that DO execute #6.n(any) non-last are named instead (tagged_any_arm_allowed_in_any_position; choice_tagged_any in tests/any-positions). - The named_key row minted pinned_reason-vectorless: gap #11 exactly (named-rule key domain, every candidate ruby=0 rust=1), now recorded as that gap's first MATRIX resident with its inline-key siblings as the controlled pair. Separating the pair surfaced a NEW oracle gap — #13, string-typed rest-row keys in a MIXED map demand an entry (* read as +): {1: 692} fails "map requires entry key of type bytes" against { 1: uint, * bytes => any } while uint/nint domains pass, the rest-entry-bearing instance passes, and the pure table keeps its empty-map pass; ruby accepts throughout. Differential grid and upstream-report sketch in draft/rust-cddl-string-key-mixed-map-rest-occurrence-gap.md; catalog cost is bytes_key's two zero-rest-entry accept candidates, dropped by the two-oracle gate. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
query_q4_directional's EXPECTED_ENFORCE_YES is the deliberate-addition fence for the enforce=yes green set; the nint member cell joined that set when its hand constraint vector landed, so the pin gains the id. Caught by the fast tier on the evidence commit — the README's 15 -> 16 prose count moved with the vector, but this pin is the mechanical half of the same fact. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
… compiled `fuzz_compile_rot` proves the byte-fuzzer's targets still COMPILE; nothing ever ran them, so a panic that only a live libFuzzer input triggers sat outside every tier. `fuzz_bounded_run` (full tier, registered after the compile-rot gate) runs both targets sequentially over the local corpus for `FUZZ_BUDGET_S` seconds each (default 120) at `-rss_limit_mb=2048`, and fails naming the libFuzzer artifact to replay. One process at a time: the peak the tier must bound is one libFuzzer RSS plus the cargo build that precedes it, and no factor scales with core count. Three deliberate properties, each recorded at the gate: - NOT gate-cached. A randomized exploration is not a pure function of the tree's bytes, so a content-hash hit would skip the only thing the gate does. Nothing else records the exemption: the closure audit traces ONE cached cell (`CLOSURE_AUDIT_GATE`) and enumerates no gate set. - Missing nightly / cargo-fuzz is a FAIL naming the install commands, never a skip — the gate is full-only, and a silent skip in the tier that ships the guarantee voids it (`runNoStdCheck`'s posture); there is no softer tier for it to be in, hence no softening arm. - No `requires:` edge on `fuzz_compile_rot`. `ensureFuzzGenerated` is shared, so either gate provisions `fuzz/generated` itself and `--only fuzz_bounded_run` asserts exactly what a whole tier run does rather than passing vacuously. The first real run is RED, and the gate is right to say so. 480 s over `from_cbor_bytes` (1929-file seed corpus, ~7 080 exec/s, peak RSS 653 MiB) found a preserve-encodings FIDELITY violation in `NonOverlapBasicNotBasic`: `bytes .cbor basic_arr` accepts a byte string whose embedded CBOR does not consume the whole payload, then re-encodes only the consumed prefix. Hand-derived 6-byte reproducer: `81 44 82 09 60 00` re-encodes as `81 43 82 09 60` — the trailing `0x00` is dropped. Disposition is a maintainer call (a fidelity violation is tier-1 class), so nothing is ledgered, pruned or retired here; on a corpus that has seen it, the default 120 s budget re-finds it in ~5 s, so the full tier fails this gate until the bug is fixed. `from_cbor_bytes_recursive` ran clean over the same 480 s: 54 768 212 execs, peak RSS 601 MiB, no crash, no artifact. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…re-encodes to itself `bytes .cbor T` says the byte string IS T's encoding. The embed read the payload and stopped — bytes left over inside the byte string were accepted, and since nothing held them, the value re-encoded to the consumed prefix ALONE. Over-acceptance on every profile, and under `--preserve-encodings` a fidelity violation on top: an ACCEPTED input round-tripped to different bytes, in a crate that compiled and passed every round-trip test, because round-trip tests only ever feed encodings the serializer itself produced. Found by the byte fuzzer's second oracle on the first bounded run of `fuzz_bounded_run` (adb165a) — the fidelity assert, not the crash boundary. Minimal reproducer, hand-derived from the libFuzzer artifact: `81 44 82 09 60 00` re-encoded as `81 43 82 09 60`. The payload is now required to be exhausted, raising the SAME `DeserializeFailure::CBOR(cbor_event::Error::TrailingData)` the top-level `from_cbor_bytes` raises for the same fact — one spelling, so a consumer matching on trailing data at the top level matches it here too, and the enclosing annotation still names the member. One emission site serves every `.cbor` spelling (`generate_deserialize`'s `CBORBytes` arm), so the rule body and the member expression were wrong together and are fixed together — both pinned by `structural_rejects` in `tests/core/tests.rs`, red-first on the pre-fix emitter. Completeness established over the OUTPUT rather than by grepping the emitter: all 154 embed sites across the blessed snapshots and the exported crates reach the check at their own block level, none with an early `return` that could bypass it. The check follows the payload's code, which is only expressible where that code is a complete STATEMENT; at a terminal position (a block's tail, a tuple element) the payload value is bound first and the binding yielded. Both spellings are emitted rather than always binding, so consumers do not get a `let x = x_payload;` rebinding that says nothing. The binding also RESTORES the check for the c-style-enum payload sweep, whose `return Ok(variant)` would otherwise have jumped past it. Snapshot churn is 30 files, audited by diff class: the new check, the payload binding, and rustfmt re-indentation around them — no other emitted token moved. `docs/docs/output_format.mdx`'s trailing-bytes paragraph said nested decoding was deliberately unaffected; that sentence was the documented form of the bug and is now the documented form of the rule. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…gistration cost The first full-tier run over cycle 13's cells failed decode_conformance_replay on contain.choice-member.prelude.any.last: all ten wrong_major header mutants DECODED Ok. For this row that is the spec's own semantics, verified before ledgering rather than assumed: - The acceptances reach the arm the spec says accepts them: probed on the generated crate, all seven non-text major shapes decode to the A::Any(AnyCbor) variant — the last-position bare `any` catch-all under forced-backtracking dispatch — never A::Text, which would have been the tstr arm mis-dispatching mutated bytes and a real over-acceptance finding. The major-3 control still lands on A::Text (first match wins). - No trunc_head mutant is in the failing set (all ten trunc_head tests ok in the gate's own output) — a trunc_head acceptance is ill-formed by construction and would be a finding always. So (row, wrong_major) joins HEADER_MUTANT_ACCEPT_SKIP beside its feature-row precedent (prelude.any, same class at the rule position), with the reason naming the accepting arm and the probe. The entry is (row, label)-wide because every committed accept samples the tstr arm (the mint's shape), so every flip lands on an any-only major — exact, not a suppression. The ledger's stale guard retires it if the row's shape ever changes. Every future any-typed catalog row owes this same entry on its first tier appearance; the cycle record says so. Rides along: the backwards-compatibility note for cff8516's `.cbor` exhaustion change in docs/docs/output_format.mdx — the acceptance change is exactly the class the docs convention carves out for historical notes (pre-2026-08 generators accepted-and-dropped trailing payload bytes; re-generated crates newly reject them; serializer-produced data is unaffected). Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…ischarged in one sweep
Two consecutive full-tier runs each died on a DIFFERENT missed registration obligation of cycle
13's twelve cells — fail-fast surfaces one per run, so this stops discovering them serially: a
complete sweep of every leg obligation for every new cell, enumerated from the gate's own ledger
registry (every `const` decode_conformance_replay declares — PRESERVE_SKIP, EXPECTED_MISMATCH,
ENCODING_VARIANT_SKIP, DOUBLED_LOCATION_SKIP, HEADER_MUTANT_{ACCEPT,LOCATION}_SKIP,
JSON_SURFACE_SKIP, WASM_SURFACE_SKIP, the four floors), not from a keyword grep. Full table:
draft/burndown2-cycle13-registration-sweep.md.
Discharged here (run 2's failure): contain.occurrence-target.memberkey.type1.open_struct_bytes_key
joins JSON_SURFACE_SKIP. Verified to be the decided boundary, not a new shape: the error is the
strict-fail the delivered posture documents ("open struct-map rest key has no JSON member-name
image", docs/docs/output_format.mdx § "Typed key domains in JSON"), the cell's own note already
marked the row as where the flattened-rest JSON convention stops, and the § findings non-string-
map-key entry carries the decided precedent verbatim — it now also names this cell among its
surfaced-by sites. The nint sibling is deliberately NOT listed (nint has a member-name image, per
the error's own admitted list); a json failure there next run is a finding, not a registration.
Every other (cell x leg) obligation is answered concretely in the sweep table: four rows have
nothing to replay (three reject fixtures, the gap-#11-pinned named_key), and every remaining cell
x leg is either LEDGERED (any.last wrong_major, d1997e1; bytes_key json, here) or explicitly
"should work" with the reason — notably tag.any_non_last owes NO header entry because its accepts
evidence majors 3 AND 6, so every derived flip lands on a major both arms reject with a located
error.
Verified by the gate in isolation at this tree: cargo test decode_conformance_replay --ignored ->
ok, 674 s, zero failures beyond the two pre-existing derived pair-map suppressions. A third
full-tier failure in this gate on these cells would now be a real finding.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…decode replay's grows with its catalog `fuzz_bounded_run` records 4m3s (n=3), its first — the span that reported it as unmeasured now names a number. `corpus_decode_replay` moves 15m36s -> 18m45s (n=20): the cycle added twelve catalog rows with real vectors, so the gate is replaying more per run rather than replaying the same work more slowly. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…t session finds them The TDD pass over everything this cycle caught by reading, probing or burning tier runs — each lesson filed in the system that owns its class: - The serial-registration cost becomes a FIRED work item (TESTING_ROADMAP § Next work items, now item 1): decode_conformance_replay aggregates failures within a row but panics at the first failing ROW, so twelve new cells cost two ~40-min full-tier runs for two independent ledger obligations. Fix shape recorded (route per-row failures into the end-of-gate failures collection the stale guards already use); the cycle's sweep table stays the authoring half. List renumbered (positional citations are banned tree-wide, so nothing dangles). - The `.cbor` doc sentence joins the docs-conformance decline as its FOURTH recorded instance — and the sharpest, because doc and behavior AGREED: "(Nested/embedded decoding — e.g. bytes .cbor T — is unaffected)" was a TRUE sentence about a DEFECT, which any docs-vs-behavior harness passes by construction. The decline is not reopened: the layer that caught it is a SPEC-side oracle (the fuzz fidelity leg, now standing), and the instance adds the zero-cost authoring rule instead — a limitation/boundary sentence in docs names its provenance (decided- posture record or findings entry), so an anchorless boundary reads as an undecision wearing decided clothes. Reopening signal for the rule: a second anchorless boundary sentence found to have documented a defect as intended, after the rule was in force. - The kill-by-PID rule in AGENTS.md learns the case where its own precondition is unsatisfiable: when agents share one harness, ancestry attributes nothing (proven 2026-08-04 — a tier run nearly killed on a wrong ancestry read; the sub-agent refused on better evidence). Attribution is by INVOCATION RECORD (disjoint self-log name classes, the log's own banner, who issued the command), and shared ancestry means identify-then-coordinate, never kill. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…unt inventory
The roadmap's fired work item asked for aggregation that already exists. Probed at HEAD by
reading both gates: every per-row, per-leg failure in `decode_conformance_replay` and
`corpus_decode_replay` is pushed into one `failures: Vec<String>` and panicked ONCE at the end —
no `panic!` or `assert!` sits inside either row loop (the asserts around them are the pre-loop
catalog/stale-pin registration guards and the post-loop vacuity floors, all outside the walk).
Cycle 13's two-run cost is explained by CONSUMPTION, not gate shape: run 1 failed with
26 problem(s) — 10 `any.last` header `wrong_major` + 8 `bytes_key` json + 8 the same row's wasm —
and run 2 with 16, a strict SUBSET of what run 1 had already printed. Each problem embeds its full
captured cargo-test output, so the 10 same-row header problems occupied ~1600 lines before the
second family's first line appeared, and the session discharged only the family it read.
So the residual is legibility, and that is what lands: `replay_failure_summary` groups failures by
the leading `"{row.id}: "` prefix (prefix-less stale-guard messages group under their own truncated
first line), and both final panics now head their details with the inventory —
decode-conformance replay found 26 problem(s) across 2 source(s):
contain.choice-member.prelude.any.last — 10
contain.occurrence-target.memberkey.type1.open_struct_bytes_key — 16
in first-appearance (row-walk) order, so related legs stay adjacent. Display-only: no leg, no
collection and no pass/fail semantics change, and the block is reachable only on an already-failing
run. The leading texts "decode-conformance replay found" / "corpus decode-conformance replay found"
are unchanged verbatim — only the count line is extended.
`replay_failure_summary_groups_by_row` (a plain `#[test]`, no crate build) pins the helper on cycle
13's exact shape: 26 synthetic multi-line failures over two rows plus one stale-guard message → 3
groups, counts 10/16/1, first-appearance order, every summary line short and free of captured
output. Its name deliberately carries neither gate's name — check.ts runs both by SUBSTRING filter.
TESTING_ROADMAP's item is removed rather than checked off (list renumbered; positional citations are
banned tree-wide, so nothing dangles). No committed doc stated the per-row-panic claim — the
decode-direction conformance sections of tests/README.md were read end to end and describe the legs
and ledgers without asserting a failure-reporting shape, so nothing was corrected there; the
rationale now lives durably in the helper's doc comment.
Verified: `cargo test --bin cddl-codegen replay_failure_summary` green (1 passed, 1193 filtered —
the name matches exactly one test), and `bun run check.ts fast` PASS, all in-tier gates green,
wall 38.2s. The local and full tiers remain unrun and are the orchestrator's to run.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…lent again
Two arms of `try_defer_wrapper` decline BEFORE any index is consulted — the
ident≠structural screen and the R3c constituent screen — so the class they mint
can carry a name a dependency's `--extern-wrapper-index` also lists, and the
defer seam has no way to see it. That is the same duplicate-`#[wasm_bindgen]`
configuration `warn_rule_declared_table_shadows_index` announces, reached by
paths that announced nothing.
The honesty check therefore lives at the one seam every LOCAL mint passes:
`warn_local_mint_shadows_index`, called from `record_collection_wrapper` and
keyed on the EMITTED ident rather than on the reason a particular arm declined.
That closes the family at once instead of chasing `return false` sites, and it
covers any future arm that declines before consulting the index. It shares
`deferred_warned` with the existing warnings, so a rule-declared table still
warns exactly once with its more specific text; it skips the
`requested_scope_override` mint by intent (a hosted wrapper's name is the
REQUESTING consumer's choice, arbitrated by the request sidecar, not this
crate's); and it is unreachable with no index flag, so flag-off byte AND stderr
identity hold — verified by generating the fixture both ways against a stashed
build.
Probed at HEAD before coding, and the recorded shape was half wrong: the
roadmap's spelling `arr_idx_foo_list = [* idx_foo_list]` never reaches R3c at
all — its structural name is `IdxFooListList`, so the ident≠structural screen
declines first — while `idx_hash_list = [* idx_hash]` over a consumer-owned
element does take R3c. Both mint a dep-indexed name silently, which is why the
fix is seam-level rather than branch-level, and both are now pinned by
`extern_wrapper_index_local_mint_under_indexed_name_warns` over the new
`inputs_nested` fixture: warning texts verbatim, the classes and their own-index
rows asserted unchanged (warn-only), the deferring sibling's unification warning
asserted to still fire beside them, and the consumer wasm `cargo check` floor.
The fixture is a new sibling dir rather than an addition to `inputs_named`,
whose `!index.contains("IdxFooList")` assertion the substring `ArrIdxFooList`
would falsify.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
… and becomes an enumeration Every collection wrapper a spec implies has an emission MODE, and the ~20 committed pins over that space are incident-shaped: each records the exact configuration of one past escape. What none of them gives is the grid, and the escapes on record were never in the primary wrapper — they were in a COMPANION (a table's synthesized keys-list, a restricted wrapper's loose `try_from` source) or a POSITION (a named-rule reference, a non-root declaring scope) that one mode happened not to walk. `src/tests/wrapper_participation_tests.rs` is that enumeration. `PARTICIPATION_TABLE` is the grid AS DATA over MODE × SHAPE × POSITION; each row states its expected outcome (Defer / Borrow / Host / LocalWarned(<which warning>) / LocalSilent(<why silence is correct>)) and, where an existing test already pins it, that test — those rows are REFERENCED, never rebuilt, so the four always-on per-mode sweeps generate exactly the rows nothing else covered. Each row's CDDL is derived from its own axes and each owns a distinct element ident, so one generated crate carries a whole mode and a new shape or mode is one table row rather than a new function. `..._table_is_complete_and_live` is the grid's own guard: rows unique, every mode covering every shape that participates in it (the one documented gap — a table RULE cannot be requested — spelled rather than silently absent), and every `pinned_by` resolving to a test that still exists, so a referenced row cannot keep reading as coverage after its pin is renamed away. Two participation facts are ENCODED rather than assumed, and one of them earned its keep immediately: a reject set can be HOSTED but never DEFER, so under `--extern-wrapper-index` an indexed name is a collision only the mint-seam backstop can announce — the row is green solely because of the previous commit. The other is that the name-only index is flavor-SAFE by construction, which makes a preserve table an ordinary shape row instead of a hazard cell. Floors are `#[ignore]`d and batched per (mode, floor), gate-cached per generated-crate content hash: `wrapper_participation_floors` runs a `cargo check` of the standalone Local column plus a real wasm32-unknown-unknown link of the index and workspace columns against the committed wasm-clean dep pair, GREEN only (the RED leg is already demonstrated once by `extern_wrapper_index_defers_to_dep`; verified non-vacuous here by regenerating the same spec flagless, which fails that link with 20 duplicate-symbol errors). What the link legs add is the POSITION crossing — a named-rule declaration, a by-name reference and a non-root scope had never reached a wasm32 link. `wrapper_participation_host_floor` checks the HOST crate a `--wrapper-requests` run emits. That host floor found a live defect on its first run, so it ships NARROWED and says so: a requested NonEmpty wrapper whose loose `try_from` source is itself co-hosted makes `requested_collections.rs` import that source from `crate::generated`, where it is not — it is in that same file. E0432, at exit 0. It is the co-hosted self-import class `workspace_requests_cohosted_keys_list_no_self_import` closed for the keys-list and left open for this second companion, and the committed request cells cannot see it because their dep spec produces the loose source itself, which makes the same import path correct. The roadmap entry is retired into its two honest successors: that finding as a DUE item carrying its reproduction, and a single-PROFILE residual whose reopening signal is a placement decision differing between two profiles for one row — something a consumer regenerating one spec twice can measure, which the entry does not already record evidence for. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…rofile sweep grows with the corpus `regen_over_prior_output_corpus` records its first warm median at 1m40s (n=3). `feature_corpus_roundtrips_nondefault_profiles` moves 7m45s -> 9m58s (n=20): the corpus gained fixtures across the last cycles, so the sweep covers more per run. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…findings ledger into the gotchas
The end-of-burndown holistic docs pass, executing the maintainer-ruled deferral recorded at cycle 11
close-out: the @custom_json can't-compile-standalone entry and its non-string-map-key sibling are
DECIDED postures — a contract boundary and a kept boundary — so § findings' own intro ("a defect or
a missing capability") mismatched them. Both are now current state in cddl-matrix/README.md
§ Gotchas, phrased as what the generator does today rather than as candidates, with the observable
that would make each a finding again stated as the boundary's own bound.
Every pointer that reached the findings entries retargets in the same change: the
JSON_SURFACE_SKIP / WASM_SURFACE_SKIP ledger citations in both replay gates (matrix and corpus),
their header comments' resident-citation contract (owning record: a decided-posture gotcha or a
findings entry), tests/README.md's json/wasm-surface-legs resident description, and the
containment-cell registration recipe's step-7 wording. The ledger instructions that route REAL
decoder gaps to § findings (ENCODING_VARIANT_SKIP and the variant-failure message) are unchanged —
that is still where defects go.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…in two stale homes The .default / range-bound / .cbor-head control-arm aborts were converted to graceful refusals in 12c9abc, which updated current_capacities.mdx and TESTING_ROADMAP but left two other homes describing the aborts as live — the classic finding-ledgered-in-two-homes staleness the holistic pass exists to catch (probed at HEAD: all three robustness rows record `error (graceful)` and KNOWN_CLOSURE_BREACH is an empty slice): - cddl-matrix/ROADMAP.md § findings still carried the "Three control-operator arms ABORT (exit 101)" entry as a candidate fix. Pruned outright: the refusals are the delivered remedy, pinned by the robustness catalog and documented in current_capacities.mdx, so nothing future-facing remains. - tests/README.md's refused-name-closure sibling paragraph still read "The pin list is NOT empty" over the same ten .default cells. It now records the empty-at-HEAD state and how it got there. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
…r entry that owns it The one transparent-alias wire-facts carve-out is documented in current_capacities.mdx as a limitation with a workaround but named no tracking artifact — the anchorless-boundary-sentence class the docs-conformance decline's fourth instance added an authoring rule for (a docs sentence stating a limitation names its provenance). It now cites the owning findings entry by exact title, the same citation shape the byte-string-literal limitation already uses. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JYLwxUHShu3rXopnyHjnRd
Bumps [wit-parser](https://github.com/bytecodealliance/wasm-tools) from 0.247.0 to 0.256.0. - [Release notes](https://github.com/bytecodealliance/wasm-tools/releases) - [Commits](https://github.com/bytecodealliance/wasm-tools/commits) --- updated-dependencies: - dependency-name: wit-parser dependency-version: 0.256.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>
dependabot
Bot
added
dependencies
Contributor
Author
|
OK, I won't notify you again about this release, but will get in touch when a new version is available. If you'd rather skip all updates until the next major or minor version, let me know by commenting If you change your mind, just re-open this PR and I'll resolve any conflicts on it. |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Bumps wit-parser from 0.247.0 to 0.256.0.
Commits
You can trigger a rebase of this PR by commenting
@dependabot rebase.Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR:
@dependabot rebasewill rebase this PR@dependabot recreatewill recreate this PR, overwriting any edits that have been made to it@dependabot show <dependency name> ignore conditionswill show all of the ignore conditions of the specified dependency@dependabot ignore this major versionwill close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)@dependabot ignore this minor versionwill close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)@dependabot ignore this dependencywill close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)