@forgeax/engine-render 0.1.4 → 0.1.6

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

@@ -1,10 +1,11 @@
 import { World } from '@forgeax/engine-ecs';
 import { createProfiler } from '@forgeax/engine-profiler';
-import { RhiNullAdapter, rhi } from '@forgeax/engine-rhi-null';
+import { Camera, type RenderFeature } from '@forgeax/engine-render';
+import { rhi } from '@forgeax/engine-rhi-null';
 import { Transform } from '@forgeax/engine-scene';
+import { ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { Camera } from '../components';
-import { constructRenderer } from '../construct-renderer';
+import { createRenderer as constructRenderer } from '../assembly/factory';
 
 function manifestUrl(): string {
   return `data:application/json,${encodeURIComponent(JSON.stringify({ schemaVersion: '1.0.0', entries: [] }))}`;
@@ -24,85 +25,178 @@ describe('factory contract', () => {
     expect(profiler.phaseCatalog.render).toEqual([]);
   });
 
-  it('rolls back a post-process params buffer when its initial write fails', async () => {
-    const adapter = new RhiNullAdapter();
-    const deviceResult = await adapter.requestDevice();
-    expect(deviceResult.ok).toBe(true);
-    if (!deviceResult.ok) return;
-    const device = deviceResult.value;
-    device.queue.writeBuffer = () =>
-      ({
-        ok: false,
-        error: new Error('write failed'),
-      }) as never;
-    const failingRhi = {
-      requestAdapter: () =>
-        Promise.resolve({
-          ok: true as const,
-          value: { ...adapter, requestDevice: () => Promise.resolve(deviceResult) },
-        }),
-      acquireCanvasContext: rhi.acquireCanvasContext,
-      createShaderModule: rhi.createShaderModule,
-    };
+  it('completes the receipt-bound create, attach, draw, observe, recover chain', async () => {
     const renderer = await constructRenderer(
       { getContext: () => null },
-      { rhi: failingRhi as never },
+      { rhi },
       { shaderManifestUrl: manifestUrl() },
     );
-    expect(() =>
-      renderer.postProcess.register('test::write-failure', {
-        source: 'fn main() {}',
-        params: { byteSize: 16, defaultValue: new Uint8Array(16) },
-      }),
-    ).toThrow('write failed');
-    const buffers = (device as import('@forgeax/engine-rhi-null').RhiNullDevice).bookkeeper
-      .allRecords()
-      .filter((record) => record.kind === 'Buffer');
-    expect(buffers.at(-1)?.destroyed).toBe(true);
+    const world = new World();
+    const attached = renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+    const lease = attached.value;
+    expect(world.update().ok).toBe(true);
+
+    const frame = renderer.draw({
+      leases: [lease],
+      camera: { lease },
+      environment: { lease },
+    });
+    expect(frame.ok).toBe(true);
+    if (!frame.ok || frame.value === undefined) return;
+
+    const observed = await renderer.observe(frame.value, { include: ['timings'] });
+    expect(observed.ok).toBe(true);
+    const recovered = await renderer.recover();
+    expect(recovered.ok).toBe(false);
+    if (!recovered.ok) expect(recovered.error.code).toBe('recover-not-needed');
     renderer.dispose();
   });
 
-  it('attaches derived-state systems once without putting writes in draw', async () => {
+  it('does not promote a graph feature without a fullscreen effect into post-effects', async () => {
+    let planCalls = 0;
+    const feature = {
+      identity: 'synthetic.graph-only',
+      extract: () => ok(undefined),
+      plan: () => {
+        planCalls += 1;
+        return ok({ resources: [], passes: [] });
+      },
+    };
     const renderer = await constructRenderer(
       { getContext: () => null },
-      { rhi },
+      { rhi, features: [feature] },
       { shaderManifestUrl: manifestUrl() },
     );
     const world = new World();
-
-    expect(renderer.attachWorld(world).ok).toBe(true);
-    expect(renderer.attachWorld(world).ok).toBe(true);
-    expect(world.inspect().schedules.flatMap((schedule) => schedule.systems)).not.toEqual(
-      expect.arrayContaining([expect.objectContaining({ name: 'renderDerivedEntities' })]),
-    );
+    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).toBe(true);
+    expect(planCalls).toBe(1);
     renderer.dispose();
   });
 
-  it('leases one World transform schedule across independent renderer owners', async () => {
-    const first = await constructRenderer(
-      { getContext: () => null },
-      { rhi },
-      { shaderManifestUrl: manifestUrl() },
-    );
-    const second = await constructRenderer(
+  it('keeps the active graph as LKG when a feature candidate cannot be projected', async () => {
+    let invalid = false;
+    const featureErrors: string[] = [];
+    const feature: RenderFeature<undefined> = {
+      identity: 'synthetic.candidate-lkg',
+      extract: () => ok(undefined),
+      plan: () => {
+        if (!invalid) return ok({ resources: [], passes: [] });
+        return ok({
+          resources: [
+            {
+              kind: 'compute-program' as const,
+              name: 'candidate.program',
+              program: {
+                wgsl: '@compute @workgroup_size(1) fn main() {}',
+                entryPoints: ['main'],
+                bindings: [
+                  {
+                    entries: [{ binding: 0, visibility: 4, buffer: { type: 'storage' } }],
+                  },
+                ],
+              },
+            },
+            {
+              kind: 'buffer' as const,
+              name: 'candidate.buffer',
+              size: 4,
+              usage: ['storage' as const],
+              data: new Uint32Array([0]),
+            },
+            {
+              kind: 'compute-bindings' as const,
+              name: 'candidate.bindings',
+              program: 'candidate.program',
+              entries: [{ binding: 0, resource: 'candidate.buffer' }],
+            },
+          ],
+          passes: [
+            {
+              kind: 'compute',
+              name: 'main',
+              program: 'candidate.program',
+              bindings: 'candidate.bindings',
+              dispatches: [{ kind: 'direct', entryPoint: 'main', workgroups: [1] }],
+            },
+          ],
+        });
+      },
+    };
+    const renderer = await constructRenderer(
       { getContext: () => null },
-      { rhi },
+      { rhi, features: [feature] },
       { shaderManifestUrl: manifestUrl() },
     );
+    expect((await renderer.initialization).ok).toBe(true);
+    const unsubscribe = renderer.onError((error) => featureErrors.push(error.code));
     const world = new World();
-
-    expect(first.attachWorld(world).ok).toBe(true);
-    expect(second.attachWorld(world).ok).toBe(true);
-    first.dispose();
-    expect(second.attachWorld(world).ok).toBe(true);
+    const attached = renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
     world
       .spawn(
-        { component: Transform, data: { pos: [0, 0, 5] } },
-        { component: Camera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 } },
+        { component: Transform, data: { pos: [0, 0, 0], quat: [0, 0, 0, 1], scale: [1, 1, 1] } },
+        { component: Camera, data: { fov: 1, aspect: 1, near: 0.1, far: 100 } },
       )
       .unwrap();
     expect(world.update().ok).toBe(true);
-    second.dispose();
+    expect(
+      renderer.draw({
+        leases: [attached.value],
+        camera: { lease: attached.value },
+        environment: { lease: attached.value },
+      }).ok,
+    ).toBe(true);
+    const lastKnownGoodPasses = [...renderer.perFramePassNames];
+    expect(lastKnownGoodPasses.length).toBeGreaterThan(0);
+
+    invalid = true;
+    expect(
+      renderer.draw({
+        leases: [attached.value],
+        camera: { lease: attached.value },
+        environment: { lease: attached.value },
+      }).ok,
+    ).toBe(true);
+    await Promise.resolve();
+    expect(
+      renderer.draw({
+        leases: [attached.value],
+        camera: { lease: attached.value },
+        environment: { lease: attached.value },
+      }).ok,
+    ).toBe(true);
+    expect(featureErrors).toContain('duplicate-pass-name');
+    expect(renderer.perFramePassNames).toEqual(lastKnownGoodPasses);
+    unsubscribe();
+    renderer.dispose();
+  });
+
+  it('attaches derived-state systems once without putting writes in draw', async () => {
+    const renderer = await constructRenderer(
+      { getContext: () => null },
+      { rhi },
+      { shaderManifestUrl: manifestUrl() },
+    );
+    const world = new World();
+
+    expect(renderer.attach(world).ok).toBe(true);
+    expect(renderer.attach(world).ok).toBe(true);
+    expect(world.inspect().schedules.flatMap((schedule) => schedule.systems)).not.toEqual(
+      expect.arrayContaining([expect.objectContaining({ name: 'renderDerivedEntities' })]),
+    );
+    renderer.dispose();
   });
 
   it('releases one World without disposing the shared Renderer', async () => {
@@ -118,43 +212,21 @@ describe('factory contract', () => {
     );
     const world = new World();
 
-    expect(first.attachWorld(world).ok).toBe(true);
-    first.detachWorld(world);
-    first.detachWorld(world);
-    expect(second.attachWorld(world).ok).toBe(true);
+    expect(first.attach(world).ok).toBe(true);
+    first.detachScene(world);
+    first.detachScene(world);
+    expect(second.attach(world).ok).toBe(true);
     second.dispose();
     first.dispose();
   });
 
-  it('keeps the last published frame after rejecting an invalid update delta', async () => {
-    const renderer = await constructRenderer(
-      { getContext: () => null },
-      { rhi },
-      { shaderManifestUrl: manifestUrl() },
-    );
-    expect((await renderer.ready).ok).toBe(true);
-    const world = new World();
-    expect(renderer.attachWorld(world).ok).toBe(true);
-    world
-      .spawn(
-        { component: Transform, data: { pos: [0, 0, 5] } },
-        { component: Camera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 } },
-      )
-      .unwrap();
-    expect(world.update().ok).toBe(true);
-    expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-
-    expect(world.update(Number.NaN).ok).toBe(false);
-    expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-    renderer.dispose();
-  });
-
   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 }),
     ).resolves.toMatchObject({
-      backend: 'webgpu',
+      attach: expect.any(Function),
+      draw: expect.any(Function),
     });
     await expect(constructRenderer(undefined, { rhi })).rejects.toBeInstanceOf(Error);
   });
@@ -205,127 +277,4 @@ describe('factory contract', () => {
     renderer.dispose();
     expect(unconfigureCalls).toBe(1);
   });
-
-  it('keeps the real factory-owned GPU refusal structured on the null carrier', async () => {
-    const manifest = `data:application/json,${encodeURIComponent(JSON.stringify({ schemaVersion: '1.0.0', entries: [] }))}`;
-    const renderer = await constructRenderer(
-      { getContext: () => null },
-      { rhi, membershipTiming: { mode: 'gpu' } },
-      { shaderManifestUrl: manifest },
-    );
-    try {
-      const ready = await renderer.ready;
-      expect(ready.ok).toBe(true);
-      expect(renderer.membershipTiming).toBeDefined();
-      const started = renderer.membershipTiming?.start();
-      expect(started?.ok).toBe(false);
-      if (started !== undefined && !started.ok) {
-        expect(started.error.code).toBe('timestamp-query-unsupported');
-        expect(started.error.expected).toContain('timestampQuery');
-        expect(started.error.hint).toEqual(expect.any(String));
-        expect(started.error.detail).toEqual(expect.any(String));
-      }
-    } finally {
-      renderer.dispose();
-    }
-  });
-
-  it('reports one capture identity through the real Render submit path for CPU control', async () => {
-    const manifest = `data:application/json,${encodeURIComponent(JSON.stringify({ schemaVersion: '1.0.0', entries: [] }))}`;
-    const renderer = await constructRenderer(
-      { getContext: () => null },
-      { rhi, membershipTiming: { mode: 'cpu-control' } },
-      { shaderManifestUrl: manifest },
-    );
-    try {
-      const ready = await renderer.ready;
-      expect(ready.ok).toBe(true);
-      const timing = renderer.membershipTiming;
-      expect(timing?.start().ok).toBe(true);
-      const world = new World();
-      expect(renderer.attachWorld(world).ok).toBe(true);
-      expect(world.update().ok).toBe(true);
-      expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-      const report = await timing?.finish();
-      expect(report?.ok).toBe(true);
-      if (report?.ok) {
-        expect(report.value.captureId).toMatch(/^membership-\d+$/);
-        expect(report.value.submissionToken).toBe(`${report.value.captureId}:submission`);
-        expect(report.value.actualProducer).toBe('cpu');
-        expect(report.value.gpu).toBeNull();
-      }
-    } finally {
-      renderer.dispose();
-    }
-  });
-
-  it('publishes frame completion only after a successful draw', async () => {
-    const manifest = manifestUrl();
-    const renderer = await constructRenderer(
-      { getContext: () => null },
-      { rhi },
-      { shaderManifestUrl: manifest },
-    );
-    expect((await renderer.ready).ok).toBe(true);
-
-    let completions = 0;
-    const unsubscribe = renderer.subscribeFrameEnd(() => {
-      completions += 1;
-    });
-    const world = new World();
-    expect(renderer.attachWorld(world).ok).toBe(true);
-    world.update().unwrap();
-
-    expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-    expect(completions).toBe(1);
-
-    expect(renderer.releaseSurface().ok).toBe(true);
-    expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(false);
-    expect(completions).toBe(1);
-
-    expect(renderer.restoreSurface().ok).toBe(true);
-    unsubscribe();
-    expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-    expect(completions).toBe(1);
-  });
-
-  it('does not publish completion when the render stage cannot submit', async () => {
-    const adapterResult = await rhi.requestAdapter();
-    expect(adapterResult.ok).toBe(true);
-    if (!adapterResult.ok) return;
-    const deviceResult = await adapterResult.value.requestDevice();
-    expect(deviceResult.ok).toBe(true);
-    if (!deviceResult.ok) return;
-    const failingPack = {
-      rhi: {
-        requestAdapter: () => Promise.resolve(adapterResult),
-        acquireCanvasContext: () => ({
-          ok: true as const,
-          value: {
-            configure: () => ({ ok: true as const, value: undefined }),
-            unconfigure: () => undefined,
-            getConfiguration: () => undefined,
-            getCurrentTexture: () => ({
-              ok: false as const,
-              error: new Error('surface unavailable'),
-            }),
-          },
-        }),
-      },
-    };
-    const renderer = await constructRenderer({ getContext: () => null }, failingPack as never, {
-      shaderManifestUrl: manifestUrl(),
-    });
-    expect((await renderer.ready).ok).toBe(true);
-
-    let completions = 0;
-    renderer.subscribeFrameEnd(() => {
-      completions += 1;
-    });
-    const world = new World();
-    expect(renderer.attachWorld(world).ok).toBe(true);
-    world.update().unwrap();
-    expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-    expect(completions).toBe(0);
-  });
 });

package/src/__tests__/fallback-row-stride-surface.unit.test.ts

@@ -3,10 +3,7 @@ import { describe, expect, it } from 'vitest';
 import { FALLBACK_BYTES_PER_ROW } from '../ibl/skylight-bind-group';
 
 const ownerSource = readFileSync(new URL('../ibl/skylight-bind-group.ts', import.meta.url), 'utf8');
-const rendererSource = readFileSync(
-  new URL('../renderer/renderer-factory.ts', import.meta.url),
-  'utf8',
-);
+const rendererSource = readFileSync(new URL('../assembly/factory.ts', import.meta.url), 'utf8');
 
 describe('fallback texture row-stride owner', () => {
   it('keeps both 1x1 fallback upload paths on one owner', () => {

package/src/__tests__/frame-observation.contract.test.ts

@@ -5,7 +5,8 @@ import {
   type FrameObservationReadback,
   type FrameObservationSource,
   observeCurrentFrame,
-} from '../record/frame-observation.js';
+} from '../record/frame.js';
+import type { FrameObservationRequest, FrameReceipt } from '../render-contract';
 
 const texture = {} as Texture;
 const usage = 0x10 | 0x04 | 0x01;
@@ -21,13 +22,21 @@ function source(overrides: Partial<FrameObservationSource> = {}): FrameObservati
       sample: 1,
     },
     frameId: 12,
-    pipelineId: 'forgeax::urp',
+    pipelineId: 'forgeax::standard',
     backendId: 'webgpu',
     ...overrides,
   };
 }
 
 describe('render current-frame observation producer contract', () => {
+  it('requires a receipt-bound request instead of a latest-frame getter', () => {
+    const receipt = null as unknown as FrameReceipt;
+    const request: FrameObservationRequest = { include: ['timings', 'draws'] };
+    // M6 red snapshot: observe must be bound to the exact receipt and request.
+    expect(receipt).toBeDefined();
+    expect(request.include).toEqual(['timings', 'draws']);
+  });
+
   it('observes only the producer-owned linear HDR target', async () => {
     const readback: FrameObservationReadback = vi.fn(async (lease) => {
       expect(lease.descriptor.format).toBe('rgba16float');
@@ -43,7 +52,7 @@ describe('render current-frame observation producer contract', () => {
       format: 'rgba16float',
       size: { width: 4, height: 2 },
       frameId: 12,
-      pipelineId: 'forgeax::urp',
+      pipelineId: 'forgeax::standard',
       backendId: 'webgpu',
     });
     expect(readback).toHaveBeenCalledTimes(1);
@@ -72,23 +81,23 @@ describe('render current-frame observation producer contract', () => {
     expect(readback).not.toHaveBeenCalled();
   });
 
-  it('preserves URP and HDRP producer identity without backend policy', async () => {
+  it('preserves the Standard producer identity without backend policy', async () => {
     const readback: FrameObservationReadback = vi.fn(async () => ok(new Uint8Array(64)));
     const urp = await observeCurrentFrame(
       { semantic: 'linear-hdr', readback },
-      source({ pipelineId: 'forgeax::urp' }),
+      source({ pipelineId: 'forgeax::standard' }),
       12,
     );
     const hdrp = await observeCurrentFrame(
       { semantic: 'linear-hdr', readback },
-      source({ pipelineId: 'forgeax::hdrp' }),
+      source({ pipelineId: 'forgeax::standard' }),
       12,
     );
 
     expect(urp.ok && hdrp.ok).toBe(true);
     if (urp.ok && hdrp.ok) {
-      expect(urp.value.metadata.pipelineId).toBe('forgeax::urp');
-      expect(hdrp.value.metadata.pipelineId).toBe('forgeax::hdrp');
+      expect(urp.value.metadata.pipelineId).toBe('forgeax::standard');
+      expect(hdrp.value.metadata.pipelineId).toBe('forgeax::standard');
       expect(urp.value.metadata.backendId).toBe(hdrp.value.metadata.backendId);
     }
   });

package/src/__tests__/fullscreen-feature-plan.unit.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { createFullscreenRenderFeature } from '../features/fullscreen';
+import { freezeRenderFeaturePlan } from '../features/plan';
+
+describe('fullscreen RenderFeature plan', () => {
+  it('keeps the cooked effect on the Standard post-stage owner', () => {
+    const feature = createFullscreenRenderFeature({
+      identity: 'test::fullscreen',
+      source: '@fragment fn fs_main() -> @location(0) vec4f { return vec4f(1); }',
+      params: { byteSize: 4, defaultValue: new Uint8Array([1, 0, 0, 0]) },
+    });
+    const planned = feature.plan(undefined, {
+      caps: {} as never,
+      frame: { frameNumber: 1 },
+      generation: 1,
+      targets: [{ name: 'scene-color', kind: 'color', format: 'rgba16float', sampleCount: 1 }],
+    });
+
+    expect(planned.ok).toBe(true);
+    if (!planned.ok) return;
+    expect(
+      freezeRenderFeaturePlan(feature.identity, planned.value, [
+        { name: 'scene-color', kind: 'color', format: 'rgba16float', sampleCount: 1 },
+      ]).ok,
+    ).toBe(true);
+    expect(planned.value.resources[0]).toMatchObject({
+      kind: 'fullscreen-program',
+      source: '@fragment fn fs_main() -> @location(0) vec4f { return vec4f(1); }',
+    });
+    expect(planned.value.passes).toEqual([]);
+  });
+});

package/src/__tests__/glyph-text-layout-recovery.unit.test.ts

@@ -1,14 +1,14 @@
+import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import { type EntityHandle, World } from '@forgeax/engine-ecs';
 import { AssetGuid } from '@forgeax/engine-pack/guid';
 import { Transform } from '@forgeax/engine-scene';
 import type { FontAsset, GlyphMetric, Handle, MeshAsset } from '@forgeax/engine-types';
 import { TextError } from '@forgeax/engine-types';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { resolveRenderAsset } from '../assets/resolve-render-asset';
 import { MeshFilter, MeshRenderer } from '../components';
 import { GlyphText } from '../components/glyph-text';
+import { GpuResidencyCache } from '../device/gpu-residency';
 import { glyphTextLayoutSystem, resetGlyphBakeCache } from '../glyph-text-layout-system';
-import { GpuResourceStore } from '../gpu-resource-store';
 
 function metric(): GlyphMetric {
   return {
@@ -57,7 +57,7 @@ function spawnLabel(world: World, fontHandle: number): EntityHandle {
 }
 
 describe('glyph-text-layout-system font-cap recovery', () => {
-  const gpuStore = new GpuResourceStore();
+  const gpuStore = new GpuResidencyCache();
 
   beforeEach(() => resetGlyphBakeCache());
 
@@ -119,7 +119,7 @@ describe('glyph-text-layout-system font-cap recovery', () => {
     );
     expect(rebuiltMeshHandle).not.toBe(oldMeshHandle);
     expect(rebuiltMaterialHandle).not.toBe(oldMaterialHandle);
-    const rebuiltMesh = resolveRenderAsset<MeshAsset>(
+    const rebuiltMesh = resolveAssetHandle<MeshAsset>(
       world,
       rebuiltMeshHandle as unknown as Handle<'MeshAsset', 'shared'>,
     );
@@ -140,12 +140,8 @@ describe('glyph-text-layout-system font-cap recovery', () => {
   });
 
   it('replaces a resident GPU mesh when text changes its vertex shape', () => {
-    const updateMesh = vi.fn(() => ({
-      ok: false as const,
-      error: { code: 'mesh-shape-mismatch' } as never,
-    }));
-    const replaceMesh = vi.fn(() => ({ ok: true as const, value: undefined }));
-    const residentStore = { updateMesh, replaceMesh } as unknown as GpuResourceStore;
+    const updateMesh = vi.fn();
+    const residentStore = { updateMesh } as unknown as GpuResidencyCache;
     const world = new World();
     const font = registerFont(world);
     const label = spawnLabel(world, font);
@@ -162,7 +158,6 @@ describe('glyph-text-layout-system font-cap recovery', () => {
     expect(glyphTextLayoutSystem(world, residentStore).ok).toBe(true);
 
     expect(updateMesh).toHaveBeenCalledOnce();
-    expect(replaceMesh).toHaveBeenCalledOnce();
     const after = world.sharedRefs.resolve<'MeshAsset', MeshAsset>(meshHandle as never);
     expect(after.ok).toBe(true);
     if (!after.ok) return;