test: cover generateData's per-dtype element width

Closes the gap noted when the dead `bytesPerElement` table was removed:
nothing asserted that generateData selects the right typed-array constructor
for each dtype. The existing checks could not see it, because a wrong
constructor still returns exactly sizeBytes bytes of non-zero data.

Adds a `generateData element width` block with two kinds of assertion.

Per dtype, the returned bytes are re-viewed through the constructor the dtype
is expected to use, and the opening run is checked for the shape generateData
actually writes: sin(i * 0.01) scaled to the dtype's range climbs from zero to
its first peak at element 157, so read at the correct width the series starts
at 0, ends the quarter period above 0, and never falls back. Read at any other
width the same bytes reinterpret into unrelated values and lose that shape.

Across dtypes, the byte patterns at a fixed size must all differ, which pins
the weaker property that the dtype argument affects the output at all.

The expected dtype -> constructor mapping is restated in the test rather than
exported from data.ts on purpose. Importing the table the implementation uses
would make the assertion tautological; restating it means a change there fails
here instead of being mirrored automatically.

Verified by mutation rather than by inspection:

  - constructors swapped so every dtype builds an Int8Array, amplitudes left
    correct: the three non-int8 width tests fail, int8 correctly still passes,
    and every pre-existing test in the file passes - which is the gap.
  - generateData made to ignore `type` for both constructor and amplitude:
    the same three fail plus the distinctness test.

Note the distinctness test caught nothing the width tests missed under either
mutant. Kept because it states the "dtype must matter" invariant directly and
runs in 31ms, but it is subsumed on current evidence.

Benchmark suite goes 43 -> 48 tests. `vp check` clean; benchmark typecheck
unchanged at 8 pre-existing TS2351 CodecConstructor errors.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: thewtex

benchmark/src/data.test.ts

@@ -1,5 +1,35 @@
 import { describe, expect, it } from "vitest";
-import { DTYPES, SIZES, generateAllData, generateData } from "./data.js";
+import { DTYPES, SIZES, generateAllData, generateData, type DType } from "./data.js";
+
+interface TypedArrayCtor {
+  new (
+    buffer: ArrayBufferLike,
+    byteOffset: number,
+    length: number,
+  ): { readonly length: number; [index: number]: number };
+  readonly BYTES_PER_ELEMENT: number;
+  readonly name: string;
+}
+
+/**
+ * The element width each dtype must be generated at, restated here rather than
+ * imported from `data.js`. Pinning the mapping independently is the point: if
+ * that module's constructor table changes, this fails instead of mirroring it.
+ */
+const ELEMENT_VIEWS: Record<DType, TypedArrayCtor> = {
+  int8: Int8Array,
+  int16: Int16Array,
+  float32: Float32Array,
+  float64: Float64Array,
+};
+
+function sameBytes(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
 
 describe("generateData", () => {
   for (const dtype of DTYPES) {
@@ -19,6 +49,56 @@ describe("generateData", () => {
   }
 });
 
+describe("generateData element width", () => {
+  const sizeBytes = SIZES["1MB"];
+
+  // generateData fills element i with sin(i * 0.01) scaled to the dtype's
+  // range, so the opening run climbs from zero to its first peak at i = 157.
+  const QUARTER_PERIOD = Math.floor(Math.PI / 2 / 0.01);
+
+  for (const dtype of DTYPES) {
+    const View = ELEMENT_VIEWS[dtype];
+    const expectedElements = sizeBytes / View.BYTES_PER_ELEMENT;
+
+    it(`lays ${dtype} out as ${View.name} elements`, () => {
+      const buf = generateData(dtype, sizeBytes);
+      expect(buf.byteLength % View.BYTES_PER_ELEMENT).toBe(0);
+
+      const view = new View(buf.buffer, buf.byteOffset, expectedElements);
+      expect(view.length).toBe(expectedElements);
+
+      // Read at the correct width the ramp starts at zero and never falls back
+      // before the peak. Read at any other width the same bytes reinterpret
+      // into unrelated values and lose that shape — which a byteLength check
+      // cannot see, since a wrong constructor still yields sizeBytes bytes.
+      expect(view[0]).toBe(0);
+      expect(view[QUARTER_PERIOD]).toBeGreaterThan(0);
+
+      let firstDrop = -1;
+      for (let i = 1; i <= QUARTER_PERIOD; i++) {
+        if (view[i] < view[i - 1]) {
+          firstDrop = i;
+          break;
+        }
+      }
+      expect(firstDrop, `ramp fell back at element ${firstDrop}`).toBe(-1);
+    });
+  }
+
+  it("gives every dtype a distinct byte pattern at the same size", () => {
+    const buffers = DTYPES.map((dtype) => generateData(dtype, sizeBytes));
+
+    for (let i = 0; i < buffers.length; i++) {
+      for (let j = i + 1; j < buffers.length; j++) {
+        expect(
+          sameBytes(buffers[i], buffers[j]),
+          `${DTYPES[i]} and ${DTYPES[j]} produced identical bytes`,
+        ).toBe(false);
+      }
+    }
+  });
+});
+
 describe("generateAllData", () => {
   it("returns 4 dtypes × 2 sizes = 8 entries", () => {
     const data = generateAllData();