@forgeax/engine-runtime 0.1.4 → 0.1.6

package/src/__tests__/point-light-shadow.dawn.test.ts

@@ -1,5 +1,5 @@
 // point-light-shadow.dawn.test.ts
-// feat-20260612-point-light-shadows-urp-hdrp M0 / T-M0-1.
+// feat-20260612-point-light-shadows M0 / T-M0-1.
 //
 // Minimal dawn-node fixture: create texture_depth_cube_array (512x512 depth32float,
 // layers=1), execute textureSampleCompareLevel via a compute shader, read back
@@ -217,24 +217,23 @@ describe('M0 cube_array comparison sampler (dawn)', () => {
   });
 });
 
-// feat-20260612-point-light-shadows-urp-hdrp M4 / T-M4-8 (AC-10 dawn smoke).
+// feat-20260612-point-light-shadows M4 / T-M4-8 (AC-10 dawn smoke).
 //
-// Structural-only HDRP point-shadow smoke: validates that the shared
-// addPointShadowPass primitive (used by both URP and HDRP buildGraph
-// closures) produces an identical 6 x N pass-count topology when N
+// Structural-only Standard point-shadow smoke: validates that the shared
+// The typed point-shadow primitive produces an identical 6 x N pass-count topology when N
 // snapshots are queued. The actual dawn-node device path is exercised by
 // T-M0-1 above (cube_array comparison sampler); this smoke focuses on the
 // `recordPointShadowPass` 6-face inner loop invariant from the host side
 // — exactly what dawn-node would observe at the GPU layer were the BGL
 // hookup landed.
 //
-// Pixel readback of HDRP point-light shadow lands in M5 / T-M5-1 (AC-15
+// Pixel readback of the point-light shadow lands in M5 / T-M5-1 (AC-15
 // dawn-e2e).
-describe('M4 HDRP point shadow smoke (dawn structural)', () => {
-  it("'HDRP point shadow smoke' -- 6 x N pass-count topology preserved (AC-10)", async () => {
+describe('M4 Standard point shadow smoke (dawn structural)', () => {
+  it("'Standard point shadow smoke' -- 6 x N pass-count topology preserved (AC-10)", async () => {
     // recordPointShadowPass walks `frameState.pointShadowSnapshots` and emits
     // 6 face passes per non-undefined snapshot. The structural assertion is
-    // unit-testable without a GPU (mirrors the URP T-M3-5 topology test);
+    // unit-testable without a GPU and owned by the Standard point-shadow path;
     // the dawn-node project simply re-verifies the contract from the dawn
     // test harness so a future BGL hookup change cannot regress the topology
     // count without tripping at least one project.
@@ -248,36 +247,30 @@ describe('M4 HDRP point shadow smoke (dawn structural)', () => {
       expect(count).toBe(6 * n);
     }
   });
-
-  it("'HDRP point shadow smoke' -- hdrpPipeline.buildGraph imports addPointShadowPass (T-M4-1 wiring)", async () => {
-    const hdrpModule = await import('@forgeax/engine-render/internal');
-    expect(hdrpModule.hdrpPipeline).toBeDefined();
-    expect(typeof hdrpModule.hdrpPipeline.build).toBe('function');
-  });
 });
 
-// feat-20260612-point-light-shadows-urp-hdrp M5 / T-M5-1 (AC-15 e2e dawn pixel readback).
+// feat-20260612-point-light-shadows M5 / T-M5-1 (AC-15 e2e dawn pixel readback).
 //
 // End-to-end fixture proving the cube_array depth atlas + comparison sampler
 // primitive that point-light shadows ride on can distinguish "occluded"
 // (closer occluder depth) from "non-occluded" (open horizon depth) when both
 // fragments query the same cube atlas with different reference depths.
 //
-// Pipeline budget posture (scope-amended): the URP / HDRP shared
-// `pbr-view-bgl` extension to declare bindings 5 + 6 was deferred from M5
+// Pipeline budget posture (scope-amended): the shared `pbr-view-bgl`
+// extension to declare bindings 5 + 6 was deferred from M5
 // (T-M3-6 + T-M4-6 carry-over concern) because the cascade through
 // vite-plugin-shader define maps + createRenderer fallback resources +
 // render-system-record viewBindGroup builder + shadowParams per-frame fill
 // exceeds the M5 milestone budget. T-M5-1 is therefore implemented against
-// the same raw RHI primitive that the URP / HDRP shaders WILL sample once
+// the same raw RHI primitive that the Standard shaders sample through the
 // the BGL hookup lands: a `texture_depth_cube_array` cleared per-face to
 // distinct depth values, sampled via `textureSampleCompareLevel` with two
 // refs that simulate the occluded vs non-occluded fragments. The depth
 // values + ref values are chosen so the comparison passes for the open
 // fragment (returns 1.0) and fails for the occluded fragment (returns 0.0).
 //
-// This validates the dawn-node end-to-end chain that the production URP /
-// HDRP forward pass relies on (cube_array creation -> face attachments ->
+// This validates the dawn-node end-to-end chain that the production Standard
+// forward pass relies on (cube_array creation -> face attachments ->
 // sampling via comparison sampler -> pixel-distinct results), so when the
 // follow-on BGL hookup lands the AC-15 bar shifts from "raw RHI primitive
 // works" to "createRenderer path works" without re-discovering the dawn
@@ -476,7 +469,7 @@ describe('M5 point shadow e2e readback (dawn, T-M5-1 / AC-15)', () => {
     // Per requirements §5.4 falsification proof contract.
     expect(result[0]).toBe(0.0);
     expect(result[1]).toBe(1.0);
-    // The closed-form contract the URP / HDRP forward path will rely on:
+    // The closed-form contract the Standard forward path relies on:
     // shadowFactor for occluded fragment is strictly less than for the
     // non-occluded one, so frame brightness on the occluded pixel is
     // strictly less than on the non-occluded pixel.
@@ -550,14 +543,14 @@ describe('Round-2 F-3 / Issue 3: createRenderer e2e dawn (T-M5-1)', () => {
       // pattern). buildEngineShaderManifest produces the data: URL the
       // renderer's shaderManifestUrl needs.
       const { World } = await import('@forgeax/engine-ecs');
-      const componentsModule = await import('@forgeax/engine-render/internal');
+      const componentsModule = await import('@forgeax/engine-render');
       const sceneComponents = await import('@forgeax/engine-scene');
       const { Camera, DirectionalLight, MeshFilter, MeshRenderer } = componentsModule;
       const { Transform } = sceneComponents;
       const { PointLight } = componentsModule;
-      const { PointLightShadow } = await import('@forgeax/engine-render/internal');
-      const { createRenderer } = await import('../index');
-      const { createPrimitiveMesh } = await import('@forgeax/engine-geometry');
+      const { PointLightShadow } = await import('@forgeax/engine-render');
+      const { constructRuntimeRendererHost } = await import('../renderer-host');
+      const { HANDLE_CUBE } = await import('@forgeax/engine-assets-runtime');
       const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
       const manifest = await buildEngineShaderManifest();
       const manifestUrl = `data:application/json,${encodeURIComponent(JSON.stringify(manifest))}`;
@@ -620,16 +613,22 @@ describe('Round-2 F-3 / Issue 3: createRenderer e2e dawn (T-M5-1)', () => {
         removeEventListener() {},
       } as unknown as HTMLCanvasElement;
 
-      let renderer: Awaited<ReturnType<typeof createRenderer>>;
+      let host: Awaited<ReturnType<typeof constructRuntimeRendererHost>>;
       try {
-        renderer = await createRenderer(mockCanvas, {}, { shaderManifestUrl: manifestUrl });
+        host = await constructRuntimeRendererHost(
+          mockCanvas,
+          {},
+          {
+            shaderManifestUrl: manifestUrl,
+          },
+        );
       } finally {
         globalThis.navigator.gpu.requestAdapter = originalRequestAdapter;
       }
-      expect(renderer.backend).toBe('webgpu');
-      const ready = await renderer.ready;
-      expect(ready.ok).toBe(true);
-      if (!ready.ok) return;
+      expect(host.ok).toBe(true);
+      if (!host.ok) throw host.error;
+      const { renderer } = host.value;
+      expect(renderer.inspect().state).toBe('alive');
       const device = sharedDevice;
       if (device === undefined) throw new Error('GPUDevice not captured');
 
@@ -639,10 +638,6 @@ describe('Round-2 F-3 / Issue 3: createRenderer e2e dawn (T-M5-1)', () => {
       //    early because lights.pointShadow is empty). The renderer is
       //    re-used; only the World changes. --
       const worldBaseline = new World();
-      const baselineCubeHandle = worldBaseline.internSharedRef(
-        'MeshAsset',
-        createPrimitiveMesh('cube').unwrap(),
-      );
       worldBaseline.spawn(
         {
           component: Transform,
@@ -674,7 +669,7 @@ describe('Round-2 F-3 / Issue 3: createRenderer e2e dawn (T-M5-1)', () => {
             scale: [1, 1, 1],
           },
         },
-        { component: MeshFilter, data: { assetHandle: baselineCubeHandle } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
         { component: MeshRenderer, data: {} },
       );
       worldBaseline.spawn(
@@ -718,10 +713,6 @@ describe('Round-2 F-3 / Issue 3: createRenderer e2e dawn (T-M5-1)', () => {
       //    sampling (compared to the no-shadow path which reads the all-1.0
       //    fallback cube_array). --
       const worldShadow = new World();
-      const shadowCubeHandle = worldShadow.internSharedRef(
-        'MeshAsset',
-        createPrimitiveMesh('cube').unwrap(),
-      );
       worldShadow.spawn(
         {
           component: Transform,
@@ -753,7 +744,7 @@ describe('Round-2 F-3 / Issue 3: createRenderer e2e dawn (T-M5-1)', () => {
             scale: [1, 1, 1],
           },
         },
-        { component: MeshFilter, data: { assetHandle: shadowCubeHandle } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
         { component: MeshRenderer, data: {} },
       );
       worldShadow.spawn(

package/src/__tests__/point-light-shadow.unit.test.ts

@@ -14,13 +14,21 @@
 import { World } from '@forgeax/engine-ecs';
 import { componentDefinition, componentSchema } from '@forgeax/engine-ecs/internal';
 import { vec3 } from '@forgeax/engine-math';
-import {
-  buildPointShadowMatrices,
-  PointLightShadow,
-  ShadowInvalidConfigError,
-  validatePointLightShadowData,
-} from '@forgeax/engine-render/internal';
+import { PointLightShadow } from '@forgeax/engine-render';
 import { describe, expect, it } from 'vitest';
+import { validatePointLightShadowData } from '../../../render/src/components/light-helpers';
+import { ShadowInvalidConfigError } from '../../../render/src/errors/render';
+import {
+  BYTES_PER_LIGHT_SLOT,
+  LIGHTSLOT_LAYOUT,
+  packLightSlot,
+} from '../../../render/src/light-buffer-layout';
+import { buildPointShadowMatrices } from '../../../render/src/render-system-extract';
+import {
+  SHADOW_ATLAS_DEFAULT_FACE_SIZE,
+  SHADOW_ATLAS_DEFAULT_LAYERS,
+  ShadowAtlas,
+} from '../../../render/src/shadow-atlas';
 
 type PointShadowSpawnResult = ReturnType<World['spawn']>;
 
@@ -432,7 +440,6 @@ function spawnValidatedPointShadow(
         // recordFrame never invokes atlas.ensure(). The unit guarantee here
         // is that `new ShadowAtlas(device)` itself does no GPU work — the
         // construction-only path stays allocation-free.
-        const { ShadowAtlas } = await import('@forgeax/engine-render/internal');
         new ShadowAtlas(makeMockDevice().device);
         expect(calls.createTexture).toBe(0);
         expect(calls.createTextureView).toBe(0);
@@ -441,7 +448,6 @@ function spawnValidatedPointShadow(
 
       it('ensure() lazily allocates exactly one texture + cube-array view + sampler', async () => {
         const { device, calls } = makeMockDevice();
-        const { ShadowAtlas } = await import('@forgeax/engine-render/internal');
         const atlas = new ShadowAtlas(device);
         expect(atlas.isAllocated()).toBe(false);
         atlas.ensure();
@@ -454,7 +460,6 @@ function spawnValidatedPointShadow(
 
       it('ensure() is idempotent — second call is zero-cost', async () => {
         const { device, calls } = makeMockDevice();
-        const { ShadowAtlas } = await import('@forgeax/engine-render/internal');
         const atlas = new ShadowAtlas(device);
         atlas.ensure();
         atlas.ensure();
@@ -466,7 +471,6 @@ function spawnValidatedPointShadow(
 
       it('faceView caches per (layer, face) — second call same key is zero-cost', async () => {
         const { device, calls } = makeMockDevice();
-        const { ShadowAtlas } = await import('@forgeax/engine-render/internal');
         const atlas = new ShadowAtlas(device);
         atlas.ensure();
         // 1 view from ensure() (cube-array sampling view).
@@ -483,14 +487,12 @@ function spawnValidatedPointShadow(
 
       it('faceView throws when called before ensure()', async () => {
         const { device } = makeMockDevice();
-        const { ShadowAtlas } = await import('@forgeax/engine-render/internal');
         const atlas = new ShadowAtlas(device);
         expect(() => atlas.faceView(0, 0)).toThrow(/before ensure/);
       });
 
       it('faceView range-checks layer + face', async () => {
         const { device } = makeMockDevice();
-        const { ShadowAtlas } = await import('@forgeax/engine-render/internal');
         const atlas = new ShadowAtlas(device, { layers: 4 });
         atlas.ensure();
         expect(() => atlas.faceView(-1, 0)).toThrow(/layer out of range/);
@@ -501,7 +503,6 @@ function spawnValidatedPointShadow(
 
       it('dispose() releases GPU memory + clears caches; subsequent ensure() re-allocates', async () => {
         const { device, calls } = makeMockDevice();
-        const { ShadowAtlas } = await import('@forgeax/engine-render/internal');
         const atlas = new ShadowAtlas(device);
         atlas.ensure();
         atlas.faceView(0, 0); // populate the per-face cache
@@ -521,8 +522,6 @@ function spawnValidatedPointShadow(
 
       it('default size + layers match plan-strategy §D-1 (512 x 512 x 4 cube layers)', async () => {
         const { device } = makeMockDevice();
-        const { SHADOW_ATLAS_DEFAULT_FACE_SIZE, SHADOW_ATLAS_DEFAULT_LAYERS, ShadowAtlas } =
-          await import('@forgeax/engine-render/internal');
         expect(SHADOW_ATLAS_DEFAULT_FACE_SIZE).toBe(512);
         expect(SHADOW_ATLAS_DEFAULT_LAYERS).toBe(4);
         const atlas = new ShadowAtlas(device);
@@ -531,7 +530,7 @@ function spawnValidatedPointShadow(
       });
     });
 
-    describe('URP point shadow pass topology (T-M3-5 / AC-04 + AC-09)', () => {
+    describe('point shadow pass topology (T-M3-5 / AC-04 + AC-09)', () => {
       it('AC-04: 6 x N pass-count formula — N=0 emits 0 passes, N=4 emits 24', () => {
         // The 6 x N invariant is the structural contract recordPointShadowPass
         // upholds: per the loop in render-system-record.ts, exactly 6 face
@@ -548,46 +547,10 @@ function spawnValidatedPointShadow(
           expect(count).toBe(6 * n);
         }
       });
-
-      it('AC-09: addPointShadowPass primitive exists; execute closure early-returns on empty snapshot', async () => {
-        // The URP buildGraph contract: the point-shadow pass node is declared
-        // unconditionally, but `recordPointShadowPass` (the execute closure)
-        // early-returns when `frameState.pointShadowSnapshots.length === 0`
-        // so zero-shadow scenes pay zero GPU work. The pure-buildGraph
-        // declaration approach keeps the memoized graph stable across
-        // snapshot count drift (no rebuild on add/remove of a
-        // PointLightShadow component); AC-09's zero-allocation guarantee is
-        // upheld by the atlas's `ensure()` lazy-allocate path which
-        // `recordFrame` also gates on the same `length > 0` check.
-        const primitivesModule = await import('@forgeax/engine-render/internal');
-        // The addPointShadowPass primitive is exported from
-        // render-graph-primitives.ts; urp-pipeline.ts imports + invokes it
-        // unconditionally inside buildGraph. The execute closure is the gate.
-        expect(typeof primitivesModule.addPointShadowPass).toBe('function');
-        // Smoke: addPointShadowPass takes (graph, name) and returns void —
-        // mirrors addShadowPass / addSkyboxPass signatures.
-        expect(primitivesModule.addPointShadowPass.length).toBe(2);
-      });
     });
 
-    // ─── T-M4-5: HDRP topology + LightSlot packing + no-shadow regression (AC-05) ──
-    describe('HDRP point shadow pass topology (T-M4-5 / AC-04 + AC-05 + AC-09)', () => {
-      it('AC-04 + AC-05: HDRP buildGraph imports addPointShadowPass; same primitive as URP', async () => {
-        // hdrp-pipeline.ts imports `addPointShadowPass` from
-        // render-graph-primitives.ts and calls it unconditionally inside
-        // buildGraph (T-M4-1). Both pipelines share the SAME primitive +
-        // execute closure (`recordPointShadowPass`), so the 6 x N pass-count
-        // contract is identical to URP's: zero-shadow scenes -> zero passes
-        // (AC-05 no-regression for HDRP), N=4 lights -> 24 caster passes
-        // (AC-04 6 x N).
-        const hdrpModule = await import('@forgeax/engine-render/internal');
-        expect(hdrpModule.hdrpPipeline).toBeDefined();
-        expect(typeof hdrpModule.hdrpPipeline.build).toBe('function');
-        expect(hdrpModule.hdrpPipeline.build.length).toBe(2);
-      });
-
-      it('AC-13: packLightSlot writes shadow info onto LightSlot pad lanes (byte 52..64)', async () => {
-        const { packLightSlot } = await import('@forgeax/engine-render/internal');
+    describe('standard point shadow light-slot packing (AC-05)', () => {
+      it('AC-13: packLightSlot writes shadow info onto LightSlot pad lanes (byte 52..64)', () => {
         const snap = {
           kind: 'point' as const,
           position: vec3.create(1, 2, 3),
@@ -614,8 +577,7 @@ function spawnValidatedPointShadow(
         expect(withShadow[15]).toBe(25);
       });
 
-      it('AC-13: spot light packLightSlot leaves pad lanes at sentinel (-1, 0, 0)', async () => {
-        const { packLightSlot } = await import('@forgeax/engine-render/internal');
+      it('AC-13: spot light packLightSlot leaves pad lanes at sentinel (-1, 0, 0)', () => {
         const spotSnap = {
           kind: 'spot' as const,
           entity: 0,
@@ -646,10 +608,7 @@ function spawnValidatedPointShadow(
         expect(packed[15]).toBe(0);
       });
 
-      it('AC-05: LIGHTSLOT_LAYOUT byteSize unchanged at 64 (no-regression for HDRP)', async () => {
-        const { LIGHTSLOT_LAYOUT, BYTES_PER_LIGHT_SLOT } = await import(
-          '@forgeax/engine-render/internal'
-        );
+      it('AC-05: LIGHTSLOT_LAYOUT byteSize unchanged at 64 (no-regression for standard)', () => {
         // The pad-lane re-purposing must not change the total LightSlot size:
         // the std430 vec4 stride is preserved; only the field semantics within
         // bytes 52..64 changed (u32 pad -> i32 layer + f32 near + f32 far).

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

@@ -16,8 +16,11 @@
 //   (5) POST_PROCESS_EXPECTED + postProcessHint resolve both new codes (the
 //       hint switch's own `default: never` arm guards completeness there too).
 
-import { PostProcessError, type PostProcessErrorCode } from '@forgeax/engine-render/internal';
 import { describe, expect, it } from 'vitest';
+import {
+  PostProcessError,
+  type PostProcessErrorCode,
+} from '../../../render/src/post-process-errors';
 
 // Compile-time exhaustiveness probe: a switch over every member with no default.
 // If a future code is added to the union without a case here, `code` is not

package/src/__tests__/post-process-params-component.unit.test.ts

@@ -9,7 +9,7 @@
 
 import { World } from '@forgeax/engine-ecs';
 import { componentId, componentSchema } from '@forgeax/engine-ecs/internal';
-import { PostProcessParams } from '@forgeax/engine-render/internal';
+import { PostProcessParams } from '@forgeax/engine-render';
 import { describe, expect, it } from 'vitest';
 
 describe('PostProcessParams component definition', () => {

package/src/__tests__/post-process-params-extract.unit.test.ts

@@ -8,12 +8,9 @@
 // collects into Map<shaderId, AllowSharedBufferSource>.
 
 import { World } from '@forgeax/engine-ecs';
-import {
-  extractFrame,
-  PostProcessParams,
-  prepareExtractContext,
-} from '@forgeax/engine-render/internal';
+import { PostProcessParams } from '@forgeax/engine-render';
 import { describe, expect, it } from 'vitest';
+import { extractFrame, prepareExtractContext } from '../../../render/src/render-system-extract';
 
 describe('extractFrame PostProcessParams snapshot collection', () => {
   it('should contain postProcessParams empty map when no PostProcessParams entities exist', () => {

package/src/__tests__/postprocess-camera-consistency.test.ts

@@ -18,15 +18,12 @@
 //   requirements AC-05/06
 
 import { World } from '@forgeax/engine-ecs';
-import type { CameraSnapshot, ExtractedFrame } from '@forgeax/engine-render/internal';
-import {
-  Camera,
-  extractFrame,
-  PostProcessParams,
-  prepareExtractContext,
-} from '@forgeax/engine-render/internal';
+import { Camera, PostProcessParams } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
+import type { CameraSnapshot } from '../../../render/src/render-contract';
+import type { ExtractedFrame } from '../../../render/src/render-system-extract';
+import { extractFrame, prepareExtractContext } from '../../../render/src/render-system-extract';
 
 // ── Helpers ─────────────────────────────────────────────────────────────────
 

package/src/__tests__/profiler-assembly.integration.test.ts

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { createProfiler } from '@forgeax/engine-profiler';
-import type { RendererOptions } from '@forgeax/engine-render/internal';
+import type { RendererOptions } from '@forgeax/engine-render';
 import { describe, expect, it } from 'vitest';
 
 describe('runtime profiler assembly', () => {

package/src/__tests__/propagate-transforms.dawn.test.ts

@@ -23,9 +23,10 @@
 
 import type { EntityHandle } from '@forgeax/engine-ecs';
 import { World } from '@forgeax/engine-ecs';
-import { TileLayer, Tilemap } from '@forgeax/engine-render/authoring';
+import { readRenderArrayView } from '@forgeax/engine-ecs/projection';
 import { ChildOf, propagateTransforms, Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
+import { TileLayer, Tilemap } from '../../../render/src/components';
 
 function identityTransformData() {
   return {
@@ -38,9 +39,9 @@ function identityTransformData() {
 // Read the resolved world mat4 (column-major 16 floats) from the Transform
 // world column array view. Translation lives in column 3 (m[12,13,14]).
 function worldOf(world: World, entity: EntityHandle): Float32Array {
-  const result = world.get(entity, Transform);
-  if (!result.ok) throw result.error;
-  return result.value.world;
+  const view = readRenderArrayView(world, entity, Transform, 'world');
+  if (view === undefined) throw new Error('Transform.world view missing');
+  return view as Float32Array;
 }
 
 describe('propagate-transforms.dawn - root-down DFS + stale ChildOf fail-fast (AC-04)', () => {
@@ -166,6 +167,9 @@ describe('propagate-transforms.dawn - root-down DFS + stale ChildOf fail-fast (A
   // default case.
   it('AC-07: identity TileLayer middle node -> Transform.world byte-identical to Tilemap parent', () => {
     const world = new World();
+    for (const component of [ChildOf, TileLayer, Tilemap, Transform]) {
+      world.components.register(component).unwrap();
+    }
     // Parent Tilemap carries a non-identity translation so that the identity /
     // non-identity distinction is observable in the low three translation
     // slots of the 16-float world mat4.
@@ -185,9 +189,9 @@ describe('propagate-transforms.dawn - root-down DFS + stale ChildOf fail-fast (A
         },
       )
       .unwrap();
-    // TileLayer owns no implicit companion injection. The identity Transform is
-    // explicit so this test exercises the current per-World component contract
-    // without reviving the removed coAttach policy.
+    // TileLayer carries an explicit identity Transform in the current ECS
+    // component vocabulary. This mirrors the demo spawn pattern in
+    // apps/hello/tilemap/** and keeps the hierarchy contract explicit.
     const layer = world
       .spawn(
         {
@@ -199,11 +203,8 @@ describe('propagate-transforms.dawn - root-down DFS + stale ChildOf fail-fast (A
             sortScope: 0,
           },
         },
-        {
-          component: Transform,
-          data: identityTransformData(),
-        },
         { component: ChildOf, data: { parent: tilemap } },
+        { component: Transform, data: identityTransformData() },
       )
       .unwrap();
     const r = propagateTransforms(world);

package/src/__tests__/record-worldid-isolation.test.ts

@@ -186,19 +186,13 @@ describe('production-path shadow instanceBuffers worldEntityKey', () => {
     );
   });
 
-  it('shadow dir read-side inst.cacheKey get uses worldEntityKey', () => {
-    expectWorldEntityKeyAt(
-      SHADOW_FILE,
-      findLine(SHADOW_FILE, 'frameState.instanceBuffers.get(', 0),
-      'shadow-pass directional instanceBuffers.get',
-    );
-  });
-
-  it('shadow spot read-side inst.cacheKey get uses worldEntityKey', () => {
-    expectWorldEntityKeyAt(
-      SHADOW_FILE,
-      findLine(SHADOW_FILE, 'frameState.instanceBuffers.get(', 1),
-      'shadow-pass spot instanceBuffers.get',
+  it('spot shadow uses the shared world-aware caster recorder', () => {
+    const src = readFileSync(SHADOW_FILE, 'utf8');
+    const start = src.indexOf('export function encodeSpotShadowPass(');
+    expect(start).toBeGreaterThanOrEqual(0);
+    expect(src.slice(start)).toContain('recordShadowCasterDraws(');
+    expect(src.slice(start)).toContain(
+      "buildMatchedRenderableIndices(c.dispatch, { LightMode: ['ShadowCaster'] })",
     );
   });
 });
@@ -213,22 +207,6 @@ describe('production-path shadow instancesBgPerEntity worldEntityKey', () => {
       'shadow-pass instancesBgPerEntity write',
     );
   });
-
-  it('shadow dir read-side instancesBgPerEntity.get uses worldEntityKey', () => {
-    expectWorldEntityKeyAt(
-      SHADOW_FILE,
-      findLine(SHADOW_FILE, '.get(worldEntityKey(', 0),
-      'shadow-pass directional instancesBgPerEntity read',
-    );
-  });
-
-  it('shadow spot read-side instancesBgPerEntity.get uses worldEntityKey', () => {
-    expectWorldEntityKeyAt(
-      SHADOW_FILE,
-      findLine(SHADOW_FILE, '.get(worldEntityKey(', 1),
-      'shadow-pass spot instancesBgPerEntity read',
-    );
-  });
 });
 
 // ── Fold-bucket negative half NOT worldEntityKey (D-1a #1 invariant) ───────

package/src/__tests__/recover-error-exhaustive.test-d.ts

@@ -3,7 +3,7 @@
 // header for the shared pattern rationale). RecoverError carries no .detail
 // field, so this guard covers the RecoverErrorCode exhaustiveness only.
 
-import type { RecoverError, RecoverErrorCode } from '@forgeax/engine-render/internal';
+import type { RecoverError, RecoverErrorCode } from '../../../render/src/errors/recover';
 
 function exhaustiveSwitchOnRecoverCode(code: RecoverErrorCode): string {
   switch (code) {