@forgeax/engine-runtime 0.1.4 → 0.1.6

package/src/__tests__/serialize-scene-asset.test.ts

@@ -1,3 +1,5 @@
+import * as SceneOwner from '@forgeax/engine-scene';
+
 // M3 test -- serializeSceneAssetToPack schema-derived field dispatch + fail-fast
 // (plan-strategy D-1/D-2: collect + serialize share same classifier;
 //  AC-14: serialize schema-derived refs index + fail-fast on unresolved GUID;
@@ -8,11 +10,17 @@
 //          + GUID unresolved fail-fast (AC-14)
 //   m3-t2: unregistered component silently skipped, other components intact (AC-15)
 
-import { defineComponent, World } from '@forgeax/engine-ecs';
-import type { LocalEntityId, SceneAsset } from '@forgeax/engine-types';
+import { AnimationPlayer } from '@forgeax/engine-animation';
+import type { Asset } from '@forgeax/engine-assets-runtime';
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { type Component, defineComponent, type EntityHandle, World } from '@forgeax/engine-ecs';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import { SceneInstance } from '@forgeax/engine-render';
+import type { LocalEntityId, MountOverride, SceneAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { serializeSceneAssetToPack } from '../collect-scene-asset';
-import '@forgeax/engine-render/internal';
+import { rootsToSceneAsset, serializeSceneAssetToPack } from '../collect-scene-asset';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+import { registerSceneComponents } from './helpers/register-scene-components';
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // Helpers
@@ -22,6 +30,44 @@ function localId(n: number): LocalEntityId {
   return n as LocalEntityId;
 }
 
+function mkReg(): AssetRegistry {
+  return new AssetRegistry(makeMockShaderRegistry());
+}
+function pg(s: string): AssetGuid {
+  const r = AssetGuid.parse(s);
+  if (!r.ok) throw new Error(`bad GUID: ${s}`);
+  return r.value;
+}
+function catScene(reg: AssetRegistry, g: string, p: SceneAsset): void {
+  reg.catalog(pg(g), p as Asset);
+}
+function rs(w: World, a: SceneAsset) {
+  registerSceneComponents(w, [AnimationPlayer, W18_ScalarShared]);
+  return w.allocSharedRef('SceneAsset', a);
+}
+
+function componentMap(...components: readonly Component[]): ReadonlyMap<string, Component> {
+  return new Map(components.map((component) => [component.name, component]));
+}
+function findMountedMember(w: World, rootA: EntityHandle): EntityHandle {
+  for (const c of w.iterDescendants(rootA)) {
+    if (c === rootA) continue;
+    if (!w.get(c, SceneInstance).ok) continue;
+    const st = SceneOwner.worldGetSceneInstanceState(w, c);
+    if (!st.ok) continue;
+    for (const [member] of st.value.entityToLocalId) return member;
+  }
+  throw new Error('no mounted member found');
+}
+function firstMountOverride(scene: SceneAsset, comp: string): MountOverride | undefined {
+  for (const m of scene.mounts ?? []) {
+    for (const ov of m.overrides ?? []) {
+      if (ov.comp === comp) return ov;
+    }
+  }
+  return undefined;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // m3-t1: serialize refs index with schema derivation (AC-14)
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -32,8 +78,6 @@ describe('m3-t1: serialize refs index with schema derivation', () => {
       assetRef: { type: 'shared<TestAsset>' },
       // biome-ignore lint/suspicious/noExplicitAny: defineComponent constraint too strict for complex schema types
     } as any);
-    const world = new World();
-    world.components.register(component).unwrap();
 
     const guid1 = 'a0000000-a000-0000-0000-000000000001';
 
@@ -49,7 +93,7 @@ describe('m3-t1: serialize refs index with schema derivation', () => {
 
     const packResult = serializeSceneAssetToPack(
       sceneAsset,
-      world.components.entries(),
+      componentMap(component as Component),
       'scene-0000-0000-0000-000000000001',
     );
     expect(packResult.ok).toBe(true);
@@ -88,8 +132,6 @@ describe('m3-t1: serialize refs index with schema derivation', () => {
       sources: { type: 'array<shared<TestAsset>>' },
       // biome-ignore lint/suspicious/noExplicitAny: defineComponent constraint too strict
     } as any);
-    const world = new World();
-    world.components.register(component).unwrap();
 
     const guidA = 'b0000000-b000-0000-0000-000000000001';
     const guidB = 'b0000000-b000-0000-0000-000000000002';
@@ -106,7 +148,7 @@ describe('m3-t1: serialize refs index with schema derivation', () => {
 
     const packResult = serializeSceneAssetToPack(
       sceneAsset,
-      world.components.entries(),
+      componentMap(component as Component),
       'scene-bbbb-bbbb-bbbb-bbbbbbbbbbbb',
     );
     expect(packResult.ok).toBe(true);
@@ -143,8 +185,6 @@ describe('m3-t1: serialize refs index with schema derivation', () => {
       tileset: { type: 'shared<TestAsset>' },
       // biome-ignore lint/suspicious/noExplicitAny: defineComponent constraint too strict
     } as any);
-    const world = new World();
-    world.components.register(component).unwrap();
 
     const tilesetGuid = 'c0000000-c000-0000-0000-000000000001';
 
@@ -160,7 +200,7 @@ describe('m3-t1: serialize refs index with schema derivation', () => {
 
     const packResult = serializeSceneAssetToPack(
       sceneAsset,
-      world.components.entries(),
+      componentMap(component as Component),
       'scene-cccc-cccc-cccc-cccccccccccc',
     );
     expect(packResult.ok).toBe(true);
@@ -181,8 +221,6 @@ describe('m3-t1: serialize refs index with schema derivation', () => {
       loneRef: { type: 'shared<TestAsset>' },
       // biome-ignore lint/suspicious/noExplicitAny: defineComponent constraint too strict for complex schema types
     } as any);
-    const world = new World();
-    world.components.register(component).unwrap();
 
     // Use a non-string value in the shared<> field — this bypasses Phase 1 GUID
     // collection (only strings are collected), so Phase 2 index lookup will fail.
@@ -204,7 +242,7 @@ describe('m3-t1: serialize refs index with schema derivation', () => {
     // and the happy path produces ok.
     const packResult = serializeSceneAssetToPack(
       sceneAsset,
-      world.components.entries(),
+      componentMap(component as Component),
       'scene-dddd-dddd-dddd-dddddddddddd',
     );
     expect(packResult.ok).toBe(true);
@@ -231,8 +269,6 @@ describe('m3-t2: unregistered component silently skipped', () => {
     const component = defineComponent('Test_SRegComp', {
       val: 'f32',
     });
-    const world = new World();
-    world.components.register(component).unwrap();
 
     const sceneAsset: SceneAsset = {
       kind: 'scene',
@@ -249,7 +285,7 @@ describe('m3-t2: unregistered component silently skipped', () => {
 
     const packResult = serializeSceneAssetToPack(
       sceneAsset,
-      world.components.entries(),
+      componentMap(component as Component),
       'scene-eeee-eeee-eeee-eeeeeeeeeeee',
     );
     expect(packResult.ok).toBe(true);
@@ -286,8 +322,6 @@ describe('m3-t2: unregistered component silently skipped', () => {
     const component = defineComponent('Test_SRegComp2', {
       count: 'i32',
     });
-    const world = new World();
-    world.components.register(component).unwrap();
 
     const sceneAsset: SceneAsset = {
       kind: 'scene',
@@ -304,7 +338,7 @@ describe('m3-t2: unregistered component silently skipped', () => {
 
     const packResult = serializeSceneAssetToPack(
       sceneAsset,
-      world.components.entries(),
+      componentMap(component as Component),
       'scene-ffff-ffff-ffff-ffffffffffff',
     );
     expect(packResult.ok).toBe(true);
@@ -334,3 +368,166 @@ describe('m3-t2: unregistered component silently skipped', () => {
 });
 
 // ═══════════════════════════════════════════════════════════════════════════════
+// w18 — AC-05: collect-side handle→GUID two-state NULL-sentinel in override values
+//
+// Override values carry shared<T> fields (scalar) and array<shared<T>> fields
+// (positional SoA, e.g. AnimationPlayer.clips = [h, 0, 0, 0]). rootsToSceneAsset
+// folds an add-override, then serializes its shared fields by reverse-looking-up
+// each live handle to its catalogued GUID. The NULL-sentinel (handle 0) has two
+// distinct semantics that must survive round-trip (aligned to #640):
+//   - scalar shared handle 0  -> field omitted (deserialize restores slot-0 default)
+//   - array  shared handle 0  -> placeholder 0 kept (positional alignment w/ SoA)
+// A valid handle -> GUID string; a mixed array distinguishes the two per slot.
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const W18_CLIP0 = 'a1a1a1a1-1111-4111-8111-111111111111';
+const W18_CLIP1 = 'b2b2b2b2-2222-4222-8222-222222222222';
+const W18_CHILD = 'c3c3c3c3-3333-4333-8333-333333333333';
+const W18_PARENT = 'd4d4d4d4-4444-4444-8444-444444444444';
+const W18_SCALAR = 'e5e5e5e5-5555-4555-8555-555555555555';
+
+// A component whose override value carries a scalar shared field, so the scalar
+// NULL-sentinel (omit) vs valid-handle (GUID) branch is exercised.
+const W18_ScalarShared = defineComponent('W18_ScalarShared', {
+  asset: { type: 'shared<TestAsset>' },
+  tag: 'f32',
+  // biome-ignore lint/suspicious/noExplicitAny: defineComponent constraint too strict for shared<>
+} as any) as Component;
+
+/**
+ * Mint a shared handle pointing at the SAME payload object that is catalogued
+ * under `guid`, so collect-side `_guidForAsset` reverse-resolves the handle back
+ * to `guid` (identity scan, asset-registry.ts _guidForAsset).
+ */
+function mintCatalogued(reg: AssetRegistry, w: World, guid: string, tag: number): number {
+  const payload = { kind: 'animation-clip', tag } as unknown as Asset;
+  reg.catalog(pg(guid), payload);
+  return w.allocSharedRef('AnimationClip', payload) as unknown as number;
+}
+
+/** Build parent scene mounting one bare child; instantiate; return root. */
+function mountOne(reg: AssetRegistry, w: World): EntityHandle {
+  const child: SceneAsset = {
+    kind: 'scene',
+    entities: [{ localId: localId(0), components: { Transform: { pos: [1, 0, 0] } } }],
+  };
+  catScene(reg, W18_CHILD, child);
+  const parent: SceneAsset = {
+    kind: 'scene',
+    entities: [{ localId: localId(0), components: { Transform: { pos: [0, 0, 0] } } }],
+    mounts: [{ localId: localId(1), source: W18_CHILD, memberFirst: localId(2), memberCount: 1 }],
+  };
+  catScene(reg, W18_PARENT, parent);
+  const inst = reg.instantiate(rs(w, parent), w);
+  if (!inst.ok) throw new Error('instantiate failed');
+  return inst.value;
+}
+
+describe('w18 — override-value shared handle→GUID two-state NULL-sentinel (AC-05)', () => {
+  it('(a) array<shared<>> mixed valid handle + NULL sentinel -> GUID string + placeholder 0', () => {
+    const reg = mkReg();
+    const w = new World();
+    const root = mountOne(reg, w);
+    const member = findMountedMember(w, root);
+
+    // clips = [validHandle, 0, 0, 0] — slot 0 active, slots 1-3 NULL sentinel.
+    // M1 migration: AnimationPlayer.clips is now variable-length; we explicitly
+    // provide the 0-sentinel slots to test the NULL-sentinel round-trip.
+    const clipH = mintCatalogued(reg, w, W18_CLIP0, 0);
+    const add = w.addComponent(member, {
+      component: AnimationPlayer,
+      data: { clips: [clipH, 0, 0, 0] } as never,
+    });
+    expect(add.ok).toBe(true);
+
+    const collect = rootsToSceneAsset(reg, w, [root]);
+    expect(collect.ok).toBe(true);
+    if (!collect.ok) return;
+    const ov = firstMountOverride(collect.value, 'AnimationPlayer');
+    expect(ov).toBeDefined();
+    if (!ov) return;
+    const clips = (ov.value as Record<string, unknown>).clips as unknown[];
+    expect(Array.isArray(clips)).toBe(true);
+    // slot 0 -> GUID string; slots 1-3 -> numeric 0 placeholder (positional).
+    expect(typeof clips[0]).toBe('string');
+    expect(clips[0]).toBe(W18_CLIP0);
+    expect(clips[1]).toBe(0);
+    expect(clips[2]).toBe(0);
+    expect(clips[3]).toBe(0);
+  });
+
+  it('(b) array<shared<>> two valid handles at slots 0 and 1 -> two distinct GUIDs', () => {
+    const reg = mkReg();
+    const w = new World();
+    const root = mountOne(reg, w);
+    const member = findMountedMember(w, root);
+
+    const h0 = mintCatalogued(reg, w, W18_CLIP0, 10);
+    const h1 = mintCatalogued(reg, w, W18_CLIP1, 11);
+    const add = w.addComponent(member, {
+      component: AnimationPlayer,
+      data: { clips: [h0, h1] } as never,
+    });
+    expect(add.ok).toBe(true);
+
+    const collect = rootsToSceneAsset(reg, w, [root]);
+    expect(collect.ok).toBe(true);
+    if (!collect.ok) return;
+    const ov = firstMountOverride(collect.value, 'AnimationPlayer');
+    expect(ov).toBeDefined();
+    if (!ov) return;
+    const clips = (ov.value as Record<string, unknown>).clips as unknown[];
+    expect(clips.length).toBe(2);
+    expect(clips[0]).toBe(W18_CLIP0);
+    expect(clips[1]).toBe(W18_CLIP1);
+  });
+
+  it('(c) scalar shared<> valid handle -> GUID string (non-null branch)', () => {
+    expect(W18_ScalarShared.name).toBe('W18_ScalarShared');
+    const reg = mkReg();
+    const w = new World();
+    const root = mountOne(reg, w);
+    const member = findMountedMember(w, root);
+
+    const h = mintCatalogued(reg, w, W18_SCALAR, 0);
+    const add = w.addComponent(member, {
+      component: W18_ScalarShared,
+      data: { asset: h, tag: 7 } as never,
+    });
+    expect(add.ok).toBe(true);
+
+    const collect = rootsToSceneAsset(reg, w, [root]);
+    expect(collect.ok).toBe(true);
+    if (!collect.ok) return;
+    const ov = firstMountOverride(collect.value, 'W18_ScalarShared');
+    expect(ov).toBeDefined();
+    if (!ov) return;
+    const val = ov.value as Record<string, unknown>;
+    expect(val.asset).toBe(W18_SCALAR); // valid handle -> GUID string
+    expect(val.tag).toBe(7);
+  });
+
+  it('(d) scalar shared<> handle 0 -> field omitted (NULL-sentinel branch)', () => {
+    const reg = mkReg();
+    const w = new World();
+    const root = mountOne(reg, w);
+    const member = findMountedMember(w, root);
+
+    const add = w.addComponent(member, {
+      component: W18_ScalarShared,
+      data: { asset: 0, tag: 3 } as never,
+    });
+    expect(add.ok).toBe(true);
+
+    const collect = rootsToSceneAsset(reg, w, [root]);
+    expect(collect.ok).toBe(true);
+    if (!collect.ok) return;
+    const ov = firstMountOverride(collect.value, 'W18_ScalarShared');
+    expect(ov).toBeDefined();
+    if (!ov) return;
+    const val = ov.value as Record<string, unknown>;
+    // scalar handle 0 -> field omitted (deserialize restores slot-0 default).
+    expect('asset' in val).toBe(false);
+    expect(val.tag).toBe(3);
+  });
+});

package/src/__tests__/shadow-caster-empty-schema.test.ts

@@ -26,9 +26,9 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { appendInjection } from '@forgeax/engine-render/internal';
 import { derive } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
+import { appendInjection } from '../../../render/src/pbr-pipeline';
 
 const repoRoot = (() => {
   // packages/runtime/src/__tests__/<this file>.ts -> repo root
@@ -72,8 +72,8 @@ describe('shadow_caster empty schema (M4 w21)', () => {
       'packages',
       'render',
       'src',
-      'renderer',
-      'renderer-factory.ts',
+      'assembly',
+      'factory.ts',
     );
     const src = readFileSync(createRendererPath, 'utf8');
     const re =

package/src/__tests__/shadow-csm-cascade-loadop.test.ts

@@ -1,8 +1,8 @@
-// shadow-csm-cascade-loadop.test.ts - bug-20260619-csm-f9-per-cascade-depth-clear
+// shadow-csm-cascade-loadop.test.ts - typed shadow per-cascade depth clear
 // @perf-budget-skip - the two truth-table cases intentionally drive the full renderer call site.
 // M1: per-cascade depth loadOp truth table, asserted against the REAL call site.
 //
-// The fix lives at render-system-record.ts:3200-3207, inside recordShadowPass:
+// The invariant is owned by the typed shadow graph's cascade recording path:
 //   buildBeginRenderPassDescriptor(..., 'shadow-caster',
 //     { depthLoadOp: cascadeIndex === 0 ? 'clear' : 'load' })
 //
@@ -10,8 +10,8 @@
 // pure builder (that would be tautological — the bug could regress verbatim
 // while the suite stays green). Instead it drives the whole pipeline through
 // createRenderer + renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }): the URP cascade loop calls
-// addShadowPass per cascade, whose execute closure invokes the real
-// recordShadowPass(c, selector, viewport, cascadeIndex). A mock GPU device
+// one typed shadow pass per cascade, whose execute closure invokes the real
+// encodeDirectionalShadowPass(c, pass, cascadeIndex, viewport). A mock GPU device
 // captures every descriptor handed to beginRenderPass on the dedicated
 // 'render-system-shadow' command encoder, so the asserted truth table is the
 // engine's decision at the real call site — flip the ternary to a constant and
@@ -21,7 +21,6 @@ import type { World as WorldType } from '@forgeax/engine-ecs';
 import type { Renderer as RendererType } from '@forgeax/engine-render';
 import type { Handle } from '@forgeax/engine-types';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { TEST_CUBE_HANDLE, withPrimitiveMeshes } from './helpers/primitive-world';
 
 const ENGINE = '../createRenderer';
 
@@ -185,17 +184,29 @@ async function importEngine(): Promise<{
     opts?: unknown,
     bundler?: unknown,
   ) => Promise<{
-    ready: Promise<void>;
+    subscribe: (listener: (event: unknown) => void) => () => void;
     draw: (worlds: unknown, opts: { cameraOwner: number; resourceOwner: number }) => void;
-    onError: (cb: (err: { code: string }) => void) => () => void;
   }>;
 }> {
-  return (await import(ENGINE)) as never;
+  const engine = (await import(ENGINE)) as {
+    createRenderer: (...args: readonly unknown[]) => Promise<unknown>;
+  };
+  return {
+    createRenderer: async (...args: readonly unknown[]) => {
+      const result = (await engine.createRenderer(...args)) as
+        | { readonly ok: true; readonly value: unknown }
+        | { readonly ok: false; readonly error: unknown };
+      if (!result.ok) throw result.error;
+      return result.value as {
+        subscribe: (listener: (event: unknown) => void) => () => void;
+        draw: (worlds: unknown, opts: { cameraOwner: number; resourceOwner: number }) => void;
+      };
+    },
+  };
 }
 
 async function importEcs(): Promise<{ World: new () => unknown }> {
-  const { World: BaseWorld } = await import('@forgeax/engine-ecs');
-  return { World: withPrimitiveMeshes(BaseWorld) } as never;
+  return (await import('@forgeax/engine-ecs')) as never;
 }
 
 async function importComponents(): Promise<{
@@ -207,9 +218,9 @@ async function importComponents(): Promise<{
   HANDLE_CUBE: Handle<'MeshAsset', 'shared'>;
 }> {
   return {
-    ...(await import('@forgeax/engine-render/internal')),
+    ...(await import('@forgeax/engine-render')),
     ...(await import('@forgeax/engine-scene')),
-    HANDLE_CUBE: TEST_CUBE_HANDLE,
+    ...(await import('@forgeax/engine-assets-runtime')),
   } as never;
 }
 
@@ -239,7 +250,6 @@ async function drawCsmScene(cascadeCount: number): Promise<CaptureLog> {
     {},
     { shaderManifestUrl: buildManifestDataUrl() },
   );
-  await renderer.ready;
   const { World } = await importEcs();
   const C = await importComponents();
   const world = new (
@@ -275,8 +285,18 @@ async function drawCsmScene(cascadeCount: number): Promise<CaptureLog> {
   );
 
   const errors: { code: string }[] = [];
-  renderer.onError((e) => errors.push(e));
-  if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
+  renderer.subscribe((event) => {
+    if (
+      typeof event === 'object' &&
+      event !== null &&
+      'kind' in event &&
+      event.kind === 'error' &&
+      'error' in event
+    ) {
+      errors.push(event.error as { code: string });
+    }
+  });
+  if (!(renderer as unknown as RendererType).attach(world as WorldType).ok) {
     throw new Error('World attachment failed');
   }
   (world as WorldType).update().unwrap();
@@ -284,7 +304,7 @@ async function drawCsmScene(cascadeCount: number): Promise<CaptureLog> {
   return log;
 }
 
-describe('CSM per-cascade depth loadOp (real recordShadowPass call site)', () => {
+describe('CSM per-cascade depth loadOp (typed shadow call site)', () => {
   beforeEach(() => {
     vi.stubGlobal('navigator', { ...baseNavigator });
   });
@@ -295,7 +315,7 @@ describe('CSM per-cascade depth loadOp (real recordShadowPass call site)', () =>
 
   // ── AC-03: cascadeCount=4 truth table (drives the real call site) ──────────
   // N=4 cascades share a single shadowDepth atlas. Each cascade pass routes
-  // through recordShadowPass -> beginRenderPass with the per-cascade override.
+  // through the typed shadow graph -> beginRenderPass with the per-cascade override.
   // The captured descriptors must read: cascade 0 -> clear + depthClearValue,
   // cascades 1..3 -> load + no depthClearValue.
 

package/src/__tests__/shadow-csm-component.test.ts

@@ -8,12 +8,10 @@
 
 import { World } from '@forgeax/engine-ecs';
 import { componentDefinition, componentSchema } from '@forgeax/engine-ecs/internal';
-import {
-  DirectionalLight,
-  ShadowInvalidConfigError,
-  validateDirectionalLightData,
-} from '@forgeax/engine-render/internal';
+import { DirectionalLight } from '@forgeax/engine-render';
 import { describe, expect, it } from 'vitest';
+import { validateDirectionalLightData } from '../../../render/src/components/light-helpers';
+import { ShadowInvalidConfigError } from '../../../render/src/errors/render';
 
 type DirectionalSpawnResult = ReturnType<World['spawn']>;
 

package/src/__tests__/shadow-csm-extract.test.ts

@@ -12,24 +12,13 @@
 // castShadow: true; lightViewProj won't populate.
 
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
-import {
-  Camera,
-  DirectionalLight,
-  extractFrame,
-  extractFrames,
-  MeshFilter,
-  MeshRenderer,
-  prepareExtractContext,
-} from '@forgeax/engine-render/internal';
+import { Camera, DirectionalLight } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
-import { executeCpuMultiViewVisibility } from '../../../render/src/gpu-driven/view-gpu';
-import { buildRenderVisibilityViewDescriptors } from '../../../render/src/render-system-extract';
+import { extractFrame, prepareExtractContext } from '../../../render/src/render-system-extract';
 
 function makeWorld(castShadow?: boolean): World {
   const world = new World();
-  const cubeHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
   world.spawn({
     component: DirectionalLight,
     data: {
@@ -47,11 +36,6 @@ function makeWorld(castShadow?: boolean): World {
       data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 },
     },
   );
-  world.spawn(
-    { component: Transform, data: { pos: [0, 0, -8] } },
-    { component: MeshFilter, data: { assetHandle: cubeHandle } },
-    { component: MeshRenderer, data: {} },
-  );
   return world;
 }
 
@@ -249,86 +233,4 @@ describe('ExtractedLights interface (M2 castShadow gate)', () => {
       expect(frame.lights.pcfKernelSize).toBe(3);
     });
   });
-
-  describe('M3 unified CPU multi-view contract', () => {
-    it('publishes four views and structured stable IDs/cascade masks', () => {
-      const world = makeWorld(true);
-      const frame = extractFrames([world], 0, undefined, undefined, undefined, undefined, {
-        cull: 'none',
-      });
-      const candidates = (frame.candidateRenderables ?? frame.renderables).map(
-        (snapshot, candidateIndex) => ({
-          stableId: snapshot.entityKey,
-          generation: 0,
-          candidateIndex,
-          worldAabb: undefined,
-          casterEligible: true,
-          batchId: undefined,
-          instanceOrdinal: undefined,
-        }),
-      );
-      const views = buildRenderVisibilityViewDescriptors({
-        camera: frame.cameras[0],
-        directionalCsm: frame.lights.directionalCsm,
-      });
-      const evidence = executeCpuMultiViewVisibility({
-        views,
-        candidates,
-        capacityByView: new Map(views.map((view) => [view.viewId, 32] as const)),
-      });
-
-      expect(views.map((view) => view.viewId)).toEqual([
-        'main',
-        'cascade-0',
-        'cascade-1',
-        'cascade-2',
-      ]);
-      expect(evidence.views).toHaveLength(4);
-      expect(evidence.views[0]?.kind).toBe('main');
-      expect(evidence.views.slice(1).every((view) => view.kind === 'cascade')).toBe(true);
-      expect(evidence.views[0]?.stableIds).toEqual(
-        candidates.map((candidate) => candidate.stableId),
-      );
-      expect(evidence.cascadeMasks).toHaveLength(candidates.length);
-      expect(evidence.cascadeMasks.some((entry) => entry.cascadeMask !== 0)).toBe(true);
-      expect(evidence.views.every((view) => view.overflow === false)).toBe(true);
-      expect(JSON.parse(JSON.stringify(evidence))).toMatchObject({
-        views: expect.arrayContaining([
-          expect.objectContaining({ viewId: 'main', stableIds: expect.any(Array) }),
-          expect.objectContaining({ viewId: 'cascade-0', compactVisible: expect.any(Array) }),
-        ]),
-        cascadeMasks: expect.any(Array),
-      });
-    });
-
-    it('keeps main visibility independent from a caster-only cascade domain', () => {
-      const world = makeWorld(true);
-      const frame = extractFrames([world], 0, undefined, undefined, undefined, undefined, {
-        cull: 'none',
-      });
-      const source = frame.candidateRenderables ?? frame.renderables;
-      const views = buildRenderVisibilityViewDescriptors({
-        camera: frame.cameras[0],
-        directionalCsm: frame.lights.directionalCsm,
-      });
-      const evidence = executeCpuMultiViewVisibility({
-        views,
-        candidates: source.map((snapshot, candidateIndex) => ({
-          stableId: snapshot.entityKey,
-          generation: 3,
-          candidateIndex,
-          worldAabb: undefined,
-          casterEligible: candidateIndex === 0,
-          batchId: undefined,
-          instanceOrdinal: undefined,
-        })),
-      });
-      const main = evidence.views.find((view) => view.kind === 'main');
-      const cascades = evidence.views.filter((view) => view.kind === 'cascade');
-      expect(main?.stableIds).toHaveLength(source.length);
-      expect(
-        cascades.every((view) => view.stableIds.every((id) => id === source[0]?.entityKey)),
-      ).toBe(true);
-    });
-  });
 });

package/src/__tests__/shadow-csm-orthoz.test.ts

@@ -23,14 +23,10 @@
 
 import { World } from '@forgeax/engine-ecs';
 import { mat4, vec3 } from '@forgeax/engine-math';
-import {
-  Camera,
-  DirectionalLight,
-  extractFrame,
-  prepareExtractContext,
-} from '@forgeax/engine-render/internal';
+import { Camera, DirectionalLight } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
+import { extractFrame, prepareExtractContext } from '../../../render/src/render-system-extract';
 
 // Light travelling down and toward +x/+z, so the source is up and toward -x/-z.
 const LIGHT_DIR: readonly [number, number, number] = [0.3, -1, 0.3];
@@ -96,9 +92,6 @@ describe('CSM ortho-Z reaches toward the light (real extract fit, AC-05)', () =>
 
     const caster = towardLightCaster(6);
     const ground = vec3.create(...GROUND_PT);
-    const volumeSet = frame.lights.directionalCsm;
-    expect(volumeSet?.volumes).toBe(volumeSet?.cascades);
-    expect(volumeSet?.revision).toBeGreaterThan(0);
 
     // Find every cascade whose XY footprint covers the GROUND fragment -- that
     // is the cascade `_pickCascadeLayer` will route the ground to. The caster
@@ -108,13 +101,6 @@ describe('CSM ortho-Z reaches toward the light (real extract fit, AC-05)', () =>
     for (let c = 0; c < count; c++) {
       const m = lvp[c];
       if (!(m instanceof Float32Array)) continue;
-      const volume = volumeSet?.volumes[c];
-      expect(volume?.lightViewProj).toBe(m);
-      expect(volume?.rasterLightBounds).toBe(volume?.clipLightBounds);
-      expect(volume?.depthLightRange).toEqual([
-        volume?.clipLightBounds[4],
-        volume?.clipLightBounds[5],
-      ]);
       const g = projectInto(m, ground);
       if (!g.inXY) continue;
       coveredGroundCascades++;