@forgeax/engine-render 0.1.4 → 0.1.6

package/src/__tests__/render-feature-prepared-graphics.test-d.ts

@@ -1,11 +1,6 @@
 import { ok } from '@forgeax/engine-types';
-import type {
-  PreparedKind,
-  RenderFeature,
-  RenderFeatureDrawRecord,
-  RenderFeatureGraphicsPassDescriptor,
-  RenderFeaturePreparedRef,
-} from '../index';
+import type { RenderFeatureDrawDeclaration } from '../features/plan';
+import type { RenderFeature, RenderFeaturePlan, RenderFeatureResourceDeclaration } from '../index';
 
 interface Frame {
   readonly vertexCount: number;
@@ -15,81 +10,64 @@ interface Frame {
 const feature = {
   identity: 'prepared.graphics.positive',
   extract: () => ok<Frame>({ vertexCount: 6, indexCount: 6 }),
-  prepare(data, context) {
-    const pipeline = context.graphics.preparePipeline('forward', {
-      shader: 'unlit',
-      vertexLayout: 'position',
-      colorFormats: ['rgba8unorm'],
-    });
-    if (!pipeline.ok) return pipeline;
-
-    const bindings = context.graphics.prepareBindings('forward', {
-      pipeline: pipeline.value,
-      values: { opacity: 1 },
-    });
-    if (!bindings.ok) return bindings;
-
-    const vertices = context.graphics.prepareVertexData('quad', {
-      layout: 'position',
-      data: new Float32Array(data.vertexCount),
-    });
-    if (!vertices.ok) return vertices;
-
-    const indices = context.graphics.prepareIndexData('quad', {
-      format: 'uint16',
-      data: new Uint16Array(data.indexCount),
-    });
-    if (!indices.ok) return indices;
-
-    const refs: readonly RenderFeaturePreparedRef<PreparedKind>[] = [
-      pipeline.value,
-      bindings.value,
-      vertices.value,
-      indices.value,
+  plan(data, context) {
+    const target = context.targets.find((candidate) => candidate.kind === 'color');
+    const resources: readonly RenderFeatureResourceDeclaration[] = [
+      {
+        kind: 'graphics-program',
+        name: 'forward-program',
+        program: {
+          shader: 'unlit',
+          vertexLayout: 'position',
+          colorFormats: [target?.format ?? 'rgba8unorm'],
+        },
+      },
+      {
+        kind: 'graphics-bindings',
+        name: 'forward-bindings',
+        program: 'forward-program',
+        values: { opacity: 1 },
+      },
+      {
+        kind: 'vertex-data',
+        name: 'quad-vertices',
+        layout: 'position',
+        data: new Float32Array(data.vertexCount),
+      },
+      {
+        kind: 'index-data',
+        name: 'quad-indices',
+        format: 'uint16',
+        data: new Uint16Array(data.indexCount),
+      },
     ];
-    void refs;
-    return ok(undefined);
-  },
-  contribute(data, context) {
-    const pipeline: RenderFeaturePreparedRef<'pipeline'> = {
-      kind: 'pipeline',
-      generation: 1,
-    };
-    const bindings: RenderFeaturePreparedRef<'bindings'> = {
-      kind: 'bindings',
-      generation: 1,
+    const vertexOnly: RenderFeatureDrawDeclaration = {
+      program: 'forward-program',
+      bindings: ['forward-bindings'],
+      vertexData: [{ slot: 0, resource: 'quad-vertices' }],
+      draw: { kind: 'draw', vertexCount: data.vertexCount, instanceCount: 1 },
     };
-    const vertices: RenderFeaturePreparedRef<'vertex-data'> = {
-      kind: 'vertex-data',
-      generation: 1,
+    const indexed: RenderFeatureDrawDeclaration = {
+      program: 'forward-program',
+      bindings: ['forward-bindings'],
+      vertexData: [{ slot: 0, resource: 'quad-vertices' }],
+      indexData: { resource: 'quad-indices', format: 'uint16' },
+      draw: { kind: 'draw-indexed', indexCount: data.indexCount, instanceCount: 1 },
     };
-    const indices: RenderFeaturePreparedRef<'index-data'> = {
-      kind: 'index-data',
-      generation: 1,
-    };
-
-    const vertexOnly: RenderFeatureDrawRecord = {
-      kind: 'draw',
-      pipeline,
-      bindings: [bindings],
-      vertexData: [{ slot: 0, resource: vertices }],
-      command: { vertexCount: data.vertexCount, instanceCount: 1 },
-    };
-    const indexed: RenderFeatureDrawRecord = {
-      kind: 'draw-indexed',
-      pipeline,
-      bindings: [bindings],
-      vertexData: [{ slot: 0, resource: vertices }],
-      indexData: { resource: indices, format: 'uint16' },
-      command: { indexCount: data.indexCount, instanceCount: 1 },
-    };
-    const pass: RenderFeatureGraphicsPassDescriptor = {
-      attachments: {
-        colors: [{ resource: 'color', format: 'rgba8unorm', loadOp: 'load', storeOp: 'store' }],
-      },
-      draws: [vertexOnly, indexed],
+    const plan: RenderFeaturePlan = {
+      resources,
+      passes: [
+        {
+          kind: 'raster',
+          name: 'forward',
+          colorAttachments: [
+            { target: target?.name ?? 'swapchain', loadOp: 'load', storeOp: 'store' },
+          ],
+          draws: [vertexOnly, indexed],
+        },
+      ],
     };
-    return context.staging.addGraphicsPass('forward', pass);
+    return ok(plan);
   },
 } satisfies RenderFeature<Frame>;
 

package/src/__tests__/render-feature-public-surface.test-d.ts

@@ -1,14 +1,10 @@
 import type {
   RenderError,
-  Renderer,
-  RendererOptions,
   RenderFeature,
-  RenderFeatureContributeContext,
-  RenderFeatureDiagnostics,
   RenderFeatureErrorDescriptor,
   RenderFeatureExtractContext,
-  RenderFeaturePassContext,
-  RenderFeaturePrepareContext,
+  RenderFeaturePlan,
+  RenderFeaturePlanContext,
 } from '@forgeax/engine-render';
 import { ok } from '@forgeax/engine-types';
 
@@ -22,25 +18,16 @@ const feature = {
     const owner: number = context.owner;
     return ok<FrameData>({ visibleCount: owner });
   },
-  prepare(data: FrameData, context: RenderFeaturePrepareContext) {
+  plan(data: FrameData, context: RenderFeaturePlanContext) {
     const count: number = data.visibleCount;
     const frameNumber: number = context.frame.frameNumber;
+    const plan: RenderFeaturePlan = { resources: [], passes: [] };
     void count;
     void frameNumber;
-    return ok(undefined);
-  },
-  contribute(data: FrameData, context: RenderFeatureContributeContext) {
-    const count: number = data.visibleCount;
-    void count;
-    void context.staging;
-    return ok(undefined);
+    return ok(plan);
   },
 } satisfies RenderFeature<FrameData>;
 
-const options: RendererOptions = { features: [feature] };
-const diagnostics = (renderer: Renderer): readonly RenderFeatureDiagnostics[] =>
-  renderer.renderFeatureDiagnostics();
-
 const errorDescriptor = (error: RenderError): RenderFeatureErrorDescriptor | undefined => {
   switch (error.code) {
     case 'render-feature-registration-conflict':
@@ -56,13 +43,8 @@ const errorDescriptor = (error: RenderError): RenderFeatureErrorDescriptor | und
   }
 };
 
-const passContext = (context: RenderFeaturePassContext): number => context.frame.frameNumber;
-// @ts-expect-error Wave1 pass execution does not expose incomplete GPU draw state
-passContext.commands;
 void errorDescriptor;
-void options;
-void diagnostics;
-void passContext;
+void feature;
 
 // The renderer host and construction context are internal implementation seams.
 // @ts-expect-error host internals are not part of the render root surface

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

@@ -3,7 +3,7 @@ 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, RenderFeatureResourceHandle } from '../features/types';
+import type { RenderFeature } from '../features/types';
 
 const caps = (compute: boolean): Readonly<RhiCaps> => ({ compute }) as unknown as RhiCaps;
 
@@ -13,16 +13,13 @@ describe('render feature retry rules', () => {
     const feature: RenderFeature<{ readonly frame: number }> = {
       identity: 'synthetic.retry',
       extract: ({ frameNumber }) => ok({ frame: frameNumber }),
-      prepare: () => {
+      plan: () => {
         attempts += 1;
         if (attempts === 1) {
-          return err(
-            new RenderFeatureStageFailedError('synthetic.retry', 0, 'prepare', 'next-frame'),
-          );
+          return err(new RenderFeatureStageFailedError('synthetic.retry', 0, 'plan', 'next-frame'));
         }
-        return ok(undefined);
+        return ok({ resources: [], passes: [] });
       },
-      contribute: () => ok(undefined),
     };
     const host = createRenderFeatureHost([feature], caps(true)).unwrap();
 
@@ -37,7 +34,7 @@ describe('render feature retry rules', () => {
     if (error?.code === 'render-feature-stage-failed') {
       expect(error.detail).toMatchObject({
         featureIdentity: 'synthetic.retry',
-        stage: 'prepare',
+        stage: 'plan',
         recovery: 'next-frame',
       });
     }
@@ -58,8 +55,7 @@ describe('render feature retry rules', () => {
       identity: 'synthetic.capability-retry',
       requiredCapabilities: ['compute'],
       extract: ({ frameNumber }) => ok({ frame: frameNumber }),
-      prepare: () => ok(undefined),
-      contribute: () => ok(undefined),
+      plan: () => ok({ resources: [], passes: [] }),
     };
     const host = createRenderFeatureHost([feature], caps(false)).unwrap();
 
@@ -86,43 +82,6 @@ describe('render feature retry rules', () => {
         frameNumber: 3,
         caps: caps(true),
       }).stageEvents,
-    ).toHaveLength(3);
-  });
-
-  it('does not release a feature-owned resource during retry or diagnostics', () => {
-    let releaseCount = 0;
-    const feature: RenderFeature<{ readonly frame: number }> = {
-      identity: 'synthetic.release-once',
-      extract: ({ frameNumber }) => ok({ frame: frameNumber }),
-      prepare: () => ok(undefined),
-      contribute: () => ok(undefined),
-    };
-    const host = createRenderFeatureHost([feature], caps(true)).unwrap();
-    host.registerResource('synthetic.release-once', {
-      handle: { __renderFeatureResource: Symbol('release-once') } as RenderFeatureResourceHandle,
-      release: () => {
-        releaseCount += 1;
-        return ok(undefined);
-      },
-    });
-
-    runRenderFeatureFrame(host, {
-      worlds: [],
-      owner: 0,
-      frameNumber: 1,
-      caps: caps(true),
-    });
-    host.diagnostics();
-    host.diagnostics();
-    runRenderFeatureFrame(host, {
-      worlds: [],
-      owner: 0,
-      frameNumber: 2,
-      caps: caps(true),
-    });
-    expect(releaseCount).toBe(0);
-    expect(host.dispose()).toEqual(ok(undefined));
-    expect(host.dispose()).toEqual(ok(undefined));
-    expect(releaseCount).toBe(1);
+    ).toHaveLength(2);
   });
 });

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

@@ -27,11 +27,7 @@ const caps = {
   maxColorAttachments: 8,
 } satisfies RhiCaps;
 
-function feature(
-  identity: string,
-  events: string[],
-  failStage?: 'extract' | 'prepare' | 'contribute',
-) {
+function feature(identity: string, events: string[], failStage?: 'extract' | 'plan') {
   const value = { identity };
   return {
     identity,
@@ -41,17 +37,11 @@ function feature(
         ? err(new RenderFeatureStageFailedError(identity, 0, 'extract', 'next-frame'))
         : ok(value);
     },
-    prepare: () => {
-      events.push(`${identity}:prepare`);
-      return failStage === 'prepare'
-        ? err(new RenderFeatureStageFailedError(identity, 0, 'prepare', 'next-frame'))
-        : ok(undefined);
-    },
-    contribute: () => {
-      events.push(`${identity}:contribute`);
-      return failStage === 'contribute'
-        ? err(new RenderFeatureStageFailedError(identity, 0, 'contribute', 'next-frame'))
-        : ok(undefined);
+    plan: () => {
+      events.push(`${identity}:plan`);
+      return failStage === 'plan'
+        ? err(new RenderFeatureStageFailedError(identity, 0, 'plan', 'next-frame'))
+        : ok({ resources: [], passes: [] });
     },
   } satisfies RenderFeature<typeof value>;
 }
@@ -71,20 +61,19 @@ describe('render feature stage scheduling', () => {
       caps,
     });
 
-    expect(result.events).toEqual([
+    expect(
+      result.stageEvents.map(({ featureIdentity, stage }) => `${featureIdentity}:${stage}`),
+    ).toEqual([
       'synthetic.first:extract',
-      'synthetic.first:prepare',
-      'synthetic.first:contribute',
+      'synthetic.first:plan',
       'synthetic.second:extract',
-      'synthetic.second:prepare',
-      'synthetic.second:contribute',
+      'synthetic.second:plan',
     ]);
   });
 
   it.each([
     'extract',
-    'prepare',
-    'contribute',
+    'plan',
   ] as const)('isolates a %s failure from the healthy feature', (failStage) => {
     const events: string[] = [];
     const host = createRenderFeatureHost([
@@ -109,12 +98,11 @@ describe('render feature stage scheduling', () => {
       });
     }
     expect(events).toContain('synthetic.healthy:extract');
-    expect(events).toContain('synthetic.healthy:prepare');
-    expect(events).toContain('synthetic.healthy:contribute');
+    expect(events).toContain('synthetic.healthy:plan');
     const failedEvents = events.filter((event) => event.startsWith('synthetic.failed:'));
-    const failedStageIndex = ['extract', 'prepare', 'contribute'].indexOf(failStage);
+    const failedStageIndex = ['extract', 'plan'].indexOf(failStage);
     expect(failedEvents).toEqual(
-      ['extract', 'prepare', 'contribute']
+      ['extract', 'plan']
         .slice(0, failedStageIndex + 1)
         .map((stage) => `synthetic.failed:${stage}`),
     );

package/src/__tests__/render-feature-stage-failed-policy-owner.unit.test.ts

@@ -6,8 +6,6 @@ import type {
   RenderFeatureStage,
   RenderFeatureStageFailedDetail,
 } from '../features/types';
-import { RenderFeatureStageFailedError as PublicRenderFeatureStageFailedError } from '../index';
-import { RenderFeatureStageFailedError as InternalRenderFeatureStageFailedError } from '../internal';
 
 const evidence = [
   {
@@ -48,11 +46,6 @@ const evidence = [
 }[];
 
 describe('RenderFeatureStageFailedError policy ownership', () => {
-  it('keeps one owner for direct, public, and internal constructors', () => {
-    expect(PublicRenderFeatureStageFailedError).toBe(RenderFeatureStageFailedError);
-    expect(InternalRenderFeatureStageFailedError).toBe(RenderFeatureStageFailedError);
-  });
-
   it('preserves every recovery diagnostic and its type correlation', () => {
     expect(evidence.map(({ recovery }) => recovery)).toEqual([
       'next-frame',
@@ -106,8 +99,6 @@ describe('RenderFeatureStageFailedError policy ownership', () => {
 
     expect(error).toBeInstanceOf(Error);
     expect(error).toBeInstanceOf(RenderFeatureStageFailedError);
-    expect(error).toBeInstanceOf(PublicRenderFeatureStageFailedError);
-    expect(error).toBeInstanceOf(InternalRenderFeatureStageFailedError);
     expect(error.name).toBe('RenderFeatureStageFailedError');
     expect(typeof error.stack).toBe('string');
     expect(error.stack).toContain(`RenderFeatureStageFailedError: ${error.message}`);

package/src/__tests__/render-feature-stage-fault-recovery.unit.test.ts

@@ -1,4 +1,4 @@
-import type { RhiCaps, RhiDevice } from '@forgeax/engine-rhi';
+import type { RhiCaps } from '@forgeax/engine-rhi';
 import { err, ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import {
@@ -13,46 +13,39 @@ import {
   runRenderFeatureFrame,
 } from '../features/host';
 import type { RenderFeature } from '../features/types';
-import { createPreparedGraphicsResolver } from '../prepare/prepared-graphics-resolver';
-import { recordResolvedRenderFeatureGraphicsPass } from '../record/frame-targets';
 
 const caps = { backendKind: 'null' } as unknown as Readonly<RhiCaps>;
 
 type Fault = 'create' | 'prepared-resource' | 'draw-recording';
 
-function healthyFeature(probe: { prepare: number; contribute: number }): RenderFeature<{
+function healthyFeature(probe: { plan: number }): RenderFeature<{
   readonly ready: true;
 }> {
   return {
     identity: 'synthetic.m10.healthy',
     extract: () => ok({ ready: true }),
-    prepare: () => {
-      probe.prepare += 1;
-      return ok(undefined);
-    },
-    contribute: (_data, context) => {
-      probe.contribute += 1;
-      context.staging.addResource('target', { kind: 'texture', lifetime: 'transient' });
-      return context.staging.addPass('pass', { reads: [], writes: ['target'] });
+    plan: () => {
+      probe.plan += 1;
+      return ok({ resources: [], passes: [] });
     },
   };
 }
 
 function faultyFeature(
   fault: Fault,
-  probe: { prepare: number; contribute: number },
+  probe: { plan: number },
 ): { readonly feature: RenderFeature<{ readonly ready: true }>; readonly repair: () => void } {
   let repaired = false;
   const identity = `synthetic.m10.${fault}`;
   const failure = (): RenderError => {
     switch (fault) {
       case 'create':
-        return new RenderFeatureStageFailedError(identity, 1, 'prepare', 'next-frame');
+        return new RenderFeatureStageFailedError(identity, 1, 'plan', 'next-frame');
       case 'prepared-resource':
         return new RenderFeaturePreparationFailedError(
           identity,
           1,
-          'prepareVertexData',
+          'planVertexData',
           'vertex-data',
           `${identity}::triangle`,
           'backend-upload-failed',
@@ -62,7 +55,7 @@ function faultyFeature(
         return new RenderFeatureDrawRecordingFailedError(
           identity,
           1,
-          'recordDraw',
+          'planDraw',
           'vertex-data',
           'backend-recording-failed',
           'synthetic backend rejected setVertexBuffer',
@@ -74,16 +67,10 @@ function faultyFeature(
     feature: {
       identity,
       extract: () => ok({ ready: true }),
-      prepare: () => {
-        probe.prepare += 1;
-        if (!repaired && fault !== 'draw-recording') return err(failure());
-        return ok(undefined);
-      },
-      contribute: (_data, context) => {
-        probe.contribute += 1;
-        if (!repaired && fault === 'draw-recording') return err(failure());
-        context.staging.addResource('target', { kind: 'texture', lifetime: 'transient' });
-        return context.staging.addPass('pass', { reads: [], writes: ['target'] });
+      plan: () => {
+        probe.plan += 1;
+        if (!repaired) return err(failure());
+        return ok({ resources: [], passes: [] });
       },
     },
     repair: () => {
@@ -107,20 +94,11 @@ describe('RenderFeature stage fault recovery lifecycle', () => {
     'prepared-resource',
     'draw-recording',
   ])('keeps a healthy sibling visible and clears feature-local %s diagnostics after repair', (fault) => {
-    const healthyProbe = { prepare: 0, contribute: 0 };
-    const faultyProbe = { prepare: 0, contribute: 0 };
+    const healthyProbe = { plan: 0 };
+    const faultyProbe = { plan: 0 };
     const faulty = faultyFeature(fault, faultyProbe);
     const healthy = healthyFeature(healthyProbe);
     const host = createRenderFeatureHost([healthy, faulty.feature], caps).unwrap();
-    let releaseCount = 0;
-    host.registerResource(`synthetic.m10.${fault}`, {
-      handle: { __renderFeatureResource: Symbol(fault) } as never,
-      release: () => {
-        releaseCount += 1;
-        return ok(undefined);
-      },
-    });
-
     const first = frame(host, 1);
     const firstError = first.errors.find((error) => {
       switch (error.code) {
@@ -143,9 +121,7 @@ describe('RenderFeature stage fault recovery lifecycle', () => {
       detail: { featureIdentity: `synthetic.m10.${fault}`, order: 1 },
     });
     expect(firstError?.hint.length).toBeGreaterThan(0);
-    expect(first.contributions.map((entry) => entry.featureIdentity)).toEqual([
-      'synthetic.m10.healthy',
-    ]);
+    expect(first.plans.map((entry) => entry.featureIdentity)).toEqual(['synthetic.m10.healthy']);
     expect(host.diagnostics().map((entry) => entry.status)).toEqual(['active', 'failed']);
     expect(host.diagnostics()[1]?.latestError).toMatchObject({
       detail: { featureIdentity: `synthetic.m10.${fault}` },
@@ -154,83 +130,17 @@ describe('RenderFeature stage fault recovery lifecycle', () => {
     faulty.repair();
     const second = frame(host, 2);
     expect(second.errors).toEqual([]);
-    expect(second.contributions.map((entry) => entry.featureIdentity)).toEqual([
+    expect(second.plans.map((entry) => entry.featureIdentity)).toEqual([
       'synthetic.m10.healthy',
       `synthetic.m10.${fault}`,
     ]);
     expect(host.diagnostics().map((entry) => entry.status)).toEqual(['active', 'active']);
     expect(host.diagnostics()[1]?.latestError).toBeUndefined();
-    expect(healthyProbe.contribute).toBe(2);
-    expect(faultyProbe.prepare).toBe(2);
-    expect(faultyProbe.contribute).toBe(fault === 'draw-recording' ? 2 : 1);
+    expect(healthyProbe.plan).toBe(2);
+    expect(faultyProbe.plan).toBe(2);
 
     expect(host.dispose()).toEqual(ok(undefined));
     expect(host.dispose()).toEqual(ok(undefined));
-    expect(releaseCount).toBe(1);
     expect(host.diagnostics().map((entry) => entry.status)).toEqual(['disposed', 'disposed']);
   });
-
-  it('keeps the owning identity and order on prepared-state and record failures', () => {
-    const resolver = createPreparedGraphicsResolver({
-      device: {} as RhiDevice,
-      featureIdentity: 'synthetic.m10.resolver',
-      generation: 2,
-      capabilityAvailable: true,
-      featureOrder: 7,
-      lookup: () => undefined,
-      resolvePipeline: () => ok({} as never),
-      resolveBindings: () => ok(undefined),
-    });
-    const missing = resolver.resolve({ kind: 'vertex-data', generation: 2 });
-    expect(missing).toMatchObject({
-      ok: false,
-      error: {
-        code: 'render-feature-prepared-state-mismatch',
-        detail: { featureIdentity: 'synthetic.m10.resolver', order: 7 },
-      },
-    });
-
-    const pipeline = { kind: 'pipeline' as const, generation: 0 };
-    const bindings = { kind: 'bindings' as const, generation: 0 };
-    const vertices = { kind: 'vertex-data' as const, generation: 0 };
-    const recorded = recordResolvedRenderFeatureGraphicsPass(
-      'synthetic.m10.record-order',
-      {
-        attachments: {
-          colors: [
-            { resource: 'swapchain', format: 'rgba8unorm', loadOp: 'load', storeOp: 'store' },
-          ],
-        },
-        draws: [
-          {
-            kind: 'draw',
-            pipeline,
-            bindings: [bindings],
-            vertexData: [{ slot: 0, resource: vertices }],
-            command: { vertexCount: 3, instanceCount: 1 },
-          },
-        ],
-      },
-      {
-        capabilityAvailable: true,
-        generation: 0,
-        attachments: [{ resource: 'swapchain', format: 'rgba8unorm' }],
-        pipeline,
-        pipelines: [pipeline],
-        bindings: [bindings],
-        vertexData: [vertices],
-        indexData: [],
-      },
-      { generation: 0, resolve: () => undefined },
-      { pipeline: 0, binding: 0, vertex: 0, index: 0, draw: 0 },
-      4,
-    );
-    expect(recorded).toMatchObject({
-      ok: false,
-      error: {
-        code: 'render-feature-stage-failed',
-        detail: { featureIdentity: 'synthetic.m10.record-order', order: 4, stage: 'record' },
-      },
-    });
-  });
 });

package/src/__tests__/render-feature-visibility-context.test-d.ts

@@ -27,12 +27,7 @@ const feature = {
     consumeContext(context);
     return ok<Frame>({ count: context.worlds.length });
   },
-  prepare() {
-    return ok(undefined);
-  },
-  contribute() {
-    return ok(undefined);
-  },
+  plan: () => ok({ resources: [], passes: [] }),
 } satisfies RenderFeature<Frame>;
 
 void feature;

package/src/__tests__/render-feature-visibility-context.unit.test.ts

@@ -15,8 +15,7 @@ describe('render feature visibility context', () => {
         context.reportHiddenEntity?.({ world, entity: 7 as never });
         return ok({ count: context.worlds.length });
       },
-      prepare: () => ok(undefined),
-      contribute: () => ok(undefined),
+      plan: () => ok({ resources: [], passes: [] }),
     };
     const host = createRenderFeatureHost([feature]).unwrap();
     const snapshots = [{ world, snapshot: {} as never }];