@forgeax/engine-render 0.1.29 → 0.1.31

package/src/__tests__/render-scene-projection.unit.test.ts

@@ -1481,7 +1481,7 @@ describe('projected bounds query', () => {
     expect(scene.bounds(worldA, 99)).toBeUndefined();
     const first = scene.bounds(worldA, 7);
     if (first === undefined) throw new Error('expected projected bounds');
-    (first.min as number[])[0] = -999;
+    Reflect.set(first.min, 0, -999);
     expect(scene.bounds(worldA, 7)?.min[0]).toBe(110);
     const instanceA = snapshot(1, 0).transform.world,
       instanceB = snapshot(2, 20).transform.world;
@@ -1506,8 +1506,9 @@ describe('projected bounds query', () => {
     );
     expect(scene.bounds(worldA, 7)?.max[0]).toBe(132);
     expect(scene.bounds(worldB, 7)?.max[0]).toBe(901);
+    const { localAabb: _localAabb, ...withoutBounds } = a;
     scene.extractComposition([worldA], { cameraOwner: 0, resourceOwner: 0 }, 3, () =>
-      frame([{ ...a, localAabb: undefined }]),
+      frame([withoutBounds]),
     );
     expect(scene.bounds(worldA, 7)).toBeUndefined();
     expect(scene.bounds(worldB, 7)).toBeUndefined();

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

@@ -1,7 +1,11 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { RhiError } from '@forgeax/engine-rhi';
-import type { MaterialShaderManifestVariant } from '@forgeax/engine-shader';
+import { type RhiDevice, RhiError } from '@forgeax/engine-rhi';
+import type {
+  MaterialShaderManifestEntry,
+  MaterialShaderManifestVariant,
+  ShaderCatalog,
+} from '@forgeax/engine-shader';
 import { describe, expect, it, vi } from 'vitest';
 import { deviceOptionsForAdapter } from '../assembly/device-feature-admission';
 import {
@@ -17,6 +21,7 @@ import {
   selectPipelineLayoutForVariant,
   shouldDeferMissingPreparedMaterialShader,
 } from '../assembly/factory';
+import { prepareMaterialShaders } from '../assembly/material-shader-policy';
 import {
   buildPipelineForMaterialShader,
   type PipelineBuilderContext,
@@ -56,6 +61,56 @@ function noColorManifest() {
 }
 
 describe('material shader variant identity', () => {
+  it('defaults a declared coverage-only axis to the opaque boot variant', async () => {
+    const entry: MaterialShaderManifestEntry = {
+      identifier: 'forgeax::default-standard-pbr',
+      sourcePath: 'default-standard-pbr.wgsl',
+      composedWgsl: 'coverage-off',
+      paramSchema: '[]',
+      variants: [
+        {
+          definesKey: 'COVERAGE_ONLY=false+STORAGE_BUFFER_AVAILABLE=true',
+          defines: { COVERAGE_ONLY: false, STORAGE_BUFFER_AVAILABLE: true },
+          composedWgsl: 'coverage-off',
+        },
+        {
+          definesKey: 'COVERAGE_ONLY=true+STORAGE_BUFFER_AVAILABLE=true',
+          defines: { COVERAGE_ONLY: true, STORAGE_BUFFER_AVAILABLE: true },
+          composedWgsl: 'coverage-on',
+        },
+      ],
+    };
+    const installMaterialArtifact = vi.fn();
+    const registry = {
+      loadManifest: vi.fn(async () => ({ ok: true, value: undefined })),
+      materialShaderManifestEntries: () => [entry][Symbol.iterator](),
+      findMaterialArtifact: vi.fn(() => ({ ok: false })),
+      installMaterialArtifact,
+    } as unknown as ShaderCatalog;
+    const assets = { catalog: vi.fn(() => ({ ok: true, value: undefined })) } as never;
+    const device = {
+      caps: {
+        backendKind: 'webgpu',
+        storageBuffer: true,
+        rgba16floatRenderable: true,
+        samplerAliasing: true,
+      },
+      limits: {
+        maxStorageBuffersPerShaderStage: 8,
+        maxSampledTexturesPerShaderStage: 32,
+        maxTextureArrayLayers: 64,
+        maxUniformBuffersPerShaderStage: 4,
+      },
+    } as unknown as RhiDevice;
+
+    await prepareMaterialShaders(device, () => registry, assets, new Map());
+
+    expect(installMaterialArtifact).toHaveBeenCalledWith('forgeax::default-standard-pbr', {
+      source: 'coverage-off',
+      paramSchema: [],
+    });
+  });
+
   it('requests the extended-lighting sampled-texture limit when the adapter supports it', () => {
     const features = new Set<GPUFeatureName>();
     expect(
@@ -65,7 +120,7 @@ describe('material shader variant identity', () => {
       } as never),
     ).toEqual({
       requiredFeatures: [],
-      requiredLimits: { maxSampledTexturesPerShaderStage: 21 },
+      requiredLimits: { maxSampledTexturesPerShaderStage: 22 },
     });
     expect(
       deviceOptionsForAdapter({
@@ -88,6 +143,29 @@ describe('material shader variant identity', () => {
     ).toBe(urpVariantKey);
   });
 
+  it('keeps coverage-only fallback selection explicit', () => {
+    const coverageKey = `COVERAGE_ONLY=true+${urpVariantKey}`;
+    const manifest = {
+      ...noColorManifest(),
+      variants: [
+        {
+          ...noColorVariant(coverageKey, false),
+          definesKey: coverageKey,
+          defines: {
+            ...noColorVariant(coverageKey, false).defines,
+            COVERAGE_ONLY: true,
+          },
+          composedWgsl: 'coverage-on',
+        },
+        { ...noColorVariant(urpVariantKey, false), composedWgsl: 'coverage-off' },
+      ],
+    };
+    expect(selectNoColorPbrVariant(manifest, true, undefined)?.definesKey).toBe(urpVariantKey);
+    expect(
+      selectNoColorPbrVariant(manifest, true, `COVERAGE_ONLY=true+${urpVariantKey}`)?.definesKey,
+    ).toBe(coverageKey);
+  });
+
   it('keeps physical root declarations out of capability variant selection', () => {
     const manifest = noColorManifest();
     expect(
@@ -207,6 +285,20 @@ describe('material shader variant identity', () => {
     );
   });
 
+  it('defaults coverage-only variants to the opaque path unless explicitly enabled', () => {
+    const variants = [{ defines: { COVERAGE_ONLY: true } }, { defines: { COVERAGE_ONLY: false } }];
+
+    expect(resolveMaterialShaderVariantSet(undefined, variants, 'webgpu', true)).toBe(
+      'COVERAGE_ONLY=false',
+    );
+    expect(resolveMaterialShaderVariantSet('', variants, 'webgpu', true)).toBe(
+      'COVERAGE_ONLY=false',
+    );
+    expect(resolveMaterialShaderVariantSet('COVERAGE_ONLY=true', variants, 'webgpu', true)).toBe(
+      '',
+    );
+  });
+
   it('keeps the negative skinning axis disabled when a shadow request omits it', () => {
     const variants = [
       {
@@ -260,7 +352,7 @@ describe('material shader variant identity', () => {
         variants,
         'webgpu',
         true,
-        19,
+        20,
       ),
     ).toBe('EXTENDED_LIGHTING_AVAILABLE=false');
     expect(
@@ -269,11 +361,11 @@ describe('material shader variant identity', () => {
         variants,
         'webgpu',
         true,
-        20,
+        21,
       ),
     ).toBe('');
     expect(
-      resolveMaterialShaderVariantSet(undefined, variants, 'webgpu', true, 20),
+      resolveMaterialShaderVariantSet(undefined, variants, 'webgpu', true, 21),
     ).toBeUndefined();
     expect(
       resolveMaterialShaderVariantSet(
@@ -281,7 +373,7 @@ describe('material shader variant identity', () => {
         variants,
         'webgpu',
         true,
-        20,
+        21,
       ),
     ).toBe('');
     expect(
@@ -290,11 +382,31 @@ describe('material shader variant identity', () => {
         variants,
         'webgpu',
         false,
-        19,
+        20,
       ),
     ).toBe('EXTENDED_LIGHTING_AVAILABLE=false');
   });
 
+  it('preserves authored default axes while rewriting backend capabilities', () => {
+    const variants = [
+      { defines: { AUTHORED_TINT: true, STORAGE_BUFFER_AVAILABLE: true } },
+      { defines: { AUTHORED_TINT: false, STORAGE_BUFFER_AVAILABLE: true } },
+      { defines: { AUTHORED_TINT: true, STORAGE_BUFFER_AVAILABLE: false } },
+      { defines: { AUTHORED_TINT: false, STORAGE_BUFFER_AVAILABLE: false } },
+    ];
+    expect(resolveMaterialShaderVariantSet(undefined, variants, 'webgpu', true)).toBeUndefined();
+    expect(resolveMaterialShaderVariantSet('', variants, 'webgpu', true)).toBe('');
+    expect(
+      resolveMaterialShaderVariantSet('STORAGE_BUFFER_AVAILABLE=true', variants, 'webgpu', true),
+    ).toBe('');
+    expect(resolveMaterialShaderVariantSet(undefined, variants, 'wgpu-webgl2', false)).toBe(
+      'AUTHORED_TINT=true+STORAGE_BUFFER_AVAILABLE=false',
+    );
+    expect(resolveMaterialShaderVariantSet('AUTHORED_TINT=false', variants, 'webgpu', true)).toBe(
+      'AUTHORED_TINT=false+STORAGE_BUFFER_AVAILABLE=true',
+    );
+  });
+
   it('keeps sprite region variants on the explicit empty-key contract', () => {
     const variants = [
       {
@@ -474,6 +586,44 @@ describe('temporal material PSO creation contract', () => {
     });
   });
 
+  it('accepts r8unorm only for the output-domain coverage temporal variant', () => {
+    const coverageContext = {
+      ...context,
+      colorFormat: 'r8unorm' as GPUTextureFormat,
+      coverageOnly: true,
+    } satisfies Pick<
+      PipelineBuilderContext,
+      'colorFormat' | 'depthFormat' | 'capabilities' | 'coverageOnly'
+    >;
+    expect(validateTemporalPipelineContract(source, coverageContext).ok).toBe(true);
+    expect(
+      validateTemporalPipelineContract(source, { ...coverageContext, coverageOnly: false }).ok,
+    ).toBe(false);
+
+    const createRenderPipeline = vi.fn((_descriptor: unknown) => ({ ok: true, value: {} }));
+    const result = buildPipelineForMaterialShader(
+      'default-unlit-temporal-coverage',
+      { source, paramSchema: [] },
+      {
+        ...coverageContext,
+        device: { createRenderPipeline },
+        shaderModuleFactory: { createShaderModule: () => ({ ok: true, value: {} }) },
+        pipelineLayout: {},
+        vertexBuffers: [],
+      } as unknown as PipelineBuilderContext,
+      { depthWriteEnabled: true, depthCompare: 'less-equal' },
+      undefined,
+      'vs_temporal',
+      'fs_temporal',
+      undefined,
+      'temporal',
+    );
+    expect(result.ok).toBe(true);
+    expect(createRenderPipeline.mock.calls[0]?.[0]).toMatchObject({
+      fragment: { entryPoint: 'fs_temporal', targets: [{ format: 'r8unorm' }] },
+    });
+  });
+
   it.each([
     { depthWriteEnabled: false, depthCompare: 'always' as const },
     { depthWriteEnabled: true, depthCompare: 'never' as const },
@@ -797,7 +947,7 @@ describe('material shader color-domain contract', () => {
       'utf8',
     );
     expect(source).toMatch(
-      /if \(\s*!isStandardMapLayout\s*&&\s*isSharedMaterialUserRegionCompatible\(/u,
+      /if \(\s*!clustered\s*&&\s*!isStandardMapLayout\s*&&\s*isSharedMaterialUserRegionCompatible\(/u,
     );
   });
 
@@ -813,6 +963,20 @@ describe('material shader color-domain contract', () => {
     expect(pipelineSource).toContain('appendTextureInjection(afterTransmission, physicalFields)');
     expect(recordSource).toContain('BUILTIN_USER_REGION_TEXTURE_FIELDS');
   });
+
+  it('keeps scene-index entries and GPU-driven instance layouts on custom pipelines', () => {
+    const source = readFileSync(
+      resolve(import.meta.dirname, '../assembly/material/pipeline-helpers.ts'),
+      'utf8',
+    );
+    expect(source).toContain(
+      "const sceneIndex = layoutKind === 'gpu-driven-pbr' || layoutKind === 'gpu-driven-skin';",
+    );
+    expect(source).toContain('? (vertexEntryPoint ?? authoredVertexEntry)');
+    expect(source).toMatch(
+      /const instancesLayout =\s+layoutKind === 'gpu-driven-pbr' \|\| layoutKind === 'gpu-driven-skin'\s+\? state\.gpuDrivenInstancesBindGroupLayout\s+: state\.instancesBindGroupLayout/u,
+    );
+  });
 });
 
 describe('material shader vertex input contract', () => {

package/src/__tests__/shader-manifest-fixture.ts

@@ -30,6 +30,12 @@ const entries: readonly FixtureEntry[] = [
     glsl: '',
     bindings: '[]',
   },
+  {
+    hash: 'fixture-motion-blur',
+    wgsl: '// fixture marker: MotionBlurParams\n',
+    glsl: '',
+    bindings: '[]',
+  },
   {
     hash: 'fixture-fxaa',
     wgsl: '// fixture marker: rgb2luma\n',

package/src/__tests__/skinned-shadow-caster.test.ts

@@ -52,6 +52,7 @@ describe('skinned shadow caster', () => {
     );
     expect(shader).toContain('#pragma variant_axis SKINNING_DISABLED');
     expect(shader).toContain('#pragma variant_axis ALPHA_MASK');
+    expect(shader).toContain('#pragma variant_axis VERTEX_COLOR_AVAILABLE');
     expect(shader).toContain('#pragma material_slot surface');
     expect(shader).toContain('#import forgeax_material::parameters::{material}');
     expect(shader).toContain('@group(1) @binding(46)');
@@ -59,6 +60,8 @@ describe('skinned shadow caster', () => {
     expect(shader).toContain('discard;');
     expect(shader).toContain('@group(2) @binding(1)');
     expect(shader).toContain('let skinMatrix = palette[');
+    expect(shader).toContain('@location(13) color : vec4<f32>');
+    expect(shader).toContain('out.color = in.color;');
     expect(record).toContain('entry.source.skin.byteOffset');
     expect(record).toContain("'shadow-pbr-skin-mesh'");
     expect(builder).toContain('buffers: [...ctx.vertexBuffers]');
@@ -76,7 +79,8 @@ describe('skinned shadow caster', () => {
     expect(singleton).toContain('if (runtime.device.caps.storageBuffer)');
     expect(singleton).toContain('binding: 46');
     const sceneMaterialEntry = singleton.slice(singleton.lastIndexOf('binding: 46'));
-    expect(sceneMaterialEntry).toContain('pipelineState.meshStorageBuffer.buffer');
+    expect(singleton).toContain('c.gpuDrivenStandardPbrFrameResources?.sceneMaterialBuffer');
+    expect(singleton).toContain('pipelineState.meshStorageBuffer.buffer');
     expect(sceneMaterialEntry).not.toContain('pipelineState.materialUniformBuffer.buffer');
     expect(singleton.indexOf('if (runtime.device.caps.storageBuffer)')).toBeLessThan(
       singleton.indexOf('binding: 46'),
@@ -165,6 +169,9 @@ describe('skinned shadow caster', () => {
     expect(shadowCasterVariantSet(true, false, true)).toBe(
       'ALPHA_MASK=false+GPU_DRIVEN_SCENE_INDEX_AVAILABLE=true+GPU_DRIVEN_SCENE_INDEX_EXPLICIT=false+SKINNING_DISABLED=true+STORAGE_BUFFER_AVAILABLE=true',
     );
+    expect(shadowCasterVariantSet(true, false, true, false, true)).toContain(
+      'VERTEX_COLOR_AVAILABLE=true',
+    );
     expect(shader).toContain('@group(3) @binding(1) var<storage, read> visibleItems');
     expect(shader).toContain('#pragma variant_axis GPU_DRIVEN_SCENE_INDEX_EXPLICIT');
     expect(shader).toContain('GPU_DRIVEN_SCENE_INDEX_EXPLICIT == false');

package/src/__tests__/specular-environment-scale.dawn.test.ts

@@ -27,6 +27,8 @@ it('decodes regular and probe-sentinel specular environment scales without tint
 @group(0) @binding(2) var<storage, read_write> outputs: array<vec4<f32>>;
 @compute @workgroup_size(4) fn probe_scale(@builtin(global_invocation_id) id: vec3<u32>) {
   let scale = decodeSpecularEnvironmentScale(cases[id.x].xyz, cases[id.x].w);
+  // Probe intensity is applied while blending local and global radiance.
+  // The outer scale stays one for either sentinel, including zero intensity.
   // RGB is the decoded scale. Alpha is the same lobe after the material AO
   // factor, matching the detached fallback's post-environment multiplication.
   outputs[id.x] = vec4<f32>(scale, scale.x * aoValues[id.x]);
@@ -139,8 +141,8 @@ it('decodes regular and probe-sentinel specular environment scales without tint
     const expected = [
       [0.375, 0.75, 1.125, 0.13125],
       [0.05, 0.1, 0.2, 0.04],
-      [0.4, 0.4, 0.4, 0.24],
-      [0.0, 0.0, 0.0, 0.0],
+      [1, 1, 1, 0.6],
+      [1, 1, 1, 0.25],
     ].flat();
     values.forEach((value, index) => {
       const target = expected[index];

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

@@ -13,6 +13,7 @@ describe('SSAO parameter authority', () => {
       radius: SSAO_DEFAULT_RADIUS,
       bias: SSAO_DEFAULT_BIAS,
       intensity: SSAO_DEFAULT_INTENSITY,
+      quality: 'high',
     });
   });
 
@@ -21,9 +22,15 @@ describe('SSAO parameter authority', () => {
       radius: 0.65,
       bias: 0.025,
       intensity: 1.4,
+      quality: 'high',
     });
   });
 
+  it.each([NaN, Infinity, -Infinity])('rejects non-finite parameters (%s)', (value) => {
+    for (const field of ['radius', 'bias', 'intensity'])
+      expect(resolveSsaoParameters({ [field]: value }).ok).toBe(false);
+  });
+
   it('returns structured failures for invalid radius and bias', () => {
     const invalidRadius = resolveSsaoParameters({ radius: 0 });
     const invalidBias = resolveSsaoParameters({ bias: -0.1 });

package/src/__tests__/ssao-surface.dawn.test.ts

@@ -0,0 +1,252 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { mat4 } from '@forgeax/engine-math';
+import { expect, it } from 'vitest';
+import {
+  GPU_TEXTURE_USAGE_COPY_DST,
+  GPU_TEXTURE_USAGE_COPY_SRC,
+  GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
+  GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+} from '../gpu-texture-usage';
+import {
+  GPU_BUFFER_USAGE_COPY_DST,
+  GPU_BUFFER_USAGE_MAP_READ,
+  GPU_BUFFER_USAGE_UNIFORM,
+} from '../gpu-usage';
+import { generateSsaoKernel, generateSsaoNoise } from '../ssao-buffers';
+
+// Analytic tilted plane: y + z + 4 = 0. Every hemisphere sample lies in
+// empty space. Exercise the production fragment program, not a CPU AO copy.
+it.each([
+  ['plane', 16],
+  ['plane', 32],
+  ['plane', 64],
+  ['orthographic', 64],
+  ['contact', 64],
+  ['distant-edge', 64],
+  ['background', 64],
+] as const)('production SSAO %s with %i samples', async (scene, sampleCount) => {
+  const compiler = await import(
+    /* @vite-ignore */ new URL('../../../shader-compiler/dist/index.mjs', import.meta.url).href
+  );
+  const compiled = await compiler.compileShader(
+    readFileSync(resolve('packages/shader/src/hdrp-ssao.wgsl'), 'utf8'),
+    {
+      id: 'forgeax_hdrp::ssao',
+      imports: {
+        'forgeax_view::common': readFileSync(resolve('packages/shader/src/common.wgsl'), 'utf8'),
+      },
+    },
+  );
+  if (!compiled.ok) throw compiled.error;
+  const adapter = await navigator.gpu.requestAdapter();
+  if (!adapter) throw new Error('Dawn adapter unavailable');
+  const device = await adapter.requestDevice();
+  const errors: string[] = [];
+  device.addEventListener('uncapturederror', (event) => errors.push(event.error.message));
+  const size = 128;
+  const texture = (format: GPUTextureFormat, width = size, height = size) =>
+    device.createTexture({
+      size: [width, height],
+      format,
+      usage:
+        GPU_TEXTURE_USAGE_RENDER_ATTACHMENT |
+        GPU_TEXTURE_USAGE_TEXTURE_BINDING |
+        GPU_TEXTURE_USAGE_COPY_SRC |
+        GPU_TEXTURE_USAGE_COPY_DST,
+    });
+  const depth = texture('depth32float');
+  const normal = texture('rgba16float');
+  const aoSize = size / 2;
+  const raw = texture('r8unorm', aoSize, aoSize);
+  const blurred = texture('r8unorm', aoSize, aoSize);
+  const noise = texture('rgba32float', 4, 4);
+  const uniform = device.createBuffer({
+    size: 256,
+    usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+  });
+  const kernel = device.createBuffer({
+    size: 1024,
+    usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+  });
+  const readback = device.createBuffer({
+    size: 256 * aoSize,
+    usage: GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ,
+  });
+  try {
+    const projection = mat4.create();
+    if (scene === 'orthographic') mat4.orthographic(projection, -3, 3, 3, -3, 0.1, 100);
+    else mat4.perspective(projection, Math.PI / 3, 1, 0.1, 100);
+    const inverse = mat4.create();
+    mat4.invert(inverse, projection);
+    const payload = new Float32Array(64);
+    payload.set(mat4.identity(mat4.create()));
+    payload.set(projection, 16);
+    payload.set(inverse, 32);
+    payload.set([1, 0.5, 0.025, sampleCount], 48);
+    device.queue.writeBuffer(uniform, 0, payload);
+    device.queue.writeBuffer(
+      kernel,
+      0,
+      new Float32Array(generateSsaoKernel().flatMap((v) => [...v, 0])),
+    );
+    const noiseRgb = generateSsaoNoise();
+    const noiseRgba = new Float32Array(64);
+    for (let i = 0; i < 16; i++) noiseRgba.set(noiseRgb.subarray(i * 3, i * 3 + 3), i * 4);
+    device.queue.writeTexture({ texture: noise }, noiseRgba, { bytesPerRow: 64 }, [4, 4]);
+    const seedModule = device.createShaderModule({
+      code: `
+      struct Out { @builtin(position) pos: vec4f, @location(0) uv: vec2f };
+      @vertex fn vs(@builtin(vertex_index) i:u32)->Out {
+        let p = array<vec2f,3>(vec2f(-1,-1),vec2f(3,-1),vec2f(-1,3));
+        return Out(vec4f(p[i],0,1),p[i]*vec2f(0.5,-0.5)+0.5);
+      }
+      struct Fragment { @builtin(frag_depth) depth:f32, @location(0) normal:vec4f };
+      @fragment fn fs(in:Out)->Fragment {
+        let rayY = (1.0-2.0*in.uv.y)*0.577350269;
+        let distance = ${scene === 'orthographic' ? '4.0+(1.0-2.0*in.uv.y)*3.0' : scene === 'plane' ? '4.0/(1.0-rayY)' : scene === 'contact' ? 'select(4.0,3.75,in.uv.x>0.5)' : scene === 'distant-edge' ? 'select(4.0,1.0,in.uv.x>0.5)' : '100.0'};
+        return Fragment(${scene === 'orthographic' ? '(distance-0.1)/99.9' : scene === 'background' ? '1.0' : '100.0/99.9-10.0/(99.9*distance)'},${scene === 'plane' || scene === 'orthographic' ? 'vec4f(0.5,0.853553391,0.853553391,1)' : 'vec4f(0.5,0.5,1,1)'});
+      }`,
+    });
+    const seed = device.createRenderPipeline({
+      layout: 'auto',
+      vertex: { module: seedModule, entryPoint: 'vs' },
+      fragment: { module: seedModule, entryPoint: 'fs', targets: [{ format: 'rgba16float' }] },
+      depthStencil: { format: 'depth32float', depthWriteEnabled: true, depthCompare: 'always' },
+    });
+    const module = device.createShaderModule({ code: compiled.value.wgsl });
+    const layout = device.createBindGroupLayout({
+      entries: [
+        { binding: 0, visibility: 2, buffer: { type: 'uniform' } },
+        { binding: 1, visibility: 2, buffer: { type: 'uniform' } },
+        { binding: 2, visibility: 2, texture: { sampleType: 'unfilterable-float' } },
+        { binding: 3, visibility: 2, sampler: { type: 'non-filtering' } },
+        { binding: 4, visibility: 2, texture: { sampleType: 'unfilterable-float' } },
+        { binding: 5, visibility: 2, texture: { sampleType: 'depth' } },
+        { binding: 6, visibility: 2, sampler: { type: 'non-filtering' } },
+      ],
+    });
+    const calc = device.createRenderPipeline({
+      layout: device.createPipelineLayout({ bindGroupLayouts: [layout] }),
+      vertex: { module, entryPoint: 'vs_ssao' },
+      fragment: { module, entryPoint: 'fs_ssao_calc', targets: [{ format: 'r8unorm' }] },
+    });
+    const sampler = device.createSampler({ addressModeU: 'repeat', addressModeV: 'repeat' });
+    const bindings = device.createBindGroup({
+      layout,
+      entries: [
+        { binding: 0, resource: { buffer: uniform } },
+        { binding: 1, resource: { buffer: kernel } },
+        { binding: 2, resource: noise.createView() },
+        { binding: 3, resource: sampler },
+        { binding: 4, resource: normal.createView() },
+        { binding: 5, resource: depth.createView() },
+        { binding: 6, resource: device.createSampler() },
+      ],
+    });
+    const encoder = device.createCommandEncoder();
+    const seedPass = encoder.beginRenderPass({
+      colorAttachments: [{ view: normal.createView(), loadOp: 'clear', storeOp: 'store' }],
+      depthStencilAttachment: {
+        view: depth.createView(),
+        depthLoadOp: 'clear',
+        depthStoreOp: 'store',
+        depthClearValue: 1,
+      },
+    });
+    seedPass.setPipeline(seed);
+    seedPass.draw(3);
+    seedPass.end();
+    const pass = encoder.beginRenderPass({
+      colorAttachments: [{ view: raw.createView(), loadOp: 'clear', storeOp: 'store' }],
+    });
+    pass.setPipeline(calc);
+    pass.setBindGroup(0, bindings);
+    pass.draw(3);
+    pass.end();
+    encoder.copyTextureToBuffer({ texture: raw }, { buffer: readback, bytesPerRow: 256 }, [
+      aoSize,
+      aoSize,
+    ]);
+    device.queue.submit([encoder.finish()]);
+    await readback.mapAsync(GPU_BUFFER_USAGE_MAP_READ);
+    const values = new Uint8Array(readback.getMappedRange());
+    const mean = (x0: number, x1: number) => {
+      let sum = 0;
+      for (let y = 8; y < aoSize - 8; y++)
+        for (let x = x0; x < x1; x++) sum += 1 - (values[y * 256 + x] ?? NaN) / 255;
+      return sum / ((aoSize - 16) * (x1 - x0));
+    };
+    expect(errors).toEqual([]);
+    if (scene === 'contact') {
+      expect(
+        mean(aoSize / 2 - 4, aoSize / 2),
+        'nearby foreground occludes the contact band',
+      ).toBeGreaterThan(0.02);
+      expect(mean(8, 16), 'open surface away from contact stays clear').toBeLessThan(0.01);
+    } else {
+      if (scene === 'distant-edge') expect(mean(aoSize / 2 - 4, aoSize / 2)).toBeLessThan(0.005);
+      expect(
+        mean(8, aoSize - 8),
+        'unoccluded surface and distant silhouettes stay clear',
+      ).toBeLessThan(0.01);
+    }
+    readback.unmap();
+    const blurLayout = device.createBindGroupLayout({
+      entries: [
+        { binding: 0, visibility: 2, buffer: { type: 'uniform' } },
+        { binding: 4, visibility: 2, texture: { sampleType: 'unfilterable-float' } },
+        { binding: 5, visibility: 2, texture: { sampleType: 'depth' } },
+        { binding: 6, visibility: 2, sampler: { type: 'non-filtering' } },
+        { binding: 7, visibility: 2, texture: { sampleType: 'unfilterable-float' } },
+      ],
+    });
+    const blurPipeline = device.createRenderPipeline({
+      layout: device.createPipelineLayout({ bindGroupLayouts: [blurLayout] }),
+      vertex: { module, entryPoint: 'vs_ssao' },
+      fragment: { module, entryPoint: 'fs_ssao_blur', targets: [{ format: 'r8unorm' }] },
+    });
+    const blurGroup = device.createBindGroup({
+      layout: blurLayout,
+      entries: [
+        { binding: 0, resource: { buffer: uniform } },
+        { binding: 4, resource: normal.createView() },
+        { binding: 5, resource: depth.createView() },
+        { binding: 6, resource: device.createSampler() },
+        { binding: 7, resource: raw.createView() },
+      ],
+    });
+    const filterEncoder = device.createCommandEncoder();
+    const filter = filterEncoder.beginRenderPass({
+      colorAttachments: [{ view: blurred.createView(), loadOp: 'clear', storeOp: 'store' }],
+    });
+    filter.setPipeline(blurPipeline);
+    filter.setBindGroup(0, blurGroup);
+    filter.draw(3);
+    filter.end();
+    filterEncoder.copyTextureToBuffer(
+      { texture: blurred },
+      { buffer: readback, bytesPerRow: 256 },
+      [aoSize, aoSize],
+    );
+    device.queue.submit([filterEncoder.finish()]);
+    await readback.mapAsync(GPU_BUFFER_USAGE_MAP_READ);
+    const filtered = new Uint8Array(readback.getMappedRange());
+    if (scene === 'contact') {
+      let foreground = 0;
+      for (let y = 8; y < aoSize - 8; y++)
+        for (let x = aoSize / 2; x < aoSize / 2 + 3; x++)
+          foreground += 1 - (filtered[y * 256 + x] ?? NaN) / 255;
+      expect(
+        foreground / ((aoSize - 16) * 3),
+        'bilateral blur must not bleed contact AO onto the foreground',
+      ).toBeLessThan(0.005);
+    }
+    expect(errors).toEqual([]);
+    readback.unmap();
+  } finally {
+    for (const resource of [depth, normal, raw, blurred, noise, uniform, kernel, readback])
+      resource.destroy();
+    device.destroy();
+  }
+});