@aura3d/assets 1.4.0 → 1.4.1

package/src/HDRLoader.ts

@@ -1 +0,0 @@
-export { HDRLoaderThreeCompat as HDRLoader } from "./loaders/HDRLoader";

package/src/ImageLoader.ts

@@ -1,52 +0,0 @@
-import type { AssetLoadRequest, AssetLoader } from "./AssetLoader";
-import type { LoadContext } from "./LoadContext";
-
-export interface ImageAsset {
-  readonly url: string;
-  readonly width: number;
-  readonly height: number;
-  readonly source: ImageBitmap | HTMLImageElement;
-}
-
-export class ImageLoader implements AssetLoader<ImageAsset> {
-  readonly type = "image";
-
-  canLoad(request: AssetLoadRequest): boolean {
-    return /\.(?:png|jpg|jpeg|webp|gif|avif)(?:\?.*)?$/i.test(request.url) || request.url.startsWith("data:image/");
-  }
-
-  async load(request: AssetLoadRequest, context: LoadContext): Promise<ImageAsset> {
-    context.throwIfAborted(request.url);
-
-    if (typeof createImageBitmap === "function" && typeof fetch === "function") {
-      const response = await fetch(request.url, { signal: request.signal });
-      if (!response.ok) {
-        throw new Error(`Image request failed with ${response.status}`);
-      }
-
-      const bitmap = await createImageBitmap(await response.blob());
-      return { url: request.url, width: bitmap.width, height: bitmap.height, source: bitmap };
-    }
-
-    const ImageCtor = globalThis.Image;
-    if (!ImageCtor) {
-      throw new Error("Image loading requires createImageBitmap or HTMLImageElement");
-    }
-
-    return new Promise<ImageAsset>((resolve, reject) => {
-      const image = new ImageCtor();
-      image.onload = () => resolve({ url: request.url, width: image.width, height: image.height, source: image });
-      image.onerror = () => reject(new Error(`Image decode failed for ${request.url}`));
-      request.signal?.addEventListener("abort", () => reject(new Error(`Image load aborted for ${request.url}`)), {
-        once: true
-      });
-      image.src = request.url;
-    });
-  }
-
-  dispose(asset: ImageAsset): void {
-    if ("close" in asset.source && typeof asset.source.close === "function") {
-      asset.source.close();
-    }
-  }
-}

package/src/ImportPipeline.ts

@@ -1,148 +0,0 @@
-export interface ImportPipelineContext {
-  readonly url: string;
-  readonly signal?: AbortSignal;
-  readonly onProgress?: (event: ImportPipelineProgressEvent) => void;
-}
-
-export interface ImportStage<TInput = unknown, TOutput = TInput> {
-  readonly name: string;
-  canRun?(input: TInput, context: ImportPipelineContext): Promise<boolean> | boolean;
-  run(input: TInput, context: ImportPipelineContext): Promise<TOutput> | TOutput;
-  rollback?(output: TOutput, context: ImportPipelineContext): Promise<void> | void;
-}
-
-export type ImportPipelineProgressStatus = "started" | "skipped" | "completed" | "rollback-started" | "rollback-completed";
-
-export interface ImportPipelineProgressEvent {
-  readonly url: string;
-  readonly stageName: string;
-  readonly status: ImportPipelineProgressStatus;
-}
-
-export interface ImportPipelineErrorOptions {
-  readonly url: string;
-  readonly stageName?: string;
-  readonly cause?: unknown;
-}
-
-export class ImportPipelineError extends Error {
-  readonly url: string;
-  readonly stageName?: string;
-  override readonly cause?: unknown;
-
-  constructor(message: string, options: ImportPipelineErrorOptions) {
-    super(message);
-    this.name = "ImportPipelineError";
-    this.url = options.url;
-    this.stageName = options.stageName;
-    this.cause = options.cause;
-  }
-}
-
-export class ImportPipeline {
-  private readonly stages: ImportStage[] = [];
-
-  addStage<TInput, TOutput>(stage: ImportStage<TInput, TOutput>): this {
-    if (this.stages.some((existing) => existing.name === stage.name)) {
-      throw new Error(`Import stage already exists: ${stage.name}`);
-    }
-    this.stages.push(stage as ImportStage);
-    return this;
-  }
-
-  async run<TInput, TOutput = unknown>(input: TInput, context: ImportPipelineContext): Promise<TOutput> {
-    const completed: Array<{ stage: ImportStage; output: unknown }> = [];
-    let current: unknown = input;
-
-    try {
-      for (const stage of this.stages) {
-        this.throwIfAborted(context, stage.name);
-
-        if (stage.canRun && !(await this.withAbort(stage.canRun(current, context), context, stage.name))) {
-          this.report(context, stage.name, "skipped");
-          continue;
-        }
-
-        this.report(context, stage.name, "started");
-        current = await this.withAbort(stage.run(current, context), context, stage.name);
-        completed.push({ stage, output: current });
-        this.throwIfAborted(context, stage.name);
-        this.report(context, stage.name, "completed");
-      }
-      return current as TOutput;
-    } catch (error) {
-      for (const entry of completed.reverse()) {
-        if (!entry.stage.rollback) {
-          continue;
-        }
-        this.report(context, entry.stage.name, "rollback-started");
-        try {
-          await this.withAbort(entry.stage.rollback(entry.output, context), context, entry.stage.name);
-          this.report(context, entry.stage.name, "rollback-completed");
-        } catch (rollbackError) {
-          throw new ImportPipelineError(`Import pipeline rollback failed at stage ${entry.stage.name} for ${context.url}`, {
-            url: context.url,
-            stageName: entry.stage.name,
-            cause: rollbackError
-          });
-        }
-      }
-      throw this.toPipelineError(error, context);
-    }
-  }
-
-  private async withAbort<T>(operation: Promise<T> | T, context: ImportPipelineContext, stageName: string): Promise<T> {
-    if (!context.signal) {
-      return operation;
-    }
-    this.throwIfAborted(context, stageName);
-
-    return new Promise<T>((resolve, reject) => {
-      const abort = () => reject(this.createAbortError(context, stageName));
-      context.signal?.addEventListener("abort", abort, { once: true });
-      Promise.resolve(operation).then(
-        (value) => {
-          context.signal?.removeEventListener("abort", abort);
-          resolve(value);
-        },
-        (error) => {
-          context.signal?.removeEventListener("abort", abort);
-          reject(error);
-        }
-      );
-    });
-  }
-
-  private throwIfAborted(context: ImportPipelineContext, stageName?: string): void {
-    if (context.signal?.aborted) {
-      throw this.createAbortError(context, stageName);
-    }
-  }
-
-  private createAbortError(context: ImportPipelineContext, stageName?: string): ImportPipelineError {
-    return new ImportPipelineError(
-      stageName ? `Import pipeline aborted at stage ${stageName} for ${context.url}` : `Import pipeline aborted for ${context.url}`,
-      { url: context.url, stageName, cause: context.signal?.reason }
-    );
-  }
-
-  private toPipelineError(error: unknown, context: ImportPipelineContext): Error {
-    if (error instanceof ImportPipelineError) {
-      return error;
-    }
-    if (error instanceof Error) {
-      return new ImportPipelineError(`Import pipeline failed for ${context.url}: ${error.message}`, {
-        url: context.url,
-        cause: error
-      });
-    }
-    return new ImportPipelineError(`Import pipeline failed for ${context.url}: ${String(error)}`, {
-      url: context.url,
-      cause: error
-    });
-  }
-
-  private report(context: ImportPipelineContext, stageName: string, status: ImportPipelineProgressStatus): void {
-    context.onProgress?.({ url: context.url, stageName, status });
-  }
-}

package/src/KTX2BasisTextureTranscoder.ts

@@ -1,225 +0,0 @@
-import type { TextureCompressedFormat, TextureMipLevelDescriptor } from "@aura3d/rendering";
-import type { DecodedGLTFImage } from "./GLTFRenderResources";
-
-export type KTX2BasisTargetFormat = "etc2-rgba8unorm" | "bc3-rgba-unorm" | "astc-4x4-rgba-unorm" | "rgba8";
-
-export interface KTX2BasisTextureTranscoderOptions {
-  readonly targetFormat?: KTX2BasisTargetFormat;
-  readonly includeFallback?: boolean;
-  readonly loaderOptions?: Record<string, unknown>;
-}
-
-interface LoadersGLTextureLevel {
-  readonly width: number;
-  readonly height: number;
-  readonly data: Uint8Array;
-  readonly compressed?: boolean;
-  readonly textureFormat?: string;
-}
-
-type LoadersGLTextureResult = readonly (readonly LoadersGLTextureLevel[])[];
-
-const DEFAULT_BROWSER_CDN = "https://unpkg.com/@loaders.gl";
-let nodeFileHooksReady = false;
-
-export async function transcodeKTX2BasisTexture(
-  bytes: ArrayBuffer | ArrayBufferView,
-  options: KTX2BasisTextureTranscoderOptions = {}
-): Promise<DecodedGLTFImage> {
-  const source = toArrayBuffer(bytes);
-  const targetFormat = options.targetFormat ?? "etc2-rgba8unorm";
-  const compressedLevels = await parseTextureLevels(source, targetFormat, options.loaderOptions);
-  const baseLevel = compressedLevels[0];
-  if (!baseLevel) {
-    throw new Error("KTX2/Basis transcode produced no texture levels");
-  }
-
-  if (targetFormat === "rgba8") {
-    return {
-      width: baseLevel.width,
-      height: baseLevel.height,
-      colorSpace: "linear",
-      format: "rgba8",
-      data: baseLevel.data
-    };
-  }
-
-  const fallbackLevels = options.includeFallback === false
-    ? []
-    : validRGBA8Levels(await parseTextureLevels(source, "rgba8", options.loaderOptions));
-  const format = mapTargetFormat(targetFormat);
-
-  return {
-    width: baseLevel.width,
-    height: baseLevel.height,
-    colorSpace: "linear",
-    format,
-    mipLevels: compressedLevels,
-    fallbackMipLevels: fallbackLevels
-  };
-}
-
-function validRGBA8Levels(levels: readonly TextureMipLevelDescriptor[]): readonly TextureMipLevelDescriptor[] {
-  const validLevels: TextureMipLevelDescriptor[] = [];
-  for (const level of levels) {
-    if (level.data.byteLength !== level.width * level.height * 4) break;
-    validLevels.push(level);
-  }
-  return validLevels;
-}
-
-async function parseTextureLevels(
-  source: ArrayBuffer,
-  targetFormat: KTX2BasisTargetFormat,
-  loaderOptions: Record<string, unknown> | undefined
-): Promise<readonly TextureMipLevelDescriptor[]> {
-  await installNodeLoadersGLFileHooks();
-  const { parse, BasisLoader } = await loadLoadersGLModules();
-  const parsed = await parse(source.slice(0), BasisLoader, {
-    // worker:false is required: worker mode resolves transcoder module URLs to dev-only /node_modules paths and the Node file hooks on globalThis.loaders only exist on the main thread.
-    worker: false,
-    CDN: defaultLoadersGLCdn(),
-    modules: defaultLoadersGLModules(),
-    ...loaderOptions,
-    ...(loaderOptions?.modules && typeof loaderOptions.modules === "object"
-      ? { modules: { ...defaultLoadersGLModules(), ...(loaderOptions.modules as Record<string, unknown>) } }
-      : {}),
-    basis: {
-      ...basisOptions(loaderOptions),
-      containerFormat: "ktx2",
-      module: "encoder",
-      format: loadersGLBasisFormat(targetFormat)
-    }
-  }) as LoadersGLTextureResult;
-  const levels = parsed[0];
-  if (!levels || levels.length === 0) {
-    throw new Error("KTX2/Basis transcode returned no texture levels");
-  }
-  return levels.map((level) => ({
-    width: level.width,
-    height: level.height,
-    data: new Uint8Array(level.data)
-  }));
-}
-
-function defaultLoadersGLCdn(): string {
-  if (typeof window !== "undefined" && window.location?.origin) {
-    return `${window.location.origin}/node_modules/@loaders.gl`;
-  }
-  return DEFAULT_BROWSER_CDN;
-}
-
-function defaultLoadersGLModules(): Record<string, string> | undefined {
-  if (typeof window === "undefined" || !window.location?.origin) return undefined;
-  const baseUrl = `${window.location.origin}/node_modules/@loaders.gl/textures/dist/libs`;
-  return {
-    "basis_encoder.js": `${baseUrl}/basis_encoder.js`,
-    "basis_encoder.wasm": `${baseUrl}/basis_encoder.wasm`,
-    "basis_transcoder.js": `${baseUrl}/basis_transcoder.js`,
-    "basis_transcoder.wasm": `${baseUrl}/basis_transcoder.wasm`
-  };
-}
-
-async function loadLoadersGLModules(): Promise<{ readonly parse: typeof import("@loaders.gl/core").parse; readonly BasisLoader: typeof import("@loaders.gl/textures").BasisLoader }> {
-  try {
-    const [core, textures] = await Promise.all([
-      import("@loaders.gl/core"),
-      import("@loaders.gl/textures")
-    ]);
-    return { parse: core.parse, BasisLoader: textures.BasisLoader };
-  } catch (error) {
-    throw new Error(`KTX2/Basis transcoder dependency resolution failed: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-function basisOptions(loaderOptions: Record<string, unknown> | undefined): Record<string, unknown> {
-  const basis = loaderOptions?.basis;
-  return basis && typeof basis === "object" ? basis as Record<string, unknown> : {};
-}
-
-function loadersGLBasisFormat(format: KTX2BasisTargetFormat): string {
-  switch (format) {
-    case "etc2-rgba8unorm":
-      return "etc2";
-    case "bc3-rgba-unorm":
-      return "bc3";
-    case "astc-4x4-rgba-unorm":
-      return "astc-4x4";
-    case "rgba8":
-      return "rgba32";
-  }
-}
-
-function mapTargetFormat(format: KTX2BasisTargetFormat): TextureCompressedFormat {
-  switch (format) {
-    case "etc2-rgba8unorm":
-    case "bc3-rgba-unorm":
-    case "astc-4x4-rgba-unorm":
-      return format;
-    case "rgba8":
-      throw new Error("rgba8 is not a compressed texture target");
-  }
-}
-
-function toArrayBuffer(bytes: ArrayBuffer | ArrayBufferView): ArrayBuffer {
-  if (bytes instanceof ArrayBuffer) return bytes.slice(0);
-  const copy = new Uint8Array(bytes.byteLength);
-  copy.set(new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength));
-  return copy.buffer;
-}
-
-async function installNodeLoadersGLFileHooks(): Promise<void> {
-  if (nodeFileHooksReady || typeof process === "undefined" || !process.versions?.node) return;
-  const existing = (globalThis as typeof globalThis & {
-    loaders?: {
-      requireFromFile?: (path: string) => unknown;
-      readFileAsArrayBuffer?: (path: string) => Promise<ArrayBuffer>;
-    };
-  }).loaders ?? {};
-  if (existing.requireFromFile && existing.readFileAsArrayBuffer) {
-    nodeFileHooksReady = true;
-    return;
-  }
-
-  const [{ readFile }, { dirname, join }, { createRequire }, vm] = await Promise.all([
-    importNodeModule<typeof import("node:fs/promises")>("node:fs/promises"),
-    importNodeModule<typeof import("node:path")>("node:path"),
-    importNodeModule<typeof import("node:module")>("node:module"),
-    importNodeModule<typeof import("node:vm")>("node:vm")
-  ]);
-  const require = createRequire(import.meta.url);
-  const texturesRoot = dirname(dirname(require.resolve("@loaders.gl/textures")));
-  const moduleCache = new Map<string, unknown>();
-  const resolveLibraryPath = (libraryPath: string): string => {
-    if (libraryPath.startsWith("modules/textures/")) {
-      return join(texturesRoot, libraryPath.slice("modules/textures/".length));
-    }
-    return libraryPath;
-  };
-
-  (globalThis as typeof globalThis & { loaders?: typeof existing }).loaders = {
-    ...existing,
-    async requireFromFile(libraryPath: string): Promise<unknown> {
-      const resolved = resolveLibraryPath(libraryPath);
-      if (moduleCache.has(resolved)) return moduleCache.get(resolved);
-      const code = await readFile(resolved, "utf8");
-      const module = { exports: {} as unknown };
-      const wrapper = vm.runInNewContext(
-        `(function(exports,module,require,__dirname,__filename){${code}\n})`,
-        { Buffer, WebAssembly, clearTimeout, console, process, setTimeout, TextDecoder, TextEncoder }
-      ) as (exports: unknown, module: { exports: unknown }, require: NodeJS.Require, dirname: string, filename: string) => void;
-      wrapper(module.exports, module, require, dirname(resolved), resolved);
-      moduleCache.set(resolved, module.exports);
-      return module.exports;
-    },
-    async readFileAsArrayBuffer(libraryPath: string): Promise<ArrayBuffer> {
-      const buffer = await readFile(resolveLibraryPath(libraryPath));
-      return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-    }
-  };
-  nodeFileHooksReady = true;
-}
-
-async function importNodeModule<T>(specifier: string): Promise<T> {
-  return import(/* @vite-ignore */ specifier) as Promise<T>;
-}

package/src/LoadContext.ts

@@ -1,60 +0,0 @@
-import { AssetLoadError } from "./AssetLoader";
-import type { AssetHandle } from "./AssetHandle";
-import type { AssetManager } from "./AssetManager";
-
-export interface LoadContextOptions {
-  readonly baseUrl?: string;
-  readonly signal?: AbortSignal;
-  readonly dependencyChain?: readonly string[];
-  readonly manager?: AssetManager;
-}
-
-export class LoadContext {
-  readonly baseUrl: string;
-  readonly signal?: AbortSignal;
-  readonly dependencyChain: readonly string[];
-
-  private readonly manager?: AssetManager;
-
-  constructor(options: LoadContextOptions = {}) {
-    this.baseUrl = options.baseUrl ?? "";
-    this.signal = options.signal;
-    this.dependencyChain = options.dependencyChain ?? [];
-    this.manager = options.manager;
-  }
-
-  resolve(url: string): string {
-    if (/^(?:[a-z]+:)?\/\//i.test(url) || url.startsWith("data:") || url.startsWith("blob:")) {
-      return url;
-    }
-
-    if (this.baseUrl.length === 0) {
-      return url;
-    }
-
-    return new URL(url, this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`).toString();
-  }
-
-  throwIfAborted(url: string): void {
-    if (this.signal?.aborted) {
-      throw new AssetLoadError("Asset load aborted", url, this.dependencyChain, this.signal.reason);
-    }
-  }
-
-  child(url: string): LoadContext {
-    return new LoadContext({
-      baseUrl: this.baseUrl,
-      signal: this.signal,
-      manager: this.manager,
-      dependencyChain: [...this.dependencyChain, url]
-    });
-  }
-
-  async loadDependency<T = unknown>(url: string, type?: string): Promise<AssetHandle<T>> {
-    if (!this.manager) {
-      throw new AssetLoadError("Cannot load dependency without an AssetManager", url, this.dependencyChain);
-    }
-
-    return this.manager.load<T>(url, { type, signal: this.signal, dependencyChain: this.dependencyChain });
-  }
-}

package/src/MaterialLoader.ts

@@ -1,166 +0,0 @@
-import type { AssetLoadRequest, AssetLoader } from "./AssetLoader";
-import type { LoadContext } from "./LoadContext";
-import {
-  Material,
-  PBRMaterial,
-  UnlitMaterial,
-  type PBRMaterialOptions,
-  type RenderState,
-  type UnlitMaterialOptions
-} from "@aura3d/rendering";
-
-export interface MaterialDescriptorAsset {
-  readonly url: string;
-  readonly name?: string;
-  readonly model: "unlit" | "pbr";
-  readonly properties: Readonly<Record<string, unknown>>;
-  createMaterial(): Material;
-}
-
-export class MaterialLoader implements AssetLoader<MaterialDescriptorAsset> {
-  readonly type = "material";
-
-  canLoad(request: AssetLoadRequest): boolean {
-    return /\.(?:mat|material)\.json(?:\?.*)?$/i.test(request.url);
-  }
-
-  async load(request: AssetLoadRequest, context: LoadContext): Promise<MaterialDescriptorAsset> {
-    context.throwIfAborted(request.url);
-
-    if (typeof fetch !== "function") {
-      throw new Error("MaterialLoader requires fetch");
-    }
-
-    const response = await fetch(request.url, { signal: request.signal });
-    if (!response.ok) {
-      throw new Error(`Material request failed with ${response.status}`);
-    }
-
-    const parsed = (await response.json()) as Partial<MaterialDescriptorAsset>;
-    if (parsed.model !== "unlit" && parsed.model !== "pbr") {
-      throw new Error(`Unsupported material model for ${request.url}`);
-    }
-
-    const descriptor = {
-      url: request.url,
-      name: parsed.name,
-      model: parsed.model,
-      properties: parseProperties(parsed.properties, request.url)
-    };
-    return {
-      ...descriptor,
-      createMaterial: () => createMaterialFromDescriptor(descriptor)
-    };
-  }
-}
-
-export function createMaterialFromDescriptor(descriptor: Pick<MaterialDescriptorAsset, "name" | "model" | "properties">): Material {
-  if (descriptor.model === "unlit") {
-    return new UnlitMaterial(toUnlitOptions(descriptor));
-  }
-  return new PBRMaterial(toPBRMaterialOptions(descriptor));
-}
-
-function toUnlitOptions(descriptor: Pick<MaterialDescriptorAsset, "name" | "properties">): UnlitMaterialOptions {
-  const color = readVec4(descriptor.properties, ["color", "baseColor", "baseColorFactor"]);
-  return {
-    name: descriptor.name,
-    color: color ?? undefined,
-    renderState: readRenderState(descriptor.properties)
-  };
-}
-
-function toPBRMaterialOptions(descriptor: Pick<MaterialDescriptorAsset, "name" | "properties">): PBRMaterialOptions {
-  const properties = descriptor.properties;
-  return {
-    name: descriptor.name,
-    baseColor: readVec4(properties, ["baseColor", "baseColorFactor"]) ?? undefined,
-    metallic: readNumber(properties, ["metallic", "metallicFactor"]),
-    roughness: readNumber(properties, ["roughness", "roughnessFactor"]),
-    emissiveColor: readVec3(properties, ["emissiveColor", "emissiveFactor"]) ?? undefined,
-    emissiveStrength: readNumber(properties, ["emissiveStrength"]),
-    clearcoatFactor: readNumber(properties, ["clearcoatFactor"]),
-    clearcoatRoughnessFactor: readNumber(properties, ["clearcoatRoughnessFactor"]),
-    transmissionFactor: readNumber(properties, ["transmissionFactor"]),
-    diffuseTransmissionFactor: readNumber(properties, ["diffuseTransmissionFactor"]),
-    diffuseTransmissionColorFactor: readVec3(properties, ["diffuseTransmissionColorFactor"]) ?? undefined,
-    volumeThicknessFactor: readNumber(properties, ["volumeThicknessFactor"]),
-    volumeAttenuationDistance: readNumber(properties, ["volumeAttenuationDistance"]),
-    volumeAttenuationColor: readVec3(properties, ["volumeAttenuationColor"]) ?? undefined,
-    ior: readNumber(properties, ["ior"]),
-    specularFactor: readNumber(properties, ["specularFactor"]),
-    specularColorFactor: readVec3(properties, ["specularColorFactor"]) ?? undefined,
-    sheenColorFactor: readVec3(properties, ["sheenColorFactor"]) ?? undefined,
-    sheenRoughnessFactor: readNumber(properties, ["sheenRoughnessFactor"]),
-    anisotropyStrength: readNumber(properties, ["anisotropyStrength"]),
-    anisotropyRotation: readNumber(properties, ["anisotropyRotation"]),
-    iridescenceFactor: readNumber(properties, ["iridescenceFactor"]),
-    iridescenceIor: readNumber(properties, ["iridescenceIor"]),
-    iridescenceThicknessMinimum: readNumber(properties, ["iridescenceThicknessMinimum"]),
-    iridescenceThicknessMaximum: readNumber(properties, ["iridescenceThicknessMaximum"]),
-    dispersion: readNumber(properties, ["dispersion"]),
-    renderState: readRenderState(properties)
-  };
-}
-
-function parseProperties(value: unknown, url: string): Readonly<Record<string, unknown>> {
-  if (value === undefined) return {};
-  if (!isRecord(value) || Array.isArray(value)) {
-    throw new Error(`Material properties for ${url} must be an object`);
-  }
-  return value;
-}
-
-function readNumber(properties: Readonly<Record<string, unknown>>, keys: readonly string[]): number | undefined {
-  const value = readFirst(properties, keys);
-  if (value === undefined) return undefined;
-  if (typeof value !== "number") {
-    throw new Error(`Material property ${keys[0]} must be a number`);
-  }
-  return value;
-}
-
-function readVec3(properties: Readonly<Record<string, unknown>>, keys: readonly string[]): readonly [number, number, number] | undefined {
-  const value = readFirst(properties, keys);
-  if (value === undefined) return undefined;
-  if (!Array.isArray(value) || value.length !== 3) {
-    throw new Error(`Material property ${keys[0]} must be a vec3`);
-  }
-  return [readFinite(value[0], keys[0]), readFinite(value[1], keys[0]), readFinite(value[2], keys[0])];
-}
-
-function readVec4(properties: Readonly<Record<string, unknown>>, keys: readonly string[]): readonly [number, number, number, number] | undefined {
-  const value = readFirst(properties, keys);
-  if (value === undefined) return undefined;
-  if (!Array.isArray(value) || value.length !== 4) {
-    throw new Error(`Material property ${keys[0]} must be a vec4`);
-  }
-  return [readFinite(value[0], keys[0]), readFinite(value[1], keys[0]), readFinite(value[2], keys[0]), readFinite(value[3], keys[0])];
-}
-
-function readRenderState(properties: Readonly<Record<string, unknown>>): Partial<RenderState> | undefined {
-  const value = properties.renderState;
-  if (value === undefined) return undefined;
-  if (!isRecord(value) || Array.isArray(value)) {
-    throw new Error("Material property renderState must be an object");
-  }
-  return value as Partial<RenderState>;
-}
-
-function readFirst(properties: Readonly<Record<string, unknown>>, keys: readonly string[]): unknown {
-  for (const key of keys) {
-    if (Object.hasOwn(properties, key)) return properties[key];
-  }
-  return undefined;
-}
-
-function readFinite(value: unknown, label: string): number {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new Error(`Material property ${label} must contain finite numbers`);
-  }
-  return value;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}