@forgeax/engine-render 0.1.32 → 0.1.34

package/src/__tests__/factory-contract.integration.test.ts

@@ -19,6 +19,7 @@ import { describe, expect, it, vi } from 'vitest';
 import type { RhiBackendPack } from '../assembly/backend-contract';
 import { createRenderer as constructRenderer } from '../assembly/factory';
 import {
+  BarrelDistortion,
   DirectionalLight,
   DynamicResolution,
   MeshFilter,
@@ -83,6 +84,10 @@ async function createBloomScenario() {
           antialias: ANTIALIAS_NONE,
           tonemap: TONEMAP_ACES_FILMIC,
           bloom: BLOOM_ENABLED,
+          bloomThreshold: 1,
+          bloomIntensity: 1,
+          bloomSoftKnee: 0.5,
+          bloomScatter: 0.7,
         },
       },
     )
@@ -103,13 +108,132 @@ async function createBloomScenario() {
     const updated = world.update();
     if (!updated.ok) throw updated.error;
   };
+  const setBloomIntensity = (bloomIntensity: number) => {
+    world.set(camera, LocalCamera, { bloomIntensity }).unwrap();
+    const updated = world.update();
+    if (!updated.ok) throw updated.error;
+  };
   const dispose = async () => {
     await renderer.dispose();
   };
-  return { renderer, draw, setBloom, dispose, canvas };
+  return { renderer, draw, setBloom, setBloomIntensity, dispose, canvas };
+}
+
+async function createMotionBlurScenario() {
+  const renderer = await constructRenderer(
+    { width: 64, height: 64, getContext: () => null },
+    { rhi },
+    { shaderManifestUrl: renderLifecycleManifestUrl() },
+  );
+  if (!(await renderer.initialization).ok)
+    throw new Error('Motion Blur renderer initialization failed');
+  const world = new World();
+  const attached = renderer.attach(world);
+  if (!attached.ok) throw attached.error;
+  registerPropagateTransforms(world);
+  const camera = world
+    .spawn(
+      { component: Transform, data: { pos: [0, 0, 4] } },
+      {
+        component: LocalCamera,
+        data: {
+          fov: 1,
+          aspect: 1,
+          near: 0.1,
+          far: 100,
+          antialias: ANTIALIAS_NONE,
+          tonemap: TONEMAP_ACES_FILMIC,
+        },
+      },
+    )
+    .unwrap();
+  world
+    .addComponent(camera, {
+      component: MotionBlur,
+      data: { shutterAngle: 180, maxRadiusPixels: 8, sampleCount: 4, targetFps: 60 },
+    })
+    .unwrap();
+  const frameInput = () => ({
+    leases: [attached.value],
+    camera: { lease: attached.value },
+    environment: { lease: attached.value },
+  });
+  return {
+    renderer,
+    draw: () => renderer.draw(frameInput()),
+    dispose: () => renderer.dispose(),
+  };
+}
+
+function createGenericPostProbeFeature(): RenderFeature<undefined> {
+  return {
+    identity: 'synthetic.generic-post-probe',
+    placement: 'post',
+    shaderModuleMode: 'immediate',
+    extract: () => ok(undefined),
+    plan: () =>
+      ok({
+        resources: [
+          {
+            kind: 'compute-program' as const,
+            name: 'generic-post-probe-program',
+            program: {
+              wgsl: '@compute @workgroup_size(1) fn main() {}',
+              entryPoints: ['main'],
+            },
+          },
+          {
+            kind: 'compute-bindings' as const,
+            name: 'generic-post-probe-bindings',
+            program: 'generic-post-probe-program',
+            entries: [],
+          },
+        ],
+        passes: [
+          {
+            kind: 'compute' as const,
+            name: 'generic-post-probe',
+            program: 'generic-post-probe-program',
+            bindings: 'generic-post-probe-bindings',
+            dispatches: [{ kind: 'direct' as const, entryPoint: 'main', workgroups: [1] }],
+          },
+        ],
+      }),
+  };
 }
 
 describe('factory contract', () => {
+  it('does not publish renderer initialization before boot queue work settles', async () => {
+    const fence = deferred<undefined>();
+    const onSubmittedWorkDone = vi
+      .spyOn(RhiNullQueue.prototype, 'onSubmittedWorkDone')
+      .mockReturnValue(fence.promise);
+    const canvas = { width: 64, height: 64, getContext: () => null };
+    let renderer: Awaited<ReturnType<typeof constructRenderer>> | undefined;
+    try {
+      renderer = await constructRenderer(
+        canvas,
+        { rhi },
+        { shaderManifestUrl: renderLifecycleManifestUrl() },
+      );
+      let settled = false;
+      const initialization = renderer.initialization.then(() => {
+        settled = true;
+      });
+      await vi.waitFor(() => expect(onSubmittedWorkDone).toHaveBeenCalled(), {
+        timeout: 2_000,
+      });
+      expect(settled).toBe(false);
+      fence.resolve(undefined);
+      await initialization;
+      expect(settled).toBe(true);
+    } finally {
+      fence.resolve(undefined);
+      onSubmittedWorkDone.mockRestore();
+      await renderer?.dispose();
+    }
+  });
+
   it('requires one Renderer-owned target lifecycle seam', () => {
     expect(existsSync(renderTargetHostSourcePath)).toBe(true);
     const factorySource = readFileSync(factorySourcePath, 'utf8');
@@ -144,7 +268,7 @@ describe('factory contract', () => {
   it('releases its profiler catalog contribution on dispose', async () => {
     const profiler = createProfiler();
     const renderer = await constructRenderer(
-      { getContext: () => null },
+      { width: 64, height: 64, getContext: () => null },
       { profiler, rhi },
       { shaderManifestUrl: manifestUrl() },
     );
@@ -172,7 +296,7 @@ describe('factory contract', () => {
 
     try {
       const renderer = await constructRenderer(
-        { getContext: () => null },
+        { width: 64, height: 64, getContext: () => null },
         { rhi },
         { shaderManifestUrl: renderLifecycleManifestUrl() },
       );
@@ -218,7 +342,7 @@ describe('factory contract', () => {
         }),
     } as never;
     const renderer = await constructRenderer(
-      { getContext: () => null },
+      { width: 64, height: 64, getContext: () => null },
       {
         rhi: timingRhi,
         gpuPassTiming: { maxPassesPerFrame: 4, maxFramesInFlight: 1, retentionFrames: 2 },
@@ -231,7 +355,7 @@ describe('factory contract', () => {
 
   it('completes the receipt-bound create, attach, draw, observe, recover chain', async () => {
     const renderer = await constructRenderer(
-      { getContext: () => null },
+      { width: 64, height: 64, getContext: () => null },
       { rhi },
       { shaderManifestUrl: manifestUrl() },
     );
@@ -248,7 +372,7 @@ describe('factory contract', () => {
       camera: { lease },
       environment: { lease },
     });
-    expect(frame.ok).toBe(true);
+    expect(frame.ok, frame.ok ? '' : JSON.stringify(frame.error)).toBe(true);
     if (!frame.ok || frame.value === undefined) return;
 
     const observed = await renderer.observe(frame.value, { include: ['timings'] });
@@ -261,7 +385,7 @@ describe('factory contract', () => {
 
   it('rejects the removed Standard reflection-probe profile field at the Renderer boundary', async () => {
     const renderer = await constructRenderer(
-      { getContext: () => null },
+      { width: 64, height: 64, getContext: () => null },
       { rhi },
       { shaderManifestUrl: manifestUrl() },
     );
@@ -277,7 +401,7 @@ describe('factory contract', () => {
 
   it('projects stable output and observation identity without pixel payloads', async () => {
     const renderer = await constructRenderer(
-      { getContext: () => null },
+      { width: 64, height: 64, getContext: () => null },
       { rhi },
       { shaderManifestUrl: manifestUrl() },
     );
@@ -306,7 +430,7 @@ describe('factory contract', () => {
 
   it('delivers a target readback only through its matching receipt', async () => {
     const renderer = await constructRenderer(
-      { getContext: () => null },
+      { width: 64, height: 64, getContext: () => null },
       { rhi },
       { shaderManifestUrl: manifestUrl() },
     );
@@ -335,7 +459,7 @@ describe('factory contract', () => {
       camera: { lease: attached.value },
       environment: { lease: attached.value },
     });
-    expect(frame.ok).toBe(true);
+    expect(frame.ok, frame.ok ? '' : JSON.stringify(frame.error)).toBe(true);
     if (!frame.ok || frame.value === undefined) return;
     const observed = await renderer.observe(frame.value, {
       include: ['target-readbacks'],
@@ -384,11 +508,65 @@ describe('factory contract', () => {
       camera: { lease: attached.value },
       environment: { lease: attached.value },
     });
-    expect(frame.ok).toBe(true);
+    expect(frame.ok, frame.ok ? '' : JSON.stringify(frame.error)).toBe(true);
     expect(planCalls).toBe(1);
     renderer.dispose();
   });
 
+  it('projects the active barrel stage through the ordinary feature host once', async () => {
+    const renderer = await constructRenderer(
+      { width: 64, height: 64, getContext: () => null },
+      { rhi },
+      { shaderManifestUrl: renderLifecycleManifestUrl() },
+    );
+    expect((await renderer.initialization).ok).toBe(true);
+    const world = new World();
+    const attached = renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+    registerPropagateTransforms(world);
+    world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 4] } },
+        {
+          component: LocalCamera,
+          data: {
+            fov: 1,
+            aspect: 1,
+            near: 0.1,
+            far: 100,
+            antialias: ANTIALIAS_NONE,
+            tonemap: TONEMAP_ACES_FILMIC,
+            bloom: BLOOM_DISABLED,
+          },
+        },
+        { component: BarrelDistortion, data: { strength: 0.2, centerX: 0.5, centerY: 0.5 } },
+      )
+      .unwrap();
+    expect(world.update().ok).toBe(true);
+    const frame = renderer.draw({
+      leases: [attached.value],
+      camera: { lease: attached.value },
+      environment: { lease: attached.value },
+    });
+    expect(frame.ok, frame.ok ? '' : JSON.stringify(frame.error)).toBe(true);
+    if (frame.ok && frame.value !== undefined) {
+      expect(frame.value.barrelDistortion).toMatchObject({
+        width: 64,
+        height: 64,
+        camera: { projection: 'perspective' },
+      });
+      expect(frame.value.barrelDistortion?.strength).toBeCloseTo(0.2, 6);
+      expect(
+        renderer.perFramePassNames.filter((name) => name === 'barrel-distortion'),
+      ).toHaveLength(1);
+      expect(
+        renderer.perFramePassNames.filter((name) => name.startsWith('post-effect-')),
+      ).toHaveLength(0);
+    }
+    await renderer.dispose();
+  });
+
   it('keeps the active graph as LKG while a feature candidate is pending', async () => {
     let invalid = false;
     let featurePlanCalls = 0;
@@ -624,7 +802,7 @@ describe('factory contract', () => {
 
   it('attaches derived-state systems once without putting writes in draw', async () => {
     const renderer = await constructRenderer(
-      { getContext: () => null },
+      { width: 64, height: 64, getContext: () => null },
       { rhi },
       { shaderManifestUrl: manifestUrl() },
     );
@@ -640,12 +818,12 @@ describe('factory contract', () => {
 
   it('releases one World without disposing the shared Renderer', async () => {
     const first = await constructRenderer(
-      { getContext: () => null },
+      { width: 64, height: 64, getContext: () => null },
       { rhi },
       { shaderManifestUrl: manifestUrl() },
     );
     const second = await constructRenderer(
-      { getContext: () => null },
+      { width: 64, height: 64, getContext: () => null },
       { rhi },
       { shaderManifestUrl: manifestUrl() },
     );
@@ -662,7 +840,11 @@ describe('factory contract', () => {
   it('resolves a renderer for a host canvas and rejects missing input', async () => {
     const manifest = `data:application/json,${encodeURIComponent(JSON.stringify({ schemaVersion: '1.0.0', entries: [] }))}`;
     await expect(
-      constructRenderer({ getContext: () => null }, { rhi }, { shaderManifestUrl: manifest }),
+      constructRenderer(
+        { width: 64, height: 64, getContext: () => null },
+        { rhi },
+        { shaderManifestUrl: manifest },
+      ),
     ).resolves.toMatchObject({
       attach: expect.any(Function),
       draw: expect.any(Function),
@@ -673,7 +855,7 @@ describe('factory contract', () => {
   it('temporarily releases presentation while preserving the Renderer identity', async () => {
     const manifest = `data:application/json,${encodeURIComponent(JSON.stringify({ schemaVersion: '1.0.0', entries: [] }))}`;
     const renderer = await constructRenderer(
-      { getContext: () => null },
+      { width: 64, height: 64, getContext: () => null },
       { rhi },
       { shaderManifestUrl: manifest },
     );
@@ -689,7 +871,7 @@ describe('factory contract', () => {
   it('does not unconfigure a surface after its ownership was released', async () => {
     let unconfigureCalls = 0;
     const renderer = await constructRenderer(
-      { getContext: () => null },
+      { width: 64, height: 64, getContext: () => null },
       {
         rhi: {
           ...rhi,
@@ -718,19 +900,70 @@ describe('factory contract', () => {
     expect(unconfigureCalls).toBe(1);
   });
 
+  it('keeps direct RHI instrumentation explicit-only at the factory boundary', async () => {
+    const drawOneFrame = (renderer: Awaited<ReturnType<typeof constructRenderer>>) => {
+      const world = new World();
+      const attached = renderer.attach(world);
+      expect(attached.ok).toBe(true);
+      if (!attached.ok) return;
+      expect(world.update().ok).toBe(true);
+      const frame = renderer.draw({
+        leases: [attached.value],
+        camera: { lease: attached.value },
+        environment: { lease: attached.value },
+      });
+      expect(frame.ok, frame.ok ? '' : JSON.stringify(frame.error)).toBe(true);
+    };
+    const moduleBoundary = vi.fn();
+    const implicit = await constructRenderer(
+      { width: 64, height: 64, getContext: () => null },
+      {
+        rhi: {
+          ...rhi,
+          instrumentation: { onFrameBoundary: moduleBoundary },
+        } as never,
+      },
+      { shaderManifestUrl: manifestUrl() },
+    );
+    expect((await implicit.initialization).ok).toBe(true);
+    drawOneFrame(implicit);
+    expect(moduleBoundary).not.toHaveBeenCalled();
+    expect((await implicit.dispose()).ok).toBe(true);
+
+    const explicitBoundary = vi.fn();
+    const explicit = await constructRenderer(
+      { width: 64, height: 64, getContext: () => null },
+      {
+        rhi: {
+          ...rhi,
+          instrumentation: { onFrameBoundary: moduleBoundary },
+        } as never,
+        rhiInstrumentation: { onFrameBoundary: explicitBoundary },
+      },
+      { shaderManifestUrl: manifestUrl() },
+    );
+    expect((await explicit.initialization).ok).toBe(true);
+    drawOneFrame(explicit);
+    expect(explicitBoundary).toHaveBeenCalled();
+    expect(moduleBoundary).not.toHaveBeenCalled();
+    expect((await explicit.dispose()).ok).toBe(true);
+  });
+
   it('retains the device-owned prewarmed TAA shader across off and on', async () => {
     const pending: Array<{
       readonly label: string;
       readonly promise: Promise<ReturnType<typeof ok<ShaderModule>>>;
       readonly resolve: (value: ReturnType<typeof ok<ShaderModule>>) => void;
     }> = [];
-    const moduleCalls: string[] = [];
+    const moduleSources: string[] = [];
+    const frameBoundary = vi.fn();
     const backend: RhiBackendPack = {
       rhi,
+      instrumentation: { onFrameBoundary: frameBoundary },
       createShaderModule: (_device, desc) => {
         const label = desc.label ?? '<unlabeled>';
-        moduleCalls.push(label);
-        if (!label.startsWith('post-process-forgeax.taa-resolve-pso-')) {
+        moduleSources.push(desc.code);
+        if (!desc.code.includes('fs_taa_resolve')) {
           return Promise.resolve(ok({} as ShaderModule));
         }
         let resolve!: (value: ReturnType<typeof ok<ShaderModule>>) => void;
@@ -781,7 +1014,8 @@ describe('factory contract', () => {
     });
 
     const first = renderer.draw(frameInput());
-    expect(first.ok).toBe(true);
+    expect(first.ok, first.ok ? '' : JSON.stringify(first.error)).toBe(true);
+    expect(frameBoundary).toHaveBeenCalled();
     expect(pending).toHaveLength(1);
 
     world.set(camera, LocalCamera, { antialias: ANTIALIAS_NONE }).unwrap();
@@ -789,14 +1023,12 @@ describe('factory contract', () => {
     const off = renderer.draw(frameInput());
     expect(off.ok).toBe(true);
 
-    expect(
-      moduleCalls.filter((label) => label.startsWith('post-process-forgeax.taa-resolve-pso-')),
-    ).toHaveLength(1);
+    expect(moduleSources.filter((source) => source.includes('fs_taa_resolve'))).toHaveLength(1);
 
     world.set(camera, LocalCamera, { antialias: ANTIALIAS_TAA }).unwrap();
     expect(world.update().ok).toBe(true);
     const second = renderer.draw(frameInput());
-    expect(second.ok).toBe(true);
+    expect(second.ok, second.ok ? '' : JSON.stringify(second.error)).toBe(true);
     expect(pending).toHaveLength(1);
     expect(renderer.draw(frameInput()).ok).toBe(true);
     world.set(camera, LocalCamera, { antialias: ANTIALIAS_NONE }).unwrap();
@@ -810,13 +1042,11 @@ describe('factory contract', () => {
 
     expect((await renderer.dispose()).ok).toBe(true);
     expect((await renderer.dispose()).ok).toBe(true);
-    expect(
-      moduleCalls.filter((label) => label.startsWith('post-process-forgeax.taa-resolve-pso-')),
-    ).toHaveLength(1);
+    expect(moduleSources.filter((source) => source.includes('fs_taa_resolve'))).toHaveLength(1);
   });
 
   it('rebuilds a TAA graph for a same-mode target resize', async () => {
-    const moduleCalls: string[] = [];
+    const moduleSources: string[] = [];
     const created = new Map<object, string>();
     const destroyed = new Set<object>();
     let wrappedDevice: object | undefined;
@@ -859,7 +1089,7 @@ describe('factory contract', () => {
     const backend: RhiBackendPack = {
       rhi: instrumentedRhi,
       createShaderModule: async (_device, desc) => {
-        moduleCalls.push(desc.label ?? '<unlabeled>');
+        moduleSources.push(desc.code);
         return ok({} as ShaderModule);
       },
     };
@@ -898,14 +1128,12 @@ describe('factory contract', () => {
       await Promise.resolve();
       first = renderer.draw(frameInput());
     }
-    expect(first.ok).toBe(true);
+    expect(first.ok, first.ok ? '' : JSON.stringify(first.error)).toBe(true);
     const firstGeneration = [...created.entries()]
       .filter(([_, label]) => label.startsWith('taa-history-'))
       .slice(-4);
     expect(firstGeneration).toHaveLength(4);
-    expect(
-      moduleCalls.filter((label) => label.startsWith('post-process-forgeax.taa-resolve-pso-')),
-    ).toHaveLength(1);
+    expect(moduleSources.filter((source) => source.includes('fs_taa_resolve'))).toHaveLength(1);
     const firstFrame = renderer.inspect().frame.frameId;
 
     canvas.width = 96;
@@ -927,9 +1155,7 @@ describe('factory contract', () => {
     expect(replacementGeneration.every(([handle]) => !destroyed.has(handle))).toBe(true);
     expect(renderer.inspect().frame.frameId).toBe(firstFrame + 1);
     expect(renderer.inspect().state).toBe('alive');
-    expect(
-      moduleCalls.filter((label) => label.startsWith('post-process-forgeax.taa-resolve-pso-')),
-    ).toHaveLength(1);
+    expect(moduleSources.filter((source) => source.includes('fs_taa_resolve'))).toHaveLength(1);
     world.set(camera, LocalCamera, { antialias: ANTIALIAS_NONE }).unwrap();
     expect(world.update().ok).toBe(true);
     expect(renderer.draw(frameInput()).ok).toBe(true);
@@ -1086,12 +1312,189 @@ describe('factory contract', () => {
     }
     const inspection = renderer.inspect();
     expect(inspection.perFramePassNames).toContain('motion-blur');
+    // The same Rhi device/frame admitted the compute plan, graph, and both
+    // production dispatches. This is the application-side admission proof;
+    // Dawn/physical timing remains a separate backend gate.
+    expect(inspection.capabilities).toMatchObject({
+      compute: true,
+      storageBuffer: true,
+      storageTexture: true,
+      rgba16floatRenderable: true,
+    });
+    expect(inspection.motionBlur).toMatchObject({ lane: 'compute', passCount: 2 });
+    expect(inspection.perFramePassNames).toContain('motion-blur');
+    expect(inspection.recoveryEvidence.graph).toMatchObject({ ready: true });
+    expect(inspection.featureGraph?.compileSuccesses ?? 0).toBeGreaterThan(0);
+    // The graph is present, but this is the first accepted temporal pair
+    // after the effect was added. Inspection must expose the reset boundary
+    // until a subsequent successful pair can provide a valid baseline.
     expect(inspection.motionBlur).toMatchObject({
       enabled: true,
-      status: 'active',
+      status: 'reset',
+      temporalDemand: 'scene-data-temporal-v1',
+    });
+    await renderer.dispose();
+  });
+
+  it('projects generic post work once and keeps Motion Blur independent across Standard lanes', async () => {
+    for (const renderPath of ['forward', 'deferred'] as const) {
+      for (const taa of [false, true]) {
+        const renderer = await constructRenderer(
+          { width: 64, height: 64, getContext: () => null },
+          { rhi, features: [createGenericPostProbeFeature()] },
+          { shaderManifestUrl: renderLifecycleManifestUrl() },
+        );
+        try {
+          expect((await renderer.initialization).ok).toBe(true);
+          expect(renderer.setProfile({ ...DEFAULT_STANDARD_PROFILE, renderPath }).ok).toBe(true);
+          const world = new World();
+          const attached = renderer.attach(world);
+          expect(attached.ok).toBe(true);
+          if (!attached.ok) continue;
+          registerPropagateTransforms(world);
+          const camera = world
+            .spawn(
+              { component: Transform, data: { pos: [0, 0, 4] } },
+              {
+                component: LocalCamera,
+                data: {
+                  fov: 1,
+                  aspect: 1,
+                  near: 0.1,
+                  far: 100,
+                  antialias: taa ? ANTIALIAS_TAA : ANTIALIAS_NONE,
+                  tonemap: TONEMAP_ACES_FILMIC,
+                },
+              },
+            )
+            .unwrap();
+          world
+            .addComponent(camera, {
+              component: MotionBlur,
+              data: { shutterAngle: 180, maxRadiusPixels: 8, sampleCount: 4, targetFps: 60 },
+            })
+            .unwrap();
+          expect(world.update().ok).toBe(true);
+          const draw = renderer.draw({
+            leases: [attached.value],
+            camera: { lease: attached.value },
+            environment: { lease: attached.value },
+          });
+          expect(draw.ok).toBe(true);
+          if (!draw.ok || draw.value === undefined) continue;
+          const completed = await draw.value.completed;
+          expect(completed.ok).toBe(true);
+          if (!completed.ok) continue;
+          const inspection = renderer.inspect();
+          const names = inspection.perFramePassNames;
+          const genericIndex = names.indexOf('generic-post-probe');
+          const motionSummaryIndex = names.indexOf('motion-blur-tile-summary');
+          const motionIndex = names.indexOf('motion-blur');
+          const outputIndex = names.indexOf('output-transform');
+          expect(names.filter((name) => name === 'generic-post-probe')).toHaveLength(1);
+          expect(names.filter((name) => name === 'motion-blur-tile-summary')).toHaveLength(1);
+          expect(names.filter((name) => name === 'motion-blur')).toHaveLength(1);
+          expect(genericIndex).toBeGreaterThanOrEqual(0);
+          expect(motionSummaryIndex).toBeGreaterThanOrEqual(0);
+          expect(motionIndex).toBeGreaterThan(motionSummaryIndex);
+          expect(outputIndex).toBeGreaterThan(motionIndex);
+          if (taa) expect(names.indexOf('taa-resolve')).toBeLessThan(motionSummaryIndex);
+          else expect(names).not.toContain('taa-resolve');
+          expect(inspection.motionBlur).toMatchObject({
+            enabled: true,
+            passCount: 2,
+            execution: { passes: [{ name: 'motion-blur-tile-summary' }, { name: 'motion-blur' }] },
+          });
+          // A completed two-pass execution is the public Renderer proof that
+          // the named motion-blurred-color target had a writer and was then
+          // consumed by the shared output chain.
+          expect(inspection.featureGraph?.compileSuccesses ?? 0).toBeGreaterThan(0);
+        } finally {
+          await renderer.dispose();
+        }
+      }
+    }
+  });
+
+  it('publishes invalid MotionBlur parameters through renderer inspection', async () => {
+    const renderer = await constructRenderer(
+      { width: 64, height: 64, getContext: () => null },
+      { rhi },
+      { shaderManifestUrl: renderLifecycleManifestUrl() },
+    );
+    expect((await renderer.initialization).ok).toBe(true);
+    const errors: unknown[] = [];
+    renderer.onError((error) => errors.push(error));
+    const world = new World();
+    const attached = renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+    registerPropagateTransforms(world);
+    const camera = world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 4] } },
+        {
+          component: LocalCamera,
+          data: { fov: 1, aspect: 1, near: 0.1, far: 100, antialias: ANTIALIAS_TAA },
+        },
+        { component: MotionBlur, data: { targetFps: 59.5 } },
+      )
+      .unwrap();
+    const frameInput = () => ({
+      leases: [attached.value],
+      camera: { lease: attached.value },
+      environment: { lease: attached.value },
+    });
+    expect(world.update().ok).toBe(true);
+
+    const draw = renderer.draw(frameInput());
+    expect(draw.ok).toBe(false);
+    if (!draw.ok) {
+      expect(draw.error).toMatchObject({
+        code: 'motion-blur-invalid-params',
+        detail: { field: 'targetFps', value: 59.5, integer: true },
+      });
+    }
+    expect(errors).toEqual(
+      expect.arrayContaining([expect.objectContaining({ code: 'motion-blur-invalid-params' })]),
+    );
+    expect(renderer.inspect().motionBlur).toMatchObject({
+      enabled: true,
+      status: 'invalid',
+      lastFailure: 'invalid-params',
       temporalDemand: 'scene-data-temporal-v1',
     });
     await renderer.dispose();
+    void camera;
+  });
+
+  it('projects a rejected Motion Blur submit while retaining its accepted baseline', async () => {
+    const scenario = await createMotionBlurScenario();
+    const submit = vi.spyOn(RhiNullQueue.prototype, 'submit');
+    const failure = new RhiError({
+      code: 'webgpu-runtime-error',
+      expected: 'Motion Blur queue submission succeeds',
+      hint: 'repair the queue and retry the same frame',
+    });
+    try {
+      expect(scenario.draw().ok).toBe(true);
+      expect(scenario.draw().ok).toBe(true);
+      const accepted = scenario.renderer.inspect().motionBlur;
+      expect(accepted).toMatchObject({ enabled: true });
+      expect(accepted).not.toHaveProperty('lastFailure');
+      submit.mockReturnValueOnce(err(failure));
+      expect(scenario.draw().ok).toBe(false);
+      expect(scenario.renderer.inspect().motionBlur).toMatchObject({
+        enabled: true,
+        lastFailure: 'submit-failure',
+      });
+      submit.mockRestore();
+      expect(scenario.draw().ok).toBe(true);
+      expect(scenario.renderer.inspect().motionBlur?.lastFailure).toBeUndefined();
+    } finally {
+      submit.mockRestore();
+      await scenario.dispose();
+    }
   });
 
   it('retires factory-owned TAA textures and params on an off submit', async () => {
@@ -1168,7 +1571,7 @@ describe('factory contract', () => {
       await Promise.resolve();
       first = renderer.draw(frameInput());
     }
-    expect(first.ok).toBe(true);
+    expect(first.ok, first.ok ? '' : JSON.stringify(first.error)).toBe(true);
     const historyHandles = [...created.entries()].filter(([_, label]) =>
       label.startsWith('taa-history-'),
     );
@@ -1230,12 +1633,12 @@ describe('factory contract', () => {
     const onInspection = renderer.inspect().bloom;
     expect(onInspection.state).toBe('active');
     expect(onInspection.graphStatus).toBe('valid');
-    expect(onInspection.targetCount).toBe(4);
-    expect(onInspection.targetBytes).toBe((64 * 64 + 3 * 32 * 32) * 8);
-    expect(onInspection.passCount).toBe(4);
-    expect(onInspection.uploadCount).toBe(4);
-    expect(onInspection.bindGroupCount).toBe(4);
-    expect(onInspection.encodeCount).toBe(4);
+    expect(onInspection.targetCount).toBe(10);
+    expect(onInspection.targetBytes).toBe(54_560);
+    expect(onInspection.passCount).toBe(10);
+    expect(onInspection.uploadCount).toBe(10);
+    expect(onInspection.bindGroupCount).toBe(10);
+    expect(onInspection.encodeCount).toBe(10);
     expect(JSON.parse(JSON.stringify(onInspection))).toEqual(onInspection);
     const firstGeneration = onInspection.generation;
     expect(firstGeneration).toBeGreaterThan(0);
@@ -1266,10 +1669,10 @@ describe('factory contract', () => {
     const recoveredInspection = renderer.inspect().bloom;
     expect(recoveredInspection.state).toBe('active');
     expect(recoveredInspection.resourceCount).toBeGreaterThan(0);
-    expect(recoveredInspection.passCount).toBe(4);
-    expect(recoveredInspection.uploadCount).toBe(4);
-    expect(recoveredInspection.bindGroupCount).toBe(4);
-    expect(recoveredInspection.encodeCount).toBe(4);
+    expect(recoveredInspection.passCount).toBe(10);
+    expect(recoveredInspection.uploadCount).toBe(10);
+    expect(recoveredInspection.bindGroupCount).toBe(10);
+    expect(recoveredInspection.encodeCount).toBe(10);
     expect(recoveredInspection.generation).toBeGreaterThan(firstGeneration);
     await Promise.resolve();
     await Promise.resolve();
@@ -1290,25 +1693,25 @@ describe('factory contract', () => {
     try {
       expect(scenario.draw().ok).toBe(true);
       expect(scenario.renderer.inspect().bloom).toMatchObject({
-        uploadCount: 4,
-        bindGroupCount: 4,
-        encodeCount: 4,
+        uploadCount: 10,
+        bindGroupCount: 10,
+        encodeCount: 10,
       });
 
       submit.mockReturnValueOnce(err(failure));
       expect(scenario.draw().ok).toBe(false);
       expect(scenario.renderer.inspect().bloom).toMatchObject({
         state: 'active',
-        uploadCount: 4,
-        bindGroupCount: 4,
-        encodeCount: 4,
+        uploadCount: 10,
+        bindGroupCount: 10,
+        encodeCount: 10,
       });
 
       expect(scenario.draw().ok).toBe(true);
       expect(scenario.renderer.inspect().bloom).toMatchObject({
-        uploadCount: 4,
-        bindGroupCount: 4,
-        encodeCount: 4,
+        uploadCount: 10,
+        bindGroupCount: 10,
+        encodeCount: 10,
       });
     } finally {
       submit.mockRestore();
@@ -1316,6 +1719,26 @@ describe('factory contract', () => {
     }
   });
 
+  it('uploads positive Bloom parameter changes without rebuilding the accepted bundle', async () => {
+    const scenario = await createBloomScenario();
+    try {
+      expect(scenario.draw().ok).toBe(true);
+      const first = scenario.renderer.inspect().bloom;
+      scenario.setBloomIntensity(0.35);
+      expect(scenario.draw().ok).toBe(true);
+      const updated = scenario.renderer.inspect().bloom;
+      expect(updated.state).toBe('active');
+      expect(updated.generation).toBe(first.generation);
+      expect(updated.resourceCount).toBe(first.resourceCount);
+      expect(updated.targetCount).toBe(first.targetCount);
+      expect(updated.targetBytes).toBe(first.targetBytes);
+      expect(updated.uploadCount).toBe(10);
+      expect(updated.passCount).toBe(10);
+    } finally {
+      await scenario.dispose();
+    }
+  });
+
   it('aborts a Bloom pass write failure without publishing partial receipts', async () => {
     const originalWriteBuffer = RhiNullQueue.prototype.writeBuffer;
     const createBuffer = vi.spyOn(RhiNullDevice.prototype, 'createBuffer');
@@ -1324,30 +1747,30 @@ describe('factory contract', () => {
     const scenario = await createBloomScenario();
     const failure = new RhiError({
       code: 'webgpu-runtime-error',
-      expected: 'Bloom blur-H params upload succeeds',
+      expected: 'Bloom downsample params upload succeeds',
       hint: 'repair the Bloom params buffer and retry the frame',
     });
     const errors: unknown[] = [];
     const unsubscribe = scenario.renderer.onError((error) => errors.push(error));
     try {
       expect(scenario.draw().ok).toBe(true);
-      const blurHParams = createBuffer.mock.calls.reduce<object | undefined>(
+      const downsampleParams = createBuffer.mock.calls.reduce<object | undefined>(
         (found, args, index) => {
-          if (found !== undefined || args[0].label !== 'bloom-blur-h-params-ubo') return found;
+          if (found !== undefined || args[0].label !== 'bloom-downsample-params-ubo') return found;
           const result = createBuffer.mock.results[index];
           if (result?.type !== 'return' || !result.value.ok) return undefined;
           return result.value.value as object;
         },
         undefined,
       );
-      expect(blurHParams).toBeDefined();
+      expect(downsampleParams).toBeDefined();
       const lkg = scenario.renderer.inspect().bloom;
-      expect(lkg).toMatchObject({ uploadCount: 4, bindGroupCount: 4, encodeCount: 4 });
+      expect(lkg).toMatchObject({ uploadCount: 10, bindGroupCount: 10, encodeCount: 10 });
       const submitCount = submit.mock.calls.length;
 
       let injected = false;
       writeBuffer.mockImplementation((buffer, ...args) => {
-        if (buffer === blurHParams && !injected) {
+        if (buffer === downsampleParams && !injected) {
           injected = true;
           return err(failure);
         }
@@ -1359,23 +1782,23 @@ describe('factory contract', () => {
       expect(errors).toHaveLength(1);
       expect(errors[0]).toMatchObject({
         code: 'pass-encode-failed',
-        detail: { passName: 'bloom-blur-h', cause: failure },
+        detail: { passName: 'bloom-downsample-0', cause: failure },
       });
       expect(scenario.renderer.inspect().bloom).toMatchObject({
         state: 'active',
         generation: lkg.generation,
-        uploadCount: 4,
-        bindGroupCount: 4,
-        encodeCount: 4,
+        uploadCount: 10,
+        bindGroupCount: 10,
+        encodeCount: 10,
       });
 
       writeBuffer.mockRestore();
       expect(scenario.draw().ok).toBe(true);
       expect(submit).toHaveBeenCalledTimes(submitCount + 1);
       expect(scenario.renderer.inspect().bloom).toMatchObject({
-        uploadCount: 4,
-        bindGroupCount: 4,
-        encodeCount: 4,
+        uploadCount: 10,
+        bindGroupCount: 10,
+        encodeCount: 10,
       });
     } finally {
       writeBuffer.mockRestore();
@@ -1388,18 +1811,17 @@ describe('factory contract', () => {
 
   const bloomConstructionFailures = [
     ['createSampler', 'bloom-sampler'],
-    ['createBindGroupLayout', 'bloom-bright-bgl'],
-    ['createBindGroupLayout', 'bloom-blur-bgl'],
+    ['createBindGroupLayout', 'bloom-downsample-bgl'],
+    ['createBindGroupLayout', 'bloom-upsample-bgl'],
     ['createBindGroupLayout', 'bloom-composite-bgl'],
-    ['createPipelineLayout', 'bloom-bright-pl'],
-    ['createPipelineLayout', 'bloom-blur-pl'],
+    ['createPipelineLayout', 'bloom-downsample-pl'],
+    ['createPipelineLayout', 'bloom-upsample-pl'],
     ['createPipelineLayout', 'bloom-composite-pl'],
-    ['createRenderPipeline', 'bloom-bright-pipeline'],
-    ['createRenderPipeline', 'bloom-blur-h-pipeline'],
+    ['createRenderPipeline', 'bloom-downsample-pipeline'],
+    ['createRenderPipeline', 'bloom-upsample-pipeline'],
     ['createRenderPipeline', 'bloom-composite-pipeline'],
-    ['createBuffer', 'bloom-bright-params-ubo'],
-    ['createBuffer', 'bloom-blur-h-params-ubo'],
-    ['createBuffer', 'bloom-blur-v-params-ubo'],
+    ['createBuffer', 'bloom-downsample-params-ubo'],
+    ['createBuffer', 'bloom-upsample-params-ubo'],
     ['createBuffer', 'bloom-composite-params-ubo'],
   ] as const;
 
@@ -1464,11 +1886,11 @@ describe('factory contract', () => {
       expect(scenario.renderer.inspect().bloom).toMatchObject({
         state: 'active',
         graphStatus: 'valid',
-        targetCount: 4,
-        passCount: 4,
-        uploadCount: 4,
-        bindGroupCount: 4,
-        encodeCount: 4,
+        targetCount: 10,
+        passCount: 10,
+        uploadCount: 10,
+        bindGroupCount: 10,
+        encodeCount: 10,
       });
     } finally {
       operation.mockRestore();
@@ -1485,7 +1907,7 @@ describe('factory contract', () => {
     const submit = vi.spyOn(RhiNullQueue.prototype, 'submit');
     const failure = new RhiError({
       code: 'webgpu-runtime-error',
-      expected: 'Bloom blur-V bind-group creation succeeds',
+      expected: 'Bloom upsample bind-group creation succeeds',
       hint: 'repair the Bloom bind group and retry the frame',
     });
     let injected = false;
@@ -1496,7 +1918,7 @@ describe('factory contract', () => {
       scenario.canvas.width = 96;
       scenario.canvas.height = 64;
       createBindGroup.mockImplementation(function (this: RhiNullDevice, descriptor) {
-        if (!injected && descriptor.label === 'bloom-blur-v-bg') {
+        if (!injected && descriptor.label === 'bloom-upsample-3-bg') {
           injected = true;
           return err(failure);
         }
@@ -1508,9 +1930,9 @@ describe('factory contract', () => {
       expect(scenario.renderer.inspect().bloom).toMatchObject({
         state: 'active',
         generation: lkg.generation,
-        uploadCount: 4,
-        bindGroupCount: 4,
-        encodeCount: 4,
+        uploadCount: 10,
+        bindGroupCount: 10,
+        encodeCount: 10,
       });
 
       createBindGroup.mockRestore();
@@ -1518,9 +1940,9 @@ describe('factory contract', () => {
       expect(submit).toHaveBeenCalledTimes(submitCount + 1);
       expect(scenario.renderer.inspect().bloom).toMatchObject({
         state: 'active',
-        uploadCount: 4,
-        bindGroupCount: 4,
-        encodeCount: 4,
+        uploadCount: 10,
+        bindGroupCount: 10,
+        encodeCount: 10,
       });
     } finally {
       createBindGroup.mockRestore();
@@ -1530,11 +1952,11 @@ describe('factory contract', () => {
   });
 
   it('aggregates active and fence-retiring Bloom bundles through Renderer.inspect', async () => {
+    const scenario = await createBloomScenario();
     const fence = deferred<undefined>();
     const onSubmittedWorkDone = vi
       .spyOn(RhiNullQueue.prototype, 'onSubmittedWorkDone')
       .mockReturnValue(fence.promise);
-    const scenario = await createBloomScenario();
     try {
       expect(scenario.draw().ok).toBe(true);
       scenario.setBloom('off');
@@ -1557,10 +1979,10 @@ describe('factory contract', () => {
       expect(overlap.state).toBe('active');
       expect(overlap.graphStatus).toBe('valid');
       expect(overlap.enabled).toBe(true);
-      expect(overlap.passCount).toBe(4);
-      expect(overlap.uploadCount).toBe(4);
-      expect(overlap.bindGroupCount).toBe(4);
-      expect(overlap.encodeCount).toBe(4);
+      expect(overlap.passCount).toBe(10);
+      expect(overlap.uploadCount).toBe(10);
+      expect(overlap.bindGroupCount).toBe(10);
+      expect(overlap.encodeCount).toBe(10);
       expect(overlap.resourceCount).toBeGreaterThan(retiring.resourceCount);
 
       fence.resolve(undefined);
@@ -1569,9 +1991,9 @@ describe('factory contract', () => {
       const settled = scenario.renderer.inspect().bloom;
       expect(settled.state).toBe('active');
       expect(settled.graphStatus).toBe('valid');
-      expect(settled.passCount).toBe(4);
-      expect(settled.targetCount).toBe(4);
-      expect(settled.targetBytes).toBe((64 * 64 + 3 * 32 * 32) * 8);
+      expect(settled.passCount).toBe(10);
+      expect(settled.targetCount).toBe(10);
+      expect(settled.targetBytes).toBe(54_560);
       expect(settled.resourceCount).toBeLessThan(overlap.resourceCount);
     } finally {
       onSubmittedWorkDone.mockRestore();
@@ -1580,11 +2002,11 @@ describe('factory contract', () => {
   });
 
   it('settles Bloom off to exact zero without re-enabling it', async () => {
+    const scenario = await createBloomScenario();
     const fence = deferred<undefined>();
     const onSubmittedWorkDone = vi
       .spyOn(RhiNullQueue.prototype, 'onSubmittedWorkDone')
       .mockReturnValue(fence.promise);
-    const scenario = await createBloomScenario();
     try {
       expect(scenario.draw().ok).toBe(true);
       scenario.setBloom('off');
@@ -1617,11 +2039,11 @@ describe('factory contract', () => {
   });
 
   it('reports one structured Bloom fence rejection and drains late-retiring resources', async () => {
+    const scenario = await createBloomScenario();
     const fence = deferred<undefined>();
     const onSubmittedWorkDone = vi
       .spyOn(RhiNullQueue.prototype, 'onSubmittedWorkDone')
       .mockReturnValue(fence.promise);
-    const scenario = await createBloomScenario();
     const errors: unknown[] = [];
     let errorSnapshot: ReturnType<typeof scenario.renderer.inspect> | undefined;
     const unsubscribe = scenario.renderer.onError((error) => {
@@ -1667,6 +2089,7 @@ describe('factory contract', () => {
   });
 
   it('keeps drained Bloom fence rejection callbacks inert', async () => {
+    const scenario = await createBloomScenario();
     const callbacks: Array<{
       readonly resolve: (value: undefined) => unknown;
       readonly reject: ((reason: unknown) => unknown) | undefined;
@@ -1681,7 +2104,6 @@ describe('factory contract', () => {
     const onSubmittedWorkDone = vi
       .spyOn(RhiNullQueue.prototype, 'onSubmittedWorkDone')
       .mockReturnValue(lateFence);
-    const scenario = await createBloomScenario();
     const errors: unknown[] = [];
     const unsubscribe = scenario.renderer.onError((error) => errors.push(error));
     try {
@@ -1797,7 +2219,7 @@ describe('factory contract', () => {
     const destroyCounts = new Map<object, number>();
     const failure = new RhiError({
       code: 'webgpu-runtime-error',
-      expected: 'Bloom blur-v params buffer construction succeeds',
+      expected: 'Bloom upsample params buffer construction succeeds',
       hint: 'repair the injected construction failure and retry the same frame',
     });
     try {
@@ -1807,7 +2229,7 @@ describe('factory contract', () => {
       const lkg = scenario.renderer.inspect().bloom;
       scenario.setBloom('on');
       createBuffer.mockImplementation(function (this: RhiNullDevice, descriptor) {
-        if (descriptor.label === 'bloom-blur-v-params-ubo') {
+        if (descriptor.label === 'bloom-upsample-params-ubo') {
           return err(failure);
         }
         const result = originalCreateBuffer.call(this, descriptor);
@@ -1832,12 +2254,12 @@ describe('factory contract', () => {
       expect(scenario.renderer.inspect().bloom.resourceCount).toBe(lkg.resourceCount);
       expect(scenario.renderer.inspect().bloom.passCount).toBe(0);
       const adoptedBeforeFailure = [...created.entries()].filter(
-        ([, label]) => label === 'bloom-bright-params-ubo' || label === 'bloom-blur-h-params-ubo',
+        ([, label]) => label === 'bloom-downsample-params-ubo',
       );
-      expect(adoptedBeforeFailure).toHaveLength(2);
+      expect(adoptedBeforeFailure).toHaveLength(1);
       expect(adoptedBeforeFailure.every(([handle]) => destroyCounts.get(handle) === 1)).toBe(true);
       expect(
-        [...created.values()].filter((label) => label === 'bloom-blur-v-params-ubo'),
+        [...created.values()].filter((label) => label === 'bloom-upsample-params-ubo'),
       ).toHaveLength(0);
       createBuffer.mockRestore();
       destroyBuffer.mockRestore();
@@ -1902,6 +2324,7 @@ describe('factory contract', () => {
           near: 0.1,
           far: 100,
           antialias: ANTIALIAS_NONE,
+          tonemap: TONEMAP_ACES_FILMIC,
           bloom: BLOOM_ENABLED,
         },
       },
@@ -1957,10 +2380,9 @@ describe('factory contract', () => {
         staleLossEvents: 0,
       });
       expect(renderer.inspect().recovery.rehydratedRoots).toBeGreaterThan(0);
-      // Recovery publishes only after the retained CPU/LKG frame has prepared
-      // the replacement graph and visible residency. The first post-recovery
-      // draw therefore starts with graph accessors and Standard inspection.
-      expect(renderer.inspect().perFramePassNames.length).toBeGreaterThan(0);
+      // Publication retires the graph bound to the previous canvas context;
+      // the first recovered draw acquires the replacement presentation target.
+      expect(renderer.inspect().perFramePassNames).toHaveLength(0);
       expect(renderer.inspect().standardLighting).toBeDefined();
       expect(world.update().ok).toBe(true);
       expect(renderer.draw(input()).ok).toBe(true);
@@ -1977,6 +2399,96 @@ describe('factory contract', () => {
     }
   });
 
+  it('does not publish Bloom resources for an intensity-zero recovery candidate', async () => {
+    const adapter = new RhiNullAdapter();
+    const lost = deferred<{ readonly reason: 'unknown'; readonly message: string }>();
+    const firstDevice = (await adapter.requestDevice()).unwrap();
+    const replacementDevice = (await adapter.requestDevice()).unwrap();
+    const lostProxy = new Proxy(firstDevice, {
+      get(target, property) {
+        if (property === 'lost') return lost.promise;
+        const value = Reflect.get(target, property, target);
+        return typeof value === 'function' ? value.bind(target) : value;
+      },
+    });
+    let requestCount = 0;
+    const recoverableRhi = {
+      ...rhi,
+      requestAdapter: async () =>
+        ok({
+          features: adapter.features,
+          limits: adapter.limits,
+          requestDevice: async () => {
+            requestCount += 1;
+            return requestCount === 1 ? ok(lostProxy) : ok(replacementDevice);
+          },
+        } as never),
+    } as never;
+    const renderer = await constructRenderer(
+      { width: 64, height: 64, getContext: () => null },
+      { rhi: recoverableRhi },
+      { shaderManifestUrl: renderLifecycleManifestUrl() },
+    );
+    const world = new World();
+    const attached = renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+    registerPropagateTransforms(world);
+    world.spawn(
+      { component: Transform, data: { pos: [0, 0, 4] } },
+      {
+        component: LocalCamera,
+        data: {
+          fov: 1,
+          aspect: 1,
+          near: 0.1,
+          far: 100,
+          antialias: ANTIALIAS_NONE,
+          tonemap: TONEMAP_ACES_FILMIC,
+          bloom: BLOOM_ENABLED,
+          bloomIntensity: 0,
+        },
+      },
+    );
+    const input = () => ({
+      leases: [attached.value],
+      camera: { lease: attached.value },
+      environment: { lease: attached.value },
+    });
+    const assertZero = (): void => {
+      expect(renderer.inspect().bloom).toMatchObject({
+        graphStatus: 'empty',
+        enabled: false,
+        targetCount: 0,
+        targetBytes: 0,
+        resourceCount: 0,
+        passCount: 0,
+        encodeCount: 0,
+        bindGroupCount: 0,
+        uploadCount: 0,
+        residentChildBytes: 0,
+        state: 'off',
+      });
+    };
+    try {
+      expect((await renderer.initialization).ok).toBe(true);
+      expect(world.update().ok).toBe(true);
+      expect(renderer.draw(input()).ok).toBe(true);
+      assertZero();
+      lost.reject({ reason: 'unknown', message: 'forced intensity-zero recovery loss' });
+      await Promise.resolve();
+      await Promise.resolve();
+      expect(renderer.health().reason).toBe('device-lost');
+      expect((await renderer.recover()).ok).toBe(true);
+      assertZero();
+      expect(world.update().ok).toBe(true);
+      expect(renderer.draw(input()).ok).toBe(true);
+      assertZero();
+    } finally {
+      await renderer.dispose();
+    }
+  });
+
   it('abandons a post-process recovery candidate before promotion and retries once', async () => {
     const adapter = new RhiNullAdapter();
     const lost = deferred<{ readonly reason: 'unknown'; readonly message: string }>();
@@ -2092,6 +2604,7 @@ describe('factory contract', () => {
             near: 0.1,
             far: 100,
             antialias: ANTIALIAS_NONE,
+            tonemap: TONEMAP_ACES_FILMIC,
             bloom: BLOOM_DISABLED,
           },
         },