@forgeax/engine-render 0.1.28 → 0.1.30

package/src/__tests__/ssr-temporal-history.unit.test.ts

@@ -0,0 +1,202 @@
+import { RhiNullAdapter, RhiNullQueue } from '@forgeax/engine-rhi-null';
+import { describe, expect, it } from 'vitest';
+import { DeviceScope } from '../device/device-scope';
+import { createSsrHistoryOwner, type SsrHistoryResetReason } from '../ssr/history';
+import { createSsrTemporalConsumer } from '../ssr/temporal';
+import { TemporalFrameCoordinator } from '../temporal/frame-coordinator';
+
+class DeferredQueue extends RhiNullQueue {
+  private readonly completion: Promise<undefined>;
+  private resolveCompletion!: () => void;
+
+  constructor() {
+    super();
+    this.completion = new Promise((resolve) => {
+      this.resolveCompletion = () => resolve(undefined);
+    });
+  }
+
+  override onSubmittedWorkDone(): Promise<undefined> {
+    return this.completion;
+  }
+
+  complete(): void {
+    this.resolveCompletion();
+  }
+}
+
+async function createDevice() {
+  return (await new RhiNullAdapter().requestDevice()).unwrap();
+}
+
+function phases(stage?: 'build' | 'encode' | 'finish' | 'submit') {
+  return {
+    build: () => {
+      if (stage === 'build') throw { stage };
+      return 'built';
+    },
+    encode: () => {
+      if (stage === 'encode') throw { stage };
+    },
+    finish: () => {
+      if (stage === 'finish') throw { stage };
+    },
+    submit: () => {
+      if (stage === 'submit') throw { stage };
+    },
+  };
+}
+
+describe('SSR temporal history owner', () => {
+  it('allocates two half-resolution color-depth and confidence history slots', async () => {
+    const device = await createDevice();
+    const scope = DeviceScope.create(41, 'renderer');
+    const owner = createSsrHistoryOwner({ device, scope, width: 5, height: 3 }).unwrap();
+
+    expect(owner.resources).toMatchObject({
+      width: 5,
+      height: 3,
+      halfWidth: 2,
+      halfHeight: 1,
+      bytes: 48,
+      descriptor: { format: 'rgba16float', sampleCount: 1 },
+    });
+    expect(owner.resources.slots).toHaveLength(2);
+    expect(
+      new Set(owner.resources.slots.flatMap((slot) => [slot.texture, slot.surfaceTexture])).size,
+    ).toBe(4);
+    expect(owner.inspect()).toMatchObject({
+      state: 'first-frame',
+      historyCount: 2,
+      activeBytes: 48,
+      candidateBytes: 0,
+      retiringBytes: 0,
+      historyValid: false,
+    });
+  });
+
+  it('uses the shared coordinator epoch and commits SSR history only after submit', async () => {
+    const device = await createDevice();
+    const scope = DeviceScope.create(42, 'renderer');
+    const owner = createSsrHistoryOwner({ device, scope, width: 5, height: 3 }).unwrap();
+    const coordinator = new TemporalFrameCoordinator<string>();
+    const consumer = createSsrTemporalConsumer(coordinator, owner);
+
+    const first = consumer.run({ current: 'frame-1', antialias: 'none' }, phases());
+    expect(first).toMatchObject({ ok: true, value: { epoch: 1, previous: 'frame-1' } });
+    expect(coordinator.inspect()).toMatchObject({
+      epoch: 1,
+      consumerIds: ['ssr'],
+      attempt: 'committed',
+    });
+    expect(consumer.inspect()).toMatchObject({
+      sharedEpoch: 1,
+      history: { state: 'stable', historyValid: true, activeBytes: 48, candidateBytes: 0 },
+    });
+
+    const second = consumer.run({ current: 'frame-2', antialias: 'none' }, phases());
+    expect(second).toMatchObject({ ok: true, value: { epoch: 2, previous: 'frame-2' } });
+    expect(owner.inspect().historyValid).toBe(true);
+  });
+
+  it.each([
+    'build',
+    'encode',
+    'finish',
+    'submit',
+  ] as const)('aborts the shared candidate and keeps active history on %s failure', async (stage) => {
+    const device = await createDevice();
+    const scope = DeviceScope.create(43, `renderer-${stage}`);
+    const owner = createSsrHistoryOwner({ device, scope, width: 5, height: 3 }).unwrap();
+    const coordinator = new TemporalFrameCoordinator<string>();
+    const consumer = createSsrTemporalConsumer(coordinator, owner);
+
+    const failed = consumer.run({ current: 'candidate', antialias: 'none' }, phases(stage));
+    expect(failed.ok).toBe(false);
+    expect(coordinator.inspect()).toMatchObject({
+      epoch: 0,
+      previous: undefined,
+      attempt: 'aborted',
+    });
+    expect(owner.inspect()).toMatchObject({
+      state: 'aborted',
+      historyValid: false,
+      candidateBytes: 0,
+      lastFailure: stage,
+    });
+  });
+
+  it.each([
+    'first-enable',
+    'resize',
+    'camera-cut',
+    'history-version',
+    'coverage-loss',
+    'reflection-generation',
+    'device-recovery',
+  ] as const)('resets SSR history as current-only on %s', async (reason: SsrHistoryResetReason) => {
+    const device = await createDevice();
+    const scope = DeviceScope.create(44, `renderer-${reason}`);
+    const owner = createSsrHistoryOwner({ device, scope, width: 5, height: 3 }).unwrap();
+    const coordinator = new TemporalFrameCoordinator<string>();
+    const consumer = createSsrTemporalConsumer(coordinator, owner);
+
+    expect(consumer.run({ current: 'stable', antialias: 'none' }, phases()).ok).toBe(true);
+    consumer.reset(reason);
+    expect(owner.inspect()).toMatchObject({ historyValid: false, resetReason: reason });
+    if (reason !== 'first-enable') {
+      expect(coordinator.inspect().epoch).toBe(0);
+    }
+    const afterReset = consumer.begin({ current: 'current-only', antialias: 'none' });
+    expect(afterReset.ok).toBe(true);
+    if (!afterReset.ok) return;
+    expect(afterReset.value.history).toMatchObject({ readSlot: null, historyValid: false });
+    consumer.abort(afterReset.value, 'build');
+  });
+
+  it('retires resized and disabled allocations only after the shared queue fence', async () => {
+    const device = await createDevice();
+    const scope = DeviceScope.create(45, 'renderer');
+    const owner = createSsrHistoryOwner({ device, scope, width: 5, height: 3 }).unwrap();
+    const queue = new DeferredQueue();
+    const failures: unknown[] = [];
+
+    expect(owner.resize(9, 5).ok).toBe(true);
+    expect(owner.inspect()).toMatchObject({
+      width: 9,
+      height: 5,
+      activeBytes: 192,
+      retiringBytes: 48,
+    });
+    owner.retireAfterFence(queue, (cause) => failures.push(cause));
+    expect(owner.inspect().retiringBytes).toBe(48);
+    queue.complete();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(failures).toEqual([]);
+    expect(owner.inspect().retiringBytes).toBe(0);
+
+    owner.retireAfterFence(queue, (cause) => failures.push(cause));
+    expect(owner.inspect().activeBytes).toBe(192);
+    queue.complete();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(owner.inspect()).toMatchObject({ state: 'retired', activeBytes: 0, retiringBytes: 0 });
+    expect(failures).toEqual([]);
+  });
+
+  it('does not expose a second queue or epoch through the consumer inspection', async () => {
+    const device = await createDevice();
+    const scope = DeviceScope.create(46, 'renderer');
+    const owner = createSsrHistoryOwner({ device, scope, width: 4, height: 4 }).unwrap();
+    const coordinator = new TemporalFrameCoordinator<string>();
+    const consumer = createSsrTemporalConsumer(coordinator, owner);
+    const inspection = consumer.inspect();
+
+    expect(inspection.sharedEpoch).toBe(0);
+    expect(inspection.consumerIds).toEqual([]);
+    expect(Object.keys(inspection)).not.toContain('queue');
+    expect(Object.keys(inspection)).not.toContain('submitCount');
+    expect(Object.keys(inspection)).not.toContain('ssrFrameNumber');
+  });
+});

package/src/__tests__/ssr-texel-crossing.dawn.test.ts

@@ -0,0 +1,448 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { mat4 } from '@forgeax/engine-math';
+import { createShaderModuleImmediate, rhi } from '@forgeax/engine-rhi-webgpu';
+import { expect, it } from 'vitest';
+import { GPU_SHADER_STAGE_COMPUTE } from '../gpu-stage';
+import {
+  GPU_TEXTURE_USAGE_COPY_DST,
+  GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
+  GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+} from '../gpu-texture-usage';
+import {
+  GPU_BUFFER_USAGE_COPY_DST,
+  GPU_BUFFER_USAGE_COPY_SRC,
+  GPU_BUFFER_USAGE_MAP_READ,
+  GPU_BUFFER_USAGE_STORAGE,
+  GPU_BUFFER_USAGE_UNIFORM,
+} from '../gpu-usage';
+import { VIEW_UNIFORM_BYTES } from '../record/view-ubo';
+
+it.each([
+  [8, 0],
+  [1024, 0],
+  [1024, 4],
+])('finds depth-texel crossings without extending the silhouette (%i pixels, Hi-Z mip cap %i)', async (width, hizMaxMip) => {
+  const compiler = (await import(
+    /* @vite-ignore */ new URL('../../../shader-compiler/dist/index.mjs', import.meta.url).href
+  )) as {
+    compileShader(
+      source: string,
+      options: { id: string; imports: Record<string, string> },
+    ): Promise<{ ok: boolean; value?: { wgsl: string }; error?: unknown }>;
+  };
+  const shader = (name: string) =>
+    readFileSync(resolve(process.cwd(), `packages/shader/src/${name}.wgsl`), 'utf8');
+  const compiled = await compiler.compileShader(
+    `${shader('ssr-trace')}
+@group(1) @binding(0) var<storage, read_write> crossingProbe: array<vec4<f32>>;
+@compute @workgroup_size(1) fn probe_crossing() {
+  if (${width}u == 1024u) {
+    // A 921.6-pixel projected span: a 512-step march skips texel 598.
+    let hit = traceScreenRay(vec3<f32>(-0.8, 0.0, -1.0),
+      normalize(vec3<f32>(1.0, 0.0, -0.2)), 6.0, 0.2,
+      vec2<u32>(${width}u, 3u), 1.2, ${hizMaxMip}u);
+    crossingProbe[0] = vec4<f32>(hit.hit, hit.uv, hit.thickness);
+    crossingProbe[10] = vec4<f32>(hit.reactivity);
+    // Exercise the rescue fraction helper on both projected axes and signs;
+    // the trace itself is intentionally horizontal in this fixture.
+    crossingProbe[11] = vec4<f32>(
+      ssrRayFraction(vec2<f32>(0.3, 0.2), vec2<f32>(0.1, 0.2), vec2<f32>(0.4, 0.0), 0.9, 1.0),
+      ssrRayFraction(vec2<f32>(0.6, 0.2), vec2<f32>(0.8, 0.2), vec2<f32>(-0.4, 0.0), 0.9, 1.0),
+      ssrRayFraction(vec2<f32>(0.2, 0.4), vec2<f32>(0.2, 0.1), vec2<f32>(0.0, 0.6), 0.9, 1.0),
+      ssrRayFraction(vec2<f32>(0.2, 0.5), vec2<f32>(0.2, 0.8), vec2<f32>(0.0, -0.6), 0.9, 1.0),
+    );
+    return;
+  }
+  let slopes = array<f32, 6>(0.6, 0.3, 0.75, -0.6, -0.3, -0.75);
+  for (var i = 0u; i < 6u; i++) {
+    let x = slopes[i];
+    let hit = traceScreenRay(vec3<f32>(0.0, 0.0, -1.0),
+      vec3<f32>(x, 0.0, -sqrt(1.0 - x*x)), 6.0, 0.2, vec2<u32>(8u, 3u), 2.8, 0u);
+    crossingProbe[i] = vec4<f32>(hit.hit, hit.uv, hit.thickness);
+    crossingProbe[10u + i] = vec4<f32>(hit.reactivity);
+  }
+  let nearHit = traceScreenRay(vec3<f32>(0.101, 0.0, -1.01),
+    vec3<f32>(0.6, 0.0, -0.8), 6.0, 0.2, vec2<u32>(8u, 3u), 1.01, 0u);
+  crossingProbe[6] = vec4<f32>(nearHit.hit, nearHit.uv, nearHit.thickness);
+  // Subpixel receiver shifts must not alter confidence on the same plane.
+  for (var i = 0u; i < 3u; i++) {
+    let shifted = traceScreenRay(vec3<f32>((f32(i) - 1.0) * 0.02, 0.0, -1.0),
+      vec3<f32>(0.6, 0.0, -0.8), 6.0, 0.2, vec2<u32>(8u, 3u), 2.8, 0u);
+    crossingProbe[7u + i] = vec4<f32>(shifted.hit, shifted.uv, shifted.thickness);
+  }
+}`,
+    { id: 'forgeax_ssr::trace', imports: { 'forgeax_view::common': shader('common') } },
+  );
+  if (!compiled.ok || !compiled.value) throw new Error(JSON.stringify(compiled.error));
+  const device = (await (await rhi.requestAdapter()).unwrap().requestDevice()).unwrap();
+  const depth = device
+    .createTexture({
+      size: { width, height: 3, depthOrArrayLayers: 1 },
+      format: 'depth32float',
+      textureBindingViewDimension: '2d',
+      usage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT | GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+    })
+    .unwrap();
+  const data = device
+    .createTexture({
+      size: { width, height: 3, depthOrArrayLayers: 1 },
+      format: 'rgba32float',
+      textureBindingViewDimension: '2d',
+      usage: GPU_TEXTURE_USAGE_COPY_DST | GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+    })
+    .unwrap();
+  const hizWidth = Math.max(1, Math.floor(width / 2));
+  const hizHeight = 1;
+  const hizMipLevels = width === 1024 ? 4 : 1;
+  const hiz = device
+    .createTexture({
+      size: { width: hizWidth, height: hizHeight, depthOrArrayLayers: 1 },
+      mipLevelCount: hizMipLevels,
+      format: 'r32float',
+      textureBindingViewDimension: '2d',
+      usage: GPU_TEXTURE_USAGE_COPY_DST | GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+    })
+    .unwrap();
+  const view = device
+    .createBuffer({
+      size: VIEW_UNIFORM_BYTES,
+      usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+    })
+    .unwrap();
+  const temporal = device
+    .createTexture({
+      size: { width, height: 3, depthOrArrayLayers: 1 },
+      format: 'rgba32float',
+      textureBindingViewDimension: '2d',
+      usage: GPU_TEXTURE_USAGE_COPY_DST | GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+    })
+    .unwrap();
+  const output = device
+    .createBuffer({
+      size: 256,
+      usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_SRC,
+    })
+    .unwrap();
+  const readback = device
+    .createBuffer({
+      size: 256,
+      usage: GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST,
+    })
+    .unwrap();
+  try {
+    const projection = mat4.create();
+    const inverse = mat4.create();
+    mat4.perspective(projection, Math.PI / 2, 1, 1, 10);
+    mat4.invert(inverse, projection);
+    const payload = new Float32Array(VIEW_UNIFORM_BYTES / 4);
+    payload.set(projection, 0);
+    payload.set(inverse, 44);
+    payload.set([1, 10, 0, 0], 228);
+    device.queue.writeBuffer(view, 0, payload).unwrap();
+    const seed = createShaderModuleImmediate(device, {
+      code: `
+@vertex fn seed_vertex(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
+  let p = array<vec2<f32>, 3>(vec2<f32>(-1.0, -1.0), vec2<f32>(3.0, -1.0), vec2<f32>(-1.0, 3.0));
+  return vec4<f32>(p[i], 0.0, 1.0);
+}
+@fragment fn seed_depth(@builtin(position) p: vec4<f32>) -> @builtin(frag_depth) f32 {
+  if (${width}u == 1024u) {
+    let viewDistance = 2.9 / (3.0 - 598.5 / 1024.0);
+    return select(1.0, 10.0 / 9.0 - 10.0 / (9.0 * viewDistance), u32(p.x) == 598u && u32(p.y) == 1u);
+  }
+  // Symmetric texels 2 and 5 contain a wall; their adjacent texels are sky.
+  return select(1.0, 10.0 / 9.0 - 10.0 / (9.0 * 2.8), u32(p.x) == 2u || u32(p.x) == 5u);
+}
+@fragment fn seed_receiver_depth(@builtin(position) p: vec4<f32>) -> @builtin(frag_depth) f32 {
+  if (u32(p.x) == 4u) { return 10.0 / 9.0 - 10.0 / (9.0 * 1.01); }
+  if (u32(p.x) == 5u) { return 10.0 / 9.0 - 10.0 / (9.0 * 1.33); }
+  return 1.0;
+}
+@fragment fn seed_smoothed_depth(@builtin(position) p: vec4<f32>) -> @builtin(frag_depth) f32 {
+  return select(1.0, 10.0 / 9.0 - 10.0 / (9.0 * 1.33), u32(p.x) == 5u || u32(p.x) == 6u);
+}
+@fragment fn seed_oblique_depth(@builtin(position) p: vec4<f32>) -> @builtin(frag_depth) f32 {
+  // Plane z=x-4.15. Its pixel-center view distance is 3.01818,
+  // although the reflected ray meets it inside this texel at distance 2.8.
+  let viewDistance = 4.15 / (1.0 + (p.x / 8.0 * 2.0 - 1.0));
+  return select(1.0, 10.0 / 9.0 - 10.0 / (9.0 * viewDistance), u32(p.x) == 5u);
+}`,
+    }).unwrap();
+    const seedPipelineFor = (entryPoint: string) =>
+      device
+        .createRenderPipeline({
+          layout: 'auto',
+          vertex: { module: seed, entryPoint: 'seed_vertex', buffers: [] },
+          fragment: { module: seed, entryPoint, targets: [] },
+          primitive: { topology: 'triangle-list' },
+          depthStencil: { format: 'depth32float', depthWriteEnabled: true, depthCompare: 'always' },
+        })
+        .unwrap();
+    const seedPipeline = seedPipelineFor('seed_depth');
+    const receiverSeedPipeline = seedPipelineFor('seed_receiver_depth');
+    const smoothedSeedPipeline = seedPipelineFor('seed_smoothed_depth');
+    const obliqueSeedPipeline = seedPipelineFor('seed_oblique_depth');
+    const module = createShaderModuleImmediate(device, { code: compiled.value.wgsl }).unwrap();
+    const inputLayout = device
+      .createBindGroupLayout({
+        entries: [
+          ...[0, 1, 6, 7].map((binding) => ({
+            binding,
+            visibility: GPU_SHADER_STAGE_COMPUTE,
+            texture: {
+              sampleType: binding === 0 ? ('depth' as const) : ('unfilterable-float' as const),
+              viewDimension: '2d' as const,
+            },
+          })),
+          {
+            binding: 3,
+            visibility: GPU_SHADER_STAGE_COMPUTE,
+            texture: { sampleType: 'unfilterable-float' as const, viewDimension: '2d' as const },
+          },
+          { binding: 5, visibility: GPU_SHADER_STAGE_COMPUTE, buffer: { type: 'uniform' } },
+        ],
+      })
+      .unwrap();
+    const outputLayout = device
+      .createBindGroupLayout({
+        entries: [
+          { binding: 0, visibility: GPU_SHADER_STAGE_COMPUTE, buffer: { type: 'storage' } },
+        ],
+      })
+      .unwrap();
+    const pipeline = device
+      .createComputePipeline({
+        layout: device
+          .createPipelineLayout({ bindGroupLayouts: [inputLayout, outputLayout] })
+          .unwrap(),
+        compute: { module, entryPoint: 'probe_crossing' },
+      })
+      .unwrap();
+    const depthView = device.createTextureView(depth, {}).unwrap();
+    const dataView = device.createTextureView(data, {}).unwrap();
+    const hizView = device.createTextureView(hiz, {}).unwrap();
+    const temporalView = device.createTextureView(temporal, {}).unwrap();
+    const inputGroup = device
+      .createBindGroup({
+        layout: inputLayout,
+        entries: [
+          ...[0, 1, 6, 7].map((binding) => ({
+            binding,
+            resource: {
+              kind: 'textureView' as const,
+              value: binding === 0 ? depthView : binding === 7 ? temporalView : dataView,
+            },
+          })),
+          { binding: 3, resource: { kind: 'textureView', value: hizView } },
+          { binding: 5, resource: { kind: 'buffer', value: { buffer: view } } },
+        ],
+      })
+      .unwrap();
+    const outputGroup = device
+      .createBindGroup({
+        layout: outputLayout,
+        entries: [{ binding: 0, resource: { kind: 'buffer', value: { buffer: output } } }],
+      })
+      .unwrap();
+    for (const [name, normalZ, coverage] of [
+      ['front-facing', 1, 1],
+      ['smooth-normal', 0.9, 1],
+      ['back-facing', 0, 1],
+      ['moving-back-facing', 0, 1],
+      ['reactive-back-facing', 0, 1],
+      ['moving-sky', 0, 1],
+      ['excluded', 1, 0],
+      ['receiver', 1, 1],
+      ['oblique', 0.5 + 0.5 * Math.SQRT1_2, 1],
+    ] as const) {
+      if (width === 1024 && (name === 'receiver' || name === 'oblique' || name === 'smooth-normal'))
+        continue;
+      // Mirror the production minimum hierarchy for this long-ray probe:
+      // the wall is in mip 0 texel 299 and in each ancestor selected by the
+      // reduction chain. The trace must descend it back to source x=598.
+      for (let level = 0; level < hizMipLevels; level += 1) {
+        const levelWidth = Math.max(1, hizWidth >> level);
+        const levelData = new Float32Array(levelWidth).fill(3.402823e38);
+        if (width === 1024) {
+          const wallCell = Math.min(levelWidth - 1, Math.floor(598 / 2 ** (level + 1)));
+          levelData[wallCell] = 2.9 / (3 - 598.5 / 1024);
+        }
+        device.queue
+          .writeTexture(
+            { texture: hiz, mipLevel: level },
+            levelData,
+            { bytesPerRow: levelWidth * 4, rowsPerImage: 1 },
+            { width: levelWidth, height: 1, depthOrArrayLayers: 1 },
+          )
+          .unwrap();
+      }
+      device.queue
+        .writeTexture(
+          { texture: temporal },
+          new Float32Array(
+            Array.from({ length: width * 3 }, (_, index) => {
+              const x = index % width;
+              const wall = width === 1024 ? x === 598 : x === 2 || x === 5;
+              return [
+                (name === 'moving-back-facing' && wall) || (name === 'moving-sky' && !wall)
+                  ? 1 / 128
+                  : 0,
+                0,
+                2.8,
+                name === 'reactive-back-facing' && wall ? 0.75 : 0,
+              ];
+            }).flat(),
+          ),
+          { bytesPerRow: width * 16, rowsPerImage: 3 },
+          { width, height: 3, depthOrArrayLayers: 1 },
+        )
+        .unwrap();
+      device.queue
+        .writeTexture(
+          { texture: data },
+          new Float32Array(
+            Array.from({ length: width * 3 }, (_, index) => {
+              const x = index % width;
+              return name === 'receiver' && x === 4
+                ? [0.5, 1, 0.5, coverage]
+                : [
+                    name === 'oblique'
+                      ? 0.5 - 0.5 * Math.SQRT1_2
+                      : name === 'smooth-normal'
+                        ? 0.75 + x * 0.01
+                        : 0.5,
+                    0.5,
+                    normalZ,
+                    coverage,
+                  ];
+            }).flat(),
+          ),
+          { bytesPerRow: width * 16, rowsPerImage: 3 },
+          { width, height: 3, depthOrArrayLayers: 1 },
+        )
+        .unwrap();
+      const encoder = device.createCommandEncoder().unwrap();
+      const raster = encoder.beginRenderPass({
+        colorAttachments: [],
+        depthStencilAttachment: {
+          view: depthView,
+          depthClearValue: 1,
+          depthLoadOp: 'clear',
+          depthStoreOp: 'store',
+        },
+      });
+      raster.setPipeline(
+        name === 'receiver'
+          ? receiverSeedPipeline
+          : name === 'smooth-normal'
+            ? smoothedSeedPipeline
+            : name === 'oblique'
+              ? obliqueSeedPipeline
+              : seedPipeline,
+      );
+      raster.draw(3);
+      raster.end();
+      const pass = encoder.beginComputePass();
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, inputGroup);
+      pass.setBindGroup(1, outputGroup);
+      pass.dispatchWorkgroups(1);
+      pass.end();
+      encoder.copyBufferToBuffer(output, 0, readback, 0, 256);
+      device.queue.submit([encoder.finish().unwrap()]).unwrap();
+      const mapped = (await readback.mapAsync(GPU_BUFFER_USAGE_MAP_READ)).unwrap();
+      const pixels = new Float32Array(mapped.getMappedRange().unwrap().slice(0));
+      mapped.unmap();
+      for (const ray of width === 1024 ? [0] : [0, 3]) {
+        expect(
+          pixels[(10 + ray) * 4],
+          `${name}: rejected moving occluder must invalidate history without becoming a reflection hit`,
+        ).toBe(name === 'moving-back-facing' ? 0.5 : name === 'reactive-back-facing' ? 0.75 : 0);
+      }
+      if (width === 1024) {
+        expect(pixels[0], `${name}: long ray must not skip its only wall texel`).toBe(
+          name === 'front-facing' ? 1 : 0,
+        );
+        if (name === 'front-facing') {
+          expect(pixels[1]).toBeCloseTo(598.5 / 1024, 5);
+          expect(pixels[2]).toBeCloseTo(0.5, 6);
+          expect(pixels[3]).toBeGreaterThan(0.99);
+        }
+        if (name === 'front-facing') {
+          expect(pixels[44]).toBeCloseTo(0.5, 6);
+          expect(pixels[45]).toBeCloseTo(0.5, 6);
+          expect(pixels[46]).toBeCloseTo(0.5, 6);
+          expect(pixels[47]).toBeCloseTo(0.5, 6);
+        }
+        continue;
+      }
+      if (name === 'receiver') {
+        // The coarse sample sees the wall, but a depth-only bisection moves
+        // backward onto the receiver. Its differently facing plane must not
+        // steal the bracket. Analytic t=(1.33-1.01)/0.8=0.4, x=0.341.
+        expect(pixels[24], 'refinement must retain the wall, not the receiver').toBe(1);
+        expect(pixels[25]).toBeCloseTo(0.5 + (0.5 * 0.341) / 1.33, 6);
+        expect(pixels[26]).toBeCloseTo(0.5, 6);
+        expect(pixels[27]).toBeGreaterThan(0.99);
+        continue;
+      }
+      if (name === 'smooth-normal') {
+        // The depth crossing belongs to texel 5. A smooth/normal-mapped
+        // shading normal points its tangent correction into adjacent sky;
+        // retry with depth geometry must recover the analytic intersection,
+        // not merely accept the stair-stepped depth crossing.
+        expect(pixels[24], 'shading-normal refinement must retain a valid depth crossing').toBe(1);
+        expect(pixels[25]).toBeCloseTo(0.5 + (0.5 * 0.341) / 1.33, 6);
+        expect(pixels[27]).toBeGreaterThan(0.99);
+        continue;
+      }
+      if (name === 'oblique') {
+        expect(pixels[0], 'pixel-center depth must not reject an in-texel oblique-plane hit').toBe(
+          1,
+        );
+        expect(pixels[1]).toBeCloseTo(0.5 + (0.5 * 1.35) / 2.8, 6);
+        expect(pixels[2]).toBeCloseTo(0.5, 6);
+        expect(pixels[3], 'an exact tangent-plane hit has no thickness residual').toBeGreaterThan(
+          0.9999,
+        );
+        for (let i = 0; i < 3; i++) {
+          const x = (i - 1) * 0.02;
+          const distance = (3.15 - x) / 1.4;
+          const offset = (7 + i) * 4;
+          expect(pixels[offset], 'subpixel shift retains the oblique plane').toBe(1);
+          expect(pixels[offset + 1]).toBeCloseTo(
+            0.5 + (0.5 * (x + 0.6 * distance)) / (1 + 0.8 * distance),
+            6,
+          );
+          expect(
+            pixels[offset + 3],
+            'confidence is independent of position inside the depth texel',
+          ).toBeGreaterThan(0.9999);
+        }
+        for (const offset of [4, 8, 12, 16, 20]) {
+          expect(pixels[offset], 'oblique-plane sky').toBe(0);
+        }
+        continue;
+      }
+      for (const offset of [0, 12]) {
+        expect(pixels[offset + 4], `${name}: inner sky`).toBe(0);
+        expect(pixels[offset + 8], `${name}: outer sky`).toBe(0);
+        expect(pixels[offset], `${name}: wall crossing`).toBe(name === 'front-facing' ? 1 : 0);
+        if (name === 'front-facing') {
+          // Analytic t=(2.8-1)/0.8=2.25, x=+/-1.35, inside texel 5/2.
+          const sign = offset === 0 ? 1 : -1;
+          expect(pixels[offset + 1]).toBeCloseTo(0.5 + (sign * (0.5 * 1.35)) / 2.8, 6);
+          expect(pixels[offset + 2]).toBeCloseTo(0.5, 6);
+          expect(pixels[offset + 3]).toBeGreaterThan(0.99);
+        }
+      }
+    }
+  } finally {
+    device.destroyTexture(depth).unwrap();
+    device.destroyTexture(data).unwrap();
+    device.destroyTexture(hiz).unwrap();
+    device.destroyTexture(temporal).unwrap();
+    for (const buffer of [view, output, readback]) device.destroyBuffer(buffer).unwrap();
+  }
+});