@forgeax/engine-render 0.1.7 → 0.1.20

package/src/__tests__/temporal-reset-matrix.unit.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+import { createTemporalView, HALTON_23_8, resolveTemporalReset } from '../temporal/view';
+
+const base = () =>
+  createTemporalView({
+    antialias: 'taa',
+    width: 100,
+    height: 100,
+    historyVersion: 1,
+    viewIdentity: 'main',
+    environmentSignature: 'environment:1',
+    fogSignature: 'fog:1',
+    deviceGeneration: 4,
+  });
+
+describe('TemporalView reset matrix', () => {
+  it.each([
+    ['width', { width: 101 }, 'resize'],
+    ['height', { height: 101 }, 'resize'],
+    ['camera cut', { cameraCut: true }, 'camera-cut'],
+    ['history version', { historyVersion: 2 }, 'history-version'],
+    ['view identity', { viewIdentity: 'secondary' }, 'view-switch'],
+    ['environment signature', { environmentSignature: 'environment:2' }, 'environment-change'],
+    ['fog signature', { fogSignature: 'fog:2' }, 'fog-change'],
+    ['device generation', { deviceGeneration: 5 }, 'device-recover'],
+  ] as const)('resets on %s', (_label, changes, reason) => {
+    const previous = base();
+    const next = createTemporalView({ ...previous.input, ...changes });
+    expect(resolveTemporalReset(previous, next)).toBe(reason);
+  });
+
+  it('does not reset a stable view', () => {
+    const previous = base();
+    const next = createTemporalView({ ...previous.input });
+    expect(resolveTemporalReset(previous, next)).toBeUndefined();
+  });
+
+  it('treats an explicit off commit as a first-frame boundary when TAA resumes', () => {
+    const previous = base();
+    const off = createTemporalView({
+      ...previous.input,
+      antialias: 'none',
+      frameIndex: previous.temporalFrameIndex,
+      historyValid: false,
+      previousUnjitteredViewProjection: undefined,
+    });
+    expect(off.mode).toBe('off');
+    expect(off.historyRequired).toBe(false);
+    expect(off.currentProjection).toBe('unjittered');
+
+    const resumed = createTemporalView({
+      ...previous.input,
+      frameIndex: 0,
+      historyValid: false,
+      previousUnjitteredViewProjection: undefined,
+    });
+    expect(resolveTemporalReset(off, resumed)).toBe('first-frame');
+    expect(resumed.previousUnjitteredViewProjection).toBeUndefined();
+  });
+
+  it('reseeds the temporal sequence after a successful off commit', () => {
+    const lastTaa = createTemporalView({
+      ...base().input,
+      frameIndex: 5,
+      currentUnjitteredViewProjection: Float32Array.from({ length: 16 }, (_v, i) => i + 1),
+      previousUnjitteredViewProjection: Float32Array.from({ length: 16 }, (_v, i) => i + 2),
+    });
+    const off = createTemporalView({
+      ...lastTaa.input,
+      antialias: 'none',
+      frameIndex: lastTaa.temporalFrameIndex,
+      historyValid: false,
+      previousUnjitteredViewProjection: undefined,
+    });
+    const firstAfterOff = createTemporalView({
+      ...lastTaa.input,
+      frameIndex: 0,
+      historyValid: false,
+      previousUnjitteredViewProjection: undefined,
+      resetReason: resolveTemporalReset(off, lastTaa) ?? 'first-frame',
+    });
+    expect(firstAfterOff.temporalFrameIndex).toBe(0);
+    expect(firstAfterOff.jitter).toEqual(HALTON_23_8[0]);
+    expect(firstAfterOff.previousUnjitteredViewProjection).toBeUndefined();
+    expect(firstAfterOff.resetReason).toBe('first-frame');
+
+    const next = createTemporalView({
+      ...firstAfterOff.input,
+      frameIndex: firstAfterOff.temporalFrameIndex + 1,
+      historyValid: true,
+      previousUnjitteredViewProjection: firstAfterOff.currentUnjitteredViewProjection,
+      resetReason: undefined,
+    });
+    expect(next.temporalFrameIndex).toBe(1);
+    expect(next.jitter).toEqual(HALTON_23_8[1]);
+  });
+});

package/src/__tests__/temporal-transaction.integration.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+import { TemporalFrameCoordinator } from '../temporal/frame-coordinator';
+
+describe('temporal successful-submit transaction', () => {
+  it.each([
+    'build',
+    'encode',
+    'finish',
+    'submit',
+  ] as const)('does not publish state when %s fails', (stage) => {
+    const coordinator = new TemporalFrameCoordinator<number>();
+    const result = coordinator.run(
+      { current: 7, antialias: 'taa' },
+      {
+        build: () => {
+          if (stage === 'build') throw { stage };
+          return 7;
+        },
+        encode: () => {
+          if (stage === 'encode') throw { stage };
+        },
+        finish: () => {
+          if (stage === 'finish') throw { stage };
+        },
+        submit: () => {
+          if (stage === 'submit') throw { stage };
+        },
+      },
+    );
+    expect(result.ok).toBe(false);
+    expect(coordinator.inspect()).toMatchObject({
+      epoch: 0,
+      previous: undefined,
+      attempt: 'aborted',
+    });
+  });
+
+  it('publishes current and advances history only after submit', () => {
+    const coordinator = new TemporalFrameCoordinator<number>();
+    const result = coordinator.run(
+      { current: 3, antialias: 'taa' },
+      { build: () => 3, encode: () => undefined, finish: () => undefined, submit: () => undefined },
+    );
+    expect(result).toMatchObject({ ok: true, value: { epoch: 1, previous: 3 } });
+    expect(coordinator.inspect()).toMatchObject({ epoch: 1, previous: 3, attempt: 'committed' });
+  });
+
+  it.each([
+    'cut',
+    'resize',
+    'camera-switch',
+    'detach',
+    'device-loss',
+  ] as const)('resets history on %s', (reason) => {
+    const coordinator = new TemporalFrameCoordinator<number>({ previous: 1, epoch: 3 });
+    coordinator.reset(reason);
+    expect(coordinator.inspect()).toMatchObject({ epoch: 0, previous: undefined, attempt: 'none' });
+    expect(coordinator.historyStore.inspect().valid).toBe(false);
+  });
+});

package/src/__tests__/temporal-view.unit.test.ts

@@ -0,0 +1,152 @@
+import type { RhiQueue } from '@forgeax/engine-rhi';
+import { describe, expect, it } from 'vitest';
+import { writeViewUbo } from '../record/view-ubo';
+import type { CameraSnapshot } from '../render-contract';
+import type { DirectionalLightSnapshot, ExtractedLights } from '../render-system-extract';
+import {
+  createTemporalView,
+  HALTON_23_8,
+  resolveTemporalReset,
+  type TemporalResetReason,
+} from '../temporal/view';
+
+describe('TemporalView v1', () => {
+  it('uses the fixed eight-sample Halton(2,3) sequence', () => {
+    expect(HALTON_23_8).toEqual([
+      [0, -1 / 6],
+      [-0.25, 1 / 6],
+      [0.25, -5 / 18],
+      [-0.375, -1 / 18],
+      [0.125, 5 / 18],
+      [-0.125, -7 / 54],
+      [0.375, 11 / 54],
+      [-0.4375, 7 / 18],
+    ]);
+  });
+
+  it('keeps jittered current projection separate from unjittered previous projection', () => {
+    const view = createTemporalView({
+      antialias: 'taa',
+      width: 1280,
+      height: 720,
+      frameIndex: 3,
+      viewIdentity: 'camera:main',
+    });
+    const jitter = (HALTON_23_8[3] ?? [0, 0]) as readonly [number, number];
+    expect(view.jitter).toEqual(jitter);
+    expect(view.currentProjection).toBe('jittered');
+    expect(view.previousProjection).toBe('unjittered');
+    expect(view.jitterCancellationUv).toEqual([jitter[0] / 1280, jitter[1] / 720]);
+  });
+
+  it.each([
+    ['first-frame', undefined, 'first-frame'],
+    ['resize', { width: 640, height: 360 }, 'resize'],
+    ['camera-cut', { cameraCut: true }, 'camera-cut'],
+    ['history-version', { historyVersion: 2 }, 'history-version'],
+    ['view-switch', { viewIdentity: 'camera:secondary' }, 'view-switch'],
+    ['environment-change', { environmentSignature: 'env:2' }, 'environment-change'],
+    ['fog-change', { fogSignature: 'fog:2' }, 'fog-change'],
+    ['device-recover', { deviceGeneration: 2 }, 'device-recover'],
+  ] as const)('reports %s as a deterministic reset reason', (reason, changes, expected) => {
+    const previous = createTemporalView({
+      antialias: 'taa',
+      width: 1280,
+      height: 720,
+      historyVersion: 1,
+      viewIdentity: 'camera:main',
+      environmentSignature: 'env:1',
+      fogSignature: 'fog:1',
+      deviceGeneration: 1,
+    });
+    const next = createTemporalView({
+      antialias: 'taa',
+      width: 1280,
+      height: 720,
+      historyVersion: 1,
+      viewIdentity: 'camera:main',
+      environmentSignature: 'env:1',
+      fogSignature: 'fog:1',
+      deviceGeneration: 1,
+      ...changes,
+    });
+    const resolved =
+      reason === 'first-frame'
+        ? resolveTemporalReset(undefined, next)
+        : resolveTemporalReset(previous, next);
+    expect(resolved).toBe(expected satisfies TemporalResetReason);
+  });
+
+  it('has no jitter or history requirement when antialias is off', () => {
+    const view = createTemporalView({ antialias: 'none', width: 320, height: 200 });
+    expect(view.mode).toBe('off');
+    expect(view.jitter).toBeUndefined();
+    expect(view.historyRequired).toBe(false);
+  });
+
+  it('writes a zero first-frame previous matrix and only the last successful matrix thereafter', () => {
+    const uploads: Float32Array[] = [];
+    const queue = {
+      writeBuffer: (_buffer: unknown, _offset: number, data: ArrayBufferView) => {
+        uploads.push(
+          new Float32Array(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength)),
+        );
+        return { ok: true, value: undefined };
+      },
+    } as unknown as RhiQueue;
+    const camera = {
+      position: new Float32Array([0, 0, 3]),
+      world: new Float32Array(16),
+      fov: Math.PI / 3,
+      aspect: 1,
+      near: 0.1,
+      far: 100,
+      projection: 'perspective',
+      orthoLeft: -1,
+      orthoRight: 1,
+      orthoBottom: -1,
+      orthoTop: 1,
+      tonemap: 'none',
+      exposure: 1,
+      whitePoint: 1,
+      antialias: 'taa',
+      bloom: 'disabled',
+      bloomThreshold: 1,
+      bloomIntensity: 0,
+      bloomBlurRadius: 0,
+      clearColor: [0, 0, 0, 1] as const,
+    } as unknown as CameraSnapshot;
+    const light = {
+      kind: 'directional',
+      direction: new Float32Array([0, -1, 0]),
+      color: new Float32Array([1, 1, 1]),
+      intensity: 1,
+    } as unknown as DirectionalLightSnapshot;
+    const lights = {
+      directional: light,
+      directionalCount: 1,
+      point: [],
+      spot: [],
+      lightViewProj: undefined,
+      splitPlanes: undefined,
+    } as unknown as ExtractedLights;
+    const buffer = {} as Parameters<typeof writeViewUbo>[1];
+    const first = createTemporalView({ antialias: 'taa', width: 4, height: 4, frameIndex: 0 });
+    writeViewUbo(queue, buffer, camera, light, lights, [], undefined, first);
+    expect(Array.from(uploads[0]?.slice(212, 228) ?? [])).toEqual(new Array(16).fill(0));
+
+    const previous = Float32Array.from({ length: 16 }, (_value, index) => index + 1);
+    const second = createTemporalView({
+      antialias: 'taa',
+      width: 4,
+      height: 4,
+      frameIndex: 1,
+      previousUnjitteredViewProjection: previous,
+    });
+    writeViewUbo(queue, buffer, camera, light, lights, [], undefined, second);
+    expect(Array.from(uploads[1]?.slice(212, 228) ?? [])).toEqual(Array.from(previous));
+
+    writeViewUbo(queue, buffer, camera, light, lights, [], undefined, second);
+    expect(Array.from(uploads[2]?.slice(212, 228) ?? [])).toEqual(Array.from(previous));
+  });
+});

package/src/__tests__/transmission-prewarm.unit.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest';
+import {
+  type MaterialShaderManifestEntry,
+  selectHdrpPbrPrewarmVariants,
+  selectStandardPbrTransmissionPrewarmVariants,
+} from '../assembly/factory.js';
+
+const falseKey =
+  'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+TRANSMISSION_AVAILABLE=false+VERTEX_COLOR_AVAILABLE=false';
+const trueKey =
+  'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+TRANSMISSION_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=false';
+const hdrpFalseKey =
+  'CLUSTER_FORWARD_AVAILABLE=true+STORAGE_BUFFER_AVAILABLE=true+TRANSMISSION_AVAILABLE=false+VERTEX_COLOR_AVAILABLE=false';
+const hdrpTrueKey =
+  'CLUSTER_FORWARD_AVAILABLE=true+STORAGE_BUFFER_AVAILABLE=true+TRANSMISSION_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=false';
+
+function standardEntry(
+  variants: readonly MaterialShaderManifestEntry['variants'][number][],
+): MaterialShaderManifestEntry {
+  return {
+    identifier: 'forgeax::default-standard-pbr',
+    sourcePath: 'default-standard-pbr.wgsl',
+    composedWgsl: 'standard-default',
+    paramSchema: '[]',
+    variants,
+  };
+}
+
+function transmissionVariant(definesKey: string, transmission: boolean) {
+  return {
+    definesKey,
+    defines: {
+      CLUSTER_FORWARD_AVAILABLE: false,
+      STORAGE_BUFFER_AVAILABLE: true,
+      TRANSMISSION_AVAILABLE: transmission,
+      VERTEX_COLOR_AVAILABLE: false,
+    },
+    composedWgsl: `standard-${transmission}`,
+  };
+}
+
+function hdrpVariant(definesKey: string, transmission: boolean) {
+  return {
+    definesKey,
+    defines: {
+      CLUSTER_FORWARD_AVAILABLE: true,
+      STORAGE_BUFFER_AVAILABLE: true,
+      TRANSMISSION_AVAILABLE: transmission,
+      VERTEX_COLOR_AVAILABLE: false,
+    },
+    composedWgsl: `hdrp-${transmission}`,
+  };
+}
+
+describe('Standard transmission exact-key prewarm selection', () => {
+  it('returns both declared variants through exact manifest lookup', () => {
+    const entry = standardEntry([
+      transmissionVariant(falseKey, false),
+      transmissionVariant(trueKey, true),
+    ]);
+    const selected = selectStandardPbrTransmissionPrewarmVariants(entry, true);
+    expect(selected.map((variant) => variant.definesKey)).toEqual([falseKey, trueKey]);
+  });
+
+  it('fails when the manifest does not declare an exact transmission key', () => {
+    const entry = standardEntry([transmissionVariant(falseKey, false)]);
+    expect(() => selectStandardPbrTransmissionPrewarmVariants(entry, true)).toThrow(
+      'TRANSMISSION_AVAILABLE=true',
+    );
+  });
+
+  it('fails when the Standard material shader manifest row is missing', () => {
+    expect(() => selectStandardPbrTransmissionPrewarmVariants(undefined, true)).toThrow(
+      'manifest row is missing',
+    );
+  });
+});
+
+describe('HDRP PBR prewarm capability selection', () => {
+  const entry = standardEntry([hdrpVariant(hdrpFalseKey, false), hdrpVariant(hdrpTrueKey, true)]);
+
+  it('does not compile the transmission variant below the sampled-texture limit', () => {
+    expect(
+      selectHdrpPbrPrewarmVariants(entry, true, false).map((variant) => variant.definesKey),
+    ).toEqual([hdrpFalseKey]);
+  });
+
+  it('retains both HDRP variants when transmission is supported', () => {
+    expect(
+      selectHdrpPbrPrewarmVariants(entry, true, true).map((variant) => variant.definesKey),
+    ).toEqual([hdrpFalseKey, hdrpTrueKey]);
+  });
+});

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

@@ -1,3 +1,4 @@
+import { readFileSync } from 'node:fs';
 import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
 import type { RhiDevice } from '@forgeax/engine-rhi';
 import { rhi } from '@forgeax/engine-rhi-null';
@@ -5,11 +6,13 @@ import { ok } from '@forgeax/engine-types';
 import { beforeAll, describe, expect, it } from 'vitest';
 import { standardPipeline } from '../pipeline/standard-pipeline';
 import { DEFAULT_STANDARD_PROFILE } from '../pipeline/standard-profile';
+import { isMotionBlurTemporalDemand } from '../record/typed-frame-graph';
 import type {
   RenderPipeline,
   RenderPipelineFrame,
   RenderPipelineTopology,
 } from '../render-pipeline';
+import { standardTemporalPostOrder } from '../temporal/standard-scene-data';
 
 let device: RhiDevice;
 
@@ -56,9 +59,13 @@ function topology(
 
 function compile(pipeline: RenderPipeline, input: RenderPipelineTopology) {
   const graph = new RenderGraphBuilder<RenderPipelineFrame>();
+  const importedHistory =
+    input.camera.antialias === 'taa' ? createImportedHistory(graph) : undefined;
   const built = pipeline.build(
     {
       graph,
+      capabilities: { rgba16floatRenderable: true },
+      ...(importedHistory === undefined ? {} : { taaHistory: importedHistory }),
       projectGpuDriven: () => ok(undefined),
       contributeFeatures: () => ok(undefined),
     },
@@ -71,7 +78,62 @@ function compile(pipeline: RenderPipeline, input: RenderPipelineTopology) {
   });
 }
 
+function createImportedHistory(graph: RenderGraphBuilder<RenderPipelineFrame>) {
+  const target = (label: string) => {
+    const texture = graph.importTexture(
+      label,
+      { format: 'rgba16float', size: 'surface', usage: 0x17 },
+      (frame) => frame.currentTexture,
+    );
+    if (!texture.ok) throw texture.error;
+    const view = graph.importView(texture.value, { label: `${label}.view` }, (frame) => frame.view);
+    if (!view.ok) throw view.error;
+    return {
+      texture: texture.value,
+      view: view.value,
+      format: 'rgba16float' as const,
+      sampleCount: 1 as const,
+    };
+  };
+  return {
+    currentColor: target('taa-history-current-color'),
+    previousColor: target('taa-history-previous-color'),
+    currentTemporal: target('taa-history-current-temporal'),
+    previousTemporal: target('taa-history-previous-temporal'),
+  };
+}
+
 describe('typed built-in pipeline topology', () => {
+  it('declares explicit output target domain and avoids alternate sRGB views', () => {
+    const source = readFileSync(new URL('../render-pipeline.ts', import.meta.url), 'utf8');
+    const postChainSource = readFileSync(
+      new URL('../pipeline/standard-post.ts', import.meta.url),
+      'utf8',
+    );
+    expect(source).toContain('domain');
+    expect(source).toContain("'display-encoded'");
+    expect(postChainSource).toContain("'rgba16float'");
+    expect(source).not.toContain('viewFormats: [topology.surface.viewFormat]');
+  });
+
+  it('declares stable JSON-safe output and observation inspection facts', () => {
+    const source = readFileSync(new URL('../render-contract.ts', import.meta.url), 'utf8');
+    for (const field of [
+      'outputTransform',
+      'displayEncoded',
+      'intermediateFormat',
+      'surfaceStorage',
+      'surfaceDisplay',
+      'endpoint',
+      'capability',
+      'observationId',
+      'frameId',
+    ]) {
+      expect(source).toContain(field);
+    }
+    expect(source).not.toContain('pixelPayload');
+  });
+
   it('orders HDRP compute, shadow, deferred, SSAO, forward, observation, and output work', () => {
     const compiled = compile(
       standardPipeline,
@@ -91,7 +153,7 @@ describe('typed built-in pipeline topology', () => {
       'lighting',
       'forward',
       'linear-hdr-observation',
-      'tonemap',
+      'output-transform',
     ];
     for (let index = 1; index < ordered.length; index += 1) {
       expect(names.indexOf(ordered[index] ?? '')).toBeGreaterThan(
@@ -204,6 +266,152 @@ describe('typed built-in pipeline topology', () => {
     expect(info.passes.some((pass) => pass.name.startsWith('post-effect-'))).toBe(false);
   });
 
+  it('declares one TAA producer and resolve for TAA demand', () => {
+    const compiled = compile(
+      standardPipeline,
+      topology('forgeax::standard', {
+        camera: { tonemap: 'aces-filmic', antialias: 'taa', bloom: 'off' },
+      }),
+    );
+    expect(compiled.ok).toBe(true);
+    if (!compiled.ok) return;
+    const names = compiled.value.inspect().passes.map((pass) => pass.name);
+    expect(names.filter((name) => name === 'standard-scene-data')).toHaveLength(1);
+    expect(names.filter((name) => name === 'taa-resolve')).toHaveLength(1);
+    expect(names.filter((name) => name.includes('taa')).length).toBe(1);
+    expect(compiled.value.inspect().resources.map((resource) => resource.label)).toEqual(
+      expect.arrayContaining([
+        'taa-history-current-color',
+        'taa-history-previous-color',
+        'taa-history-current-temporal',
+        'taa-history-previous-temporal',
+      ]),
+    );
+    expect(
+      compiled.value.inspect().passes.find((pass) => pass.name === 'taa-resolve')?.accesses,
+    ).toEqual(
+      expect.arrayContaining([
+        { resource: 'taa-history-previous-color', usage: 'sampled-read' },
+        { resource: 'taa-history-previous-temporal', usage: 'sampled-read' },
+      ]),
+    );
+  });
+
+  it('fails closed when TAA history imports are missing', () => {
+    const graph = new RenderGraphBuilder<RenderPipelineFrame>();
+    const built = standardPipeline.build(
+      {
+        graph,
+        capabilities: { rgba16floatRenderable: true },
+        projectGpuDriven: () => ok(undefined),
+        contributeFeatures: () => ok(undefined),
+      },
+      topology('forgeax::standard', {
+        camera: { tonemap: 'aces-filmic', antialias: 'taa', bloom: 'off' },
+      }),
+    );
+    expect(built.ok).toBe(false);
+    if (built.ok) return;
+    expect(built.error).toMatchObject({
+      code: 'scene-data-unavailable',
+      detail: { reason: 'producer-missing' },
+    });
+  });
+
+  it('uses an owned scene intermediate for CPU WebGL2 temporal output', () => {
+    const compiled = compile(
+      standardPipeline,
+      topology('forgeax::standard', {
+        camera: { tonemap: 'none', antialias: 'taa', bloom: 'off' },
+        temporal: { taa: true, motionBlur: true },
+        lane: {
+          compute: false,
+          storageBuffer: false,
+          multisample: false,
+          maxColorAttachments: 4,
+        },
+      }),
+    );
+    expect(compiled.ok).toBe(true);
+    if (!compiled.ok) return;
+
+    const info = compiled.value.inspect();
+    const names = info.passes.map((pass) => pass.name);
+    const ordered = ['standard-scene-data', 'taa-resolve', 'motion-blur', 'output-transform'];
+    for (let index = 1; index < ordered.length; index += 1) {
+      expect(names.indexOf(ordered[index] ?? '')).toBeGreaterThan(
+        names.indexOf(ordered[index - 1] ?? ''),
+      );
+    }
+
+    const sceneColor = info.resources.find((resource) => resource.label === 'scene-color');
+    const surface = info.resources.find((resource) => resource.label === 'surface');
+    expect(sceneColor?.origin).toBe('created');
+    expect(sceneColor?.derivedUsage).toBeGreaterThanOrEqual(0x04);
+    expect(surface?.derivedUsage).toBe(0x10);
+
+    const resolve = info.passes.find((pass) => pass.name === 'taa-resolve');
+    expect(resolve?.accesses).toContainEqual({
+      resource: 'scene-color',
+      usage: 'sampled-read',
+    });
+    const motionBlur = info.passes.find((pass) => pass.name === 'motion-blur');
+    expect(motionBlur?.accesses).toContainEqual({
+      resource: 'motion-blurred-color',
+      usage: 'color-attachment',
+    });
+    expect(motionBlur?.accesses).toContainEqual({
+      resource: 'taa-history-current-color',
+      usage: 'sampled-read',
+    });
+    const output = info.passes.find((pass) => pass.name === 'output-transform');
+    expect(output?.accesses).toContainEqual({
+      resource: 'motion-blurred-color',
+      usage: 'sampled-read',
+    });
+    expect(output?.accesses).toContainEqual({ resource: 'surface', usage: 'color-attachment' });
+  });
+
+  it('keeps none and fxaa free of temporal topology', () => {
+    for (const antialias of ['none', 'fxaa'] as const) {
+      const compiled = compile(
+        standardPipeline,
+        topology('forgeax::standard', {
+          camera: { tonemap: 'aces-filmic', antialias, bloom: 'off' },
+        }),
+      );
+      expect(compiled.ok).toBe(true);
+      if (!compiled.ok) continue;
+      const names = compiled.value.inspect().passes.map((pass) => pass.name);
+      expect(names.some((name) => name.includes('taa'))).toBe(false);
+      expect(names.some((name) => name.includes('temporal'))).toBe(false);
+    }
+  });
+
+  it('keeps zero-shutter Motion Blur free of temporal target and passes', () => {
+    expect(
+      isMotionBlurTemporalDemand({ shutterAngle: 0, maxRadiusPixels: 32, sampleCount: 8 }),
+    ).toBe(false);
+    const compiled = compile(
+      standardPipeline,
+      topology('forgeax::standard', {
+        camera: { tonemap: 'aces-filmic', antialias: 'none', bloom: 'off' },
+        temporal: { taa: false, motionBlur: false },
+      }),
+    );
+    expect(compiled.ok).toBe(true);
+    if (!compiled.ok) return;
+    const info = compiled.value.inspect();
+    expect(info.resources.filter((resource) => resource.label.includes('temporal'))).toHaveLength(
+      0,
+    );
+    expect(
+      info.passes.filter((pass) =>
+        ['standard-scene-data', 'taa-resolve', 'motion-blur'].includes(pass.name),
+      ),
+    ).toHaveLength(0);
+  });
+
   it('returns a structured HDRP capability refusal before graph compilation', () => {
     const built = compile(
       standardPipeline,
@@ -221,3 +429,24 @@ describe('typed built-in pipeline topology', () => {
     if (!built.ok) expect(built.error.code).toBe('hdrp-deferred-caps-insufficient');
   });
 });
+
+describe('Standard temporal post topology', () => {
+  it('orders TAA then Motion Blur before Bloom and tone', () => {
+    expect(standardTemporalPostOrder({ taa: true, motionBlur: true, bloom: true })).toEqual([
+      'scene',
+      'standard-scene-data',
+      'taa-resolve',
+      'motion-blur',
+      'bloom',
+      'tone',
+      'output',
+    ]);
+  });
+
+  it('does not reserve temporal work when both consumers are disabled', () => {
+    expect(standardTemporalPostOrder({ taa: false, motionBlur: false, bloom: false })).toEqual([
+      'scene',
+      'output',
+    ]);
+  });
+});