@forgeax/engine-render 0.1.4 → 0.1.7

package/src/__tests__/morph-culling-reentry.dawn.test.ts

@@ -3,17 +3,20 @@ import type { RhiCommandEncoder } from '@forgeax/engine-rhi';
 import { createShaderModule, rhi } from '@forgeax/engine-rhi-webgpu';
 import { ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { createRenderFeatureContributionStaging } from '../features/graph-contribution';
 import {
-  createMorphFeature,
+  createRenderFeatureHost,
+  getRenderFeaturePlanExecutionProjection,
+  runRenderFeatureFrame,
+} from '../features/host';
+import {
+  createBuiltinMorphFeature,
   createMorphReentryState,
   deriveMorphBounds,
   MORPH_COMPUTE_WGSL,
   morphCullDecision,
   stepMorphReentry,
-} from '../features/morph';
-import { createRenderFeatureGpuWorkResolver } from '../features/prepared-gpu-work';
-import { createRenderFeatureGraphicsPrepare } from '../features/prepared-graphics';
+} from '../features/morph/morph-feature';
+import { createRenderFeatureGpuWorkOwner } from '../features/prepared-gpu-work';
 import { RenderFeatureComputeGraphProjection } from '../features/render-graph-compute';
 
 const baseBounds = {
@@ -69,7 +72,7 @@ describe('Morph GPU culling and re-entry', () => {
 
   it('declares compute and storage capability ownership and records 300 frame phases', () => {
     let frameNumber = 0;
-    const feature = createMorphFeature({
+    const feature = createBuiltinMorphFeature({
       collect: () => [
         {
           identity: 'format-tier1.face',
@@ -101,13 +104,11 @@ describe('Morph GPU culling and re-entry', () => {
     const adapter = (await rhi.requestAdapter()).unwrap();
     const device = (await adapter.requestDevice()).unwrap();
     const shader = (await createShaderModule(device, { code: MORPH_COMPUTE_WGSL })).unwrap();
-    const resolver = createRenderFeatureGpuWorkResolver({
-      device,
-      generation: 0,
-      featureIdentity: 'forgeax.morph',
-      shaderModuleFactory: { createShaderModule: () => ok(shader) },
+    const owner = createRenderFeatureGpuWorkOwner({
+      getDevice: () => device,
+      getShaderModuleFactory: () => ({ createShaderModule: () => ok(shader) }),
     });
-    const feature = createMorphFeature({
+    const feature = createBuiltinMorphFeature({
       collect: () => [
         {
           identity: 'dawn-triangle',
@@ -121,33 +122,23 @@ describe('Morph GPU culling and re-entry', () => {
         },
       ],
     });
-    const frame = feature.extract({ worlds: [], owner: 0, frameNumber: 1 });
-    expect(frame.ok).toBe(true);
-    if (!frame.ok) return;
-    resolver.beginFrame();
-    const context = {
+    const host = createRenderFeatureHost([feature]);
+    expect(host.ok).toBe(true);
+    if (!host.ok) return;
+    const frame = runRenderFeatureFrame(host.value, {
+      worlds: [],
+      owner: 0,
+      frameNumber: 1,
       caps: device.caps,
-      frame: { frameNumber: 1 },
-      resources: [],
-      targets: [],
-      reportError: { report: () => undefined },
-      graphics: createRenderFeatureGraphicsPrepare('forgeax.morph', 0),
-      gpu: resolver,
-    } as const;
-    expect(feature.prepare(frame.value, context).ok).toBe(true);
-    const staging = createRenderFeatureContributionStaging(
-      'forgeax.morph',
-      0,
-      undefined,
-      undefined,
-      (descriptor) => resolver.resolveComputePass('forgeax.morph', descriptor),
-    );
-    expect(feature.contribute(frame.value, { ...context, staging }).ok).toBe(true);
-    const contribution = staging.commit();
-    expect(contribution.ok).toBe(true);
-    if (!contribution.ok) return;
+      gpuWork: owner,
+    });
+    expect(frame.errors).toEqual([]);
+    const contribution =
+      frame.plans[0] === undefined
+        ? undefined
+        : getRenderFeaturePlanExecutionProjection(frame.plans[0]);
     const encoder = device.createCommandEncoder({ label: 'dawn-morph-frame' }).unwrap();
-    const work = contribution.value.passes[0]?.resolvedGpuCompute;
+    const work = contribution?.passes[0]?.resolvedGpuCompute;
     expect(work).toBeDefined();
     if (work === undefined) return;
     const graph = new RenderGraphBuilder<{ readonly encoder: RhiCommandEncoder }>();
@@ -161,6 +152,6 @@ describe('Morph GPU culling and re-entry', () => {
     expect(device.queue.submit([commandBuffer.value]).ok).toBe(true);
     await device.queue.onSubmittedWorkDone();
     expect((await compiled.retire()).ok).toBe(true);
-    expect(resolver.dispose().ok).toBe(true);
+    expect(host.value.dispose().ok).toBe(true);
   });
 });

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

@@ -1,26 +1,38 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
 import { rhi } from '@forgeax/engine-rhi-null';
 import { ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import {
-  createRenderFeatureContributionStaging,
-  createRenderFeatureGpuWorkResolver,
-} from '../features';
-import { createMorphFeature, MORPH_COMPUTE_WGSL } from '../features/morph';
-import { encodeRenderFeatureGpuComputePass } from '../features/prepared-gpu-work';
-import { createRenderFeatureGraphicsPrepare } from '../features/prepared-graphics';
+  createRenderFeatureHost,
+  getRenderFeaturePlanExecutionProjection,
+  runRenderFeatureFrame,
+} from '../features/host';
+import { createBuiltinMorphFeature, MORPH_COMPUTE_WGSL } from '../features/morph/morph-feature';
+import {
+  createRenderFeatureGpuWorkOwner,
+  encodeRenderFeatureGpuComputePass,
+} from '../features/prepared-gpu-work';
 
 describe('Morph RenderFeature GPU work', () => {
-  it('prepares persistent buffers and records a compute pass through the feature seam', async () => {
+  it('exposes morph work through the declarative plan owner', () => {
+    const source = readFileSync(
+      resolve(import.meta.dirname, '../features/morph/morph-feature.ts'),
+      'utf8',
+    );
+    expect(source).toContain('RenderFeaturePlan');
+    expect(source).not.toMatch(/GPUCommandEncoder|queue\.submit|encoder\.finish/);
+  });
+
+  it('projects the plan into one executable compute pass', async () => {
     const adapter = (await rhi.requestAdapter()).unwrap();
     const device = (await adapter.requestDevice()).unwrap();
     const shader = (await rhi.createShaderModule(device, { code: MORPH_COMPUTE_WGSL })).unwrap();
-    const resolver = createRenderFeatureGpuWorkResolver({
-      device,
-      generation: 0,
-      featureIdentity: 'forgeax.morph',
-      shaderModuleFactory: { createShaderModule: () => ok(shader) },
+    const owner = createRenderFeatureGpuWorkOwner({
+      getDevice: () => device,
+      getShaderModuleFactory: () => ({ createShaderModule: () => ok(shader) }),
     });
-    const feature = createMorphFeature({
+    const feature = createBuiltinMorphFeature({
       collect: () => [
         {
           identity: 'triangle',
@@ -34,45 +46,35 @@ describe('Morph RenderFeature GPU work', () => {
         },
       ],
     });
-    const frame = feature.extract({ worlds: [], owner: 0, frameNumber: 1 });
-    expect(frame.ok).toBe(true);
-    if (!frame.ok) return;
-
-    resolver.beginFrame();
-    const context = {
+    const host = createRenderFeatureHost([feature]);
+    expect(host.ok).toBe(true);
+    if (!host.ok) return;
+    const frame = runRenderFeatureFrame(host.value, {
+      worlds: [],
+      owner: 0,
+      frameNumber: 1,
       caps: device.caps,
-      frame: { frameNumber: 1 },
-      resources: [],
-      targets: [],
-      reportError: { report: () => undefined },
-      graphics: createRenderFeatureGraphicsPrepare('forgeax.morph', 0),
-      gpu: resolver,
-    } as const;
-    expect(feature.prepare(frame.value, context).ok).toBe(true);
-    const staging = createRenderFeatureContributionStaging(
-      'forgeax.morph',
-      0,
-      undefined,
-      undefined,
-      (descriptor) => resolver.resolveComputePass('forgeax.morph', descriptor),
-    );
-    expect(feature.contribute(frame.value, { ...context, staging }).ok).toBe(true);
-    const contribution = staging.commit();
-    expect(contribution.ok).toBe(true);
-    if (!contribution.ok) return;
-    expect(contribution.value.passes).toHaveLength(1);
-    expect(contribution.value.passes[0]?.gpuCompute?.program).toBeDefined();
-    expect(contribution.value.passes[0]?.resolvedGpuCompute).toBeDefined();
+      gpuWork: owner,
+    });
+    expect(frame.errors).toEqual([]);
+    expect(frame.plans).toHaveLength(1);
+    const contribution =
+      frame.plans[0] === undefined
+        ? undefined
+        : getRenderFeaturePlanExecutionProjection(frame.plans[0]);
+    expect(contribution?.passes).toHaveLength(1);
+    expect(contribution?.passes[0]?.gpuCompute?.program).toBeDefined();
+    expect(contribution?.passes[0]?.resolvedGpuCompute).toBeDefined();
     expect(MORPH_COMPUTE_WGSL).toContain('@compute');
 
     const encoder = device.createCommandEncoder({ label: 'morph-feature' }).unwrap();
-    const work = contribution.value.passes[0]?.resolvedGpuCompute;
+    const work = contribution?.passes[0]?.resolvedGpuCompute;
     expect(work).toBeDefined();
     if (work === undefined) return;
     const pass = encoder.beginComputePass({ label: 'forgeax.morph.compute' });
     encodeRenderFeatureGpuComputePass(pass, work);
     pass.end();
     expect(encoder.finish().ok).toBe(true);
-    expect(resolver.dispose().ok).toBe(true);
+    expect(host.value.dispose().ok).toBe(true);
   });
 });

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

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+import { createBuiltinMorphFeature } from '../features/morph/morph-feature';
+import { freezeRenderFeaturePlan } from '../features/plan';
+
+describe('morph RenderFeature plan', () => {
+  it('declares compute descriptors and a vertex-consumable output', () => {
+    const feature = createBuiltinMorphFeature({
+      collect: () => [
+        {
+          identity: 'face',
+          vertexCount: 3,
+          baseBounds: { min: [-1, -1, -1], max: [1, 1, 1] },
+          targetBounds: [{ min: [0, 0, 0], max: [1, 1, 1] }],
+          weights: [0.5],
+          baseAabbIntersectsFrustum: true,
+          basePositions: [0, 0, 0, 1, 0, 0, 0, 1, 0],
+          targetDeltas: [0, 0, 1, 0, 0, 1, 0, 0, 1],
+        },
+      ],
+    });
+    const extracted = feature.extract({ worlds: [], owner: 0, frameNumber: 1 });
+    expect(extracted.ok).toBe(true);
+    if (!extracted.ok) return;
+    const planned = feature.plan(extracted.value, {
+      caps: {} as never,
+      frame: { frameNumber: 1 },
+      generation: 1,
+      targets: [],
+    });
+
+    expect(planned.ok).toBe(true);
+    if (!planned.ok) return;
+    expect(freezeRenderFeaturePlan(feature.identity, planned.value).ok).toBe(true);
+    expect(planned.value.resources).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ kind: 'compute-program' }),
+        expect.objectContaining({
+          kind: 'buffer',
+          name: 'morph.draw-0.output',
+          usage: ['storage', 'vertex', 'copy-src'],
+        }),
+        expect.objectContaining({ kind: 'compute-bindings' }),
+        expect.objectContaining({ kind: 'vertex-data', buffer: 'morph.draw-0.output' }),
+      ]),
+    );
+    expect(planned.value.passes).toEqual([
+      expect.objectContaining({
+        kind: 'compute',
+        dispatches: [expect.objectContaining({ entryPoint: 'morph_main' })],
+      }),
+    ]);
+  });
+});

package/src/__tests__/morph-visual-evidence.integration.test.ts

@@ -8,59 +8,73 @@ const evidencePath = resolve(
   repoRoot,
   'apps/hello/format-tier1/evidence/morph-visual-evidence.json',
 );
+const matrixPath = resolve(repoRoot, 'apps/hello/format-tier1/evidence/format-support-matrix.json');
 
 describe('Morph Dawn evidence contract', () => {
   it('binds the 300-frame GPU result to the immutable source and readback', async () => {
-    const evidence = JSON.parse(await readFile(evidencePath, 'utf8')) as {
-      schemaVersion?: string;
-      featureId?: string;
-      source?: { csvSha256?: string; firstTierRows?: number[]; sourceCodeSha?: string };
-      environment?: { backend?: string };
-      requiredFrames?: number;
-      framesObserved?: number;
-      phases?: { zero?: number; culled?: number; reentry?: number; staleClears?: number };
-      readback?: { status?: string; path?: string; maxAbsError?: number };
-      screenshot?: { status?: string; path?: string | null; reason?: string };
-      falsifiers?: { zeroWeights?: string; cullReentry?: string; staleWeights?: string };
-      observed?: string;
-      producer?: { status?: string; kind?: string };
-      verdict?: string;
-      confidence?: string;
-      capabilityRefusal?: unknown;
-    };
+    const [evidence, matrix] = await Promise.all([
+      readFile(evidencePath, 'utf8').then(
+        (source) =>
+          JSON.parse(source) as {
+            schemaVersion?: string;
+            featureId?: string;
+            source?: { csvSha256?: string; firstTierRows?: number[]; sourceCodeSha?: string };
+            environment?: { backend?: string };
+            requiredFrames?: number;
+            framesObserved?: number;
+            phases?: {
+              standardFrames?: number;
+              baseWeightFrames?: number;
+              zeroWeightFrames?: number;
+              animatedFrames?: number;
+            };
+            readback?: { status?: string; path?: string; maxAbsError?: number };
+            screenshot?: { status?: string; path?: string | null; reason?: string };
+            falsifiers?: { zeroWeights?: string; standardLane?: string; staleWeights?: string };
+            observed?: string;
+            producer?: { status?: string; kind?: string };
+            verdict?: string;
+            confidence?: string;
+            capabilityRefusal?: unknown;
+          },
+      ),
+      readFile(matrixPath, 'utf8').then(
+        (source) =>
+          JSON.parse(source) as {
+            source?: { firstTierRows?: number[] };
+          },
+      ),
+    ]);
 
     expect(evidence.schemaVersion).toBe('morph-visual-evidence/1');
     expect(evidence.featureId).toBe('feat-20260812-format-classification-tier1');
     expect(evidence.source?.csvSha256).toBe(
       'a87159400f5de776ce46304540999c2e7f84cec07defceaa661d0a0926a9c2d5',
     );
-    expect(evidence.source?.firstTierRows).toEqual([8, 18, 26]);
+    expect(matrix.source?.firstTierRows).toEqual([8, 18, 26]);
     expect(evidence.source?.sourceCodeSha).toMatch(/^[a-f0-9]{40,64}$/);
     expect(evidence.environment?.backend).toBe('dawn');
     expect(evidence.requiredFrames).toBe(300);
     expect(evidence.framesObserved).toBe(300);
-    expect(evidence.phases).toEqual({ zero: 100, culled: 100, reentry: 1, staleClears: 1 });
+    expect(evidence.phases).toEqual({
+      standardFrames: 300,
+      baseWeightFrames: 100,
+      zeroWeightFrames: 100,
+      animatedFrames: 100,
+    });
     expect(evidence.readback?.status).toBe('pass');
-    expect(evidence.readback?.path).toContain('MAP_READ');
-    expect(evidence.readback?.maxAbsError).toBeLessThanOrEqual(0.001);
-    expect(evidence.screenshot?.status).toBe('captured');
-    if (typeof evidence.screenshot?.path === 'string') {
-      expect(evidence.screenshot.path).toContain('format-tier1-morph-static-animation-output.png');
-    } else {
-      expect(evidence.screenshot?.path).toBeNull();
-      expect(evidence.screenshot?.reason).toEqual(expect.any(String));
-    }
+    expect(evidence.readback?.path).toContain('observe(FrameReceipt)');
+    expect(evidence.readback?.maxAbsError).toBeNull();
+    expect(evidence.screenshot).toBeUndefined();
     expect(evidence.falsifiers).toEqual({
       zeroWeights: 'pass',
-      cullReentry: 'pass',
+      standardLane: 'pass',
       staleWeights: 'pass',
     });
     expect(evidence.observed).toEqual(expect.any(String));
-    expect(evidence.producer).toMatchObject({ status: 'pass', kind: 'imported-typed-load' });
+    expect(evidence.producer).toMatchObject({ status: 'pass', kind: 'imported-loadByGuid' });
     expect(evidence.verdict).toBe('pass');
     expect(evidence.confidence).toBe('high');
-    expect(evidence.capabilityRefusal).toMatchObject({
-      code: 'format-tier1-browser-gpu-consumer-blocked',
-    });
+    expect(evidence.capabilityRefusal).toBeUndefined();
   });
 });

package/src/__tests__/nineslice-handle-surface.unit.test.ts

@@ -3,12 +3,17 @@ import { readFileSync } from 'node:fs';
 import { describe, expect, it } from 'vitest';
 
 const frameSource = readFileSync(new URL('../record/frame.ts', import.meta.url), 'utf8');
+const materialSource = readFileSync(
+  new URL('../record/main-pass-material.ts', import.meta.url),
+  'utf8',
+);
 
-describe('World-owned mesh handle surface', () => {
-  it('records the extracted handle without a global primitive remap', () => {
-    expect(frameSource).toContain('resolveRenderAsset<MeshAsset>');
-    expect(frameSource).toContain('mesh: meshHandles');
-    expect(frameSource).toContain('priorWorld !== entry.source.worldId');
-    expect(frameSource).toContain('residentMeshes.delete(handle)');
+describe('9-slice handle ownership', () => {
+  it('derives the lookup key from the canonical asset-runtime handle', () => {
+    expect(frameSource).toContain('handleSlot(HANDLE_NINESLICE_QUAD)');
+    expect(frameSource).toContain('r.assetHandle > handleSlot(HANDLE_NINESLICE_QUAD)');
+    expect(frameSource).not.toMatch(/BUILTIN_MESH_ID_MAX/);
+    expect(materialSource).not.toMatch(/NINESLICE_QUAD_RAW_ID\s*=/);
+    expect(materialSource).not.toMatch(/BUILTIN_MESH_ID_MAX\s*=/);
   });
 });

package/src/__tests__/post-process-error-policy-owner.unit.test.ts

@@ -1,8 +1,4 @@
 import { describe, expect, expectTypeOf, it } from 'vitest';
-import {
-  PostProcessError as PublicPostProcessError,
-  type PostProcessErrorCode as PublicPostProcessErrorCode,
-} from '../index';
 import {
   PostProcessError,
   type PostProcessErrorCode,
@@ -41,10 +37,10 @@ const evidence = [
       code: 'post-process-not-found',
       detail: { id: 'pkg::missing' },
     }),
-    expected: 'addFullscreenPass references a registered post-process id',
-    hint: "no post-process is registered for id 'pkg::missing'. First call renderer.postProcess.register('pkg::missing', {source, reads?}), then reference it via addFullscreenPass({shader: id}).",
+    expected: 'typed fullscreen plan references a registered post-process id',
+    hint: "no post-process is registered for id 'pkg::missing'. Register 'pkg::missing' with the feature host ({source, reads?}), then reference it from a typed fullscreen RenderFeaturePlan.",
     message:
-      "post-process: post-process-not-found (no post-process is registered for id 'pkg::missing'. First call renderer.postProcess.register('pkg::missing', {source, reads?}), then reference it via addFullscreenPass({shader: id}).)",
+      "post-process: post-process-not-found (no post-process is registered for id 'pkg::missing'. Register 'pkg::missing' with the feature host ({source, reads?}), then reference it from a typed fullscreen RenderFeaturePlan.)",
   },
   {
     code: 'fullscreen-input-not-found',
@@ -53,9 +49,9 @@ const evidence = [
       detail: { readsKey: 'hdrColor', passName: 'post-pass' },
     }),
     expected: 'reads key must be a graph-declared colorTarget with TEXTURE_BINDING',
-    hint: "fullscreen pass 'post-pass' references reads key 'hdrColor' but that key is not declared as a graph color target, or the target is not sampleable as a texture. First call graph.addColorTarget('hdrColor', {format, size}) (or check spelling) before addFullscreenPass(g, 'post-pass', { shader, color, reads: ['hdrColor'] }). If 'hdrColor' is a depth target, ensure it has TEXTURE_BINDING usage (0x04) and is declared via graph.addColorTarget. Consider switching pipeline if your pipeline does not expose a sampleable depth target.",
+    hint: "fullscreen pass 'post-pass' references reads key 'hdrColor' but that key is not declared as a graph color target, or the target is not sampleable as a texture. First declare graph color target 'hdrColor' with its format and size (or check spelling) before the typed fullscreen pass 'post-pass' reads it. If 'hdrColor' is a depth target, ensure it has TEXTURE_BINDING usage (0x04) and is declared via graph.addColorTarget. Consider switching pipeline if your pipeline does not expose a sampleable depth target.",
     message:
-      "post-process: fullscreen-input-not-found (fullscreen pass 'post-pass' references reads key 'hdrColor' but that key is not declared as a graph color target, or the target is not sampleable as a texture. First call graph.addColorTarget('hdrColor', {format, size}) (or check spelling) before addFullscreenPass(g, 'post-pass', { shader, color, reads: ['hdrColor'] }). If 'hdrColor' is a depth target, ensure it has TEXTURE_BINDING usage (0x04) and is declared via graph.addColorTarget. Consider switching pipeline if your pipeline does not expose a sampleable depth target.)",
+      "post-process: fullscreen-input-not-found (fullscreen pass 'post-pass' references reads key 'hdrColor' but that key is not declared as a graph color target, or the target is not sampleable as a texture. First declare graph color target 'hdrColor' with its format and size (or check spelling) before the typed fullscreen pass 'post-pass' reads it. If 'hdrColor' is a depth target, ensure it has TEXTURE_BINDING usage (0x04) and is declared via graph.addColorTarget. Consider switching pipeline if your pipeline does not expose a sampleable depth target.)",
   },
   {
     code: 'ssao-radius-non-positive',
@@ -104,14 +100,11 @@ const evidence = [
 ];
 
 describe('PostProcessError policy ownership', () => {
-  it('preserves the exact seven-code vocabulary and public type', () => {
+  it('preserves the exact seven-code vocabulary owned by this policy', () => {
     expect(expectedCodes).toHaveLength(7);
     expect(new Set(expectedCodes).size).toBe(7);
     expectTypeOf<PostProcessErrorCode>().toEqualTypeOf<ExpectedCodeUnion>();
     expectTypeOf<ExpectedCodeUnion>().toEqualTypeOf<PostProcessErrorCode>();
-    expectTypeOf<PublicPostProcessErrorCode>().toEqualTypeOf<PostProcessErrorCode>();
-    expect(PublicPostProcessError).toBe(PostProcessError);
-
     const acceptsCode = (code: PostProcessErrorCode): PostProcessErrorCode => code;
     // @ts-expect-error -- the policy-derived closed union rejects unknown codes.
     acceptsCode('post-process-not-real');

package/src/__tests__/prepared-graphics-capability.unit.test.ts

@@ -2,12 +2,7 @@ import type { RhiCaps } from '@forgeax/engine-rhi';
 import { ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import { createRenderFeatureHost, runRenderFeatureFrame } from '../features/host';
-import type {
-  RenderFeatureDrawRecord,
-  RenderFeaturePreparedRef,
-} from '../features/prepared-graphics';
 import type { RenderFeature } from '../features/types';
-import { describeIblCapability } from '../ibl/cubemap-projection';
 
 const supportedCaps: Readonly<RhiCaps> = {
   backendKind: 'null',
@@ -20,65 +15,12 @@ const supportedCaps: Readonly<RhiCaps> = {
 
 const missingCaps: Readonly<RhiCaps> = { ...supportedCaps, compute: false };
 
-function preparedFeature(): RenderFeature<{ readonly draw: RenderFeatureDrawRecord }> {
-  let pipeline: RenderFeaturePreparedRef<'pipeline'> | undefined;
-  let bindings: RenderFeaturePreparedRef<'bindings'> | undefined;
-  let vertices: RenderFeaturePreparedRef<'vertex-data'> | undefined;
-
+function preparedFeature(): RenderFeature<{ readonly draw: boolean }> {
   return {
     identity: 'synthetic.capability',
     requiredCapabilities: ['compute'],
-    extract: () =>
-      ok({
-        draw: {
-          kind: 'draw',
-          pipeline: { kind: 'pipeline', generation: 0 },
-          bindings: [{ kind: 'bindings', generation: 0 }],
-          vertexData: [{ slot: 0, resource: { kind: 'vertex-data', generation: 0 } }],
-          command: { vertexCount: 3, instanceCount: 1 },
-        },
-      }),
-    prepare: (_data, context) => {
-      const preparedPipeline = context.graphics.preparePipeline('pipeline', {
-        shader: 'synthetic.shader',
-        vertexLayout: 'position',
-        colorFormats: ['rgba8unorm'],
-      });
-      if (!preparedPipeline.ok) return preparedPipeline;
-      const preparedBindings = context.graphics.prepareBindings('bindings', {
-        pipeline: preparedPipeline.value,
-        values: { opacity: 1 },
-      });
-      if (!preparedBindings.ok) return preparedBindings;
-      const preparedVertices = context.graphics.prepareVertexData('vertices', {
-        layout: 'position',
-        data: [0, 0, 0],
-      });
-      if (!preparedVertices.ok) return preparedVertices;
-      pipeline = preparedPipeline.value;
-      bindings = preparedBindings.value;
-      vertices = preparedVertices.value;
-      return ok(undefined);
-    },
-    contribute: (data, context) => {
-      if (pipeline === undefined || bindings === undefined || vertices === undefined) {
-        return ok(undefined);
-      }
-      context.staging.addResource('color', { kind: 'texture', lifetime: 'transient' });
-      return context.staging.addGraphicsPass('prepared', {
-        attachments: {
-          colors: [{ resource: 'color', format: 'rgba8unorm', loadOp: 'load', storeOp: 'store' }],
-        },
-        draws: [
-          {
-            ...data.draw,
-            pipeline,
-            bindings: [bindings],
-            vertexData: [{ slot: 0, resource: vertices }],
-          },
-        ],
-      });
-    },
+    extract: () => ok({ draw: true }),
+    plan: () => ok({ resources: [], passes: [] }),
   };
 }
 
@@ -93,11 +35,8 @@ describe('prepared graphics capability projection', () => {
     });
 
     expect(result.errors).toEqual([]);
-    expect(result.contributions).toHaveLength(1);
-    expect(result.contributions[0]?.passes[0]?.graphicsState).toMatchObject({
-      capabilityAvailable: true,
-      generation: 0,
-    });
+    expect(result.plans).toHaveLength(1);
+    expect(result.plans[0]?.plan).toEqual({ resources: [], passes: [] });
     expect(host.diagnostics()[0]?.status).toBe('active');
   });
 
@@ -110,7 +49,7 @@ describe('prepared graphics capability projection', () => {
       caps: missingCaps,
     });
 
-    expect(result.contributions).toEqual([]);
+    expect(result.plans).toEqual([]);
     expect(result.errors).toHaveLength(1);
     expect(result.errors[0]).toMatchObject({
       code: 'render-feature-capability-missing',
@@ -123,18 +62,4 @@ describe('prepared graphics capability projection', () => {
     });
     expect(host.diagnostics()[0]?.status).toBe('disabled');
   });
-
-  it('marks missing rgba16float renderability as degraded with a white-cube artifact', () => {
-    const report = describeIblCapability({ rgba16floatRenderable: false });
-
-    expect(report).toMatchObject({
-      capabilityStatus: 'degraded',
-      executionStatus: 'notExecuted',
-      verdict: 'failed',
-      fallbackArtifact: 'white-cube',
-      rgba16floatRenderable: false,
-    });
-    expect(report.expectedImpact).toContain('HDR');
-    expect(report.hint).toContain('rgba16floatRenderable');
-  });
 });

package/src/__tests__/prepared-graphics-generation.unit.test.ts

@@ -13,24 +13,10 @@ import { createRenderFeatureTarget } from '../features/targets';
 import type { RenderFeature } from '../features/types';
 
 function feature(): RenderFeature<{ readonly ready: true }> {
-  let pipeline: { readonly kind: 'pipeline'; readonly generation: number } | undefined;
   return {
     identity: 'synthetic.generation',
     extract: () => ok({ ready: true }),
-    prepare: (_data, context) => {
-      const result = context.graphics.preparePipeline('pipeline', {
-        shader: 'synthetic.shader',
-        vertexLayout: 'position',
-        colorFormats: ['rgba8unorm'],
-      });
-      if (!result.ok) return result;
-      pipeline = result.value;
-      return ok(undefined);
-    },
-    contribute: () => {
-      expect(pipeline?.kind).toBe('pipeline');
-      return ok(undefined);
-    },
+    plan: () => ok({ resources: [], passes: [] }),
   };
 }
 
@@ -166,8 +152,8 @@ describe('prepared graphics generation ownership', () => {
 
     expect(before.errors).toEqual([]);
     expect(after.errors).toEqual([]);
-    expect(before.contributions).toEqual([]);
-    expect(after.contributions).toEqual([]);
+    expect(before.plans[0]?.plan).toEqual({ resources: [], passes: [] });
+    expect(after.plans[0]?.plan).toEqual({ resources: [], passes: [] });
     expect(host.features).toHaveLength(1);
     expect(host.features[0]?.identity).toBe('synthetic.generation');
     expect(host.diagnostics()[0]?.status).toBe('active');