feat: store exact homogeneous arrays statically

Author: SebastienGllmt

cddl-matrix/README.md

@@ -193,8 +193,9 @@ the guard that replaced the silent truncation this row's vector exposed; pinned
 `signed_ints_width_rejects` / `width_collapse_rejects` execution fixtures),
 the eight `rangeop` rows (`rangeop.{inclusive,exclusive}` plus their head-type × sign variation
 rows `.int`/`.nint`/`.float`), the three occurrence-bound rows `occur.bounded{,.lower,.upper}`
-(out-of-count arrays against the generated bounded collection conversion door — `BoundedVec` or
-`BoundedOrderedSet` for reject sets), and the three fixed-value lexeme
+(out-of-count arrays against the generated collection handover — `BoundedVec` for variable
+windows, `[T; N]` conversion for exact ordinary windows, or `BoundedOrderedSet` for reject sets),
+and the three fixed-value lexeme
 rows `value.number.{hexfloat,hex,bin}` (wrong-value instances against the fixed 3.0 / 16 / 10,
 rejected as FixedValueMismatch — hex/bin carry hand pins including `[0]`, the silent-zero
 radix-conversion trap), the fixed-selector MEMBER-equality family

cddl-matrix/containment/occurrence-target.toml

@@ -260,7 +260,7 @@ id = "contain.occurrence-target.grpent.member.zero_array"
 role = "role.occurrence-target"
 feature = "grpent.member"
 spec = "allowed"
-note = "A zero-or-more occurrence on a bare-type entry in a HETEROGENEOUS array is an open-array segment. A final `* t` tail is supported, as is the one safe non-final shape: a leading/middle segment whose immediate fixed suffix is mandatory, exactly one CBOR item, field-codec-free, and CBOR-major-disjoint from `t` (`[uint, * bytes, tstr]`). Each effective boundary head is generator-proven (including mandatory outer framing) or declared by a transparent custom-codec alias with `@custom_wire_major`; an undeclared custom-owned or direct opaque-extern head remains unproven. The decoder obeys RFC 8610 greedy non-backtracking matching: it consumes repeated element majors without rewind and stops at that disjoint suffix. Same-major/value-discriminator boundaries, multiple occurrences, and group/group-choice/plain-group forms stay rejected gracefully. `*` captures `Vec<T>`; `+` and bounded siblings use `NonEmptyVec`/`BoundedVec`. Under --preserve-encodings each captured segment element re-serializes byte-exactly via a positional per-element sidecar (a self-carried `any` element needs none), and --canonical-form normalizes each element in source position; the captured `Vec<T>` renders as an ordinary JSON array field (skip-if-empty on write, default-on-read) and exposes a read-only wasm `rest()` list-wrapper getter. RFC8610 §3.2, §3.4."
+note = "A zero-or-more occurrence on a bare-type entry in a HETEROGENEOUS array is an open-array segment. A final `* t` tail is supported, as is the one safe non-final shape: a leading/middle segment whose immediate fixed suffix is mandatory, exactly one CBOR item, field-codec-free, and CBOR-major-disjoint from `t` (`[uint, * bytes, tstr]`). Each effective boundary head is generator-proven (including mandatory outer framing) or declared by a transparent custom-codec alias with `@custom_wire_major`; an undeclared custom-owned or direct opaque-extern head remains unproven. The decoder obeys RFC 8610 greedy non-backtracking matching: it consumes repeated element majors without rewind and stops at that disjoint suffix. A finite exact `N*N` segment instead stops by count, needs no major discriminator, and stores ordinary/preserve data as `[T; N]` (exact reject remains `BoundedOrderedSet<T, N, N>`); uniquely named finite exact segments may be adjacent. Variable same-major/value-discriminator, variable multiple, and group/group-choice/plain-group forms stay rejected gracefully. `*` captures `Vec<T>`, `+` `NonEmptyVec<T>`, and variable bounded windows `BoundedVec<T, MIN, MAX>`. Under --preserve-encodings each captured segment element re-serializes byte-exactly via a positional per-element sidecar (a self-carried `any` element needs none), and --canonical-form normalizes each element in source position; the loose captured `Vec<T>` renders as an ordinary JSON array field (skip-if-empty on write, default-on-read) and exposes a read-only wasm `rest()` list-wrapper getter. RFC8610 §3.2, §3.4."
 example = "a = [uint, * bytes, tstr]"
 
 [[contain]]

cddl-matrix/matrix.json

@@ -4813,7 +4813,7 @@
       "example": "a = [uint, * bytes, tstr]",
       "feature": "grpent.member",
       "id": "contain.occurrence-target.grpent.member.zero_array",
-      "note": "A zero-or-more occurrence on a bare-type entry in a HETEROGENEOUS array is an open-array segment. A final `* t` tail is supported, as is the one safe non-final shape: a leading/middle segment whose immediate fixed suffix is mandatory, exactly one CBOR item, field-codec-free, and CBOR-major-disjoint from `t` (`[uint, * bytes, tstr]`). Each effective boundary head is generator-proven (including mandatory outer framing) or declared by a transparent custom-codec alias with `@custom_wire_major`; an undeclared custom-owned or direct opaque-extern head remains unproven. The decoder obeys RFC 8610 greedy non-backtracking matching: it consumes repeated element majors without rewind and stops at that disjoint suffix. Same-major/value-discriminator boundaries, multiple occurrences, and group/group-choice/plain-group forms stay rejected gracefully. `*` captures `Vec<T>`; `+` and bounded siblings use `NonEmptyVec`/`BoundedVec`. Under --preserve-encodings each captured segment element re-serializes byte-exactly via a positional per-element sidecar (a self-carried `any` element needs none), and --canonical-form normalizes each element in source position; the captured `Vec<T>` renders as an ordinary JSON array field (skip-if-empty on write, default-on-read) and exposes a read-only wasm `rest()` list-wrapper getter. RFC8610 §3.2, §3.4.",
+      "note": "A zero-or-more occurrence on a bare-type entry in a HETEROGENEOUS array is an open-array segment. A final `* t` tail is supported, as is the one safe non-final shape: a leading/middle segment whose immediate fixed suffix is mandatory, exactly one CBOR item, field-codec-free, and CBOR-major-disjoint from `t` (`[uint, * bytes, tstr]`). Each effective boundary head is generator-proven (including mandatory outer framing) or declared by a transparent custom-codec alias with `@custom_wire_major`; an undeclared custom-owned or direct opaque-extern head remains unproven. The decoder obeys RFC 8610 greedy non-backtracking matching: it consumes repeated element majors without rewind and stops at that disjoint suffix. A finite exact `N*N` segment instead stops by count, needs no major discriminator, and stores ordinary/preserve data as `[T; N]` (exact reject remains `BoundedOrderedSet<T, N, N>`); uniquely named finite exact segments may be adjacent. Variable same-major/value-discriminator, variable multiple, and group/group-choice/plain-group forms stay rejected gracefully. `*` captures `Vec<T>`, `+` `NonEmptyVec<T>`, and variable bounded windows `BoundedVec<T, MIN, MAX>`. Under --preserve-encodings each captured segment element re-serializes byte-exactly via a positional per-element sidecar (a self-carried `any` element needs none), and --canonical-form normalizes each element in source position; the loose captured `Vec<T>` renders as an ordinary JSON array field (skip-if-empty on write, default-on-read) and exposes a read-only wasm `rest()` list-wrapper getter. RFC8610 §3.2, §3.4.",
       "role": "role.occurrence-target",
       "spec": "allowed"
     },

cddl-matrix/no_std_check.ts

@@ -361,15 +361,18 @@ const PROFILES: Profile[] = [
     // (the std prelude supplies the name) and an E0425 the moment the crate is built without it.
     // That is exactly the shape of the first consumer-reported no_std break, and this member set —
     // a plain `any`, an optional `any`, a `[* any]` seq, an optional seq, a `{* K => any}` table and
-    // an optional table — is what puts every adapter shape inside the thumb compile.
+    // an optional table — is what puts every adapter shape inside the thumb compile. `wide` makes
+    // the separately composed typed static-array runtime live too: its child modules must spell
+    // allocation macros explicitly rather than inheriting the host `std` prelude.
     id: "json_schema",
     libName: "nostd-json",
     flags: ["--preserve-encodings=true", "--json-serde-derives=true", "--json-schema-export=true"],
     cddl: [
       "inner = [ a: uint, b: text ]",
       "tbl = { * uint => text }",
+      "wide = [64*64 uint]",
       "any_members = { 1: any, ? 2: any, 3: [* any], ? 4: [* any], 5: { * uint => any }, ? 6: { * uint => any } }",
-      "outer = [ i: inner, t: tbl, ? o: bytes, am: any_members ]",
+      "outer = [ i: inner, t: tbl, ? o: bytes, w: wide, am: any_members ]",
       "",
     ].join("\n"),
   },

cddl-matrix/roadmap.toml

@@ -629,28 +629,30 @@ event_md = '''a concrete query needs it
 
 [[record]]
 id = "matrix.fixed-array.static-representation"
-title = "Fixed-array representation optimization"
+title = "Compose exact static-array JSON support through containing shapes"
 
 [record.payload]
 kind = "work"
-body_md = '''### Fixed-array representation optimization
+body_md = '''### Compose exact static-array JSON support through containing shapes
 
-An exact `n*n T` can map to `[T; n]`, so the representation itself carries the constraint. The
-`uint .size 1` → `u8` mapping is the shipped precedent, independently of the `TryFrom` door, which
-stays as the ergonomic entry point. The fixed carrier and its construction door must compose with
-serialization, deserialization, Rust, wasm, JSON, component, cross-crate projection, matrix
-classification, and spec-derived boundary vectors.
+Exact ordinary/preserve `n*n T` occurrences now use `[T; n]` across Rust, CBOR, wasm, component,
+cross-crate projection, matrix classification, and boundary vectors. The pinned serde/schemars
+versions only derive arrays through length 32, so the generated `static_array` runtime presently
+adapts a direct field/newtype payload and a loose `Vec<[T; N]>` occurrence when `T` is not CDDL
+`any`. Direct/optional exact `any` arrays use the natural-JSON static adapter. That is not a general
+solution: an optional loose sequence, bounded sequence, map value, nested exact array, or another
+containing shape would still require `Serialize`/`Deserialize`/`JsonSchema` directly on a wide
+`[T; N]`. With either JSON flag, the generator now rejects those shapes loudly before codegen rather
+than emitting a crate that fails to compile.
 
 '''
 work_state = "ready"
-work_intent = "optimize"
-work_kind = "optimization"
+work_intent = "build_capability"
+work_kind = "feature"
 risk = "wrong_public_api"
-acceptance_md = '''Map exact n*n homogeneous array occurrences to [T; n], retain TryFrom as the ergonomic construction door, keep fixed-byte representation outside this identity, and update every applicable Rust, wasm, JSON, component, cross-crate, matrix, and boundary-vector surface.
-'''
+acceptance_md = '''Make JSON derives and schema generation compositional for every supported position that contains a wide exact ordinary/preserve array, including optional/loose/bounded sequences, map values, nested exact arrays, records, aliases, and type choices; preserve the ordinary JSON list surface and exact inner minItems/maxItems. Preserve CDDL `any`'s natural JSON rendering rather than falling back to AnyCbor's tagged codec, including nested exact-any arrays. Add execution coverage for representative nesting families. Until then, reject every unadapted containing shape under either JSON flag before codegen; do not claim complete JSON support while any containing shape still relies on serde/schemars' length-32 array traits.'''
 priority_band = "normal"
-priority_rationale_md = '''The fixed-array representation remains explicitly selected because an exact array type carries the cardinality invariant statically and avoids conflating this scope with the separate fixed-byte representation.
-'''
+priority_rationale_md = '''The native carrier is shipped, but JSON flags must not turn otherwise-supported CDDL nesting into a generated-crate compile failure. The remaining work is an adapter-composition design, not a reason to revert the representation.'''
 
 [[record]]
 id = "matrix.fixed-bytes.lowercase-base64-parser"
@@ -955,8 +957,10 @@ body_md = '''### Honor the remaining ambiguous/multiple count-permitting occurre
 
 A final occurrence after fixed members is supported: bare `*` / `0*` uses the loose open-array
 `Vec` rest tail, `+` / `1*` uses its `NonEmptyVec` twin with the shipped first-element construction
-door, and every other bounded window uses a complete checked `BoundedVec` carrier (including finite,
-max-only, min-only, and exact-zero windows). One leading/middle bare-type occurrence may precede an
+door; variable bounded windows use a complete checked `BoundedVec` carrier (including finite,
+max-only, and min-only windows), while ordinary/preserve exact `N*N` homogeneous windows use the
+native `[T; N]` carrier (including zero). Exact `@duplicates reject` remains a checked
+`BoundedOrderedSet<T, N, N>`. One leading/middle bare-type occurrence may precede an
 immediate mandatory, single-item fixed suffix. Variable windows retain the field-codec-free,
 effective, CBOR-major-disjoint boundary (`[uint, * bytes, tstr]`): heads are generator-proven or a
 transparent custom alias declares its actual wire major. A variable same-major boundary is also
@@ -967,7 +971,7 @@ owned heads. The decoder therefore obeys RFC 8610 greedy, non-backtracking match
 speculation; final and safe-middle forms share the
 carrier/projection paths covered by `contain.occurrence-target.grpent.member.{zero_array,plus_array,bounded_array}`.
 Two or more occurrence members are supported when every member has a unique explicit `@name` and a
-finite exact `N*N` window other than `1*1`: each is a separate flat `BoundedVec` and exact count is
+finite exact `N*N` window other than `1*1`: each is a separate flat `[T; N]` and exact count is
 its wire boundary, including adjacent and same-major segments.
 
 Still rejected gracefully: variable-cardinality multiple occurrence-bearing members; inline-group and group-choice-arm