@forgeax/engine-runtime 0.1.20 → 0.1.23

package/src/__tests__/loader-name-survival.test.ts

@@ -13,11 +13,11 @@
 //                 after loadByGuid (parseAssetPayload sync branch) resolveName
 //                 returns each stored name.
 //   AC-08 async — a texture in its own (single-asset) package; after loadByGuid
-//                 (texture upstream async branch) resolveName returns the
-//                 basename derived from its package path. Without the entry ->
-//                 Package wiring the texture would land in a null package and
-//                 resolveName would be '' -- so basename here still proves the
-//                 async load path registered the package post-roundtrip.
+//                 (texture upstream async branch) resolveName preserves the
+//                 explicit entry name. Without the entry -> Package wiring the
+//                 texture would land in a null package and resolveName would be
+//                 '' -- so the named result proves the async load path registered
+//                 the package post-roundtrip.
 //   FALSIFY     — the same pack with the entry name stripped degrades to
 //                 basename(path), proving the assertion is name-sensitive (not
 //                 a tautology). The FALSIFY block does not gate CI; it documents
@@ -187,10 +187,9 @@ describe('loader name survival (AC-08)', () => {
 
     const r = await reg.loadByGuid(parseGuid(TEX));
     expect(r.ok).toBe(true);
-    // Single-asset texture package -> basename(path) (AC-01). The wiring is what
-    // makes this non-empty: without entry -> Package the texture lands in a null
-    // package and resolveName would be ''.
-    expect(reg.resolveName(TEX)).toBe('diffuse.pack.json');
+    // An explicit entry name wins even for a single-asset package. The wiring
+    // makes this name survive the async JSON-roundtrip path.
+    expect(reg.resolveName(TEX)).toBe('Diffuse');
   });
 
   it('FALSIFY: stripped entry.name degrades to basename, proving name-sensitivity', async () => {

package/src/__tests__/package-promotion.test.ts

@@ -7,13 +7,10 @@
 //           asset's derived basename is frozen as its stored name so it keeps
 //           the same resolveName (now via the multi-asset branch), with no error
 //           and no caller awareness. Promotion is idempotent: re-registering the
-//           same path does not overwrite an already-frozen name.
+//           same path does not overwrite an already-frozen name. An explicitly
+//           authored name is already stable and is preserved through promotion.
 //
-// The promotion is observable through `package.xor-invariant-violated`: when the
-// original asset already carries a stored name at promotion time (the abnormal
-// single-asset-with-name state, D-4), the freeze must not overwrite it and the
-// soft-violation counter increments. Without w11 there is no promotion branch,
-// so the counter never fires (the falsifying assertion).
+// The promotion must not emit a violation for an explicitly named first asset.
 
 import { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import { AssetGuid } from '@forgeax/engine-pack/guid';
@@ -70,19 +67,18 @@ describe('1->N package promotion (AC-05)', () => {
     expect(reg.resolveName(G2)).toBe('SecondAsset');
   });
 
-  it('abnormal single-asset-with-name state bumps the xor counter and is not overwritten', () => {
+  it('preserves an explicitly authored first-asset name without a false violation', () => {
     const reg = makeRegistry();
     const metrics = createEngineMetrics();
     reg.setMetrics(metrics);
-    // Abnormal: a single-asset package whose lone asset already carries a name.
     reg.catalog(parseGuid(G1), sampler);
     reg._registerPackage(PATH, [G1], new Map([[G1, 'PreNamed']]));
     reg.catalog(parseGuid(G2), sampler);
-    // Promotion fires: the pre-existing name is preserved (not overwritten by
-    // basename) and the soft-violation counter records the abnormal state.
+    // Promotion preserves the authored name rather than replacing it with the
+    // package basename.
     reg._registerPackage(PATH, [G2], new Map([[G2, 'SecondAsset']]));
 
     expect(reg.resolveName(G1)).toBe('PreNamed');
-    expect(metrics.snapshot()['package.xor-invariant-violated']).toBe(1);
+    expect(metrics.snapshot()['package.xor-invariant-violated'] ?? 0).toBe(0);
   });
 });

package/src/__tests__/pbr-pipeline.unit.test.ts

@@ -44,34 +44,29 @@ function makeSpec(): PipelineSpec {
 
 describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', () => {
   describe('pbr-view', () => {
-    it('storageBuffer=true: 12 entries with read-only-storage on bindings 1+2 and projector bindings 11+12', () => {
+    it('storageBuffer=true: 10 entries with projector bindings 11+12', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'pbr-view',
-        caps: { storageBuffer: true },
+        caps: { storageBuffer: true, extendedLighting: false },
       });
       const expected = {
         label: 'pbr-view-bgl',
-        entries: buildPbrViewBglEntries({ storageBuffer: true }),
+        entries: buildPbrViewBglEntries({ storageBuffer: true, extendedLighting: false }),
       };
       expect(out).toEqual(expected);
-      // feat-20260625-spot-light-shadow-mapping: binding 8 (spot shadow atlas,
-      // w14) raised the view BGL to 9 entries (always-on, D-5). The
-      // Points/Lines viewport UBO occupies binding 10, while w25 (scope-amend
-      // webkit-fallback) folded the former binding 9 spotLightViewProj matrices
-      // UBO into the View UBO (`view.spotLightViewProj`), so the BGL stays at 9
-      // entries (bindings 0..8 plus optional projector 11+12 and binding 10)
-      // — keeping the WebGL2 fallback fragment uniform-buffer count <= 11
-      // (GLES 3.0), while the projector remains available on the default
-      // WebGPU path.
-      expect(out.entries.length).toBe(12);
+      // Binding 8 is the always-on spot shadow atlas, binding 10 is the
+      // Points/Lines viewport UBO, and bindings 11/12 are the optional
+      // projector resources. Local lights are exclusively carried by the
+      // Standard Cluster group(2), so the view group has no point/spot slots.
+      expect(out.entries.length).toBe(10);
       expect(out.entries.find((entry) => entry.binding === 9)).toBeUndefined();
       expect(out.entries.find((entry) => entry.binding === 10)?.buffer?.type).toBe('uniform');
       expect(out.entries.find((entry) => entry.binding === 11)?.texture?.viewDimension).toBe('2d');
       expect(out.entries.find((entry) => entry.binding === 12)?.sampler?.type).toBe('filtering');
     });
 
-    it('storageBuffer=false: bindings 1+2 fall back to uniform', () => {
+    it('storageBuffer=false: view group still has no local-light bindings', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'pbr-view',
@@ -82,17 +77,22 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
         entries: buildPbrViewBglEntries({ storageBuffer: false }),
       };
       expect(out).toEqual(expected);
+      expect(out.entries.some((entry) => entry.binding === 1 || entry.binding === 2)).toBe(false);
     });
 
     it('projectorAvailable=false: omits optional projector bindings for the 16-texture limit', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'pbr-view',
-        caps: { storageBuffer: true, projectorAvailable: false },
+        caps: { storageBuffer: true, projectorAvailable: false, extendedLighting: false },
       });
       expect(out).toEqual({
         label: 'pbr-view-bgl',
-        entries: buildPbrViewBglEntries({ storageBuffer: true, projectorAvailable: false }),
+        entries: buildPbrViewBglEntries({
+          storageBuffer: true,
+          projectorAvailable: false,
+          extendedLighting: false,
+        }),
       });
       expect(out.entries.find((entry) => entry.binding === 11)).toBeUndefined();
       expect(out.entries.find((entry) => entry.binding === 12)).toBeUndefined();
@@ -179,7 +179,7 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
   });
 
   describe('pbr-skin-mesh-array', () => {
-    it('storageBuffer=true: 2 entries, both dynamic offset', () => {
+    it('storageBuffer=true: 3 entries, all dynamic offset', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'pbr-skin-mesh-array',
@@ -198,6 +198,11 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
             visibility: 0x1,
             buffer: { type: 'read-only-storage', hasDynamicOffset: true },
           },
+          {
+            binding: 2,
+            visibility: 0x1,
+            buffer: { type: 'read-only-storage', hasDynamicOffset: true },
+          },
         ],
       });
     });

package/src/__tests__/pipeline.unit.test.ts

@@ -31,9 +31,8 @@
 //   - packages/runtime/src/__tests__/render-data.test.ts
 //   - packages/runtime/src/__tests__/hdrp-bgl-slots.test.ts
 //   - packages/runtime/src/__tests__/hdrp-caps-gate.test.ts
-//   - packages/runtime/src/__tests__/hdrp-grid-invalid.test.ts
-//   - packages/runtime/src/__tests__/hdrp-index-list-overflow-once.test.ts
-//   - packages/runtime/src/__tests__/hdrp-light-budget.test.ts
+//   - packages/runtime/src/__tests__/standard-profile-invalid.test.ts
+//   - packages/runtime/src/__tests__/standard-cluster-index-overflow-once.test.ts
 //   - packages/runtime/src/__tests__/hdrp-pipeline-asset-config.test.ts
 //   - packages/runtime/src/__tests__/m7-hdrp-demo-shape.test.ts
 //
@@ -110,16 +109,14 @@ import {
 } from '../../../render/src/cluster-binner';
 import { GpuResidencyCache } from '../../../render/src/device/gpu-residency';
 import { createEngineMetrics } from '../../../render/src/engine-metrics';
+import { StandardProfileInvalidError } from '../../../render/src/errors/render';
 import { assertStorageBufferCap } from '../../../render/src/light-buffer-layout';
 import {
   buildPbrPipelineLayouts,
   buildPbrViewBglEntries,
   type PbrCaps,
 } from '../../../render/src/pbr-pipeline';
-import {
-  HdrpInstallError,
-  validateClusterGrid,
-} from '../../../render/src/pipeline/standard-pipeline';
+import { validateClusterGrid } from '../../../render/src/pipeline/standard-pipeline';
 import {
   buildPipelineForMaterialShader,
   type PipelineBuilderContext,
@@ -907,16 +904,14 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
       expect(result.value).toBe(false);
     });
 
-    it('buildPbrViewBglEntries with UNIFORM_CAPS yields uniform for bindings 1 and 2', () => {
+    it('buildPbrViewBglEntries with UNIFORM_CAPS has no local-light bindings', () => {
       const entries = buildPbrViewBglEntries(UNIFORM_CAPS);
-      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);
     });
 
-    it('buildPbrViewBglEntries with STORAGE_CAPS yields read-only-storage (regression guard)', () => {
+    it('buildPbrViewBglEntries with STORAGE_CAPS has no local-light bindings', () => {
       const entries = buildPbrViewBglEntries(STORAGE_CAPS);
-      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);
     });
   });
 
@@ -993,14 +988,15 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
       expect(instBgl?.entries[0]?.buffer?.type).toBe('uniform');
     });
 
-    it('uniform fallback: view BGL bindings 1+2 are uniform', () => {
+    it('uniform fallback: view BGL has no local-light bindings', () => {
       const device = makeMockDevice();
       // biome-ignore lint/suspicious/noExplicitAny: structural mock
       buildPbrPipelineLayouts(device as any, UNIFORM_CAPS);
       const viewBgl = device.capturedBgls.find((b) => b.label === 'pbr-view-bgl');
       expect(viewBgl).toBeDefined();
-      expect(viewBgl?.entries[1]?.buffer?.type).toBe('uniform');
-      expect(viewBgl?.entries[2]?.buffer?.type).toBe('uniform');
+      expect(viewBgl?.entries.some((entry) => entry.binding === 1 || entry.binding === 2)).toBe(
+        false,
+      );
     });
 
     it('storage path: mesh-array BGL entry type is read-only-storage (regression guard)', () => {
@@ -2122,13 +2118,13 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
     // sprite; the test locks the outcome so an inline-logic drift is caught.
     function resolveBootDefinesKey(
       msEntry: MaterialShaderManifestEntry,
-      opts: { readonly storageBufferCapable: boolean; readonly isHdrpActive: boolean },
+      opts: { readonly storageBufferCapable: boolean; readonly clusteredLighting: boolean },
     ): string {
       const variantDefines: Record<string, boolean> = {
         STORAGE_BUFFER_AVAILABLE: opts.storageBufferCapable,
       };
       if (msEntry.variants.some((v) => 'CLUSTER_FORWARD_AVAILABLE' in v.defines)) {
-        variantDefines.CLUSTER_FORWARD_AVAILABLE = opts.isHdrpActive;
+        variantDefines.CLUSTER_FORWARD_AVAILABLE = opts.clusteredLighting;
       }
       if (msEntry.variants.some((v) => 'PER_INSTANCE_REGION' in v.defines)) {
         variantDefines.PER_INSTANCE_REGION = false;
@@ -2145,7 +2141,7 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
       const spriteEntry = makeSpriteEntry();
       const definesKey = resolveBootDefinesKey(spriteEntry, {
         storageBufferCapable: true,
-        isHdrpActive: false,
+        clusteredLighting: false,
       });
       expect(definesKey).toBe('PER_INSTANCE_REGION=false+STORAGE_BUFFER_AVAILABLE=true');
       const variant = findVariantByKey(spriteEntry, definesKey);
@@ -2162,7 +2158,7 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
       const spriteEntry = makeSpriteEntry();
       const definesKey = resolveBootDefinesKey(spriteEntry, {
         storageBufferCapable: false,
-        isHdrpActive: false,
+        clusteredLighting: false,
       });
       expect(definesKey).toBe('PER_INSTANCE_REGION=false+STORAGE_BUFFER_AVAILABLE=false');
       const variant = findVariantByKey(spriteEntry, definesKey);
@@ -2197,7 +2193,7 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
       const spriteEntry = makeSpriteEntry();
       const bootDefinesKey = resolveBootDefinesKey(spriteEntry, {
         storageBufferCapable: true,
-        isHdrpActive: false,
+        clusteredLighting: false,
       });
       const bootVariant = findVariantByKey(spriteEntry, bootDefinesKey);
       const spriteInstancesVariant = findVariantByKey(spriteEntry, '');
@@ -4934,40 +4930,49 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
 }
 
 {
-  // --- from hdrp-grid-invalid.test.ts ---
-  describe('hdrp-grid-invalid', () => {
+  // --- from standard-profile-invalid.test.ts ---
+  describe('standard-profile-invalid', () => {
     describe('validateClusterGrid', () => {
       // AC-23 scenario (a): x === 0
-      it('rejects x=0 with code hdrp-grid-invalid and hint contains "positive integer"', () => {
+      it('rejects x=0 with code standard-profile-invalid and hint contains "positive integer"', () => {
         const result = validateClusterGrid({ x: 0, y: 9, z: 24 });
         expect(result.ok).toBe(false);
         if (!result.ok) {
-          expect(result.error.code).toBe('hdrp-grid-invalid');
+          expect(result.error.code).toBe('standard-profile-invalid');
           expect(result.error.hint).toContain('positive integer');
           expect(result.error.expected).toContain('[1, 64]');
-          expect(result.error.detail).toEqual({ x: 0, y: 9, z: 24 });
+          expect(result.error.detail).toEqual({
+            field: 'clusterGrid',
+            actual: { x: 0, y: 9, z: 24 },
+          });
         }
       });
 
       // AC-23 scenario (b): non-integer x=1.5
-      it('rejects x=1.5 (non-integer) with code hdrp-grid-invalid', () => {
+      it('rejects x=1.5 (non-integer) with code standard-profile-invalid', () => {
         const result = validateClusterGrid({ x: 1.5, y: 9, z: 24 });
         expect(result.ok).toBe(false);
         if (!result.ok) {
-          expect(result.error.code).toBe('hdrp-grid-invalid');
+          expect(result.error.code).toBe('standard-profile-invalid');
           expect(result.error.hint).toContain('positive integer');
-          expect(result.error.detail).toEqual({ x: 1.5, y: 9, z: 24 });
+          expect(result.error.detail).toEqual({
+            field: 'clusterGrid',
+            actual: { x: 1.5, y: 9, z: 24 },
+          });
         }
       });
 
       // AC-23 scenario (c): y === -1
-      it('rejects y=-1 with code hdrp-grid-invalid', () => {
+      it('rejects y=-1 with code standard-profile-invalid', () => {
         const result = validateClusterGrid({ x: 16, y: -1, z: 24 });
         expect(result.ok).toBe(false);
         if (!result.ok) {
-          expect(result.error.code).toBe('hdrp-grid-invalid');
+          expect(result.error.code).toBe('standard-profile-invalid');
           expect(result.error.hint).toContain('positive integer');
-          expect(result.error.detail).toEqual({ x: 16, y: -1, z: 24 });
+          expect(result.error.detail).toEqual({
+            field: 'clusterGrid',
+            actual: { x: 16, y: -1, z: 24 },
+          });
         }
       });
 
@@ -4976,10 +4981,13 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
         const result = validateClusterGrid({ x: 16, y: 9, z: 65 });
         expect(result.ok).toBe(false);
         if (!result.ok) {
-          expect(result.error.code).toBe('hdrp-grid-invalid');
+          expect(result.error.code).toBe('standard-profile-invalid');
           expect(result.error.hint).toContain('[1, 64]');
           expect(result.error.expected).toContain('[1, 64]');
-          expect(result.error.detail).toEqual({ x: 16, y: 9, z: 65 });
+          expect(result.error.detail).toEqual({
+            field: 'clusterGrid',
+            actual: { x: 16, y: 9, z: 65 },
+          });
         }
       });
 
@@ -5001,21 +5009,24 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
       });
     });
 
-    describe('HdrpInstallError shape', () => {
+    describe('StandardProfileInvalidError shape', () => {
       // AC-23: charter P3 triple-set .code / .hint / .expected + .detail.{x,y,z}
       it('carries charter P3 triple-set with detail', () => {
-        const err = new HdrpInstallError(0, 9, 24);
-        expect(err.code).toBe('hdrp-grid-invalid');
+        const err = new StandardProfileInvalidError('clusterGrid invalid', {
+          field: 'clusterGrid',
+          actual: { x: 0, y: 9, z: 24 },
+        });
+        expect(err.code).toBe('standard-profile-invalid');
         expect(err.hint).toContain('positive integer');
         expect(err.expected).toContain('[1, 64]');
-        expect(err.detail).toEqual({ x: 0, y: 9, z: 24 });
+        expect(err.detail).toEqual({ field: 'clusterGrid', actual: { x: 0, y: 9, z: 24 } });
       });
     });
   });
 }
 
 {
-  // --- from hdrp-index-list-overflow-once.test.ts ---
+  // --- from standard-cluster-index-overflow-once.test.ts ---
   function makeIdentityMat4(): Mat4 {
     return mat4.identity(mat4.create());
   }
@@ -5076,194 +5087,25 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
     });
   });
 
-  // ── hdrp-index-list-overflow RuntimeError class shape ────────────────────────
+  // ── Standard cluster index-overflow RuntimeError class shape ─────────────────
 
-  // ── AC-03 guardrail: URP LIGHT_ARRAY_MAX_SLOTS=4 + 5 PointLights ─────────────
-  //
-  // This test verifies that the existing URP `render-system-multi-light` warn-once
-  // still fires when PointLights exceed the first-slice cap (AC-03).
-  // The budget constant LIGHT_ARRAY_MAX_SLOTS must remain at 4.
+  // ── Unified Cluster light ABI guardrails ─────────────────────────────────
 
-  describe('URP light budget warn-once guardrail (AC-03)', () => {
-    it('LIGHT_ARRAY_MAX_SLOTS is still 4 (URP first-slice cap)', async () => {
-      const { LIGHT_ARRAY_MAX_SLOTS } = await import('../../../render/src/light-buffer-layout');
-      expect(LIGHT_ARRAY_MAX_SLOTS).toBe(4);
-    });
-
-    it('POINT_LIGHT_STD430_BYTES and SPOT_LIGHT_STD430_BYTES match the current URP payloads', async () => {
-      const { POINT_LIGHT_STD430_BYTES, SPOT_LIGHT_STD430_BYTES } = await import(
+  describe('Standard Cluster light ABI guardrail', () => {
+    it('BYTES_PER_DIRECT_LIGHT_SLOT matches the unified URP and HDRP ABI', async () => {
+      const { BYTES_PER_DIRECT_LIGHT_SLOT } = await import(
         '../../../render/src/light-buffer-layout'
       );
-      expect(POINT_LIGHT_STD430_BYTES).toBe(32);
-      // SpotLight's projector receiver controls and shadow intensity occupy
-      // the appended fifth vec4 column; point-light layout remains unchanged.
-      expect(SPOT_LIGHT_STD430_BYTES).toBe(80);
-    });
-  });
-}
-
-{
-  // --- from hdrp-light-budget.test.ts ---
-
-  // ── Budget gate unit logic (the pure gate w23 will embed) ─────────────────────
-
-  const HDRP_BUDGET = 256;
-
-  function enforceLightBudget(
-    totalLightCount: number,
-    oncePerFrameFired: Set<string>,
-    fire: (code: string, errors: unknown[]) => void,
-  ): number {
-    if (totalLightCount <= HDRP_BUDGET) {
-      return totalLightCount;
-    }
-    // Truncate to budget.
-    const truncated = HDRP_BUDGET;
-    if (!oncePerFrameFired.has('hdrp-light-budget-exceeded')) {
-      oncePerFrameFired.add('hdrp-light-budget-exceeded');
-      fire('hdrp-light-budget-exceeded', [totalLightCount, HDRP_BUDGET]);
-    }
-    return truncated;
-  }
-
-  describe('HDRP light budget enforcement gate (AC-06/AC-07)', () => {
-    it('256 lights: no fire, returns 256 (AC-06 boundary)', () => {
-      const fired = new Set<string>();
-      const errors: Array<{ code: string; actual: number; budget: number }> = [];
-      const fireFn = (_code: string, args: unknown[]) => {
-        errors.push({
-          code: 'hdrp-light-budget-exceeded',
-          actual: args[0] as number,
-          budget: args[1] as number,
-        });
-      };
-
-      const result = enforceLightBudget(256, fired, fireFn);
-      expect(result).toBe(256);
-      expect(fired.size).toBe(0);
-      expect(errors.length).toBe(0);
-    });
-
-    it('257 lights: fires once, returns 256 (AC-07 truncation)', () => {
-      const fired = new Set<string>();
-      const errors: Array<{ code: string; actual: number; budget: number }> = [];
-      const fireFn = (_code: string, args: unknown[]) => {
-        errors.push({
-          code: 'hdrp-light-budget-exceeded',
-          actual: args[0] as number,
-          budget: args[1] as number,
-        });
-      };
-
-      const result = enforceLightBudget(257, fired, fireFn);
-      expect(result).toBe(256);
-      expect(fired.size).toBe(1);
-      expect(fired.has('hdrp-light-budget-exceeded')).toBe(true);
-      expect(errors.length).toBe(1);
-      expect(errors[0]?.actual).toBe(257);
-      expect(errors[0]?.budget).toBe(256);
-    });
-
-    it('same-frame subsequent overflow suppressed (warn-once-per-frame-bucket)', () => {
-      // Simulate frame already having fired the budget error.
-      const fired = new Set<string>(['hdrp-light-budget-exceeded']);
-      const errors: Array<{ code: string; actual: number; budget: number }> = [];
-      const fireFn = (_code: string, args: unknown[]) => {
-        errors.push({
-          code: 'hdrp-light-budget-exceeded',
-          actual: args[0] as number,
-          budget: args[1] as number,
-        });
-      };
-
-      // Even with 300 lights on the same frame, it should not fire again.
-      const result = enforceLightBudget(300, fired, fireFn);
-      expect(result).toBe(256);
-      expect(errors.length).toBe(0);
-    });
-
-    it('second frame fires again (fresh bucket)', () => {
-      // New frame: empty Set.
-      const fired = new Set<string>();
-      const errors: Array<{ code: string; actual: number; budget: number }> = [];
-      const fireFn = (_code: string, args: unknown[]) => {
-        errors.push({
-          code: 'hdrp-light-budget-exceeded',
-          actual: args[0] as number,
-          budget: args[1] as number,
-        });
-      };
-
-      const result = enforceLightBudget(258, fired, fireFn);
-      expect(result).toBe(256);
-      expect(errors.length).toBe(1);
-      expect(errors[0]?.actual).toBe(258);
-      expect(errors[0]?.budget).toBe(256);
-    });
-
-    it('second frame with exactly 256 does not fire (fresh bucket, under budget)', () => {
-      const fired = new Set<string>();
-      const errors: Array<{ code: string; actual: number; budget: number }> = [];
-      const fireFn = (_code: string, args: unknown[]) => {
-        errors.push({
-          code: 'hdrp-light-budget-exceeded',
-          actual: args[0] as number,
-          budget: args[1] as number,
-        });
-      };
-
-      const result = enforceLightBudget(256, fired, fireFn);
-      expect(result).toBe(256);
-      expect(errors.length).toBe(0);
-    });
-
-    it('0 lights returns 0 (empty scene, no fire)', () => {
-      const fired = new Set<string>();
-      const errors: Array<{ code: string; actual: number; budget: number }> = [];
-      const fireFn = (_code: string, args: unknown[]) => {
-        errors.push({
-          code: 'hdrp-light-budget-exceeded',
-          actual: args[0] as number,
-          budget: args[1] as number,
-        });
-      };
-
-      const result = enforceLightBudget(0, fired, fireFn);
-      expect(result).toBe(0);
-      expect(errors.length).toBe(0);
-    });
-
-    it('HDRP_BUDGET constant must be 256 (D-scope anchor)', () => {
-      expect(HDRP_BUDGET).toBe(256);
-    });
-  });
-
-  // ── Integration pattern: once-per-frame Set complements existing hdrpOncePerFrameFired ──
-
-  describe('hdrpOncePerFrameFired Set dedup semantics', () => {
-    it('empty set allows first fire', () => {
-      const fired = new Set<string>();
-      expect(fired.has('hdrp-light-budget-exceeded')).toBe(false);
+      expect(BYTES_PER_DIRECT_LIGHT_SLOT).toBe(80);
     });
 
-    it('set with entry suppresses subsequent fires on the same code', () => {
-      const fired = new Set<string>(['hdrp-light-budget-exceeded']);
-      expect(fired.has('hdrp-light-budget-exceeded')).toBe(true);
-    });
-
-    it('hdrp-light-budget-exceeded is independent from hdrp-index-list-overflow', () => {
-      const fired = new Set<string>(['hdrp-index-list-overflow']);
-      // Budget-exceeded should still fire even if index-list-overflow already fired this frame.
-      expect(fired.has('hdrp-light-budget-exceeded')).toBe(false);
-      expect(fired.has('hdrp-index-list-overflow')).toBe(true);
-    });
-
-    it('clearing the set (new frame) allows re-fire', () => {
-      const fired = new Set<string>(['hdrp-light-budget-exceeded']);
-      fired.clear();
-      expect(fired.has('hdrp-light-budget-exceeded')).toBe(false);
-      // The recordFrame entry clears hdrpOncePerFrameFired when frameNumber increments.
-      // This test verifies the clear() semantics match the expected new-frame behaviour.
+    it('direct-light payload byte size matches the Cluster volume transport', async () => {
+      const { BYTES_PER_DIRECT_LIGHT_SLOT } = await import(
+        '../../../render/src/light-buffer-layout'
+      );
+      // Point, Spot, and Rect volume receivers share the same five-row
+      // DirectLightSlot transport as the Standard surface Cluster path.
+      expect(BYTES_PER_DIRECT_LIGHT_SLOT).toBe(80);
     });
   });
 }
@@ -5274,13 +5116,13 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
     it('creates a RenderPipelineAsset with HDRP pipelineId and clusterGrid config', () => {
       const asset: RenderPipelineAsset = {
         kind: 'render-pipeline',
-        pipelineId: 'forgeax::hdrp',
+        pipelineId: 'forgeax::standard',
         config: {
           clusterGrid: { x: 16, y: 9, z: 24 },
         },
       };
 
-      expect(asset.pipelineId).toBe('forgeax::hdrp');
+      expect(asset.pipelineId).toBe('forgeax::standard');
       expect(asset.kind).toBe('render-pipeline');
       expect(asset.config?.clusterGrid).toBeDefined();
       expect(asset.config?.clusterGrid?.x).toBe(16);
@@ -5291,17 +5133,17 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
     it('creates a RenderPipelineAsset with URP pipelineId and no clusterGrid', () => {
       const asset: RenderPipelineAsset = {
         kind: 'render-pipeline',
-        pipelineId: 'forgeax::urp',
+        pipelineId: 'forgeax::standard',
       };
 
-      expect(asset.pipelineId).toBe('forgeax::urp');
+      expect(asset.pipelineId).toBe('forgeax::standard');
       expect(asset.config?.clusterGrid).toBeUndefined();
     });
 
     it('passCount field is still supported alongside clusterGrid', () => {
       const asset: RenderPipelineAsset = {
         kind: 'render-pipeline',
-        pipelineId: 'forgeax::hdrp',
+        pipelineId: 'forgeax::standard',
         config: {
           passCount: 3,
           clusterGrid: { x: 16, y: 9, z: 24 },