@forgeax/engine-render 0.1.3 → 0.1.6

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',
+    ]);
+  });
+});

package/src/__tests__/surface-configuration.unit.test.ts

@@ -1,8 +1,7 @@
 import type { RhiCanvasContext, RhiDevice } from '@forgeax/engine-rhi';
 import { ok } from '@forgeax/engine-rhi';
 import { describe, expect, it, vi } from 'vitest';
-import { configureSurface } from '../render-system';
-import { resolveSurfaceFormatPair } from '../surface-format';
+import { configureSurface, resolveSurfaceFormatPair } from '../render-system';
 
 function device(backendKind: 'webgpu' | 'wgpu-webgl2', storageBuffer = false): RhiDevice {
   return {

package/src/__tests__/texture-usage-surface.unit.test.ts

@@ -13,12 +13,9 @@ const consumerSources = [
   readFileSync(new URL('../render-data.ts', import.meta.url), 'utf8'),
   readFileSync(new URL('../shadow-atlas.ts', import.meta.url), 'utf8'),
   readFileSync(new URL('../ssao-buffers.ts', import.meta.url), 'utf8'),
-  readFileSync(new URL('../hdrp-buffers.ts', import.meta.url), 'utf8'),
-  readFileSync(new URL('../gpu-resource-store.ts', import.meta.url), 'utf8'),
-  readFileSync(new URL('../render-system.ts', import.meta.url), 'utf8'),
+  readFileSync(new URL('../device/gpu-residency.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('../renderer/renderer-factory.ts', import.meta.url), 'utf8'),
 ];
 
 describe('texture usage owner', () => {
@@ -46,8 +43,8 @@ describe('texture usage owner', () => {
 
   it('keeps typed pipelines on graph access declarations instead of physical usage bits', async () => {
     const graphOwners = await Promise.all([
-      readFileSync(new URL('../hdrp-pipeline.ts', import.meta.url), 'utf8'),
-      readFileSync(new URL('../urp-pipeline.ts', import.meta.url), 'utf8'),
+      readFileSync(new URL('../pipeline/standard-forward-lane.ts', import.meta.url), 'utf8'),
+      readFileSync(new URL('../pipeline/standard-pipeline.ts', import.meta.url), 'utf8'),
       readFileSync(new URL('../typed-shadow-passes.ts', import.meta.url), 'utf8'),
     ]);
     for (const source of graphOwners) {

package/src/__tests__/typed-pipeline-topology.unit.test.ts

@@ -3,15 +3,13 @@ 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 { hdrpPipeline } from '../hdrp-pipeline';
+import { standardPipeline } from '../pipeline/standard-pipeline';
+import { DEFAULT_STANDARD_PROFILE } from '../pipeline/standard-profile';
 import type {
   RenderPipeline,
   RenderPipelineFrame,
   RenderPipelineTopology,
 } from '../render-pipeline';
-import { createRenderPipelineTemporalContract } from '../render-pipeline';
-import { createRenderPipelineTarget } from '../render-pipeline-target';
-import { urpPipeline } from '../urp-pipeline';
 
 let device: RhiDevice;
 
@@ -24,7 +22,7 @@ beforeAll(async () => {
 });
 
 function topology(
-  pipelineId: 'forgeax::urp' | 'forgeax::hdrp',
+  pipelineId: 'forgeax::standard',
   overrides: Partial<RenderPipelineTopology> = {},
 ): RenderPipelineTopology {
   return {
@@ -58,55 +56,27 @@ function topology(
 
 function compile(pipeline: RenderPipeline, input: RenderPipelineTopology) {
   const graph = new RenderGraphBuilder<RenderPipelineFrame>();
-  const temporal = createRenderPipelineTemporalContract({
-    enabled: input.camera.antialias === 'taa',
-    rgba16floatRenderable: true,
-    maxColorAttachments: input.lane.maxColorAttachments,
-    project: (targets) => ok({ resolvedColor: targets.sceneColor }),
-  });
   const built = pipeline.build(
     {
       graph,
       projectGpuDriven: () => ok(undefined),
       contributeFeatures: () => ok(undefined),
-      resolveTemporal: temporal.resolve,
     },
     input,
   );
   if (!built.ok) return built;
-  const finished = temporal.finish();
-  if (!finished.ok) return finished;
   return graph.compile({
     device,
     surfaceSize: { width: input.surface.width, height: input.surface.height },
   });
 }
 
-function projectTemporal(
-  graph: RenderGraphBuilder<RenderPipelineFrame>,
-  targets: Parameters<ReturnType<typeof createRenderPipelineTemporalContract>['resolve']>[0],
-) {
-  const output = createRenderPipelineTarget(graph, 'test-taa-resolved-color', {
-    format: 'rgba16float',
-    size: 'surface',
-  });
-  if (!output.ok) return output;
-  const pass = graph.addCopyPass('taa-resolve', {
-    accesses: [
-      { resource: targets.sceneColor.view, usage: 'copy-src' },
-      { resource: output.value.view, usage: 'copy-dst' },
-    ],
-    encode: () => undefined,
-  });
-  return pass.ok ? ok({ resolvedColor: { kind: 'scene-color' as const, ...output.value } }) : pass;
-}
-
 describe('typed built-in pipeline topology', () => {
   it('orders HDRP compute, shadow, deferred, SSAO, forward, observation, and output work', () => {
     const compiled = compile(
-      hdrpPipeline,
-      topology('forgeax::hdrp', {
-        config: { ssao: { enabled: true } },
+      standardPipeline,
+      topology('forgeax::standard', {
+        standardProfile: { ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered', ssao: true },
       }),
     );
     expect(compiled.ok).toBe(true);
@@ -151,8 +121,9 @@ describe('typed built-in pipeline topology', () => {
 
   it('omits SSAO and compute membership on the bounded fallback lane', () => {
     const compiled = compile(
-      hdrpPipeline,
-      topology('forgeax::hdrp', {
+      standardPipeline,
+      topology('forgeax::standard', {
+        standardProfile: { ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered' },
         config: { ssao: { enabled: false } },
         lane: {
           compute: false,
@@ -171,8 +142,8 @@ describe('typed built-in pipeline topology', () => {
 
   it('keeps URP post effects after output and before debug overlay', () => {
     const compiled = compile(
-      urpPipeline,
-      topology('forgeax::urp', {
+      standardPipeline,
+      topology('forgeax::standard', {
         config: { postEffects: ['example::a', 'example::b'] },
       }),
     );
@@ -185,14 +156,37 @@ describe('typed built-in pipeline topology', () => {
     expect(names.indexOf('post-effect-1')).toBeGreaterThan(names.indexOf('post-effect-0'));
     expect(names.indexOf('debug-overlay')).toBeGreaterThan(names.indexOf('post-effect-1'));
     expect(info.resources.map((resource) => resource.label)).toEqual(
-      expect.arrayContaining(['post-effect-scratch-0', 'post-effect-scratch-1']),
+      expect.arrayContaining([
+        'post-effect-scratch-0',
+        'post-effect-output-0',
+        'post-effect-scratch-1',
+      ]),
     );
+    const copy0 = info.passes.find((pass) => pass.name === 'post-effect-copy-0');
+    const effect0 = info.passes.find((pass) => pass.name === 'post-effect-0');
+    const copy1 = info.passes.find((pass) => pass.name === 'post-effect-copy-1');
+    const effect1 = info.passes.find((pass) => pass.name === 'post-effect-1');
+    expect(copy0?.accesses).toContainEqual({ resource: 'surface', usage: 'copy-src' });
+    expect(copy1?.accesses).toContainEqual({
+      resource: 'post-effect-output-0',
+      usage: 'copy-src',
+    });
+    expect(effect0?.accesses).toContainEqual({
+      resource: 'post-effect-output-0',
+      usage: 'color-attachment',
+    });
+    expect(effect1?.accesses).toContainEqual({
+      resource: 'surface',
+      usage: 'color-attachment',
+    });
+    expect(copy1?.dependencies).toContain('post-effect-0');
+    expect(effect1?.dependencies).toContain('post-effect-copy-1');
   });
 
   it('removes unsupported MSAA and composite post work on the fallback lane', () => {
     const compiled = compile(
-      urpPipeline,
-      topology('forgeax::urp', {
+      standardPipeline,
+      topology('forgeax::standard', {
         camera: { tonemap: 'none', antialias: 'msaa', bloom: 'off' },
         config: { postEffects: ['example::a'] },
         lane: {
@@ -212,8 +206,9 @@ describe('typed built-in pipeline topology', () => {
 
   it('returns a structured HDRP capability refusal before graph compilation', () => {
     const built = compile(
-      hdrpPipeline,
-      topology('forgeax::hdrp', {
+      standardPipeline,
+      topology('forgeax::standard', {
+        standardProfile: { ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered' },
         lane: {
           compute: true,
           storageBuffer: true,
@@ -225,165 +220,4 @@ describe('typed built-in pipeline topology', () => {
     expect(built.ok).toBe(false);
     if (!built.ok) expect(built.error.code).toBe('hdrp-deferred-caps-insufficient');
   });
-
-  it.each([
-    ['forgeax::urp', urpPipeline],
-    ['forgeax::hdrp', hdrpPipeline],
-  ] as const)('calls the renderer temporal seam exactly once in %s', (pipelineId, pipeline) => {
-    const graph = new RenderGraphBuilder<RenderPipelineFrame>();
-    let projected = 0;
-    const input = topology(pipelineId, {
-      camera: { tonemap: 'aces-filmic', antialias: 'taa', bloom: 'on' },
-    });
-    const temporal = createRenderPipelineTemporalContract({
-      enabled: true,
-      rgba16floatRenderable: true,
-      maxColorAttachments: 8,
-      project: (targets) => {
-        projected += 1;
-        return projectTemporal(graph, targets);
-      },
-    });
-    const built = pipeline.build(
-      {
-        graph,
-        projectGpuDriven: () => ok(undefined),
-        contributeFeatures: () => ok(undefined),
-        resolveTemporal: temporal.resolve,
-      },
-      input,
-    );
-    expect(built.ok).toBe(true);
-    expect(temporal.finish().ok).toBe(true);
-    expect(temporal.inspect()).toEqual({ resolveCount: 1 });
-    expect(projected).toBe(1);
-    const compiled = graph.compile({
-      device,
-      surfaceSize: { width: input.surface.width, height: input.surface.height },
-    });
-    expect(compiled.ok).toBe(true);
-    if (!compiled.ok) return;
-    const names = compiled.value.inspect().passes.map((pass) => pass.name);
-    expect(names.filter((name) => name === 'scene-temporal')).toHaveLength(1);
-    expect(names.indexOf('scene-temporal')).toBeGreaterThan(
-      names.indexOf(pipelineId === 'forgeax::urp' ? 'main' : 'forward'),
-    );
-    expect(names.filter((name) => name === 'taa-resolve')).toHaveLength(1);
-    expect(names.indexOf('taa-resolve')).toBeGreaterThan(names.indexOf('scene-temporal'));
-    const temporalPass = compiled.value
-      .inspect()
-      .passes.find((pass) => pass.name === 'scene-temporal');
-    expect(temporalPass?.kind).toBe('raster');
-    expect(temporalPass?.accesses).toEqual(
-      expect.arrayContaining([
-        { resource: 'scene-temporal', usage: 'color-attachment' },
-        {
-          resource: 'scene-temporal-depth',
-          usage: 'depth-stencil-write',
-        },
-      ]),
-    );
-    expect(temporalPass?.accesses).not.toContainEqual({
-      resource: pipelineId === 'forgeax::urp' ? 'scene-depth' : 'hdrp-depth',
-      usage: 'depth-stencil-write',
-    });
-    expect(names.indexOf('linear-hdr-observation')).toBeGreaterThan(names.indexOf('taa-resolve'));
-    expect(names.indexOf('bloom-bright')).toBeGreaterThan(names.indexOf('taa-resolve'));
-    expect(names.indexOf('tonemap')).toBeGreaterThan(names.indexOf('taa-resolve'));
-    expect(names.indexOf('debug-overlay')).toBeGreaterThan(names.indexOf('tonemap'));
-  });
-
-  it('rejects custom TAA pipelines that omit or duplicate the resolve seam', () => {
-    const input = topology('forgeax::urp', {
-      camera: { tonemap: 'none', antialias: 'taa', bloom: 'off' },
-    });
-    const omitted = createRenderPipelineTemporalContract({
-      enabled: true,
-      rgba16floatRenderable: true,
-      maxColorAttachments: 8,
-      project: (targets) => ok({ resolvedColor: targets.sceneColor }),
-    });
-    const missing = omitted.finish();
-    expect(missing.ok).toBe(false);
-    if (!missing.ok) {
-      expect(missing.error.code).toBe('temporal-unsupported');
-      if (missing.error.code === 'temporal-unsupported') {
-        expect(missing.error.detail).toMatchObject({ reason: 'resolve-count' });
-      }
-    }
-
-    const graph = new RenderGraphBuilder<RenderPipelineFrame>();
-    const color = graph.createTexture('custom-color', { format: 'rgba16float', size: 'surface' });
-    const depth = graph.createTexture('custom-depth', { format: 'depth24plus', size: 'surface' });
-    const temporalTexture = graph.createTexture('custom-temporal', {
-      format: 'rgba16float',
-      size: 'surface',
-    });
-    expect(color.ok && depth.ok && temporalTexture.ok).toBe(true);
-    if (!color.ok || !depth.ok || !temporalTexture.ok) return;
-    const colorView = graph.view(color.value);
-    const depthView = graph.view(depth.value);
-    const temporalView = graph.view(temporalTexture.value);
-    expect(colorView.ok && depthView.ok && temporalView.ok).toBe(true);
-    if (!colorView.ok || !depthView.ok || !temporalView.ok) return;
-    const targets = {
-      sceneColor: {
-        kind: 'scene-color' as const,
-        texture: color.value,
-        view: colorView.value,
-        format: 'rgba16float',
-        sampleCount: 1 as const,
-      },
-      sceneDepth: {
-        kind: 'scene-depth' as const,
-        texture: depth.value,
-        view: depthView.value,
-        format: 'depth24plus',
-        sampleCount: 1 as const,
-      },
-      sceneTemporal: {
-        kind: 'scene-temporal' as const,
-        texture: temporalTexture.value,
-        view: temporalView.value,
-        format: 'rgba16float',
-        sampleCount: 1 as const,
-      },
-    };
-    const duplicate = createRenderPipelineTemporalContract({
-      enabled: input.camera.antialias === 'taa',
-      rgba16floatRenderable: true,
-      maxColorAttachments: 8,
-      project: (value) => ok({ resolvedColor: value.sceneColor }),
-    });
-    expect(duplicate.resolve(targets).ok).toBe(true);
-    const second = duplicate.resolve(targets);
-    expect(second.ok).toBe(false);
-    if (!second.ok) {
-      expect(second.error.code).toBe('temporal-unsupported');
-      if (second.error.code === 'temporal-unsupported') {
-        expect(second.error.detail).toMatchObject({ reason: 'resolve-count' });
-      }
-    }
-
-    const insufficient = createRenderPipelineTemporalContract({
-      enabled: true,
-      rgba16floatRenderable: false,
-      maxColorAttachments: 1,
-      project: (value) => ok({ resolvedColor: value.sceneColor }),
-    }).resolve(targets);
-    expect(insufficient.ok).toBe(false);
-    if (!insufficient.ok) expect(insufficient.error.code).toBe('taa-caps-insufficient');
-
-    const invalidDomain = createRenderPipelineTemporalContract({
-      enabled: true,
-      rgba16floatRenderable: true,
-      maxColorAttachments: 8,
-      project: (value) => ok({ resolvedColor: value.sceneColor }),
-    }).resolve({
-      ...targets,
-      sceneColor: { ...targets.sceneColor, format: 'bgra8unorm' },
-    });
-    expect(invalidDomain.ok).toBe(false);
-    if (!invalidDomain.ok) expect(invalidDomain.error.code).toBe('temporal-unsupported');
-  });
 });

package/src/__tests__/urp-pipeline-targets.unit.test.ts

@@ -3,11 +3,10 @@ import { resolveStandardRenderFeatureTargets } from '../features/targets';
 
 function targets(
   tonemap: 'none' | 'aces-filmic',
-  antialias: 'none' | 'fxaa' | 'msaa' | 'taa',
+  antialias: 'none' | 'fxaa' | 'msaa',
   storageBuffer: boolean,
 ) {
   return resolveStandardRenderFeatureTargets({
-    pipelineId: 'forgeax::urp',
     tonemap,
     antialias,
     colorAttachmentFormat: 'bgra8unorm-srgb',
@@ -40,13 +39,4 @@ describe('urp render feature targets', () => {
       sampleCount: 1,
     });
   });
-
-  it('publishes packed temporal coverage only for TAA', () => {
-    expect(targets('none', 'taa', true)?.[2]).toMatchObject({
-      kind: 'scene-temporal',
-      format: 'rgba16float',
-      sampleCount: 1,
-    });
-    expect(targets('none', 'none', true)).toHaveLength(2);
-  });
 });

package/src/__tests__/urp-pipeline.unit.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, it } from 'vitest';
 import { resolvePostColorDomainContract } from '../render-pipeline';
 
-describe('URP post color-domain order', () => {
+describe('Standard forward post color-domain order', () => {
   it('declares the required linear-to-encoded stage sequence', () => {
-    expect(resolvePostColorDomainContract('urp')).toEqual([
+    expect(resolvePostColorDomainContract('linear-ldr')).toEqual([
       ['transparent-blend', 'linear-ldr', 'linear-ldr'],
       ['bloom', 'linear-hdr', 'linear-hdr'],
       ['tone', 'linear-hdr', 'linear-ldr'],

package/src/__tests__/vertex-color-pipeline.unit.test.ts

@@ -4,8 +4,12 @@ import {
 } from '@forgeax/engine-geometry';
 import type { VertexAttributeMap } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { variantSetFromVertexLayoutProjection } from '../pipeline';
-import { buildPipelineDescriptor, cacheKeyOf, type PipelineSpec } from '../pipeline-spec';
+import {
+  buildPipelineDescriptor,
+  cacheKeyOf,
+  type PipelineSpec,
+  variantSetFromVertexLayoutProjection,
+} from '../pipeline-spec';
 
 const baseAttributes = (): VertexAttributeMap => ({
   position: new Float32Array([0, 0, 0]),
@@ -93,6 +97,10 @@ describe('render vertex-color projection contract', () => {
         'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=true',
     });
     expect(variantSetFromVertexLayoutProjection(colored, '')).toEqual({ ok: true, value: '' });
+    expect(variantSetFromVertexLayoutProjection(plain, '')).toEqual({
+      ok: true,
+      value: 'VERTEX_COLOR_AVAILABLE=false',
+    });
   });
 
   it('does not allocate color stream bytes for a plain mesh', () => {