@forgeax/engine-render 0.1.28 → 0.1.30

package/src/pipeline/render-extent.ts

@@ -0,0 +1,111 @@
+/** Immutable dimensions shared by every Standard graph consumer. */
+export interface RenderExtent {
+  readonly outputWidth: number;
+  readonly outputHeight: number;
+  readonly internalWidth: number;
+  readonly internalHeight: number;
+  readonly scale: number;
+  readonly generation: number;
+}
+
+export interface RenderExtentInput {
+  readonly outputWidth: number;
+  readonly outputHeight: number;
+  readonly requestedScale: number;
+  readonly generation: number;
+}
+
+export type RenderExtentDomain = 'internal' | 'output' | 'authoring';
+
+/** Project the immutable extent into a graph texture descriptor size. */
+export function renderExtentSize(
+  extent: RenderExtent,
+  domain: RenderExtentDomain,
+): { readonly width: number; readonly height: number } {
+  if (domain === 'internal') {
+    return { width: extent.internalWidth, height: extent.internalHeight };
+  }
+  return { width: extent.outputWidth, height: extent.outputHeight };
+}
+
+export type StandardLightingLane = 'direct' | 'clustered' | 'cpu-webgl2';
+
+export interface StandardExtentDomainPlan {
+  readonly extent: RenderExtent;
+  readonly lane: StandardLightingLane;
+  readonly topologyKey: string;
+  readonly dynamicDelta: 0 | 1;
+  readonly domains: {
+    readonly internal: { readonly width: number; readonly height: number };
+    readonly output: { readonly width: number; readonly height: number };
+    readonly authoring: { readonly width: number; readonly height: number };
+  };
+  readonly resources: readonly {
+    readonly name: string;
+    readonly domain: 'internal' | 'output' | 'authoring';
+  }[];
+}
+
+const MIN_SCALE = 0.5;
+const MAX_SCALE = 1;
+const SCALE_STEPS = 32;
+const AXIS_ALIGNMENT = 8;
+
+function alignedAxis(output: number, scale: number): number {
+  return Math.max(AXIS_ALIGNMENT, Math.floor((output * scale) / AXIS_ALIGNMENT) * AXIS_ALIGNMENT);
+}
+
+function finiteDimension(value: number): number {
+  return Math.max(1, Math.floor(value));
+}
+
+/** Derive the one immutable Standard extent before graph construction. */
+export function deriveRenderExtent(input: RenderExtentInput): RenderExtent {
+  const outputWidth = finiteDimension(input.outputWidth);
+  const outputHeight = finiteDimension(input.outputHeight);
+  const clamped = Math.min(MAX_SCALE, Math.max(MIN_SCALE, input.requestedScale));
+  const scale = Math.round(clamped * SCALE_STEPS) / SCALE_STEPS;
+  const nativeSurface = outputWidth < AXIS_ALIGNMENT || outputHeight < AXIS_ALIGNMENT;
+  const internalWidth = nativeSurface ? outputWidth : alignedAxis(outputWidth, scale);
+  const internalHeight = nativeSurface ? outputHeight : alignedAxis(outputHeight, scale);
+  return Object.freeze({
+    outputWidth,
+    outputHeight,
+    internalWidth,
+    internalHeight,
+    scale: nativeSurface ? 1 : scale,
+    generation: input.generation,
+  });
+}
+
+/** Describe Standard's shared internal/output/authoring domain assignment. */
+export function standardExtentDomainPlan(
+  extent: RenderExtent,
+  lane: StandardLightingLane,
+): StandardExtentDomainPlan {
+  const domains = {
+    internal: { width: extent.internalWidth, height: extent.internalHeight },
+    output: { width: extent.outputWidth, height: extent.outputHeight },
+    authoring: { width: extent.outputWidth, height: extent.outputHeight },
+  } as const;
+  return Object.freeze({
+    extent,
+    lane,
+    topologyKey: `standard:${extent.internalWidth}x${extent.internalHeight}:${extent.outputWidth}x${extent.outputHeight}:g${extent.generation}`,
+    dynamicDelta: extent.scale === 1 ? 0 : 1,
+    domains,
+    resources: Object.freeze([
+      { name: 'scene', domain: 'internal' },
+      { name: 'depth', domain: 'internal' },
+      { name: 'g-buffer', domain: 'internal' },
+      { name: 'scene-temporal', domain: 'internal' },
+      { name: 'ssao', domain: 'internal' },
+      { name: 'taa-history', domain: 'output' },
+      { name: 'bloom', domain: 'output' },
+      { name: 'output', domain: 'output' },
+      { name: 'overlay', domain: 'output' },
+      { name: 'observation', domain: 'output' },
+      { name: 'shadow', domain: 'authoring' },
+    ] satisfies StandardExtentDomainPlan['resources']),
+  });
+}

package/src/pipeline/standard-build-context.ts

@@ -0,0 +1,7 @@
+import type { RenderPipelineBuildContext, RenderPipelineFrame } from '../render-pipeline';
+import type { TargetCoverageAttachment } from '../temporal/target-coverage-attachment';
+
+/** Standard-only graph input; custom pipeline consumers never see coverage. */
+export type StandardPipelineBuildContext = RenderPipelineBuildContext<RenderPipelineFrame> & {
+  readonly targetCoverage?: TargetCoverageAttachment;
+};

package/src/pipeline/standard-forward-lane.ts

@@ -4,6 +4,7 @@ import type {
   RenderGraphError,
 } from '@forgeax/engine-render-graph';
 import { err, ok, type Result } from '@forgeax/engine-types';
+import { addAtmosphereBackground } from '../environment/background';
 import { SceneDataUnavailableError } from '../errors/render';
 import {
   GPU_TEXTURE_USAGE_COPY_SRC,
@@ -12,7 +13,6 @@ import {
 } from '../gpu-texture-usage';
 import type {
   RenderPipeline,
-  RenderPipelineBuildContext,
   RenderPipelineFrame,
   RenderPipelineTopology,
 } from '../render-pipeline';
@@ -27,6 +27,7 @@ import {
   createStandardSceneDataTarget,
   standardTemporalLaneAdmission,
 } from '../temporal/standard-scene-data';
+import { addTargetCoveragePass } from '../temporal/target-coverage-attachment';
 import {
   addTransmissionBackdropPasses,
   addTransmissionBackdropTemporalPass,
@@ -41,6 +42,8 @@ import {
 } from '../typed-render-graph-primitives';
 import { addTypedShadowPasses } from '../typed-shadow-passes';
 import { addAuthoredVolumetricFogPasses } from '../volume/passes';
+import { renderExtentSize } from './render-extent';
+import type { StandardPipelineBuildContext } from './standard-build-context';
 import {
   addStandardClusterMembershipPass,
   importStandardClusterBuffers,
@@ -58,7 +61,7 @@ function target(
 }
 
 function buildUrp(
-  context: RenderPipelineBuildContext<RenderPipelineFrame>,
+  context: StandardPipelineBuildContext,
   topology: RenderPipelineTopology,
   lighting: StandardTopologyInputValue,
 ): ReturnType<RenderPipeline['build']> {
@@ -66,6 +69,9 @@ function buildUrp(
   const surface = importRenderPipelineSurface(graph, topology);
   if (!surface.ok) return surface;
 
+  const internalSize =
+    topology.extent === undefined ? 'surface' : renderExtentSize(topology.extent, 'internal');
+
   const clearOnly = topology.clearOnly === true;
   const msaa = !clearOnly && topology.camera.antialias === 'msaa' && topology.lane.multisample;
   const hdr =
@@ -93,7 +99,7 @@ function buildUrp(
 
   const depth = target(graph, 'scene-depth', {
     format: 'depth24plus-stencil8',
-    size: 'surface',
+    size: internalSize,
     sampleCount: msaa ? 4 : 1,
   });
   if (!depth.ok) return depth;
@@ -110,7 +116,7 @@ function buildUrp(
     : hdr || fxaa || linearLdr || msaa || rawOnly || needsTemporalIntermediate
       ? target(graph, 'scene-color', {
           format: sceneFormat,
-          size: 'surface',
+          size: internalSize,
           sampleCount: 1,
           domain: 'linear-ldr',
           ...(sceneFormat === topology.surface.storageFormat &&
@@ -130,7 +136,7 @@ function buildUrp(
   const scene = msaa
     ? target(graph, 'scene-color-msaa', {
         format: sceneFormat,
-        size: 'surface',
+        size: internalSize,
         sampleCount: 4,
         domain: 'linear-ldr',
         ...(sceneFormat === topology.surface.storageFormat &&
@@ -144,7 +150,7 @@ function buildUrp(
   const reflectionFallback = topology.reflectionFallback?.enabled
     ? target(graph, 'reflection-fallback-linear-hdr', {
         format: 'rgba16float',
-        size: 'surface',
+        size: internalSize,
         sampleCount: scene.value.sampleCount,
         domain: 'linear-hdr',
         usage:
@@ -170,7 +176,14 @@ function buildUrp(
     if (!initialized.ok) return initialized;
   }
 
-  const shadows = addTypedShadowPasses(graph, topology);
+  const featureShadows = context.contributeShadowFeatures?.();
+  if (featureShadows !== undefined && !featureShadows.ok) return featureShadows;
+  const shadows = addTypedShadowPasses(
+    graph,
+    topology,
+    context.projectGpuDrivenShadow,
+    featureShadows?.value,
+  );
   if (!shadows.ok) return shadows;
 
   const clusterBuffers = clearOnly ? ok(null) : importStandardClusterBuffers(graph, lighting);
@@ -183,11 +196,21 @@ function buildUrp(
   const clusterReads =
     clusterBuffers.value === null ? [] : standardClusterReadAccesses(clusterBuffers.value);
 
-  const skybox = addTypedSkyboxPass(graph, scene.value);
-  if (!skybox.ok) return skybox;
+  const atmosphere =
+    topology.atmosphere === true ? addAtmosphereBackground(graph, scene.value) : ok(undefined);
+  if (!atmosphere.ok) return atmosphere;
+  if (atmosphere.value === undefined) {
+    const skybox = addTypedSkyboxPass(graph, scene.value);
+    if (!skybox.ok) return skybox;
+  }
   const gpuDriven = context.projectGpuDriven({
     format: scene.value.format,
     sampleCount: scene.value.sampleCount,
+    ...(reflectionFallback.value === undefined
+      ? {}
+      : {
+          additionalColorFormats: [reflectionFallback.value.format],
+        }),
   });
   if (!gpuDriven.ok) return gpuDriven;
   const transmissionDemand = transmissionDemandForTopology(topology);
@@ -196,6 +219,7 @@ function buildUrp(
     sourceSampleCount: scene.value.sampleCount,
   }).active;
   const main = addTypedScenePass(graph, {
+    environment: atmosphere.value,
     name: 'main',
     color: scene.value,
     ...(reflectionFallback.value === undefined
@@ -247,12 +271,18 @@ function buildUrp(
     );
   }
   const temporal =
-    temporalDemand.targetCount === 1 ? createStandardSceneDataTarget(graph) : ok(undefined);
+    temporalDemand.targetCount === 1
+      ? createStandardSceneDataTarget(graph, topology.extent)
+      : ok(undefined);
   if (!temporal.ok) return temporal;
   if (temporal.value !== undefined) {
     const producer = addStandardSceneDataPass(graph, temporal.value.temporal, depth.value);
     if (!producer.ok) return producer;
   }
+  if (context.targetCoverage !== undefined) {
+    const coverage = addTargetCoveragePass(graph, context.targetCoverage);
+    if (!coverage.ok) return coverage;
+  }
 
   const transmission = addTransmissionBackdropPasses({
     graph,
@@ -265,6 +295,7 @@ function buildUrp(
   if (!transmission.ok) return transmission;
   if (transmission.value.topology.active) {
     const transmissionPass = addTypedScenePass(graph, {
+      environment: atmosphere.value,
       name: 'transmission-forward',
       color: scene.value,
       depth: depth.value,
@@ -289,6 +320,7 @@ function buildUrp(
     if (!transmissionPass.ok) return transmissionPass;
 
     const transparentPass = addTypedScenePass(graph, {
+      environment: atmosphere.value,
       name: 'transparent',
       color: scene.value,
       depth: depth.value,
@@ -330,24 +362,34 @@ function buildUrp(
     if (!volume.ok) return volume;
   }
 
-  const features = context.contributeFeatures([
-    {
-      name: 'linear-hdr',
-      kind: 'scene-color',
-      texture: scene.value.texture,
-      view: scene.value.view,
-      ...(msaa ? { resolveTarget: sceneResolved.value.view } : {}),
-      format: scene.value.format,
-      sampleCount: scene.value.sampleCount,
-    },
-    {
-      kind: 'scene-depth',
-      texture: depth.value.texture,
-      view: depth.value.view,
-      format: depth.value.format,
-      sampleCount: depth.value.sampleCount,
-    },
-  ]);
+  const features = context.contributeFeatures(
+    [
+      {
+        name: 'linear-hdr',
+        kind: 'scene-color',
+        texture: scene.value.texture,
+        view: scene.value.view,
+        ...(msaa ? { resolveTarget: sceneResolved.value.view } : {}),
+        format: scene.value.format,
+        sampleCount: scene.value.sampleCount,
+      },
+      {
+        kind: 'scene-depth',
+        texture: depth.value.texture,
+        view: depth.value.view,
+        format: depth.value.format,
+        sampleCount: depth.value.sampleCount,
+      },
+    ],
+    [],
+    {},
+    [
+      ...clusterReads,
+      ...[shadows.value.directional, shadows.value.spot, shadows.value.point].flatMap((target) =>
+        target === undefined ? [] : [{ resource: target.view, usage: 'sampled-read' as const }],
+      ),
+    ],
+  );
   if (!features.ok) return features;
 
   if (hdr || linearLdr || rawOnly) {
@@ -373,9 +415,12 @@ function buildUrp(
     depth.value,
     surface.value,
     temporal.value?.temporal,
+    undefined,
+    context.targetCoverage?.coverage,
+    context.targetCoverage?.depth,
   );
   if (!post.ok) return post;
-  const cubeCaptures = context.contributeCubeCaptures?.();
+  const cubeCaptures = context.contributeCubeCaptures?.(atmosphere.value);
   if (cubeCaptures !== undefined && !cubeCaptures.ok) return cubeCaptures;
   return ok(undefined);
 }

package/src/pipeline/standard-output/__tests__/lut-admission.unit.test.ts

@@ -0,0 +1,103 @@
+import type { TextureAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import {
+  admitStandardColorLut,
+  createStandardLutSamplerDescriptor,
+  lutTexelCenter,
+  type StandardColorLutAdmissionInput,
+} from '../lut-admission';
+
+function texture(overrides: Partial<TextureAsset> = {}): TextureAsset {
+  return {
+    kind: 'texture',
+    shape: { viewDimension: '3d', extent: { width: 16, height: 16, depth: 16 } },
+    format: 'rgba16float',
+    data: new Uint8Array(16 * 16 * 16 * 8),
+    colorSpace: 'linear',
+    mips: { kind: 'none' },
+    ...overrides,
+  };
+}
+
+function input(overrides: Partial<StandardColorLutAdmissionInput> = {}) {
+  return {
+    texture: texture(),
+    maxTextureDimension3D: 2048,
+    rgba16floatFilterable: true,
+    bind: () => true,
+    ...overrides,
+  } satisfies StandardColorLutAdmissionInput;
+}
+
+describe('Standard output 3D LUT admission', () => {
+  it('accepts a linear, equal-extent, single-mip rgba16float texture', () => {
+    const result = admitStandardColorLut(input());
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.viewDimension).toBe('3d');
+    expect(result.value.extent).toEqual({ width: 16, height: 16, depth: 16 });
+    expect(result.value.sampler).toEqual(createStandardLutSamplerDescriptor());
+  });
+
+  it.each([
+    ['view dimension', { shape: { viewDimension: '2d', extent: { width: 16, height: 16 } } }],
+    [
+      'unequal extent',
+      { shape: { viewDimension: '3d', extent: { width: 16, height: 17, depth: 16 } } },
+    ],
+    ['format', { format: 'rgba32float' }],
+    ['color space', { colorSpace: 'srgb' }],
+    ['mip policy', { mips: { kind: 'generate' } }],
+  ] as const)('rejects invalid %s', (_name, overrides) => {
+    const result = admitStandardColorLut(input({ texture: texture(overrides as never) }));
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe('standard-lut-shape-invalid');
+  });
+
+  it('rejects dimensions over the live 3D limit', () => {
+    const result = admitStandardColorLut(
+      input({
+        texture: texture({
+          shape: { viewDimension: '3d', extent: { width: 4096, height: 4096, depth: 4096 } },
+        }),
+        maxTextureDimension3D: 2048,
+      }),
+    );
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe('standard-lut-limit-exceeded');
+  });
+
+  it('does not infer rgba16float filterability from float32 filterability', () => {
+    const result = admitStandardColorLut(input({ rgba16floatFilterable: false }));
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe('standard-lut-filter-unavailable');
+  });
+
+  it('requires a successful live bind probe', () => {
+    const result = admitStandardColorLut(input({ bind: () => false }));
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe('standard-lut-bind-failed');
+  });
+
+  it('uses texel centers and clamp-to-edge linear filtering', () => {
+    expect(lutTexelCenter(0, 16)).toBe(0.5 / 16);
+    expect(lutTexelCenter(15, 16)).toBe(15.5 / 16);
+    expect(createStandardLutSamplerDescriptor()).toEqual({
+      addressModeU: 'clamp-to-edge',
+      addressModeV: 'clamp-to-edge',
+      addressModeW: 'clamp-to-edge',
+      magFilter: 'linear',
+      minFilter: 'linear',
+      mipmapFilter: 'nearest',
+    });
+  });
+});

package/src/pipeline/standard-output/auto-exposure/__tests__/capability.unit.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+import { resolveAutoExposureCapability } from '../capability';
+
+const complete = {
+  compute: true,
+  storageBuffer: true,
+  float32Filterable: true,
+  rgba16floatRenderable: true,
+};
+
+describe('auto exposure capability contract', () => {
+  it('requires live compute, storage, and float filtering facts', () => {
+    expect(resolveAutoExposureCapability(complete, 8)).toMatchObject({
+      ok: true,
+      value: { available: true, generation: 8 },
+    });
+    expect(resolveAutoExposureCapability({ ...complete, compute: false }, 8)).toMatchObject({
+      ok: false,
+      error: { code: 'auto-exposure-capability-unavailable', detail: { capability: 'compute' } },
+    });
+    expect(
+      resolveAutoExposureCapability({ ...complete, float32Filterable: false }, 8),
+    ).toMatchObject({
+      ok: false,
+      error: {
+        code: 'auto-exposure-capability-unavailable',
+        detail: { capability: 'float-filterable' },
+      },
+    });
+  });
+
+  it('does not infer float filtering from rgba16float renderability', () => {
+    expect(
+      resolveAutoExposureCapability(
+        { ...complete, float32Filterable: false, rgba16floatRenderable: true },
+        9,
+      ),
+    ).toMatchObject({ ok: false, error: { detail: { capability: 'float-filterable' } } });
+  });
+});

package/src/pipeline/standard-output/auto-exposure/__tests__/gpu.contract.unit.test.ts

@@ -0,0 +1,125 @@
+import { ok } from '@forgeax/engine-types';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  addAutoExposureExposurePass,
+  addAutoExposureGraphPasses,
+  createAutoExposureApplyWgsl,
+} from '../gpu';
+
+describe('auto exposure GPU pass contract', () => {
+  it('encodes clear, histogram, and adapt in one compute pass with a fixed cohort', () => {
+    type Descriptor = {
+      readonly accesses: readonly unknown[];
+      readonly encode: (context: never) => void;
+    };
+    const passes: Array<{ name: string; kind: string; descriptor: Descriptor }> = [];
+    const graph = {
+      addComputePass: (name: string, descriptor: Descriptor) => {
+        passes.push({ name, kind: 'compute', descriptor });
+        return ok(undefined);
+      },
+    };
+    const result = addAutoExposureGraphPasses(
+      { graph } as never,
+      {
+        source: { view: {} },
+        resources: { histogram: {}, state: {}, candidate: {}, parameters: {} },
+        width: 1080,
+        height: 1920,
+      } as never,
+    );
+
+    expect(result.ok).toBe(true);
+    expect(passes.map(({ name, kind }) => [name, kind])).toEqual([
+      ['auto-exposure-meter', 'compute'],
+    ]);
+    expect(passes[0]?.descriptor.accesses).toEqual([
+      { resource: {}, usage: 'sampled-read' },
+      { resource: {}, usage: 'storage-write' },
+      { resource: {}, usage: 'storage-write' },
+      { resource: {}, usage: 'storage-write' },
+      { resource: {}, usage: 'storage-read' },
+    ]);
+
+    const pipelineNames: string[] = [];
+    const setPipeline = vi.fn((pipeline: { readonly label: string }) => {
+      pipelineNames.push(pipeline.label);
+    });
+    const setBindGroup = vi.fn();
+    const dispatchWorkgroups = vi.fn();
+    const shaderFactory = {
+      createShaderModule: vi.fn(({ label }: { readonly label: string }) => ok({ label })),
+    };
+    const device = {
+      createBindGroupLayout: vi.fn((descriptor: unknown) => ok({ descriptor })),
+      createPipelineLayout: vi.fn((descriptor: unknown) => ok({ descriptor })),
+      createComputePipeline: vi.fn((descriptor: { readonly label: string }) =>
+        ok({ label: descriptor.label }),
+      ),
+      createBindGroup: vi.fn((descriptor: unknown) => ok({ descriptor })),
+    };
+    const encoded = passes[0]?.descriptor.encode({
+      pass: { setPipeline, setBindGroup, dispatchWorkgroups },
+      frame: { runtime: { device, immediateShaderModuleFactory: shaderFactory } },
+      resources: {
+        textureView: () => ok({}),
+        buffer: () => ok({}),
+      },
+    } as never);
+
+    expect(encoded).toBeUndefined();
+    expect(pipelineNames).toEqual([
+      'auto_exposure_clear',
+      'auto_exposure_histogram',
+      'auto_exposure_adapt',
+    ]);
+    expect(dispatchWorkgroups).toHaveBeenCalledTimes(3);
+    expect(dispatchWorkgroups).toHaveBeenNthCalledWith(1, 1, 1, 1);
+    expect(dispatchWorkgroups).toHaveBeenNthCalledWith(2, 4, 8, 1);
+    expect(dispatchWorkgroups).toHaveBeenNthCalledWith(3, 1, 1, 1);
+    expect(setBindGroup).toHaveBeenCalledTimes(1);
+    expect(device.createComputePipeline).toHaveBeenCalledTimes(3);
+  });
+
+  it('routes the same-frame GPU candidate into the exposure consumer', () => {
+    const passes: Array<{ name: string; descriptor: { accesses: readonly unknown[] } }> = [];
+    const graph = {
+      addRasterPass: (name: string, descriptor: { accesses: readonly unknown[] }) => {
+        passes.push({ name, descriptor });
+        return ok(undefined);
+      },
+    };
+    const result = addAutoExposureExposurePass(
+      { graph } as never,
+      { view: {}, format: 'rgba16float' } as never,
+      { view: {}, format: 'rgba16float' } as never,
+      { histogram: {}, state: {}, candidate: {}, parameters: {} } as never,
+    );
+    expect(result.ok).toBe(true);
+    expect(passes).toHaveLength(1);
+    expect(passes[0]).toMatchObject({
+      name: 'standard-exposure-white-balance',
+      descriptor: {
+        accesses: [
+          { resource: {}, usage: 'sampled-read' },
+          { resource: {}, usage: 'storage-read' },
+          { resource: {}, usage: 'color-attachment' },
+        ],
+      },
+    });
+  });
+
+  it('keeps Bradford white balance in the sole linear-HDR consumer and preserves alpha', () => {
+    const withCandidate = createAutoExposureApplyWgsl({ temperature: 5000, tint: 0.2 }, true);
+    expect(withCandidate).toContain('@group(0) @binding(2) var<storage, read> candidate');
+    expect(withCandidate).toContain('mul_bradford');
+    expect(withCandidate).toContain('blackbody_white_point');
+    expect(withCandidate).toContain('WB_TEMPERATURE: f32 = 5000.00000000');
+    expect(withCandidate).toContain('WB_TINT: f32 = 0.20000000');
+    expect(withCandidate).toContain('color.a');
+
+    const manual = createAutoExposureApplyWgsl({ temperature: 6504, tint: 0 }, false);
+    expect(manual).not.toContain('var<storage, read> candidate');
+    expect(manual).toContain('let exposed = color.rgb * 1.0');
+  });
+});