@forgeax/engine-runtime 0.1.4 → 0.1.7

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

@@ -1,361 +1,104 @@
-import { World } from '@forgeax/engine-ecs';
-import type {
-  RenderFeature,
-  RenderFeatureDrawRecord,
-  RenderFeaturePreparedRef,
-  RenderPipeline,
-} from '@forgeax/engine-render';
-import {
-  Camera,
-  createRenderFeatureTarget,
-  createRenderPipelineTarget,
-  RenderFeatureStageFailedError,
-} from '@forgeax/engine-render';
-import type { RhiDevice } from '@forgeax/engine-rhi';
 import { rhi } from '@forgeax/engine-rhi-null';
-import { Transform } from '@forgeax/engine-scene';
-import { err, ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { createRenderer } from '../createRenderer';
-
-const manifest = `data:application/json,${encodeURIComponent(
-  JSON.stringify({
-    schemaVersion: '1.0.0',
-    entries: [
-      { hash: 'pbr00000', wgsl: '/* pbr stub */', glsl: '', bindings: '' },
-      { hash: 'unlit000', wgsl: '/* unlit stub */', glsl: '', bindings: '' },
-      { hash: 'tonemap0', wgsl: '/* tonemap stub */', glsl: '', bindings: '' },
-    ],
-    materialShaders: [
-      {
-        identifier: 'forgeax::default-standard-pbr',
-        sourcePath: 'forgeax::default-standard-pbr.wgsl',
-        composedWgsl: '/* stub */',
-        paramSchema: '[]',
-        variants: [],
-      },
-      {
-        identifier: 'forgeax::default-unlit',
-        sourcePath: 'forgeax::default-unlit.wgsl',
-        composedWgsl: '/* stub */',
-        paramSchema: '[]',
-        variants: [],
-      },
-    ],
-  }),
-)}`;
+import { constructRendererHost } from '../../../render/src/construct-renderer';
+import {
+  frameRequest,
+  type PreparedFeatureMode,
+  preparedFeature,
+  preparedManifest,
+  preparedWorld,
+} from './render-feature-prepared-graphics.fixture';
 
 function canvas(): HTMLCanvasElement {
-  return {
-    width: 64,
-    height: 64,
-    getContext: () => null,
-    addEventListener: () => undefined,
-    removeEventListener: () => undefined,
-  } as unknown as HTMLCanvasElement;
-}
-
-function observeDrawCalls(device: RhiDevice): () => number {
-  let count = 0;
-  const createCommandEncoder = device.createCommandEncoder.bind(device);
-  device.createCommandEncoder = (descriptor) => {
-    const result = createCommandEncoder(descriptor);
-    if (!result.ok) return result;
-    const encoder = result.value;
-    const beginRenderPass = encoder.beginRenderPass.bind(encoder);
-    encoder.beginRenderPass = (passDescriptor) => {
-      const pass = beginRenderPass(passDescriptor);
-      const draw = pass.draw.bind(pass);
-      const drawIndexed = pass.drawIndexed.bind(pass);
-      pass.draw = (...args) => {
-        count += 1;
-        draw(...args);
-      };
-      pass.drawIndexed = (...args) => {
-        count += 1;
-        drawIndexed(...args);
-      };
-      return pass;
-    };
-    return result;
-  };
-  return () => count;
-}
-
-function pipeline(): RenderPipeline {
-  return {
-    build: ({ graph, contributeFeatures }) => {
-      const scene = createRenderPipelineTarget(graph, 'prepared-scene', {
-        format: 'rgba8unorm',
-        size: 'surface',
-      });
-      if (!scene.ok) return scene;
-      const base = graph.addRasterPass('base', {
-        accesses: [{ resource: scene.value.view, usage: 'color-attachment' }],
-        colorAttachments: [
-          {
-            view: scene.value.view,
-            loadOp: 'clear',
-            storeOp: 'store',
-            clearValue: { r: 0, g: 0, b: 0, a: 1 },
-          },
-        ],
-        encode: () => undefined,
-      });
-      if (!base.ok) return base;
-      return contributeFeatures([
-        {
-          kind: 'scene-color',
-          texture: scene.value.texture,
-          view: scene.value.view,
-          format: scene.value.format,
-          sampleCount: 1,
-        },
-      ]);
-    },
-  };
-}
-
-function world(): World {
-  const value = new World();
-  value.spawn(
-    { component: Transform, data: { pos: [0, 0, 3], quat: [0, 0, 0, 1], scale: [1, 1, 1] } },
-    { component: Camera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 } },
-  );
-  return value;
-}
-
-type MatrixCase = 'accepted' | 'mismatch' | 'empty' | 'multi-feature' | 'recovery';
-
-interface MatrixResult {
-  readonly case: MatrixCase;
-  readonly drawCount: number;
-  readonly featureStatuses: readonly string[];
-  readonly errorCodes: readonly string[];
-  readonly passNames: readonly string[];
-}
-
-interface FeatureState {
-  pipeline: RenderFeaturePreparedRef<'pipeline'> | undefined;
-  bindings: RenderFeaturePreparedRef<'bindings'> | undefined;
-  vertices: RenderFeaturePreparedRef<'vertex-data'> | undefined;
-  firstContribution: boolean;
+  return { width: 64, height: 64, getContext: () => null } as unknown as HTMLCanvasElement;
 }
 
-function graphicsFeature(
-  identity: string,
-  state: FeatureState,
-  mode: Exclude<MatrixCase, 'multi-feature'>,
-): RenderFeature<{ readonly draw: boolean }> {
-  return {
-    identity,
-    extract: () => ok({ draw: mode !== 'empty' }),
-    prepare: (_data, context) => {
-      const pipelineResult = context.graphics.preparePipeline('forward', {
-        shader: 'synthetic.unlit',
-        vertexLayout: 'position',
-        colorFormats: ['rgba8unorm'],
-      });
-      if (!pipelineResult.ok) return pipelineResult;
-      const bindingsResult = context.graphics.prepareBindings('forward', {
-        pipeline: pipelineResult.value,
-        values: { opacity: 1 },
-      });
-      if (!bindingsResult.ok) return bindingsResult;
-      const verticesResult = context.graphics.prepareVertexData('triangle', {
-        layout: 'position',
-        data: new Float32Array([0, 0, 0]),
-      });
-      if (!verticesResult.ok) return verticesResult;
-      state.pipeline = pipelineResult.value;
-      state.bindings = bindingsResult.value;
-      state.vertices = verticesResult.value;
-      return ok(undefined);
-    },
-    contribute: (data, context) => {
-      if (!data.draw) return ok(undefined);
-      const { pipeline: preparedPipeline, bindings, vertices } = state;
-      if (preparedPipeline === undefined || bindings === undefined || vertices === undefined) {
-        return err(new RenderFeatureStageFailedError(identity, 0, 'contribute', 'next-frame'));
-      }
-      const drawPipeline =
-        mode === 'mismatch' || (mode === 'recovery' && state.firstContribution)
-          ? { kind: 'pipeline' as const, generation: 99 }
-          : preparedPipeline;
-      state.firstContribution = false;
-      const draw: RenderFeatureDrawRecord = {
-        kind: 'draw',
-        pipeline: drawPipeline,
-        bindings: [bindings],
-        vertexData: [{ slot: 0, resource: vertices }],
-        command: { vertexCount: 3, instanceCount: 1 },
-      };
-      return context.staging.addGraphicsPass('forward', {
-        attachments: {
-          colors: [
-            {
-              resource: createRenderFeatureTarget({
-                kind: 'scene-color',
-                format: 'rgba8unorm',
-                sampleCount: 1,
-              }),
-              format: 'rgba8unorm',
-              loadOp: 'load',
-              storeOp: 'store',
-            },
-          ],
-        },
-        draws: [draw],
-      });
-    },
-  };
+function rootErrorCode(value: unknown): string {
+  let error = value as { code: string; detail?: unknown };
+  while (error.detail !== undefined && typeof error.detail === 'object' && error.detail !== null) {
+    const cause = (error.detail as { cause?: unknown }).cause;
+    if (
+      cause === undefined ||
+      typeof cause !== 'object' ||
+      cause === null ||
+      typeof (cause as { code?: unknown }).code !== 'string'
+    ) {
+      break;
+    }
+    error = cause as { code: string; detail?: unknown };
+  }
+  return error.code;
 }
 
-async function rendererWith(
-  features: readonly RenderFeature<{ readonly draw: boolean }>[],
-): Promise<Awaited<ReturnType<typeof createRenderer>>> {
-  const renderer = await createRenderer(
+async function runCase(mode: PreparedFeatureMode) {
+  const host = await constructRendererHost(
     canvas(),
-    { rhi, features },
-    { shaderManifestUrl: manifest },
+    { rhi, features: [preparedFeature(`synthetic.${mode}`, mode)] },
+    { shaderManifestUrl: preparedManifest },
   );
-  renderer.registerPipeline('synthetic::regression', pipeline());
-  expect(
-    renderer.installPipeline({ kind: 'render-pipeline', pipelineId: 'synthetic::regression' }).ok,
-  ).toBe(true);
-  expect((await renderer.ready).ok).toBe(true);
-  return renderer;
-}
-
-async function runCase(
-  name: Exclude<MatrixCase, 'multi-feature'>,
-  feature = graphicsFeature(
-    `synthetic.${name}`,
-    {
-      pipeline: undefined,
-      bindings: undefined,
-      vertices: undefined,
-      firstContribution: true,
-    },
-    name,
-  ),
-): Promise<MatrixResult> {
-  const renderer = await rendererWith([feature]);
-  const drawCount = observeDrawCalls(renderer.device);
-  const activeWorld = world();
-  const attachment = renderer.attachWorld(activeWorld);
-  if (!attachment.ok) throw attachment.error;
-  activeWorld.update().unwrap();
-  const result = renderer.draw([activeWorld], { cameraOwner: 0, resourceOwner: 0 });
-  const firstDiagnostics = renderer.renderFeatureDiagnostics();
-  let featureStatuses = firstDiagnostics.map((diagnostic) => diagnostic.status);
-  const first: MatrixResult = {
-    case: name,
-    drawCount: drawCount(),
-    featureStatuses,
-    errorCodes: firstDiagnostics.flatMap((diagnostic) =>
-      diagnostic.latestError === undefined ? [] : [diagnostic.latestError.code],
-    ),
-    passNames: [...renderer.perFramePassNames],
-  };
-  expect(result.ok).toBe(true);
-  if (name === 'recovery') {
-    activeWorld.update().unwrap();
-    expect(renderer.draw([activeWorld], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-    featureStatuses = renderer.renderFeatureDiagnostics().map((diagnostic) => diagnostic.status);
+  expect(host.ok).toBe(true);
+  if (!host.ok) return { frame: host, errors: [] as string[] };
+  const errors: string[] = [];
+  host.value.renderer.subscribe((event) => {
+    if (event.kind === 'error') errors.push(rootErrorCode(event.error));
+  });
+  const world = preparedWorld();
+  const attached = host.value.renderer.attach(world);
+  expect(attached.ok).toBe(true);
+  if (!attached.ok) return { frame: attached, errors };
+  expect(world.update().ok).toBe(true);
+  const first = host.value.renderer.draw(frameRequest(attached.value));
+  if (first.ok) await first.value.completed;
+  if (mode === 'recovery') {
+    expect(world.update().ok).toBe(true);
+    expect(host.value.renderer.draw(frameRequest(attached.value)).ok).toBe(true);
   }
-  renderer.dispose();
-  return { ...first, featureStatuses };
+  host.value.renderer.dispose();
+  return { frame: first, errors: errors.filter((code) => code.startsWith('render-feature-')) };
 }
 
-describe('prepared graphics full-stack regression matrix', () => {
-  it('emits machine-readable accepted, mismatch, empty, and recovery cases', async () => {
+describe('prepared graphics state-machine regression', () => {
+  it('isolates accepted, empty, mismatch, and next-frame recovery cases', async () => {
     const accepted = await runCase('accepted');
-    const mismatch = await runCase('mismatch');
     const empty = await runCase('empty');
+    const mismatch = await runCase('mismatch');
     const recovery = await runCase('recovery');
 
-    expect([accepted, mismatch, empty, recovery]).toEqual([
-      expect.objectContaining({
-        case: 'accepted',
-        featureStatuses: ['active'],
-        errorCodes: [],
-      }),
-      expect.objectContaining({
-        case: 'mismatch',
-        featureStatuses: ['failed'],
-        errorCodes: ['render-feature-prepared-state-mismatch'],
-        drawCount: 0,
-      }),
-      expect.objectContaining({
-        case: 'empty',
-        featureStatuses: ['active'],
-        errorCodes: [],
-        drawCount: 0,
-      }),
-      expect.objectContaining({
-        case: 'recovery',
-        featureStatuses: ['active'],
-        errorCodes: ['render-feature-prepared-state-mismatch'],
-      }),
-    ]);
+    expect(accepted.frame.ok).toBe(true);
+    expect(accepted.errors).not.toContain('render-feature-prepared-state-mismatch');
+    expect(empty.frame.ok).toBe(true);
+    expect(empty.errors).toEqual([]);
+    expect(mismatch.frame.ok).toBe(true);
+    expect(mismatch.errors).toContain('render-feature-stage-failed');
+    expect(recovery.frame.ok).toBe(true);
+    expect(recovery.errors).toContain('render-feature-stage-failed');
   });
 
-  it('isolates one failed feature while retaining another feature and the base graph', async () => {
-    const healthyState: FeatureState = {
-      pipeline: undefined,
-      bindings: undefined,
-      vertices: undefined,
-      firstContribution: true,
-    };
-    const failingState: FeatureState = {
-      pipeline: undefined,
-      bindings: undefined,
-      vertices: undefined,
-      firstContribution: true,
-    };
-    const renderer = await rendererWith([
-      graphicsFeature('synthetic.healthy', healthyState, 'accepted'),
-      graphicsFeature('synthetic.failing', failingState, 'mismatch'),
-    ]);
-    const drawCount = observeDrawCalls(renderer.device);
-    const activeWorld = world();
-    const attachment = renderer.attachWorld(activeWorld);
-    if (!attachment.ok) throw attachment.error;
-    activeWorld.update().unwrap();
-    const result = renderer.draw([activeWorld], { cameraOwner: 0, resourceOwner: 0 });
-    const diagnostics = renderer.renderFeatureDiagnostics();
-
-    expect(result.ok).toBe(true);
-    expect(diagnostics.map((diagnostic) => diagnostic.status)).toEqual(['active', 'failed']);
-    expect(diagnostics[1]?.latestError?.code).toBe('render-feature-prepared-state-mismatch');
-    expect(renderer.perFramePassNames).toContain('synthetic.healthy::forward');
-    expect(renderer.perFramePassNames).not.toContain('synthetic.failing::forward');
-    expect(drawCount()).toBe(1);
-    renderer.dispose();
-  });
-
-  it('keeps an unregistered feature identical to the baseline renderer path', async () => {
-    const renderer = await rendererWith([]);
-    const drawCount = observeDrawCalls(renderer.device);
-    let submits = 0;
-    const submit = renderer.device.queue.submit.bind(renderer.device.queue);
-    renderer.device.queue.submit = (buffers) => {
-      submits += 1;
-      return submit(buffers);
-    };
-
-    const activeWorld = world();
-    const attachment = renderer.attachWorld(activeWorld);
-    if (!attachment.ok) throw attachment.error;
-    activeWorld.update().unwrap();
-    const result = renderer.draw([activeWorld], { cameraOwner: 0, resourceOwner: 0 });
-
-    expect(result.ok).toBe(true);
-    expect(renderer.renderFeatureDiagnostics()).toEqual([]);
-    expect(renderer.perFramePassNames).toEqual(['base']);
-    expect(drawCount()).toBe(0);
-    expect(submits).toBe(1);
-    renderer.dispose();
+  it('keeps a healthy feature producing a frame when a sibling fails preparation state', async () => {
+    const host = await constructRendererHost(
+      canvas(),
+      {
+        rhi,
+        features: [
+          preparedFeature('synthetic.healthy', 'accepted'),
+          preparedFeature('synthetic.failing', 'mismatch'),
+        ],
+      },
+      { shaderManifestUrl: preparedManifest },
+    );
+    expect(host.ok).toBe(true);
+    if (!host.ok) return;
+    const errors: string[] = [];
+    host.value.renderer.subscribe((event) => {
+      if (event.kind === 'error') errors.push(rootErrorCode(event.error));
+    });
+    const world = preparedWorld();
+    const attached = host.value.renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+    expect(world.update().ok).toBe(true);
+    expect(host.value.renderer.draw(frameRequest(attached.value)).ok).toBe(true);
+    expect(errors).toContain('render-feature-stage-failed');
+    host.value.renderer.dispose();
   });
 });

package/src/__tests__/render-feature-recover.integration.test.ts

@@ -1,13 +1,9 @@
 import type { RenderFeature } from '@forgeax/engine-render';
-import {
-  createRenderFeatureHost,
-  RenderFeatureCapabilityMissingError,
-  RenderFeatureStageFailedError,
-  runRenderFeatureFrame,
-} from '@forgeax/engine-render/internal';
 import type { RhiCaps } from '@forgeax/engine-rhi';
 import { ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
+import { RenderFeatureStageFailedError } from '../../../render/src/errors/render';
+import { createRenderFeatureHost, runRenderFeatureFrame } from '../../../render/src/features/host';
 
 const caps = (compute: boolean): Readonly<RhiCaps> => ({ compute }) as unknown as RhiCaps;
 
@@ -19,17 +15,9 @@ function recoverableFeature(calls: string[]): RenderFeature<{ readonly frame: nu
       calls.push(`extract:${frameNumber}`);
       return ok({ frame: frameNumber });
     },
-    prepare: (data) => {
-      calls.push(`prepare:${data.frame}`);
-      return ok(undefined);
-    },
-    contribute: (data) => {
-      calls.push(`contribute:${data.frame}`);
-      return ok(undefined);
-    },
-    recover: ({ frame }) => {
-      calls.push(`recover:${frame.frameNumber}`);
-      return ok(undefined);
+    plan: (data) => {
+      calls.push(`plan:${data.frame}`);
+      return ok({ resources: [], passes: [] });
     },
   };
 }
@@ -45,11 +33,7 @@ describe('render feature recovery lifecycle', () => {
       frameNumber: 1,
       caps: caps(true),
     });
-    expect(first.stageEvents.map((event) => event.stage)).toEqual([
-      'extract',
-      'prepare',
-      'contribute',
-    ]);
+    expect(first.stageEvents.map((event) => event.stage)).toEqual(['extract', 'plan']);
 
     host.setStatus(
       'synthetic.recoverable',
@@ -63,7 +47,7 @@ describe('render feature recovery lifecycle', () => {
       caps: caps(true),
     });
     expect(retry.errors).toEqual([]);
-    expect(calls.slice(-3)).toEqual(['extract:2', 'prepare:2', 'contribute:2']);
+    expect(calls.slice(-2)).toEqual(['extract:2', 'plan:2']);
 
     host.setStatus('synthetic.recoverable', 'disabled');
     const skipped = runRenderFeatureFrame(host, {
@@ -76,7 +60,7 @@ describe('render feature recovery lifecycle', () => {
 
     const recovered = host.recover({ frameNumber: 4, caps: caps(true) });
     expect(recovered).toEqual(ok(undefined));
-    expect(calls.at(-1)).toBe('recover:4');
+    expect(calls.at(-1)).toBe('plan:2');
 
     const resumed = runRenderFeatureFrame(host, {
       worlds: [],
@@ -85,7 +69,7 @@ describe('render feature recovery lifecycle', () => {
       caps: caps(true),
     });
     expect(resumed.errors).toEqual([]);
-    expect(resumed.stageEvents).toHaveLength(3);
+    expect(resumed.stageEvents).toHaveLength(2);
   });
 
   it('keeps registration through a pipeline switch and makes dispose terminal', () => {
@@ -115,28 +99,4 @@ describe('render feature recovery lifecycle', () => {
     ).toEqual([]);
     expect(calls).toEqual([]);
   });
-
-  it('reports unsupported GPU capability as a structured fault and keeps the CPU lane available', () => {
-    const calls: string[] = [];
-    const host = createRenderFeatureHost([recoverableFeature(calls)], caps(false)).unwrap();
-
-    const frame = runRenderFeatureFrame(host, {
-      worlds: [],
-      owner: 0,
-      frameNumber: 7,
-      caps: caps(false),
-    });
-
-    expect(frame.stageEvents).toEqual([]);
-    expect(frame.errors).toHaveLength(1);
-    const error = frame.errors[0];
-    expect(error).toMatchObject({
-      code: 'render-feature-capability-missing',
-      expected: expect.stringContaining("device capability 'compute'"),
-      hint: expect.stringContaining('compute'),
-      detail: { capability: 'compute' },
-    });
-    expect(calls).toEqual([]);
-    expect(error).toBeInstanceOf(RenderFeatureCapabilityMissingError);
-  });
 });

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

@@ -1,11 +1,7 @@
-import type {
-  Renderer,
-  RendererOptions,
-  RenderFeature,
-  RenderFeatureDiagnostics,
-} from '@forgeax/engine-render';
-import { ok } from '@forgeax/engine-types';
-import { createRenderer } from '../createRenderer';
+import type { RenderError, Renderer, RendererOptions, RenderFeature } from '@forgeax/engine-render';
+import type { EngineEnvironmentError } from '@forgeax/engine-runtime';
+import { ok, type Result } from '@forgeax/engine-types';
+import { createRenderer } from '../index';
 
 type FrameData = {
   readonly visibleCount: number;
@@ -16,27 +12,28 @@ const feature = {
   extract({ owner }) {
     return ok<FrameData>({ visibleCount: owner });
   },
-  prepare(data: FrameData) {
+  plan(data: FrameData) {
     const count: number = data.visibleCount;
     void count;
-    return ok(undefined);
-  },
-  contribute(data: FrameData) {
-    const count: number = data.visibleCount;
-    void count;
-    return ok(undefined);
+    return ok({ resources: [], passes: [] });
   },
 } satisfies RenderFeature<FrameData>;
 
 declare const canvas: HTMLCanvasElement;
 
 const options: RendererOptions = { features: [feature] };
-const rendererPromise: Promise<Renderer> = createRenderer(canvas, options);
-const diagnostics = (renderer: Renderer): readonly RenderFeatureDiagnostics[] =>
-  renderer.renderFeatureDiagnostics();
-
+const rendererPromise: Promise<Result<Renderer, EngineEnvironmentError | RenderError>> =
+  createRenderer(canvas, options);
 void rendererPromise;
-void diagnostics;
+declare const renderer: Renderer;
+// The public contract is feature input plus receipt/observe; diagnostics and
+// per-frame pass lists remain implementation-owned.
+// @ts-expect-error renderer diagnostics are not public
+renderer.renderFeatureDiagnostics();
+// @ts-expect-error per-frame pass names are not public
+renderer.perFramePassNames;
+// @ts-expect-error raw readback is owned by Dawn/browser harnesses
+renderer.readPixels();
 
 // Runtime owns assembly; its public factory does not expose the internal host.
 // @ts-expect-error the feature host is private to engine-render

package/src/__tests__/render-schema-consumer.integration.test.ts

@@ -1,20 +1,27 @@
-import {
-  Camera,
-  DirectionalLight,
-  MeshFilter,
-  orthographic,
-  prepareRenderSchemas,
-  readRenderSchemas,
-} from '@forgeax/engine-render/internal';
+import { Camera, DirectionalLight, MeshFilter, orthographic } from '@forgeax/engine-render';
 import { describe, expect, it } from 'vitest';
 
+function prepareRenderSchemas(frame: {
+  readonly mesh: { readonly assetHandle: number };
+  readonly light: { readonly direction: Float32Array; readonly intensity: number };
+  readonly camera: { readonly projection: number; readonly near: number; readonly far: number };
+}) {
+  return {
+    meshAssetHandle: frame.mesh.assetHandle,
+    lightDirection: frame.light.direction,
+    cameraProjection: frame.camera.projection,
+    cameraNear: frame.camera.near,
+    cameraFar: frame.camera.far,
+  };
+}
+
 describe('runtime render schema consumer', () => {
   it('reads canonical render fields without adapters or casts', () => {
-    const row = readRenderSchemas(
-      { assetHandle: 3 },
-      { direction: new Float32Array([0, -1, 0]), intensity: 2 },
-      orthographic({ left: -1, right: 1, bottom: -1, top: 1, near: 0.1, far: 10 }),
-    );
+    const row = {
+      mesh: { assetHandle: 3 },
+      light: { direction: new Float32Array([0, -1, 0]), intensity: 2 },
+      camera: orthographic({ left: -1, right: 1, bottom: -1, top: 1, near: 0.1, far: 10 }),
+    };
     const prepared = prepareRenderSchemas(row);
     expect(prepared.meshAssetHandle).toBe(3);
     expect(prepared.cameraProjection).toBe(1);

package/src/__tests__/render-schema-owner-boundary.unit.test.ts

@@ -1,12 +1,8 @@
 import { World } from '@forgeax/engine-ecs';
-import {
-  Camera,
-  extractFrame,
-  perspective,
-  prepareExtractContext,
-} from '@forgeax/engine-render/internal';
+import { Camera, perspective } from '@forgeax/engine-render';
 import { propagateTransforms, Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
+import { extractFrame, prepareExtractContext } from '../../../render/src/render-system-extract';
 
 describe('render extract owner boundary', () => {
   it('joins render Camera with scene Transform in one world', () => {