@forgeax/engine-render 0.1.33 → 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,
@@ -164,7 +165,75 @@ async function createMotionBlurScenario() {
   };
 }
 
+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');
@@ -199,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() },
     );
@@ -227,7 +296,7 @@ describe('factory contract', () => {
 
     try {
       const renderer = await constructRenderer(
-        { getContext: () => null },
+        { width: 64, height: 64, getContext: () => null },
         { rhi },
         { shaderManifestUrl: renderLifecycleManifestUrl() },
       );
@@ -273,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 },
@@ -286,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() },
     );
@@ -303,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'] });
@@ -316,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() },
     );
@@ -332,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() },
     );
@@ -361,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() },
     );
@@ -390,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'],
@@ -439,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;
@@ -679,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() },
     );
@@ -695,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() },
     );
@@ -717,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),
@@ -728,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 },
     );
@@ -744,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,
@@ -773,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;
@@ -836,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();
@@ -844,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();
@@ -865,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;
@@ -914,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);
       },
     };
@@ -953,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;
@@ -982,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);
@@ -1165,6 +1336,86 @@ describe('factory contract', () => {
     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 },
@@ -1320,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-'),
     );
@@ -1701,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');
@@ -1751,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');
@@ -1788,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) => {
@@ -1838,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;
@@ -1852,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 {
@@ -2129,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);