iterate fixed-size arrays by element, not byte step

[GrapeBaBa]

Bug

`deserialize` for `.array` with fixed-size child uses `i` simultaneously as the element index and as the byte stride:

```zig
var i: usize = 0;
const pitch = try comptime serializedFixedSize(U);
while (i < out.len) : (i += pitch) {
try deserialize(U, serialized[i * pitch .. (i + 1) * pitch], &out[i], allocator);
}
```

`i < out.len` treats `i` as an element index; `i += pitch` treats it as a byte step. For `[N]u8` (`pitch = 1`) the two uses coincide, which is why every existing test passes. For any wider element the loop only writes every `pitch`-th slot — interior elements are left undefined and the roundtrip diverges.

Concrete cases hit while consuming this library from zeam against leanSpec's `test_basic_types` fixtures:

type	pitch	writes	leaves undefined
`[3]u16`	2	`out[0]`, `out[2]`	`out[1]`
`[4]u64`	8	`out[0]`	`out[1..4]`
`[2][4]u32`	16	`out[0]`	`out[1]`

Re-serializing then produces garbage for the unwritten slots and the roundtrip test diverges.

Fix

Step by one element and keep `i * pitch` as the byte slice:

```zig
const pitch = try comptime serializedFixedSize(U);
for (0..out.len) |i| {
try deserialize(U, serialized[i * pitch .. (i + 1) * pitch], &out[i], allocator);
}
```

Why existing tests didn't catch this

The only array-deserialize test, `deserializes a Vector[N]`, uses `[2]Pastry` where `Pastry` contains a `[]const u8` — variable-size. That routes through the offset-based decode branch, not the fixed-size branch this fix lives in.

Added three regression tests covering the previously-untested shape:

• `[3]u16` — primitive fixed-size element > 1 byte
• `[4]u64` — widest primitive int
• `[2][4]u32` — nested fixed-size array

Before the fix all three fail (interior elements zero / undefined). After, all 139 tests pass.

Test plan

• `zig build test --summary all` — 139/139 pass (was 136/139 with new regression tests on unfixed HEAD).

[Copilot]

Pull request overview

Fixes a bug in deserialize for fixed-size arrays ([N]T) where the loop index was incorrectly used as both an element index and a byte stride, causing only every pitch-th element to be written for element sizes > 1 byte.

Changes:

• Correct array deserialization for fixed-size element arrays by iterating by element and slicing bytes via i * pitch.
• Add regression tests for fixed-size arrays of wider primitives and nested fixed-size arrays.
• Document the root cause in the deserialization implementation.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
src/lib.zig	Fixes fixed-size array deserialization iteration to write every element correctly.
src/tests.zig	Adds targeted regression tests covering fixed-size array element sizes > 1 and nested fixed-size arrays.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[gballet]

wow yeah that's a big issue, thanks for catching it.