@forgeax/engine-runtime 0.1.20 → 0.1.23

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

@@ -349,7 +349,7 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
       });
     });
 
-    describe('t2 - AC-15 ImageErrorCode exhaustive switch (new member)', () => {
+    describe('t2 - AC-15 ImageErrorCode exhaustive switch (new members)', () => {
       it('ImageErrorCode includes image-hdr-decode-failed', () => {
         const code: ImageErrorCode = 'image-hdr-decode-failed';
         expect(code).toBe('image-hdr-decode-failed');
@@ -378,10 +378,17 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
               return 'atlas size exceeded';
             case 'atlas-region-mismatch':
               return 'atlas region mismatch';
+            // feat-20260829-deep-agent-game-feedback-resolution M5 —
+            // PixelSurface authoring errors remain part of the closed image
+            // error vocabulary and must stay covered by every exhaustive
+            // consumer switch.
+            case 'image-surface-invalid':
+              return 'surface invalid';
           }
         }
         expect(exhaustive('image-decode-failed')).toBe('decode failed');
         expect(exhaustive('image-hdr-decode-failed')).toBe('hdr decode failed');
+        expect(exhaustive('image-surface-invalid')).toBe('surface invalid');
       });
     });
   });
@@ -420,6 +427,8 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
               return 'cleanup failed';
             case 'scene-data-unavailable':
               return 'scene data unavailable';
+            case 'standard-profile-invalid':
+              return 'standard profile invalid';
             case 'frame-receipt-stale':
               return 'frame receipt stale';
             case 'renderer-contract-failed':
@@ -464,14 +473,24 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
               return 'mesh ssbo capacity exceeded';
             case 'mesh-ssbo-ceiling-reached':
               return 'mesh ssbo ceiling reached';
-            case 'hdrp-light-budget-exceeded':
-              return 'hdrp light budget exceeded';
-            case 'hdrp-index-list-overflow':
-              return 'hdrp index list overflow';
-            // feat-20260612-hdrp-deferred-shading-learn-render-5-8 M1 / w6:
-            // 3 new deferred-path error codes.
-            case 'hdrp-deferred-caps-insufficient':
-              return 'hdrp deferred caps insufficient';
+            case 'render-target-descriptor-invalid':
+              return 'render target descriptor invalid';
+            case 'render-target-capability-missing':
+              return 'render target capability missing';
+            case 'render-target-state-invalid':
+              return 'render target state invalid';
+            case 'render-target-operation-failed':
+              return 'render target operation failed';
+            case 'reflection-probe-budget-exceeded':
+              return 'reflection probe budget exceeded';
+            case 'render-intent-invalid':
+              return 'render intent invalid';
+            case 'standard-light-budget-exceeded':
+              return 'standard light budget exceeded';
+            case 'standard-cluster-index-overflow':
+              return 'standard cluster index overflow';
+            case 'standard-cluster-transport-unavailable':
+              return 'standard cluster transport unavailable';
             // feat-20260611-fox-skinning-vertex-attribute-chain M4 / w17 (D-5):
             // bidirectional Skin <-> pbr-skin material mismatch detected at extract.
             case 'skin-material-mismatch':
@@ -528,6 +547,8 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
               return 'points lines budget exceeded';
             case 'points-lines-prepare-failed':
               return 'points lines prepare failed';
+            case 'light-resource-unavailable':
+              return 'light resource unavailable';
             case 'transmission-capability-missing':
               return 'transmission capability missing';
             case 'projector-binding-failed':
@@ -551,16 +572,15 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
     });
 
     /*
-     * feat-20260612-hdrp-deferred-shading-learn-render-5-8 M1 / w3:
-     * RuntimeErrorCode +3 members — exhaustive narrow test.
+     * Standard lighting closed error codes — exhaustive narrow test.
      *
-     * AC-07: three new error codes must be members of RuntimeErrorCode closed union.
+     * AC-07: three Standard lighting codes are members of the closed render union.
      * Each error code narrows without a default branch in switch (err.code).
      */
-    describe('RuntimeErrorCode +3 new members (w3)', () => {
-      it('hdrp-deferred-caps-insufficient is a valid RuntimeErrorCode', () => {
-        const code: RuntimeLayerErrorCode = 'hdrp-deferred-caps-insufficient';
-        expect(code).toBe('hdrp-deferred-caps-insufficient');
+    describe('Standard lighting error members', () => {
+      it('standard-cluster-transport-unavailable is a valid RenderErrorCode', () => {
+        const code: RuntimeLayerErrorCode = 'standard-cluster-transport-unavailable';
+        expect(code).toBe('standard-cluster-transport-unavailable');
       });
 
       it('exhaustive switch covers all 3 new members alongside existing members', () => {
@@ -591,6 +611,7 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
             case 'cleanup-failed':
               return 'ok';
             case 'scene-data-unavailable':
+            case 'standard-profile-invalid':
               return 'ok';
             case 'frame-receipt-stale':
               return 'ok';
@@ -636,9 +657,9 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
               return 'ok';
             case 'mesh-ssbo-ceiling-reached':
               return 'ok';
-            case 'hdrp-light-budget-exceeded':
+            case 'standard-light-budget-exceeded':
               return 'ok';
-            case 'hdrp-index-list-overflow':
+            case 'standard-cluster-index-overflow':
               return 'ok';
             case 'skin-material-mismatch':
               return 'ok';
@@ -650,7 +671,19 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
               return 'ok';
             case 'joint-entity-dangling':
               return 'ok';
-            case 'hdrp-deferred-caps-insufficient':
+            case 'standard-cluster-transport-unavailable':
+              return 'ok';
+            case 'render-target-descriptor-invalid':
+              return 'ok';
+            case 'render-target-capability-missing':
+              return 'ok';
+            case 'render-target-state-invalid':
+              return 'ok';
+            case 'render-target-operation-failed':
+              return 'ok';
+            case 'reflection-probe-budget-exceeded':
+              return 'ok';
+            case 'render-intent-invalid':
               return 'ok';
             case 'point-shadow-atlas-uninitialized':
               return 'ok';
@@ -688,6 +721,7 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
               return 'ok';
             case 'points-lines-prepare-failed':
               return 'ok';
+            case 'light-resource-unavailable':
             case 'transmission-capability-missing':
               return 'ok';
             case 'projector-binding-failed':
@@ -702,7 +736,7 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
               return 'ok';
           }
         }
-        expect(exhaustive('hdrp-deferred-caps-insufficient')).toBe('ok');
+        expect(exhaustive('standard-cluster-transport-unavailable')).toBe('ok');
         expect(exhaustive('point-shadow-atlas-uninitialized')).toBe('ok');
         expect(exhaustive('point-shadow-atlas-bounds-violation')).toBe('ok');
       });

package/src/__tests__/extract-frames-merge.test.ts

@@ -161,62 +161,39 @@ function simulateMerge(
   // AC-04: lights — point[]/spot[] concat; directional first-hit in worlds[] order; directionalCount sum
   const point: PointLightSnapshot[] = [];
   const spot: SpotLightSnapshot[] = [];
+  const rect: ExtractedLights['rect'][number][] = [];
   let directional: DirectionalLightSnapshot | undefined;
   let directionalCount = 0;
   for (const f of frames) {
     for (const p of f.lights.point) point.push(p);
     for (const s of f.lights.spot) spot.push(s);
+    for (const r of f.lights.rect) rect.push(r);
     if (directional === undefined && f.lights.directional !== undefined) {
       directional = f.lights.directional;
     }
     directionalCount += f.lights.directionalCount;
   }
+  const firstDirectionalLights = frames.find(
+    (frame) => frame.lights.directional !== undefined,
+  )?.lights;
   const lights: ExtractedLights = {
     directional,
     directionalCount,
     point,
     spot,
-    lightViewProj:
-      directional !== undefined
-        ? frames.find((f) => f.lights.directional !== undefined)?.lights.lightViewProj
-        : undefined,
-    splitPlanes:
-      directional !== undefined
-        ? frames.find((f) => f.lights.directional !== undefined)?.lights.splitPlanes
-        : undefined,
-    cascadeCount:
-      directional !== undefined
-        ? frames.find((f) => f.lights.directional !== undefined)?.lights.cascadeCount
-        : undefined,
-    cascadeBlend:
-      directional !== undefined
-        ? frames.find((f) => f.lights.directional !== undefined)?.lights.cascadeBlend
-        : undefined,
-    shadowMapSize:
-      directional !== undefined
-        ? frames.find((f) => f.lights.directional !== undefined)?.lights.shadowMapSize
-        : undefined,
-    depthBias:
-      directional !== undefined
-        ? frames.find((f) => f.lights.directional !== undefined)?.lights.depthBias
-        : undefined,
-    normalBias:
-      directional !== undefined
-        ? frames.find((f) => f.lights.directional !== undefined)?.lights.normalBias
-        : undefined,
-    pcfKernelSize:
-      directional !== undefined
-        ? frames.find((f) => f.lights.directional !== undefined)?.lights.pcfKernelSize
-        : undefined,
+    rect,
+    lightViewProj: firstDirectionalLights?.lightViewProj,
+    splitPlanes: firstDirectionalLights?.splitPlanes,
+    cascadeCount: firstDirectionalLights?.cascadeCount,
+    cascadeBlend: firstDirectionalLights?.cascadeBlend,
+    shadowMapSize: firstDirectionalLights?.shadowMapSize,
+    depthBias: firstDirectionalLights?.depthBias,
+    normalBias: firstDirectionalLights?.normalBias,
+    directionalShadowQuality: firstDirectionalLights?.directionalShadowQuality,
+    directionalShadowError: firstDirectionalLights?.directionalShadowError,
     pointShadow: frames.flatMap((f) => f.lights.pointShadow),
-    directionalCsmConfig:
-      directional !== undefined
-        ? frames.find((f) => f.lights.directional !== undefined)?.lights.directionalCsmConfig
-        : undefined,
-    directionalCsmDirection:
-      directional !== undefined
-        ? frames.find((f) => f.lights.directional !== undefined)?.lights.directionalCsmDirection
-        : undefined,
+    directionalCsmConfig: firstDirectionalLights?.directionalCsmConfig,
+    directionalCsmDirection: firstDirectionalLights?.directionalCsmDirection,
   };
 
   // AC-05: singletons from owner world only
@@ -433,6 +410,36 @@ describe('extractFrames merge semantics (m2-t1, AC-04/05/06)', () => {
     expect(frameB.lights.directionalCount).toBe(1);
   });
 
+  it('AC-04: first directional owner error is preserved across the merge', () => {
+    const worldA = new World();
+    worldA
+      .spawn(
+        { component: Transform, data: identityTransform() },
+        {
+          component: DirectionalLight,
+          data: {
+            direction: [0, -1, 0],
+            shadowFilter: 4,
+            shadowAngularRadius: 999,
+            maxPenumbraTexels: 32,
+          },
+        },
+      )
+      .unwrap();
+
+    const worldB = makeWorldWithDirectionalLight();
+    const frameA = extractFrame(worldA, prepareExtractContext(worldA));
+    const frameB = extractFrame(worldB, prepareExtractContext(worldB));
+
+    expect(frameA.lights.directionalShadowError?.code).toBe('shadow-invalid-config');
+    expect(frameB.lights.directionalShadowError).toBeUndefined();
+    const merged = simulateMerge([frameA, frameB], 0);
+    expect(merged.lights.directionalShadowError?.detail).toMatchObject({
+      field: 'shadowAngularRadius',
+      actual: 999,
+    });
+  });
+
   // ── AC-05: singleton resources from owner only ─────────────────────────────
 
   it('AC-05: skylight is taken from owner world only, non-owner ignored', () => {
@@ -624,6 +631,9 @@ describe('extractFrames cross-world directional CSM (bug-20260710)', () => {
     }
     // splitPlanes reach the component shadowDistance on the last cascade.
     expect(frame.lights.splitPlanes).toBeDefined();
+    expect(frame.lights.splitPlanes).toHaveLength(16);
+    expect(frame.lights.splitPlanes?.[1]).toBeGreaterThan(0);
+    expect(frame.lights.splitPlanes?.[2]).toBeGreaterThan(0);
   });
 
   it('single world (camera + light together) still yields non-zero lightViewProj', () => {
@@ -652,5 +662,6 @@ describe('extractFrames cross-world directional CSM (bug-20260710)', () => {
     for (let i = 0; i < (frame.lights.cascadeCount ?? 0); i++) {
       expect(isNonZeroMat(lvp?.[i])).toBe(true);
     }
+    expect(frame.lights.splitPlanes).toHaveLength(16);
   });
 });

package/src/__tests__/extract-skin-mismatch.unit.test.ts

@@ -276,7 +276,7 @@ describe('render-system-extract Skin / pbr-skin mismatch (AC-07 / w19)', () => {
     expect(frame.renderables).toHaveLength(0);
   });
 
-  it('(c) Skin + pbr-skin material + skinned mesh -> no error routed', () => {
+  it('(c) Skin + pbr-skin material without a palette allocator -> renderable and dispatch skipped', () => {
     const world = new World();
     const assets = makeAssetRegistry();
     const meshHandle = registerSkinnedMesh(world);
@@ -288,9 +288,13 @@ describe('render-system-extract Skin / pbr-skin mismatch (AC-07 / w19)', () => {
 
     const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
 
-    extractFrame(world, prepareExtractContext(world, { assets }));
+    const frame = extractFrame(world, prepareExtractContext(world, { assets }));
 
     expect(errorSpy).not.toHaveBeenCalled();
+    expect(frame.renderables).toHaveLength(0);
+    expect(frame.dispatch.some((entry) => entry.materialShaderId === 'forgeax::pbr-skin')).toBe(
+      false,
+    );
   });
 
   it('(d) D-5 continue semantics: bad-skin entity skipped does NOT abort sibling extract', () => {

package/src/__tests__/frame-targets-shadow-regression.unit.test.ts

@@ -25,4 +25,17 @@ describe('frame targets shadow removal', () => {
 
     expect(resolveShadowMapSize(internals as never, lights as never)).toBe(1024);
   });
+
+  it('does not resolve a Directional atlas for the disabled topology sentinel', () => {
+    const internals = {
+      device: { limits: { maxTextureDimension2D: 2048 } },
+    };
+    const lights = {
+      directional: 'disabled',
+      shadowMapSize: 2048,
+      cascadeCount: undefined,
+    };
+
+    expect(resolveShadowMapSize(internals as never, lights as never)).toBeUndefined();
+  });
 });

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

@@ -2390,20 +2390,17 @@ function drawPublished(renderer: RendererType, world: WorldType) {
       spies.drawIndexed.mockClear();
       drawPublished(renderer, world as WorldType);
 
-      // All submesh draws share the same instanceCount (D-8).
-      // Verify drawIndexed calls carry instanceCount parameter at index 1.
+      // Mesh indexed draws carry the Instances cardinality. Fullscreen graph
+      // draws are a separate topology concern and intentionally use one
+      // instance; do not mix those two contracts in one equality assertion.
       const indexedCalls = spies.drawIndexed.mock.calls as Array<
         [number, number, number, number, number]
       >;
       const drawCalls = spies.draw.mock.calls as Array<[number, number, number, number]>;
-      const allInstanceCounts = [...indexedCalls.map((c) => c[1]), ...drawCalls.map((c) => c[1])];
-      // All instanceCounts should be identical (shared across submeshes, D-8).
-      if (allInstanceCounts.length >= 2) {
-        const first = allInstanceCounts[0];
-        for (const ic of allInstanceCounts) {
-          expect(ic).toBe(first);
-        }
-      }
+      expect(indexedCalls.length).toBeGreaterThan(0);
+      expect(indexedCalls.map((call) => call[1])).toEqual(expect.arrayContaining([4]));
+      expect(indexedCalls.every((call) => call[1] === 4)).toBe(true);
+      expect(drawCalls.every((call) => call[1] === 1)).toBe(true);
       expect(errors).toEqual([]);
     });
 

package/src/__tests__/helpers/register-runtime-components.ts

@@ -24,7 +24,14 @@ import {
   TileLayer,
   Tilemap,
 } from '@forgeax/engine-render/authoring';
-import { ChildOf, Children, MorphWeights, Name, Transform } from '@forgeax/engine-scene';
+import {
+  ChildOf,
+  Children,
+  GlobalTransform,
+  MorphWeights,
+  Name,
+  Transform,
+} from '@forgeax/engine-scene';
 
 const RUNTIME_COMPONENTS: readonly Component[] = [
   Camera,
@@ -51,6 +58,7 @@ const RUNTIME_COMPONENTS: readonly Component[] = [
   TileLayer,
   Tilemap,
   Transform,
+  GlobalTransform,
   VideoPlayer,
   Visibility,
 ];

package/src/__tests__/helpers/register-scene-components.ts

@@ -1,10 +1,17 @@
 import type { Component, World } from '@forgeax/engine-ecs';
 import { SceneInstance } from '@forgeax/engine-render';
-import { ChildOf, Children, Transform } from '@forgeax/engine-scene';
+import { ChildOf, Children, GlobalTransform, Transform } from '@forgeax/engine-scene';
 
 /** Register the scene vocabulary explicitly for an isolated test World. */
 export function registerSceneComponents(world: World, extras: readonly Component[] = []): void {
-  for (const component of [SceneInstance, ChildOf, Children, Transform, ...extras]) {
+  for (const component of [
+    SceneInstance,
+    ChildOf,
+    Children,
+    Transform,
+    GlobalTransform,
+    ...extras,
+  ]) {
     world.components.register(component).unwrap();
   }
 }

package/src/__tests__/light-gpu-byte-neutral.unit.test.ts

@@ -7,8 +7,8 @@
 // lock the four light GPU pack paths' byte output so the collapse is proven
 // byte-neutral end to end:
 //   1. View UBO (DirectionalLight direction/color lanes)   -> writeViewUbo
-//   2. PointLightBuffer (color lanes)                       -> packPointLight
-//   3. SpotLightBuffer (direction + color lanes)            -> packSpotLight
+//   2. PointLightBuffer (color lanes)                       -> packDirectLightSlot
+//   3. SpotLightBuffer (direction + color lanes)            -> packDirectLightSlot
 //   4. Skylight uniform/ambient (color destructure)         -> SkylightSnapshot
 // (Camera clear pass is M3, not here.)
 
@@ -16,7 +16,7 @@ import { vec3 } from '@forgeax/engine-math';
 import type { Buffer, RhiQueue } from '@forgeax/engine-rhi';
 import { ok } from '@forgeax/engine-rhi';
 import { describe, expect, it } from 'vitest';
-import { packPointLight, packSpotLight } from '../../../render/src/light-buffer-layout';
+import { packDirectLightSlot } from '../../../render/src/light-buffer-layout';
 import { writeViewUbo } from '../../../render/src/record/view-ubo';
 import type { CameraSnapshot } from '../../../render/src/render-contract';
 import type {
@@ -57,13 +57,14 @@ const emptyLights: ExtractedLights = {
   directionalCount: 0,
   point: [],
   spot: [],
+  directionalShadowError: undefined,
   lightViewProj: undefined,
   splitPlanes: undefined,
   cascadeCount: undefined,
   cascadeBlend: undefined,
   depthBias: undefined,
   normalBias: undefined,
-  pcfKernelSize: undefined,
+  directionalShadowQuality: undefined,
 } as unknown as ExtractedLights;
 
 /** Capture the single writeViewUbo payload as a Float32Array. */
@@ -102,7 +103,7 @@ describe('w7 -- light GPU pack byte-neutral (AC-11)', () => {
     expect(payload[22]).toBeCloseTo(0.7, 5);
   });
 
-  it('packPointLight writes color into slots 4..6 byte-for-byte (32 B)', () => {
+  it('packDirectLightSlot writes Point color into slots 4..6 byte-for-byte (80 B)', () => {
     const snap: PointLightSnapshot = {
       kind: 'point',
       position: vec3.create(1.5, -2.25, 0.125),
@@ -110,14 +111,14 @@ describe('w7 -- light GPU pack byte-neutral (AC-11)', () => {
       intensity: 2,
       invRangeSquared: 0.04,
     };
-    const out = packPointLight(snap);
-    expect(out.byteLength).toBe(32);
+    const out = packDirectLightSlot(snap);
+    expect(out.byteLength).toBe(80);
     expect(out[4]).toBeCloseTo(0.4, 6);
     expect(out[5]).toBeCloseTo(0.5, 6);
     expect(out[6]).toBeCloseTo(0.6, 6);
   });
 
-  it('packSpotLight writes color slots 4..6 + direction slots 8..10 byte-for-byte (80 B)', () => {
+  it('packDirectLightSlot writes Spot color slots 4..6 + direction slots 8..10 byte-for-byte (80 B)', () => {
     const snap: SpotLightSnapshot = {
       kind: 'spot',
       position: vec3.create(0, 5, 0),
@@ -134,9 +135,7 @@ describe('w7 -- light GPU pack byte-neutral (AC-11)', () => {
       farPlane: 50,
       shadowAtlasTile: -1,
     };
-    const out = packSpotLight(snap);
-    // SpotLight carries projector receiver controls and the shadow intensity
-    // tail in the current std430 payload.
+    const out = packDirectLightSlot(snap);
     expect(out.byteLength).toBe(80);
     expect(out[4]).toBeCloseTo(0.3, 6);
     expect(out[5]).toBeCloseTo(0.4, 6);

package/src/__tests__/light-snapshot.test-d.ts

@@ -21,11 +21,18 @@
 // covers any .test-d.ts file in any package).
 
 import { expectTypeOf, test } from 'vitest';
+import type { DirectionalShadowQuality } from '../../../render/src/components/directional-shadow-filter';
+import type { LightValidationError } from '../../../render/src/components/light-helpers';
+import type {
+  DirectLightSlotKind,
+  DirectLightSnapshot,
+} from '../../../render/src/light-buffer-layout';
 import type {
   DirectionalLightSnapshot,
   ExtractedLights,
   LightSnapshot,
   PointLightSnapshot,
+  RectAreaDirectLightSnapshot,
   SpotLightSnapshot,
 } from '../../../render/src/render-system-extract';
 
@@ -44,6 +51,8 @@ function consumeSnapshot(s: LightSnapshot): number {
       return s.invRangeSquared;
     case 'spot':
       return s.cosInner + s.cosOuter;
+    case 'rect-area':
+      return s.halfWidth + s.halfHeight;
     default:
       return assertNever(s);
   }
@@ -51,7 +60,7 @@ function consumeSnapshot(s: LightSnapshot): number {
 
 test('LightSnapshot is a discriminated union on kind', () => {
   expectTypeOf<LightSnapshot>().toEqualTypeOf<
-    DirectionalLightSnapshot | PointLightSnapshot | SpotLightSnapshot
+    DirectionalLightSnapshot | PointLightSnapshot | SpotLightSnapshot | RectAreaDirectLightSnapshot
   >();
   // Smoke that the consumer compiles (run-time noop; compile-time exhaustive).
   void consumeSnapshot;
@@ -81,4 +90,29 @@ test('ExtractedLights three-bucket shape', () => {
   expectTypeOf<ExtractedLights['directionalCount']>().toEqualTypeOf<number>();
   expectTypeOf<ExtractedLights['point']>().toEqualTypeOf<readonly PointLightSnapshot[]>();
   expectTypeOf<ExtractedLights['spot']>().toEqualTypeOf<readonly SpotLightSnapshot[]>();
+  expectTypeOf<ExtractedLights['rect']>().toEqualTypeOf<readonly RectAreaDirectLightSnapshot[]>();
+});
+
+function consumeDirectLight(snapshot: DirectLightSnapshot): number {
+  switch (snapshot.kind) {
+    case 'point':
+      return snapshot.invRangeSquared;
+    case 'spot':
+      return snapshot.cosInner + snapshot.cosOuter;
+    case 'rect-area':
+      return snapshot.halfWidth + snapshot.halfHeight;
+    default:
+      return assertNever(snapshot);
+  }
+}
+
+test('DirectLightSlot kind is closed and includes only finite direct lights', () => {
+  expectTypeOf<DirectLightSlotKind>().toEqualTypeOf<'point' | 'spot' | 'rect-area'>();
+  void consumeDirectLight;
+  expectTypeOf<ExtractedLights['directionalShadowQuality']>().toEqualTypeOf<
+    DirectionalShadowQuality | undefined
+  >();
+  expectTypeOf<ExtractedLights['directionalShadowError']>().toEqualTypeOf<
+    LightValidationError | undefined
+  >();
 });