@forgeax/engine-runtime 0.1.21 → 0.1.24

package/src/__tests__/sprite-animation-tick-regions-mismatch.cases.unit.test.ts

@@ -0,0 +1,466 @@
+// @ts-nocheck — merged file: indexed-access checks cascade across noUncheckedIndexedAccess for blocks originally outside src/ rootDir
+// Consolidated by feat-20260609-test-pool-startup-reduction-merge-tiny-test-files
+// biome-ignore-all lint/complexity/noUselessLoneBlockStatements: block-scope isolation between merged source files (consolidation paradigm)
+//
+// Source files (N=44):
+//   - packages/runtime/__tests__/antialias-from-f32.test.ts
+//   - packages/runtime/src/__tests__/bloom-gating.test.ts
+//   - packages/runtime/src/__tests__/camera-antialias.test.ts
+//   - packages/runtime/src/__tests__/camera-bloom.test.ts
+//   - packages/runtime/src/__tests__/camera-clear-schema.test.ts
+//   - packages/runtime/src/__tests__/camera-ortho.test.ts
+//   - packages/runtime/src/__tests__/fxaa-intermediate-texture.test.ts
+//   - packages/runtime/src/__tests__/fxaa-pipeline.test.ts
+//   - packages/runtime/src/__tests__/ibl-pipeline-cache.test.ts
+//   - packages/runtime/src/__tests__/ibl-runtime-probe.test.ts
+//   - packages/runtime/src/__tests__/render-system-record-warn-once.test.ts
+//   - packages/runtime/src/__tests__/shadow-skip-non-triangle.test.ts
+//   - packages/runtime/src/__tests__/skin-errors-kebab-case.test.ts
+//   - packages/runtime/src/__tests__/skybox-error.test.ts
+//   - packages/runtime/src/__tests__/skybox-shader-compile.test.ts
+//   - packages/runtime/src/__tests__/skylight-bind-group.test.ts
+//   - packages/runtime/src/__tests__/skylight-component.test.ts
+//   - packages/runtime/src/__tests__/skylight-fallback-path.test.ts
+//   - packages/runtime/src/__tests__/skylight-pipeline-layout.test.ts
+//   - packages/runtime/src/__tests__/tonemap-hdr-target.test.ts
+//   - packages/runtime/src/__tests__/tonemap-pipeline-split.test.ts
+//   - packages/runtime/src/__tests__/zero-camera-clear-fallback.test.ts
+//   - packages/runtime/src/components/__tests__/skin.test.ts
+//   - packages/runtime/src/systems/__tests__/advance-animation-player.test.ts
+//   - packages/runtime/src/systems/__tests__/graph-skybox.test.ts
+//   - packages/runtime/src/systems/__tests__/propagate-transforms.test.ts
+//   - packages/runtime/src/systems/__tests__/skin-cap-gate.test.ts
+//   - packages/runtime/src/systems/__tests__/skin-instances-coexist.test.ts
+//   - packages/runtime/src/systems/__tests__/skin-palette-extract.test.ts
+//   - packages/runtime/src/systems/__tests__/skin-pipeline-routing.test.ts
+//   - packages/runtime/src/systems/__tests__/skybox-extract.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-boundary.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-clamp.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-frame-duration-negative.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-frame-duration-zero.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-loop.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-override-probe.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-regions-mismatch.test.ts
+//   - packages/runtime/src/systems/__tests__/tonemap.test.ts
+//   - packages/runtime/src/systems/__tests__/transparent-sort-config-get.test.ts
+//   - packages/runtime/src/systems/__tests__/transparent-sort-config-set.test.ts
+//   - packages/runtime/src/systems/__tests__/transparent-sort.test.ts
+//   - packages/runtime/src/__tests__/render-system-multi-material.test.ts
+//   - packages/runtime/src/__tests__/render-system-record-submesh.test.ts
+//
+// Paradigm: each block-scope wraps a source file. ancestorTitles[0] is the
+// source-preserved inner describe (NOT the source filename for these 3 files
+// — recovery path: vitest report ancestorTitles -> grep this file -> upstream
+// `// ─── from <name>.test.ts ───` block separator -> source filename).
+// Top-level imports merged + deduped.
+
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { AnimationPlayer } from '@forgeax/engine-animation';
+import type { AssetRuntimeErrorCode } from '@forgeax/engine-assets-runtime';
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import type { EntityHandle, World as WorldType } from '@forgeax/engine-ecs';
+import { ENTITY_NULL_RAW, World } from '@forgeax/engine-ecs';
+import { SpriteAnimationInvalidError } from '@forgeax/engine-ecs/projection';
+import { mat4, vec3 } from '@forgeax/engine-math';
+import type { RenderErrorCode, Renderer as RendererType } from '@forgeax/engine-render';
+import {
+  ANTIALIAS_FXAA,
+  ANTIALIAS_NONE,
+  BLOOM_DISABLED,
+  BLOOM_ENABLED,
+  CAMERA_PROJECTION_ORTHOGRAPHIC,
+  CAMERA_PROJECTION_PERSPECTIVE,
+  Camera,
+  MeshFilter,
+  MeshRenderer,
+  SkyboxBackground,
+  Skylight,
+} from '@forgeax/engine-render';
+import type { BindGroupEntry, Buffer, Sampler, Texture, TextureView } from '@forgeax/engine-rhi';
+import { ok as rhiOk } from '@forgeax/engine-rhi';
+import { ChildOf, Name, propagateTransforms, Transform } from '@forgeax/engine-scene';
+import { TONEMAP_LUMINANCE_EPSILON } from '@forgeax/engine-shader';
+import type { SkinErrorCode } from '@forgeax/engine-skinning';
+import {
+  Skin,
+  SkinInstancesCoexistForbiddenError,
+  SkinJointCountExceededError,
+  SkinJointDespawnedError,
+  SkinJointPathUnresolvedError,
+} from '@forgeax/engine-skinning';
+import type {
+  Handle,
+  MaterialAsset,
+  MeshAsset,
+  SkeletonAsset,
+  TextureFormat,
+} from '@forgeax/engine-types';
+import { toShared } from '@forgeax/engine-types';
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { worldInternal } from '../../../ecs/src/world-internal';
+import {
+  SPRITE_PLAYBACK_MODE_CLAMP,
+  SPRITE_PLAYBACK_MODE_LOOP,
+  SpriteAnimation,
+  SpriteRegionOverride,
+} from '../../../render/src/components';
+import {
+  type CameraProjection,
+  cameraProjectionFromF32,
+} from '../../../render/src/components/camera';
+import {
+  assembleMaterialWithSkylightEntries,
+  createSkylightFallback,
+  mergeSkylightIntoMaterialBgl,
+} from '../../../render/src/ibl/skylight-bind-group';
+import { buildPbrPipelineLayouts, buildUnlitMaterialBgl } from '../../../render/src/pbr-pipeline';
+import { INSTANCE_STORAGE_STRIDE_FLOATS } from '../../../render/src/record/mesh-ssbo';
+import { selectSwapChainFormat } from '../../../render/src/render-system';
+import { createSkinPaletteAllocator } from '../../../render/src/systems/skin-palette-allocator';
+import type { TransparentEntry } from '../../../render/src/systems/transparent-sort-config';
+import { standardMaterialShaderVariants } from './helpers/standard-material-manifest';
+import { drawWithOwners } from './renderer-test-utils';
+
+function componentFieldType(component: { fields: Record<string, { type: string }> }, name: string) {
+  return component.fields[name]?.type;
+}
+
+function componentFieldDefault(
+  component: { fields: Record<string, { default?: unknown }> },
+  name: string,
+) {
+  return component.fields[name]?.default;
+}
+
+function componentSchemaTypes(component: { fields: Record<string, { type: string }> }) {
+  return Object.fromEntries(
+    Object.entries(component.fields).map(([name, field]) => [name, field.type]),
+  );
+}
+
+afterEach(() => vi.restoreAllMocks());
+
+type RendererErrorObservation = {
+  readonly code: string;
+  readonly detail?: unknown;
+  readonly hint?: string;
+};
+
+function unwrapRendererError(value: unknown): RendererErrorObservation {
+  let current = value as RendererErrorObservation;
+  while (
+    current.detail !== undefined &&
+    typeof current.detail === 'object' &&
+    current.detail !== null
+  ) {
+    const cause = (current.detail as { cause?: unknown }).cause;
+    if (
+      cause === undefined ||
+      typeof cause !== 'object' ||
+      cause === null ||
+      typeof (cause as { code?: unknown }).code !== 'string'
+    ) {
+      break;
+    }
+    current = cause as RendererErrorObservation;
+  }
+  return current;
+}
+
+function subscribeRendererErrors(
+  renderer: RendererType,
+  listener: (error: RendererErrorObservation) => void,
+): () => void {
+  return renderer.subscribe((event) => {
+    if (event.kind === 'error') listener(unwrapRendererError(event.error));
+  });
+}
+
+function drawPublished(renderer: RendererType, world: WorldType) {
+  const attached = renderer.attach(world);
+  if (!attached.ok) throw attached.error;
+  world.update().unwrap();
+  return drawWithOwners(renderer, world);
+}
+
+// feat-20260704-runtime-tier1-decomposition M2 / w12: reconstitute the
+// eliminated top-level RuntimeErrorCode aggregate union (D-3) as a test-local
+// alias so the exhaustive-switch bodies below stay byte-identical (AC-09).
+type RuntimeLayerErrorCode = RenderErrorCode | AssetRuntimeErrorCode | SkinErrorCode;
+
+import {
+  AnimationTargetId,
+  bindAnimationTargets,
+  advanceAnimationPlayer as canonicalAdvanceAnimationPlayer,
+} from '@forgeax/engine-animation';
+import { deriveAnimationTargetId } from '@forgeax/engine-animation/target-id';
+import { DeviceScope } from '../../../render/src/device/device-scope';
+import { GpuBuffer } from '../../../render/src/gpu-resource';
+import { getOrCreateIblCache, hasIblCache } from '../../../render/src/ibl/IblPipelineCache';
+import {
+  disposeInstanceBuffers,
+  type InstanceBufferCacheEntry,
+} from '../../../render/src/instance-buffer-cache';
+import { standardPipeline as urpPipeline } from '../../../render/src/pipeline/standard-pipeline';
+import { ZERO_CAMERA_CLEAR_FALLBACK } from '../../../render/src/record/frame-snapshot';
+import {
+  warnMultiLightDirectional,
+  warnMultiLightPoint,
+  warnMultiLightSpot,
+} from '../../../render/src/record/helpers';
+import type { CameraSnapshot } from '../../../render/src/render-contract';
+import {
+  type ExtractedLights,
+  extractFrame,
+  extractFrames,
+  prepareExtractContext,
+} from '../../../render/src/render-system-extract';
+import {
+  getTransparentSortConfig,
+  setTransparentSortConfig,
+  TRANSPARENT_SORT_CONFIG_KEY,
+  TRANSPARENT_SORT_MODE_LAYER_Y,
+  TRANSPARENT_SORT_MODE_LAYER_YZ,
+  TRANSPARENT_SORT_MODE_LAYER_Z,
+} from '../../../render/src/systems/transparent-sort-config';
+import { spriteAnimationTickSystem } from '../systems/sprite-animation-tick';
+import { REC709_LUMA_WEIGHTS, tonemapReinhardLuminance } from '../systems/tonemap';
+import { transparentSortEntries } from '../systems/transparent-sort';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+
+void [
+  ANTIALIAS_FXAA,
+  ANTIALIAS_NONE,
+  AnimationPlayer,
+  AnimationTargetId,
+  AssetRegistry,
+  BLOOM_DISABLED,
+  BLOOM_ENABLED,
+  CAMERA_PROJECTION_ORTHOGRAPHIC,
+  CAMERA_PROJECTION_PERSPECTIVE,
+  Camera,
+  ChildOf,
+  DeviceScope,
+  ENTITY_NULL_RAW,
+  GpuBuffer,
+  INSTANCE_STORAGE_STRIDE_FLOATS,
+  MeshFilter,
+  MeshRenderer,
+  Name,
+  REC709_LUMA_WEIGHTS,
+  SPRITE_PLAYBACK_MODE_CLAMP,
+  SPRITE_PLAYBACK_MODE_LOOP,
+  Skin,
+  SkinInstancesCoexistForbiddenError,
+  SkinJointCountExceededError,
+  SkinJointDespawnedError,
+  SkinJointPathUnresolvedError,
+  SkyboxBackground,
+  Skylight,
+  SpriteAnimation,
+  SpriteAnimationInvalidError,
+  SpriteRegionOverride,
+  TONEMAP_LUMINANCE_EPSILON,
+  TRANSPARENT_SORT_CONFIG_KEY,
+  TRANSPARENT_SORT_MODE_LAYER_Y,
+  TRANSPARENT_SORT_MODE_LAYER_YZ,
+  TRANSPARENT_SORT_MODE_LAYER_Z,
+  Transform,
+  World,
+  ZERO_CAMERA_CLEAR_FALLBACK,
+  afterEach,
+  assembleMaterialWithSkylightEntries,
+  beforeAll,
+  beforeEach,
+  bindAnimationTargets,
+  buildPbrPipelineLayouts,
+  buildUnlitMaterialBgl,
+  cameraProjectionFromF32,
+  canonicalAdvanceAnimationPlayer,
+  componentFieldDefault,
+  componentFieldType,
+  componentSchemaTypes,
+  createSkinPaletteAllocator,
+  createSkylightFallback,
+  deriveAnimationTargetId,
+  describe,
+  disposeInstanceBuffers,
+  drawPublished,
+  drawWithOwners,
+  expect,
+  extractFrame,
+  extractFrames,
+  fileURLToPath,
+  getOrCreateIblCache,
+  getTransparentSortConfig,
+  hasIblCache,
+  it,
+  makeMockShaderRegistry,
+  mat4,
+  mergeSkylightIntoMaterialBgl,
+  prepareExtractContext,
+  propagateTransforms,
+  readFileSync,
+  resolve,
+  rhiOk,
+  selectSwapChainFormat,
+  setTransparentSortConfig,
+  spriteAnimationTickSystem,
+  standardMaterialShaderVariants,
+  subscribeRendererErrors,
+  toShared,
+  tonemapReinhardLuminance,
+  transparentSortEntries,
+  unwrapRendererError,
+  urpPipeline,
+  vec3,
+  vi,
+  warnMultiLightDirectional,
+  warnMultiLightPoint,
+  warnMultiLightSpot,
+  worldInternal,
+];
+type __MergedKeep =
+  | AssetRuntimeErrorCode
+  | BindGroupEntry
+  | Buffer
+  | CameraProjection
+  | CameraSnapshot
+  | EntityHandle
+  | ExtractedLights
+  | Handle
+  | InstanceBufferCacheEntry
+  | MaterialAsset
+  | MeshAsset
+  | RenderErrorCode
+  | RendererErrorObservation
+  | RendererType
+  | RuntimeLayerErrorCode
+  | Sampler
+  | SkeletonAsset
+  | SkinErrorCode
+  | Texture
+  | TextureFormat
+  | TextureView
+  | TransparentEntry
+  | WorldType;
+
+{
+  // --- from sprite-animation-tick-regions-mismatch.test.ts ---
+
+  function setDt(world: World, dt: number): void {
+    world[worldInternal].getClockWriter().time.delta = dt;
+  }
+
+  function spawnBadRegionsLength(world: World): EntityHandle {
+    // frameCount=4 but regions.length=12 (should be 16). The first row is
+    // distinguishable from row 0 of any regions buffer that the tick system
+    // could plausibly synthesise so a regression that wrote a stale slice
+    // would NOT match this initial state.
+    return world
+      .spawn({
+        component: SpriteAnimation,
+        data: {
+          frameCount: 4,
+          frameDuration: 0.1,
+          currentFrame: 0,
+          accumDt: 0,
+          regions: new Float32Array([0.1, 0.1, 0.2, 0.2, 0.3, 0.3, 0.4, 0.4, 0.5, 0.5, 0.6, 0.6]),
+          playbackMode: SPRITE_PLAYBACK_MODE_LOOP,
+        },
+      })
+      .unwrap();
+  }
+
+  function spawnHealthy(world: World): EntityHandle {
+    // 4 frames x 4 floats = 16. Distinguishable per-frame so the per-step
+    // region assertion can pin which frame fired without ambiguity.
+    const regions = new Float32Array([
+      0.0, 0, 0.25, 1, 0.25, 0, 0.25, 1, 0.5, 0, 0.25, 1, 0.75, 0, 0.25, 1,
+    ]);
+    return world
+      .spawn({
+        component: SpriteAnimation,
+        data: {
+          frameCount: 4,
+          frameDuration: 0.1,
+          currentFrame: 0,
+          accumDt: 0,
+          regions,
+          playbackMode: SPRITE_PLAYBACK_MODE_LOOP,
+        },
+      })
+      .unwrap();
+  }
+
+  describe('spriteAnimationTickSystem - AC-09(a) regions.length fail-fast (M4 T-19)', () => {
+    it('returns Result.err with 4 structured fields when regions.length !== frameCount * 4', () => {
+      const world = new World();
+      const entity = spawnBadRegionsLength(world);
+
+      setDt(world, 0.1);
+      const r = spriteAnimationTickSystem(world);
+
+      expect(r.ok).toBe(false);
+      if (r.ok) {
+        throw new Error('expected Result.err but got ok');
+      }
+      expect(r.error).toBeInstanceOf(SpriteAnimationInvalidError);
+      expect(r.error.code).toBe('sprite-animation-invalid');
+      expect(r.error.expected).toBeTruthy();
+      expect(r.error.expected.length).toBeGreaterThan(0);
+      expect(r.error.hint).toBeTruthy();
+      expect(r.error.hint.length).toBeGreaterThan(0);
+      expect(r.error.detail.field).toBe('regions-length');
+      if (r.error.detail.field !== 'regions-length') {
+        throw new Error('expected detail.field=regions-length narrowing');
+      }
+      expect(r.error.detail.regionsLength).toBe(12);
+      expect(r.error.detail.frameCount).toBe(4);
+
+      // The bad entity does NOT advance: currentFrame stays at 0,
+      // accumDt stays at 0. A regression that mutated state before the
+      // invariant check would surface as accumDt > 0 here.
+      const snap = world.get(entity, SpriteAnimation).unwrap();
+      expect(snap.currentFrame).toBe(0);
+      expect(snap.accumDt).toBeCloseTo(0, 6);
+    });
+
+    it('healthy entity advances normally beside a bad-regions-length entity', () => {
+      const world = new World();
+      const bad = spawnBadRegionsLength(world);
+      const good = spawnHealthy(world);
+
+      // dt=0.15 -> good.accumDt=0.15 -> one advance: good.currentFrame=1,
+      // good.accumDt=0.05. The bad entity stays put.
+      setDt(world, 0.15);
+      const r = spriteAnimationTickSystem(world);
+
+      expect(r.ok).toBe(false);
+      if (r.ok) {
+        throw new Error('expected Result.err but got ok');
+      }
+      expect(r.error.code).toBe('sprite-animation-invalid');
+      expect(r.error.detail.field).toBe('regions-length');
+
+      const badSnap = world.get(bad, SpriteAnimation).unwrap();
+      expect(badSnap.currentFrame).toBe(0);
+      expect(badSnap.accumDt).toBeCloseTo(0, 6);
+
+      const goodSnap = world.get(good, SpriteAnimation).unwrap();
+      expect(goodSnap.currentFrame).toBe(1);
+      expect(goodSnap.accumDt).toBeCloseTo(0.05, 6);
+
+      // Healthy entity also got its SpriteRegionOverride written to the
+      // currentFrame=1 slice (regions[4..8]).
+      const sro = world.get(good, SpriteRegionOverride).unwrap();
+      expect(sro.region.length).toBe(4);
+      expect(sro.region[0]).toBeCloseTo(0.25, 6);
+      expect(sro.region[1]).toBeCloseTo(0, 6);
+      expect(sro.region[2]).toBeCloseTo(0.25, 6);
+      expect(sro.region[3]).toBeCloseTo(1, 6);
+    });
+  });
+}

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

@@ -46,22 +46,22 @@ function makeSpec(shaderId: string): PipelineSpec {
 }
 
 describe('sprite-lit BGL byte-identical to sprite (AC-07, w4/w5 close)', () => {
-  describe('pbr-view BGL (light buffers; binding 1+2)', () => {
-    it('sprite-lit vs sprite share the same 12-entry pbr-view BGL under storage-buffer caps', () => {
+  describe('pbr-view BGL (Cluster lights live in group(2))', () => {
+    it('sprite-lit vs sprite share the same 10-entry pbr-view BGL under storage-buffer caps', () => {
       const spriteSpec = makeSpec('forgeax::sprite');
       const spriteLitSpec = makeSpec('forgeax::sprite-lit');
       const sprite = buildBindGroupLayoutDescriptor(spriteSpec, {
         kind: 'pbr-view',
-        caps: { storageBuffer: true },
+        caps: { storageBuffer: true, extendedLighting: false },
       });
       const spriteLit = buildBindGroupLayoutDescriptor(spriteLitSpec, {
         kind: 'pbr-view',
-        caps: { storageBuffer: true },
+        caps: { storageBuffer: true, extendedLighting: false },
       });
       expect(JSON.stringify(spriteLit)).toBe(JSON.stringify(sprite));
       // binding 10 is the shared Points/Lines view UBO; bindings 11/12 are the
       // optional SpotLight projector texture and sampler on capable devices.
-      expect(spriteLit.entries.length).toBe(12);
+      expect(spriteLit.entries.length).toBe(10);
     });
 
     it('sprite-lit vs sprite share the same 10-entry pbr-view BGL under uniform fallback caps (AC-10)', () => {
@@ -69,25 +69,23 @@ describe('sprite-lit BGL byte-identical to sprite (AC-07, w4/w5 close)', () => {
       const spriteLitSpec = makeSpec('forgeax::sprite-lit');
       const sprite = buildBindGroupLayoutDescriptor(spriteSpec, {
         kind: 'pbr-view',
-        caps: { storageBuffer: false },
+        caps: { storageBuffer: false, extendedLighting: false },
       });
       const spriteLit = buildBindGroupLayoutDescriptor(spriteLitSpec, {
         kind: 'pbr-view',
-        caps: { storageBuffer: false },
+        caps: { storageBuffer: false, extendedLighting: false },
       });
       expect(JSON.stringify(spriteLit)).toBe(JSON.stringify(sprite));
     });
 
-    it('binding 1 + 2 are read-only-storage on storageBuffer=true (point/spot light buffers)', () => {
+    it('does not expose point/spot light bindings on storageBuffer=true', () => {
       const entries = buildPbrViewBglEntries({ storageBuffer: true });
-      expect(entries[1]?.buffer?.type).toBe('read-only-storage');
-      expect(entries[2]?.buffer?.type).toBe('read-only-storage');
+      expect(entries.some((entry) => entry.binding === 1 || entry.binding === 2)).toBe(false);
     });
 
-    it('binding 1 + 2 fall back to uniform on storageBuffer=false (AC-10 fallback)', () => {
+    it('does not expose point/spot light bindings on storageBuffer=false', () => {
       const entries = buildPbrViewBglEntries({ storageBuffer: false });
-      expect(entries[1]?.buffer?.type).toBe('uniform');
-      expect(entries[2]?.buffer?.type).toBe('uniform');
+      expect(entries.some((entry) => entry.binding === 1 || entry.binding === 2)).toBe(false);
     });
   });
 
@@ -120,19 +118,19 @@ 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 17 (PBR layout reused by sprite & sprite-lit)', () => {
+    it('pbr-material-user-region entries are 15 (PBR layout reused by sprite & sprite-lit)', () => {
       // sprite + sprite-lit use the default standard-PBR user-region
-      // schema (20 value fields + 8 texture fields produce 17 BGL entries).
+      // schema (20 value fields + 7 user-region texture fields produce 15 BGL entries).
       // Both share the same userRegion shape and therefore the same BGL.
       const base = buildPbrMaterialUserRegionEntries();
-      expect(base.length).toBe(17);
+      expect(base.length).toBe(15);
     });
 
-    it('pbr-material-merged stays 26 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(26);
+      expect(merged.entries.length).toBe(24);
       // mergeSkylightIntoMaterialBgl + transmission injection must stay
       // append-only against the 7-entry PBR base.
       const base = buildPbrMaterialUserRegionEntries();

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/assembly/factory.ts', import.meta.url)),
+      fileURLToPath(new URL('../../../render/src/assembly/webgpu-renderer.ts', import.meta.url)),
       'utf8',
     );
     // Once t7 wires it, both literals appear (sprite already in tree).

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

@@ -39,6 +39,7 @@ import {
   getOrCreateSsaoFallbackTexture,
   packClusterUniform,
 } from '../../../render/src/hdrp-buffers';
+import { BYTES_PER_DIRECT_LIGHT_SLOT } from '../../../render/src/light-buffer-layout';
 import { createHdrpBindGroupLayoutDescriptor } from '../../../render/src/pipeline-spec';
 import type { RenderSystemRuntime } from '../../../render/src/render-system';
 
@@ -133,7 +134,7 @@ function fakeHdrpBuffers(): HdrpBuffers {
   return {
     device: {} as HdrpBuffers['device'],
     lightDataBuffer: mockBuffer('hdrp-light-data'),
-    lightDataBytes: 16384,
+    lightDataBytes: 256 * BYTES_PER_DIRECT_LIGHT_SLOT,
     clusterGridBuffer: mockBuffer('hdrp-cluster-grid'),
     clusterGridBytes: 1024,
     lightIndexListBuffer: mockBuffer('hdrp-light-index-list'),

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

@@ -107,7 +107,7 @@ describe('SSAO RenderPipeline PSO descriptor assertions (w24 — RED)', () => {
 
   it('(g1) renderer BGL keeps the kernel binding uniform', () => {
     const factory = readFileSync(
-      fileURLToPath(new URL('../../../render/src/assembly/factory.ts', import.meta.url)),
+      fileURLToPath(new URL('../../../render/src/assembly/webgpu-ready.ts', import.meta.url)),
       'utf8',
     );
     const ssaoBgl = factory.slice(factory.indexOf("label: 'ssao-bgl'"));