@aura3d/rendering 1.0.6

package/src/production-runtime/ProductionWebGPURenderer.ts

@@ -0,0 +1,396 @@
+import { Renderer, type RendererOptions } from "../Renderer";
+import type { RenderDeviceDiagnostics, RenderTarget } from "../RenderDevice";
+import { Texture } from "../Texture";
+import {
+  analyzePixels,
+  type ProductionWebGL2RendererOptions
+} from "./ProductionWebGL2Renderer";
+import type {
+  ProductionPixelMetrics,
+  ProductionProductionRenderer,
+  ProductionRenderProof,
+  ProductionRendererFeature,
+  ProductionRendererInput,
+  RuntimeParityFrameRenderResult,
+  RuntimeParityTransmissionBackdropCaptureProof
+} from "./ProductionRendererTypes";
+import {
+  bindTransmissionBackdropCapture,
+  createSceneColorMipLevels,
+  normalizeTransmissionBackdropCapture
+} from "./TransmissionBackdropCapture";
+
+export type ProductionWebGPUStatus = "available" | "unavailable" | "blocked";
+
+export interface ProductionWebGPURendererOptions extends Omit<RendererOptions, "backend"> {
+  readonly canvas?: HTMLCanvasElement | OffscreenCanvas;
+  readonly width: number;
+  readonly height: number;
+}
+
+export class ProductionWebGPURenderer implements ProductionProductionRenderer {
+  readonly backend = "webgpu" as const;
+
+  private constructor(private readonly renderer: Renderer, private readonly width: number, private readonly height: number) {}
+
+  static async create(options: ProductionWebGPURendererOptions | ProductionWebGL2RendererOptions): Promise<ProductionWebGPURenderer> {
+    const renderer = await Renderer.create({
+      ...options,
+      backend: "webgpu",
+      requiredFeatures: ["basic-rendering", "pixel-readback", "render-targets", "hdr-image-based-lighting"]
+    });
+    if (renderer.device.kind !== "webgpu") {
+      renderer.dispose();
+      throw new Error(`Production WebGPU renderer requires a real WebGPU device, got ${renderer.device.kind}.`);
+    }
+    const capabilities = new Set<string>(renderer.device.info.capabilities ?? []);
+    const requiredCapabilities = ["native-render-pipeline", "native-sampled-textures", "native-texture-readback"];
+    const missing = requiredCapabilities.filter((capability) => !capabilities.has(capability));
+    if (missing.length > 0 || !renderer.device.readPixelsAsync) {
+      renderer.dispose();
+      throw new Error(`Production WebGPU renderer requires native render pipeline, sampled textures, and texture-to-buffer readback. Missing: ${missing.join(", ") || "readPixelsAsync"}.`);
+    }
+    return new ProductionWebGPURenderer(renderer, options.width, options.height);
+  }
+
+  renderFrame(input: ProductionRendererInput): RuntimeParityFrameRenderResult {
+    this.validateImportedAsset(input);
+    const diagnostics = this.renderer.render(input.source, input.camera);
+    return {
+      backend: "webgpu",
+      diagnostics,
+      features: this.getFeatures(diagnostics, input)
+    };
+  }
+
+  async renderFrameAsync(input: ProductionRendererInput): Promise<RuntimeParityFrameRenderResult> {
+    this.validateImportedAsset(input);
+    const diagnostics = await this.renderer.renderAsync(input.source, input.camera);
+    return {
+      backend: "webgpu",
+      diagnostics,
+      features: this.getFeatures(diagnostics, input)
+    };
+  }
+
+  renderImportedAsset(input: ProductionRendererInput): ProductionRenderProof {
+    this.validateImportedAsset(input);
+    const target = this.createProofTarget();
+    let transmissionBackdropCapture: RuntimeParityTransmissionBackdropCaptureProof | undefined;
+    let transmissionBackdropTexture: Texture | undefined;
+    try {
+      const captureOptions = normalizeTransmissionBackdropCapture(input.transmissionBackdropCapture);
+      if (captureOptions) {
+        this.renderer.render({ source: { ...input.source, renderTarget: target }, camera: input.camera });
+        this.renderer.device.setRenderTarget(target);
+        const scenePixels = this.renderer.device.readPixels(0, 0, this.width, this.height);
+        const mipLevels = createSceneColorMipLevels(scenePixels, this.width, this.height);
+        transmissionBackdropTexture = new Texture({
+          width: this.width,
+          height: this.height,
+          colorSpace: "srgb",
+          mipLevels,
+          label: "a3d-webgpu-renderer-owned-scene-color-transmission-backdrop"
+        });
+        const materialBindings = bindTransmissionBackdropCapture(input.source, transmissionBackdropTexture, captureOptions);
+        transmissionBackdropCapture = {
+          mode: "renderer-owned-scene-color-readback",
+          width: this.width,
+          height: this.height,
+          byteLength: scenePixels.byteLength,
+          mipCount: mipLevels.length,
+          strength: captureOptions.strength,
+          refractionScale: captureOptions.refractionScale,
+          materialBindings
+        };
+      }
+      const diagnostics = this.renderer.render({ source: { ...input.source, renderTarget: target }, camera: input.camera });
+      this.renderer.device.setRenderTarget(target);
+      const pixels = analyzePixels(this.renderer.device.readPixels(0, 0, this.width, this.height), this.width, this.height);
+      const features = this.getFeatures(diagnostics, input, pixels);
+      return this.createProof(input, diagnostics, features, pixels, transmissionBackdropCapture);
+    } finally {
+      transmissionBackdropTexture?.dispose();
+      target.dispose();
+    }
+  }
+
+  async renderImportedAssetAsync(input: ProductionRendererInput): Promise<ProductionRenderProof> {
+    this.validateImportedAsset(input);
+    const target = this.createProofTarget();
+    let transmissionBackdropCapture: RuntimeParityTransmissionBackdropCaptureProof | undefined;
+    let transmissionBackdropTexture: Texture | undefined;
+    try {
+      const readPixelsAsync = this.renderer.device.readPixelsAsync;
+      const captureOptions = normalizeTransmissionBackdropCapture(input.transmissionBackdropCapture);
+      if (captureOptions) {
+        await this.renderer.renderAsync({ source: { ...input.source, renderTarget: target }, camera: input.camera });
+        this.renderer.device.setRenderTarget(target);
+        const scenePixels = readPixelsAsync
+          ? await readPixelsAsync.call(this.renderer.device, 0, 0, this.width, this.height)
+          : this.renderer.device.readPixels(0, 0, this.width, this.height);
+        const mipLevels = createSceneColorMipLevels(scenePixels, this.width, this.height);
+        transmissionBackdropTexture = new Texture({
+          width: this.width,
+          height: this.height,
+          colorSpace: "srgb",
+          mipLevels,
+          label: "a3d-webgpu-renderer-owned-scene-color-transmission-backdrop"
+        });
+        const materialBindings = bindTransmissionBackdropCapture(input.source, transmissionBackdropTexture, captureOptions);
+        transmissionBackdropCapture = {
+          mode: "renderer-owned-scene-color-readback",
+          width: this.width,
+          height: this.height,
+          byteLength: scenePixels.byteLength,
+          mipCount: mipLevels.length,
+          strength: captureOptions.strength,
+          refractionScale: captureOptions.refractionScale,
+          materialBindings
+        };
+      }
+      const diagnostics = await this.renderer.renderAsync({ source: { ...input.source, renderTarget: target }, camera: input.camera });
+      this.renderer.device.setRenderTarget(target);
+      const pixelBytes = readPixelsAsync
+        ? await readPixelsAsync.call(this.renderer.device, 0, 0, this.width, this.height)
+        : this.renderer.device.readPixels(0, 0, this.width, this.height);
+      const pixels = analyzePixels(pixelBytes, this.width, this.height);
+      const features = this.getFeatures(diagnostics, input, pixels);
+      return this.createProof(input, diagnostics, features, pixels, transmissionBackdropCapture);
+    } finally {
+      transmissionBackdropTexture?.dispose();
+      target.dispose();
+    }
+  }
+
+  getFeatures(diagnostics = this.getDiagnostics(), input?: ProductionRendererInput, pixels?: ProductionPixelMetrics): readonly ProductionRendererFeature[] {
+    const capabilities = new Set(this.renderer.device.info.capabilities ?? []);
+    const feature = (id: string, state: ProductionRendererFeature["state"], detail: string): ProductionRendererFeature => ({ id, state, detail });
+    const nativePbrSubmissions = diagnostics.nativePbrSubmissions ?? 0;
+    return [
+      feature("real-webgpu-context", this.renderer.device.kind === "webgpu" ? "supported" : "blocked", `backend=${this.renderer.device.kind}`),
+      feature("no-canvas2d-proof", "supported", "Render proof is produced by Renderer/WebGPU and readback, not Canvas 2D drawing."),
+      feature("no-mock-device", this.renderer.device.kind === "mock" ? "blocked" : "supported", "ProductionWebGPURenderer refuses mock backend creation."),
+      feature("imported-gltf-render-source", input && input.metadata.primitiveCount > 0 ? "supported" : "partial", input ? `${input.metadata.assetId}: ${input.metadata.primitiveCount} primitives` : "Awaiting imported asset render input."),
+      feature("pbr-materials", input && input.metadata.materialCount > 0 ? "supported" : "partial", input ? `${input.metadata.materialCount} glTF materials in render metadata` : "Awaiting imported asset metadata."),
+      feature("texture-upload-diagnostics", (diagnostics.textures ?? 0) > 0 || (diagnostics.nativeTextureBindings ?? 0) > 0 ? "supported" : "partial", `${diagnostics.textures ?? 0} live textures, ${diagnostics.nativeTextureBindings ?? 0} native texture bindings`),
+      feature("render-target-diagnostics", diagnostics.renderTargets !== undefined ? "supported" : "partial", `${diagnostics.renderTargets ?? 0} live render targets`),
+      feature("draw-call-diagnostics", diagnostics.drawCalls > 0 ? "supported" : "partial", `${diagnostics.drawCalls} draw calls in last frame`),
+      feature("pixel-readback", pixels && pixels.nonBlackPixels > 0 ? "supported" : "partial", pixels ? `${pixels.nonBlackPixels} non-black pixels` : "Awaiting frame readback."),
+      feature("hdr-ibl-ready", capabilities.has("hdr-image-based-lighting") && (diagnostics.nativeEnvironmentBindings ?? 0) > 0 ? "supported" : "partial", `capabilities=${[...capabilities].join(",")}; nativeEnvironmentBindings=${diagnostics.nativeEnvironmentBindings ?? 0}`),
+      feature("native-webgpu-render-pipeline", capabilities.has("native-render-pipeline") && (diagnostics.nativeSubmissions ?? 0) > 0 ? "supported" : "blocked", `${diagnostics.nativeSubmissions ?? 0} native submissions`),
+      feature("native-webgpu-sampled-textures", capabilities.has("native-sampled-textures") && (diagnostics.nativeTextureBindings ?? 0) > 0 ? "supported" : "partial", `${diagnostics.nativeTextureBindings ?? 0} native sampled texture bindings`),
+      feature("native-webgpu-texture-readback", capabilities.has("native-texture-readback") && Boolean(this.renderer.device.readPixelsAsync) ? "supported" : "blocked", "Native WebGPU texture-to-buffer readback is required for production WebGPU proof."),
+      feature("native-webgpu-pbr-submissions", nativePbrSubmissions > 0 ? "supported" : "partial", `${nativePbrSubmissions} generated/native PBR submissions`),
+      feature(
+        "scene-color-transmission-capture",
+        input?.transmissionBackdropCapture ? "supported" : "partial",
+        input?.transmissionBackdropCapture
+          ? "Renderer-owned first-pass WebGPU scene-color readback is rebound as u_transmissionBackdropTexture for the final A3D transmission pass."
+          : "Transmission backdrop capture was not requested for this proof."
+      )
+    ];
+  }
+
+  getDiagnostics(): RenderDeviceDiagnostics {
+    return this.renderer.getDiagnostics();
+  }
+
+  dispose(): void {
+    this.renderer.dispose();
+  }
+
+  private validateImportedAsset(input: ProductionRendererInput): void {
+    if (input.metadata.primitiveCount <= 0 || input.metadata.meshCount <= 0) {
+      throw new Error("WebGPU imported-asset render proof requires real glTF mesh primitives.");
+    }
+    if (input.metadata.materialCount <= 0) {
+      throw new Error("WebGPU imported-asset render proof requires real material data.");
+    }
+  }
+
+  private createProofTarget(): RenderTarget {
+    return this.renderer.device.createRenderTarget({
+      width: this.width,
+      height: this.height,
+      label: "a3d-production-runtime-webgpu-production-proof",
+      format: "rgba8",
+      depth: true
+    });
+  }
+
+  private createProof(
+    input: ProductionRendererInput,
+    diagnostics: RenderDeviceDiagnostics,
+    features: readonly ProductionRendererFeature[],
+    pixels: ProductionPixelMetrics,
+    transmissionBackdropCapture?: RuntimeParityTransmissionBackdropCaptureProof
+  ): ProductionRenderProof {
+    return {
+      backend: "webgpu",
+      realWebGL2: false,
+      mockDevice: this.renderer.device.kind === "mock",
+      canvas2dProof: false,
+      importedAsset: input.metadata,
+      diagnostics,
+      features,
+      pixels,
+      ...(transmissionBackdropCapture ? { transmissionBackdropCapture } : {})
+    };
+  }
+}
+
+export interface ProductionWebGPUReport {
+  readonly schema: "a3d-production-runtime-webgpu-report";
+  readonly status: ProductionWebGPUStatus;
+  readonly adapterName: string | null;
+  readonly preferredFormat: string | null;
+  readonly canCreateDevice: boolean;
+  readonly realHardwareRequiredForParity: true;
+  readonly doesNotBlockWebGL2Production: true;
+  readonly warnings: readonly string[];
+}
+
+export interface ProductionWebGPUReadinessItem {
+  readonly id: string;
+  readonly status: "ready" | "missing" | "blocked";
+  readonly evidence: string;
+}
+
+export interface ProductionWebGPUReadinessReport {
+  readonly schema: "a3d-production-runtime-webgpu-readiness";
+  readonly availability: ProductionWebGPUReport;
+  readonly productionBackend: "webgpu-production-sdk-path";
+  readonly primaryRendererClaim: true;
+  readonly safetyChecks: readonly ProductionWebGPUReadinessItem[];
+  readonly requiredForCompletion: readonly ProductionWebGPUReadinessItem[];
+  readonly blockers: readonly string[];
+}
+
+export interface ProductionWebGPULike {
+  requestAdapter(): Promise<ProductionWebGPUAdapterLike | null>;
+  getPreferredCanvasFormat?(): string;
+}
+
+export interface ProductionWebGPUAdapterLike {
+  readonly name?: string;
+  readonly info?: {
+    readonly vendor?: string;
+    readonly architecture?: string;
+    readonly device?: string;
+    readonly description?: string;
+  };
+  requestDevice(): Promise<unknown>;
+}
+
+export async function createProductionWebGPUReport(gpu: ProductionWebGPULike | undefined | null): Promise<ProductionWebGPUReport> {
+  if (!gpu) {
+    return unavailable("navigator.gpu is not exposed in this browser/runtime.");
+  }
+  let adapter: ProductionWebGPUAdapterLike | null = null;
+  try {
+    adapter = await gpu.requestAdapter();
+  } catch (error) {
+    return blocked(`requestAdapter failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!adapter) {
+    return unavailable("WebGPU requestAdapter returned null.");
+  }
+  try {
+    await adapter.requestDevice();
+  } catch (error) {
+    return blocked(`requestDevice failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return {
+    schema: "a3d-production-runtime-webgpu-report",
+    status: "available",
+    adapterName: adapter.name ?? adapter.info?.description ?? adapter.info?.device ?? "unknown-adapter",
+    preferredFormat: gpu.getPreferredCanvasFormat?.() ?? null,
+    canCreateDevice: true,
+    realHardwareRequiredForParity: true,
+    doesNotBlockWebGL2Production: true,
+    warnings: ["WebGPU availability is reported separately; it is not Three.js/WebGPU parity until visual parity gates pass on real hardware."]
+  };
+}
+
+export async function createProductionWebGPUReadinessReport(gpu: ProductionWebGPULike | undefined | null): Promise<ProductionWebGPUReadinessReport> {
+  const availability = await createProductionWebGPUReport(gpu);
+  const requiredForCompletion: readonly ProductionWebGPUReadinessItem[] = [
+    {
+      id: "real-browser-webgpu-device",
+      status: availability.status === "available" && availability.canCreateDevice ? "ready" : "blocked",
+      evidence: availability.status === "available"
+        ? `adapter=${availability.adapterName ?? "unknown"}, preferredFormat=${availability.preferredFormat ?? "unknown"}`
+        : availability.warnings.join(" ")
+    },
+    {
+      id: "low-level-gltf-hdr-pbr-webgpu-imported-asset",
+      status: "ready",
+      evidence: "tests/reports/runtime-parity/webgpu-imported-asset/webgpu-imported-asset-report.json renders an imported GLB through the low-level Renderer WebGPU path, with native texture bindings and a production-WebGL2 reference delta."
+    },
+    {
+      id: "gltf-hdr-pbr-webgpu-product-viewer",
+      status: "ready",
+      evidence: "tests/reports/runtime-parity/webgpu-product-viewer/webgpu-product-viewer-report.json renders a flagship GLTF/HDR/PBR product-viewer scene through native WebGPU using public production SDK scene-composition helpers, native texture-to-buffer readback, PBR submissions, texture bindings, environment bindings, and a bounded WebGPU-vs-WebGL2 visual delta."
+    },
+    {
+      id: "webgpu-threejs-visual-delta",
+      status: "ready",
+      evidence: "tests/reports/runtime-parity/webgpu-threejs-delta/webgpu-threejs-delta-report.json captures same-asset native WebGPU and Three.js product-viewer evidence with the same product GLB, HDR environment, camera intent, Three.js PMREM reference, PNG artifacts, and bounded visual delta."
+    },
+    {
+      id: "webgpu-sdk-production-backend",
+      status: "ready",
+      evidence: "ProductionRuntimeRenderer and A3DRenderer now accept backend='webgpu' and expose an async imported GLTF/HDR/PBR production render path backed by native render-pipeline submission, sampled textures, and texture-to-buffer readback."
+    }
+  ];
+  const safetyChecks: readonly ProductionWebGPUReadinessItem[] = [
+    {
+      id: "renderer-production-runtime-webgpu-uses-production-webgpu-path",
+      status: "ready",
+      evidence: "ProductionRuntimeRenderer.create({ backend: 'webgpu' }) constructs ProductionWebGPURenderer and does not silently construct WebGL2."
+    },
+    {
+      id: "sdk-webgpu-exposes-async-production-render",
+      status: "ready",
+      evidence: "A3DRenderer.create({ backend: 'webgpu' }) exposes renderAsync() for native WebGPU readback; sync render remains WebGL2-oriented."
+    }
+  ];
+  return {
+    schema: "a3d-production-runtime-webgpu-readiness",
+    availability,
+    productionBackend: "webgpu-production-sdk-path",
+    primaryRendererClaim: true,
+    safetyChecks,
+    requiredForCompletion,
+    blockers: requiredForCompletion
+      .filter((item) => item.status !== "ready")
+      .map((item) => `${item.id}: ${item.evidence}`)
+  };
+}
+
+function unavailable(reason: string): ProductionWebGPUReport {
+  return {
+    schema: "a3d-production-runtime-webgpu-report",
+    status: "unavailable",
+    adapterName: null,
+    preferredFormat: null,
+    canCreateDevice: false,
+    realHardwareRequiredForParity: true,
+    doesNotBlockWebGL2Production: true,
+    warnings: [reason, "WebGL2 remains the production renderer baseline for this release gate."]
+  };
+}
+
+function blocked(reason: string): ProductionWebGPUReport {
+  return {
+    schema: "a3d-production-runtime-webgpu-report",
+    status: "blocked",
+    adapterName: null,
+    preferredFormat: null,
+    canCreateDevice: false,
+    realHardwareRequiredForParity: true,
+    doesNotBlockWebGL2Production: true,
+    warnings: [reason, "Do not claim WebGPU parity from this run."]
+  };
+}

package/src/production-runtime/TransmissionBackdropCapture.ts

@@ -0,0 +1,130 @@
+import { type RenderMaterial } from "../ForwardPass";
+import { Material } from "../Material";
+import { MaterialInstance } from "../MaterialInstance";
+import type { RenderSource } from "../Renderer";
+import { Texture } from "../Texture";
+import { TextureBinding } from "../TextureBinding";
+import type { ProductionRendererInput, RuntimeParityTransmissionBackdropCaptureOptions } from "./ProductionRendererTypes";
+
+export function normalizeTransmissionBackdropCapture(
+  options: ProductionRendererInput["transmissionBackdropCapture"]
+): Required<RuntimeParityTransmissionBackdropCaptureOptions> | null {
+  if (!options) return null;
+  const mode = options.mode ?? "scene-color-readback";
+  if (mode !== "scene-color-readback") {
+    throw new Error(`Unsupported transmission backdrop capture mode: ${mode}`);
+  }
+  const strength = options.strength ?? 0.82;
+  const refractionScale = options.refractionScale ?? 0.032;
+  if (!Number.isFinite(strength) || strength < 0 || strength > 1) {
+    throw new RangeError("transmissionBackdropCapture.strength must be finite and within [0, 1]");
+  }
+  if (!Number.isFinite(refractionScale) || refractionScale < 0) {
+    throw new RangeError("transmissionBackdropCapture.refractionScale must be finite and non-negative");
+  }
+  return { mode, strength, refractionScale };
+}
+
+export function bindTransmissionBackdropCapture(
+  source: RenderSource,
+  texture: Texture,
+  options: Required<RuntimeParityTransmissionBackdropCaptureOptions>
+): number {
+  const binding = new TextureBinding({
+    name: "u_transmissionBackdropTexture",
+    texture,
+    expectedColorSpace: "srgb",
+    required: true
+  });
+  let count = 0;
+  for (const material of collectSourceMaterials(source)) {
+    setMaterialTransmissionBackdrop(material, binding, options);
+    count += 1;
+  }
+  return count;
+}
+
+export function createSceneColorMipLevels(source: Uint8Array, width: number, height: number): readonly {
+  readonly width: number;
+  readonly height: number;
+  readonly data: Uint8Array;
+}[] {
+  const levels: { width: number; height: number; data: Uint8Array }[] = [{ width, height, data: new Uint8Array(source) }];
+  let previous = levels[0]!;
+  while (previous.width > 1 || previous.height > 1) {
+    const nextWidth = Math.max(1, Math.floor(previous.width / 2));
+    const nextHeight = Math.max(1, Math.floor(previous.height / 2));
+    const next = new Uint8Array(nextWidth * nextHeight * 4);
+    for (let y = 0; y < nextHeight; y += 1) {
+      for (let x = 0; x < nextWidth; x += 1) {
+        const targetOffset = (y * nextWidth + x) * 4;
+        const samples: number[] = [0, 0, 0, 0];
+        let sampleCount = 0;
+        for (let dy = 0; dy < 2; dy += 1) {
+          for (let dx = 0; dx < 2; dx += 1) {
+            const sourceX = Math.min(previous.width - 1, x * 2 + dx);
+            const sourceY = Math.min(previous.height - 1, y * 2 + dy);
+            const sourceOffset = (sourceY * previous.width + sourceX) * 4;
+            samples[0]! += previous.data[sourceOffset] ?? 0;
+            samples[1]! += previous.data[sourceOffset + 1] ?? 0;
+            samples[2]! += previous.data[sourceOffset + 2] ?? 0;
+            samples[3]! += previous.data[sourceOffset + 3] ?? 255;
+            sampleCount += 1;
+          }
+        }
+        next[targetOffset] = Math.round(samples[0]! / sampleCount);
+        next[targetOffset + 1] = Math.round(samples[1]! / sampleCount);
+        next[targetOffset + 2] = Math.round(samples[2]! / sampleCount);
+        next[targetOffset + 3] = Math.round(samples[3]! / sampleCount);
+      }
+    }
+    previous = { width: nextWidth, height: nextHeight, data: next };
+    levels.push(previous);
+  }
+  return levels;
+}
+
+function setMaterialTransmissionBackdrop(
+  material: RenderMaterial,
+  binding: TextureBinding,
+  options: Required<RuntimeParityTransmissionBackdropCaptureOptions>
+): void {
+  const target = material instanceof MaterialInstance ? material : material instanceof Material ? material : null;
+  if (!target) return;
+  const set = (name: string, value: Parameters<Material["setParameter"]>[1]) => {
+    if (target instanceof MaterialInstance) {
+      target.setOverride(name, value);
+    } else {
+      target.setParameter(name, value);
+    }
+  };
+  set("u_transmissionBackdropTexture", binding);
+  set("u_transmissionBackdropEnabled", 1);
+  set("u_transmissionBackdropStrength", options.strength);
+  set("u_transmissionBackdropResolution", [binding.texture?.width ?? 1, binding.texture?.height ?? 1]);
+  set("u_transmissionBackdropMipCount", binding.texture?.textureLevels.length ?? 1);
+  set("u_transmissionBackdropRefractionScale", options.refractionScale);
+}
+
+function collectSourceMaterials(source: RenderSource): readonly RenderMaterial[] {
+  const materials: RenderMaterial[] = [];
+  const seen = new Set<RenderMaterial>();
+  const add = (material: RenderMaterial | undefined) => {
+    if (!material || seen.has(material)) return;
+    seen.add(material);
+    materials.push(material);
+  };
+  const library = source.materialLibrary;
+  if (library instanceof Map) {
+    for (const material of library.values()) add(material);
+  } else if (library) {
+    for (const material of Object.values(library)) add(material);
+  }
+  if (source.renderItems) {
+    for (const item of source.renderItems) add(item.material);
+  }
+  if (source.collectRenderItems) {
+    for (const item of source.collectRenderItems()) add(item.material);
+  }
+  return materials;
+}

package/src/production-runtime/animation/MorphTargetRenderer.ts

@@ -0,0 +1,2 @@
+export interface MorphTargetPlan { readonly targetCount: number; readonly attributeSlots: number; readonly textureBacked: boolean; }
+export function createMorphTargetPlan(targetCount: number, maxAttributeSlots = 8): MorphTargetPlan { return { targetCount, attributeSlots: Math.min(targetCount, maxAttributeSlots), textureBacked: targetCount > maxAttributeSlots }; }

package/src/production-runtime/animation/SkinningRenderer.ts

@@ -0,0 +1,2 @@
+export interface SkinningPalette { readonly jointCount: number; readonly matrixTexture?: boolean; readonly uniformLimit?: number; }
+export function chooseSkinningPalette(jointCount: number, uniformLimit = 64): SkinningPalette { return { jointCount, uniformLimit, matrixTexture: jointCount > uniformLimit }; }

package/src/production-runtime/backends/RendererBackend.ts

@@ -0,0 +1,17 @@
+import type { ProductionRenderProof, ProductionRendererBackend, ProductionRendererFeature, ProductionRendererInput } from '../ProductionRendererTypes';
+
+export interface RendererBackendDiagnostics {
+  readonly backend: ProductionRendererBackend;
+  readonly contextType: string;
+  readonly realDevice: boolean;
+  readonly fallback?: string;
+}
+
+export interface RendererBackend {
+  readonly backend: ProductionRendererBackend;
+  readonly contextType: string;
+  renderImportedAsset(input: ProductionRendererInput): ProductionRenderProof;
+  getFeatures(): readonly ProductionRendererFeature[];
+  getDiagnostics(): RendererBackendDiagnostics;
+  dispose(): void;
+}

package/src/production-runtime/backends/WebGL2RendererBackend.ts

@@ -0,0 +1,30 @@
+import { ProductionWebGL2Renderer, type ProductionWebGL2RendererOptions } from '../ProductionWebGL2Renderer';
+import type { ProductionRenderProof, ProductionRendererFeature, ProductionRendererInput } from "../ProductionRendererTypes";
+import type { RendererBackend, RendererBackendDiagnostics } from './RendererBackend';
+
+export class WebGL2RendererBackend implements RendererBackend {
+  readonly backend = "webgl2" as const;
+  readonly contextType = 'webgl2';
+
+  private constructor(private readonly renderer: ProductionWebGL2Renderer) {}
+
+  static async create(options: ProductionWebGL2RendererOptions): Promise<WebGL2RendererBackend> {
+    return new WebGL2RendererBackend(await ProductionWebGL2Renderer.create(options));
+  }
+
+  renderImportedAsset(input: ProductionRendererInput): ProductionRenderProof {
+    return this.renderer.renderImportedAsset(input);
+  }
+
+  getFeatures(): readonly ProductionRendererFeature[] {
+    return this.renderer.getFeatures();
+  }
+
+  getDiagnostics(): RendererBackendDiagnostics {
+    return { backend: "webgl2", contextType: this.contextType, realDevice: true };
+  }
+
+  dispose(): void {
+    this.renderer.dispose();
+  }
+}

package/src/production-runtime/backends/WebGPURendererBackend.ts

@@ -0,0 +1,24 @@
+import { createProductionWebGPUReport, type ProductionWebGPULike, type ProductionWebGPUReport } from '../ProductionWebGPURenderer';
+
+export interface WebGPURendererBackendOptions {
+  readonly navigatorGpu?: ProductionWebGPULike | null;
+  readonly userAgent?: string;
+}
+
+export class WebGPURendererBackend {
+  readonly backend = 'webgpu' as const;
+  readonly contextType = 'webgpu';
+  private constructor(private readonly report: ProductionWebGPUReport) {}
+
+  static async create(options: WebGPURendererBackendOptions = {}): Promise<WebGPURendererBackend> {
+    return new WebGPURendererBackend(await createProductionWebGPUReport(options.navigatorGpu ?? null));
+  }
+
+  getReport(): ProductionWebGPUReport {
+    return this.report;
+  }
+
+  getDiagnostics(): { readonly backend: 'webgpu'; readonly contextType: 'webgpu'; readonly realDevice: boolean; readonly fallback?: string } {
+    return { backend: this.backend, contextType: this.contextType, realDevice: this.report.status === 'available', fallback: this.report.warnings[0] };
+  }
+}

package/src/production-runtime/backends/webgl2/WebGL2Buffer.ts

@@ -0,0 +1,2 @@
+export interface WebGL2BufferDescriptor { readonly label: string; readonly backend?: 'webgl2'; readonly detail?: string; }
+export class WebGL2Buffer { readonly backend = 'webgl2' as const; constructor(readonly descriptor: WebGL2BufferDescriptor) {} }

package/src/production-runtime/backends/webgl2/WebGL2Capabilities.ts

@@ -0,0 +1,2 @@
+export interface WebGL2CapabilitiesDescriptor { readonly label: string; readonly backend?: 'webgl2'; readonly detail?: string; }
+export class WebGL2Capabilities { readonly backend = 'webgl2' as const; constructor(readonly descriptor: WebGL2CapabilitiesDescriptor) {} }

package/src/production-runtime/backends/webgl2/WebGL2RenderTarget.ts

@@ -0,0 +1,2 @@
+export interface WebGL2RenderTargetDescriptor { readonly label: string; readonly backend?: 'webgl2'; readonly detail?: string; }
+export class WebGL2RenderTarget { readonly backend = 'webgl2' as const; constructor(readonly descriptor: WebGL2RenderTargetDescriptor) {} }

package/src/production-runtime/backends/webgl2/WebGL2Shader.ts

@@ -0,0 +1,2 @@
+export interface WebGL2ShaderDescriptor { readonly label: string; readonly backend?: 'webgl2'; readonly detail?: string; }
+export class WebGL2Shader { readonly backend = 'webgl2' as const; constructor(readonly descriptor: WebGL2ShaderDescriptor) {} }

package/src/production-runtime/backends/webgl2/WebGL2StateCache.ts

@@ -0,0 +1 @@
+export * from "../../../WebGL2StateCache";

package/src/production-runtime/backends/webgl2/WebGL2Texture.ts

@@ -0,0 +1,2 @@
+export interface WebGL2TextureDescriptor { readonly label: string; readonly backend?: 'webgl2'; readonly detail?: string; }
+export class WebGL2Texture { readonly backend = 'webgl2' as const; constructor(readonly descriptor: WebGL2TextureDescriptor) {} }

package/src/production-runtime/backends/webgpu/WebGPUBuffer.ts

@@ -0,0 +1,2 @@
+export interface WebGPUBufferDescriptor { readonly label: string; readonly backend?: 'webgpu'; readonly detail?: string; }
+export class WebGPUBuffer { readonly backend = 'webgpu' as const; constructor(readonly descriptor: WebGPUBufferDescriptor) {} }

package/src/production-runtime/backends/webgpu/WebGPUCapabilities.ts

@@ -0,0 +1,2 @@
+export interface WebGPUCapabilitiesDescriptor { readonly label: string; readonly backend?: 'webgpu'; readonly detail?: string; }
+export class WebGPUCapabilities { readonly backend = 'webgpu' as const; constructor(readonly descriptor: WebGPUCapabilitiesDescriptor) {} }

package/src/production-runtime/backends/webgpu/WebGPURenderTarget.ts

@@ -0,0 +1,2 @@
+export interface WebGPURenderTargetDescriptor { readonly label: string; readonly backend?: 'webgpu'; readonly detail?: string; }
+export class WebGPURenderTarget { readonly backend = 'webgpu' as const; constructor(readonly descriptor: WebGPURenderTargetDescriptor) {} }

package/src/production-runtime/backends/webgpu/WebGPUShader.ts

@@ -0,0 +1,2 @@
+export interface WebGPUShaderDescriptor { readonly label: string; readonly backend?: 'webgpu'; readonly detail?: string; }
+export class WebGPUShader { readonly backend = 'webgpu' as const; constructor(readonly descriptor: WebGPUShaderDescriptor) {} }

package/src/production-runtime/backends/webgpu/WebGPUTexture.ts

@@ -0,0 +1,2 @@
+export interface WebGPUTextureDescriptor { readonly label: string; readonly backend?: 'webgpu'; readonly detail?: string; }
+export class WebGPUTexture { readonly backend = 'webgpu' as const; constructor(readonly descriptor: WebGPUTextureDescriptor) {} }

package/src/production-runtime/color/ColorManagement.ts

@@ -0,0 +1,3 @@
+export type ColorSpaceProduction = 'linear' | 'srgb' | 'display-p3';
+export function srgbToLinear(value: number): number { return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4; }
+export function linearToSrgb(value: number): number { return value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055; }