@forgeax/engine-render 0.1.28 → 0.1.30

package/src/__tests__/device-scope-lifecycle.unit.test.ts

@@ -25,6 +25,24 @@ function spec(
 }
 
 describe('DeviceScope lifecycle transaction', () => {
+  it('does not retain a late LUT resource after recovery disposal', async () => {
+    const scope = DeviceScope.create(40, 'renderer');
+    let resolveCreate: ((value: { id: string }) => void) | undefined;
+    const transaction = new LifecycleTransaction(scope);
+    transaction.add({
+      kind: 'texture',
+      create: () => new Promise<{ id: string }>((resolve) => (resolveCreate = resolve)),
+      cleanup: () => undefined,
+    });
+    const pending = transaction.commit();
+    scope.dispose();
+    resolveCreate?.({ id: 'late-lut' });
+    const result = await pending;
+    expect(result.ok).toBe(false);
+    expect(scope.resourceDelta()).toBe(0);
+    expect(scope.state).toBe('disposed');
+  });
+
   it('rolls back the first N-1 resources in reverse order and keeps the primary error', async () => {
     const scope = DeviceScope.create(7, 'renderer');
     const order: string[] = [];

package/src/__tests__/device-scope-stale-matrix.unit.test.ts

@@ -40,3 +40,21 @@ describe('DeviceScope stale resource matrix', () => {
     expect(abandoned.isAlive()).toBe(false);
   });
 });
+
+describe('auto exposure generation fence', () => {
+  it('rejects a candidate prepared for a retired device generation', async () => {
+    const { createAutoExposureState, prepareAutoExposureCandidate } = await import(
+      '../pipeline/standard-output/auto-exposure/state'
+    );
+    const state = createAutoExposureState({ fallback: 1, targetGeneration: 4, deviceEpoch: 2 });
+    if (!state.ok) throw state.error;
+    expect(
+      prepareAutoExposureCandidate(state.value, {
+        ev: 1,
+        generation: 4,
+        deviceEpoch: 3,
+        frameId: 1,
+      }),
+    ).toMatchObject({ ok: false, error: { code: 'auto-exposure-stale-generation' } });
+  });
+});

package/src/__tests__/docs-gate-green.unit.test.ts

@@ -16,10 +16,10 @@ describe('M4 material and Instances documentation contract', () => {
       '`ready`, `pending`, `failed`, or `last-known-good`',
       'nearest structured preparation',
       'does not keep a second readiness ledger',
-      '`Instances` remains author data',
-      'renderer derives a CPU union bound',
+      '`Instances` is a lightweight ECS association',
+      'derives CPU union bounds',
       'conservative no-cull result',
-      'GPU path keeps the mesh-local AABB',
+      'mesh AABB',
     ]) {
       expect(renderReadme).toContain(token);
     }

package/src/__tests__/dynamic-geometry-batch.unit.test.ts

@@ -0,0 +1,157 @@
+import { World } from '@forgeax/engine-ecs';
+import { rhi } from '@forgeax/engine-rhi-null';
+import { Transform } from '@forgeax/engine-scene';
+import type { MeshAsset } from '@forgeax/engine-types';
+import { describe, expect, it, vi } from 'vitest';
+import { createDynamicGeometryHost } from '../assembly/dynamic-geometry-host';
+import { MeshFilter } from '../components/mesh-filter';
+import { MeshRenderer } from '../components/mesh-renderer';
+import { GpuResidencyCache } from '../device/gpu-residency';
+import { createDynamicGeometryLifecycle } from '../dynamic-geometry';
+
+function mesh(): MeshAsset {
+  return {
+    kind: 'mesh',
+    vertices: new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]),
+    indices: new Uint16Array([0, 1, 2]),
+    attributes: { position: new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]) },
+    aabb: new Float32Array([0, 0, 0, 1, 1, 0]),
+    submeshes: [
+      { indexOffset: 0, indexCount: 3, vertexCount: 3, topology: 'triangle-list', materialSlot: 0 },
+    ],
+    materialSlots: [{ slotName: 'default' }],
+  };
+}
+
+async function fixture() {
+  const world = new World();
+  const device = (await (await rhi.requestAdapter()).unwrap().requestDevice()).unwrap();
+  const store = new GpuResidencyCache();
+  store.configureGpuDevice(
+    device,
+    undefined,
+    () => {
+      throw new Error('unused cubemap');
+    },
+    device.caps,
+  );
+  const topologyChanged = vi.fn();
+  const lifecycle = createDynamicGeometryLifecycle();
+  const host = createDynamicGeometryHost({
+    lifecycle,
+    attachedWorlds: new Set([world]),
+    getGpuStore: () => store,
+    currentGeneration: () => 1,
+    isConsumedByRenderFrame: () => true,
+    onTopologyChanged: topologyChanged,
+  });
+  const entities = Array.from({ length: 2 }, () =>
+    world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: MeshFilter, data: { assetHandle: world.allocSharedRef('MeshAsset', mesh()) } },
+        { component: MeshRenderer, data: { materials: [] } },
+      )
+      .unwrap(),
+  );
+  const prepare = (revision: number) =>
+    entities.map((entity) => {
+      const source = mesh();
+      return host
+        .prepareDynamicGeometry({
+          world,
+          entity,
+          mesh: source,
+          meshHandle: world.allocSharedRef('MeshAsset', source),
+          revision,
+        })
+        .unwrap();
+    });
+  const handles = () =>
+    entities.map((entity) => world.get(entity, MeshFilter).unwrap().assetHandle);
+  return { world, store, host, lifecycle, entities, prepare, handles, topologyChanged };
+}
+
+describe('dynamic geometry batch admission', () => {
+  it('admits both meshes in one ordering and publishes both receipts', async () => {
+    const f = await fixture();
+    const prepared = f.prepare(1);
+    const old = f.handles();
+    const accepted = f.host
+      .acceptDynamicGeometryCandidates(prepared, { world: f.world, fixedStep: 0 })
+      .unwrap();
+    expect(f.handles()).not.toEqual(old);
+    expect(accepted.map((candidate) => candidate.state)).toEqual(['accepted', 'accepted']);
+    expect(f.topologyChanged).toHaveBeenCalledTimes(1);
+    const receipts = f.host.publishDynamicGeometry({ frameId: 1, deviceGeneration: 1 });
+    expect(receipts.map((receipt) => receipt.candidateId).sort()).toEqual(
+      prepared.map((candidate) => candidate.candidateId).sort(),
+    );
+    f.store.destroyAll();
+  });
+
+  it('retains prior unpublished candidates when the second ECS swap fails', async () => {
+    const f = await fixture();
+    const prior = f
+      .prepare(1)
+      .map((candidate) =>
+        f.host.acceptDynamicGeometry(candidate, { world: f.world, fixedStep: 0 }).unwrap(),
+      );
+    const old = f.handles();
+    const next = f.prepare(2);
+    const set = f.world.set.bind(f.world);
+    // Use the ECS's own missing-component failure without changing either live mesh.
+    const absent = f.world.spawn({ component: Transform, data: {} }).unwrap();
+    const refused = set(absent, MeshFilter, { assetHandle: old[0] });
+    expect(refused.ok).toBe(false);
+    vi.spyOn(f.world, 'set').mockImplementation((entity, component, data) =>
+      entity === f.entities[1] && component === MeshFilter ? refused : set(entity, component, data),
+    );
+    expect(f.host.acceptDynamicGeometryCandidates(next, { world: f.world, fixedStep: 0 }).ok).toBe(
+      false,
+    );
+    expect(f.handles()).toEqual(old);
+    const receipts = f.host.publishDynamicGeometry({ frameId: 1, deviceGeneration: 1 });
+    expect(receipts.map((receipt) => receipt.candidateId).sort()).toEqual(
+      prior.map((candidate) => candidate.candidateId).sort(),
+    );
+    vi.restoreAllMocks();
+    f.store.destroyAll();
+  });
+
+  it('throws when a failed group cannot restore its first ECS binding', async () => {
+    const f = await fixture();
+    const old = f.handles();
+    const next = f.prepare(1);
+    const set = f.world.set.bind(f.world);
+    const absent = f.world.spawn({ component: Transform, data: {} }).unwrap();
+    const refused = set(absent, MeshFilter, { assetHandle: old[0] });
+    let writes = 0;
+    vi.spyOn(f.world, 'set').mockImplementation((entity, component, data) => {
+      if (component === MeshFilter && ++writes >= 2) return refused;
+      return set(entity, component, data);
+    });
+    expect(() =>
+      f.host.acceptDynamicGeometryCandidates(next, { world: f.world, fixedStep: 0 }),
+    ).toThrow('restores every previous ECS binding');
+    vi.restoreAllMocks();
+    f.store.destroyAll();
+  });
+
+  it('rejects duplicate entities before changing the visible meshes', async () => {
+    const f = await fixture();
+    const candidates = f.prepare(1);
+    const first = candidates[0];
+    if (first === undefined) throw new Error('fixture requires a prepared candidate');
+    const old = f.handles();
+    expect(
+      f.host.acceptDynamicGeometryCandidates([first, first], {
+        world: f.world,
+        fixedStep: 0,
+      }).ok,
+    ).toBe(false);
+    expect(f.handles()).toEqual(old);
+    expect(f.topologyChanged).not.toHaveBeenCalled();
+    f.store.destroyAll();
+  });
+});

package/src/__tests__/dynamic-geometry.unit.test.ts

@@ -1,3 +1,4 @@
+import { createMeshBuilder } from '@forgeax/engine-geometry';
 import type { MeshAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import { createDynamicGeometryLifecycle } from '../dynamic-geometry';
@@ -15,6 +16,41 @@ const mesh = (): MeshAsset => ({
 });
 
 describe('standard dynamic geometry lifecycle', () => {
+  it('accepts a MeshBuilder interleaved color buffer with four vertices', () => {
+    const source = createMeshBuilder({
+      attributes: {
+        position: new Float32Array([0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0]),
+        color: new Float32Array(16).fill(1),
+      },
+      indices: new Uint16Array([0, 1, 2, 0, 2, 3]),
+    })
+      .build()
+      .unwrap();
+    expect(source.vertices.length % 3).not.toBe(0);
+    const lifecycle = createDynamicGeometryLifecycle();
+    expect(lifecycle.prepare({ world: {}, mesh: source, revision: 1 }, 1).ok).toBe(true);
+  });
+
+  it('validates referenced material slots rather than requiring one slot per submesh', () => {
+    const source = mesh();
+    const shared = { ...source, submeshes: [...source.submeshes, ...source.submeshes] };
+    const lifecycle = createDynamicGeometryLifecycle();
+    expect(lifecycle.prepare({ world: {}, mesh: shared, revision: 1 }, 1).ok).toBe(true);
+    expect(
+      lifecycle.prepare(
+        {
+          world: {},
+          mesh: {
+            ...source,
+            submeshes: source.submeshes.map((submesh) => ({ ...submesh, materialSlot: 2 })),
+          },
+          revision: 1,
+        },
+        1,
+      ).ok,
+    ).toBe(false);
+  });
+
   it('copies a MeshAsset and publishes only after a matching frame generation', () => {
     const lifecycle = createDynamicGeometryLifecycle();
     const world = {};

package/src/__tests__/dynamic-resolution-plugin.integration.test.ts

@@ -0,0 +1,81 @@
+import { createWorldContext, World } from '@forgeax/engine-ecs';
+import { scenePlugin, Transform } from '@forgeax/engine-scene';
+import { describe, expect, it } from 'vitest';
+import { extractCameraSnapshots } from '../extract/camera';
+import { ANTIALIAS_NONE, ANTIALIAS_TAA, Camera, DynamicResolution, MotionBlur } from '../index';
+import { renderComponentsPlugin } from '../plugin';
+import { extractFrames } from '../render-system-extract';
+
+describe('DynamicResolution render component registration', () => {
+  it('uses the existing render plugin for add, remove, and extraction retries', async () => {
+    const world = new World();
+    const context = await createWorldContext(world, [renderComponentsPlugin(), scenePlugin()]);
+    const entries = [...world.components.entries()].map(([name]) => name);
+    expect(entries).toContain('DynamicResolution');
+
+    const entity = world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: Camera, data: { antialias: ANTIALIAS_TAA } },
+        { component: DynamicResolution, data: { minScale: 0.5, maxScale: 0.5 } },
+      )
+      .unwrap();
+    world.update(1 / 60).unwrap();
+    expect(extractCameraSnapshots(world)[0]?.dynamicResolution).toMatchObject({
+      minScale: 0.5,
+      maxScale: 0.5,
+    });
+    expect(extractCameraSnapshots(world)[0]?.dynamicResolution?.targetGpuMs).toBeCloseTo(16.67);
+
+    world.removeComponent(entity, DynamicResolution).unwrap();
+    expect(extractCameraSnapshots(world)[0]?.dynamicResolution).toBeUndefined();
+    expect(extractFrames([world], 0).cameras[0]?.dynamicResolution).toBeUndefined();
+    world
+      .addComponent(entity, {
+        component: DynamicResolution,
+        data: { minScale: 0.75, maxScale: 0.75 },
+      })
+      .unwrap();
+    expect(extractCameraSnapshots(world)[0]?.dynamicResolution).toMatchObject({
+      minScale: 0.75,
+      maxScale: 0.75,
+    });
+    expect(extractCameraSnapshots(world)[0]?.dynamicResolution?.targetGpuMs).toBeCloseTo(16.67);
+
+    const nonTaa = world.set(entity, Camera, { antialias: ANTIALIAS_NONE });
+    expect(nonTaa.ok).toBe(true);
+    expect(() => extractCameraSnapshots(world)).toThrowError(
+      expect.objectContaining({ code: 'dynamic-resolution-requires-taa' }),
+    );
+
+    await context.fiber.dispose();
+  });
+
+  it('registers MotionBlur for the shared camera extraction query', async () => {
+    const world = new World();
+    const context = await createWorldContext(world, [renderComponentsPlugin(), scenePlugin()]);
+    expect([...world.components.entries()].map(([name]) => name)).toContain('MotionBlur');
+
+    world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: Camera, data: { antialias: ANTIALIAS_TAA } },
+        { component: MotionBlur, data: { shutterAngle: 120, maxRadiusPixels: 12, sampleCount: 6 } },
+      )
+      .unwrap();
+    world.update(1 / 60).unwrap();
+
+    expect(extractCameraSnapshots(world)[0]?.motionBlur).toEqual({
+      shutterAngle: 120,
+      maxRadiusPixels: 12,
+      sampleCount: 6,
+    });
+    expect(extractFrames([world], 0).cameras[0]?.motionBlur).toEqual({
+      shutterAngle: 120,
+      maxRadiusPixels: 12,
+      sampleCount: 6,
+    });
+
+    await context.fiber.dispose();
+  });
+});

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

@@ -5,7 +5,7 @@ import { HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
 import { createProfiler } from '@forgeax/engine-profiler';
 import { DEFAULT_STANDARD_PROFILE } from '@forgeax/engine-render';
-import { RhiError, type ShaderModule } from '@forgeax/engine-rhi';
+import { RhiError, type RhiWebgpuRuntimeCause, type ShaderModule } from '@forgeax/engine-rhi';
 import {
   RhiNullAdapter,
   RhiNullCommandEncoder,
@@ -18,7 +18,15 @@ import { err, ok } from '@forgeax/engine-types';
 import { describe, expect, it, vi } from 'vitest';
 import type { RhiBackendPack } from '../assembly/backend-contract';
 import { createRenderer as constructRenderer } from '../assembly/factory';
-import { DirectionalLight, MeshFilter, MeshRenderer, PointLight, SpotLight } from '../components';
+import {
+  DirectionalLight,
+  DynamicResolution,
+  MeshFilter,
+  MeshRenderer,
+  MotionBlur,
+  PointLight,
+  SpotLight,
+} from '../components';
 import {
   ANTIALIAS_NONE,
   ANTIALIAS_TAA,
@@ -27,6 +35,7 @@ import {
   Camera as LocalCamera,
   TONEMAP_ACES_FILMIC,
 } from '../components/camera';
+import { TemporalFrameSubmitError } from '../errors/render';
 import type { RenderFeature } from '../features/types';
 import { renderLifecycleManifestUrl } from './shader-manifest-fixture';
 
@@ -144,6 +153,54 @@ describe('factory contract', () => {
     expect(profiler.phaseCatalog.render).toEqual([]);
   });
 
+  it('preserves a PipelineSpecError and its structured GPU cause during initialization', async () => {
+    const original = RhiNullDevice.prototype.createRenderPipeline;
+    const failure = new RhiError({
+      code: 'webgpu-runtime-error',
+      expected: 'the GPU accepts the pre-warmed render pipeline descriptor',
+      hint: 'inspect the backend gpuMessage for the rejected descriptor',
+    });
+    let injected = false;
+    const operation = vi.spyOn(RhiNullDevice.prototype, 'createRenderPipeline');
+    operation.mockImplementation(function (this: RhiNullDevice, ...args: never[]) {
+      if (!injected) {
+        injected = true;
+        return err(failure) as never;
+      }
+      return Reflect.apply(original as (...input: never[]) => unknown, this, args) as never;
+    } as never);
+
+    try {
+      const renderer = await constructRenderer(
+        { getContext: () => null },
+        { rhi },
+        { shaderManifestUrl: renderLifecycleManifestUrl() },
+      );
+      const ready = await renderer.initialization;
+      expect(injected).toBe(true);
+      expect(ready.ok).toBe(false);
+      if (ready.ok) return;
+      expect(ready.error).toMatchObject({
+        code: 'webgpu-runtime-error',
+        detail: {
+          error: {
+            code: 'pipeline-build-failed',
+            detail: { cause: failure },
+          },
+        },
+      });
+      await renderer.dispose();
+    } finally {
+      operation.mockRestore();
+    }
+  });
+
+  it('keeps named temporal causes assignable without flattening their detail', () => {
+    const temporal = new TemporalFrameSubmitError('queue-submit-failed');
+    const cause: RhiWebgpuRuntimeCause = temporal;
+    expect(cause.detail).toEqual({ reason: 'queue-submit-failed' });
+  });
+
   it('forwards timing admission to the backend device request', async () => {
     const adapter = new RhiNullAdapter();
     const device = (await adapter.requestDevice()).unwrap();
@@ -178,6 +235,7 @@ describe('factory contract', () => {
       { rhi },
       { shaderManifestUrl: manifestUrl() },
     );
+    expect((await renderer.initialization).ok).toBe(true);
     const world = new World();
     const attached = renderer.attach(world);
     expect(attached.ok).toBe(true);
@@ -228,11 +286,13 @@ describe('factory contract', () => {
       // Before the first draw there is no committed graph from which to
       // claim an output transform or an intermediate target.  Inspection is
       // intentionally conservative instead of projecting profile defaults.
-      displayEncoded: false,
-      surfaceStorage: expect.any(String),
-      surfaceDisplay: expect.any(String),
-      endpoint: 'surface.storage.raw',
-      capability: 'unavailable',
+      output: {
+        displayEncoded: false,
+        surfaceStorage: expect.any(String),
+        surfaceDisplay: expect.any(String),
+        endpoint: 'surface.storage.raw',
+        capability: 'unavailable',
+      },
       observation: {
         observationId: expect.any(String),
         frameId: expect.any(Number),
@@ -250,6 +310,7 @@ describe('factory contract', () => {
       { rhi },
       { shaderManifestUrl: manifestUrl() },
     );
+    expect((await renderer.initialization).ok).toBe(true);
     const target = renderer.createRenderTarget({
       shape: '2d',
       width: 17,
@@ -312,6 +373,7 @@ describe('factory contract', () => {
       { rhi, features: [feature] },
       { shaderManifestUrl: manifestUrl() },
     );
+    expect((await renderer.initialization).ok).toBe(true);
     const world = new World();
     const attached = renderer.attach(world);
     expect(attached.ok).toBe(true);
@@ -474,7 +536,11 @@ describe('factory contract', () => {
     );
     expect((await renderer.initialization).ok).toBe(true);
     const errors: string[] = [];
-    const unsubscribe = renderer.onError((error) => errors.push(error.code));
+    const errorDetails: unknown[] = [];
+    const unsubscribe = renderer.onError((error) => {
+      errors.push(error.code);
+      errorDetails.push(error);
+    });
     const world = new World();
     const attached = renderer.attach(world);
     expect(attached.ok).toBe(true);
@@ -516,7 +582,7 @@ describe('factory contract', () => {
       camera: { lease: attached.value },
       environment: { lease: attached.value },
     });
-    expect(frame.ok).toBe(true);
+    expect(frame.ok, JSON.stringify(errorDetails)).toBe(true);
     expect(renderer.inspect().standardLighting).toMatchObject({
       producer: 'none',
       requested: 0,
@@ -611,6 +677,7 @@ describe('factory contract', () => {
       { rhi },
       { shaderManifestUrl: manifest },
     );
+    expect((await renderer.initialization).ok).toBe(true);
     expect(renderer.releaseSurface().ok).toBe(true);
     expect(renderer.releaseSurface().ok).toBe(true);
     expect(renderer.draw([], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(false);
@@ -872,6 +939,161 @@ describe('factory contract', () => {
     expect((await renderer.dispose()).ok).toBe(true);
   });
 
+  it('rebuilds the TAA graph when DynamicResolution is removed', 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);
+    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: DynamicResolution,
+          data: { targetGpuMs: 16.67, minScale: 0.5, maxScale: 0.5 },
+        },
+      )
+      .unwrap();
+    const frameInput = () => ({
+      leases: [attached.value],
+      camera: { lease: attached.value },
+      environment: { lease: attached.value },
+    });
+    expect(world.update().ok).toBe(true);
+    expect(renderer.draw(frameInput()).ok).toBe(true);
+    const dynamicInspection = renderer.inspect();
+    expect(dynamicInspection.perFramePassNames).toContain('standard-scene-coverage');
+    expect(dynamicInspection.temporalTarget).toMatchObject({
+      descriptor: { width: 32, height: 32 },
+    });
+    const dynamicGeneration = dynamicInspection.recoveryEvidence.graph.generation;
+
+    expect(world.removeComponent(camera, DynamicResolution).ok).toBe(true);
+    expect(world.update().ok).toBe(true);
+    expect(renderer.draw(frameInput()).ok).toBe(true);
+    const surfaceInspection = renderer.inspect();
+    expect(surfaceInspection.perFramePassNames).not.toContain('standard-scene-coverage');
+    expect(surfaceInspection.temporalTarget).toMatchObject({
+      descriptor: { width: 64, height: 64 },
+    });
+    expect(surfaceInspection.recoveryEvidence.graph.generation).toBeGreaterThan(dynamicGeneration);
+    await renderer.dispose();
+  });
+
+  it('restores the surface graph after toggling DynamicResolution on and off', 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);
+    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 },
+        },
+      )
+      .unwrap();
+    const frameInput = () => ({
+      leases: [attached.value],
+      camera: { lease: attached.value },
+      environment: { lease: attached.value },
+    });
+    expect(world.update().ok).toBe(true);
+    expect(renderer.draw(frameInput()).ok).toBe(true);
+    expect(renderer.inspect().perFramePassNames).not.toContain('standard-scene-coverage');
+
+    expect(
+      world.addComponent(camera, {
+        component: DynamicResolution,
+        data: { targetGpuMs: 16.67, minScale: 0.5, maxScale: 0.5 },
+      }).ok,
+    ).toBe(true);
+    expect(world.update().ok).toBe(true);
+    expect(renderer.draw(frameInput()).ok).toBe(true);
+    const dynamic = renderer.inspect();
+    expect(dynamic.perFramePassNames).toContain('standard-scene-coverage');
+    expect(dynamic.temporalTarget).toMatchObject({ descriptor: { width: 32, height: 32 } });
+
+    expect(world.removeComponent(camera, DynamicResolution).ok).toBe(true);
+    expect(world.update().ok).toBe(true);
+    expect(renderer.draw(frameInput()).ok).toBe(true);
+    const surface = renderer.inspect();
+    expect(surface.perFramePassNames).not.toContain('standard-scene-coverage');
+    expect(surface.temporalTarget).toMatchObject({ descriptor: { width: 64, height: 64 } });
+    await renderer.dispose();
+  });
+
+  it('rebuilds the TAA graph when MotionBlur is added', 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 },
+        },
+      )
+      .unwrap();
+    const frameInput = () => ({
+      leases: [attached.value],
+      camera: { lease: attached.value },
+      environment: { lease: attached.value },
+    });
+    expect(world.update().ok).toBe(true);
+    expect(renderer.draw(frameInput()).ok).toBe(true);
+    expect(renderer.inspect().perFramePassNames).not.toContain('motion-blur');
+
+    expect(
+      world.addComponent(camera, {
+        component: MotionBlur,
+        data: { shutterAngle: 180, maxRadiusPixels: 8, sampleCount: 4 },
+      }).ok,
+    ).toBe(true);
+    expect(world.update().ok).toBe(true);
+    const motionDraw = renderer.draw(frameInput());
+    if (!motionDraw.ok) {
+      throw new Error(JSON.stringify({ error: motionDraw.error, events: errors }));
+    }
+    const inspection = renderer.inspect();
+    expect(inspection.perFramePassNames).toContain('motion-blur');
+    expect(inspection.motionBlur).toMatchObject({
+      enabled: true,
+      status: 'active',
+      temporalDemand: 'scene-data-temporal-v1',
+    });
+    await renderer.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>();