@aura3d/rendering 1.4.0 → 1.4.2

package/src/production-runtime/PBRHDRPipeline.ts

@@ -1,381 +0,0 @@
-import {
-  createEnvironmentMapResourceSet,
-  decodeRgbeEnvironmentMap,
-  generateRgba16fSpecularPrefilterMipLevels,
-  type EnvironmentMapResourceSet,
-  type EnvironmentToneMappingOperator,
-  type LinearHdrEnvironmentMapSource,
-  type RgbeEnvironmentMapSource
-} from "../EnvironmentMapResources";
-import type { EnvironmentLightingOptions } from "../ForwardPass";
-import { Sampler } from "../Sampler";
-import { Texture, type TextureCubeFace } from "../Texture";
-import { TextureBinding } from "../TextureBinding";
-import {
-  createCubemapPMREMShaderContract,
-  generateCubemapPMREMResources,
-  type CubemapPMREMResources,
-  type CubemapPMREMShaderContract
-} from "./environment/PMREMGenerator";
-
-export type ProductionToneMappingOperator = "aces" | "filmic" | "linear" | "reinhard";
-
-export interface ProductionToneMappingPolicy {
-  readonly operator: ProductionToneMappingOperator;
-  readonly exposure: number;
-  readonly whitePoint: number;
-  readonly outputColorSpace: "srgb" | "linear";
-}
-
-export interface ProductionPbrHdrPipelineOptions {
-  readonly id: string;
-  readonly label: string;
-  readonly intensity?: number;
-  readonly backgroundIntensity?: number;
-  readonly rotation?: number;
-  readonly toneMapping?: Partial<ProductionToneMappingPolicy>;
-  readonly specularLevels?: number;
-  readonly cubemapFaceSize?: number;
-  readonly cubemapMipCount?: number;
-  readonly irradianceWidth?: number;
-  readonly irradianceHeight?: number;
-  readonly brdfLutSize?: number;
-  readonly brdfLutSampleCount?: number;
-  readonly specularSampleCount?: number;
-  readonly cubemapSampleCount?: number;
-}
-
-export interface ProductionRadianceHDR {
-  readonly width: number;
-  readonly height: number;
-  readonly rgbe: Uint8Array;
-  readonly header: string;
-  readonly format: "32-bit_rle_rgbe";
-}
-
-export interface ProductionPbrHdrPipeline {
-  readonly id: string;
-  readonly label: string;
-  readonly radiance: ProductionRadianceHDR;
-  readonly linear: LinearHdrEnvironmentMapSource;
-  readonly resources: EnvironmentMapResourceSet;
-  readonly environmentMipLevels: ReturnType<typeof generateRgba16fSpecularPrefilterMipLevels>;
-  readonly cubemapPMREM: CubemapPMREMResources;
-  readonly cubemapPMREMShaderContract: CubemapPMREMShaderContract;
-  readonly toneMapping: ProductionToneMappingPolicy;
-  readonly intensity: number;
-  readonly backgroundIntensity: number;
-  readonly rotation: number;
-  readonly diagnostics: {
-    readonly realRadianceHdr: boolean;
-    readonly environmentTextureEncoding: "rgba8-linear" | "rgba8-srgb" | "rgbe" | "rgba16f-linear";
-    readonly environmentTextureFormat: "rgba8" | "rgba16f";
-    readonly hdrPixelCount: number;
-    readonly maxLinearValue: number;
-    readonly diffuseIrradiance: boolean;
-    readonly diffuseIrradianceModel: "cosine-weighted-hemisphere";
-    readonly specularPrefilter: boolean;
-    readonly specularPrefilterModel: "ggx-importance-sampled";
-    readonly cubemapPMREM: boolean;
-    readonly cubemapPMREMModel: "equirectangular-to-cubemap-ggx-importance-sampled-prefilter";
-    readonly cubemapPMREMShaderSampling: "webgl2-sampler-cube";
-    readonly cubemapPMREMShaderContract: "webgl2-sampler-cube-split-sum";
-    readonly cubemapFaceSize: number;
-    readonly cubemapMipCount: number;
-    readonly brdfLut: boolean;
-    readonly specularMipCount: number;
-    readonly textureBytes: number;
-  };
-}
-
-export interface ProductionEnvironmentLightingResources {
-  readonly lighting: EnvironmentLightingOptions;
-  readonly environmentTexture: Texture;
-  readonly environmentCubeTexture: Texture;
-  readonly brdfLutTexture: Texture;
-  dispose(): void;
-}
-
-const DEFAULT_TONE_MAPPING: ProductionToneMappingPolicy = {
-  operator: "filmic",
-  exposure: 1,
-  whitePoint: 11.2,
-  outputColorSpace: "srgb"
-};
-
-const CUBE_TEXTURE_FACES: readonly TextureCubeFace[] = ["px", "nx", "py", "ny", "pz", "nz"];
-
-export function parseProductionRadianceHDR(buffer: ArrayBuffer | Uint8Array): ProductionRadianceHDR {
-  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-  const headerProbe = new TextDecoder("ascii").decode(bytes.slice(0, Math.min(bytes.length, 4096)));
-  const resolutionMatch = /(^|\n)-Y\s+(\d+)\s+\+X\s+(\d+)\s*\n/.exec(headerProbe);
-  if (!/^#\?RADIANCE/m.test(headerProbe) && !/^#\?RGBE/m.test(headerProbe)) {
-    throw new Error("Production HDR parser requires a Radiance/RGBE header.");
-  }
-  if (!/FORMAT=32-bit_rle_rgbe/.test(headerProbe)) {
-    throw new Error("Production HDR parser requires FORMAT=32-bit_rle_rgbe.");
-  }
-  if (!resolutionMatch || resolutionMatch.index === undefined) {
-    throw new Error("Production HDR parser could not find -Y +X resolution.");
-  }
-  const height = Number(resolutionMatch[2]);
-  const width = Number(resolutionMatch[3]);
-  if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
-    throw new Error("Production HDR parser found invalid dimensions.");
-  }
-  const dataOffset = resolutionMatch.index + resolutionMatch[0].length;
-  const rgbe = decodeRadianceRle(bytes.subarray(dataOffset), width, height);
-  return {
-    width,
-    height,
-    rgbe,
-    header: headerProbe.slice(0, dataOffset),
-    format: "32-bit_rle_rgbe"
-  };
-}
-
-export function createProductionPbrHdrPipelineFromRadiance(
-  buffer: ArrayBuffer | Uint8Array,
-  options: ProductionPbrHdrPipelineOptions
-): ProductionPbrHdrPipeline {
-  const radiance = parseProductionRadianceHDR(buffer);
-  const rgbeSource: RgbeEnvironmentMapSource = {
-    width: radiance.width,
-    height: radiance.height,
-    data: radiance.rgbe
-  };
-  const linear = decodeRgbeEnvironmentMap(rgbeSource);
-  const toneMapping = createProductionToneMappingPolicy(options.toneMapping);
-  const resources = createEnvironmentMapResourceSet({ ...rgbeSource, encoding: "rgbe" }, {
-    textureEncoding: "rgbe",
-    outputColorSpace: toneMapping.outputColorSpace,
-    exposure: toneMapping.exposure,
-    toneMapping: environmentToneMappingOperator(toneMapping.operator),
-    specularLevels: options.specularLevels ?? 9,
-    specularBlurRadius: 3,
-    irradianceWidth: options.irradianceWidth ?? 32,
-    irradianceHeight: options.irradianceHeight ?? 16,
-    irradianceBlurRadius: 12,
-    brdfLutSize: options.brdfLutSize ?? 64,
-    brdfLutSampleCount: options.brdfLutSampleCount
-  });
-  const environmentMipLevels = generateRgba16fSpecularPrefilterMipLevels(linear, {
-    levels: resources.specularMipLevels.length,
-    sampleCount: options.specularSampleCount ?? 16
-  });
-  const cubemapPMREM = generateCubemapPMREMResources(linear, {
-    faceSize: options.cubemapFaceSize ?? 128,
-    mipCount: options.cubemapMipCount,
-    sampleCount: options.cubemapSampleCount ?? 32
-  });
-  const cubemapPMREMShaderContract = createCubemapPMREMShaderContract(cubemapPMREM);
-  const textureBytes = environmentMipLevels.reduce((total, level) => total + level.data.byteLength, 0)
-    + cubemapPMREM.diagnostics.totalByteLength
-    + resources.brdfLut.data.byteLength
-    + resources.diffuseIrradiance.data.byteLength;
-  return {
-    id: options.id,
-    label: options.label,
-    radiance,
-    linear,
-    resources,
-    environmentMipLevels,
-    cubemapPMREM,
-    cubemapPMREMShaderContract,
-    toneMapping,
-    intensity: options.intensity ?? 1,
-    backgroundIntensity: options.backgroundIntensity ?? 0.8,
-    rotation: options.rotation ?? 0,
-    diagnostics: {
-      realRadianceHdr: true,
-      environmentTextureEncoding: "rgba16f-linear",
-      environmentTextureFormat: "rgba16f",
-      hdrPixelCount: radiance.width * radiance.height,
-      maxLinearValue: resources.diagnostics.maxLinearValue,
-      diffuseIrradiance: resources.diffuseIrradiance.width > 0 && resources.diffuseIrradiance.height > 0,
-      diffuseIrradianceModel: "cosine-weighted-hemisphere",
-      specularPrefilter: resources.specularMipLevels.length >= 4,
-      specularPrefilterModel: "ggx-importance-sampled",
-      cubemapPMREM: cubemapPMREM.levels.length > 0 && cubemapPMREM.levels.every((level) => level.faces.length === 6),
-      cubemapPMREMModel: "equirectangular-to-cubemap-ggx-importance-sampled-prefilter",
-      cubemapPMREMShaderSampling: "webgl2-sampler-cube",
-      cubemapPMREMShaderContract: "webgl2-sampler-cube-split-sum",
-      cubemapFaceSize: cubemapPMREM.faceSize,
-      cubemapMipCount: cubemapPMREM.mipCount,
-      brdfLut: resources.brdfLut.width > 0 && resources.brdfLut.height > 0,
-      specularMipCount: resources.specularMipLevels.length,
-      textureBytes
-    }
-  };
-}
-
-export function createProductionEnvironmentLightingResources(
-  pipeline: ProductionPbrHdrPipeline
-): ProductionEnvironmentLightingResources {
-  const environmentTexture = new Texture({
-    width: pipeline.resources.base.width,
-    height: pipeline.resources.base.height,
-    format: "rgba16f",
-    colorSpace: "linear",
-    label: `production-runtime-${pipeline.id}-pmrem`,
-    mipLevels: pipeline.environmentMipLevels
-  });
-  const brdfLutTexture = new Texture({
-    width: pipeline.resources.brdfLut.width,
-    height: pipeline.resources.brdfLut.height,
-    colorSpace: "linear",
-    label: `production-runtime-${pipeline.id}-brdf-lut`,
-    data: pipeline.resources.brdfLut.data
-  });
-  const environmentCubeTexture = new Texture({
-    width: pipeline.cubemapPMREM.faceSize,
-    height: pipeline.cubemapPMREM.faceSize,
-    dimension: "cube",
-    format: "rgba16f",
-    colorSpace: "linear",
-    label: `production-runtime-${pipeline.id}-cubemap-pmrem`,
-    cubeFaces: CUBE_TEXTURE_FACES.map((face) => ({
-      face,
-      mipLevels: pipeline.cubemapPMREM.levels.map((level) => {
-        const faceLevel = level.faces.find((candidate) => candidate.face === face);
-        if (!faceLevel) {
-          throw new Error(`Missing cubemap PMREM face ${face} at mip ${level.mip}`);
-        }
-        return {
-          width: faceLevel.width,
-          height: faceLevel.height,
-          data: faceLevel.data
-        };
-      })
-    }))
-  });
-  return {
-    environmentTexture,
-    environmentCubeTexture,
-    brdfLutTexture,
-    lighting: {
-      color: [1, 1, 1],
-      intensity: 0.08,
-      proceduralMap: {
-        skyColor: [0.2, 0.24, 0.32],
-        horizonColor: [0.22, 0.2, 0.18],
-        groundColor: [0.03, 0.035, 0.045],
-        specularColor: [1, 1, 1],
-        intensity: 0.06,
-        specularIntensity: 0.1
-      },
-      environmentMapTexture: new TextureBinding({
-        name: "u_environmentMapTexture",
-        texture: environmentTexture,
-        sampler: new Sampler({ minFilter: "linear-mipmap-linear", magFilter: "linear", addressU: "repeat", addressV: "clamp-to-edge" }),
-        expectedColorSpace: "linear"
-      }),
-      environmentCubeMapTexture: new TextureBinding({
-        name: "u_environmentCubeMapTexture",
-        texture: environmentCubeTexture,
-        sampler: new Sampler({ minFilter: "linear-mipmap-linear", magFilter: "linear", addressU: "clamp-to-edge", addressV: "clamp-to-edge" }),
-        expectedColorSpace: "linear"
-      }),
-      environmentMapIntensity: pipeline.intensity,
-      environmentMapSpecularIntensity: pipeline.intensity * 0.38,
-      environmentMapRotation: pipeline.rotation,
-      environmentMapMipCount: pipeline.cubemapPMREM.mipCount,
-      environmentMapEncoding: "linear",
-      environmentBrdfLutTexture: new TextureBinding({
-        name: "u_environmentBrdfLutTexture",
-        texture: brdfLutTexture,
-        sampler: new Sampler({ minFilter: "linear", magFilter: "linear", addressU: "clamp-to-edge", addressV: "clamp-to-edge" }),
-        expectedColorSpace: "linear"
-      })
-    },
-    dispose: () => {
-      environmentTexture.dispose();
-      environmentCubeTexture.dispose();
-      brdfLutTexture.dispose();
-    }
-  };
-}
-
-export function createProductionToneMappingPolicy(overrides: Partial<ProductionToneMappingPolicy> = {}): ProductionToneMappingPolicy {
-  const policy = { ...DEFAULT_TONE_MAPPING, ...overrides };
-  if (!Number.isFinite(policy.exposure) || policy.exposure < 0) {
-    throw new RangeError("Production tone mapping exposure must be finite and non-negative.");
-  }
-  if (!Number.isFinite(policy.whitePoint) || policy.whitePoint <= 0) {
-    throw new RangeError("Production tone mapping whitePoint must be finite and positive.");
-  }
-  return policy;
-}
-
-function environmentToneMappingOperator(operator: ProductionToneMappingOperator): EnvironmentToneMappingOperator {
-  return operator === "linear" ? "linear" : "reinhard";
-}
-
-function decodeRadianceRle(data: Uint8Array, width: number, height: number): Uint8Array {
-  const output = new Uint8Array(width * height * 4);
-  let offset = 0;
-  for (let y = 0; y < height; y += 1) {
-    if (offset + 4 > data.length) {
-      throw new Error(`Production HDR scanline ${y} is truncated.`);
-    }
-    const b0 = data[offset] ?? 0;
-    const b1 = data[offset + 1] ?? 0;
-    const b2 = data[offset + 2] ?? 0;
-    const b3 = data[offset + 3] ?? 0;
-    if (width >= 8 && width < 32768 && b0 === 2 && b1 === 2 && (b2 & 0x80) === 0) {
-      const scanlineWidth = (b2 << 8) | b3;
-      if (scanlineWidth !== width) {
-        throw new Error(`Production HDR scanline ${y} width ${scanlineWidth} does not match ${width}.`);
-      }
-      offset += 4;
-      const scanline = new Uint8Array(width * 4);
-      for (let channel = 0; channel < 4; channel += 1) {
-        let x = 0;
-        while (x < width) {
-          const count = data[offset++];
-          if (count === undefined) {
-            throw new Error(`Production HDR scanline ${y} channel ${channel} is truncated.`);
-          }
-          if (count === 0) {
-            throw new Error(`Production HDR scanline ${y} channel ${channel} has invalid zero run length.`);
-          }
-          if (count > 128) {
-            const runLength = count - 128;
-            if (x + runLength > width) {
-              throw new Error(`Production HDR scanline ${y} channel ${channel} run exceeds width ${width}.`);
-            }
-            const value = data[offset++];
-            if (value === undefined) {
-              throw new Error(`Production HDR scanline ${y} channel ${channel} run is truncated.`);
-            }
-            for (let index = 0; index < runLength; index += 1) {
-              scanline[(x + index) * 4 + channel] = value;
-            }
-            x += runLength;
-          } else {
-            if (x + count > width) {
-              throw new Error(`Production HDR scanline ${y} channel ${channel} literal exceeds width ${width}.`);
-            }
-            for (let index = 0; index < count; index += 1) {
-              const value = data[offset++];
-              if (value === undefined) {
-                throw new Error(`Production HDR scanline ${y} channel ${channel} literal is truncated.`);
-              }
-              scanline[(x + index) * 4 + channel] = value;
-            }
-            x += count;
-          }
-        }
-      }
-      output.set(scanline, y * width * 4);
-    } else {
-      const byteLength = width * 4;
-      if (offset + byteLength > data.length) {
-        throw new Error(`Production HDR scanline ${y} is truncated.`);
-      }
-      output.set(data.subarray(offset, offset + byteLength), y * byteLength);
-      offset += byteLength;
-    }
-  }
-  return output;
-}

package/src/production-runtime/ProductionEffectsPipeline.ts

@@ -1,85 +0,0 @@
-import type { RenderSource, RendererPostProcessOptions, RendererShadowOptions } from "../Renderer";
-import type { ProductionRenderProof } from "./ProductionRendererTypes";
-
-export interface ProductionEffectsOptions {
-  readonly shadow?: RendererShadowOptions | boolean;
-  readonly postprocess?: RendererPostProcessOptions | boolean;
-  readonly transparentItemCount?: number;
-}
-
-export interface ProductionEffectsSummary {
-  readonly pass: boolean;
-  readonly shadowProof: boolean;
-  readonly transparencyProof: boolean;
-  readonly postprocessProof: boolean;
-  readonly drawCalls: number;
-  readonly nonBlackPixels: number;
-  readonly uniqueColorBuckets: number;
-  readonly failures: readonly string[];
-}
-
-export function createProductionEffectsRenderSource(source: RenderSource, options: ProductionEffectsOptions = {}): RenderSource {
-  return {
-    ...source,
-    shadow: options.shadow ?? {
-      enabled: true,
-      size: 512,
-      bias: 0.0008,
-      strength: 0.48,
-      filter: "pcf",
-      pcfRadius: 1.25,
-      pcfSamples: 9
-    },
-    postprocess: options.postprocess ?? {
-      targetFormat: "rgba8",
-      toneMapping: {
-        operator: "filmic",
-        exposure: 1.08,
-        whitePoint: 1.18,
-        inputColorSpace: "linear",
-        outputColorSpace: "srgb"
-      },
-      colorGrade: {
-        contrast: 1.08,
-        saturation: 1.06,
-        vibrance: 0.08,
-        vignette: 0.12,
-        sharpening: 0.24
-      },
-      bloom: {
-        threshold: 0.84,
-        intensity: 0.08,
-        radius: 1
-      },
-      fxaa: {
-        edgeThreshold: 0.08,
-        subpixelBlend: 0.55
-      }
-    }
-  };
-}
-
-export function summarizeProductionEffectsProof(proof: ProductionRenderProof, options: ProductionEffectsOptions = {}): ProductionEffectsSummary {
-  const shadowProof = proof.diagnostics.drawCalls >= 2;
-  const transparencyProof = (options.transparentItemCount ?? 0) > 0;
-  const postprocessProof = proof.pixels.uniqueColorBuckets > 12 && proof.pixels.maxLuma > 40;
-  const failures = [
-    ...(!proof.realWebGL2 ? ["not a real WebGL2 proof"] : []),
-    ...(proof.mockDevice ? ["mock renderer was used"] : []),
-    ...(proof.canvas2dProof ? ["Canvas 2D proof was used"] : []),
-    ...(!shadowProof ? ["shadow pass did not add draw-call evidence"] : []),
-    ...(!transparencyProof ? ["transparent item ordering was not declared"] : []),
-    ...(!postprocessProof ? ["postprocess pixel metrics are too weak"] : []),
-    ...(proof.pixels.nonBlackPixels <= 1000 ? ["visible pixel count is too low"] : [])
-  ];
-  return {
-    pass: failures.length === 0,
-    shadowProof,
-    transparencyProof,
-    postprocessProof,
-    drawCalls: proof.diagnostics.drawCalls,
-    nonBlackPixels: proof.pixels.nonBlackPixels,
-    uniqueColorBuckets: proof.pixels.uniqueColorBuckets,
-    failures
-  };
-}

package/src/production-runtime/ProductionRendererTypes.ts

@@ -1,136 +0,0 @@
-import type { CameraLike, RenderSource } from "../Renderer";
-import type { RenderDeviceDiagnostics } from "../RenderDevice";
-
-export type ProductionRendererBackend = "webgl2" | "webgpu";
-export type ProductionRendererFeatureState = "supported" | "partial" | "blocked";
-
-export interface ProductionRendererFeature {
-  readonly id: string;
-  readonly state: ProductionRendererFeatureState;
-  readonly detail: string;
-}
-
-export interface ProductionImportedAssetRenderMetadata {
-  readonly assetId: string;
-  readonly assetUri: string;
-  readonly assetName?: string;
-  readonly meshCount: number;
-  readonly primitiveCount: number;
-  readonly materialCount: number;
-  readonly textureCount: number;
-  readonly imageCount: number;
-  readonly animationCount: number;
-  readonly skinCount: number;
-  readonly morphTargetCount: number;
-  readonly extensionsUsed: readonly string[];
-  readonly environmentId?: string;
-  readonly hdrEnvironmentUri?: string;
-}
-
-export interface ProductionRendererInput {
-  readonly source: RenderSource;
-  readonly camera?: CameraLike;
-  readonly metadata: ProductionImportedAssetRenderMetadata;
-  readonly transmissionBackdropCapture?: false | RuntimeParityTransmissionBackdropCaptureOptions;
-}
-
-export interface RuntimeParityTransmissionBackdropCaptureOptions {
-  readonly mode?: "scene-color-readback";
-  readonly strength?: number;
-  readonly refractionScale?: number;
-}
-
-export interface RuntimeParityTransmissionBackdropCaptureProof {
-  readonly mode: "renderer-owned-scene-color-readback";
-  readonly width: number;
-  readonly height: number;
-  readonly byteLength: number;
-  readonly mipCount: number;
-  readonly strength: number;
-  readonly refractionScale: number;
-  readonly materialBindings: number;
-}
-
-export interface ProductionPixelMetrics {
-  readonly width: number;
-  readonly height: number;
-  readonly nonTransparentPixels: number;
-  readonly nonBlackPixels: number;
-  readonly averageLuma: number;
-  readonly maxLuma: number;
-  readonly uniqueColorBuckets: number;
-  readonly centerPixel: readonly [number, number, number, number];
-}
-
-export interface CurrentRoutesRendererTimingDiagnostics {
-  readonly source: "performance-now" | "date-now";
-  readonly totalMs: number;
-  readonly renderMs: number;
-  readonly readbackMs?: number;
-  readonly pixelAnalysisMs?: number;
-  readonly transmissionBackdropCaptureMs?: number;
-}
-
-export interface ProductionRenderProof {
-  readonly backend: ProductionRendererBackend;
-  readonly realWebGL2: boolean;
-  readonly mockDevice: boolean;
-  readonly canvas2dProof: boolean;
-  readonly importedAsset: ProductionImportedAssetRenderMetadata;
-  readonly diagnostics: RenderDeviceDiagnostics;
-  readonly features: readonly ProductionRendererFeature[];
-  readonly pixels: ProductionPixelMetrics;
-  readonly timing?: CurrentRoutesRendererTimingDiagnostics;
-  readonly transmissionBackdropCapture?: RuntimeParityTransmissionBackdropCaptureProof;
-}
-
-export interface RuntimeParityFrameRenderResult {
-  readonly backend: ProductionRendererBackend;
-  readonly diagnostics: RenderDeviceDiagnostics;
-  readonly features: readonly ProductionRendererFeature[];
-  readonly timing?: CurrentRoutesRendererTimingDiagnostics;
-}
-
-export interface ProductionProductionRenderer {
-  readonly backend: ProductionRendererBackend;
-  renderFrame(input: ProductionRendererInput): RuntimeParityFrameRenderResult;
-  renderImportedAsset(input: ProductionRendererInput): ProductionRenderProof;
-  getFeatures(): readonly ProductionRendererFeature[];
-  getDiagnostics(): RenderDeviceDiagnostics;
-  dispose(): void;
-}
-
-export interface CurrentRoutesProductionRenderer extends ProductionProductionRenderer {
-  renderInteractiveFrame(input: ProductionRendererInput): RuntimeParityFrameRenderResult;
-  captureProof(input: ProductionRendererInput): ProductionRenderProof;
-}
-
-export const PRODUCTION_WEBGL2_REQUIRED_FEATURES = [
-  "real-webgl2-context",
-  "no-canvas2d-proof",
-  "no-mock-device",
-  "imported-gltf-render-source",
-  "pbr-materials",
-  "texture-upload-diagnostics",
-  "render-target-diagnostics",
-  "draw-call-diagnostics",
-  "pixel-readback",
-  "hdr-ibl-ready"
-] as const;
-
-export const RUNTIME_PARITY_WEBGPU_REQUIRED_FEATURES = [
-  "real-webgpu-context",
-  "no-canvas2d-proof",
-  "no-mock-device",
-  "imported-gltf-render-source",
-  "pbr-materials",
-  "texture-upload-diagnostics",
-  "render-target-diagnostics",
-  "draw-call-diagnostics",
-  "pixel-readback",
-  "hdr-ibl-ready",
-  "native-webgpu-render-pipeline",
-  "native-webgpu-sampled-textures",
-  "native-webgpu-texture-readback",
-  "native-webgpu-pbr-submissions"
-] as const;