@forgeax/engine-render 0.1.20 → 0.1.23

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

@@ -1,9 +1,13 @@
+import { mat4, vec3 } from '@forgeax/engine-math';
 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 { createRenderSurfaceError, type RenderSurfaceExpectedError } from '../errors/render';
+import { prepareStandardLighting } from '../pipeline/standard-lighting/prepare';
+import { deriveStandardTopologyInput } from '../pipeline/standard-lighting/topology';
+import { selectStandardClusterTransport } from '../pipeline/standard-lighting/transport';
 import { standardPipeline } from '../pipeline/standard-pipeline';
 import {
   DEFAULT_STANDARD_PROFILE,
@@ -45,8 +49,8 @@ function topology(
     },
     camera: { tonemap: 'aces-filmic', antialias: 'fxaa', bloom: 'on' },
     shadow: {
-      mapSize: 64,
-      cascadeCount: 1,
+      directional: { mapSize: 64, cascadeCount: 1 },
+      spotMapSize: 64,
       pointCount: 0,
       pointFaceSize: 64,
       spotCount: 0,
@@ -73,12 +77,45 @@ beforeAll(async () => {
   device = created.value;
 });
 
+function standardLightingFor(resolvedTopology: RenderPipelineTopology) {
+  const prepared = prepareStandardLighting({
+    directional: undefined,
+    local: [{ kind: 'point', shadowed: false, position: vec3.create(0, 0, -4), range: 2 }],
+    view: mat4.create(),
+    projection: mat4.create(),
+    near: 0.1,
+    far: 100,
+    grid: resolvedTopology.config?.clusterGrid ?? { x: 4, y: 3, z: 4 },
+    lightCount: resolvedTopology.standardProfile?.lightCount ?? DEFAULT_STANDARD_PROFILE.lightCount,
+    renderPath: resolvedTopology.standardProfile?.renderPath ?? DEFAULT_STANDARD_PROFILE.renderPath,
+  });
+  if (!prepared.ok) return prepared;
+  const transport = selectStandardClusterTransport(
+    {
+      compute: resolvedTopology.lane.compute,
+      storageBuffer: resolvedTopology.lane.storageBuffer,
+      membershipPipelineReady: resolvedTopology.lane.compute,
+    },
+    prepared.value,
+  );
+  if (!transport.ok) return transport;
+  const standardLighting = deriveStandardTopologyInput({
+    prepared: prepared.value,
+    kind: 'clustered',
+    transport: transport.value,
+  });
+  return standardLighting;
+}
+
 async function build(profile: StandardProfile, overrides?: Partial<RenderPipelineTopology>) {
   const graph = new RenderGraphBuilder<RenderPipelineFrame>();
   const resolvedTopology = topology(profile, overrides);
+  const standardLighting = standardLightingFor(resolvedTopology);
+  if (!standardLighting.ok) return standardLighting;
   const built = standardPipeline.build(
     {
       graph,
+      standardLighting: standardLighting.value,
       encodeTransmissionMip: ({ pass }) => pass.draw(3, 1, 0, 0),
       projectGpuDriven: () => ok(undefined),
       contributeFeatures: () => ok(undefined),
@@ -123,21 +160,31 @@ function importedTaaHistory(graph: RenderGraphBuilder<RenderPipelineFrame>) {
 async function buildTaa(profile: StandardProfile, overrides?: Partial<RenderPipelineTopology>) {
   const graph = new RenderGraphBuilder<RenderPipelineFrame>();
   const history = importedTaaHistory(graph);
+  const resolvedTopology = topology(profile, overrides);
+  const standardLighting = standardLightingFor(resolvedTopology);
+  if (!standardLighting.ok) return standardLighting;
   const built = standardPipeline.build(
     {
       graph,
+      standardLighting: standardLighting.value,
       capabilities: { rgba16floatRenderable: true },
       taaHistory: history,
       projectGpuDriven: () => ok(undefined),
       contributeFeatures: () => ok(undefined),
     },
-    topology(profile, overrides),
+    resolvedTopology,
   );
   if (!built.ok) return built;
   return graph.compile({ device, surfaceSize: { width: 1, height: 1 } });
 }
 
 describe('forgeax::standard graph', () => {
+  it('does not admit an unsupported four-light budget', async () => {
+    const profile = { ...DEFAULT_STANDARD_PROFILE, lightCount: 4 } as unknown as StandardProfile;
+    const result = await build(profile);
+    expect(result.ok).toBe(false);
+  });
+
   it('keeps the last-known-good graph for each explicit surface failure', () => {
     let activeGraph = 'last-known-good';
     const failures = ['allocation', 'attachment', 'sampled-read', 'raw-endpoint'] as const;
@@ -160,9 +207,9 @@ 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' }],
+    ['forward-1', { ...DEFAULT_STANDARD_PROFILE, lightCount: 1, renderPath: 'forward' }],
+    ['forward-32', { ...DEFAULT_STANDARD_PROFILE, lightCount: 32, renderPath: 'forward' }],
+    ['deferred-256', { ...DEFAULT_STANDARD_PROFILE, lightCount: 256, renderPath: 'deferred' }],
   ] as const)('preserves the %s light lane under one identity', async (_name, profile) => {
     const result = await build(profile);
     expect(result.ok).toBe(true);
@@ -172,7 +219,7 @@ describe('forgeax::standard graph', () => {
 
   it('keeps Bloom a no-op when TAA has no active tone mapper', async () => {
     const result = await buildTaa(
-      { ...DEFAULT_STANDARD_PROFILE, lighting: 'direct' },
+      { ...DEFAULT_STANDARD_PROFILE, renderPath: 'forward' },
       { camera: { tonemap: 'none', antialias: 'taa', bloom: 'on' } },
     );
     expect(result.ok).toBe(true);
@@ -187,7 +234,7 @@ describe('forgeax::standard graph', () => {
   });
 
   it('keeps shadow, lighting, post, and debug work in one ordered graph', async () => {
-    const result = await build({ ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered' });
+    const result = await build({ ...DEFAULT_STANDARD_PROFILE, renderPath: 'deferred' });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     const names = result.value.inspect().passes.map((pass) => pass.name);
@@ -206,15 +253,27 @@ describe('forgeax::standard graph', () => {
     }
   });
 
-  it('routes a no-camera clear-only frame directly to the surface', async () => {
+  it('keeps one clustered resource layout when compute admission is unavailable', async () => {
     const result = await build(
-      { ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered' },
+      { ...DEFAULT_STANDARD_PROFILE, renderPath: 'forward' },
       {
-        clearOnly: true,
-        camera: { tonemap: 'none', antialias: 'none', bloom: 'off' },
+        lane: {
+          compute: false,
+          storageBuffer: true,
+          multisample: false,
+          maxColorAttachments: 4,
+        },
       },
     );
     expect(result.ok).toBe(true);
+  });
+
+  it('routes a no-camera clear-only frame directly to the surface', async () => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      clearOnly: true,
+      camera: { tonemap: 'none', antialias: 'none', bloom: 'off' },
+    });
+    expect(result.ok).toBe(true);
     if (!result.ok) return;
     const info = result.value.inspect();
     const names = info.passes.map((pass) => pass.name);
@@ -229,9 +288,9 @@ describe('forgeax::standard graph', () => {
     expect(info.resources.map((resource) => resource.label)).not.toContain('scene-color');
   });
 
-  it('uses the CPU/WebGL2 fallback without clustered resources', async () => {
+  it('refuses the clustered transport when storage is unavailable', async () => {
     const result = await build(
-      { ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered' },
+      { ...DEFAULT_STANDARD_PROFILE, renderPath: 'forward' },
       {
         lane: {
           compute: false,
@@ -241,27 +300,19 @@ describe('forgeax::standard graph', () => {
         },
       },
     );
-    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',
-    );
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe('standard-cluster-transport-unavailable');
   });
 
   it.each([
-    ['direct', 'aces-filmic', 'fxaa'],
-    ['direct', 'none', 'fxaa'],
-    ['clustered', 'aces-filmic', 'fxaa'],
-    ['clustered', 'none', 'fxaa'],
-    ['direct', 'aces-filmic', 'none'],
-    ['clustered', 'aces-filmic', 'none'],
-  ] as const)('uses one explicit post-chain contract for %s/%s/%s', async (lighting, tonemap, antialias) => {
-    const result = await build(
-      { ...DEFAULT_STANDARD_PROFILE, lighting },
-      { camera: { tonemap, antialias, bloom: 'on' } },
-    );
+    ['aces-filmic', 'fxaa'],
+    ['none', 'fxaa'],
+    ['aces-filmic', 'none'],
+  ] as const)('uses one explicit post-chain contract for %s/%s', async (tonemap, antialias) => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap, antialias, bloom: 'on' },
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     const info = result.value.inspect();
@@ -281,38 +332,31 @@ describe('forgeax::standard graph', () => {
     expect(info.resources.map((resource) => resource.label)).not.toContain('ldr-color');
   });
 
-  const routeMatrix = (['direct', 'clustered'] as const).flatMap((lighting) =>
-    (['dual-view', 'raw-only'] as const).flatMap((surfaceKind) =>
-      (['none', 'aces-filmic'] as const).flatMap((tonemap) =>
-        (['none', 'fxaa'] as const).map(
-          (antialias) => [lighting, surfaceKind, tonemap, antialias] as const,
-        ),
-      ),
+  const routeMatrix = (['dual-view', 'raw-only'] as const).flatMap((surfaceKind) =>
+    (['none', 'aces-filmic'] as const).flatMap((tonemap) =>
+      (['none', 'fxaa'] as const).map((antialias) => [surfaceKind, tonemap, antialias] as const),
     ),
   );
 
   it.each(
     routeMatrix,
-  )('keeps the output route explicit for %s/%s/%s/%s', async (lighting, surfaceKind, tonemap, antialias) => {
+  )('keeps the output route explicit for %s/%s/%s', async (surfaceKind, tonemap, antialias) => {
     const rawOnly = surfaceKind === 'raw-only';
-    const result = await build(
-      { ...DEFAULT_STANDARD_PROFILE, lighting },
-      {
-        camera: { tonemap, antialias, bloom: 'off' },
-        surface: {
-          width: 1,
-          height: 1,
-          storageFormat: rawOnly ? 'rgba8unorm' : 'bgra8unorm',
-          viewFormat: rawOnly ? 'rgba8unorm' : 'bgra8unorm-srgb',
-          profile: rawOnly ? rawOnlyProfile : dualViewProfile,
-        },
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap, antialias, bloom: 'off' },
+      surface: {
+        width: 1,
+        height: 1,
+        storageFormat: rawOnly ? 'rgba8unorm' : 'bgra8unorm',
+        viewFormat: rawOnly ? 'rgba8unorm' : 'bgra8unorm-srgb',
+        profile: rawOnly ? rawOnlyProfile : dualViewProfile,
       },
-    );
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     const info = result.value.inspect();
     const names = info.passes.map((pass) => pass.name);
-    const sceneLabel = lighting === 'direct' ? 'scene-color' : 'hdrp-scene-color';
+    const sceneLabel = 'scene-color';
     const sceneResource = info.resources.find((resource) => resource.label === sceneLabel);
     expect(sceneResource).toBeDefined();
     expect(sceneResource?.derivedUsage).toBe(0x15);
@@ -338,11 +382,10 @@ describe('forgeax::standard graph', () => {
     }
   });
 
-  it('uses one linear target and one output transform for direct storage-buffer LDR output', async () => {
-    const result = await build(
-      { ...DEFAULT_STANDARD_PROFILE, lighting: 'direct' },
-      { camera: { tonemap: 'none', antialias: 'none', bloom: 'off' } },
-    );
+  it('uses one linear target and one output transform for Standard storage-buffer LDR output', async () => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'none', antialias: 'none', bloom: 'off' },
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     const info = result.value.inspect();
@@ -350,47 +393,39 @@ describe('forgeax::standard graph', () => {
     expect(names).toContain('output-transform');
     expect(names).not.toContain('fxaa');
     expect(info.resources.find((resource) => resource.label === 'scene-color')).toMatchObject({
-      descriptor: { format: 'rgba16float', domain: 'linear-ldr' },
+      descriptor: { format: 'rgba16float' },
+      derivedUsage: 0x15,
     });
     expect(info.resources.map((resource) => resource.label)).not.toContain('standard-output-color');
     expect(info.resources.map((resource) => resource.label)).not.toContain('ldr-color');
   });
 
-  it('keeps the direct display fast path when storage buffers are unavailable', async () => {
-    const result = await build(
-      { ...DEFAULT_STANDARD_PROFILE, lighting: 'direct' },
-      {
-        camera: { tonemap: 'none', antialias: 'none', bloom: 'off' },
-        lane: {
-          compute: false,
-          storageBuffer: false,
-          multisample: false,
-          maxColorAttachments: 4,
-        },
+  it('keeps the Standard output route when storage buffers are unavailable', async () => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'none', antialias: 'none', bloom: 'off' },
+      lane: {
+        compute: false,
+        storageBuffer: false,
+        multisample: false,
+        maxColorAttachments: 4,
       },
-    );
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-    const info = result.value.inspect();
-    const names = info.passes.map((pass) => pass.name);
-    expect(names).not.toContain('output-transform');
-    expect(info.resources.map((resource) => resource.label)).not.toContain('scene-color');
+    });
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe('standard-cluster-transport-unavailable');
   });
 
   it('uses one linear target and one output transform for raw-only no-FXAA', async () => {
-    const result = await build(
-      { ...DEFAULT_STANDARD_PROFILE, lighting: 'direct' },
-      {
-        camera: { tonemap: 'none', antialias: 'none', bloom: 'off' },
-        surface: {
-          width: 1,
-          height: 1,
-          storageFormat: 'rgba8unorm',
-          viewFormat: 'rgba8unorm',
-          profile: rawOnlyProfile,
-        },
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'none', antialias: 'none', bloom: 'off' },
+      surface: {
+        width: 1,
+        height: 1,
+        storageFormat: 'rgba8unorm',
+        viewFormat: 'rgba8unorm',
+        profile: rawOnlyProfile,
       },
-    );
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     const info = result.value.inspect();
@@ -405,19 +440,16 @@ describe('forgeax::standard graph', () => {
   });
 
   it('keeps raw-only FXAA in one display-encoded float intermediate', async () => {
-    const result = await build(
-      { ...DEFAULT_STANDARD_PROFILE, lighting: 'direct' },
-      {
-        camera: { tonemap: 'none', antialias: 'fxaa', bloom: 'off' },
-        surface: {
-          width: 1,
-          height: 1,
-          storageFormat: 'rgba8unorm',
-          viewFormat: 'rgba8unorm',
-          profile: rawOnlyProfile,
-        },
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'none', antialias: 'fxaa', bloom: 'off' },
+      surface: {
+        width: 1,
+        height: 1,
+        storageFormat: 'rgba8unorm',
+        viewFormat: 'rgba8unorm',
+        profile: rawOnlyProfile,
       },
-    );
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     const info = result.value.inspect();
@@ -436,20 +468,17 @@ describe('forgeax::standard graph', () => {
     'none',
     'fxaa',
   ] as const)('routes raw-only registered post effects through an encoded float input target (%s)', async (antialias) => {
-    const result = await build(
-      { ...DEFAULT_STANDARD_PROFILE, lighting: 'direct' },
-      {
-        camera: { tonemap: 'none', antialias, bloom: 'off' },
-        config: { postEffects: ['test-effect'] },
-        surface: {
-          width: 1,
-          height: 1,
-          storageFormat: 'rgba8unorm',
-          viewFormat: 'rgba8unorm',
-          profile: rawOnlyProfile,
-        },
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'none', antialias, bloom: 'off' },
+      config: { postEffects: ['test-effect'] },
+      surface: {
+        width: 1,
+        height: 1,
+        storageFormat: 'rgba8unorm',
+        viewFormat: 'rgba8unorm',
+        profile: rawOnlyProfile,
       },
-    );
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     const info = result.value.inspect();
@@ -480,18 +509,15 @@ describe('forgeax::standard graph', () => {
   });
 
   it('presents a resolved no-tone MSAA scene through the shared output boundary', async () => {
-    const result = await build(
-      { ...DEFAULT_STANDARD_PROFILE, lighting: 'direct' },
-      {
-        camera: { tonemap: 'none', antialias: 'msaa', bloom: 'off' },
-        lane: {
-          compute: true,
-          storageBuffer: true,
-          multisample: true,
-          maxColorAttachments: 8,
-        },
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'none', antialias: 'msaa', bloom: 'off' },
+      lane: {
+        compute: true,
+        storageBuffer: true,
+        multisample: true,
+        maxColorAttachments: 8,
       },
-    );
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     const info = result.value.inspect();
@@ -506,16 +532,20 @@ describe('forgeax::standard graph', () => {
 
   it('uses the live rgba16float capability for temporal admission', () => {
     const graph = new RenderGraphBuilder<RenderPipelineFrame>();
+    const resolvedTopology = topology(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'aces-filmic', antialias: 'taa', bloom: 'off' },
+    });
+    const standardLighting = standardLightingFor(resolvedTopology);
+    if (!standardLighting.ok) throw standardLighting.error;
     const built = standardPipeline.build(
       {
         graph,
+        standardLighting: standardLighting.value,
         capabilities: { rgba16floatRenderable: false },
         projectGpuDriven: () => ok(undefined),
         contributeFeatures: () => ok(undefined),
       },
-      topology(DEFAULT_STANDARD_PROFILE, {
-        camera: { tonemap: 'aces-filmic', antialias: 'taa', bloom: 'off' },
-      }),
+      resolvedTopology,
     );
     expect(built.ok).toBe(false);
     if (built.ok) return;
@@ -527,21 +557,25 @@ describe('forgeax::standard graph', () => {
 
   it('fails closed when the temporal capability probe is absent', () => {
     const graph = new RenderGraphBuilder<RenderPipelineFrame>();
+    const resolvedTopology = topology(DEFAULT_STANDARD_PROFILE, {
+      surface: {
+        width: 1,
+        height: 1,
+        storageFormat: 'rgba16float',
+        viewFormat: 'rgba16float',
+      },
+      camera: { tonemap: 'aces-filmic', antialias: 'taa', bloom: 'off' },
+    });
+    const standardLighting = standardLightingFor(resolvedTopology);
+    if (!standardLighting.ok) throw standardLighting.error;
     const built = standardPipeline.build(
       {
         graph,
+        standardLighting: standardLighting.value,
         projectGpuDriven: () => ok(undefined),
         contributeFeatures: () => ok(undefined),
       },
-      topology(DEFAULT_STANDARD_PROFILE, {
-        surface: {
-          width: 1,
-          height: 1,
-          storageFormat: 'rgba16float',
-          viewFormat: 'rgba16float',
-        },
-        camera: { tonemap: 'aces-filmic', antialias: 'taa', bloom: 'off' },
-      }),
+      resolvedTopology,
     );
     expect(built.ok).toBe(false);
     if (built.ok) return;
@@ -551,9 +585,9 @@ describe('forgeax::standard graph', () => {
     });
   });
 
-  it('keeps direct and clustered transmission topology in one graph', async () => {
-    for (const lighting of ['direct', 'clustered'] as const) {
-      const result = await build({ ...DEFAULT_STANDARD_PROFILE, lighting }, {
+  it('keeps both Standard render paths on one transmission topology', async () => {
+    for (const renderPath of ['forward', 'deferred'] as const) {
+      const result = await build({ ...DEFAULT_STANDARD_PROFILE, renderPath }, {
         surface: {
           width: 8,
           height: 4,
@@ -577,7 +611,7 @@ describe('forgeax::standard graph', () => {
 
   it('uses the resolved single-sample MSAA source for the shared backdrop', async () => {
     const result = await build(
-      { ...DEFAULT_STANDARD_PROFILE, lighting: 'direct' },
+      { ...DEFAULT_STANDARD_PROFILE, renderPath: 'forward' },
       {
         surface: {
           width: 8,
@@ -611,13 +645,13 @@ describe('forgeax::standard graph', () => {
     });
   });
 
-  it('keeps the CPU fallback lane on the same transmission phase contract', async () => {
+  it('keeps the CPU transport on the same transmission phase contract', async () => {
     const result = await build(
-      { ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered', fallback: 'cpu-webgl2' },
+      { ...DEFAULT_STANDARD_PROFILE, renderPath: 'deferred' },
       {
         lane: {
           compute: false,
-          storageBuffer: false,
+          storageBuffer: true,
           multisample: false,
           maxColorAttachments: 4,
         },
@@ -645,12 +679,9 @@ describe('forgeax::standard graph', () => {
     ],
     ['reversed-phase-order', (names: readonly string[]) => [...names].reverse()],
   ] as const)('dev falsifier %s rejects the two-lane phase contract', async (_name, falsify) => {
-    const result = await build(
-      { ...DEFAULT_STANDARD_PROFILE, lighting: 'direct' },
-      {
-        transmissionDemand: { activeCount: 1, needsRoughMips: false },
-      },
-    );
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      transmissionDemand: { activeCount: 1, needsRoughMips: false },
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     const names = result.value.inspect().passes.map((pass) => pass.name);

package/src/__tests__/standard-probe-binding.unit.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import { resolveReflectionProbeBinding } from '../record/frame-lighting';
+import { standardReflectionProbeIndex } from '../record/main-pass';
+
+describe('Standard scene reflection probe binding', () => {
+  it('maps a selected scene probe to both Standard lanes', () => {
+    const selection = {
+      kind: 'probe' as const,
+      worldId: 2,
+      entityKey: 7,
+      normalizedDistance: 0.25,
+    };
+    expect(resolveReflectionProbeBinding(selection)).toEqual({ probeIndex: 7, useSkylight: false });
+    expect(standardReflectionProbeIndex(selection)).toBe(7);
+  });
+
+  it('uses Skylight without a per-material probe identity', () => {
+    const selection = { kind: 'skylight' as const };
+    expect(resolveReflectionProbeBinding(selection)).toEqual({
+      probeIndex: undefined,
+      useSkylight: true,
+    });
+    expect(standardReflectionProbeIndex(selection)).toBeUndefined();
+  });
+});

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

@@ -1,13 +1,20 @@
 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('requires the renderPath-only profile contract', () => {
+    const profile: StandardProfile = DEFAULT_STANDARD_PROFILE;
+    expect(profile.pipelineId).toBe('forgeax::standard');
+    expect(profile.renderPath).toBe('forward');
+    expect(profile).not.toHaveProperty('lighting');
+    expect(profile).not.toHaveProperty('fallback');
+  });
+
   it('keeps one identity across the supported light budgets', () => {
     expect(STANDARD_LIGHT_COUNTS).toEqual([1, 32, 256]);
     for (const lightCount of STANDARD_LIGHT_COUNTS) {
@@ -20,34 +27,21 @@ describe('Standard profile oracle', () => {
     }
   });
 
-  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('does not model a second lighting or fallback lane', () => {
+    const profile = DEFAULT_STANDARD_PROFILE as unknown as Record<string, unknown>;
+    expect(profile).not.toHaveProperty('lighting');
+    expect(profile).not.toHaveProperty('fallback');
+  });
+
+  it('selects only the graph path; Cluster transport is capability-derived', () => {
+    expect({ ...DEFAULT_STANDARD_PROFILE, renderPath: 'forward' }).toMatchObject({
+      pipelineId: STANDARD_PIPELINE_ID,
+      renderPath: 'forward',
+    });
+    expect({ ...DEFAULT_STANDARD_PROFILE, renderPath: 'deferred' }).toMatchObject({
+      pipelineId: STANDARD_PIPELINE_ID,
+      renderPath: 'deferred',
+    });
   });
 
   it('keeps the color-domain stage order stable for all profiles', () => {
@@ -60,13 +54,4 @@ describe('Standard profile oracle', () => {
       'present',
     ]);
   });
-
-  it('keeps current-main post-processing defaults in the Standard profile', () => {
-    expect(DEFAULT_STANDARD_PROFILE).toMatchObject({
-      tone: 'aces-filmic',
-      antialias: 'fxaa',
-      bloom: true,
-      sky: true,
-    });
-  });
 });