@forgeax/engine-render 0.1.32 → 0.1.33

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

@@ -83,6 +83,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,10 +107,61 @@ 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(),
+  };
 }
 
 describe('factory contract', () => {
@@ -1086,14 +1141,111 @@ 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('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 () => {
     const created = new Map<object, string>();
     const destroyed = new Set<object>();
@@ -1230,12 +1382,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 +1418,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 +1442,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 +1468,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 +1496,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 +1531,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 +1560,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 +1635,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 +1656,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 +1667,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 +1679,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 +1689,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();
@@ -1557,10 +1728,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 +1740,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();
@@ -1797,7 +1968,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 +1978,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 +2003,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 +2073,7 @@ describe('factory contract', () => {
           near: 0.1,
           far: 100,
           antialias: ANTIALIAS_NONE,
+          tonemap: TONEMAP_ACES_FILMIC,
           bloom: BLOOM_ENABLED,
         },
       },
@@ -1977,6 +2149,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 +2354,7 @@ describe('factory contract', () => {
             near: 0.1,
             far: 100,
             antialias: ANTIALIAS_NONE,
+            tonemap: TONEMAP_ACES_FILMIC,
             bloom: BLOOM_DISABLED,
           },
         },

package/src/__tests__/frame-camera-selection.unit.test.ts

@@ -1,6 +1,6 @@
 import { World } from '@forgeax/engine-ecs';
 import { Transform } from '@forgeax/engine-scene';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { Atmosphere, Camera, DirectionalLight } from '../components';
 import {
   extractFrame,
@@ -89,6 +89,44 @@ describe('FrameCamera entity selection', () => {
 });
 
 describe('Atmosphere sun extraction', () => {
+  it('routes a missing sun through World, then retries after ownership is fixed', () => {
+    const world = new World();
+    world.spawn({ component: Atmosphere, data: {} }).unwrap();
+    spawnCamera(world, 1);
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    try {
+      expect(() =>
+        extractFrame(world, prepareExtractContext(world, { renderables: 'none' })),
+      ).toThrow(
+        expect.objectContaining({ code: 'sun-cardinality', detail: { field: 'sun', value: 0 } }),
+      );
+      const firstRouted = consoleError.mock.calls[0]?.[1] as
+        | { code?: string; detail?: { value?: number } }
+        | undefined;
+      expect(consoleError.mock.calls[0]?.[0]).toBe(
+        '[RenderSystem.extract (environment-selection)]',
+      );
+      expect(firstRouted?.code).toBe('sun-cardinality');
+      expect(firstRouted?.detail?.value).toBe(0);
+
+      // This is the direct extraction boundary. App.onError owns frame-loop
+      // Result failures and renderer events; World routes this internal
+      // producer error to its documented console boundary.
+
+      const firstSun = world
+        .spawn({
+          component: DirectionalLight,
+          data: { direction: [0, -0.25, 1], color: [1, 1, 1], intensity: 1 },
+        })
+        .unwrap();
+      const recovered = extractFrame(world, prepareExtractContext(world, { renderables: 'none' }));
+      expect(recovered.lights.directional?.entity).toBe(firstSun);
+      expect(consoleError).toHaveBeenCalledTimes(1);
+    } finally {
+      consoleError.mockRestore();
+    }
+  });
+
   it('keeps DirectionalLight intensity out of SunCandidate color', () => {
     const world = new World();
     world.spawn({ component: Atmosphere, data: {} }).unwrap();

package/src/__tests__/frame-plan-contract.unit.test.ts

@@ -13,6 +13,8 @@ const atmosphereParameters: AtmosphereParameters = {
   mieCoefficient: 0.005,
   mieDirectionalG: 0.8,
   sunAngularRadius: 0.004675,
+  circumsolarStrength: 1,
+  circumsolarWidth: 1,
 };
 
 function unwrapFrame(result: ReturnType<typeof selectEnvironmentFrame>): EnvironmentFrame {

package/src/__tests__/gpu-driven-indirect-raster-evidence.ts

@@ -110,7 +110,8 @@ function camera(): CameraSnapshot {
     bloom: 'off',
     bloomThreshold: 1,
     bloomIntensity: 1,
-    bloomBlurRadius: 4,
+    bloomSoftKnee: 0.5,
+    bloomScatter: 0.7,
     clearColor: [0, 0, 0, 0],
   };
 }