@aardworx/wombat.rendering 0.7.0 → 0.7.2

package/src/core/bufferView.ts

@@ -4,33 +4,33 @@
 //
 //   - `buffer` is `aval<IBuffer>` so per-frame content changes flow
 //     through normal aval marking without reshaping the view.
-//   - `elementType` carries the element kind; the backend derives
-//     `GPUVertexFormat` / `GPUIndexFormat` and a default stride from
-//     it.
+//   - `elementType` is a singleton token from the `ElementType`
+//     namespace (e.g. `ElementType.V3f`, `ElementType.U16`); the
+//     backend reads `byteSize` / `vertexFormat` / `indexFormat`
+//     directly off it.
 //   - `singleValue` is set when the view was constructed from a
 //     single adaptive value broadcast to all instances/vertices —
 //     the runtime can lower it to a uniform binding instead of a
 //     per-vertex/per-instance attribute.
 //
 // The view itself is plain (not wrapped in `aval`). Structural
-// fields — `elementType`, `offset`, `stride`, `normalized` — are
-// eager so the binding plan / pipeline layout can be computed
-// without forcing.
+// fields are eager so the binding plan / pipeline layout can be
+// computed without forcing.
 
 import type { aval } from "@aardworx/wombat.adaptive";
 import { AVal } from "@aardworx/wombat.adaptive";
 import { IBuffer } from "./buffer.js";
-import type { ElementType } from "./elementType.js";
-import { ElementType as ElementTypeRegistry } from "./elementType.js";
+import { ElementType } from "./elementType.js";
+import type { ElementKind } from "./elementType.js";
 
 export interface BufferView {
   /** Adaptive buffer source — content changes flow through this aval. */
   readonly buffer: aval<IBuffer>;
-  /** Element kind. Stride defaults from this when `stride` is 0/undefined. */
+  /** Element kind (singleton from the `ElementType` namespace). */
   readonly elementType: ElementType;
   /** Byte offset into `buffer` where the view starts. Default 0. */
   readonly offset?: number;
-  /** Stride between consecutive elements in bytes. 0 = tight (= `byteSize(elementType)`). */
+  /** Stride between consecutive elements in bytes. 0 = tight (= `elementType.byteSize`). */
   readonly stride?: number;
   /** Integer attributes treated as normalized fixed-point floats. Default false. */
   readonly normalized?: boolean;
@@ -43,58 +43,6 @@ export interface BufferView {
   readonly singleValue?: aval<unknown>;
 }
 
-// ---------------------------------------------------------------------------
-// Inference helpers — discover ElementType from a wombat.base packed
-// array or a TypedArray. Kept as a duck-type lookup so wombat.base
-// doesn't need to expose explicit brands.
-// ---------------------------------------------------------------------------
-
-interface WombatArrayLike {
-  readonly buffer: ArrayBufferLike;
-  readonly length: number;
-}
-
-function inferElementType(arr: unknown): ElementType {
-  // wombat.base packed types — discover via class name. These all
-  // have a distinct `constructor.name` and a `buffer: ArrayBuffer`
-  // backing field.
-  const ctor = (arr as { constructor?: { name?: string } }).constructor;
-  const name = ctor?.name;
-  switch (name) {
-    case "V2fArray": return "v2f";
-    case "V3fArray": return "v3f";
-    case "V4fArray": return "v4f";
-    case "V2iArray": return "v2i";
-    case "V3iArray": return "v3i";
-    case "V4iArray": return "v4i";
-    case "V2uiArray": return "v2u";
-    case "V3uiArray": return "v3u";
-    case "V4uiArray": return "v4u";
-    // Native typed arrays.
-    case "Float32Array": return "f32";
-    case "Uint32Array":  return "u32";
-    case "Int32Array":   return "i32";
-    case "Uint16Array":  return "u16";
-    case "Int16Array":   return "i16";
-    case "Uint8Array":   return "u8";
-    case "Int8Array":    return "i8";
-  }
-  throw new Error(
-    `BufferView.ofArray: cannot infer ElementType from ${name ?? "unknown type"}; ` +
-    `pass elementType explicitly`,
-  );
-}
-
-function arrayToHostBytes(arr: unknown): ArrayBuffer | ArrayBufferView {
-  // wombat.base packed types expose `.buffer: ArrayBuffer` covering
-  // exactly the packed bytes.
-  const a = arr as { buffer?: unknown };
-  if (a.buffer instanceof ArrayBuffer) return a.buffer;
-  // Native typed array — pass through.
-  if (ArrayBuffer.isView(arr as ArrayBufferView)) return arr as ArrayBufferView;
-  throw new Error("BufferView.ofArray: unsupported array source");
-}
-
 // ---------------------------------------------------------------------------
 // Constructors
 // ---------------------------------------------------------------------------
@@ -106,7 +54,7 @@ interface OfArrayOptions {
   readonly normalized?: boolean;
 }
 
-interface OfGPUOptions {
+interface OfBufferOptions {
   readonly offset?: number;
   readonly stride?: number;
   readonly normalized?: boolean;
@@ -117,23 +65,33 @@ function isAval<T>(v: unknown): v is aval<T> {
     && typeof (v as { getValue?: unknown }).getValue === "function";
 }
 
+function arrayToHostBytes(arr: unknown): ArrayBuffer | ArrayBufferView {
+  // wombat.base packed array types expose `.buffer: ArrayBuffer`.
+  const a = arr as { buffer?: unknown };
+  if (a.buffer instanceof ArrayBuffer) return a.buffer;
+  // Native TypedArray.
+  if (ArrayBuffer.isView(arr as ArrayBufferView)) return arr as ArrayBufferView;
+  throw new Error("BufferView.ofArray: unsupported array source");
+}
+
 export const BufferView = {
   /**
    * Build a view from a wombat.base packed array (`V3fArray`,
-   * `Uint16Array`, …) or an `aval<…>` of one. The element type is
-   * inferred from the array constructor; pass it explicitly via
-   * `opts.elementType` for unusual cases.
+   * `Uint16Array`, …) or an `aval<…>` of one. The element kind is
+   * inferred from the array's constructor identity; pass it
+   * explicitly via `opts.elementType` for unusual cases (e.g. a
+   * `Float32Array` interpreted as packed `V4f` with `ElementType.V4f`).
    */
-  ofArray<T extends WombatArrayLike | ArrayBufferView>(
+  ofArray<T>(
     a: aval<T> | T,
     opts: OfArrayOptions = {},
   ): BufferView {
     const adaptive = isAval<T>(a) ? a : AVal.constant(a);
-    // Determine element type — eager. We force the aval ONCE here
-    // to discover the array kind, which is structural; subsequent
-    // changes are expected to keep the same kind.
+    // One-time element-kind discovery from the source's constructor.
+    // Marked allow-force: structural-eager, runs at construction only;
+    // per-frame content changes flow through `buffer` without re-running.
     const sample = adaptive.force(/* allow-force */);
-    const elementType = opts.elementType ?? inferElementType(sample);
+    const elementType = opts.elementType ?? ElementType.fromArray(sample);
     const buffer = adaptive.map((arr): IBuffer =>
       IBuffer.fromHost(arrayToHostBytes(arr)),
     );
@@ -152,14 +110,17 @@ export const BufferView = {
    * and lowers it to a uniform binding instead of a per-element
    * attribute. The `buffer` aval still carries packed bytes for
    * backends that don't recognize the fast path.
+   *
+   * The `T` parameter on `ElementKind<T>` flows through to the
+   * value type — passing `ElementType.V4f` requires `T = V4f` here.
    */
   ofValue<T>(
     v: aval<T> | T,
-    elementType: ElementType,
+    elementType: ElementKind<T>,
   ): BufferView {
     const adaptive = isAval<T>(v) ? v : AVal.constant(v);
     const buffer = adaptive.map((value): IBuffer => {
-      const bytes = ElementTypeRegistry.byteSize(elementType);
+      const bytes = elementType.byteSize;
       const ab = new ArrayBuffer(bytes);
       packSingle(value, elementType, ab);
       return IBuffer.fromHost(ab);
@@ -178,7 +139,7 @@ export const BufferView = {
   ofGPU(
     buffer: aval<GPUBuffer> | GPUBuffer,
     elementType: ElementType,
-    opts: OfGPUOptions = {},
+    opts: OfBufferOptions = {},
   ): BufferView {
     const adaptive = isAval<GPUBuffer>(buffer) ? buffer : AVal.constant(buffer);
     const ibuffer = adaptive.map((b): IBuffer => IBuffer.fromGPU(b));
@@ -193,13 +154,13 @@ export const BufferView = {
 
   /**
    * Wrap an already-built `aval<IBuffer>` with explicit element
-   * type. Used by callers that compute their own `IBuffer` (e.g.
+   * kind. Used by callers that compute their own `IBuffer` (e.g.
    * compositing multiple attributes into one packed buffer).
    */
   ofBuffer(
     buffer: aval<IBuffer>,
     elementType: ElementType,
-    opts: OfGPUOptions = {},
+    opts: OfBufferOptions = {},
   ): BufferView {
     return {
       buffer,
@@ -216,12 +177,12 @@ export const BufferView = {
   offsetOf(v: BufferView): number { return v.offset ?? 0; },
   /**
    * Stride in bytes — `v.stride` if set and non-zero, otherwise
-   * tight from `elementType`.
+   * tight from `elementType.byteSize`.
    */
   strideOf(v: BufferView): number {
     return v.stride !== undefined && v.stride > 0
       ? v.stride
-      : ElementTypeRegistry.byteSize(v.elementType);
+      : v.elementType.byteSize;
   },
   /** Whether this view is a single-value broadcast. */
   isSingleValue(v: BufferView): boolean {
@@ -230,41 +191,39 @@ export const BufferView = {
 } as const;
 
 // ---------------------------------------------------------------------------
-// Single-value packing — write one element of `elementType` into a
-// fresh ArrayBuffer. The runtime usually shortcuts this via
-// `singleValue` (lifted to a uniform), so this path runs only for
-// backends that don't recognize the broadcast.
+// Single-value packing — write one element of `t` into a fresh
+// ArrayBuffer. The runtime usually shortcuts this via `singleValue`
+// (lifted to a uniform); this path runs only for backends that
+// don't recognise the broadcast.
 // ---------------------------------------------------------------------------
 
 function packSingle(value: unknown, t: ElementType, dst: ArrayBuffer): void {
-  // Lazy import to avoid a hard dep on wombat.base shapes here. We
-  // peek at `_data` (the typed-array view exposed by every wombat
-  // math type) and copy its bytes into the destination.
   const v = value as { _data?: ArrayLike<number> };
   if (v._data !== undefined) {
     const src = v._data;
-    switch (t) {
-      case "v2f": case "v3f": case "v4f":
-      case "m22f": case "m33f": case "m44f":
-      case "f32": {
-        const out = new Float32Array(dst);
-        for (let i = 0; i < src.length; i++) out[i] = src[i]!;
-        return;
-      }
-      case "v2i": case "v3i": case "v4i": case "i32": {
-        const out = new Int32Array(dst);
-        for (let i = 0; i < src.length; i++) out[i] = src[i]!;
-        return;
-      }
-      case "v2u": case "v3u": case "v4u": case "u32": {
-        const out = new Uint32Array(dst);
-        for (let i = 0; i < src.length; i++) out[i] = src[i]!;
-        return;
-      }
+    // Match by name on the singleton — concise and minifier-safe
+    // since the names are baked at the singleton's construction.
+    const name = t.name;
+    if (name === "f32"
+        || name.startsWith("v") && name.endsWith("f")
+        || name.startsWith("m") && name.endsWith("f")) {
+      const out = new Float32Array(dst);
+      for (let i = 0; i < src.length; i++) out[i] = src[i]!;
+      return;
+    }
+    if (name === "i32" || (name.startsWith("v") && name.endsWith("i"))) {
+      const out = new Int32Array(dst);
+      for (let i = 0; i < src.length; i++) out[i] = src[i]!;
+      return;
+    }
+    if (name === "u32" || (name.startsWith("v") && name.endsWith("u"))) {
+      const out = new Uint32Array(dst);
+      for (let i = 0; i < src.length; i++) out[i] = src[i]!;
+      return;
     }
   }
   // Scalars and unbranded values.
-  switch (t) {
+  switch (t.name) {
     case "f32": new Float32Array(dst)[0] = value as number; return;
     case "u32": new Uint32Array(dst)[0]  = value as number; return;
     case "i32": new Int32Array(dst)[0]   = value as number; return;
@@ -273,5 +232,5 @@ function packSingle(value: unknown, t: ElementType, dst: ArrayBuffer): void {
     case "u8":  new Uint8Array(dst)[0]   = value as number; return;
     case "i8":  new Int8Array(dst)[0]    = value as number; return;
   }
-  throw new Error(`BufferView.ofValue: cannot pack ${typeof value} as ${t}`);
+  throw new Error(`BufferView.ofValue: cannot pack ${typeof value} as ${t.name}`);
 }

package/src/core/elementType.ts

@@ -1,84 +1,178 @@
-// ElementType — the data type of a single element in a BufferView.
+// ElementType — runtime token + structural metadata for the data
+// type of a single element in a `BufferView`. The TypeScript-side
+// equivalent of F#'s `typeof<T>` / `System.Type`: a value (not a
+// string tag) carrying byte size, vertex / index format, and a
+// phantom type parameter that flows through to `BufferView<T>`-
+// generic call sites.
 //
-// Mirrors Aardvark.Rendering's `BufferView.ElementType : System.Type`
-// pattern: structural information about the element kept separate
-// from the per-frame buffer content. The runtime maps `ElementType`
-// to a `GPUVertexFormat`/`GPUIndexFormat` and a byte size at
-// pipeline-layout time.
-
-export type ElementType =
-  // scalar
-  | "f32" | "u32" | "i32"
-  | "u16" | "i16"
-  | "u8"  | "i8"
-  // vec — float
-  | "v2f" | "v3f" | "v4f"
-  // vec — int
-  | "v2i" | "v3i" | "v4i"
-  // vec — uint
-  | "v2u" | "v3u" | "v4u"
-  // matrix (float, square)
-  | "m22f" | "m33f" | "m44f"
-  // packed colour
-  | "c4b" | "c3b";
+// All entries are exposed as singleton properties on `ElementType`:
+//
+//   ElementType.V3f         // ElementKind<V3f>
+//   ElementType.U16         // ElementKind<number>
+//   ElementType.M44f        // ElementKind<M44f>
+//
+// `BufferView.ofArray` infers the kind from the source array's
+// constructor identity (V3fArray → ElementType.V3f, Float32Array →
+// ElementType.F32, etc.) so the explicit second argument is rarely
+// needed.
+
+import type {
+  V2f, V3f, V4f, M22f, M33f, M44f, V2i, V3i, V4i,
+} from "@aardworx/wombat.base";
+import {
+  V2fArray, V3fArray, V4fArray,
+  V2iArray, V3iArray, V4iArray,
+  V2uiArray, V3uiArray, V4uiArray,
+} from "@aardworx/wombat.base";
+
+// ---------------------------------------------------------------------------
+// ElementKind<T>
+// ---------------------------------------------------------------------------
+
+/**
+ * Phantom-typed token describing a single element's data type. The
+ * `T` parameter is a brand only — it carries the source-side type
+ * (V3f, M44f, number, …) into the type system at zero runtime cost.
+ *
+ * Identity equality is the equality used everywhere in the renderer
+ * (group keys, bind plans). All instances are singletons under the
+ * `ElementType` namespace below.
+ */
+export class ElementKind<T> {
+  constructor(
+    /** Short human-readable tag (e.g. `"v3f"`, `"u16"`). */
+    readonly name: string,
+    /** Size of one element in bytes. */
+    readonly byteSize: number,
+    /** GPUVertexFormat for use as a vertex attribute. `undefined` for matrix and non-vertex types. */
+    readonly vertexFormat: GPUVertexFormat | undefined,
+    /** GPUIndexFormat when used as an index buffer. `undefined` unless the type is `u16` / `u32`. */
+    readonly indexFormat: GPUIndexFormat | undefined,
+  ) {}
+
+  /** Phantom — never read at runtime. Forces TS to track T. */
+  declare readonly _brand: T;
+
+  toString(): string { return this.name; }
+}
+
+/**
+ * `ElementType` doubles as a type alias (the structural shape) and
+ * a value namespace (the singleton tokens). `ElementType` in type
+ * position is `ElementKind<unknown>`; in value position it's the
+ * collection of singletons below.
+ */
+export type ElementType = ElementKind<unknown>;
+
+// ---------------------------------------------------------------------------
+// Singleton tokens
+// ---------------------------------------------------------------------------
 
+const _V2f  = new ElementKind<V2f>("v2f",   8, "float32x2", undefined);
+const _V3f  = new ElementKind<V3f>("v3f",  12, "float32x3", undefined);
+const _V4f  = new ElementKind<V4f>("v4f",  16, "float32x4", undefined);
+const _M22f = new ElementKind<M22f>("m22f", 16, undefined, undefined);
+const _M33f = new ElementKind<M33f>("m33f", 36, undefined, undefined);
+const _M44f = new ElementKind<M44f>("m44f", 64, undefined, undefined);
+const _V2i  = new ElementKind<V2i>("v2i",   8, "sint32x2", undefined);
+const _V3i  = new ElementKind<V3i>("v3i",  12, "sint32x3", undefined);
+const _V4i  = new ElementKind<V4i>("v4i",  16, "sint32x4", undefined);
+const _V2u  = new ElementKind<V2i>("v2u",   8, "uint32x2", undefined);
+const _V3u  = new ElementKind<V3i>("v3u",  12, "uint32x3", undefined);
+const _V4u  = new ElementKind<V4i>("v4u",  16, "uint32x4", undefined);
+const _F32  = new ElementKind<number>("f32", 4, "float32", undefined);
+const _U32  = new ElementKind<number>("u32", 4, "uint32",  "uint32");
+const _I32  = new ElementKind<number>("i32", 4, "sint32",  undefined);
+const _U16  = new ElementKind<number>("u16", 2, undefined, "uint16");
+const _I16  = new ElementKind<number>("i16", 2, undefined, undefined);
+const _U8   = new ElementKind<number>("u8",  1, undefined, undefined);
+const _I8   = new ElementKind<number>("i8",  1, undefined, undefined);
+
+/**
+ * Construct a vertex view; throws if the kind has no vertex format
+ * (matrix / unsupported type).
+ */
+function asVertexFormat(t: ElementType): GPUVertexFormat {
+  if (t.vertexFormat === undefined) {
+    throw new Error(
+      `ElementType.${t.name}: no GPUVertexFormat (matrices must be split into column attributes; ` +
+      `unsupported types must be repacked first)`,
+    );
+  }
+  return t.vertexFormat;
+}
+
+function asIndexFormat(t: ElementType): GPUIndexFormat {
+  if (t.indexFormat === undefined) {
+    throw new Error(`ElementType.${t.name}: not a valid index type (use ElementType.U16 or ElementType.U32)`);
+  }
+  return t.indexFormat;
+}
+
+// ---------------------------------------------------------------------------
+// Constructor → ElementType registry — drives `BufferView.ofArray`
+// auto-inference. Keyed on class identity (V3fArray, Float32Array,
+// …) so it survives minification.
+// ---------------------------------------------------------------------------
+
+const FROM_CTOR: ReadonlyMap<unknown, ElementType> = new Map<unknown, ElementType>([
+  // wombat.base packed arrays
+  [V2fArray,  _V2f], [V3fArray, _V3f], [V4fArray, _V4f],
+  [V2iArray,  _V2i], [V3iArray, _V3i], [V4iArray, _V4i],
+  [V2uiArray, _V2u], [V3uiArray, _V3u], [V4uiArray, _V4u],
+  // native typed arrays (interpreted as scalars)
+  [Float32Array, _F32],
+  [Uint32Array,  _U32],
+  [Int32Array,   _I32],
+  [Uint16Array,  _U16],
+  [Int16Array,   _I16],
+  [Uint8Array,   _U8],
+  [Int8Array,    _I8],
+]);
+
+function fromArray(arr: unknown): ElementType {
+  const ctor = (arr as { constructor?: unknown }).constructor;
+  if (ctor === undefined) {
+    throw new Error("ElementType.fromArray: input has no constructor");
+  }
+  const et = FROM_CTOR.get(ctor);
+  if (et === undefined) {
+    const name = (ctor as { name?: string }).name ?? "<anonymous>";
+    throw new Error(
+      `ElementType.fromArray: cannot infer ElementType from ${name}; ` +
+      `pass the kind explicitly (e.g. ElementType.V3f)`,
+    );
+  }
+  return et;
+}
+
+// ---------------------------------------------------------------------------
+// Public namespace
+// ---------------------------------------------------------------------------
+
+/**
+ * Singleton tokens + helpers. Most call sites use the singleton
+ * directly (`ElementType.V3f`); the helpers are kept on the
+ * namespace so `import { ElementType }` is the only import you
+ * need.
+ */
 export const ElementType = {
-  /** Size of one element in bytes. */
-  byteSize(t: ElementType): number {
-    switch (t) {
-      case "f32": case "u32": case "i32": return 4;
-      case "u16": case "i16": return 2;
-      case "u8":  case "i8":  return 1;
-      case "v2f": case "v2i": case "v2u": return 8;
-      case "v3f": case "v3i": case "v3u": return 12;
-      case "v4f": case "v4i": case "v4u": return 16;
-      case "m22f": return 16;
-      case "m33f": return 36;
-      case "m44f": return 64;
-      case "c4b": return 4;
-      case "c3b": return 3;
-    }
-  },
-
-  /**
-   * GPUVertexFormat for use as a vertex / instance attribute.
-   * `normalized=true` only affects integer types — picks the `unorm`
-   * / `snorm` form. Matrix types are not directly supported as
-   * vertex formats; the auto-instancing pass splits them into
-   * column attributes upstream.
-   */
-  toVertexFormat(t: ElementType, normalized = false): GPUVertexFormat {
-    switch (t) {
-      case "f32": return "float32";
-      case "u32": return "uint32";
-      case "i32": return "sint32";
-      case "v2f": return "float32x2";
-      case "v3f": return "float32x3";
-      case "v4f": return "float32x4";
-      case "v2i": return "sint32x2";
-      case "v3i": return "sint32x3";
-      case "v4i": return "sint32x4";
-      case "v2u": return "uint32x2";
-      case "v3u": return "uint32x3";
-      case "v4u": return "uint32x4";
-      case "u16": return normalized ? "unorm16x2" as GPUVertexFormat : "uint16";
-      case "i16": return normalized ? "snorm16x2" as GPUVertexFormat : "sint16";
-      case "u8":  return normalized ? "unorm8x4"  as GPUVertexFormat : "uint8";
-      case "i8":  return normalized ? "snorm8x4"  as GPUVertexFormat : "sint8";
-      case "c4b": return normalized ? "unorm8x4" : "uint8x4";
-      case "c3b":
-        // No 3-component byte format in WebGPU; promoted to x4 with
-        // a dummy fourth byte by the upload path.
-        throw new Error(`ElementType.toVertexFormat: c3b cannot be a vertex format directly; pad to c4b`);
-      case "m22f": case "m33f": case "m44f":
-        throw new Error(`ElementType.toVertexFormat: ${t} is a matrix; split into column attributes first`);
-    }
-  },
-
-  /** Index format. Throws unless the type is `u16` or `u32`. */
-  toIndexFormat(t: ElementType): GPUIndexFormat {
-    if (t === "u16") return "uint16";
-    if (t === "u32") return "uint32";
-    throw new Error(`ElementType.toIndexFormat: ${t} is not a valid index type (use u16 or u32)`);
-  },
+  // Float vectors
+  V2f:  _V2f, V3f: _V3f, V4f: _V4f,
+  // Float matrices (square)
+  M22f: _M22f, M33f: _M33f, M44f: _M44f,
+  // Signed-int vectors
+  V2i: _V2i, V3i: _V3i, V4i: _V4i,
+  // Unsigned-int vectors
+  V2u: _V2u, V3u: _V3u, V4u: _V4u,
+  // Scalars
+  F32: _F32, U32: _U32, I32: _I32,
+  U16: _U16, I16: _I16, U8: _U8, I8: _I8,
+
+  /** Infer from a wombat.base packed array or a native TypedArray. */
+  fromArray,
+  /** GPUVertexFormat for `t`; throws if `t` has no vertex form. */
+  toVertexFormat: asVertexFormat,
+  /** GPUIndexFormat for `t`; throws if `t` is not `u16` / `u32`. */
+  toIndexFormat:  asIndexFormat,
 } as const;

package/src/core/index.ts

@@ -17,6 +17,7 @@ export {
 
 export {
   ElementType,
+  ElementKind,
 } from "./elementType.js";
 
 export type {

package/src/resources/preparedRenderObject.ts

@@ -543,8 +543,16 @@ export function prepareRenderObject(
     const stepMode: GPUVertexStepMode = isInstance ? "instance" : "vertex";
 
     const view = (fromVertex ?? fromInstance)!;
-    const format = ElementType.toVertexFormat(view.elementType, view.normalized ?? false);
-    const stride = BufferView.strideOf(view);
+    const format = ElementType.toVertexFormat(view.elementType);
+    // Single-value broadcast — `BufferView.ofValue(...)` allocates a
+    // tight one-element buffer and asks every vertex/instance to read
+    // it. WebGPU reads the same element when arrayStride is 0
+    // (regardless of stepMode), so override the default tight stride
+    // here. Without this the second vertex would read past the end of
+    // the 16-byte buffer and pick up zeros — colorAval would tint
+    // only the first vertex of a draw.
+    const isBroadcast = view.singleValue !== undefined;
+    const stride = isBroadcast ? 0 : BufferView.strideOf(view);
     const offset = BufferView.offsetOf(view);
     resolved.push({
       name: vb.name,