@forgeax/engine-render 0.0.0-dev.8d955ade1c79

package/src/__tests__/renderer-factory-material-contract.unit.test.ts

@@ -0,0 +1,121 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import {
+  allowsUnlitPreparedFallback,
+  resolveMaterialShaderBindingContract,
+  resolveMaterialShaderVertexInputContract,
+  shouldDeferMissingPreparedMaterialShader,
+} from '../assembly/factory';
+
+describe('material shader binding contract', () => {
+  it('keeps record binding on the cooked projection contract', () => {
+    const recordSource = readFileSync(
+      resolve(import.meta.dirname, '../record/main-pass-material.ts'),
+      'utf8',
+    );
+    const projectionSource = readFileSync(
+      resolve(import.meta.dirname, '../assembly/material/pipeline-projection.ts'),
+      'utf8',
+    );
+    expect(projectionSource).toContain('routeMaterialPipeline');
+    expect(recordSource).not.toMatch(/internals\.assets\.get<MaterialAsset>/);
+    expect(recordSource).not.toMatch(/firstMaterial as \{/);
+    expect(recordSource).not.toContain('baseColorHandle');
+  });
+
+  it('recognizes a world-space shader that reads only the canonical view uniform', () => {
+    const source = `
+      struct View { worldViewProj: mat4x4<f32> }
+      @group(0) @binding(0) var<uniform> view: View;
+      @vertex fn vs_main() -> @builtin(position) vec4<f32> { return view.worldViewProj[0]; }
+    `;
+
+    expect(resolveMaterialShaderBindingContract(source)).toBe('view-only');
+  });
+
+  it('recognizes the canonical view name after naga-oil import mangling', () => {
+    const source = `
+      @group(0) @binding(0)
+      var<uniform> viewX_naga_oil_mod_XMZXXEZ3FMF4F65TJMV3TUOTDN5WW233OX: View;
+    `;
+
+    expect(resolveMaterialShaderBindingContract(source)).toBe('view-only');
+  });
+
+  it('recognizes the VFX view plus sampled scene-depth contract', () => {
+    const source = `
+      struct View { worldViewProj: mat4x4<f32> }
+      @group(0) @binding(0) var<uniform> view: View;
+      @group(0) @binding(1) var scene_depth: texture_depth_2d;
+      @fragment fn fs_main() -> @location(0) vec4<f32> {
+        return vec4<f32>(textureLoad(scene_depth, vec2<i32>(0, 0), 0));
+      }
+    `;
+
+    expect(resolveMaterialShaderBindingContract(source)).toBe('view-and-scene-depth');
+  });
+
+  it('keeps shaders with material groups on the full render-material layout', () => {
+    const source = `
+      @group(0) @binding(0) var<uniform> view: mat4x4<f32>;
+      @group(1) @binding(0) var<uniform> material: vec4<f32>;
+    `;
+
+    expect(resolveMaterialShaderBindingContract(source)).toBe('render-material');
+  });
+
+  it('recognizes a group-zero sampled depth resource without inventing a view uniform', () => {
+    const source = `
+      @group(0) @binding(0) var sceneDepth: texture_depth_2d;
+      @fragment fn fs_main(@builtin(position) position: vec4<f32>) -> @location(0) vec4<f32> {
+        return vec4<f32>(textureLoad(sceneDepth, vec2<i32>(position.xy), 0));
+      }
+    `;
+
+    expect(resolveMaterialShaderBindingContract(source)).toBe('group-0-resource');
+  });
+});
+
+describe('material shader vertex input contract', () => {
+  it('recognizes VsIn-style vertex input structs', () => {
+    const source = `
+      struct VsIn { @location(0) position: vec3<f32> }
+      struct VsOut { @builtin(position) position: vec4<f32> }
+      @vertex fn vs_main(input: VsIn) -> VsOut { var out: VsOut; return out }
+    `;
+
+    expect(resolveMaterialShaderVertexInputContract(source)).toBe('render-material');
+  });
+
+  it('does not treat fullscreen output locations as vertex inputs', () => {
+    const source = `
+      struct FullscreenOutput {
+        @builtin(position) position: vec4<f32>,
+        @location(0) uv: vec2<f32>,
+      }
+      @vertex fn vs_main(@builtin(vertex_index) vertexIndex: u32) -> FullscreenOutput {
+        var out: FullscreenOutput;
+        return out;
+      }
+    `;
+
+    expect(resolveMaterialShaderVertexInputContract(source)).toBe('none');
+  });
+
+  it('keeps an explicit prepared vertex layout on a missing shader', () => {
+    expect(allowsUnlitPreparedFallback(null, undefined)).toBe(true);
+    expect(allowsUnlitPreparedFallback(null, 'position-size-color-instance', 'forward')).toBe(true);
+    expect(
+      allowsUnlitPreparedFallback(null, 'position-size-color-instance', 'forgeax::missing-shader'),
+    ).toBe(false);
+  });
+
+  it('defers every VFX prepared layout when its material shader is missing', () => {
+    expect(shouldDeferMissingPreparedMaterialShader('billboard-material-instance')).toBe(true);
+    expect(shouldDeferMissingPreparedMaterialShader('topology-segment-instance')).toBe(true);
+    expect(shouldDeferMissingPreparedMaterialShader('mesh-geometry-material-instance')).toBe(true);
+    expect(shouldDeferMissingPreparedMaterialShader('position-size-color-instance')).toBe(false);
+    expect(shouldDeferMissingPreparedMaterialShader(undefined)).toBe(false);
+  });
+});

package/src/__tests__/renderer-lifecycle.integration.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest';
+import { createRenderer as constructRenderer } from '../assembly/factory';
+import { DeviceScope, LifecycleTransaction } from '../device/device-scope';
+import { RenderRecoveryError } from '../errors/recover';
+import { LifecycleConstructionError, type RenderError } from '../errors/render';
+
+describe('renderer lifecycle', () => {
+  it('rejects missing construction input', async () => {
+    await expect(constructRenderer(undefined, { rhi })).rejects.toBeDefined();
+  });
+
+  it('keeps the lifecycle tree structural and independent from a GPU backend', async () => {
+    const scope = DeviceScope.create(60, 'renderer');
+    const transaction = new LifecycleTransaction(scope);
+    transaction.add({
+      kind: 'scene-table',
+      create: () => ({ id: 'scene-table' }),
+      cleanup: () => undefined,
+    });
+
+    const result = await transaction.commit();
+
+    expect(result.ok).toBe(true);
+    expect(scope.generation).toBe(60);
+    expect(scope.resourceDelta()).toBe(1);
+  });
+
+  it('keeps lifecycle and recovery failures structured without message parsing', () => {
+    const receipt = { owner: 'renderer', generation: 61, resourceCount: 0 } as const;
+    const lifecycleError = new LifecycleConstructionError({
+      owner: receipt.owner,
+      generation: receipt.generation,
+      operation: 'create',
+      resourceKind: 'pipeline',
+      cause: new Error('driver failure'),
+      cleanupFailures: [],
+      receipt,
+    });
+    const renderError: RenderError = lifecycleError;
+    expect(renderError.code).toBe('lifecycle-construction-failed');
+    expect(renderError.detail.owner).toBe('renderer');
+    expect(renderError.detail.receipt).toEqual(receipt);
+    expect(renderError.hint).toContain('recover');
+
+    const recoveryError = new RenderRecoveryError('recover-lifecycle-failed', {
+      owner: receipt.owner,
+      generation: receipt.generation,
+      recovery: 'recover',
+      receipt,
+      cause: lifecycleError,
+    });
+    expect(recoveryError.code).toBe('recover-lifecycle-failed');
+    expect(recoveryError.detail.receipt).toEqual(receipt);
+    expect(recoveryError.hint).toContain('rebuild');
+  });
+});
+
+import { rhi } from '@forgeax/engine-rhi-null';

package/src/__tests__/rhi-backend-package-boundary.unit.test.ts

@@ -0,0 +1,11 @@
+import { readFile } from 'node:fs/promises';
+import { describe, expect, it } from 'vitest';
+
+describe('render package backend identity boundary', () => {
+  it('externalizes stateful RHI backends from the render bundle', async () => {
+    const source = await readFile(new URL('../../tsup.config.ts', import.meta.url), 'utf8');
+
+    expect(source).toContain("'@forgeax/engine-rhi-webgpu'");
+    expect(source).toContain("'@forgeax/engine-rhi-wgpu'");
+  });
+});

package/src/__tests__/scriptable-pack-consumer.test-d.ts

@@ -0,0 +1,14 @@
+import type { TilesetAsset } from '@forgeax/engine-types';
+import { expectTypeOf } from 'vitest';
+
+const tileset: TilesetAsset = {
+  kind: 'tileset',
+  atlases: ['019ffa97-9000-7000-8000-000000000004'],
+  tileWidth: 1,
+  tileHeight: 1,
+  columns: 1,
+  rows: 1,
+  regions: [{ x: 0, y: 0, width: 1, height: 1 }],
+  tiles: [{ regionIndex: 0 }],
+};
+expectTypeOf(tileset.atlases).toEqualTypeOf<readonly string[]>();

package/src/__tests__/shader-stage-surface.unit.test.ts

@@ -0,0 +1,43 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import {
+  GPU_SHADER_STAGE_COMPUTE,
+  GPU_SHADER_STAGE_FRAGMENT,
+  GPU_SHADER_STAGE_VERTEX,
+} from '../gpu-stage';
+
+const ownerSource = readFileSync(new URL('../gpu-stage.ts', import.meta.url), 'utf8');
+const computeConsumerSources = [
+  readFileSync(new URL('../hdrp-buffers.ts', import.meta.url), 'utf8'),
+];
+const fragmentConsumerSources = [
+  readFileSync(new URL('../pbr-pipeline.ts', import.meta.url), 'utf8'),
+  readFileSync(new URL('../ibl/IblPipelineCache.ts', import.meta.url), 'utf8'),
+  readFileSync(new URL('../ibl/skylight-bind-group.ts', import.meta.url), 'utf8'),
+  readFileSync(new URL('../assembly/factory.ts', import.meta.url), 'utf8'),
+];
+
+describe('shader stage owner', () => {
+  it('keeps the three shader stage bits in one owner', () => {
+    expect(GPU_SHADER_STAGE_VERTEX).toBe(0x1);
+    expect(GPU_SHADER_STAGE_FRAGMENT).toBe(0x2);
+    expect(GPU_SHADER_STAGE_COMPUTE).toBe(0x4);
+    expect(ownerSource.match(/export const GPU_SHADER_STAGE_/g)).toHaveLength(3);
+  });
+
+  it('routes render visibility consumers through the owner', () => {
+    for (const source of [...computeConsumerSources, ...fragmentConsumerSources]) {
+      expect(source).toContain('gpu-stage');
+      expect(source).not.toMatch(/const GPU_SHADER_STAGE_(VERTEX|FRAGMENT|COMPUTE)\s*=/);
+      expect(source).not.toMatch(/visibility:\s*0x[124]/);
+    }
+    for (const source of fragmentConsumerSources) {
+      expect(source).toContain('GPU_SHADER_STAGE_FRAGMENT');
+    }
+    for (const source of computeConsumerSources) {
+      expect(source).toContain('GPU_SHADER_STAGE_COMPUTE');
+    }
+    expect(fragmentConsumerSources[0]).toContain('GPU_SHADER_STAGE_VERTEX');
+    expect(fragmentConsumerSources[1]).toContain('GPU_SHADER_STAGE_VERTEX');
+  });
+});

package/src/__tests__/ssao-config.unit.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import {
+  getSsaoParameters,
+  resolveSsaoParameters,
+  SSAO_DEFAULT_BIAS,
+  SSAO_DEFAULT_INTENSITY,
+  SSAO_DEFAULT_RADIUS,
+} from '../ssao-config';
+
+describe('SSAO parameter authority', () => {
+  it('keeps the documented defaults in one resolver', () => {
+    expect(getSsaoParameters(undefined)).toEqual({
+      radius: SSAO_DEFAULT_RADIUS,
+      bias: SSAO_DEFAULT_BIAS,
+      intensity: SSAO_DEFAULT_INTENSITY,
+    });
+  });
+
+  it('preserves configured radius, bias, and intensity', () => {
+    expect(getSsaoParameters({ radius: 0.65, bias: 0.025, intensity: 1.4 })).toEqual({
+      radius: 0.65,
+      bias: 0.025,
+      intensity: 1.4,
+    });
+  });
+
+  it('returns structured failures for invalid radius and bias', () => {
+    const invalidRadius = resolveSsaoParameters({ radius: 0 });
+    const invalidBias = resolveSsaoParameters({ bias: -0.1 });
+    expect(invalidRadius.ok).toBe(false);
+    expect(invalidBias.ok).toBe(false);
+    if (invalidRadius.ok || invalidBias.ok) throw new Error('expected structured SSAO failures');
+    expect(invalidRadius.error.code).toBe('ssao-radius-non-positive');
+    expect(invalidBias.error.code).toBe('ssao-bias-negative');
+  });
+});

package/src/__tests__/ssao-kernel-surface.unit.test.ts

@@ -0,0 +1,14 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { SSAO_KERNEL_SAMPLE_COUNT } from '../ssao-buffers';
+
+const ownerSource = readFileSync(new URL('../ssao-buffers.ts', import.meta.url), 'utf8');
+
+describe('SSAO kernel cardinality owner', () => {
+  it('keeps the generated and uploaded sample count on one owner', () => {
+    expect(SSAO_KERNEL_SAMPLE_COUNT).toBe(64);
+    expect(ownerSource.match(/export const SSAO_KERNEL_SAMPLE_COUNT\s*=\s*64/g)).toHaveLength(1);
+    expect(ownerSource).toContain('SSAO_KERNEL_SAMPLE_COUNT');
+    expect(ownerSource).not.toMatch(/const (KERNEL_SIZE|KERNEL_SAMPLE_COUNT)\s*=\s*64/);
+  });
+});

package/src/__tests__/standard-clustered-pipeline.unit.test.ts

@@ -0,0 +1,28 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { resolvePostColorDomainContract } from '../render-pipeline';
+
+const clusteredSource = readFileSync(
+  new URL('../pipeline/standard-pipeline.ts', import.meta.url),
+  'utf8',
+);
+const frameSource = readFileSync(new URL('../record/frame.ts', import.meta.url), 'utf8');
+
+describe('Standard clustered post color-domain order', () => {
+  it('keeps transparent and bloom work in linear HDR before tone output', () => {
+    const stages = resolvePostColorDomainContract('linear-hdr');
+    expect(stages).toContainEqual(['transparent-blend', 'linear-hdr', 'linear-hdr']);
+    expect(stages).toContainEqual(['bloom', 'linear-hdr', 'linear-hdr']);
+    expect(stages).toContainEqual(['tone', 'linear-hdr', 'linear-ldr']);
+    expect(stages).toContainEqual(['output', 'linear-ldr', 'display-encoded']);
+    expect(stages.findIndex(([name]) => name === 'tone')).toBeGreaterThan(
+      stages.findIndex(([name]) => name === 'bloom'),
+    );
+  });
+
+  it('keeps the real Standard producer and record owner as one provenance chain', () => {
+    expect(clusteredSource).toContain("graph.addComputePass('cluster-membership-producer'");
+    expect(frameSource).toContain('internals.device.caps?.compute === true,');
+    expect(clusteredSource).toContain('pass.dispatchWorkgroups(');
+  });
+});

package/src/__tests__/standard-descriptors.test-d.ts

@@ -0,0 +1,22 @@
+import type { ColorTargetDescriptor } from '@forgeax/engine-render-graph';
+import type { TextureFormat } from '@forgeax/engine-rhi';
+import { describe, expectTypeOf, it } from 'vitest';
+import type { StandardProfile } from '../pipeline/standard-profile';
+
+describe('M4 Standard descriptor contract', () => {
+  it('keeps graph attachment formats on the RHI TextureFormat union', () => {
+    expectTypeOf<ColorTargetDescriptor['format']>().toEqualTypeOf<TextureFormat>();
+    const invalid: ColorTargetDescriptor = {
+      // @ts-expect-error -- malformed formats never enter a graph declaration.
+      format: 'not-a-texture-format',
+      size: { w: 1, h: 1 },
+    };
+    void invalid;
+  });
+
+  it('keeps the profile inspectable and free of implementation handles', () => {
+    expectTypeOf<StandardProfile['pipelineId']>().toEqualTypeOf<'forgeax::standard'>();
+    // @ts-expect-error -- a profile is POD; raw device handles are not a profile field.
+    type _NoDevice = StandardProfile['device'];
+  });
+});

package/src/__tests__/standard-pipeline.dawn.test.ts

@@ -0,0 +1,61 @@
+import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
+import type { RhiDevice } from '@forgeax/engine-rhi';
+import { rhi } from '@forgeax/engine-rhi-webgpu';
+import { ok } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { standardPipeline } from '../pipeline/standard-pipeline';
+import { DEFAULT_STANDARD_PROFILE, STANDARD_PIPELINE_ID } from '../pipeline/standard-profile';
+import type { RenderPipelineFrame, RenderPipelineTopology } from '../render-pipeline';
+
+function topology(): RenderPipelineTopology {
+  return {
+    pipelineId: STANDARD_PIPELINE_ID,
+    standardProfile: { ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered', lightCount: 256 },
+    config: { ssao: { enabled: true } },
+    surface: {
+      width: 1,
+      height: 1,
+      storageFormat: 'bgra8unorm',
+      viewFormat: 'bgra8unorm-srgb',
+    },
+    camera: { tonemap: 'aces-filmic', antialias: 'fxaa', bloom: 'on' },
+    shadow: {
+      mapSize: 64,
+      cascadeCount: 1,
+      pointCount: 0,
+      pointFaceSize: 64,
+      spotCount: 0,
+    },
+    lane: {
+      compute: true,
+      storageBuffer: true,
+      multisample: false,
+      maxColorAttachments: 8,
+    },
+    featureTopologySignature: 'none',
+    gpuDrivenTopologySignature: '',
+  };
+}
+
+describe('forgeax::standard graph on a real WebGPU device', () => {
+  it('compiles the clustered profile with real texture and binding formats', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device: RhiDevice = (await adapter.requestDevice()).unwrap();
+    const graph = new RenderGraphBuilder<RenderPipelineFrame>();
+    const built = standardPipeline.build(
+      {
+        graph,
+        projectGpuDriven: () => ok(undefined),
+        contributeFeatures: () => ok(undefined),
+      },
+      topology(),
+    );
+    expect(built.ok).toBe(true);
+    if (!built.ok) return;
+    const compiled = graph.compile({ device, surfaceSize: { width: 1, height: 1 } });
+    expect(compiled.ok).toBe(true);
+    if (compiled.ok) {
+      expect(compiled.value.inspect().passes.map((pass) => pass.kind)).toContain('compute');
+    }
+  });
+});

package/src/__tests__/standard-pipeline.integration.test.ts

@@ -0,0 +1,124 @@
+import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
+import type { RhiDevice } from '@forgeax/engine-rhi';
+import { rhi } from '@forgeax/engine-rhi-null';
+import { ok } from '@forgeax/engine-types';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { standardPipeline } from '../pipeline/standard-pipeline';
+import {
+  DEFAULT_STANDARD_PROFILE,
+  STANDARD_PIPELINE_ID,
+  type StandardProfile,
+} from '../pipeline/standard-profile';
+import type { RenderPipelineFrame, RenderPipelineTopology } from '../render-pipeline';
+
+function topology(
+  profile: StandardProfile,
+  overrides: Partial<RenderPipelineTopology> = {},
+): RenderPipelineTopology {
+  return {
+    pipelineId: STANDARD_PIPELINE_ID,
+    standardProfile: profile,
+    config: profile.ssao ? { ssao: { enabled: true } } : undefined,
+    surface: {
+      width: 1,
+      height: 1,
+      storageFormat: 'bgra8unorm',
+      viewFormat: 'bgra8unorm-srgb',
+    },
+    camera: { tonemap: 'aces-filmic', antialias: 'fxaa', bloom: 'on' },
+    shadow: {
+      mapSize: 64,
+      cascadeCount: 1,
+      pointCount: 0,
+      pointFaceSize: 64,
+      spotCount: 0,
+    },
+    lane: {
+      compute: true,
+      storageBuffer: true,
+      multisample: false,
+      maxColorAttachments: 8,
+    },
+    featureTopologySignature: 'none',
+    gpuDrivenTopologySignature: '',
+    ...overrides,
+  };
+}
+
+let device: RhiDevice;
+
+beforeAll(async () => {
+  const adapter = await rhi.requestAdapter();
+  if (!adapter.ok) throw adapter.error;
+  const created = await adapter.value.requestDevice();
+  if (!created.ok) throw created.error;
+  device = created.value;
+});
+
+async function build(profile: StandardProfile, overrides?: Partial<RenderPipelineTopology>) {
+  const graph = new RenderGraphBuilder<RenderPipelineFrame>();
+  const built = standardPipeline.build(
+    {
+      graph,
+      projectGpuDriven: () => ok(undefined),
+      contributeFeatures: () => ok(undefined),
+    },
+    topology(profile, overrides),
+  );
+  if (!built.ok) return built;
+  return graph.compile({ device, surfaceSize: { width: 1, height: 1 } });
+}
+
+describe('forgeax::standard graph', () => {
+  it.each([
+    ['direct-1', { ...DEFAULT_STANDARD_PROFILE, lightCount: 1, lighting: 'direct' }],
+    ['clustered-32', { ...DEFAULT_STANDARD_PROFILE, lightCount: 32, lighting: 'clustered' }],
+    ['clustered-256', { ...DEFAULT_STANDARD_PROFILE, lightCount: 256, lighting: 'clustered' }],
+  ] as const)('preserves the %s light lane under one identity', async (_name, profile) => {
+    const result = await build(profile);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.inspect().passes.length).toBeGreaterThan(0);
+  });
+
+  it('keeps shadow, lighting, post, and debug work in one ordered graph', async () => {
+    const result = await build({ ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered' });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const names = result.value.inspect().passes.map((pass) => pass.name);
+    const stages = [
+      'shadowCascade-0',
+      'g-buffer',
+      'lighting',
+      'forward',
+      'tonemap',
+      'debug-overlay',
+    ];
+    for (let index = 1; index < stages.length; index += 1) {
+      expect(names.indexOf(stages[index] ?? '')).toBeGreaterThan(
+        names.indexOf(stages[index - 1] ?? ''),
+      );
+    }
+  });
+
+  it('uses the CPU/WebGL2 fallback without clustered resources', async () => {
+    const result = await build(
+      { ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered' },
+      {
+        lane: {
+          compute: false,
+          storageBuffer: false,
+          multisample: false,
+          maxColorAttachments: 4,
+        },
+      },
+    );
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const names = result.value.inspect().passes.map((pass) => pass.name);
+    expect(names).not.toContain('cluster-membership-producer');
+    expect(result.value.inspect().resources.map((resource) => resource.label)).not.toContain(
+      'hdrp-light-index-list',
+    );
+  });
+});

package/src/__tests__/standard-profile-oracle.unit.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest';
+import {
+  DEFAULT_STANDARD_PROFILE,
+  resolveStandardLane,
+  STANDARD_LIGHT_COUNTS,
+  STANDARD_PIPELINE_ID,
+  type StandardProfile,
+} from '../pipeline/standard-profile';
+
+describe('Standard profile oracle', () => {
+  it('keeps one identity across the supported light budgets', () => {
+    expect(STANDARD_LIGHT_COUNTS).toEqual([1, 32, 256]);
+    for (const lightCount of STANDARD_LIGHT_COUNTS) {
+      const profile: StandardProfile = {
+        ...DEFAULT_STANDARD_PROFILE,
+        lightCount,
+      };
+      expect(profile.pipelineId).toBe(STANDARD_PIPELINE_ID);
+      expect(profile.lightCount).toBe(lightCount);
+    }
+  });
+
+  it('selects direct, clustered, and CPU/WebGL2 fallback lanes from profile and caps', () => {
+    expect(
+      resolveStandardLane(
+        { ...DEFAULT_STANDARD_PROFILE, lighting: 'direct' },
+        {
+          compute: true,
+          storageBuffer: true,
+        },
+      ),
+    ).toBe('direct');
+    expect(
+      resolveStandardLane(
+        { ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered' },
+        {
+          compute: true,
+          storageBuffer: true,
+        },
+      ),
+    ).toBe('clustered');
+    expect(
+      resolveStandardLane(
+        { ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered' },
+        {
+          compute: false,
+          storageBuffer: false,
+        },
+      ),
+    ).toBe('cpu-webgl2');
+  });
+
+  it('keeps the color-domain stage order stable for all profiles', () => {
+    expect(DEFAULT_STANDARD_PROFILE.postStages).toEqual([
+      'transparent-blend',
+      'bloom',
+      'tone',
+      'fxaa',
+      'output',
+    ]);
+  });
+});