@forgeax/engine-runtime 0.1.4 → 0.1.6

package/src/__tests__/shadow-mesh-ssbo-order.test.ts

@@ -25,40 +25,24 @@ function expectValidatedOrderedLoop(
   expect(body).toContain(`${dynamicOffsetBindGroup}, [${indexName} * MESH_PER_ENTITY_STRIDE]`);
 }
 
-function expectShadowEntriesLoop(signature: string, dynamicOffsetBindGroup: string): void {
-  const body = sourceAfter(signature);
-  expect(body).toContain('for (const { entry, validatedIndex: ei } of shadowEntries)');
-  expect(body).toContain(`${dynamicOffsetBindGroup}, [ei * MESH_PER_ENTITY_STRIDE]`);
-}
-
 describe('shadow mesh SSBO order', () => {
-  it('uses the upload order for directional, point, and spot shadow offsets', () => {
+  it('uses the upload order for typed directional, point, and spot shadow offsets', () => {
     expectValidatedOrderedLoop(
       'function recordShadowCasterDraws(',
       'i',
       'shadowPass.setBindGroup(2, shadowMeshBindGroup',
     );
-    expectShadowEntriesLoop(
-      'export function recordPointShadowPass(',
-      'pass.setBindGroup(2, meshBindGroup',
-    );
-    expectShadowEntriesLoop(
-      'function recordSpotShadowGeometry(',
-      'pass.setBindGroup(2, meshBindGroup',
-    );
-  });
-
-  it('keeps directional candidate union out of legacy point/spot caster domains', () => {
-    const point = sourceAfter('export function recordPointShadowPass(');
-    const spot = sourceAfter('function recordSpotShadowGeometry(');
-    expect(shadowPass).toContain(
+    expect(shadowPass).toContain('export function encodeDirectionalShadowPass(');
+    expect(shadowPass).toContain('export function encodePointShadowPass(');
+    expect(shadowPass).toContain('export function encodeSpotShadowPass(');
+    const spotBody = sourceAfter('export function encodeSpotShadowPass(');
+    expect(spotBody).toContain('recordShadowCasterDraws(');
+    expect(spotBody).toContain(
       "buildMatchedRenderableIndices(c.dispatch, { LightMode: ['ShadowCaster'] })",
     );
-    expect(point).toContain('const mainMembership = mainShadowMembership(c);');
-    expect(point).toContain('c.validatedShadowEntries ??');
-    expect(point).toContain('isMainShadowRenderable(entry, mainMembership)');
-    expect(spot).toContain('const mainMembership = mainShadowMembership(c);');
-    expect(spot).toContain('c.validatedShadowEntries ??');
-    expect(spot).toContain('isMainShadowRenderable(entry, mainMembership)');
+    expect(shadowPass).not.toContain('export function recordShadowPass(');
+    expect(shadowPass).not.toContain('export function recordPointShadowPass(');
+    expect(shadowPass).not.toContain('export function recordSpotShadowPass(');
+    expect(shadowPass).not.toContain('function recordSpotShadowGeometry(');
   });
 });

package/src/__tests__/skin-errors.unit.test.ts

@@ -1,5 +1,5 @@
-import { SkinMaterialMismatchError } from '@forgeax/engine-render/internal';
 import { describe, expect, it } from 'vitest';
+import { SkinMaterialMismatchError } from '../../../render/src/errors/render';
 
 describe('render skin errors stay outside skinning binding', () => {
   it('retains material failures in runtime render error cluster', () => {

package/src/__tests__/skin-extract-getarrayview-count.unit.test.ts

@@ -12,12 +12,14 @@ const extractPath = (() => {
   return join(here, '..', '..', '..', 'render', 'src', 'render-system-extract.ts');
 })();
 
-describe('query-row hot-field access (AC-03 gate)', () => {
-  it('keeps skin and instance hot fields on the token-first query row', () => {
+describe('_getArrayView count (AC-03 gate)', () => {
+  it('keeps skin and instance hot fields on column views', () => {
     const src = readFileSync(extractPath, 'utf8');
-    expect(src).not.toContain('_getArrayView(');
-    expect(src).toContain('row.get(Instances)');
-    expect(src).toContain('row.get(SpriteInstances)');
+    expect(src).toContain("_getArrayView(jointEntity, Transform, 'world')");
+    expect(src).toContain("_getArrayView(entity, Instances, 'transforms')");
+    expect(src).toContain("_getArrayView(entity, SpriteInstances, 'transforms')");
+    expect(src).toContain("_getArrayView(entity, SpriteInstances, 'regions')");
+    expect(src).not.toMatch(/^\s*const\s+\w+\s*=\s*world\.get\(jointEntity, Transform\)/m);
     expect(src).not.toMatch(/^\s*const\s+\w+\s*=\s*world\.get\(entity, Instances\)/m);
   });
 });

package/src/__tests__/skylight-lazy-projection.test.ts

@@ -22,18 +22,19 @@
 
 import type { World as WorldType } from '@forgeax/engine-ecs';
 import { World } from '@forgeax/engine-ecs';
+import type { RhiCaps } from '@forgeax/engine-rhi';
+import type { EquirectAsset, Handle } from '@forgeax/engine-types';
+import { toShared } from '@forgeax/engine-types';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { DeviceScope } from '../../../render/src/device/device-scope';
+import { GpuResidencyCache } from '../../../render/src/device/gpu-residency';
+import { RhiErrorListenerRegistry } from '../../../render/src/lifecycle';
 import {
   driveLazyEquirectProjection,
-  GpuResourceStore,
-  RhiErrorListenerRegistry,
   selectLazyEquirectHandle,
   warnMultiSkybox,
   warnMultiSkylight,
-} from '@forgeax/engine-render/internal';
-import type { RhiCaps } from '@forgeax/engine-rhi';
-import type { EquirectAsset, Handle } from '@forgeax/engine-types';
-import { toShared } from '@forgeax/engine-types';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+} from '../../../render/src/record/helpers';
 
 // ── caps probes ──────────────────────────────────────────────────────────────
 
@@ -73,7 +74,18 @@ function makeReadyDevice(probe: DeviceProbe): any {
     createPipelineLayout: () => okShim({ __mock: 'layout' }),
     createRenderPipeline: () => okShim({ __mock: 'pipeline' }),
     createBindGroup: () => okShim({ __mock: 'bindGroup' }),
-    createCommandEncoder: () => okShim({ __mock: 'encoder', beginRenderPass: () => ({}) }),
+    createCommandEncoder: () =>
+      okShim({
+        __mock: 'encoder',
+        beginRenderPass: () => ({
+          setPipeline: () => undefined,
+          setBindGroup: () => undefined,
+          setVertexBuffer: () => undefined,
+          draw: () => undefined,
+          end: () => undefined,
+        }),
+        finish: () => okShim({ __mock: 'command-buffer' }),
+      }),
     createBuffer: (desc: { size?: number }) => okShim({ __mock: 'buffer', size: desc.size ?? 0 }),
     createTexture: () => {
       probe.textures += 1;
@@ -84,9 +96,9 @@ function makeReadyDevice(probe: DeviceProbe): any {
     },
     createTextureView: () => okShim({ __mock: 'view' }),
     queue: {
-      writeTexture: () => undefined,
-      writeBuffer: () => undefined,
-      submit: () => undefined,
+      writeTexture: () => okShim(undefined),
+      writeBuffer: () => okShim(undefined),
+      submit: () => okShim(undefined),
     },
   };
 }
@@ -98,7 +110,11 @@ function makeFailingDevice(): any {
     createShaderModule: () => okShim({ __mock: 'shader' }),
     createTexture: () => ({ ok: false as const, error: undefined }),
     createTextureView: () => ({ ok: false as const, error: undefined }),
-    queue: { writeTexture: () => undefined, writeBuffer: () => undefined, submit: () => undefined },
+    queue: {
+      writeTexture: () => okShim(undefined),
+      writeBuffer: () => okShim(undefined),
+      submit: () => okShim(undefined),
+    },
   };
 }
 
@@ -123,8 +139,8 @@ function equirectPod(width = 4, height = 2): EquirectAsset {
 // by recordMainPass off the global cache views (out of scope for this unit test,
 // covered by the dawn IBL readback test). This unit test asserts the lazy
 // trigger's launch / dedup / caps-gate / fail-once-and-no-retry bookkeeping.
-function configuredStore(device: unknown, caps: RhiCaps): GpuResourceStore {
-  const store = new GpuResourceStore();
+function configuredStore(device: unknown, caps: RhiCaps): GpuResidencyCache {
+  const store = new GpuResidencyCache();
   let next = 9000;
   store.configureGpuDevice(
     // biome-ignore lint/suspicious/noExplicitAny: mock device satisfies MipmapBlitDevice structurally
@@ -133,13 +149,18 @@ function configuredStore(device: unknown, caps: RhiCaps): GpuResourceStore {
     (() => okShim(toShared<'EquirectAsset'>(next++))) as never,
     caps,
   );
+  store.configureIblDevice(
+    device as import('@forgeax/engine-rhi').RhiDevice,
+    async (_device, desc) => okShim({ __mock: 'shader', label: desc.label ?? '' }) as never,
+  );
+  store.bindDeviceScope(DeviceScope.create(0, 'skylight-lazy-test'));
   return store;
 }
 
 // Minimal RenderSystemInternals surface driveLazyEquirectProjection touches:
 // gpuStore, errorRegistry, device.caps. Everything else is unused by the arm.
 function makeInternals(
-  store: GpuResourceStore,
+  store: GpuResidencyCache,
   errorRegistry: RhiErrorListenerRegistry,
   caps: RhiCaps,
 ) {

package/src/__tests__/sparse-tag-scene-roundtrip.test.ts

@@ -1,6 +1,6 @@
+import type { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import { defineComponent, World } from '@forgeax/engine-ecs';
-import { createSceneAssetPort } from '@forgeax/engine-runtime';
-import { worldInstantiateScene } from '@forgeax/engine-scene';
+import * as SceneOwner from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
 import { rootsToSceneAsset } from '../collect-scene-asset';
 import { registerSceneComponents } from './helpers/register-scene-components';
@@ -22,8 +22,8 @@ describe('sparse tag scene persistence', () => {
     const entity = source
       .spawn({ component: Selected, data: {} }, { component: RuntimeOnly, data: {} })
       .unwrap();
-    const assets = createSceneAssetPort(() => undefined);
-    const collected = rootsToSceneAsset(assets, source, [entity]).unwrap();
+    const registry = {} as AssetRegistry;
+    const collected = rootsToSceneAsset(registry, source, [entity]).unwrap();
     const components = collected.entities[0]?.components as
       | Record<string, Record<string, unknown>>
       | undefined;
@@ -34,7 +34,7 @@ describe('sparse tag scene persistence', () => {
     const target = new World();
     registerSceneComponents(target, [Selected, RuntimeOnly]);
     const handle = target.allocSharedRef('SceneAsset', collected);
-    worldInstantiateScene(target, handle).unwrap();
+    SceneOwner.worldInstantiateScene(target, handle).unwrap();
     expect(
       Array.from(target.query({ with: [Selected] }).unwrap(), (row) => row.entity),
     ).toHaveLength(1);

package/src/__tests__/sprite-cullmode-flip.dawn.test.ts

@@ -20,19 +20,19 @@
 // Anchors: plan-tasks m2-t5; plan-strategy §D-8 (sprite cullMode 'none')
 // + §R-5 (sprite single-frame baseline non-degradation).
 
+import { HANDLE_QUAD } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
-import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from '@forgeax/engine-render/authoring';
 import {
   ANTIALIAS_NONE,
   Camera,
   MeshFilter,
   MeshRenderer,
   TONEMAP_NONE,
-} from '@forgeax/engine-render/internal';
+} from '@forgeax/engine-render';
+import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from '@forgeax/engine-render/authoring';
 import { Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
-import { createRenderer } from '../index';
+import { constructRuntimeRendererHost } from '../renderer-host';
 
 const WIDTH = 256;
 const HEIGHT = 256;
@@ -94,7 +94,6 @@ function spawnFlippedSpriteScene(
   sx: number,
   sy: number,
 ): void {
-  const quadHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('quad').unwrap());
   world.spawn(
     {
       component: Transform,
@@ -104,7 +103,7 @@ function spawnFlippedSpriteScene(
         scale: [sx, sy, 1],
       },
     },
-    { component: MeshFilter, data: { assetHandle: quadHandle } },
+    { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
     { component: MeshRenderer, data: { materials: [spriteMaterial as never] } },
   );
   world.spawn(
@@ -207,21 +206,24 @@ describe('feat-20260608 M2 m2-t5: sprite pipeline cullMode "none" lets H/V flipp
       removeEventListener() {},
     } as unknown as HTMLCanvasElement;
 
-    let renderer: Awaited<ReturnType<typeof createRenderer>>;
+    let host: Awaited<ReturnType<typeof constructRuntimeRendererHost>>;
     try {
-      renderer = await createRenderer(mockCanvas, {}, { shaderManifestUrl: ENGINE_MANIFEST_URL });
+      host = await constructRuntimeRendererHost(
+        mockCanvas,
+        {},
+        {
+          shaderManifestUrl: ENGINE_MANIFEST_URL,
+        },
+      );
     } 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');
-
-    const assets = renderer.assets;
-    if (assets === null) throw new Error('AssetRegistry is null');
     const worldFlip = new World();
 
     const synth = buildSyntheticRgba();
@@ -235,17 +237,6 @@ describe('feat-20260608 M2 m2-t5: sprite pipeline cullMode "none" lets H/V flipp
       mipmap: false,
     };
     const textureHandle = worldFlip.allocSharedRef('TextureAsset', synthPod as never);
-    const uploadRes = await renderer.store.uploadTexture(textureHandle, synthPod as never, {
-      bytes: synth.data,
-      width: synth.width,
-      height: synth.height,
-      mime: 'image/png',
-      colorSpace: 'srgb',
-      mipmap: false,
-    });
-    expect(uploadRes.ok, 'sprite texture upload').toBe(true);
-    if (!uploadRes.ok) return;
-
     const samplerHandle = worldFlip.allocSharedRef('SamplerAsset', {
       kind: 'sampler',
       magFilter: 'linear',
@@ -281,14 +272,7 @@ describe('feat-20260608 M2 m2-t5: sprite pipeline cullMode "none" lets H/V flipp
         // pivotAndSize / baseColorTexture). The legacy baseColor / texture /
         // pivot field names lose their backwards-compat fold post-R1.
         colorTint: [1.0, 1.0, 1.0, 1.0],
-        baseColorTexture: {
-          texture: textureHandle,
-          coordinates: {
-            set: 0,
-            transform: { offset: [0, 0], scale: [1, 1], rotation: 0 },
-            physicalUvScale: [1, 1],
-          },
-        },
+        baseColorTexture: textureHandle,
         sampler: samplerHandle,
         region: [0, 0, 1, 1],
         pivotAndSize: [0.5, 0.5, 1, 1],
@@ -298,9 +282,15 @@ describe('feat-20260608 M2 m2-t5: sprite pipeline cullMode "none" lets H/V flipp
     // Render an H-flipped sprite (scale.x < 0). With cullMode='back' this
     // would be culled and the centre would stay clear-colour-black.
     spawnFlippedSpriteScene(worldFlip, spriteMaterial, /* sx= */ -1, /* sy= */ 1);
-    expect(renderer.attachWorld(worldFlip).ok).toBe(true);
+    const attachment = renderer.attach(worldFlip);
+    expect(attachment.ok).toBe(true);
+    if (!attachment.ok) throw attachment.error;
     worldFlip.update(1 / 60).unwrap();
-    const drawn = renderer.draw([worldFlip], { cameraOwner: 0, resourceOwner: 0 });
+    const drawn = renderer.draw({
+      leases: [attachment.value],
+      camera: { lease: attachment.value },
+      environment: { lease: attachment.value },
+    });
     await device.queue.onSubmittedWorkDone();
     expect(drawn.ok, 'H-flipped sprite draw').toBe(true);
 
@@ -369,21 +359,24 @@ describe('feat-20260608 M2 m2-t5: sprite pipeline cullMode "none" lets H/V flipp
       removeEventListener() {},
     } as unknown as HTMLCanvasElement;
 
-    let renderer: Awaited<ReturnType<typeof createRenderer>>;
+    let host: Awaited<ReturnType<typeof constructRuntimeRendererHost>>;
     try {
-      renderer = await createRenderer(mockCanvas, {}, { shaderManifestUrl: ENGINE_MANIFEST_URL });
+      host = await constructRuntimeRendererHost(
+        mockCanvas,
+        {},
+        {
+          shaderManifestUrl: ENGINE_MANIFEST_URL,
+        },
+      );
     } 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');
-
-    const assets = renderer.assets;
-    if (assets === null) throw new Error('AssetRegistry is null');
     const worldFlipBoth = new World();
 
     const synth = buildSyntheticRgba();
@@ -397,15 +390,6 @@ describe('feat-20260608 M2 m2-t5: sprite pipeline cullMode "none" lets H/V flipp
       mipmap: false,
     };
     const textureHandle = worldFlipBoth.allocSharedRef('TextureAsset', synthPod as never);
-    await renderer.store.uploadTexture(textureHandle, synthPod as never, {
-      bytes: synth.data,
-      width: synth.width,
-      height: synth.height,
-      mime: 'image/png',
-      colorSpace: 'srgb',
-      mipmap: false,
-    });
-
     const samplerHandle = worldFlipBoth.allocSharedRef('SamplerAsset', {
       kind: 'sampler',
       magFilter: 'linear',
@@ -441,14 +425,7 @@ describe('feat-20260608 M2 m2-t5: sprite pipeline cullMode "none" lets H/V flipp
         // pivotAndSize / baseColorTexture). The legacy baseColor / texture /
         // pivot field names lose their backwards-compat fold post-R1.
         colorTint: [1.0, 1.0, 1.0, 1.0],
-        baseColorTexture: {
-          texture: textureHandle,
-          coordinates: {
-            set: 0,
-            transform: { offset: [0, 0], scale: [1, 1], rotation: 0 },
-            physicalUvScale: [1, 1],
-          },
-        },
+        baseColorTexture: textureHandle,
         sampler: samplerHandle,
         region: [0, 0, 1, 1],
         pivotAndSize: [0.5, 0.5, 1, 1],
@@ -456,9 +433,15 @@ describe('feat-20260608 M2 m2-t5: sprite pipeline cullMode "none" lets H/V flipp
     } as never);
 
     spawnFlippedSpriteScene(worldFlipBoth, spriteMaterial, /* sx= */ -1, /* sy= */ -1);
-    expect(renderer.attachWorld(worldFlipBoth).ok).toBe(true);
+    const attachmentBoth = renderer.attach(worldFlipBoth);
+    expect(attachmentBoth.ok).toBe(true);
+    if (!attachmentBoth.ok) throw attachmentBoth.error;
     worldFlipBoth.update(1 / 60).unwrap();
-    const drawn = renderer.draw([worldFlipBoth], { cameraOwner: 0, resourceOwner: 0 });
+    const drawn = renderer.draw({
+      leases: [attachmentBoth.value],
+      camera: { lease: attachmentBoth.value },
+      environment: { lease: attachmentBoth.value },
+    });
     await device.queue.onSubmittedWorkDone();
     expect(drawn.ok).toBe(true);
 

package/src/__tests__/sprite-lit-bgl-byte-identical.test.ts

@@ -15,14 +15,15 @@
 //     white texture; BGL JSON unchanged across sprite vs sprite-lit)
 //   - requirements AC-07
 
-import type { PipelineSpec } from '@forgeax/engine-render/internal';
+import { describe, expect, it } from 'vitest';
+import { mergeSkylightIntoMaterialBgl } from '../../../render/src/ibl/skylight-bind-group';
 import {
-  buildBindGroupLayoutDescriptor,
+  appendInjection,
   buildPbrMaterialUserRegionEntries,
   buildPbrViewBglEntries,
-  mergeSkylightIntoMaterialBgl,
-} from '@forgeax/engine-render/internal';
-import { describe, expect, it } from 'vitest';
+} from '../../../render/src/pbr-pipeline';
+import type { PipelineSpec } from '../../../render/src/pipeline-spec';
+import { buildBindGroupLayoutDescriptor } from '../../../render/src/pipeline-spec';
 
 function makeSpec(shaderId: string): PipelineSpec {
   return {
@@ -119,22 +120,22 @@ describe('sprite-lit BGL byte-identical to sprite (AC-07, w4/w5 close)', () => {
   describe('material BGL congruence (pbr-material-merged / unlit-material)', () => {
     it('pbr-material-user-region entries are 13 (PBR layout reused by sprite & sprite-lit)', () => {
       // sprite + sprite-lit use the default standard-PBR user-region
-      // schema (6 texture fields produce 13 BGL entries after std140 merge).
+      // schema (5 user fields produce 7 BGL entries after std140 merge).
       // Both share the same userRegion shape and therefore the same BGL.
       const base = buildPbrMaterialUserRegionEntries();
       expect(base.length).toBe(13);
     });
 
-    it('pbr-material-merged stays 20 entries (sprite/sprite-lit do not change material BGL shape)', () => {
+    it('pbr-material-merged stays 24 entries (sprite/sprite-lit do not change material BGL shape)', () => {
       const merged = buildBindGroupLayoutDescriptor(makeSpec('forgeax::sprite-lit'), {
         kind: 'pbr-material-merged',
       });
-      expect(merged.entries.length).toBe(20);
-      // mergeSkylightIntoMaterialBgl stays append-only against the derived
-      // user-region; material textures own emissive and occlusion.
+      expect(merged.entries.length).toBe(24);
+      // mergeSkylightIntoMaterialBgl + lightmap injection must stay
+      // append-only against the 7-entry PBR base.
       const base = buildPbrMaterialUserRegionEntries();
       const afterSky = mergeSkylightIntoMaterialBgl(base);
-      const expected = afterSky;
+      const expected = [...afterSky, ...appendInjection(afterSky, 'lightmap')];
       expect(merged.entries).toEqual(expected);
     });
   });

package/src/__tests__/sprite-lit-extract-branch.test.ts

@@ -26,8 +26,8 @@
 //   - requirements AC-01 / AC-02 (post-rewrite)
 
 import { fileURLToPath } from 'node:url';
-import type { MaterialSnapshot } from '@forgeax/engine-render/internal';
 import { describe, expect, it } from 'vitest';
+import type { MaterialSnapshot } from '../../../render/src/render-system-extract';
 
 describe('sprite-lit extract branch (D-9 remap, AC-02 + AC-01)', () => {
   describe('sprite-lit routes via materialShaderId (AC-01 D-10 remap)', () => {

package/src/__tests__/sprite-lit-pipeline-cache-key.test.ts

@@ -113,7 +113,7 @@ describe('sprite-lit pipeline cache-key string isolation (D-11 remap, AC-08)', (
     // recognised material shader.
     const fs = await import('node:fs');
     const src = fs.readFileSync(
-      fileURLToPath(new URL('../../../render/src/renderer/renderer-factory.ts', import.meta.url)),
+      fileURLToPath(new URL('../../../render/src/assembly/factory.ts', import.meta.url)),
       'utf8',
     );
     // Once t7 wires it, both literals appear (sprite already in tree).

package/src/__tests__/ssao-bgl.test.ts

@@ -22,15 +22,6 @@
 // the existing 5-entry assertions in pipeline.unit.test.ts are migrated
 // holistically (one-cut, no v1/v2 dual fixture).
 
-import type { HdrpBuffers, RenderSystemRuntime } from '@forgeax/engine-render/internal';
-import {
-  createHdrpBindGroupLayoutDescriptor,
-  createHdrpClusterMembershipBindGroup,
-  createHdrpClusterMembershipBindGroupLayoutDescriptor,
-  createHdrpUnifiedBindGroup,
-  getOrCreateSsaoFallbackTexture,
-  packClusterUniform,
-} from '@forgeax/engine-render/internal';
 import type {
   BindGroupLayout,
   Buffer,
@@ -40,6 +31,16 @@ import type {
   TextureView,
 } from '@forgeax/engine-rhi';
 import { describe, expect, it, vi } from 'vitest';
+import type { HdrpBuffers } from '../../../render/src/hdrp-buffers';
+import {
+  createHdrpClusterMembershipBindGroup,
+  createHdrpClusterMembershipBindGroupLayoutDescriptor,
+  createHdrpUnifiedBindGroup,
+  getOrCreateSsaoFallbackTexture,
+  packClusterUniform,
+} from '../../../render/src/hdrp-buffers';
+import { createHdrpBindGroupLayoutDescriptor } from '../../../render/src/pipeline-spec';
+import type { RenderSystemRuntime } from '../../../render/src/render-system';
 
 const FRAGMENT_VISIBILITY = 0x2;
 const COMPUTE_VISIBILITY = 0x4;
@@ -160,6 +161,12 @@ describe('HDRP GPU membership producer bind-group contract', () => {
     expect(storagePayload[3]).toBe(256);
   });
 
+  it('keeps enabled SSAO intensity in the zero-punctual-light uniform path', () => {
+    const payload = new Float32Array(packClusterUniform({ x: 16, y: 9, z: 24 }, 0.1, 50, 1, 0));
+    expect(payload[3]).toBe(0);
+    expect(payload[7]).toBe(1);
+  });
+
   it('uses four compute-only bindings with read-write membership output', () => {
     const desc = createHdrpClusterMembershipBindGroupLayoutDescriptor();
     expect(desc.entries?.map((entry) => entry.binding)).toEqual([0, 1, 2, 3]);

package/src/__tests__/ssao-buffers.test.ts

@@ -9,10 +9,10 @@
 //
 // AC-05 anchor: lazy alloc + hdrp-ssao-* labels + call-count assertions.
 
-import type { RenderSystemRuntime } from '@forgeax/engine-render/internal';
-import { getOrCreateSsaoBuffers } from '@forgeax/engine-render/internal';
 import type { Buffer, RhiCaps, RhiDevice, Texture } from '@forgeax/engine-rhi';
 import { describe, expect, it, vi } from 'vitest';
+import type { RenderSystemRuntime } from '../../../render/src/render-system';
+import { getOrCreateSsaoBuffers } from '../../../render/src/ssao-buffers';
 
 function mockTexture(label?: string): Texture {
   return { label: label ?? 'mock-tex' } as unknown as Texture;

package/src/__tests__/ssao-data.test.ts

@@ -1,4 +1,4 @@
-// ssao-data.test.ts -- M1 / w1: kernel distribution test (TDD red phase).
+// ssao-kernel.test.ts -- M1 / w1: kernel distribution test (TDD red phase).
 //
 // Asserts:
 //  - generateSsaoKernel() returns 64 vec3 samples.
@@ -10,8 +10,8 @@
 //
 // AC-03 anchor: kernel length 64 + distribution properties.
 
-import { generateSsaoKernel, generateSsaoNoise } from '@forgeax/engine-render/internal';
 import { describe, expect, it } from 'vitest';
+import { generateSsaoKernel, generateSsaoNoise } from '../../../render/src/ssao-buffers';
 
 function readFloat(v: Float32Array, idx: number): number {
   const val = v[idx];

package/src/__tests__/ssao-errors.test.ts

@@ -17,8 +17,8 @@
 // RED before w10 (SSAO codes not yet added to PostProcessErrorCode).
 // GREEN after w10 extends the union.
 
-import { PostProcessError } from '@forgeax/engine-render/internal';
 import { describe, expect, it } from 'vitest';
+import { PostProcessError } from '../../../render/src/post-process-errors';
 
 describe('SSAO PostProcessErrorCode exhaustive switch (M2 / w9)', () => {
   it('(a) PostProcessErrorCode union has the 2 SSAO validation members', () => {