@forgeax/engine-render 0.1.4 → 0.1.7

package/src/__tests__/typed-pipeline-topology.unit.test.ts

@@ -3,15 +3,13 @@ import type { RhiDevice } from '@forgeax/engine-rhi';
 import { rhi } from '@forgeax/engine-rhi-null';
 import { ok } from '@forgeax/engine-types';
 import { beforeAll, describe, expect, it } from 'vitest';
-import { hdrpPipeline } from '../hdrp-pipeline';
+import { standardPipeline } from '../pipeline/standard-pipeline';
+import { DEFAULT_STANDARD_PROFILE } from '../pipeline/standard-profile';
 import type {
   RenderPipeline,
   RenderPipelineFrame,
   RenderPipelineTopology,
 } from '../render-pipeline';
-import { createRenderPipelineTemporalContract } from '../render-pipeline';
-import { createRenderPipelineTarget } from '../render-pipeline-target';
-import { urpPipeline } from '../urp-pipeline';
 
 let device: RhiDevice;
 
@@ -24,7 +22,7 @@ beforeAll(async () => {
 });
 
 function topology(
-  pipelineId: 'forgeax::urp' | 'forgeax::hdrp',
+  pipelineId: 'forgeax::standard',
   overrides: Partial<RenderPipelineTopology> = {},
 ): RenderPipelineTopology {
   return {
@@ -58,55 +56,27 @@ function topology(
 
 function compile(pipeline: RenderPipeline, input: RenderPipelineTopology) {
   const graph = new RenderGraphBuilder<RenderPipelineFrame>();
-  const temporal = createRenderPipelineTemporalContract({
-    enabled: input.camera.antialias === 'taa',
-    rgba16floatRenderable: true,
-    maxColorAttachments: input.lane.maxColorAttachments,
-    project: (targets) => ok({ resolvedColor: targets.sceneColor }),
-  });
   const built = pipeline.build(
     {
       graph,
       projectGpuDriven: () => ok(undefined),
       contributeFeatures: () => ok(undefined),
-      resolveTemporal: temporal.resolve,
     },
     input,
   );
   if (!built.ok) return built;
-  const finished = temporal.finish();
-  if (!finished.ok) return finished;
   return graph.compile({
     device,
     surfaceSize: { width: input.surface.width, height: input.surface.height },
   });
 }
 
-function projectTemporal(
-  graph: RenderGraphBuilder<RenderPipelineFrame>,
-  targets: Parameters<ReturnType<typeof createRenderPipelineTemporalContract>['resolve']>[0],
-) {
-  const output = createRenderPipelineTarget(graph, 'test-taa-resolved-color', {
-    format: 'rgba16float',
-    size: 'surface',
-  });
-  if (!output.ok) return output;
-  const pass = graph.addCopyPass('taa-resolve', {
-    accesses: [
-      { resource: targets.sceneColor.view, usage: 'copy-src' },
-      { resource: output.value.view, usage: 'copy-dst' },
-    ],
-    encode: () => undefined,
-  });
-  return pass.ok ? ok({ resolvedColor: { kind: 'scene-color' as const, ...output.value } }) : pass;
-}
-
 describe('typed built-in pipeline topology', () => {
   it('orders HDRP compute, shadow, deferred, SSAO, forward, observation, and output work', () => {
     const compiled = compile(
-      hdrpPipeline,
-      topology('forgeax::hdrp', {
-        config: { ssao: { enabled: true } },
+      standardPipeline,
+      topology('forgeax::standard', {
+        standardProfile: { ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered', ssao: true },
       }),
     );
     expect(compiled.ok).toBe(true);
@@ -151,8 +121,9 @@ describe('typed built-in pipeline topology', () => {
 
   it('omits SSAO and compute membership on the bounded fallback lane', () => {
     const compiled = compile(
-      hdrpPipeline,
-      topology('forgeax::hdrp', {
+      standardPipeline,
+      topology('forgeax::standard', {
+        standardProfile: { ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered' },
         config: { ssao: { enabled: false } },
         lane: {
           compute: false,
@@ -171,8 +142,8 @@ describe('typed built-in pipeline topology', () => {
 
   it('keeps URP post effects after output and before debug overlay', () => {
     const compiled = compile(
-      urpPipeline,
-      topology('forgeax::urp', {
+      standardPipeline,
+      topology('forgeax::standard', {
         config: { postEffects: ['example::a', 'example::b'] },
       }),
     );
@@ -185,14 +156,37 @@ describe('typed built-in pipeline topology', () => {
     expect(names.indexOf('post-effect-1')).toBeGreaterThan(names.indexOf('post-effect-0'));
     expect(names.indexOf('debug-overlay')).toBeGreaterThan(names.indexOf('post-effect-1'));
     expect(info.resources.map((resource) => resource.label)).toEqual(
-      expect.arrayContaining(['post-effect-scratch-0', 'post-effect-scratch-1']),
+      expect.arrayContaining([
+        'post-effect-scratch-0',
+        'post-effect-output-0',
+        'post-effect-scratch-1',
+      ]),
     );
+    const copy0 = info.passes.find((pass) => pass.name === 'post-effect-copy-0');
+    const effect0 = info.passes.find((pass) => pass.name === 'post-effect-0');
+    const copy1 = info.passes.find((pass) => pass.name === 'post-effect-copy-1');
+    const effect1 = info.passes.find((pass) => pass.name === 'post-effect-1');
+    expect(copy0?.accesses).toContainEqual({ resource: 'surface', usage: 'copy-src' });
+    expect(copy1?.accesses).toContainEqual({
+      resource: 'post-effect-output-0',
+      usage: 'copy-src',
+    });
+    expect(effect0?.accesses).toContainEqual({
+      resource: 'post-effect-output-0',
+      usage: 'color-attachment',
+    });
+    expect(effect1?.accesses).toContainEqual({
+      resource: 'surface',
+      usage: 'color-attachment',
+    });
+    expect(copy1?.dependencies).toContain('post-effect-0');
+    expect(effect1?.dependencies).toContain('post-effect-copy-1');
   });
 
   it('removes unsupported MSAA and composite post work on the fallback lane', () => {
     const compiled = compile(
-      urpPipeline,
-      topology('forgeax::urp', {
+      standardPipeline,
+      topology('forgeax::standard', {
         camera: { tonemap: 'none', antialias: 'msaa', bloom: 'off' },
         config: { postEffects: ['example::a'] },
         lane: {
@@ -212,8 +206,9 @@ describe('typed built-in pipeline topology', () => {
 
   it('returns a structured HDRP capability refusal before graph compilation', () => {
     const built = compile(
-      hdrpPipeline,
-      topology('forgeax::hdrp', {
+      standardPipeline,
+      topology('forgeax::standard', {
+        standardProfile: { ...DEFAULT_STANDARD_PROFILE, lighting: 'clustered' },
         lane: {
           compute: true,
           storageBuffer: true,
@@ -225,165 +220,4 @@ describe('typed built-in pipeline topology', () => {
     expect(built.ok).toBe(false);
     if (!built.ok) expect(built.error.code).toBe('hdrp-deferred-caps-insufficient');
   });
-
-  it.each([
-    ['forgeax::urp', urpPipeline],
-    ['forgeax::hdrp', hdrpPipeline],
-  ] as const)('calls the renderer temporal seam exactly once in %s', (pipelineId, pipeline) => {
-    const graph = new RenderGraphBuilder<RenderPipelineFrame>();
-    let projected = 0;
-    const input = topology(pipelineId, {
-      camera: { tonemap: 'aces-filmic', antialias: 'taa', bloom: 'on' },
-    });
-    const temporal = createRenderPipelineTemporalContract({
-      enabled: true,
-      rgba16floatRenderable: true,
-      maxColorAttachments: 8,
-      project: (targets) => {
-        projected += 1;
-        return projectTemporal(graph, targets);
-      },
-    });
-    const built = pipeline.build(
-      {
-        graph,
-        projectGpuDriven: () => ok(undefined),
-        contributeFeatures: () => ok(undefined),
-        resolveTemporal: temporal.resolve,
-      },
-      input,
-    );
-    expect(built.ok).toBe(true);
-    expect(temporal.finish().ok).toBe(true);
-    expect(temporal.inspect()).toEqual({ resolveCount: 1 });
-    expect(projected).toBe(1);
-    const compiled = graph.compile({
-      device,
-      surfaceSize: { width: input.surface.width, height: input.surface.height },
-    });
-    expect(compiled.ok).toBe(true);
-    if (!compiled.ok) return;
-    const names = compiled.value.inspect().passes.map((pass) => pass.name);
-    expect(names.filter((name) => name === 'scene-temporal')).toHaveLength(1);
-    expect(names.indexOf('scene-temporal')).toBeGreaterThan(
-      names.indexOf(pipelineId === 'forgeax::urp' ? 'main' : 'forward'),
-    );
-    expect(names.filter((name) => name === 'taa-resolve')).toHaveLength(1);
-    expect(names.indexOf('taa-resolve')).toBeGreaterThan(names.indexOf('scene-temporal'));
-    const temporalPass = compiled.value
-      .inspect()
-      .passes.find((pass) => pass.name === 'scene-temporal');
-    expect(temporalPass?.kind).toBe('raster');
-    expect(temporalPass?.accesses).toEqual(
-      expect.arrayContaining([
-        { resource: 'scene-temporal', usage: 'color-attachment' },
-        {
-          resource: 'scene-temporal-depth',
-          usage: 'depth-stencil-write',
-        },
-      ]),
-    );
-    expect(temporalPass?.accesses).not.toContainEqual({
-      resource: pipelineId === 'forgeax::urp' ? 'scene-depth' : 'hdrp-depth',
-      usage: 'depth-stencil-write',
-    });
-    expect(names.indexOf('linear-hdr-observation')).toBeGreaterThan(names.indexOf('taa-resolve'));
-    expect(names.indexOf('bloom-bright')).toBeGreaterThan(names.indexOf('taa-resolve'));
-    expect(names.indexOf('tonemap')).toBeGreaterThan(names.indexOf('taa-resolve'));
-    expect(names.indexOf('debug-overlay')).toBeGreaterThan(names.indexOf('tonemap'));
-  });
-
-  it('rejects custom TAA pipelines that omit or duplicate the resolve seam', () => {
-    const input = topology('forgeax::urp', {
-      camera: { tonemap: 'none', antialias: 'taa', bloom: 'off' },
-    });
-    const omitted = createRenderPipelineTemporalContract({
-      enabled: true,
-      rgba16floatRenderable: true,
-      maxColorAttachments: 8,
-      project: (targets) => ok({ resolvedColor: targets.sceneColor }),
-    });
-    const missing = omitted.finish();
-    expect(missing.ok).toBe(false);
-    if (!missing.ok) {
-      expect(missing.error.code).toBe('temporal-unsupported');
-      if (missing.error.code === 'temporal-unsupported') {
-        expect(missing.error.detail).toMatchObject({ reason: 'resolve-count' });
-      }
-    }
-
-    const graph = new RenderGraphBuilder<RenderPipelineFrame>();
-    const color = graph.createTexture('custom-color', { format: 'rgba16float', size: 'surface' });
-    const depth = graph.createTexture('custom-depth', { format: 'depth24plus', size: 'surface' });
-    const temporalTexture = graph.createTexture('custom-temporal', {
-      format: 'rgba16float',
-      size: 'surface',
-    });
-    expect(color.ok && depth.ok && temporalTexture.ok).toBe(true);
-    if (!color.ok || !depth.ok || !temporalTexture.ok) return;
-    const colorView = graph.view(color.value);
-    const depthView = graph.view(depth.value);
-    const temporalView = graph.view(temporalTexture.value);
-    expect(colorView.ok && depthView.ok && temporalView.ok).toBe(true);
-    if (!colorView.ok || !depthView.ok || !temporalView.ok) return;
-    const targets = {
-      sceneColor: {
-        kind: 'scene-color' as const,
-        texture: color.value,
-        view: colorView.value,
-        format: 'rgba16float',
-        sampleCount: 1 as const,
-      },
-      sceneDepth: {
-        kind: 'scene-depth' as const,
-        texture: depth.value,
-        view: depthView.value,
-        format: 'depth24plus',
-        sampleCount: 1 as const,
-      },
-      sceneTemporal: {
-        kind: 'scene-temporal' as const,
-        texture: temporalTexture.value,
-        view: temporalView.value,
-        format: 'rgba16float',
-        sampleCount: 1 as const,
-      },
-    };
-    const duplicate = createRenderPipelineTemporalContract({
-      enabled: input.camera.antialias === 'taa',
-      rgba16floatRenderable: true,
-      maxColorAttachments: 8,
-      project: (value) => ok({ resolvedColor: value.sceneColor }),
-    });
-    expect(duplicate.resolve(targets).ok).toBe(true);
-    const second = duplicate.resolve(targets);
-    expect(second.ok).toBe(false);
-    if (!second.ok) {
-      expect(second.error.code).toBe('temporal-unsupported');
-      if (second.error.code === 'temporal-unsupported') {
-        expect(second.error.detail).toMatchObject({ reason: 'resolve-count' });
-      }
-    }
-
-    const insufficient = createRenderPipelineTemporalContract({
-      enabled: true,
-      rgba16floatRenderable: false,
-      maxColorAttachments: 1,
-      project: (value) => ok({ resolvedColor: value.sceneColor }),
-    }).resolve(targets);
-    expect(insufficient.ok).toBe(false);
-    if (!insufficient.ok) expect(insufficient.error.code).toBe('taa-caps-insufficient');
-
-    const invalidDomain = createRenderPipelineTemporalContract({
-      enabled: true,
-      rgba16floatRenderable: true,
-      maxColorAttachments: 8,
-      project: (value) => ok({ resolvedColor: value.sceneColor }),
-    }).resolve({
-      ...targets,
-      sceneColor: { ...targets.sceneColor, format: 'bgra8unorm' },
-    });
-    expect(invalidDomain.ok).toBe(false);
-    if (!invalidDomain.ok) expect(invalidDomain.error.code).toBe('temporal-unsupported');
-  });
 });

package/src/__tests__/urp-pipeline-targets.unit.test.ts

@@ -3,11 +3,10 @@ import { resolveStandardRenderFeatureTargets } from '../features/targets';
 
 function targets(
   tonemap: 'none' | 'aces-filmic',
-  antialias: 'none' | 'fxaa' | 'msaa' | 'taa',
+  antialias: 'none' | 'fxaa' | 'msaa',
   storageBuffer: boolean,
 ) {
   return resolveStandardRenderFeatureTargets({
-    pipelineId: 'forgeax::urp',
     tonemap,
     antialias,
     colorAttachmentFormat: 'bgra8unorm-srgb',
@@ -40,13 +39,4 @@ describe('urp render feature targets', () => {
       sampleCount: 1,
     });
   });
-
-  it('publishes packed temporal coverage only for TAA', () => {
-    expect(targets('none', 'taa', true)?.[2]).toMatchObject({
-      kind: 'scene-temporal',
-      format: 'rgba16float',
-      sampleCount: 1,
-    });
-    expect(targets('none', 'none', true)).toHaveLength(2);
-  });
 });

package/src/__tests__/urp-pipeline.unit.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, it } from 'vitest';
 import { resolvePostColorDomainContract } from '../render-pipeline';
 
-describe('URP post color-domain order', () => {
+describe('Standard forward post color-domain order', () => {
   it('declares the required linear-to-encoded stage sequence', () => {
-    expect(resolvePostColorDomainContract('urp')).toEqual([
+    expect(resolvePostColorDomainContract('linear-ldr')).toEqual([
       ['transparent-blend', 'linear-ldr', 'linear-ldr'],
       ['bloom', 'linear-hdr', 'linear-hdr'],
       ['tone', 'linear-hdr', 'linear-ldr'],

package/src/__tests__/vertex-color-pipeline.unit.test.ts

@@ -4,8 +4,12 @@ import {
 } from '@forgeax/engine-geometry';
 import type { VertexAttributeMap } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { variantSetFromVertexLayoutProjection } from '../pipeline';
-import { buildPipelineDescriptor, cacheKeyOf, type PipelineSpec } from '../pipeline-spec';
+import {
+  buildPipelineDescriptor,
+  cacheKeyOf,
+  type PipelineSpec,
+  variantSetFromVertexLayoutProjection,
+} from '../pipeline-spec';
 
 const baseAttributes = (): VertexAttributeMap => ({
   position: new Float32Array([0, 0, 0]),
@@ -93,6 +97,10 @@ describe('render vertex-color projection contract', () => {
         'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=true',
     });
     expect(variantSetFromVertexLayoutProjection(colored, '')).toEqual({ ok: true, value: '' });
+    expect(variantSetFromVertexLayoutProjection(plain, '')).toEqual({
+      ok: true,
+      value: 'VERTEX_COLOR_AVAILABLE=false',
+    });
   });
 
   it('does not allocate color stream bytes for a plain mesh', () => {

package/src/__tests__/vertex-layout-consumer.unit.test.ts

@@ -7,7 +7,7 @@ const source = (name: string): string =>
 describe('render consumes geometry layout projection', () => {
   it('does not retain the legacy stride discriminator or uv count as layout authority', () => {
     const renderData = source('render-data.ts');
-    const store = source('gpu-resource-store.ts');
+    const store = source('device/gpu-residency.ts');
     const pipeline = source('pipeline-spec.ts');
 
     expect(renderData).toMatch(/VertexLayoutProjection/);

package/src/__tests__/visibility-diagnostics.integration.test.ts

@@ -1,15 +1,12 @@
+import { HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
-import {
-  Camera,
-  extractFrames,
-  MeshFilter,
-  MeshRenderer,
-  Visibility,
-  VisibilityStateValue,
-} from '@forgeax/engine-render/internal';
 import { registerPropagateTransforms, Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
+import { Camera } from '../components/camera';
+import { MeshFilter } from '../components/mesh-filter';
+import { MeshRenderer } from '../components/mesh-renderer';
+import { Visibility, VisibilityStateValue } from '../components/visibility';
+import { extractFrames } from '../render-system-extract';
 
 function spawnCamera(world: World): void {
   world
@@ -21,11 +18,10 @@ function spawnCamera(world: World): void {
 }
 
 function spawnCandidate(world: World, state: keyof typeof VisibilityStateValue) {
-  const meshHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
   return world
     .spawn(
       { component: Transform, data: { pos: [0, 0, 200] } },
-      { component: MeshFilter, data: { assetHandle: meshHandle } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: {} },
       { component: Visibility, data: { state: VisibilityStateValue[state] } },
     )

package/src/__tests__/visibility-extract.integration.test.ts

@@ -1,14 +1,8 @@
 import { World } from '@forgeax/engine-ecs';
-import { createWorldProjection } from '@forgeax/engine-ecs/projection';
-import {
-  extractFrame,
-  extractFrames,
-  prepareExtractContext,
-  Visibility,
-  VisibilityStateValue,
-} from '@forgeax/engine-render/internal';
 import { ChildOf, registerPropagateTransforms, Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
+import { Visibility, VisibilityStateValue } from '../components/visibility';
+import { extractFrame, extractFrames, prepareExtractContext } from '../render-system-extract';
 
 function transform(pos: [number, number, number]) {
   return {
@@ -54,14 +48,29 @@ describe('visibility extract orchestration', () => {
     const { world, parent, child } = makeWorld();
     world.update(0).unwrap();
     const before = [...world.get(child, Transform).unwrap().world];
+    const beforeInspection = world.inspect();
+    const beforeShape = {
+      entityCount: beforeInspection.entityCount,
+      archetypeCount: beforeInspection.archetypeCount,
+      tableCount: beforeInspection.tableCount,
+      activeComponents: beforeInspection.activeComponents,
+      systemCount: beforeInspection.systemCount,
+      resourceKeys: beforeInspection.resourceKeys,
+    };
 
     world.set(parent, Transform, { pos: [9, 0, 0] }).unwrap();
-    const projection = createWorldProjection(world, { components: [Transform] });
-    projection.poll();
     extractFrames([world], 0);
 
     expect([...world.get(child, Transform).unwrap().world]).toEqual(before);
-    expect(projection.poll()).toMatchObject({ changes: [] });
+    const afterInspection = world.inspect();
+    expect({
+      entityCount: afterInspection.entityCount,
+      archetypeCount: afterInspection.archetypeCount,
+      tableCount: afterInspection.tableCount,
+      activeComponents: afterInspection.activeComponents,
+      systemCount: afterInspection.systemCount,
+      resourceKeys: afterInspection.resourceKeys,
+    }).toEqual(beforeShape);
     world.update(0).unwrap();
     expect(world.get(child, Transform).unwrap().world[12]).toBeCloseTo(11);
   });

package/src/__tests__/visibility-extract.perf.test.ts

@@ -1,22 +1,40 @@
+import { HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
-import {
-  extractFrames,
-  MeshFilter,
-  MeshRenderer,
-  Visibility,
-  VisibilityStateValue,
-} from '@forgeax/engine-render/internal';
 import { ChildOf, Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
+import { MeshFilter } from '../components/mesh-filter';
+import { MeshRenderer } from '../components/mesh-renderer';
+import { Visibility, VisibilityStateValue } from '../components/visibility';
+import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
+import { extractFrames } from '../render-system-extract';
+import { RenderScene } from '../scene/render-scene';
 
 const ENTITY_COUNT = 10_000;
 const SAMPLE_COUNT = 101;
-const PERF_TEST_TIMEOUT_MS = 600_000;
+
+const sceneMaterial = {} as MaterialSnapshot;
+
+function sceneSnapshot(entityKey: number): RenderableSnapshot {
+  const world = new Float32Array(16);
+  world[0] = 1;
+  world[5] = 1;
+  world[10] = 1;
+  world[15] = 1;
+  world[12] = entityKey % 1_000;
+  return {
+    assetHandle: 1,
+    transform: { world },
+    localAabb: new Float32Array([-0.5, -0.5, -0.5, 0.5, 0.5, 0.5]),
+    material: { ...sceneMaterial, materialHandle: entityKey % 1_000 },
+    materials: [{ ...sceneMaterial, materialHandle: entityKey % 1_000 }],
+    materialBindingSources: ['engine-default'],
+    worldId: 0,
+    entityKey,
+  };
+}
 
 function buildWorld(inherited: boolean, withHierarchy: boolean): World {
   const world = new World();
-  const meshHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
   const parent = withHierarchy
     ? world
         .spawn(
@@ -36,7 +54,7 @@ function buildWorld(inherited: boolean, withHierarchy: boolean): World {
         ...(inherited
           ? [{ component: Visibility, data: { state: VisibilityStateValue.inherited } }]
           : []),
-        { component: MeshFilter, data: { assetHandle: meshHandle } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
         { component: MeshRenderer, data: {} },
       )
       .unwrap();
@@ -71,26 +89,42 @@ function measureWorlds(worlds: readonly World[]): number[] {
 }
 
 describe('visibility extraction performance (10k)', () => {
-  it(
-    'keeps inherited hierarchy extraction within the 10 percent budget',
-    () => {
-      const flat = buildWorld(false, false);
-      const hierarchy = buildWorld(false, true);
-      const inherited = buildWorld(true, true);
-      const flatMedian = measureWorlds([flat])[0] ?? 0;
-      const [hierarchyMedian = 0, inheritedMedian = 0] = measureWorlds([hierarchy, inherited]);
-      const overhead = inheritedMedian / Math.max(hierarchyMedian, 0.001) - 1;
-      // biome-ignore lint/suspicious/noConsole: retain benchmark profile evidence
-      console.info(
-        `[m3-b-performance] flat=${flatMedian.toFixed(3)}ms hierarchy=${hierarchyMedian.toFixed(3)}ms inherited=${inheritedMedian.toFixed(3)}ms overhead=${(overhead * 100).toFixed(2)}% samples=${SAMPLE_COUNT}`,
-      );
+  it('keeps inherited hierarchy extraction within the 10 percent budget', () => {
+    const flat = buildWorld(false, false);
+    const hierarchy = buildWorld(false, true);
+    const inherited = buildWorld(true, true);
+    const flatMedian = measureWorlds([flat])[0] ?? 0;
+    const [hierarchyMedian = 0, inheritedMedian = 0] = measureWorlds([hierarchy, inherited]);
+    const overhead = inheritedMedian / Math.max(hierarchyMedian, 0.001) - 1;
+    // biome-ignore lint/suspicious/noConsole: retain benchmark profile evidence
+    console.info(
+      `[m3-b-performance] flat=${flatMedian.toFixed(3)}ms hierarchy=${hierarchyMedian.toFixed(3)}ms inherited=${inheritedMedian.toFixed(3)}ms overhead=${(overhead * 100).toFixed(2)}% samples=${SAMPLE_COUNT}`,
+    );
+
+    expect(overhead).toBeLessThanOrEqual(0.1);
+  }, 60_000);
+
+  it('keeps RenderScene delta and no-change evidence on the 100k workload', () => {
+    const scene = new RenderScene();
+    scene.reset(Array.from({ length: 100_000 }, (_, entityKey) => sceneSnapshot(entityKey)));
+    const stable = scene.materialize();
+    const noChange = scene.apply([]);
+    const delta = scene.apply(
+      Array.from({ length: 10_000 }, (_, entityKey) => {
+        const previous = stable[entityKey];
+        const world =
+          previous === undefined
+            ? new Float32Array(16)
+            : new Float32Array(previous.transform.world);
+        world[12] = (world[12] ?? 0) + 1;
+        return { kind: 'update-transform' as const, worldId: 0, entityKey, world };
+      }),
+    );
 
-      expect(overhead).toBeLessThanOrEqual(0.1);
-      // 10k entities x 101 samples is intentionally a large ratio benchmark. The
-      // Linux self-hosted carriers can spend >330s in this uninstrumented test even
-      // though the measured ratio is healthy; keep the benchmark budget intact and
-      // give those carriers an honest wall-clock envelope.
-    },
-    PERF_TEST_TIMEOUT_MS,
-  );
+    expect(noChange).toMatchObject({ updated: 0, resynced: 0 });
+    expect(delta).toMatchObject({ updated: 10_000, resynced: 0 });
+    expect(scene.inspect()).toMatchObject({ renderableScans: 10_000 });
+    expect(scene.materialize()).not.toBe(stable);
+    expect(scene.querySpatial({ min: [-1, -1, -1], max: [1, 1, 1] }).length).toBeGreaterThan(0);
+  }, 60_000);
 });

package/src/__tests__/visibility-feature-dedup.integration.test.ts

@@ -13,8 +13,7 @@ describe('render feature visibility report deduplication', () => {
         context.reportHiddenEntity?.({ world, entity: 3 as never });
         return ok({ count: context.worlds.length });
       },
-      prepare: () => ok(undefined),
-      contribute: () => ok(undefined),
+      plan: () => ok({ resources: [], passes: [] }),
     };
     const host = createRenderFeatureHost([feature]).unwrap();
 
@@ -39,8 +38,7 @@ describe('render feature visibility report deduplication', () => {
         context.reportHiddenEntity?.({ world: second, entity: 1 as never });
         return ok({ count: context.worlds.length });
       },
-      prepare: () => ok(undefined),
-      contribute: () => ok(undefined),
+      plan: () => ok({ resources: [], passes: [] }),
     };
     const host = createRenderFeatureHost([feature]).unwrap();
     const result = runRenderFeatureFrame(host, {

package/src/__tests__/visibility-hidden-report.unit.test.ts

@@ -20,8 +20,7 @@ describe('render feature hidden entity report contract', () => {
         context.reportHiddenEntity?.({ world, entity: 9 as never });
         return ok({ count: context.worlds.length });
       },
-      prepare: () => ok(undefined),
-      contribute: () => ok(undefined),
+      plan: () => ok({ resources: [], passes: [] }),
     };
     const host = createRenderFeatureHost([feature]).unwrap();
     const result = runRenderFeatureFrame(host, {