@forgeax/engine-render 0.0.0-dev.8d955ade1c79

package/src/__tests__/render-feature-contract.test-d.ts

@@ -0,0 +1,49 @@
+import { ok } from '@forgeax/engine-types';
+import type { RenderFeature, RenderFeaturePlanContext } from '../features/types';
+
+type AlphaFrame = {
+  readonly visibleCount: number;
+};
+
+type BetaFrame = {
+  readonly bounds: readonly [number, number, number, number];
+};
+
+const alphaFeature = {
+  identity: 'synthetic.alpha',
+  extract({ owner }) {
+    return ok<AlphaFrame>({ visibleCount: owner });
+  },
+  plan(data: AlphaFrame, context: RenderFeaturePlanContext) {
+    const count: number = data.visibleCount;
+    void count;
+    void context;
+    return ok({ resources: [], passes: [] });
+  },
+} satisfies RenderFeature<AlphaFrame>;
+
+const betaFeature = {
+  identity: 'synthetic.beta',
+  extract() {
+    return ok<BetaFrame>({ bounds: [0, 0, 1, 1] });
+  },
+  plan(data: BetaFrame, context: RenderFeaturePlanContext) {
+    const bounds: BetaFrame['bounds'] = data.bounds;
+    void bounds;
+    void context;
+    return ok({ resources: [], passes: [] });
+  },
+} satisfies RenderFeature<BetaFrame>;
+
+const heterogeneousFeatures = [
+  alphaFeature,
+  betaFeature,
+] satisfies readonly RenderFeature<unknown>[];
+
+for (const feature of heterogeneousFeatures) {
+  const identity: string = feature.identity;
+  void identity;
+}
+
+void alphaFeature;
+void betaFeature;

package/src/__tests__/render-feature-diagnostics.unit.test.ts

@@ -0,0 +1,149 @@
+import type { RhiCaps } from '@forgeax/engine-rhi';
+import { err, ok } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { RenderFeatureStageFailedError } from '../errors/render';
+import { createRenderFeatureHost, runRenderFeatureFrame } from '../features/host';
+import type { RenderFeature } from '../features/types';
+
+const caps = (compute: boolean): Readonly<RhiCaps> => ({ compute }) as unknown as RhiCaps;
+
+function gatedFeature(): RenderFeature<{ readonly frame: number }> {
+  return {
+    identity: 'synthetic.gated',
+    requiredCapabilities: ['compute'],
+    extract: ({ frameNumber }) => ok({ frame: frameNumber }),
+    plan: () => ok({ resources: [], passes: [] }),
+  };
+}
+
+describe('render feature diagnostics and capability gate', () => {
+  it('notifies only lifecycle projection changes and stops after unsubscribe', () => {
+    const host = createRenderFeatureHost([gatedFeature()], caps(true)).unwrap();
+    let notifications = 0;
+    const unsubscribe = host.subscribeDiagnostics(() => {
+      notifications += 1;
+    });
+
+    expect(host.setStatus('synthetic.gated', 'active')).toEqual(ok(undefined));
+    expect(notifications).toBe(0);
+
+    expect(host.setStatus('synthetic.gated', 'disabled')).toEqual(ok(undefined));
+    expect(notifications).toBe(1);
+    expect(host.setStatus('synthetic.gated', 'active')).toEqual(ok(undefined));
+    expect(notifications).toBe(2);
+
+    unsubscribe();
+    expect(host.setStatus('synthetic.gated', 'disabled')).toEqual(ok(undefined));
+    expect(notifications).toBe(2);
+  });
+
+  it('isolates a throwing diagnostics observer from renderer lifecycle changes', () => {
+    const host = createRenderFeatureHost([gatedFeature()], caps(true)).unwrap();
+    let healthyNotifications = 0;
+    host.subscribeDiagnostics(() => {
+      throw new Error('observer failed');
+    });
+    host.subscribeDiagnostics(() => {
+      healthyNotifications += 1;
+    });
+
+    expect(host.setStatus('synthetic.gated', 'disabled')).toEqual(ok(undefined));
+    expect(host.diagnostics()[0]?.status).toBe('disabled');
+    expect(healthyNotifications).toBe(1);
+    expect(() => host.dispose()).not.toThrow();
+  });
+
+  it('installs a late feature once and keeps identity conflicts explicit', () => {
+    const host = createRenderFeatureHost([], caps(true)).unwrap();
+    const feature = gatedFeature();
+    expect(host.install(feature)).toEqual(ok(undefined));
+    expect(host.install(feature)).toEqual(ok(undefined));
+    expect(host.size).toBe(1);
+    expect(host.install(gatedFeature())).toMatchObject({
+      ok: false,
+      error: { code: 'render-feature-registration-conflict' },
+    });
+    expect(
+      runRenderFeatureFrame(host, {
+        worlds: [],
+        owner: 0,
+        frameNumber: 1,
+        caps: caps(true),
+      }).stageEvents,
+    ).toHaveLength(2);
+  });
+
+  it('disables without a capability and re-enables only after recover re-evaluation', () => {
+    const host = createRenderFeatureHost([gatedFeature()], caps(false)).unwrap();
+    const first = runRenderFeatureFrame(host, {
+      worlds: [],
+      owner: 0,
+      frameNumber: 1,
+      caps: caps(false),
+    });
+
+    expect(first.stageEvents).toEqual([]);
+    expect(first.errors).toHaveLength(1);
+    expect(first.errors[0]?.code).toBe('render-feature-capability-missing');
+    expect(host.diagnostics()[0]?.status).toBe('disabled');
+
+    const stillDisabled = runRenderFeatureFrame(host, {
+      worlds: [],
+      owner: 0,
+      frameNumber: 2,
+      caps: caps(true),
+    });
+    expect(stillDisabled.stageEvents).toEqual([]);
+
+    expect(host.recover({ frameNumber: 3, caps: caps(true) })).toEqual(ok(undefined));
+    expect(host.diagnostics()[0]?.status).toBe('active');
+    expect(
+      runRenderFeatureFrame(host, {
+        worlds: [],
+        owner: 0,
+        frameNumber: 3,
+        caps: caps(true),
+      }).stageEvents,
+    ).toHaveLength(2);
+  });
+
+  it('replaces the latest stage failure after retry and returns deep readonly snapshots', () => {
+    let shouldFail = true;
+    const feature: RenderFeature<{ readonly ready: true }> = {
+      identity: 'synthetic.latest-error',
+      extract: () => ok({ ready: true }),
+      plan: () => {
+        if (shouldFail) {
+          return err(
+            new RenderFeatureStageFailedError('synthetic.latest-error', 0, 'plan', 'next-frame'),
+          );
+        }
+        return ok({ resources: [], passes: [] });
+      },
+    };
+    const host = createRenderFeatureHost([feature], caps(true)).unwrap();
+
+    runRenderFeatureFrame(host, {
+      worlds: [],
+      owner: 0,
+      frameNumber: 1,
+      caps: caps(true),
+    });
+    const failed = host.diagnostics();
+    expect(failed[0]?.latestError?.code).toBe('render-feature-stage-failed');
+    expect(Object.isFrozen(failed)).toBe(true);
+    expect(Object.isFrozen(failed[0])).toBe(true);
+    expect(Object.isFrozen(failed[0]?.latestError)).toBe(true);
+    expect(Object.isFrozen(failed[0]?.latestError?.detail)).toBe(true);
+
+    shouldFail = false;
+    runRenderFeatureFrame(host, {
+      worlds: [],
+      owner: 0,
+      frameNumber: 2,
+      caps: caps(true),
+    });
+    expect(host.diagnostics()[0]?.status).toBe('active');
+    expect(host.diagnostics()[0]?.latestError).toBeUndefined();
+  });
+});

package/src/__tests__/render-feature-docs.unit.test.ts

@@ -0,0 +1,89 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import {
+  RenderFeatureCapabilityMissingError,
+  RenderFeaturePassOrderConflictError,
+  RenderFeatureRegistrationConflictError,
+  RenderFeatureStageFailedError,
+} from '../errors/render';
+
+function read(relativePath: string): string {
+  return readFileSync(new URL(relativePath, import.meta.url), 'utf8');
+}
+
+const renderReadme = read('../../README.md');
+const runtimeReadme = read('../../../runtime/README.md');
+const appSkill = read('../../../../skills/forgeax-engine-app/SKILL.md');
+
+// M4-06 prepends the direct-light contract; keep the existing first-read
+// vocabulary assertion wide enough to cover that approved contract.
+const topSurface = renderReadme.slice(0, 18000);
+
+describe('RenderFeature documentation surface', () => {
+  it('keeps the first-read public route and four-term vocabulary indexable', () => {
+    for (const token of [
+      '## RenderFeature: the producer seam',
+      'type FrameData',
+      'createRenderer(canvas, { features: [feature] })',
+      'plan(data, context)',
+      'named resources and passes',
+      'active RenderGraph',
+      'RenderFeature',
+      'Standard Pipeline',
+      'RenderGraph pass',
+    ]) {
+      expect(topSurface).toContain(token);
+    }
+    expect(topSurface).not.toContain('passContext.commands');
+    expect(topSurface).not.toContain('context.staging.addPass');
+    expect(topSurface).not.toContain('graph-only Wave 1 feature');
+    expect(runtimeReadme).toContain('createRenderer(canvas, options?, bundler?)');
+    expect(appSkill).toContain('Renderer feature assembly');
+  });
+
+  it('indexes capability, structured error, recovery, disposal, and pipeline switching', () => {
+    const surface = `${renderReadme}\n${runtimeReadme}\n${appSkill}`;
+    for (const token of [
+      'Readonly<RhiCaps>',
+      'RenderError',
+      'error.code',
+      'error.hint',
+      'error.detail',
+      'renderer.subscribe()',
+      'renderer.inspect()',
+      'renderer.recover()',
+      'renderer.dispose()',
+      'RenderFeaturePlan',
+    ]) {
+      expect(surface).toContain(token);
+    }
+  });
+
+  it('keeps the error hint actions aligned with the recovery matrix', () => {
+    const cases = [
+      {
+        error: new RenderFeatureRegistrationConflictError('test.feature', 1, 0),
+        recoveryToken: 'registration',
+      },
+      {
+        error: new RenderFeatureStageFailedError('test.feature', 1, 'prepare', 'next-frame'),
+        recoveryToken: 'next frame',
+      },
+      {
+        error: new RenderFeatureCapabilityMissingError('test.feature', 1, 'compute'),
+        recoveryToken: 'capability',
+      },
+      {
+        error: new RenderFeaturePassOrderConflictError('test.feature', 1, 'overlay', 'main'),
+        recoveryToken: 'reorder',
+      },
+    ];
+
+    for (const { error, recoveryToken } of cases) {
+      expect(error.hint.toLowerCase()).toContain(recoveryToken);
+      expect(`${renderReadme}\n${runtimeReadme}\n${appSkill}`.toLowerCase()).toContain(
+        recoveryToken,
+      );
+    }
+  });
+});

package/src/__tests__/render-feature-errors.unit.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import { ObservationUnavailableError } from '../errors/render';
+import type { RenderFeatureErrorCode, RenderFeatureErrorDescriptor } from '../features/types';
+
+const renderFeatureErrorCodes: readonly RenderFeatureErrorCode[] = [
+  'render-feature-registration-conflict',
+  'render-feature-stage-failed',
+  'render-feature-capability-missing',
+  'render-feature-pass-order-conflict',
+  'render-feature-preparation-failed',
+  'render-feature-prepared-state-mismatch',
+  'render-feature-draw-recording-failed',
+];
+
+function describeError(error: RenderFeatureErrorDescriptor): string {
+  switch (error.code) {
+    case 'render-feature-registration-conflict':
+      return error.detail.featureIdentity;
+    case 'render-feature-stage-failed':
+      return `${error.detail.featureIdentity}:${error.detail.stage}`;
+    case 'render-feature-capability-missing':
+      return error.detail.featureIdentity;
+    case 'render-feature-pass-order-conflict':
+      return error.detail.featureIdentity;
+    case 'render-feature-preparation-failed':
+      return error.detail.featureIdentity;
+    case 'render-feature-prepared-state-mismatch':
+      return error.detail.featureIdentity;
+    case 'render-feature-draw-recording-failed':
+      return error.detail.featureIdentity;
+  }
+}
+
+describe('render feature error vocabulary', () => {
+  it('keeps the four feature codes closed and machine-readable', () => {
+    expect(renderFeatureErrorCodes).toHaveLength(7);
+    expect(describeError).toBeTypeOf('function');
+  });
+
+  it('keeps observation recovery structured and producer-owned', () => {
+    const error = new ObservationUnavailableError('stale', 'draw a fresh current frame');
+    expect(error.code).toBe('observation-unavailable');
+    expect(error.expected).toContain('rgba16float');
+    expect(error.hint).toContain('fresh');
+    expect(error.detail).toEqual({ reason: 'stale', recovery: 'draw-current-frame' });
+  });
+});

package/src/__tests__/render-feature-gpu-work.integration.test.ts

@@ -0,0 +1,316 @@
+import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
+import {
+  type BindGroup,
+  type Buffer,
+  type ComputePipeline,
+  type RenderPipeline,
+  type RhiCommandEncoder,
+  RhiError,
+} from '@forgeax/engine-rhi';
+import { rhi } from '@forgeax/engine-rhi-null';
+import { err, ok } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { createRenderFeatureGpuWorkOwner } from '../features/prepared-gpu-work';
+import { RenderFeatureComputeGraphProjection } from '../features/render-graph-compute';
+import { RenderFeatureRasterGraphProjection } from '../features/render-graph-raster';
+import { createRenderFeatureGraphBufferState } from '../features/render-graph-resources';
+import type { PreparedGraphicsResolvedResource } from '../prepare/prepared-graphics-resolver';
+
+describe('RenderFeature persistent GPU work', () => {
+  it('projects compute output and indirect raster consumption into one typed graph', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap();
+    const indirectBuffer = device
+      .createBuffer({ size: 16, usage: 0x0080 | 0x0100 | 0x0020 | 0x0008 })
+      .unwrap();
+    const graph = new RenderGraphBuilder<{ readonly encoder: RhiCommandEncoder }>();
+    const output = graph
+      .createTexture('output', { format: 'rgba8unorm', size: { width: 1, height: 1 } })
+      .unwrap();
+    const outputView = graph.view(output, { label: 'output.view' }).unwrap();
+    const buffers = createRenderFeatureGraphBufferState();
+    const compute = new RenderFeatureComputeGraphProjection(graph, buffers);
+    expect(
+      compute.addPass('vfx.simulate-and-project', 'forgeax.vfx', 0, {
+        buffers: [
+          {
+            name: 'draw-args',
+            buffer: indirectBuffer,
+            size: 16,
+            physicalUsage: 0x0080 | 0x0100 | 0x0020 | 0x0008,
+            access: 'storage-write',
+          },
+        ],
+        dispatches: [
+          {
+            pipeline: {} as ComputePipeline,
+            bindGroup: {} as BindGroup,
+            workgroups: [1, 1, 1],
+          },
+        ],
+      }).ok,
+    ).toBe(true);
+
+    const pipeline = { kind: 'pipeline', generation: 1 } as const;
+    const binding = { kind: 'bindings', generation: 1 } as const;
+    const vertices = { kind: 'vertex-data', generation: 1 } as const;
+    const gpuArgs = { name: 'draw-args', generation: 1 } as never;
+    const resources = new Map<object, PreparedGraphicsResolvedResource>([
+      [
+        pipeline,
+        {
+          kind: 'pipeline',
+          reference: pipeline as never,
+          handle: {} as RenderPipeline,
+        },
+      ],
+      [
+        vertices,
+        {
+          kind: 'vertex-data',
+          reference: vertices as never,
+          handle: indirectBuffer,
+          size: 16,
+          physicalUsage: 0x0080 | 0x0100 | 0x0020 | 0x0008,
+        },
+      ],
+      [
+        binding,
+        {
+          kind: 'bindings',
+          reference: binding as never,
+          handle: {} as BindGroup,
+        },
+      ],
+    ]);
+    const raster = new RenderFeatureRasterGraphProjection(
+      graph,
+      () => ({ texture: output, view: outputView }),
+      undefined,
+      buffers,
+    );
+    expect(
+      raster.addPass(
+        'vfx.draw',
+        'vfx',
+        0,
+        {
+          attachments: {
+            colors: [
+              {
+                resource: 'output',
+                format: 'rgba8unorm',
+                loadOp: 'clear',
+                storeOp: 'store',
+              },
+            ],
+          },
+          draws: [
+            {
+              kind: 'draw-indirect',
+              pipeline: pipeline as never,
+              bindings: [binding as never],
+              vertexData: [{ slot: 0, resource: vertices as never }],
+              command: { buffer: gpuArgs, offset: 0 },
+            },
+          ],
+        },
+        {
+          capabilityAvailable: true,
+          generation: 1,
+          attachments: [{ resource: 'output', format: 'rgba8unorm' }],
+          pipeline: pipeline as never,
+          pipelines: [pipeline as never],
+          bindings: [binding as never],
+          vertexData: [vertices as never],
+          indexData: [],
+        },
+        {
+          generation: 1,
+          resolve: (reference) => resources.get(reference),
+          resolveGpuBuffer: () => ({
+            buffer: indirectBuffer as Buffer,
+            size: 16,
+            physicalUsage: 0x0080 | 0x0100 | 0x0020 | 0x0008,
+          }),
+        },
+      ).ok,
+    ).toBe(true);
+
+    const compiled = graph.compile({ device, surfaceSize: { width: 1, height: 1 } }).unwrap();
+    expect(compiled.inspect().passes).toMatchObject([
+      { name: 'vfx.simulate-and-project', kind: 'compute', dependencies: [] },
+      { name: 'vfx.draw', kind: 'raster', dependencies: ['vfx.simulate-and-project'] },
+    ]);
+    const encoder = device.createCommandEncoder({ label: 'vfx-mixed-frame' }).unwrap();
+    expect(compiled.execute({ encoder }).ok).toBe(true);
+    expect(encoder.finish().ok).toBe(true);
+  });
+
+  it('classifies an asynchronous shader warmup as a next-frame retry', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap();
+    const owner = createRenderFeatureGpuWorkOwner({
+      getDevice: () => device,
+      getShaderModuleFactory: () => ({
+        createShaderModule: () =>
+          err(
+            new RhiError({
+              code: 'rhi-not-available',
+              expected: 'asynchronous shader compilation to finish',
+              hint: 'retry on the next frame',
+            }),
+          ),
+      }),
+    });
+    const resolver = owner.beginFeature('synthetic.gpu', 0);
+
+    const prepared = resolver.prepareProgram('program', {
+      wgsl: 'synthetic',
+      entryPoints: ['simulate'],
+    });
+
+    expect(prepared.ok).toBe(false);
+    if (!prepared.ok) {
+      expect(prepared.error).toMatchObject({
+        code: 'render-feature-preparation-failed',
+        detail: {
+          operation: 'prepare-gpu-program',
+          reason: 'rhi-not-available:retry on the next frame',
+          recovery: 'next-frame',
+        },
+      });
+    }
+  });
+
+  it('records compute against persistent storage and releases it once', async () => {
+    const adapter = (await rhi.requestAdapter()).unwrap();
+    const device = (await adapter.requestDevice()).unwrap();
+    const shader = (await rhi.createShaderModule(device, { code: 'synthetic' })).unwrap();
+    const owner = createRenderFeatureGpuWorkOwner({
+      getDevice: () => device,
+      getShaderModuleFactory: () => ({ createShaderModule: () => ok(shader) }),
+    });
+    const resolver = owner.beginFeature('synthetic.gpu', 4);
+    const program = resolver
+      .prepareProgram('program', {
+        wgsl: 'synthetic',
+        entryPoints: ['simulate', 'compact'],
+        bindings: [
+          {
+            entries: [
+              {
+                binding: 0,
+                visibility: 0x4,
+                buffer: { type: 'storage', hasDynamicOffset: false, minBindingSize: 0 },
+              },
+              {
+                binding: 1,
+                visibility: 0x4,
+                buffer: { type: 'storage', hasDynamicOffset: false, minBindingSize: 0 },
+              },
+            ],
+          },
+        ],
+      })
+      .unwrap();
+    const storage = resolver
+      .prepareBuffer('particles', {
+        size: 4096,
+        usage: ['storage', 'vertex'],
+        data: new Uint32Array([1, 2, 3, 4]),
+      })
+      .unwrap();
+    const indirect = resolver
+      .prepareBuffer('indirect', {
+        size: 20,
+        usage: ['storage', 'indirect'],
+        data: new Uint32Array([6, 0, 0, 0, 0]),
+      })
+      .unwrap();
+    const dispatchArgs = resolver
+      .prepareBuffer('dispatch-args', {
+        size: 12,
+        usage: ['indirect'],
+        data: new Uint32Array([1, 1, 1]),
+      })
+      .unwrap();
+    const bindings = resolver
+      .prepareBindings('bindings', {
+        program,
+        entries: [
+          { binding: 0, buffer: storage },
+          { binding: 1, buffer: indirect },
+        ],
+      })
+      .unwrap();
+    const computeDescriptor = {
+      program,
+      bindings,
+      dispatches: [
+        { entryPoint: 'simulate', workgroups: [16] as const },
+        { entryPoint: 'compact', workgroups: [1] as const },
+        { entryPoint: 'simulate', indirect: { buffer: dispatchArgs, offset: 0 } },
+      ],
+    } as const;
+    const missingUsage = resolver.resolveComputePass('synthetic.gpu', {
+      program,
+      bindings,
+      dispatches: [{ entryPoint: 'simulate', indirect: { buffer: storage, offset: 0 } }],
+    });
+    expect(missingUsage.ok).toBe(false);
+    if (!missingUsage.ok && missingUsage.error.code === 'render-feature-preparation-failed') {
+      expect(missingUsage.error.detail.reason).toBe('indirect-dispatch-invalid');
+    }
+    const outOfBounds = resolver.resolveComputePass('synthetic.gpu', {
+      program,
+      bindings,
+      dispatches: [{ entryPoint: 'simulate', indirect: { buffer: dispatchArgs, offset: 4 } }],
+    });
+    expect(outOfBounds.ok).toBe(false);
+    if (!outOfBounds.ok && outOfBounds.error.code === 'render-feature-preparation-failed') {
+      expect(outOfBounds.error.detail.reason).toBe('indirect-dispatch-invalid');
+    }
+    const work = resolver.resolveComputePass('synthetic.gpu', computeDescriptor).unwrap();
+    expect(work.buffers.map((buffer) => [buffer.name, buffer.access])).toEqual([
+      ['particles', 'storage-read-write'],
+      ['indirect', 'storage-read-write'],
+      ['dispatch-args', 'indirect-read'],
+    ]);
+    const graph = new RenderGraphBuilder<{ readonly encoder: RhiCommandEncoder }>();
+    const projection = new RenderFeatureComputeGraphProjection(graph);
+    expect(projection.addPass('synthetic.gpu.compute', 'synthetic.gpu', 0, work).ok).toBe(true);
+    const compiled = graph.compile({ device, surfaceSize: { width: 1, height: 1 } }).unwrap();
+    expect(compiled.inspect().passes[0]).toMatchObject({
+      name: 'synthetic.gpu.compute',
+      kind: 'compute',
+      accesses: [
+        { resource: 'synthetic.gpu.compute.particles', usage: 'storage-read-write' },
+        { resource: 'synthetic.gpu.compute.indirect', usage: 'storage-read-write' },
+        { resource: 'synthetic.gpu.compute.dispatch-args', usage: 'indirect-read' },
+      ],
+    });
+    const encoder = device.createCommandEncoder({ label: 'gpu-feature-frame' }).unwrap();
+    expect(compiled.execute({ encoder }).ok).toBe(true);
+    expect(encoder.finish().ok).toBe(true);
+
+    expect(resolver.resolveBuffer(storage)).toBeDefined();
+    expect(resolver.resolveBuffer(indirect)).toBeDefined();
+    expect(resolver.resolveBuffer(dispatchArgs)).toBeDefined();
+    expect(resolver.retireUntouched()).toEqual([]);
+
+    resolver.beginFrame();
+    expect(resolver.retainBindings([bindings]).ok).toBe(true);
+    expect(resolver.resolveComputePass('synthetic.gpu', computeDescriptor).ok).toBe(true);
+    expect(resolver.retireUntouched()).toEqual([]);
+
+    resolver.beginFrame();
+    const retired = resolver.retireUntouched();
+    expect(retired).toHaveLength(1);
+    expect(resolver.resolveBuffer(storage)).toBeUndefined();
+    expect(retired[0]?.release().ok).toBe(true);
+    expect(retired[0]?.release().ok).toBe(true);
+    expect(resolver.dispose().ok).toBe(true);
+    expect(resolver.dispose().ok).toBe(true);
+  });
+});