@forgeax/engine-gltf 0.0.0-dev.8d955ade1c79

package/src/__tests__/parse-gltf-multi-uv.test.ts

@@ -0,0 +1,238 @@
+// parse-gltf-multi-uv.test.ts (feat-20260629-multi-uv-set-support m1-w1).
+//
+// TDD red-green-red: byte-level tests for TEXCOORD_0..7 parsing. Uses
+// hand-crafted glTF JSON with data: URIs to exercise the primitive-decode
+// loop.  Initial state is RED because GltfMeshIr currently only carries
+// texcoord0 — texcoord1..texcoord7 fields do not yet exist.
+//
+// Covers: 2/3/8 sets byte-level fidelity, sparse (skip-index) boundary,
+// and missing TEXCOORD_0 → texcoord0 undefined.
+
+import { describe, expect, it } from 'vitest';
+import type { GltfMeshIr } from '../parse-gltf.js';
+import { parseGltf } from '../parse-gltf.js';
+
+const noopLoader = async (_: string) => new ArrayBuffer(0);
+
+interface BufferEntry {
+  readonly uri: string;
+}
+interface BufferViewEntry {
+  readonly buffer: number;
+  readonly byteOffset: number;
+  readonly byteLength: number;
+}
+interface AccessorEntry {
+  readonly bufferView: number;
+  readonly byteOffset: number;
+  readonly componentType: number;
+  readonly count: number;
+  readonly type: string;
+}
+
+const FLOAT = 5126;
+
+function bytesToB64(bytes: Uint8Array): string {
+  return btoa(String.fromCharCode(...bytes));
+}
+
+function addBuf(
+  buffers: BufferEntry[],
+  bufferViews: BufferViewEntry[],
+  accessors: AccessorEntry[],
+  bytes: Uint8Array,
+  type: string,
+  count: number,
+  componentType: number,
+): number {
+  const bufIdx = buffers.length;
+  buffers.push({ uri: `data:application/octet-stream;base64,${bytesToB64(bytes)}` });
+  const bvIdx = bufferViews.length;
+  bufferViews.push({ buffer: bufIdx, byteOffset: 0, byteLength: bytes.byteLength });
+  const acIdx = accessors.length;
+  accessors.push({ bufferView: bvIdx, byteOffset: 0, componentType, count, type });
+  return acIdx;
+}
+
+/**
+ * Build a minimal glTF 2.0 JSON document with configurable TEXCOORD sets.
+ *
+ * @param texcoordSets  Array of UV data arrays (Float32Array per set).
+ *                      undefined entries represent missing sets (skip).
+ */
+function buildMultiUvJson(texcoordSets: ReadonlyArray<Float32Array | undefined>): unknown {
+  const buffers: BufferEntry[] = [];
+  const bufferViews: BufferViewEntry[] = [];
+  const accessors: AccessorEntry[] = [];
+
+  // Positions: 4 vertices * VEC3 * F32 = 48 bytes.
+  const posF32 = new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]);
+  const posIdx = addBuf(
+    buffers,
+    bufferViews,
+    accessors,
+    new Uint8Array(posF32.buffer),
+    'VEC3',
+    4,
+    FLOAT,
+  );
+
+  const attributes: Record<string, number> = { POSITION: posIdx };
+
+  for (let k = 0; k < texcoordSets.length; k++) {
+    const set = texcoordSets[k];
+    if (set === undefined) continue;
+    const bytes = new Uint8Array(set.buffer);
+    const count = set.byteLength / 4 / 2;
+    const idx = addBuf(buffers, bufferViews, accessors, bytes, 'VEC2', count, FLOAT);
+    attributes[`TEXCOORD_${k}`] = idx;
+  }
+
+  return {
+    asset: { version: '2.0' },
+    buffers,
+    bufferViews,
+    accessors,
+    meshes: [{ name: 'MultiUvMesh', primitives: [{ attributes }] }],
+    materials: [],
+    nodes: [],
+    scenes: [],
+  };
+}
+
+/** Cast a GltfMeshIr to a dynamic record for forward-looking field access (texcoord1..7). */
+function asDict(mesh: GltfMeshIr): Record<string, unknown> {
+  return mesh as unknown as Record<string, unknown>;
+}
+
+describe('parse-gltf-multi-uv.test.ts', () => {
+  describe('parseGltf TEXCOORD_0..7 multi-UV parsing', () => {
+    it('parses 2 sets of UV (TEXCOORD_0 + TEXCOORD_1) byte-identical', async () => {
+      const uv0 = new Float32Array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]);
+      const uv1 = new Float32Array([1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8]);
+      const json = buildMultiUvJson([uv0, uv1]);
+      const result = await parseGltf(json, noopLoader, '/multi-uv.gltf');
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+
+      const mesh: GltfMeshIr | undefined = result.value.meshes[0];
+      expect(mesh).toBeDefined();
+      if (!mesh) return;
+
+      // texcoord0 must exist and match byte-for-byte
+      expect(mesh.texcoord0).toBeInstanceOf(Float32Array);
+      expect(mesh.texcoord0?.length).toBe(8);
+      for (let i = 0; i < 8; i++) {
+        expect(mesh.texcoord0?.[i]).toBeCloseTo(uv0[i] ?? NaN, 6);
+      }
+
+      // texcoord1 should exist once GltfMeshIr is extended (m1-w2).
+      // Until then, this assertion will fail (RED — expected TDD red phase).
+      // After m1-w2 adds texcoord1 to GltfMeshIr and parse-gltf.ts decodes
+      // TEXCOORD_1, this assertion becomes green.
+      const meshRecord = asDict(mesh);
+      const uv1Actual = meshRecord.texcoord1 as Float32Array | undefined;
+      expect(uv1Actual, 'texcoord1 should exist on GltfMeshIr after m1-w2').toBeDefined();
+      if (!uv1Actual) return;
+      expect(uv1Actual.length).toBe(8);
+      for (let i = 0; i < 8; i++) {
+        expect(uv1Actual[i]).toBeCloseTo(uv1[i] ?? NaN, 6);
+      }
+    });
+
+    it('parses 3 sets of UV (TEXCOORD_0..2) byte-identical', async () => {
+      const uv0 = new Float32Array([0.0, 0.0, 0.1, 0.1, 0.2, 0.2, 0.3, 0.3]);
+      const uv1 = new Float32Array([1.0, 1.0, 1.1, 1.1, 1.2, 1.2, 1.3, 1.3]);
+      const uv2 = new Float32Array([2.0, 2.0, 2.1, 2.1, 2.2, 2.2, 2.3, 2.3]);
+      const json = buildMultiUvJson([uv0, uv1, uv2]);
+      const result = await parseGltf(json, noopLoader, '/multi-uv.gltf');
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+
+      const mesh = result.value.meshes[0];
+      expect(mesh).toBeDefined();
+      if (!mesh) return;
+
+      expect(mesh.texcoord0?.length).toBe(8);
+      const meshRecord = asDict(mesh);
+      const uv1Actual = meshRecord.texcoord1 as Float32Array | undefined;
+      const uv2Actual = meshRecord.texcoord2 as Float32Array | undefined;
+      expect(uv1Actual, 'texcoord1').toBeDefined();
+      expect(uv2Actual, 'texcoord2').toBeDefined();
+      if (!uv1Actual || !uv2Actual) return;
+      expect(uv1Actual.length).toBe(8);
+      expect(uv2Actual.length).toBe(8);
+      for (let i = 0; i < 8; i++) {
+        expect(uv1Actual[i]).toBeCloseTo(uv1[i] ?? NaN, 6);
+        expect(uv2Actual[i]).toBeCloseTo(uv2[i] ?? NaN, 6);
+      }
+    });
+
+    it('parses 8 sets of UV (TEXCOORD_0..7) byte-identical', async () => {
+      const sets = Array.from({ length: 8 }, (_, k) => {
+        const arr = new Float32Array(8); // 4 verts * 2
+        for (let i = 0; i < 8; i++) arr[i] = k + i * 0.01;
+        return arr;
+      });
+      const json = buildMultiUvJson(sets);
+      const result = await parseGltf(json, noopLoader, '/multi-uv.gltf');
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+
+      const mesh = result.value.meshes[0];
+      expect(mesh).toBeDefined();
+      if (!mesh) return;
+      expect(mesh.texcoord0?.length).toBe(8);
+
+      const meshRecord = asDict(mesh);
+      for (let k = 1; k <= 7; k++) {
+        const actual = meshRecord[`texcoord${k}`] as Float32Array | undefined;
+        expect(actual, `texcoord${k} should exist`).toBeDefined();
+        if (!actual) continue;
+        expect(actual.length).toBe(8);
+        for (let i = 0; i < 8; i++) {
+          expect(actual[i]).toBeCloseTo(sets[k]?.[i] ?? NaN, 6);
+        }
+      }
+    });
+
+    it('handles sparse UV sets: TEXCOORD_0 + TEXCOORD_2 (no TEXCOORD_1) → texcoord1 undefined', async () => {
+      const uv0 = new Float32Array([0.0, 0.0, 0.1, 0.1, 0.2, 0.2, 0.3, 0.3]);
+      const uv2 = new Float32Array([2.0, 2.0, 2.1, 2.1, 2.2, 2.2, 2.3, 2.3]);
+      const json = buildMultiUvJson([uv0, undefined, uv2]);
+      const result = await parseGltf(json, noopLoader, '/sparse-uv.gltf');
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+
+      const mesh = result.value.meshes[0];
+      expect(mesh).toBeDefined();
+      if (!mesh) return;
+      expect(mesh.texcoord0?.length).toBe(8);
+
+      const meshRecord = asDict(mesh);
+      // texcoord1 should be undefined (missing set)
+      expect(meshRecord.texcoord1, 'texcoord1 should be undefined for sparse set').toBeUndefined();
+      // texcoord2 should exist
+      const uv2Actual = meshRecord.texcoord2 as Float32Array | undefined;
+      expect(uv2Actual, 'texcoord2 should exist even when texcoord1 is skipped').toBeDefined();
+      if (!uv2Actual) return;
+      expect(uv2Actual.length).toBe(8);
+      for (let i = 0; i < 8; i++) {
+        expect(uv2Actual[i]).toBeCloseTo(uv2[i] ?? NaN, 6);
+      }
+    });
+
+    it('handles mesh with no TEXCOORD_0 → texcoord0 undefined', async () => {
+      const json = buildMultiUvJson([]); // zero UV sets
+      const result = await parseGltf(json, noopLoader, '/no-uv.gltf');
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+
+      const mesh = result.value.meshes[0];
+      expect(mesh).toBeDefined();
+      if (!mesh) return;
+      expect(mesh.texcoord0).toBeUndefined();
+      expect(mesh.positions.length).toBe(12); // positions still decoded
+    });
+  });
+});

package/src/__tests__/parse-gltf-skin-attrs.unit.test.ts

@@ -0,0 +1,191 @@
+// parse-gltf-skin-attrs.unit.test.ts (feat-20260611 M1).
+//
+// Covers AC-06 (JOINTS_0/WEIGHTS_0 paired-presence fail-fast) and
+// AC-10 (UBYTE JOINTS_0 width-convert to Uint16Array at parse stage).
+// Owns parseGltf primitive-decode skin-attr surface; parse-decode.unit.test.ts
+// continues to cover positions/normals/texcoord/tangent.
+
+import { describe, expect, it } from 'vitest';
+import type { GltfMeshIr } from '../parse-gltf.js';
+import { parseGltf } from '../parse-gltf.js';
+
+const noopLoader = async (_: string) => new ArrayBuffer(0);
+
+interface BufferEntry {
+  readonly uri: string;
+}
+interface BufferViewEntry {
+  readonly buffer: number;
+  readonly byteOffset: number;
+  readonly byteLength: number;
+}
+interface AccessorEntry {
+  readonly bufferView: number;
+  readonly byteOffset: number;
+  readonly componentType: number;
+  readonly count: number;
+  readonly type: string;
+}
+
+function bytesToB64(bytes: Uint8Array): string {
+  return btoa(String.fromCharCode(...bytes));
+}
+
+interface SkinPrimitiveOptions {
+  readonly includeJoints: boolean;
+  readonly includeWeights: boolean;
+  readonly jointsComponentType: number;
+}
+
+// glTF spec component-type IDs.
+const UBYTE = 5121;
+const FLOAT = 5126;
+
+function buildSkinPrimitiveJson(opts: SkinPrimitiveOptions): unknown {
+  // 4 vertices for VEC4 attributes; positions are VEC3.
+  const buffers: BufferEntry[] = [];
+  const bufferViews: BufferViewEntry[] = [];
+  const accessors: AccessorEntry[] = [];
+
+  function addBuf(bytes: Uint8Array, type: string, count: number, componentType: number): number {
+    const bufIdx = buffers.length;
+    buffers.push({ uri: `data:application/octet-stream;base64,${bytesToB64(bytes)}` });
+    const bvIdx = bufferViews.length;
+    bufferViews.push({ buffer: bufIdx, byteOffset: 0, byteLength: bytes.byteLength });
+    const acIdx = accessors.length;
+    accessors.push({ bufferView: bvIdx, byteOffset: 0, componentType, count, type });
+    return acIdx;
+  }
+
+  // Positions: 4 vertices * VEC3 * F32 = 48 bytes.
+  const posBytes = new Uint8Array(new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]).buffer);
+  const posIdx = addBuf(posBytes, 'VEC3', 4, FLOAT);
+
+  let jointsIdx: number | undefined;
+  if (opts.includeJoints) {
+    if (opts.jointsComponentType === UBYTE) {
+      // 4 vertices * VEC4 * U8 = 16 bytes; include 0 and 255 boundaries.
+      const j = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 255]);
+      jointsIdx = addBuf(j, 'VEC4', 4, UBYTE);
+    } else {
+      // U16 path: 4 * VEC4 * 2 = 32 bytes.
+      const j16 = new Uint16Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 65535]);
+      const jBytes = new Uint8Array(j16.buffer);
+      jointsIdx = addBuf(jBytes, 'VEC4', 4, 5123);
+    }
+  }
+  let weightsIdx: number | undefined;
+  if (opts.includeWeights) {
+    const w = new Float32Array([
+      1, 0, 0, 0, 0.5, 0.5, 0, 0, 0.25, 0.25, 0.25, 0.25, 0.7, 0.1, 0.1, 0.1,
+    ]);
+    const wBytes = new Uint8Array(w.buffer);
+    weightsIdx = addBuf(wBytes, 'VEC4', 4, FLOAT);
+  }
+
+  const attributes: Record<string, number> = { POSITION: posIdx };
+  if (jointsIdx !== undefined) attributes.JOINTS_0 = jointsIdx;
+  if (weightsIdx !== undefined) attributes.WEIGHTS_0 = weightsIdx;
+
+  return {
+    asset: { version: '2.0' },
+    buffers,
+    bufferViews,
+    accessors,
+    meshes: [{ name: 'SkinMesh', primitives: [{ attributes }] }],
+    materials: [],
+    nodes: [],
+    scenes: [],
+  };
+}
+
+describe('parse-gltf-skin-attrs.unit.test.ts', () => {
+  describe('parseGltf JOINTS_0 / WEIGHTS_0 paired skinning attributes', () => {
+    it('AC-10: UBYTE JOINTS_0 width-converts to Uint16Array (length 16, 0/255 boundaries preserved)', async () => {
+      const json = buildSkinPrimitiveJson({
+        includeJoints: true,
+        includeWeights: true,
+        jointsComponentType: UBYTE,
+      });
+      const result = await parseGltf(json, noopLoader, '/skin.gltf');
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+
+      const mesh: GltfMeshIr | undefined = result.value.meshes[0];
+      expect(mesh).toBeDefined();
+      if (!mesh) return;
+
+      expect(mesh.joints0).toBeDefined();
+      const joints = mesh.joints0;
+      if (!joints) return;
+      expect(joints).toBeInstanceOf(Uint16Array);
+      expect(joints.length).toBe(16);
+      // Source UBYTE values: 0..14, 255 (boundary).
+      const expected = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 255];
+      for (let i = 0; i < 16; i++) {
+        expect(joints[i]).toBe(expected[i]);
+      }
+    });
+
+    it('AC-06: JOINTS_0 present without WEIGHTS_0 -> gltf-skin-attr-asymmetric (hasJoints=true)', async () => {
+      const json = buildSkinPrimitiveJson({
+        includeJoints: true,
+        includeWeights: false,
+        jointsComponentType: UBYTE,
+      });
+      const result = await parseGltf(json, noopLoader, '/skin.gltf');
+      expect(result.ok).toBe(false);
+      if (result.ok) return;
+      expect(result.error.code).toBe('gltf-skin-attr-asymmetric');
+      if (result.error.code !== 'gltf-skin-attr-asymmetric') return;
+      expect(result.error.detail.hasJoints).toBe(true);
+      expect(result.error.detail.hasWeights).toBe(false);
+      expect(result.error.detail.meshIndex).toBe(0);
+      expect(result.error.detail.primitiveIndex).toBe(0);
+      expect(typeof result.error.hint).toBe('string');
+      expect(result.error.hint.length).toBeGreaterThan(0);
+    });
+
+    it('AC-06: WEIGHTS_0 present without JOINTS_0 -> gltf-skin-attr-asymmetric (hasWeights=true)', async () => {
+      const json = buildSkinPrimitiveJson({
+        includeJoints: false,
+        includeWeights: true,
+        jointsComponentType: UBYTE,
+      });
+      const result = await parseGltf(json, noopLoader, '/skin.gltf');
+      expect(result.ok).toBe(false);
+      if (result.ok) return;
+      expect(result.error.code).toBe('gltf-skin-attr-asymmetric');
+      if (result.error.code !== 'gltf-skin-attr-asymmetric') return;
+      expect(result.error.detail.hasJoints).toBe(false);
+      expect(result.error.detail.hasWeights).toBe(true);
+    });
+
+    it('AC-06+AC-10: complete skin pair parses cleanly + non-skin attrs unaffected', async () => {
+      const json = buildSkinPrimitiveJson({
+        includeJoints: true,
+        includeWeights: true,
+        jointsComponentType: UBYTE,
+      });
+      const result = await parseGltf(json, noopLoader, '/skin.gltf');
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+
+      const mesh: GltfMeshIr | undefined = result.value.meshes[0];
+      expect(mesh).toBeDefined();
+      if (!mesh) return;
+
+      // (b) joints0 typed + length === vertex count * 4.
+      expect(mesh.joints0).toBeInstanceOf(Uint16Array);
+      expect(mesh.joints0?.length).toBe(16);
+      // (c) weights0 typed + length === vertex count * 4.
+      expect(mesh.weights0).toBeInstanceOf(Float32Array);
+      expect(mesh.weights0?.length).toBe(16);
+      // (d) positions still decoded; no regression on the non-skin path.
+      expect(mesh.positions).toBeInstanceOf(Float32Array);
+      expect(mesh.positions.length).toBe(12);
+      expect(mesh.positions[0]).toBeCloseTo(0);
+      expect(mesh.positions[3]).toBeCloseTo(1);
+    });
+  });
+});

package/src/__tests__/parse-gltf.unit.test.ts

@@ -0,0 +1,133 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { dataUriBase64Payload, decodeBase64 } from '../data-uri.js';
+import { parseGltf } from '../parse-gltf.js';
+
+const noopLoader = async (_uri: string) => new ArrayBuffer(0);
+
+async function parseMaterial(material: Record<string, unknown>) {
+  const result = await parseGltf(
+    {
+      asset: { version: '2.0' },
+      materials: [material],
+    },
+    noopLoader,
+    '/material-alpha.gltf',
+  );
+  expect(result.ok).toBe(true);
+  if (!result.ok) throw new Error('expected material parse to succeed');
+  return result.value.materials[0];
+}
+
+describe('glTF MASK alpha cutoff parsing', () => {
+  it('applies the glTF default cutoff of 0.5', async () => {
+    const material = await parseMaterial({
+      alphaMode: 'MASK',
+      pbrMetallicRoughness: { baseColorFactor: [1, 1, 1, 0.5] },
+    });
+
+    expect(material?.alphaMode).toBe('MASK');
+    expect(material?.alphaCutoff).toBe(0.5);
+  });
+
+  it.each([0, 0.5, 1])('preserves the explicit cutoff boundary %s', async (cutoff) => {
+    const material = await parseMaterial({
+      alphaMode: 'MASK',
+      alphaCutoff: cutoff,
+      pbrMetallicRoughness: { baseColorFactor: [1, 1, 1, 0.5] },
+    });
+
+    expect(material?.alphaCutoff).toBe(cutoff);
+  });
+});
+
+describe('glTF COLOR_0 importer carrier', () => {
+  it('publishes normalized VEC3 FLOAT colors as importer-owned RGBA', async () => {
+    const fixture = JSON.parse(
+      readFileSync(new URL('./fixtures/color-0/float-vec3.gltf', import.meta.url), 'utf8'),
+    ) as {
+      readonly buffers: readonly { readonly uri: string }[];
+      readonly meshes: readonly {
+        readonly primitives: readonly { readonly attributes: Record<string, number> }[];
+      }[];
+      readonly accessors: readonly unknown[];
+      readonly bufferViews: readonly unknown[];
+    };
+    const uri = fixture.buffers[0]?.uri;
+    if (uri === undefined) throw new Error('fixture buffer is missing');
+    const payload = dataUriBase64Payload(uri);
+    if (payload === undefined) throw new Error('fixture buffer must be a data URI');
+    const result = await parseGltf(
+      fixture,
+      async () => {
+        const bytes = decodeBase64(payload);
+        const buffer = new ArrayBuffer(bytes.byteLength);
+        new Uint8Array(buffer).set(bytes);
+        return buffer;
+      },
+      '/fixtures/color-0/float-vec3.gltf',
+    );
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const mesh = result.value.meshes[0] as unknown as {
+      readonly colors0?: Float32Array;
+    };
+    expect(Array.from(mesh.colors0 ?? [])).toEqual([0, 0.5, 1, 1, 1, 0.25, 0, 1]);
+  });
+
+  it('keeps an absent COLOR_0 distinct from a present-invalid accessor', async () => {
+    const source = JSON.parse(
+      readFileSync(new URL('./fixtures/color-0/float-vec3.gltf', import.meta.url), 'utf8'),
+    ) as {
+      readonly asset: { readonly version: string };
+      readonly buffers: readonly unknown[];
+      readonly bufferViews: readonly unknown[];
+      readonly accessors: readonly unknown[];
+      readonly meshes: readonly {
+        readonly primitives: readonly { readonly attributes: Record<string, number> }[];
+      }[];
+    };
+    const sourcePrimitive = source.meshes[0]?.primitives[0];
+    if (sourcePrimitive === undefined) throw new Error('fixture primitive is missing');
+    const plain = await parseGltf(
+      {
+        ...source,
+        meshes: [
+          {
+            primitives: [{ attributes: { POSITION: sourcePrimitive.attributes.POSITION ?? 0 } }],
+          },
+        ],
+      },
+      noopLoader,
+      '/fixtures/color-0/absent.gltf',
+    );
+    expect(plain.ok).toBe(true);
+    if (!plain.ok) return;
+    expect(
+      (plain.value.meshes[0] as unknown as { readonly colors0?: unknown }).colors0,
+    ).toBeUndefined();
+
+    const invalid = await parseGltf(
+      {
+        ...source,
+        meshes: [
+          {
+            primitives: [
+              {
+                attributes: {
+                  POSITION: sourcePrimitive.attributes.POSITION ?? 0,
+                  COLOR_0: 9,
+                },
+              },
+            ],
+          },
+        ],
+      },
+      noopLoader,
+      '/fixtures/color-0/present-invalid.gltf',
+    );
+    expect(invalid.ok).toBe(false);
+    if (invalid.ok) return;
+    expect(invalid.error.detail).toMatchObject({ semantic: 'COLOR_0', accessorIndex: 9 });
+  });
+});