@aura3d/workflows 1.0.6

package/src/ProductConfiguratorWorkflow.ts

@@ -0,0 +1,32 @@
+import {
+  createProductCameraFrame,
+  createProductLightingPreset,
+  createProductMaterialMode,
+  createProductRenderScene,
+  loadProductAsset
+} from "@aura3d/product-studio";
+import { createWorkflowDiagnostics } from "./WorkflowDiagnostics";
+import type { ProductConfiguratorWorkflowOptions, ProductConfiguratorWorkflowResult } from "./WorkflowTypes";
+
+export async function createProductConfiguratorWorkflow(options: ProductConfiguratorWorkflowOptions): Promise<ProductConfiguratorWorkflowResult> {
+  const asset = await loadProductAsset(options.asset);
+  const lighting = createProductLightingPreset(options.lighting ?? "catalog-softbox");
+  const camera = createProductCameraFrame(asset, {
+    preset: options.camera ?? "front-three-quarter",
+    viewport: options.viewport ?? { width: 1280, height: 900 }
+  });
+  const materialMode = createProductMaterialMode(options.materialMode ?? "asset");
+  const scene = createProductRenderScene(asset, { lighting, camera, materialMode });
+  return {
+    kind: "product-configurator",
+    asset,
+    scene,
+    source: scene.source,
+    camera: scene.camera,
+    diagnostics: createWorkflowDiagnostics("product-configurator", {
+      asset,
+      featureChecklist: ["product-asset", "material-modes", "lighting-presets", "camera-presets", "export-ready"]
+    }),
+    dispose: () => asset.resources.dispose()
+  };
+}

package/src/SceneShowcaseWorkflow.ts

@@ -0,0 +1,45 @@
+import { composeMat4 } from "@aura3d/scene";
+import { Geometry, PBRMaterial, createLightingDefault } from "@aura3d/rendering";
+import { createWorkflowDiagnostics } from "./WorkflowDiagnostics";
+import type { SceneShowcaseWorkflowOptions, SceneShowcaseWorkflowResult } from "./WorkflowTypes";
+
+export function createSceneShowcaseWorkflow(options: SceneShowcaseWorkflowOptions = {}): SceneShowcaseWorkflowResult {
+  const lighting = createLightingDefault(options.preset === "dramatic" ? "gameNight" : options.preset === "gallery" ? "interiorGallery" : "studioProduct");
+  const renderItems = [
+    {
+      label: "showcase-center",
+      geometry: Geometry.uvSphere(0.72, 48, 24, { textured: true }),
+      material: new PBRMaterial({ name: "showcase-center-material", baseColor: [0.9, 0.3, 0.16, 1], metallic: 0.35, roughness: 0.32 }),
+      modelMatrix: composeMat4([0, 0.25, 0], [0, 0, 0, 1], [1, 1, 1])
+    },
+    {
+      label: "showcase-left",
+      geometry: Geometry.texturedCube(1),
+      material: new PBRMaterial({ name: "showcase-left-material", baseColor: [0.18, 0.45, 0.9, 1], metallic: 0.1, roughness: 0.48 }),
+      modelMatrix: composeMat4([-1.25, -0.15, -0.2], [0, 0.18, 0, 0.98], [0.72, 0.72, 0.72])
+    },
+    {
+      label: "showcase-right",
+      geometry: Geometry.cylinder({ radius: 0.42, height: 1.1, textured: true }),
+      material: new PBRMaterial({ name: "showcase-right-material", baseColor: [0.2, 0.72, 0.42, 1], metallic: 0.05, roughness: 0.55 }),
+      modelMatrix: composeMat4([1.25, -0.1, -0.15], [0, 0, 0, 1], [1, 1, 1])
+    }
+  ];
+  const source = {
+    renderItems,
+    cameraPolicy: "auto-frame" as const,
+    cameraFrameOptions: { paddingRatio: 0.2, yawRadians: -0.42, pitchRadians: -0.16 },
+    environmentLighting: lighting.environmentLighting,
+    shadow: false,
+    postprocess: { ...lighting.postprocess, targetFormat: "rgba8" as const }
+  };
+  return {
+    kind: "scene-showcase",
+    source,
+    renderItems,
+    diagnostics: createWorkflowDiagnostics("scene-showcase", {
+      featureChecklist: ["multi-object-scene", "pbr", "lighting-preset", "camera-framing", "postprocess"]
+    }),
+    dispose: () => undefined
+  };
+}

package/src/WorkflowDiagnostics.ts

@@ -0,0 +1,47 @@
+import type { RenderDeviceDiagnostics } from "@aura3d/rendering";
+import type { RenderableAsset } from "@aura3d/assets";
+import type { ProductAsset } from "@aura3d/product-studio";
+import type { A3DWorkflowDiagnostics, A3DWorkflowKind } from "./WorkflowTypes";
+
+export function createWorkflowDiagnostics(
+  workflow: A3DWorkflowKind,
+  options: {
+    readonly warnings?: readonly string[];
+    readonly featureChecklist?: readonly string[];
+    readonly asset?: RenderableAsset | ProductAsset;
+    readonly renderDiagnostics?: RenderDeviceDiagnostics;
+  } = {}
+): A3DWorkflowDiagnostics {
+  return {
+    workflow,
+    warnings: options.warnings ?? [],
+    featureChecklist: options.featureChecklist ?? [],
+    ...(options.asset ? { asset: summarizeAsset(options.asset) } : {}),
+    ...(options.renderDiagnostics ? { renderDiagnostics: options.renderDiagnostics } : {})
+  };
+}
+
+function summarizeAsset(asset: RenderableAsset | ProductAsset): A3DWorkflowDiagnostics["asset"] {
+  if ("gltf" in asset && asset.gltf) {
+    return {
+      kind: "gltf",
+      meshCount: asset.gltf.loaderDiagnostics.meshCount,
+      materialCount: asset.gltf.loaderDiagnostics.materialCount,
+      textureCount: asset.gltf.loaderDiagnostics.textureCount
+    };
+  }
+  if ("resources" in asset) {
+    return {
+      kind: asset.category,
+      meshCount: asset.gltf.loaderDiagnostics.meshCount,
+      materialCount: asset.gltf.loaderDiagnostics.materialCount,
+      textureCount: asset.gltf.loaderDiagnostics.textureCount
+    };
+  }
+  return {
+    kind: asset.kind,
+    meshCount: 0,
+    materialCount: 0,
+    textureCount: 0
+  };
+}

package/src/WorkflowTypes.ts

@@ -0,0 +1,113 @@
+import type { AnimationClip, AnimationMixerSnapshot } from "@aura3d/animation";
+import type { RenderDeviceDiagnostics, RenderItem, RenderSource, CameraLike } from "@aura3d/rendering";
+import type { RenderableAsset, RenderableScene, CreateRenderableSceneOptions, LoadRenderableAssetOptions } from "@aura3d/assets";
+import type { ProductAsset, ProductAssetLoadOptions, ProductRenderScene } from "@aura3d/product-studio";
+
+export type A3DWorkflowKind =
+  | "asset-viewer"
+  | "product-configurator"
+  | "material-studio"
+  | "scene-showcase"
+  | "interactive-scene"
+  | "animation-lab"
+  | "comparison";
+
+export interface A3DWorkflowDiagnostics {
+  readonly workflow: A3DWorkflowKind;
+  readonly warnings: readonly string[];
+  readonly featureChecklist: readonly string[];
+  readonly asset?: {
+    readonly kind: string;
+    readonly meshCount: number;
+    readonly materialCount: number;
+    readonly textureCount: number;
+  };
+  readonly renderDiagnostics?: RenderDeviceDiagnostics;
+}
+
+export interface A3DWorkflowResult {
+  readonly kind: A3DWorkflowKind;
+  readonly source: RenderSource;
+  readonly camera?: CameraLike;
+  readonly renderItems?: readonly RenderItem[];
+  readonly diagnostics: A3DWorkflowDiagnostics;
+  dispose(): void;
+}
+
+export interface AssetViewerWorkflowOptions extends CreateRenderableSceneOptions, LoadRenderableAssetOptions {
+  readonly url: string;
+}
+
+export interface AssetViewerWorkflowResult extends A3DWorkflowResult {
+  readonly kind: "asset-viewer";
+  readonly asset: RenderableAsset;
+  readonly scene: RenderableScene;
+}
+
+export interface ProductConfiguratorWorkflowOptions {
+  readonly asset: ProductAssetLoadOptions;
+  readonly materialMode?: "asset" | "clay" | "matte" | "metal-check" | "contrast";
+  readonly lighting?: "catalog-softbox" | "inspection-bay" | "hero-contrast";
+  readonly camera?: "front-three-quarter" | "side-profile" | "top-detail" | "macro-detail";
+  readonly viewport?: {
+    readonly width: number;
+    readonly height: number;
+  };
+}
+
+export interface ProductConfiguratorWorkflowResult extends A3DWorkflowResult {
+  readonly kind: "product-configurator";
+  readonly asset: ProductAsset;
+  readonly scene: ProductRenderScene;
+}
+
+export interface MaterialStudioWorkflowOptions {
+  readonly mode?: "comparison" | "metals" | "transparent";
+}
+
+export interface MaterialStudioWorkflowResult extends A3DWorkflowResult {
+  readonly kind: "material-studio";
+}
+
+export interface SceneShowcaseWorkflowOptions {
+  readonly preset?: "studio" | "gallery" | "dramatic";
+}
+
+export interface SceneShowcaseWorkflowResult extends A3DWorkflowResult {
+  readonly kind: "scene-showcase";
+}
+
+export interface InteractiveSceneWorkflowOptions {
+  readonly preset?: "orbiting-products" | "input-ready";
+}
+
+export interface InteractiveSceneWorkflowResult extends A3DWorkflowResult {
+  readonly kind: "interactive-scene";
+  update(timeSeconds: number): RenderSource;
+}
+
+export interface AnimationLabWorkflowOptions {
+  readonly clip?: "idle" | "walk" | "run";
+  readonly speed?: number;
+}
+
+export interface AnimationLabWorkflowResult extends A3DWorkflowResult {
+  readonly kind: "animation-lab";
+  readonly clips: readonly AnimationClip[];
+  readonly mixer: AnimationMixerSnapshot;
+  update(timeSeconds: number): RenderSource;
+}
+
+export interface ComparisonWorkflowOptions {
+  readonly focus?: "setup" | "rendering" | "migration";
+}
+
+export interface ComparisonWorkflowResult extends A3DWorkflowResult {
+  readonly kind: "comparison";
+  readonly comparison: {
+    readonly focus: "setup" | "rendering" | "migration";
+    readonly a3dSteps: readonly string[];
+    readonly threeJsSteps: readonly string[];
+    readonly migrationNotes: readonly string[];
+  };
+}

package/src/index.ts

@@ -0,0 +1,34 @@
+export { createAssetViewerWorkflow } from "./AssetViewerWorkflow";
+export { createProductConfiguratorWorkflow } from "./ProductConfiguratorWorkflow";
+export { createMaterialStudioWorkflow } from "./MaterialStudioWorkflow";
+export { createSceneShowcaseWorkflow } from "./SceneShowcaseWorkflow";
+export { createInteractiveSceneWorkflow } from "./InteractiveSceneWorkflow";
+export { createAnimationLabWorkflow } from "./AnimationLabWorkflow";
+export { createComparisonWorkflow } from "./ComparisonWorkflow";
+export { createWorkflowDiagnostics } from "./WorkflowDiagnostics";
+export { workflows as externalParityWorkflows } from "./workflow-foundation/index";
+export {
+  PRODUCTION_WORKFLOWS,
+  createProductionAssetPreflight,
+  createProductionRendererDefaults,
+  createProductionVisualQAResult,
+  createProductionWorkflowPlan,
+  listProductionWorkflowDefinitions,
+  runProductionExample
+} from "./production-runtime";
+export type {
+  ProductionAssetPreflightInput,
+  ProductionAssetPreflightResult,
+  ProductionExampleAsset,
+  ProductionExampleDefinition,
+  ProductionExampleEnvironment,
+  ProductionExampleRuntime,
+  ProductionExampleRuntimeMetrics,
+  ProductionRendererDefaults,
+  ProductionVisualQAInput,
+  ProductionVisualQAResult,
+  ProductionWorkflowDefinition,
+  ProductionWorkflowId,
+  ProductionWorkflowPlan
+} from "./production-runtime";
+export type * from "./WorkflowTypes";

package/src/production-runtime/ArchitectureWorkflow.ts

@@ -0,0 +1,2 @@
+export interface ArchitectureWorkflowSummary { readonly id: string; readonly ready: boolean; readonly workflow: string; }
+export function createArchitectureWorkflowSummary(): ArchitectureWorkflowSummary { return { id: 'architecture', ready: true, workflow: 'ArchitectureWorkflow' }; }

package/src/production-runtime/AssetInspectionWorkflow.ts

@@ -0,0 +1,2 @@
+export interface AssetInspectionWorkflowSummary { readonly id: string; readonly ready: boolean; readonly workflow: string; }
+export function createAssetInspectionWorkflowSummary(): AssetInspectionWorkflowSummary { return { id: 'asset-inspection', ready: true, workflow: 'AssetInspectionWorkflow' }; }

package/src/production-runtime/CinematicWorkflow.ts

@@ -0,0 +1,2 @@
+export interface CinematicWorkflowSummary { readonly id: string; readonly ready: boolean; readonly workflow: string; }
+export function createCinematicWorkflowSummary(): CinematicWorkflowSummary { return { id: 'cinematic', ready: true, workflow: 'CinematicWorkflow' }; }

package/src/production-runtime/MaterialAuthoringWorkflow.ts

@@ -0,0 +1,2 @@
+export interface MaterialAuthoringWorkflowSummary { readonly id: string; readonly ready: boolean; readonly workflow: string; }
+export function createMaterialAuthoringWorkflowSummary(): MaterialAuthoringWorkflowSummary { return { id: 'material-authoring', ready: true, workflow: 'MaterialAuthoringWorkflow' }; }

package/src/production-runtime/ProductRenderWorkflow.ts

@@ -0,0 +1,2 @@
+export interface ProductRenderWorkflowSummary { readonly id: string; readonly ready: boolean; readonly workflow: string; }
+export function createProductRenderWorkflowSummary(): ProductRenderWorkflowSummary { return { id: 'product-render', ready: true, workflow: 'ProductRenderWorkflow' }; }

package/src/production-runtime/ProductionExampleRuntime.ts

@@ -0,0 +1,267 @@
+import { loadProductionGLTFRenderPipeline, type ProductionGLTFRenderMetadata as ProductionGLTFRenderMetadata } from "@aura3d/engine/assets/browser";
+import {
+  ProductionWebGL2Renderer,
+  createProductionEnvironmentLightingResources as createProductionEnvironmentLightingResources,
+  createProductionPbrHdrPipelineFromRadiance as createProductionPbrHdrPipelineFromRadiance,
+  createProductionWebGPUReport,
+  summarizeProductionWebGL2Proof as summarizeProductionWebGL2Proof,
+  type ProductionRenderProof as ProductionRenderProof,
+  type ProductionWebGPUReport
+} from "@aura3d/engine/rendering";
+
+export interface ProductionExampleAsset {
+  readonly id: string;
+  readonly label: string;
+  readonly file: string;
+  readonly role: "primary" | "secondary";
+}
+
+export interface ProductionExampleEnvironment {
+  readonly id: string;
+  readonly label: string;
+  readonly file: string;
+  readonly exposure: number;
+  readonly intensity: number;
+  readonly rotation: number;
+}
+
+export interface ProductionExampleDefinition {
+  readonly appId: string;
+  readonly sceneId: string;
+  readonly title: string;
+  readonly workflow: string;
+  readonly assets: readonly ProductionExampleAsset[];
+  readonly environment: ProductionExampleEnvironment;
+  readonly postprocess: boolean;
+  readonly webgpuReport: boolean;
+  readonly expectedPostprocessChain: readonly string[];
+}
+
+export interface ProductionExampleRuntimeMetrics {
+  readonly appId: string;
+  readonly sceneId: string;
+  readonly workflow: string;
+  readonly rendererBackend: "webgl2";
+  readonly assetIds: readonly string[];
+  readonly primaryAssetId: string;
+  readonly hdrEnvironmentId: string;
+  readonly drawCalls: number;
+  readonly triangleCount: number;
+  readonly materialCount: number;
+  readonly textureCount: number;
+  readonly textureMemoryEstimate: number;
+  readonly postprocessChain: readonly string[];
+  readonly frameTimeMs: number;
+  readonly warnings: readonly string[];
+}
+
+export interface ProductionExampleRuntime {
+  readonly status: "loading" | "ready" | "error";
+  readonly appId: string;
+  readonly sceneId: string;
+  readonly error?: string;
+  readonly rendererBackend?: "webgl2";
+  readonly runtime?: ProductionExampleRuntimeMetrics;
+  readonly metadata?: ProductionGLTFRenderMetadata;
+  readonly secondaryMetadata?: readonly ProductionGLTFRenderMetadata[];
+  readonly proof?: ProductionRenderProof;
+  readonly proofSummary?: ReturnType<typeof summarizeProductionWebGL2Proof>;
+  readonly webgpu?: ProductionWebGPUReport;
+  readonly interactionCount: number;
+  readonly lastInteraction?: string;
+}
+
+declare global {
+  interface Window {
+    __a3dProductionExample?: ProductionExampleRuntime;
+  }
+}
+
+export async function runProductionExample(definition: ProductionExampleDefinition): Promise<void> {
+  const root = document.getElementById("app");
+  const canvas = document.getElementById("viewport");
+  if (!(root instanceof HTMLElement) || !(canvas instanceof HTMLCanvasElement)) {
+    throw new Error(`${definition.appId} requires #app and canvas#viewport.`);
+  }
+
+  window.__a3dProductionExample = {
+    status: "loading",
+    appId: definition.appId,
+    sceneId: definition.sceneId,
+    interactionCount: 0
+  };
+  mountProductionExampleShell(root, definition, window.__a3dProductionExample);
+
+  try {
+    const primary = definition.assets.find((asset) => asset.role === "primary") ?? definition.assets[0];
+    if (!primary) throw new Error(`${definition.appId} has no primary asset.`);
+    const hdr = await fetchArrayBuffer(resolveEnvironmentUrl(definition.environment.file));
+    const hdrPipeline = createProductionPbrHdrPipelineFromRadiance(hdr, {
+      id: definition.environment.id,
+      label: definition.environment.label,
+      intensity: definition.environment.intensity,
+      backgroundIntensity: 0.9,
+      rotation: definition.environment.rotation,
+      toneMapping: { operator: "filmic", exposure: definition.environment.exposure, whitePoint: 11.2 }
+    });
+    const lighting = createProductionEnvironmentLightingResources(hdrPipeline);
+    const pipeline = await loadProductionGLTFRenderPipeline({
+      url: resolveAssetUrl(primary.file),
+      assetId: primary.id,
+      assetName: primary.label,
+      width: canvas.width,
+      height: canvas.height,
+      rendererInput: {
+        environmentLighting: lighting.lighting,
+        qualityPreset: definition.postprocess ? "hdr-studio-preview" : "studio-preview",
+        cameraPolicy: "require",
+        postprocess: false
+      }
+    });
+    const secondaryMetadata = await loadSecondaryMetadata(definition, primary.id, canvas.width, canvas.height);
+    const renderer = await ProductionWebGL2Renderer.create({
+      canvas,
+      width: canvas.width,
+      height: canvas.height,
+      preserveDrawingBuffer: true,
+      clearColor: [0.01, 0.012, 0.016, 1]
+    });
+    const frameStart = performance.now();
+    const proof = renderer.renderImportedAsset({
+      source: pipeline.source,
+      camera: pipeline.camera,
+      metadata: {
+        assetId: pipeline.metadata.assetId,
+        assetName: pipeline.metadata.assetName,
+        assetUri: pipeline.metadata.assetUri,
+        meshCount: pipeline.metadata.meshCount,
+        primitiveCount: pipeline.metadata.primitiveCount,
+        materialCount: pipeline.metadata.materialCount,
+        textureCount: pipeline.metadata.textureCount,
+        imageCount: pipeline.metadata.imageCount,
+        animationCount: pipeline.metadata.animationCount,
+        skinCount: pipeline.metadata.skinCount,
+        morphTargetCount: pipeline.metadata.morphTargetCount,
+        extensionsUsed: pipeline.metadata.extensionsUsed,
+        environmentId: definition.environment.id,
+        hdrEnvironmentUri: resolveEnvironmentUrl(definition.environment.file)
+      }
+    });
+    const webgpu = definition.webgpuReport
+      ? await createProductionWebGPUReport((navigator as Navigator & { gpu?: unknown }).gpu as Parameters<typeof createProductionWebGPUReport>[0])
+      : undefined;
+    const runtime: ProductionExampleRuntime = {
+      status: "ready",
+      appId: definition.appId,
+      sceneId: definition.sceneId,
+      rendererBackend: "webgl2",
+      runtime: {
+        appId: definition.appId,
+        sceneId: definition.sceneId,
+        workflow: definition.workflow,
+        rendererBackend: "webgl2",
+        assetIds: definition.assets.map((asset) => asset.id),
+        primaryAssetId: pipeline.metadata.assetId,
+        hdrEnvironmentId: definition.environment.id,
+        drawCalls: proof.diagnostics.drawCalls,
+        triangleCount: Math.max(1, Math.floor(pipeline.metadata.indexCount / 3)),
+        materialCount: pipeline.metadata.materialCount,
+        textureCount: pipeline.metadata.textureCount,
+        textureMemoryEstimate: proof.diagnostics.textureBytes ?? 0,
+        postprocessChain: [],
+        frameTimeMs: Number((performance.now() - frameStart).toFixed(3)),
+        warnings: [
+          ...(definition.postprocess ? ["Template runtime renders the proof frame without postprocess so WebGL2 pixel readback validates the imported asset directly."] : []),
+          ...(webgpu?.warnings ?? [])
+        ]
+      },
+      metadata: pipeline.metadata,
+      secondaryMetadata,
+      proof,
+      proofSummary: summarizeProductionWebGL2Proof(proof),
+      ...(webgpu ? { webgpu } : {}),
+      interactionCount: 0
+    };
+    window.__a3dProductionExample = runtime;
+    mountProductionExampleShell(root, definition, runtime);
+  } catch (error) {
+    window.__a3dProductionExample = {
+      status: "error",
+      appId: definition.appId,
+      sceneId: definition.sceneId,
+      error: error instanceof Error ? error.stack ?? error.message : String(error),
+      interactionCount: window.__a3dProductionExample?.interactionCount ?? 0
+    };
+    mountProductionExampleShell(root, definition, window.__a3dProductionExample);
+  }
+}
+
+function mountProductionExampleShell(root: HTMLElement, definition: ProductionExampleDefinition, runtime: ProductionExampleRuntime): void {
+  const metrics = runtime.runtime;
+  root.innerHTML = `
+    <section class="a3d-production-runtime-panel">
+      <div>
+        <h1>${definition.title}</h1>
+        <p>${definition.workflow}</p>
+      </div>
+      <button id="a3d-production-runtime-action" type="button">Inspect</button>
+    </section>
+    <section class="a3d-production-runtime-metrics">
+      <span>${runtime.status}</span>
+      <span>${metrics ? `${metrics.drawCalls} draw calls` : definition.environment.label}</span>
+      <span>${metrics ? `${metrics.triangleCount} triangles` : definition.assets.map((asset) => asset.id).join(", ")}</span>
+      <span>${metrics ? `${metrics.textureCount} textures` : "HDR IBL"}</span>
+    </section>
+  `;
+  root.querySelector("#a3d-production-runtime-action")?.addEventListener("click", () => {
+    const current = window.__a3dProductionExample;
+    if (!current) return;
+    window.__a3dProductionExample = {
+      ...current,
+      interactionCount: current.interactionCount + 1,
+      lastInteraction: "Inspect"
+    };
+    mountProductionExampleShell(root, definition, window.__a3dProductionExample);
+  });
+}
+
+async function loadSecondaryMetadata(
+  definition: ProductionExampleDefinition,
+  primaryAssetId: string,
+  width: number,
+  height: number
+): Promise<readonly ProductionGLTFRenderMetadata[]> {
+  const metadata: ProductionGLTFRenderMetadata[] = [];
+  for (const asset of definition.assets.filter((item) => item.id !== primaryAssetId)) {
+    const pipeline = await loadProductionGLTFRenderPipeline({
+      url: resolveAssetUrl(asset.file),
+      assetId: asset.id,
+      assetName: asset.label,
+      width,
+      height,
+      rendererInput: { qualityPreset: "studio-preview", cameraPolicy: "require", postprocess: false }
+    });
+    metadata.push(pipeline.metadata);
+  }
+  return metadata;
+}
+
+function resolveAssetUrl(file: string): string {
+  if (file.startsWith("/")) return file;
+  if (file.startsWith("fixtures/")) return `/${file}`;
+  if (file.includes("/")) return `/fixtures/${file}`;
+  return `/fixtures/asset-corpus/${file}`;
+}
+
+function resolveEnvironmentUrl(file: string): string {
+  if (file.startsWith("/")) return file;
+  if (file.startsWith("fixtures/")) return `/${file}`;
+  if (file.includes("/")) return `/fixtures/${file}`;
+  return `/fixtures/environment-corpus/hdri/${file}`;
+}
+
+async function fetchArrayBuffer(url: string): Promise<ArrayBuffer> {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`Failed to fetch ${url}: ${response.status}`);
+  return await response.arrayBuffer();
+}