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

package/src/__tests__/source-key.unit.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, expectTypeOf, it } from 'vitest';
+import { type GltfMetaJson, reimportReuseMeta } from '../reimport-reuse-meta.js';
+import {
+  deriveGltfSourceKeys,
+  type GltfSourceKeyError,
+  type GltfSourceKeyErrorCode,
+} from '../source-key.js';
+
+const META_BASE: GltfMetaJson = {
+  schemaVersion: 1,
+  kind: 'external-asset-package',
+  importer: 'gltf',
+  source: 'scene.gltf',
+  subAssets: [],
+  importSettings: {
+    defaultSceneIndex: 0,
+    diagnostics: { nodeNames: [], unsupportedExtensions: [], matrixTrsCoexistNodes: [] },
+  },
+};
+
+describe('glTF producer sourceKey', () => {
+  it('derives the public error-code alias from its error owner', () => {
+    expectTypeOf<GltfSourceKeyErrorCode>().toEqualTypeOf<GltfSourceKeyError['code']>();
+  });
+
+  it('derives stable semantic keys without using sourceIndex or locator', () => {
+    const result = deriveGltfSourceKeys([
+      { kind: 'mesh', sourceIndex: 4, name: 'Hero' },
+      { kind: 'material', sourceIndex: 0, name: 'Skin' },
+    ]);
+    expect(result).toEqual({ ok: true, keys: ['mesh:Hero', 'material:Skin'], conflicts: [] });
+  });
+
+  it('reports duplicate semantic names as a structured conflict', () => {
+    const result = deriveGltfSourceKeys([
+      { kind: 'mesh', sourceIndex: 0, name: 'Hero' },
+      { kind: 'mesh', sourceIndex: 1, name: 'Hero' },
+    ]);
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error.code).toBe('duplicate-source-key');
+  });
+
+  it('uses the semantic kind for one anonymous output, never sourceIndex', () => {
+    const result = deriveGltfSourceKeys([{ kind: 'mesh', sourceIndex: 7 }]);
+    expect(result).toEqual({ ok: true, keys: ['mesh'], conflicts: [] });
+  });
+
+  it('persists an output display name in the generated sub-asset entry', () => {
+    const result = reimportReuseMeta([{ kind: 'mesh', sourceIndex: 0, name: 'Hero' }], undefined);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.subAssets[0]).toMatchObject({
+      kind: 'mesh',
+      sourceKey: 'mesh:Hero',
+      name: 'Hero',
+    });
+  });
+
+  it('rejects two anonymous outputs of one kind as ambiguous', () => {
+    const result = deriveGltfSourceKeys([
+      { kind: 'mesh', sourceIndex: 7 },
+      { kind: 'mesh', sourceIndex: 9 },
+    ]);
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error.code).toBe('ambiguous-source-key');
+  });
+
+  it('preserves keyed identity when output order changes', () => {
+    const existing: GltfMetaJson = {
+      ...META_BASE,
+      subAssets: [
+        {
+          guid: '01928000-7c00-7000-8000-000000000001',
+          sourceIndex: 0,
+          kind: 'mesh',
+          sourceKey: 'mesh:Hero',
+        },
+        {
+          guid: '01928000-7c00-7000-8000-000000000002',
+          sourceIndex: 1,
+          kind: 'mesh',
+          sourceKey: 'mesh:Body',
+        },
+      ],
+    };
+    const result = reimportReuseMeta(
+      [
+        { kind: 'mesh', sourceIndex: 0, name: 'Body' },
+        { kind: 'mesh', sourceIndex: 1, name: 'Hero' },
+      ],
+      existing,
+    );
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.subAssets).toMatchObject([
+      { guid: '01928000-7c00-7000-8000-000000000002', sourceIndex: 0, sourceKey: 'mesh:Body' },
+      { guid: '01928000-7c00-7000-8000-000000000001', sourceIndex: 1, sourceKey: 'mesh:Hero' },
+    ]);
+  });
+
+  it('preserves keyed identity when a new output is inserted', () => {
+    const existing: GltfMetaJson = {
+      ...META_BASE,
+      subAssets: [
+        {
+          guid: '01928000-7c00-7000-8000-000000000004',
+          sourceIndex: 0,
+          kind: 'mesh',
+          sourceKey: 'mesh:Hero',
+        },
+        {
+          guid: '01928000-7c00-7000-8000-000000000005',
+          sourceIndex: 1,
+          kind: 'mesh',
+          sourceKey: 'mesh:Body',
+        },
+      ],
+    };
+    const result = reimportReuseMeta(
+      [
+        { kind: 'mesh', sourceIndex: 0, name: 'New' },
+        { kind: 'mesh', sourceIndex: 1, name: 'Hero' },
+        { kind: 'mesh', sourceIndex: 2, name: 'Body' },
+      ],
+      existing,
+    );
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.subAssets.slice(1)).toMatchObject([
+      { guid: '01928000-7c00-7000-8000-000000000004', sourceKey: 'mesh:Hero' },
+      { guid: '01928000-7c00-7000-8000-000000000005', sourceKey: 'mesh:Body' },
+    ]);
+  });
+
+  it('reuses an anonymous semantic kind key when its sourceIndex changes', () => {
+    const existing: GltfMetaJson = {
+      ...META_BASE,
+      subAssets: [
+        {
+          guid: '01928000-7c00-7000-8000-000000000003',
+          sourceIndex: 0,
+          kind: 'scene',
+          sourceKey: 'scene',
+        },
+      ],
+    };
+    const result = reimportReuseMeta([{ kind: 'scene', sourceIndex: 9 }], existing);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.subAssets).toEqual([
+      {
+        guid: '01928000-7c00-7000-8000-000000000003',
+        sourceIndex: 9,
+        kind: 'scene',
+        sourceKey: 'scene',
+      },
+    ]);
+  });
+});

package/src/accessor/decode-accessor.ts

@@ -0,0 +1,309 @@
+// decode-accessor.ts - glTF 2.0 accessor decoder (w9).
+//
+// Pure helper that walks one accessor and returns the typed array view of
+// its dense values. Tier-B v1 accepts only the dense, fixed-stride,
+// non-sparse, non-morph subset; everything else returns
+// `gltf-accessor-type-mismatch` with the reason discriminator.
+//
+// glTF 2.0 spec section 3.6 (accessor):
+//   - componentType  : 5120 I8 / 5121 U8 / 5122 I16 / 5123 U16 / 5125 U32 / 5126 F32
+//   - type           : 'SCALAR' / 'VEC2' / 'VEC3' / 'VEC4' / 'MAT2' / 'MAT3' / 'MAT4'
+//   - bufferView     : index into bufferViews[]
+//   - byteOffset     : within bufferView
+//   - count          : number of elements
+//   - sparse         : OOS (Tier-B v1 reject)
+//   - bufferView.byteStride : when set and != element_size -> interleaved (OOS reject)
+//
+// The U8 -> U16 widening for INDICES is handled inline (a 1-byte index
+// stream is rewritten into a fresh Uint16Array). U16 and U32 index streams
+// pass through at their source width; `MeshAsset.indices` is
+// `Uint16Array | Uint32Array` end-to-end (mesh-bin serializes iwidth 2|4,
+// GPU runtime auto-selects the index format), and bridge.ts narrows U32 to
+// U16 losslessly when the merged mesh's maxIndex fits.
+//
+// Producers MUST use `decodeAccessor` rather than reading typed arrays
+// directly so the closed `GltfErrorCode` surface (charter proposition 4)
+// is the only public failure path.
+
+import { err, type GltfError, gltfErr, ok, type Result } from '../errors.js';
+
+/** glTF 2.0 component-type IDs (KHR spec section 3.6 table 4). */
+export const COMPONENT_TYPE = {
+  I8: 5120,
+  U8: 5121,
+  I16: 5122,
+  U16: 5123,
+  U32: 5125,
+  F32: 5126,
+} as const;
+export type ComponentTypeId = (typeof COMPONENT_TYPE)[keyof typeof COMPONENT_TYPE];
+
+/** Number of components per element for each glTF accessor `type` literal. */
+const TYPE_COMPONENT_COUNT: Readonly<Record<string, number>> = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16,
+};
+
+/** Byte size of one component for each component type. */
+const COMPONENT_BYTE_SIZE: Readonly<Record<number, number>> = {
+  [COMPONENT_TYPE.I8]: 1,
+  [COMPONENT_TYPE.U8]: 1,
+  [COMPONENT_TYPE.I16]: 2,
+  [COMPONENT_TYPE.U16]: 2,
+  [COMPONENT_TYPE.U32]: 4,
+  [COMPONENT_TYPE.F32]: 4,
+};
+
+/** Minimal accessor JSON shape touched by the decoder. */
+export interface AccessorJson {
+  readonly bufferView: number;
+  readonly byteOffset?: number;
+  readonly componentType: number;
+  readonly count: number;
+  readonly normalized?: boolean;
+  readonly type: string;
+  readonly sparse?: unknown;
+}
+
+/** Minimal bufferView JSON shape touched by the decoder. */
+export interface BufferViewJson {
+  readonly buffer: number;
+  readonly byteOffset?: number;
+  readonly byteLength: number;
+  readonly byteStride?: number;
+}
+
+/**
+ * Caller intent flag: when this accessor backs a mesh `INDICES` slot, U8
+ * indices auto-widen to U16 (Tier-B v1 mesh asset stores U16 only).
+ */
+export type AccessorRole = 'attribute' | 'indices' | 'joints';
+
+export interface DecodeAccessorInput {
+  readonly accessorIndex: number;
+  readonly accessor: AccessorJson;
+  readonly bufferView: BufferViewJson;
+  readonly buffer: Uint8Array;
+  readonly role: AccessorRole;
+}
+
+export type DecodedAccessor =
+  | { readonly kind: 'f32'; readonly data: Float32Array }
+  | { readonly kind: 'u16'; readonly data: Uint16Array }
+  | { readonly kind: 'u32'; readonly data: Uint32Array };
+
+type F32AccessorJson = Omit<AccessorJson, 'bufferView'> & {
+  readonly bufferView?: number;
+};
+
+/**
+ * Decode an F32 accessor for parser-owned type subsets without duplicating
+ * buffer lookup and dense-range handling in each parser.
+ */
+export function decodeF32Accessor(
+  accessorIndex: number,
+  accessor: F32AccessorJson,
+  allowedTypes: readonly string[],
+  bufferViews: readonly BufferViewJson[],
+  buffers: readonly Uint8Array[],
+): Result<Float32Array, GltfError> {
+  if (accessor.componentType !== COMPONENT_TYPE.F32 || !allowedTypes.includes(accessor.type)) {
+    return err(
+      gltfErr('gltf-accessor-type-mismatch', { accessorIndex, reason: 'unknownComponentType' }),
+    );
+  }
+
+  const bufferViewIndex = accessor.bufferView;
+  if (bufferViewIndex === undefined) {
+    return err(
+      gltfErr('gltf-buffer-out-of-bounds', {
+        accessor: accessorIndex,
+        byteOffset: 0,
+        byteLength: 0,
+        bufferIndex: 0,
+      }),
+    );
+  }
+  const bufferView = bufferViews[bufferViewIndex];
+  if (bufferView === undefined) {
+    return err(
+      gltfErr('gltf-buffer-out-of-bounds', {
+        accessor: accessorIndex,
+        byteOffset: 0,
+        byteLength: 0,
+        bufferIndex: bufferViewIndex,
+      }),
+    );
+  }
+  const buffer = buffers[bufferView.buffer];
+  if (buffer === undefined) {
+    return err(
+      gltfErr('gltf-buffer-out-of-bounds', {
+        accessor: accessorIndex,
+        byteOffset: bufferView.byteOffset ?? 0,
+        byteLength: bufferView.byteLength,
+        bufferIndex: bufferView.buffer,
+      }),
+    );
+  }
+
+  const decoded = decodeAccessor({
+    accessor: { ...accessor, bufferView: bufferViewIndex },
+    bufferView,
+    buffer,
+    accessorIndex,
+    role: 'attribute',
+  });
+  if (!decoded.ok) return decoded;
+  if (decoded.value.kind !== 'f32') {
+    return err(
+      gltfErr('gltf-accessor-type-mismatch', { accessorIndex, reason: 'unknownComponentType' }),
+    );
+  }
+  return ok(decoded.value.data);
+}
+
+/**
+ * Decode a dense glTF accessor into the typed array view of its values.
+ * Rejects sparse / morph / interleaved / unknown-componentType variants
+ * with `gltf-accessor-type-mismatch`. Out-of-range byte slices return
+ * `gltf-buffer-out-of-bounds`.
+ *
+ * `morph` is signalled by the caller (mesh primitive iteration in
+ * parseGltf) by passing an accessor reached via a `targets[]` slot - the
+ * decoder cannot infer it from the accessor JSON alone, so this function
+ * surfaces the reason via the `morph` parameter when the caller has
+ * already detected it.
+ */
+export function decodeAccessor(
+  input: DecodeAccessorInput,
+  flags: { readonly morph?: boolean } = {},
+): Result<DecodedAccessor, GltfError> {
+  const { accessorIndex, accessor, bufferView, buffer, role } = input;
+
+  if (flags.morph === true) {
+    return err(
+      gltfErr('gltf-accessor-type-mismatch', {
+        accessorIndex,
+        reason: 'morph',
+      }),
+    );
+  }
+
+  if ('sparse' in accessor && accessor.sparse !== undefined) {
+    return err(
+      gltfErr('gltf-accessor-type-mismatch', {
+        accessorIndex,
+        reason: 'sparse',
+      }),
+    );
+  }
+
+  const componentByteSize = COMPONENT_BYTE_SIZE[accessor.componentType];
+  const componentCount = TYPE_COMPONENT_COUNT[accessor.type];
+  if (componentByteSize === undefined || componentCount === undefined) {
+    return err(
+      gltfErr('gltf-accessor-type-mismatch', {
+        accessorIndex,
+        reason: 'unknownComponentType',
+      }),
+    );
+  }
+  const elementSize = componentByteSize * componentCount;
+  const byteStride = bufferView.byteStride;
+  if (byteStride !== undefined && byteStride !== elementSize) {
+    return err(
+      gltfErr('gltf-accessor-type-mismatch', {
+        accessorIndex,
+        reason: 'interleaved',
+      }),
+    );
+  }
+
+  const accessorByteOffset = accessor.byteOffset ?? 0;
+  const bufferViewByteOffset = bufferView.byteOffset ?? 0;
+  const totalByteLength = elementSize * accessor.count;
+  if (accessorByteOffset + totalByteLength > bufferView.byteLength) {
+    return err(
+      gltfErr('gltf-buffer-out-of-bounds', {
+        accessor: accessorIndex,
+        byteOffset: bufferViewByteOffset + accessorByteOffset,
+        byteLength: totalByteLength,
+        bufferIndex: bufferView.buffer,
+      }),
+    );
+  }
+  const absoluteOffset = bufferViewByteOffset + accessorByteOffset;
+  if (absoluteOffset + totalByteLength > buffer.byteLength) {
+    return err(
+      gltfErr('gltf-buffer-out-of-bounds', {
+        accessor: accessorIndex,
+        byteOffset: absoluteOffset,
+        byteLength: totalByteLength,
+        bufferIndex: bufferView.buffer,
+      }),
+    );
+  }
+
+  // U8 INDICES auto-widen to U16 (Tier-B v1 mesh asset stores U16 only).
+  if (role === 'indices' && accessor.componentType === COMPONENT_TYPE.U8) {
+    const widened = new Uint16Array(accessor.count);
+    for (let i = 0; i < accessor.count; i++) {
+      widened[i] = buffer[absoluteOffset + i] ?? 0;
+    }
+    return ok({ kind: 'u16', data: widened });
+  }
+  // U8 JOINTS auto-widen to U16 (Tier-B v1 mesh asset stores U16 only).
+  // Reuses the indices widen pattern (E-5) but JOINTS_0 is VEC4 (componentCount=4),
+  // not SCALAR like INDICES; total values = accessor.count * componentCount.
+  if (role === 'joints' && accessor.componentType === COMPONENT_TYPE.U8) {
+    const totalValues = accessor.count * componentCount;
+    const widened = new Uint16Array(totalValues);
+    for (let i = 0; i < totalValues; i++) {
+      widened[i] = buffer[absoluteOffset + i] ?? 0;
+    }
+    return ok({ kind: 'u16', data: widened });
+  }
+  if (accessor.componentType === COMPONENT_TYPE.F32) {
+    // Copy out (rather than alias) so callers may safely mutate / persist
+    // the result independent of the underlying GLB BIN chunk lifetime.
+    const out = new Float32Array(accessor.count * componentCount);
+    const src = new Float32Array(buffer.buffer, buffer.byteOffset + absoluteOffset, out.length);
+    out.set(src);
+    return ok({ kind: 'f32', data: out });
+  }
+  if (accessor.componentType === COMPONENT_TYPE.U16) {
+    const out = new Uint16Array(accessor.count * componentCount);
+    const src = new Uint16Array(buffer.buffer, buffer.byteOffset + absoluteOffset, out.length);
+    out.set(src);
+    return ok({ kind: 'u16', data: out });
+  }
+  if (accessor.componentType === COMPONENT_TYPE.U32) {
+    const out = new Uint32Array(accessor.count * componentCount);
+    const src = new Uint32Array(buffer.buffer, buffer.byteOffset + absoluteOffset, out.length);
+    out.set(src);
+    return ok({ kind: 'u32', data: out });
+  }
+  if (accessor.componentType === COMPONENT_TYPE.I16) {
+    const out = new Float32Array(accessor.count * componentCount);
+    const src = new Int16Array(buffer.buffer, buffer.byteOffset + absoluteOffset, out.length);
+    for (let index = 0; index < src.length; index++) {
+      const value = src[index] ?? 0;
+      out[index] = accessor.normalized === true ? Math.max(-1, value / 32767) : value;
+    }
+    return ok({ kind: 'f32', data: out });
+  }
+  // I8 remains outside the current attribute contract. Keep it rejected
+  // rather than silently widening an unowned representation.
+  return err(
+    gltfErr('gltf-accessor-type-mismatch', {
+      accessorIndex,
+      reason: 'unknownComponentType',
+    }),
+  );
+}

package/src/accessor/decode-color.ts

@@ -0,0 +1,128 @@
+import { err, gltfErr, ok, type Result } from '../errors.js';
+import type { AccessorJson, BufferViewJson } from './decode-accessor.js';
+
+export interface DecodeColorAccessorInput {
+  readonly accessorIndex: number;
+  readonly accessor: AccessorJson;
+  readonly bufferView: BufferViewJson;
+  readonly buffer: Uint8Array;
+  readonly bufferIndex?: number;
+  readonly semantic: 'COLOR_0';
+}
+
+const FLOAT = 5126;
+const UNSIGNED_BYTE = 5121;
+const UNSIGNED_SHORT = 5123;
+
+function unsupported(
+  input: DecodeColorAccessorInput,
+  reason: 'component' | 'type' | 'normalized' | 'sparse' | 'morph',
+) {
+  return err(
+    gltfErr('gltf-color-accessor-unsupported', {
+      semantic: input.semantic,
+      accessorIndex: input.accessorIndex,
+      reason,
+      expectedType: 'VEC3 or VEC4',
+      expectedComponent: 'FLOAT or normalized UNSIGNED_BYTE/UNSIGNED_SHORT',
+      ...(reason === 'normalized' ? { expectedNormalized: true } : {}),
+    }),
+  );
+}
+
+function malformed(
+  input: DecodeColorAccessorInput,
+  reason: 'count' | 'bounds' | 'finite' | 'range' | 'reference',
+) {
+  return err(
+    gltfErr('gltf-color-accessor-malformed', {
+      semantic: input.semantic,
+      accessorIndex: input.accessorIndex,
+      reason,
+      ...(reason === 'count'
+        ? { expectedCount: 'matches POSITION vertex count and is greater than zero' }
+        : {}),
+      ...(reason === 'range' || reason === 'finite'
+        ? { expectedRange: '[0,1] finite linear values' }
+        : {}),
+    }),
+  );
+}
+
+/** Decode one dense glTF COLOR_0 accessor into linear RGBA float values. */
+export function decodeColorAccessor(
+  input: DecodeColorAccessorInput,
+  flags: { readonly morph?: boolean } = {},
+): Result<Float32Array, import('../errors.js').GltfError> {
+  const { accessor, bufferView, buffer } = input;
+  if (flags.morph === true) return unsupported(input, 'morph');
+  if (accessor.sparse !== undefined) return unsupported(input, 'sparse');
+
+  if (accessor.type !== 'VEC3' && accessor.type !== 'VEC4') return unsupported(input, 'type');
+  if (!Number.isSafeInteger(accessor.count) || accessor.count <= 0)
+    return malformed(input, 'count');
+
+  let componentByteSize: 1 | 2 | 4;
+  if (accessor.componentType === FLOAT) componentByteSize = 4;
+  else if (accessor.componentType === UNSIGNED_BYTE) componentByteSize = 1;
+  else if (accessor.componentType === UNSIGNED_SHORT) componentByteSize = 2;
+  else return unsupported(input, 'component');
+
+  if (accessor.componentType === FLOAT) {
+    if (accessor.normalized !== undefined) return unsupported(input, 'normalized');
+  } else if (accessor.normalized !== true) {
+    return unsupported(input, 'normalized');
+  }
+
+  const componentCount = accessor.type === 'VEC3' ? 3 : 4;
+  const elementByteLength = componentByteSize * componentCount;
+  const byteStride = bufferView.byteStride ?? elementByteLength;
+  if (
+    !Number.isSafeInteger(byteStride) ||
+    byteStride < elementByteLength ||
+    byteStride % componentByteSize !== 0
+  ) {
+    return malformed(input, 'bounds');
+  }
+  if (input.bufferIndex !== undefined && bufferView.buffer !== input.bufferIndex) {
+    return malformed(input, 'reference');
+  }
+
+  const accessorByteOffset = accessor.byteOffset ?? 0;
+  const viewByteOffset = bufferView.byteOffset ?? 0;
+  const lastElementEnd = accessorByteOffset + byteStride * (accessor.count - 1) + elementByteLength;
+  if (
+    !Number.isSafeInteger(accessorByteOffset) ||
+    accessorByteOffset < 0 ||
+    lastElementEnd > bufferView.byteLength
+  ) {
+    return malformed(input, 'bounds');
+  }
+  const absoluteLastElementEnd = viewByteOffset + lastElementEnd;
+  if (
+    !Number.isSafeInteger(viewByteOffset) ||
+    viewByteOffset < 0 ||
+    absoluteLastElementEnd > buffer.byteLength
+  ) {
+    return malformed(input, 'bounds');
+  }
+
+  const output = new Float32Array(accessor.count * 4);
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  const base = viewByteOffset + accessorByteOffset;
+  for (let vertex = 0; vertex < accessor.count; vertex++) {
+    const sourceOffset = base + vertex * byteStride;
+    for (let component = 0; component < componentCount; component++) {
+      const byteOffset = sourceOffset + component * componentByteSize;
+      let value: number;
+      if (accessor.componentType === FLOAT) value = view.getFloat32(byteOffset, true);
+      else if (accessor.componentType === UNSIGNED_BYTE) value = view.getUint8(byteOffset) / 255;
+      else value = view.getUint16(byteOffset, true) / 65535;
+      if (!Number.isFinite(value)) return malformed(input, 'finite');
+      if (value < 0 || value > 1) return malformed(input, 'range');
+      output[vertex * 4 + component] = value;
+    }
+    if (componentCount === 3) output[vertex * 4 + 3] = 1;
+  }
+  return ok(output);
+}

package/src/accessor/index.ts

@@ -0,0 +1,15 @@
+export {
+  type AccessorJson,
+  type AccessorRole,
+  type BufferViewJson,
+  COMPONENT_TYPE,
+  type ComponentTypeId,
+  type DecodeAccessorInput,
+  type DecodedAccessor,
+  decodeAccessor,
+  decodeF32Accessor,
+} from './decode-accessor.js';
+export {
+  type DecodeColorAccessorInput,
+  decodeColorAccessor,
+} from './decode-color.js';