@forgeax/engine-render 0.1.28 → 0.1.30

package/src/__tests__/standard-pbr-artifact-assembly.unit.test.ts

@@ -0,0 +1,275 @@
+import { createStandardPbrArtifactReceipt } from '@forgeax/engine-shader';
+import { describe, expect, it } from 'vitest';
+import {
+  assembleStandardPbrArtifact,
+  resolveMaterialShaderArtifact,
+  resolveStandardPbrArtifact,
+} from '../assembly/material/assembly';
+
+const source = '@vertex fn vs_main() -> @builtin(position) vec4<f32> { return vec4(0.0); }';
+
+describe('Standard PBR artifact assembly', () => {
+  it('assembles the rigid registry entry from one receipt producer', () => {
+    const artifact = assembleStandardPbrArtifact('forgeax::default-standard-pbr', source);
+    const receipt = createStandardPbrArtifactReceipt();
+
+    expect(artifact).toBeDefined();
+    expect(artifact?.material).toBe('forgeax::default-standard-pbr');
+    expect(artifact?.wgsl).toBe(source);
+    expect(artifact?.layoutIdentity).toBe(receipt.reflection.layoutIdentity);
+    expect(artifact?.receipt).toEqual(receipt);
+    expect(artifact?.vertexInputs).toEqual(
+      receipt.vertexInputs.map(({ semantic, location, format }) => ({
+        semantic,
+        location,
+        format,
+      })),
+    );
+  });
+
+  it('retains shader UV aliases beyond the minimum geometry receipt after recovery', () => {
+    const receipt = createStandardPbrArtifactReceipt();
+    const wgsl = `struct VsIn { @location(2) uv: vec2<f32>, @location(12) uv7: vec2<f32>, }
+@vertex fn vs_scene_index(input: VsIn) -> @builtin(position) vec4<f32> { return vec4(input.uv, 0., 1.); }`;
+    const artifact = resolveMaterialShaderArtifact(
+      'forgeax::default-standard-pbr',
+      {
+        findMaterialArtifact: () => ({
+          ok: true,
+          value: { source: wgsl, paramSchema: [], receipt },
+        }),
+      } as unknown as Parameters<typeof resolveMaterialShaderArtifact>[1],
+      { address: 'scene-index' },
+    );
+    expect(artifact?.uvSetCount).toBe(8);
+    expect(artifact?.receipt).toBe(receipt);
+  });
+
+  it('adds the skin palette receipt facts for the skinned registry entry', () => {
+    const artifact = assembleStandardPbrArtifact('forgeax::default-standard-pbr-skin', source);
+    const receipt = createStandardPbrArtifactReceipt(true);
+
+    expect(artifact?.receipt).toEqual(receipt);
+    expect(artifact?.receipt?.skinPaletteAddress).toEqual({ group: 2, binding: 1, stride: 64 });
+    expect(artifact?.vertexInputs).toHaveLength(receipt.vertexInputs.length);
+  });
+
+  it('rejects unsupported shader identifiers without manufacturing an artifact', () => {
+    expect(assembleStandardPbrArtifact('forgeax::default-unlit', source)).toBeUndefined();
+  });
+
+  it('fails closed when a geometry-specific color fact has no matching producer receipt', () => {
+    expect(
+      assembleStandardPbrArtifact(
+        'forgeax::default-standard-pbr',
+        { source, paramSchema: [] },
+        { vertexColorAvailable: true },
+      ),
+    ).toBeUndefined();
+    expect(
+      assembleStandardPbrArtifact(
+        'forgeax::default-standard-pbr',
+        { source, paramSchema: [], receipt: createStandardPbrArtifactReceipt() },
+        { vertexColorAvailable: true },
+      ),
+    ).toBeUndefined();
+  });
+
+  it('selects the published COLOR_0 ABI and keeps colored/plain identities apart', () => {
+    const plain = createStandardPbrArtifactReceipt();
+    const colored = createStandardPbrArtifactReceipt(false, true);
+    const shader = {
+      findMaterialArtifact: () => ({
+        ok: true as const,
+        value: { source: 'fallback', paramSchema: [], receipt: plain },
+      }),
+      materialShaderManifestEntries: () => [
+        {
+          identifier: 'forgeax::default-standard-pbr',
+          sourcePath: 'default-standard-pbr.wgsl',
+          composedWgsl: 'fallback',
+          paramSchema: '[]',
+          variants: [
+            {
+              definesKey: 'VERTEX_COLOR_AVAILABLE=false',
+              defines: { VERTEX_COLOR_AVAILABLE: false },
+              composedWgsl: 'plain-variant',
+              receipt: plain,
+            },
+            {
+              definesKey: 'VERTEX_COLOR_AVAILABLE=true',
+              defines: { VERTEX_COLOR_AVAILABLE: true },
+              composedWgsl: 'colored-variant',
+              receipt: colored,
+            },
+          ],
+        },
+      ],
+    } as unknown as Parameters<typeof resolveStandardPbrArtifact>[1];
+
+    const coloredArtifact = resolveStandardPbrArtifact('forgeax::default-standard-pbr', shader, {
+      vertexColorAvailable: true,
+    });
+    const plainArtifact = resolveStandardPbrArtifact('forgeax::default-standard-pbr', shader, {
+      vertexColorAvailable: false,
+    });
+
+    expect(coloredArtifact?.wgsl).toBe('colored-variant');
+    expect(coloredArtifact?.receipt).toEqual(colored);
+    expect(coloredArtifact?.receipt?.vertexInputs).toContainEqual({
+      semantic: 'color',
+      location: 13,
+      format: 'float32x4',
+    });
+    expect(plainArtifact?.wgsl).toBe('plain-variant');
+    expect(plainArtifact?.receipt).toEqual(plain);
+    expect(plainArtifact?.receipt?.vertexInputs).not.toContainEqual(
+      expect.objectContaining({ semantic: 'color' }),
+    );
+    expect(coloredArtifact?.receipt?.receiptIdentity).not.toBe(
+      plainArtifact?.receipt?.receiptIdentity,
+    );
+
+    const custom = resolveMaterialShaderArtifact(
+      'game::custom-surface',
+      {
+        findMaterialArtifact: () => ({
+          ok: true as const,
+          value: { source: 'custom-fallback', paramSchema: [], receipt: plain },
+        }),
+        materialShaderManifestEntries: () => [
+          {
+            identifier: 'game::custom-surface',
+            sourcePath: 'custom.wgsl',
+            composedWgsl: 'custom-fallback',
+            paramSchema: '[]',
+            variants: [
+              {
+                definesKey: 'VERTEX_COLOR_AVAILABLE=true',
+                defines: { VERTEX_COLOR_AVAILABLE: true },
+                composedWgsl: 'custom-colored',
+                receipt: colored,
+              },
+            ],
+          },
+        ],
+      } as unknown as Parameters<typeof resolveMaterialShaderArtifact>[1],
+      { vertexColorAvailable: true },
+    );
+    expect(custom?.wgsl).toBe('custom-colored');
+    expect(custom?.receipt).toEqual(colored);
+  });
+
+  it('routes built-in Standard shadow requests through the shadow-caster artifact', () => {
+    const rigidPlain = createStandardPbrArtifactReceipt();
+    const rigidColor = createStandardPbrArtifactReceipt(false, true);
+    const skinPlain = createStandardPbrArtifactReceipt(true);
+    const shadowEntry = {
+      identifier: 'forgeax::default-shadow-caster',
+      sourcePath: 'default-shadow-caster.wgsl',
+      composedWgsl: 'shadow-primary',
+      paramSchema: '[]',
+      variants: [
+        {
+          definesKey: 'SKINNING_DISABLED=true+VERTEX_COLOR_AVAILABLE=false',
+          defines: { SKINNING_DISABLED: true, VERTEX_COLOR_AVAILABLE: false },
+          composedWgsl: 'shadow-rigid-plain-with-fs_shadow',
+          receipt: rigidPlain,
+        },
+        {
+          definesKey: 'SKINNING_DISABLED=true+VERTEX_COLOR_AVAILABLE=true',
+          defines: { SKINNING_DISABLED: true, VERTEX_COLOR_AVAILABLE: true },
+          composedWgsl: 'shadow-rigid-color-with-fs_shadow',
+          receipt: rigidColor,
+        },
+        {
+          definesKey: 'SKINNING_DISABLED=false+VERTEX_COLOR_AVAILABLE=false',
+          defines: { SKINNING_DISABLED: false, VERTEX_COLOR_AVAILABLE: false },
+          composedWgsl: 'shadow-skin-plain-with-fs_shadow',
+          receipt: skinPlain,
+        },
+      ],
+    };
+    const standardEntry = {
+      identifier: 'forgeax::default-standard-pbr',
+      sourcePath: 'default-standard-pbr.wgsl',
+      composedWgsl: 'standard-forward-without-fs_shadow',
+      paramSchema: '[]',
+      variants: [],
+    };
+
+    for (const entries of [
+      [standardEntry, shadowEntry],
+      [shadowEntry, standardEntry],
+    ]) {
+      const shader = {
+        findMaterialArtifact: (identifier: string) => ({
+          ok: true as const,
+          value: {
+            source: identifier === 'forgeax::default-shadow-caster' ? 'shadow-primary' : 'standard',
+            paramSchema: [],
+            receipt: rigidPlain,
+          },
+        }),
+        materialShaderManifestEntries: () => entries,
+      } as unknown as Parameters<typeof resolveMaterialShaderArtifact>[1];
+
+      const rigidColorArtifact = resolveMaterialShaderArtifact(
+        'forgeax::default-standard-pbr',
+        shader,
+        {
+          address: 'scene-index',
+          deformation: 'rigid',
+          pass: 'shadow',
+          vertexColorAvailable: true,
+        },
+      );
+      const skinPlainArtifact = resolveMaterialShaderArtifact(
+        'forgeax::default-standard-pbr-skin',
+        shader,
+        { address: 'scene-index', deformation: 'skin', pass: 'shadow' },
+      );
+
+      expect(rigidColorArtifact?.material).toBe('forgeax::default-shadow-caster');
+      expect(rigidColorArtifact?.fragmentEntry).toBe('fs_shadow');
+      expect(rigidColorArtifact?.wgsl).toBe('shadow-rigid-color-with-fs_shadow');
+      expect(rigidColorArtifact?.receipt).toEqual(rigidColor);
+      expect(skinPlainArtifact?.material).toBe('forgeax::default-shadow-caster');
+      expect(skinPlainArtifact?.wgsl).toBe('shadow-skin-plain-with-fs_shadow');
+      expect(skinPlainArtifact?.receipt).toEqual(skinPlain);
+    }
+  });
+  it('reuses immutable publications and invalidates changed registry or manifest identities', () => {
+    const receipt = createStandardPbrArtifactReceipt();
+    let entry = { source, paramSchema: [], receipt };
+    let manifest = {
+      identifier: 'game::surface',
+      sourcePath: 'surface.wgsl',
+      composedWgsl: source,
+      paramSchema: '[]',
+      variants: [{ definesKey: '', defines: {}, composedWgsl: 'first', receipt }],
+    };
+    const registry = {
+      findMaterialArtifact: () => ({ ok: true, value: entry }),
+      materialShaderManifestEntries: () => [manifest].values(),
+    } as unknown as Parameters<typeof resolveMaterialShaderArtifact>[1];
+    const resolve = () =>
+      resolveMaterialShaderArtifact('game::surface', registry, { address: 'scene-index' });
+    const first = resolve();
+    expect(first?.wgsl).toBe('first');
+    expect(resolve()).toBe(first);
+    expect(
+      resolveMaterialShaderArtifact('game::surface', registry, { address: 'direct' })?.vertexEntry,
+    ).toBe(receipt.directEntry);
+    manifest = {
+      ...manifest,
+      variants: [{ definesKey: '', defines: {}, receipt, composedWgsl: 'second' }],
+    };
+    const second = resolve();
+    expect(second).not.toBe(first);
+    expect(second?.wgsl).toBe('second');
+    expect(resolve()).toBe(second);
+    entry = { ...entry };
+    expect(resolve()).not.toBe(second);
+  });
+});

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

@@ -8,6 +8,7 @@ import { createRenderSurfaceError, type RenderSurfaceExpectedError } from '../er
 import { prepareStandardLighting } from '../pipeline/standard-lighting/prepare';
 import { deriveStandardTopologyInput } from '../pipeline/standard-lighting/topology';
 import { selectStandardClusterTransport } from '../pipeline/standard-lighting/transport';
+import { createStandardOutputPlan } from '../pipeline/standard-output/graph';
 import { standardPipeline } from '../pipeline/standard-pipeline';
 import {
   DEFAULT_STANDARD_PROFILE,
@@ -16,6 +17,7 @@ import {
 } from '../pipeline/standard-profile';
 import type { RenderPipelineFrame, RenderPipelineTopology } from '../render-pipeline';
 import type { SurfaceProfile } from '../render-system';
+import { admitSsrSpatial } from '../ssr/admission';
 
 const rawOnlyProfile: SurfaceProfile = {
   kind: 'raw-only',
@@ -110,13 +112,84 @@ function standardLightingFor(resolvedTopology: RenderPipelineTopology) {
 async function build(profile: StandardProfile, overrides?: Partial<RenderPipelineTopology>) {
   const graph = new RenderGraphBuilder<RenderPipelineFrame>();
   const resolvedTopology = topology(profile, overrides);
+  const histogram = graph.createBuffer('standard-auto-exposure-histogram', { size: 1024 });
+  const state = graph.createBuffer('standard-auto-exposure-state', { size: 32 });
+  const candidate = graph.createBuffer('standard-auto-exposure-candidate', { size: 16 });
+  const parameters = graph.createBuffer('standard-auto-exposure-parameters', { size: 32 });
+  const lutTexture = graph.createTexture('standard-color-lut-source', {
+    format: 'rgba16float',
+    size: { width: 2, height: 2, depthOrArrayLayers: 2 },
+    dimension: '3d',
+  });
+  if (!histogram.ok || !state.ok || !candidate.ok || !parameters.ok || !lutTexture.ok)
+    throw new Error('standard output test resources could not be declared');
+  if (overrides?.output?.autoExposure === true) {
+    const parametersInit = graph.addComputePass('standard-auto-exposure-parameters-init', {
+      accesses: [{ resource: parameters.value, usage: 'storage-write' }],
+      encode: () => undefined,
+    });
+    if (!parametersInit.ok) throw parametersInit.error;
+  }
+  const lutView = graph.view(lutTexture.value, { dimension: '3d' });
+  if (!lutView.ok) throw lutView.error;
+  const lutInit = graph.addComputePass('standard-color-lut-test-init', {
+    accesses: [{ resource: lutView.value, usage: 'storage-write' }],
+    encode: () => undefined,
+  });
+  if (!lutInit.ok) throw lutInit.error;
+  const lutSampler = device.createSampler({ minFilter: 'linear', magFilter: 'linear' });
+  if (!lutSampler.ok) throw lutSampler.error;
+  const lutGpuTexture = device
+    .createTexture({
+      label: 'standard-output-test-lut',
+      format: 'rgba16float',
+      size: { width: 2, height: 2, depthOrArrayLayers: 2 },
+      dimension: '3d',
+      usage: 0x04,
+      textureBindingViewDimension: undefined,
+    })
+    .unwrap();
+  const lutGpuView = device.createTextureView(lutGpuTexture, { dimension: '3d' }).unwrap();
+  const lutBindGroupLayout = device
+    .createBindGroupLayout({
+      entries: [
+        { binding: 0, visibility: 0x2, texture: { sampleType: 'float', viewDimension: '3d' } },
+        { binding: 1, visibility: 0x2, sampler: { type: 'filtering' } },
+      ],
+    })
+    .unwrap();
+  const lutBindGroup = device
+    .createBindGroup({
+      layout: lutBindGroupLayout,
+      entries: [
+        { binding: 0, resource: { kind: 'textureView', value: lutGpuView } },
+        { binding: 1, resource: { kind: 'sampler', value: lutSampler.value } },
+      ],
+    })
+    .unwrap();
   const standardLighting = standardLightingFor(resolvedTopology);
   if (!standardLighting.ok) return standardLighting;
   const built = standardPipeline.build(
     {
       graph,
       standardLighting: standardLighting.value,
+      standardOutput: {
+        autoExposure: {
+          histogram: histogram.value,
+          state: state.value,
+          candidate: candidate.value,
+          parameters: parameters.value,
+        },
+        colorLut: {
+          view: lutView.value,
+          sampler: lutSampler.value,
+          strength: 1,
+          bindGroupLayout: lutBindGroupLayout,
+          bindGroup: lutBindGroup,
+        },
+      },
       encodeTransmissionMip: ({ pass }) => pass.draw(3, 1, 0, 0),
+      capabilities: { rgba16floatRenderable: true },
       projectGpuDriven: () => ok(undefined),
       contributeFeatures: () => ok(undefined),
     },
@@ -133,10 +206,10 @@ async function build(profile: StandardProfile, overrides?: Partial<RenderPipelin
 }
 
 function importedTaaHistory(graph: RenderGraphBuilder<RenderPipelineFrame>) {
-  const target = (label: string) => {
+  const target = (label: string, format: 'rgba16float' | 'r8unorm' = 'rgba16float') => {
     const texture = graph.importTexture(
       label,
-      { format: 'rgba16float', size: 'surface', usage: 0x17 },
+      { format, size: 'surface', usage: 0x17 },
       (frame) => frame.currentTexture,
     );
     if (!texture.ok) throw texture.error;
@@ -145,7 +218,7 @@ function importedTaaHistory(graph: RenderGraphBuilder<RenderPipelineFrame>) {
     return {
       texture: texture.value,
       view: view.value,
-      format: 'rgba16float' as const,
+      format,
       sampleCount: 1 as const,
     };
   };
@@ -154,6 +227,8 @@ function importedTaaHistory(graph: RenderGraphBuilder<RenderPipelineFrame>) {
     previousColor: target('taa-history-previous-color'),
     currentTemporal: target('taa-history-current-temporal'),
     previousTemporal: target('taa-history-previous-temporal'),
+    currentStability: target('taa-history-current-stability', 'r8unorm'),
+    previousStability: target('taa-history-previous-stability', 'r8unorm'),
   };
 }
 
@@ -179,12 +254,168 @@ async function buildTaa(profile: StandardProfile, overrides?: Partial<RenderPipe
 }
 
 describe('forgeax::standard graph', () => {
+  it('builds auto exposure and positive LUT with prepared live producers', async () => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      output: {
+        autoExposure: true,
+        colorLut: true,
+        colorLutStrength: 1,
+        lutSourceKey: 'asset-guid:lut',
+      },
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const info = result.value.inspect();
+    const names = info.passes.map((pass) => pass.name);
+    const tone = names.indexOf('standard-tone');
+    const lut = names.indexOf('standard-color-lut');
+    const fxaa = names.indexOf('fxaa');
+    const encoding = names.indexOf('standard-output-encoding');
+    expect(tone).toBeGreaterThanOrEqual(0);
+    expect(lut).toBeGreaterThan(tone);
+    expect(fxaa).toBeGreaterThan(lut);
+    expect(encoding).toBeGreaterThan(fxaa);
+    expect(info.resources).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          label: 'standard-tone-output',
+          descriptor: expect.objectContaining({ format: 'rgba16float', domain: 'linear-ldr' }),
+        }),
+        expect.objectContaining({
+          label: 'standard-color-lut',
+          descriptor: expect.objectContaining({ format: 'rgba16float', domain: 'linear-ldr' }),
+        }),
+        expect.objectContaining({
+          label: 'standard-fxaa-output',
+          descriptor: expect.objectContaining({ format: 'rgba16float', domain: 'linear-ldr' }),
+        }),
+      ]),
+    );
+  });
+
+  it('splits auto exposure without a LUT into tone, linear-LDR, and final encoding stages', async () => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'aces-filmic', antialias: 'none', bloom: 'off' },
+      output: { autoExposure: true, colorLut: false, colorLutStrength: 0 },
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const info = result.value.inspect();
+    const names = info.passes.map((pass) => pass.name);
+    const tone = names.indexOf('standard-tone');
+    const encoding = names.indexOf('standard-output-encoding');
+    expect(tone).toBeGreaterThanOrEqual(0);
+    expect(encoding).toBeGreaterThan(tone);
+    expect(names).not.toContain('output-transform');
+    expect(names).not.toContain('standard-color-lut');
+    expect(names).toEqual(
+      expect.arrayContaining([
+        'linear-hdr-observation',
+        'linear-ldr-observation',
+        'final-srgb-observation',
+      ]),
+    );
+    expect(info.resources).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          label: 'standard-tone-output',
+          descriptor: expect.objectContaining({ format: 'rgba16float', domain: 'linear-ldr' }),
+        }),
+      ]),
+    );
+  });
+
+  it('routes non-neutral Camera white balance through the shared linear-HDR stage', async () => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'aces-filmic', antialias: 'none', bloom: 'off' },
+      output: {
+        autoExposure: false,
+        whiteBalance: true,
+        temperature: 5000,
+        tint: 0.2,
+        colorLut: false,
+        colorLutStrength: 0,
+      },
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const names = result.value.inspect().passes.map((pass) => pass.name);
+    const wb = names.indexOf('standard-exposure-white-balance');
+    const tone = names.indexOf('standard-tone');
+    const encoding = names.indexOf('standard-output-encoding');
+    expect(wb).toBeGreaterThanOrEqual(0);
+    expect(tone).toBeGreaterThan(wb);
+    expect(encoding).toBeGreaterThan(tone);
+  });
+
+  it('keeps LUT0 on the combined output transform single pass', async () => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'aces-filmic', antialias: 'none', bloom: 'off' },
+      output: { autoExposure: false, colorLut: false, colorLutStrength: 0 },
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const names = result.value.inspect().passes.map((pass) => pass.name);
+    expect(names.filter((name) => name === 'output-transform')).toHaveLength(1);
+    expect(names).not.toContain('standard-tone');
+    expect(names).not.toContain('standard-color-lut');
+    expect(names).not.toContain('standard-output-encoding');
+  });
+
   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('uses one output plan for direct and clustered lanes', () => {
+    const request = {
+      temporal: true,
+      meter: true,
+      bloom: true,
+      exposure: true,
+      whiteBalance: true,
+      lut: true,
+      fxaa: true,
+      outputEncoding: 'explicit-oetf' as const,
+    };
+    const direct = createStandardOutputPlan({ ...request, lane: 'direct' });
+    const clustered = createStandardOutputPlan({ ...request, lane: 'clustered' });
+    expect(clustered.logicalStages).toEqual(direct.logicalStages);
+    expect(clustered.physicalStages).toEqual(direct.physicalStages);
+    expect(clustered.finalWriterCount).toBe(direct.finalWriterCount);
+  });
+
+  it('accounts for admitted LUT bindings without adding work to the zero-strength path', () => {
+    const baseline = createStandardOutputPlan({
+      lane: 'direct',
+      temporal: false,
+      meter: false,
+      bloom: false,
+      exposure: false,
+      whiteBalance: false,
+      lut: false,
+      fxaa: false,
+      outputEncoding: 'explicit-oetf',
+    });
+    const lut = createStandardOutputPlan({
+      lane: 'direct',
+      temporal: false,
+      meter: false,
+      bloom: false,
+      exposure: false,
+      whiteBalance: false,
+      lut: true,
+      fxaa: false,
+      outputEncoding: 'explicit-oetf',
+    });
+
+    expect(baseline.incrementalResources).toEqual([]);
+    expect(baseline.incrementalBindings).toBe(0);
+    expect(lut.incrementalResources).toContain('standard-color-lut');
+    expect(lut.incrementalBindings).toBeGreaterThan(0);
+  });
+
   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;
@@ -206,6 +437,92 @@ describe('forgeax::standard graph', () => {
     expect(activeGraph).toBe('candidate');
   });
 
+  it('keeps SSR out of the Standard graph without admitted dependencies', async () => {
+    const result = await build({ ...DEFAULT_STANDARD_PROFILE, renderPath: 'deferred' });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const info = result.value.inspect();
+    expect(info.passes.map((pass) => pass.name).some((name) => name.startsWith('ssr'))).toBe(false);
+    expect(
+      info.resources.map((resource) => resource.label).some((label) => label.startsWith('ssr')),
+    ).toBe(false);
+  });
+
+  it('projects the admitted SSR spatial chain into the deferred Standard graph', async () => {
+    const result = await build(
+      { ...DEFAULT_STANDARD_PROFILE, renderPath: 'deferred' },
+      {
+        reflectionFallback: { enabled: true },
+        ssr: admitSsrSpatial({
+          camera: {
+            projection: 'perspective',
+            near: 0.1,
+            far: 100,
+            screenSpaceReflection: {
+              maxDistance: 40,
+              thickness: 0.2,
+              maxRoughness: 0.6,
+            },
+          },
+          environment: {
+            lane: 'deferred',
+            m0: { status: 'admitted' },
+            sceneInputs: true,
+            temporal: true,
+            reflectionFallback: true,
+            capabilities: {
+              compute: true,
+              storageTexture: true,
+              rgba16floatRenderable: true,
+              r32floatSampledStorage: true,
+            },
+          },
+        }),
+      },
+    );
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const names = result.value.inspect().passes.map((pass) => pass.name);
+    expect(names).toContain('ssr-hiz-seed');
+    expect(names).toContain('ssr-trace');
+    expect(names).toContain('standard-scene-data');
+    expect(names).toContain('ssr-compose');
+    expect(names.indexOf('skybox')).toBeLessThan(names.indexOf('lighting'));
+    expect(names.indexOf('lighting')).toBeLessThan(names.indexOf('ssr-hiz-seed'));
+    expect(names.indexOf('ssr-compose')).toBeLessThan(names.indexOf('forward'));
+    expect(names).toContain('reflection-fallback-observation');
+    expect(result.value.inspect().resources.map((resource) => resource.label)).toEqual(
+      expect.arrayContaining(['ssr-hiz', 'ssr-trace', 'reflection-fallback-linear-hdr']),
+    );
+  });
+
+  it('keeps the deferred reflection fallback producer observable without SSR', async () => {
+    const result = await build(
+      { ...DEFAULT_STANDARD_PROFILE, renderPath: 'deferred' },
+      { reflectionFallback: { enabled: true } },
+    );
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const names = result.value.inspect().passes.map((pass) => pass.name);
+    expect(names).toContain('reflection-fallback-observation');
+    expect(result.value.inspect().resources.map((resource) => resource.label)).toContain(
+      'reflection-fallback-linear-hdr',
+    );
+    expect(names.some((name) => name.startsWith('ssr-'))).toBe(false);
+    expect(
+      result.value.inspect().passes.find((pass) => pass.name === 'lighting')?.accesses,
+    ).toContainEqual({
+      resource: 'reflection-fallback-linear-hdr',
+      usage: 'color-attachment',
+    });
+    expect(
+      result.value.inspect().passes.find((pass) => pass.name === 'g-buffer')?.accesses,
+    ).not.toContainEqual({
+      resource: 'reflection-fallback-linear-hdr',
+      usage: 'color-attachment',
+    });
+  });
+
   it.each([
     ['forward-1', { ...DEFAULT_STANDARD_PROFILE, lightCount: 1, renderPath: 'forward' }],
     ['forward-32', { ...DEFAULT_STANDARD_PROFILE, lightCount: 32, renderPath: 'forward' }],