@forgeax/engine-runtime 0.1.19 → 0.1.21

package/src/__tests__/shadow-csm-component.test.ts

@@ -83,7 +83,11 @@ describe('CSM component schema (w1)', () => {
       error: {
         code?: string;
         hint?: string;
-        detail?: { field?: string; value?: number; min?: number; max?: number };
+        detail?: {
+          field?: string;
+          actual?: number;
+          bound?: { kind?: string; min?: number; max?: number };
+        };
       };
     };
 
@@ -97,7 +101,7 @@ describe('CSM component schema (w1)', () => {
       expect(r.error.code).toBe('shadow-invalid-config');
       expect(r.error.hint).toContain('cascadeCount');
       expect(r.error.detail?.field).toBe('cascadeCount');
-      expect(r.error.detail?.value).toBe(0);
+      expect(r.error.detail?.actual).toBe(0);
     });
 
     it('cascadeCount=5 -> ShadowInvalidConfigError (max=4)', () => {
@@ -110,8 +114,8 @@ describe('CSM component schema (w1)', () => {
       expect(r.error.code).toBe('shadow-invalid-config');
       expect(r.error.hint).toContain('cascadeCount');
       expect(r.error.detail?.field).toBe('cascadeCount');
-      expect(r.error.detail?.value).toBe(5);
-      expect(r.error.detail?.max).toBe(4);
+      expect(r.error.detail?.actual).toBe(5);
+      expect(r.error.detail?.bound).toEqual({ kind: 'range', min: 1, max: 4 });
     });
 
     it('splitLambda=-0.1 -> ShadowInvalidConfigError (min=0)', () => {
@@ -124,7 +128,8 @@ describe('CSM component schema (w1)', () => {
       expect(r.error.code).toBe('shadow-invalid-config');
       expect(r.error.hint).toContain('splitLambda');
       expect(r.error.detail?.field).toBe('splitLambda');
-      expect(r.error.detail?.value).toBeCloseTo(-0.1, 5);
+      expect(r.error.detail?.actual).toBeCloseTo(-0.1, 5);
+      expect(r.error.detail?.bound).toEqual({ kind: 'range', min: 0, max: 1 });
     });
 
     it('splitLambda=1.1 -> ShadowInvalidConfigError (max=1)', () => {
@@ -137,8 +142,8 @@ describe('CSM component schema (w1)', () => {
       expect(r.error.code).toBe('shadow-invalid-config');
       expect(r.error.hint).toContain('splitLambda');
       expect(r.error.detail?.field).toBe('splitLambda');
-      expect(r.error.detail?.value).toBeCloseTo(1.1, 5);
-      expect(r.error.detail?.max).toBe(1);
+      expect(r.error.detail?.actual).toBeCloseTo(1.1, 5);
+      expect(r.error.detail?.bound).toEqual({ kind: 'range', min: 0, max: 1 });
     });
 
     it('cascadeBlend=-0.1 -> ShadowInvalidConfigError (min=0)', () => {
@@ -151,7 +156,8 @@ describe('CSM component schema (w1)', () => {
       expect(r.error.code).toBe('shadow-invalid-config');
       expect(r.error.hint).toContain('cascadeBlend');
       expect(r.error.detail?.field).toBe('cascadeBlend');
-      expect(r.error.detail?.value).toBeCloseTo(-0.1, 5);
+      expect(r.error.detail?.actual).toBeCloseTo(-0.1, 5);
+      expect(r.error.detail?.bound).toEqual({ kind: 'range', min: 0, max: 0.5 });
     });
 
     it('cascadeBlend=0.6 -> ShadowInvalidConfigError (max=0.5)', () => {
@@ -164,8 +170,8 @@ describe('CSM component schema (w1)', () => {
       expect(r.error.code).toBe('shadow-invalid-config');
       expect(r.error.hint).toContain('cascadeBlend');
       expect(r.error.detail?.field).toBe('cascadeBlend');
-      expect(r.error.detail?.value).toBeCloseTo(0.6, 5);
-      expect(r.error.detail?.max).toBeCloseTo(0.5, 5);
+      expect(r.error.detail?.actual).toBeCloseTo(0.6, 5);
+      expect(r.error.detail?.bound).toEqual({ kind: 'range', min: 0, max: 0.5 });
     });
 
     it('all three new fields within valid range spawn succeeds', () => {
@@ -180,29 +186,28 @@ describe('CSM component schema (w1)', () => {
 
   // ── w2: ShadowInvalidConfigDetail.max field constructor tests ──────────
 
-  describe('w2: ShadowInvalidConfigDetail.max constructor', () => {
-    it('cascadeCount=5 detail.max=4 via constructor', () => {
+  describe('w2: ShadowInvalidConfigDetail.bound constructor', () => {
+    it('cascadeCount=5 bound.max=4 via constructor', () => {
       // TDD red: max param not yet on constructor.
       const err = new (ShadowInvalidConfigError as any)('cascadeCount', 5, 1, 4);
       expect(err.code).toBe('shadow-invalid-config');
       expect(err.detail.field).toBe('cascadeCount');
-      expect(err.detail.value).toBe(5);
-      expect(err.detail.min).toBe(1);
-      expect(err.detail.max).toBe(4);
+      expect(err.detail.actual).toBe(5);
+      expect(err.detail.bound).toEqual({ kind: 'range', min: 1, max: 4 });
       expect(err.hint).toContain('[1, 4]');
     });
 
-    it('cascadeBlend=0.6 detail.max=0.5 via constructor', () => {
+    it('cascadeBlend=0.6 bound.max=0.5 via constructor', () => {
       const err = new (ShadowInvalidConfigError as any)('cascadeBlend', 0.6, 0, 0.5);
       expect(err.detail.field).toBe('cascadeBlend');
-      expect(err.detail.max).toBeCloseTo(0.5, 5);
+      expect(err.detail.bound).toEqual({ kind: 'range', min: 0, max: 0.5 });
       expect(err.hint).toContain('[0, 0.5]');
     });
 
-    it('splitLambda=1.1 detail.max=1 via constructor', () => {
+    it('splitLambda=1.1 bound.max=1 via constructor', () => {
       const err = new (ShadowInvalidConfigError as any)('splitLambda', 1.1, 0, 1);
       expect(err.detail.field).toBe('splitLambda');
-      expect(err.detail.max).toBe(1);
+      expect(err.detail.bound).toEqual({ kind: 'range', min: 0, max: 1 });
       expect(err.hint).toContain('[0, 1]');
     });
   });
@@ -260,15 +265,17 @@ describe('CSM component schema (w1)', () => {
         const err = r.error as {
           code?: string;
           hint?: string;
-          detail?: { field?: string; value?: number; min?: number; max?: number };
+          detail?: {
+            field?: string;
+            actual?: number;
+            bound?: { kind?: string; min?: number; max?: number };
+          };
         };
         expect(err.code).toBe('shadow-invalid-config');
         expect(err.hint).toContain('mapSize');
         expect(err.detail?.field).toBe('mapSize');
-        expect(err.detail?.value).toBe(0);
-        expect(err.detail?.min).toBe(1);
-        // mapSize < 1 has no max (lower-bound only), compatible with old callers.
-        expect(err.detail?.max).toBeUndefined();
+        expect(err.detail?.actual).toBe(0);
+        expect(err.detail?.bound).toEqual({ kind: 'lower-bound', operator: '>=', value: 1 });
       }
     });
 

package/src/__tests__/shadow-csm-extract.test.ts

@@ -6,16 +6,22 @@
 // This test asserts the extract stage:
 //   (a) castShadow:true  → CSM path runs (lightViewProj + cascades populated)
 //   (b) castShadow:false → CSM path skipped (no cascade output)
-//   (c) ExtractedLights carries depthBias/normalBias/pcfKernelSize
-//   (d) bias/PCF fields are undefined when castShadow:false
+//   (c) ExtractedLights carries depthBias/normalBias and accepted filter quality
+//   (d) bias/filter fields are undefined when castShadow:false
 // RED before m2-t2/m2-t3: extract still queries the deleted
 // castShadow: true; lightViewProj won't populate.
 
 import { World } from '@forgeax/engine-ecs';
+import { vec3 } from '@forgeax/engine-math';
 import { Camera, DirectionalLight } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
-import { extractFrame, prepareExtractContext } from '../../../render/src/render-system-extract';
+import {
+  type CsmCameraData,
+  computeDirectionalCsm,
+  extractFrame,
+  prepareExtractContext,
+} from '../../../render/src/render-system-extract';
 
 function makeWorld(castShadow?: boolean): World {
   const world = new World();
@@ -26,7 +32,9 @@ function makeWorld(castShadow?: boolean): World {
       castShadow: castShadow ?? true,
       depthBias: 0.01,
       normalBias: 0.08,
-      pcfKernelSize: 5,
+      shadowFilter: 3,
+      shadowAngularRadius: 0.01,
+      maxPenumbraTexels: 48,
     },
   });
   world.spawn(
@@ -56,16 +64,16 @@ describe('ExtractedLights interface (M2 castShadow gate)', () => {
       }
     });
 
-    it('splitPlanes is a Float32Array of length 4', () => {
+    it('splitPlanes is a Float32Array of four vec4 metric lanes', () => {
       const world = makeWorld(true);
       const frame = extractFrame(world, prepareExtractContext(world));
       const { splitPlanes } = frame.lights;
       expect(splitPlanes).toBeDefined();
       if (splitPlanes === undefined) return;
       expect(splitPlanes).toBeInstanceOf(Float32Array);
-      expect(splitPlanes.length).toBe(4);
+      expect(splitPlanes.length).toBe(16);
       for (let i = 0; i < 4; i++) {
-        const v = splitPlanes[i];
+        const v = splitPlanes[i * 4];
         expect(typeof v).toBe('number');
         expect(Number.isFinite(v)).toBe(true);
       }
@@ -95,7 +103,7 @@ describe('ExtractedLights interface (M2 castShadow gate)', () => {
     });
   });
 
-  describe('ExtractedLights carries bias/PCF from merged DirectionalLight', () => {
+  describe('ExtractedLights carries bias and accepted Directional quality', () => {
     it('depthBias populated when castShadow=true', () => {
       const world = makeWorld(true);
       const frame = extractFrame(world, prepareExtractContext(world));
@@ -108,18 +116,46 @@ describe('ExtractedLights interface (M2 castShadow gate)', () => {
       expect(frame.lights.normalBias).toBeCloseTo(0.08, 5);
     });
 
-    it('pcfKernelSize populated when castShadow=true', () => {
+    it('accepted Directional quality is populated when castShadow=true', () => {
       const world = makeWorld(true);
       const frame = extractFrame(world, prepareExtractContext(world));
-      expect(frame.lights.pcfKernelSize).toBe(5);
+      expect(frame.lights.directionalShadowQuality).toEqual({ kind: 'pcf', kernel: 5 });
     });
 
-    it('depthBias, normalBias, pcfKernelSize are undefined when castShadow=false', () => {
+    it('quality is undefined when castShadow=false', () => {
       const world = makeWorld(false);
       const frame = extractFrame(world, prepareExtractContext(world));
       expect(frame.lights.depthBias).toBeUndefined();
       expect(frame.lights.normalBias).toBeUndefined();
-      expect(frame.lights.pcfKernelSize).toBeUndefined();
+      expect(frame.lights.directionalShadowQuality).toBeUndefined();
+    });
+
+    it('withholds an invalid PCSS candidate and exposes a structured error', () => {
+      const world = new World();
+      const spawned = world.spawn({
+        component: DirectionalLight,
+        data: {
+          direction: [0, -1, 0],
+          shadowFilter: 4,
+          shadowAngularRadius: 999,
+          maxPenumbraTexels: 32,
+        },
+      });
+      expect(spawned.ok).toBe(true);
+      world.spawn(
+        { component: Transform, data: {} },
+        { component: Camera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 } },
+      );
+
+      const frame = extractFrame(world, prepareExtractContext(world));
+      expect(frame.lights.directionalShadowError?.code).toBe('shadow-invalid-config');
+      expect(frame.lights.directionalShadowError?.detail).toMatchObject({
+        field: 'shadowAngularRadius',
+        actual: 999,
+      });
+      expect(frame.lights.directionalShadowQuality).toBeUndefined();
+      expect(frame.lights.directionalCsmConfig).toBeUndefined();
+      expect(frame.lights.lightViewProj).toBeUndefined();
     });
   });
 
@@ -174,24 +210,18 @@ describe('ExtractedLights interface (M2 castShadow gate)', () => {
     });
   });
 
-  // feat-20260621-learn-render-5-3-production-shadow-demos M0 / AC-14:
-  // extract reads DirectionalLightShadow.pcfKernelSize into the frame lights
-  // struct (symmetric with cascadeCount/cascadeBlend). Before M0 this field is
-  // dead (research F7): extract never read it, so frame.lights.pcfKernelSize
-  // is undefined regardless of the component value -- these cases are RED
-  // until M0-T-IMPL-EXTRACT lands.
-  describe('pcfKernelSize wiring (M0, AC-14; merged DirectionalLight)', () => {
-    function setupWorldWithPcf(pcfKernelSize: number): World {
+  describe('CSM fit derives world-scale metrics and accepts one quality projection', () => {
+    function setupWorldWithQuality(shadowFilter: number): World {
       const world = new World();
-      // feat-20260621: shadow fields merged onto DirectionalLight (castShadow
-      // defaults true); pcfKernelSize is read from the same component.
       world.spawn({
         component: DirectionalLight,
         data: {
           direction: [0, -1, 0],
           cascadeCount: 1,
           shadowDistance: 100,
-          pcfKernelSize,
+          shadowFilter,
+          shadowAngularRadius: 0.01,
+          maxPenumbraTexels: 32,
         },
       });
       world.spawn(
@@ -201,36 +231,115 @@ describe('ExtractedLights interface (M2 castShadow gate)', () => {
       return world;
     }
 
-    it('reads pcfKernelSize=1 from the merged component', () => {
-      const world = setupWorldWithPcf(1);
-      const frame = extractFrame(world, prepareExtractContext(world));
-      expect(frame.lights.pcfKernelSize).toBe(1);
-    });
-
-    it('reads pcfKernelSize=3 from the merged component', () => {
-      const world = setupWorldWithPcf(3);
+    it('projects PCSS quality from the same Directional query', () => {
+      const world = setupWorldWithQuality(4);
       const frame = extractFrame(world, prepareExtractContext(world));
-      expect(frame.lights.pcfKernelSize).toBe(3);
+      expect(frame.lights.directionalShadowQuality).toEqual({
+        kind: 'pcss',
+        preset: 'medium',
+        angularRadiusRadians: expect.closeTo(0.01, 0.000001),
+        maxPenumbraTexels: 32,
+      });
     });
 
-    it('reads pcfKernelSize=5 from the merged component', () => {
-      const world = setupWorldWithPcf(5);
-      const frame = extractFrame(world, prepareExtractContext(world));
-      expect(frame.lights.pcfKernelSize).toBe(5);
+    it('exposes four finite vec4 cascade metric lanes from the CSM fit', () => {
+      const camera: CsmCameraData = {
+        world: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
+        fov: Math.PI / 4,
+        aspect: 1,
+        near: 0.1,
+        far: 100,
+        projection: 'perspective',
+        orthoLeft: -1,
+        orthoRight: 1,
+        orthoBottom: -1,
+        orthoTop: 1,
+      };
+      for (const cascadeCount of [1, 2, 3, 4]) {
+        const result = computeDirectionalCsm(
+          vec3.create(0, -1, 0),
+          {
+            cascadeCount,
+            splitLambda: 0.75,
+            cascadeBlend: 0.2,
+            mapSize: 1024,
+            shadowDistance: 100,
+            shadowFilter: 3,
+            shadowAngularRadius: 0.01,
+            maxPenumbraTexels: 32,
+          },
+          camera,
+        );
+        expect(result).not.toBeNull();
+        const lanes = result?.splitPlanes ?? new Float32Array();
+        expect(lanes).toHaveLength(16);
+        for (let index = 0; index < cascadeCount; index += 1) {
+          expect(Number.isFinite(lanes[index * 4 + 1])).toBe(true);
+          expect(lanes[index * 4 + 1]).toBeGreaterThan(0);
+          expect(Number.isFinite(lanes[index * 4 + 2])).toBe(true);
+          expect(lanes[index * 4 + 2]).toBeGreaterThan(0);
+        }
+      }
     });
 
-    it('defaults pcfKernelSize to 3 when the component omits it', () => {
-      const world = new World();
-      world.spawn({
-        component: DirectionalLight,
-        data: { direction: [0, -1, 0], cascadeCount: 1 },
-      });
-      world.spawn(
-        { component: Transform, data: {} },
-        { component: Camera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 } },
+    it('recomputes worldUnitsPerTexel when mapSize changes and rejects non-finite config', () => {
+      const camera: CsmCameraData = {
+        world: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
+        fov: Math.PI / 4,
+        aspect: 1,
+        near: 0.1,
+        far: 100,
+        projection: 'perspective',
+        orthoLeft: -1,
+        orthoRight: 1,
+        orthoBottom: -1,
+        orthoTop: 1,
+      };
+      const coarse = computeDirectionalCsm(
+        vec3.create(0, -1, 0),
+        {
+          cascadeCount: 1,
+          splitLambda: 0.75,
+          cascadeBlend: 0.2,
+          mapSize: 512,
+          shadowDistance: 100,
+          shadowFilter: 3,
+          shadowAngularRadius: 0.01,
+          maxPenumbraTexels: 32,
+        },
+        camera,
       );
-      const frame = extractFrame(world, prepareExtractContext(world));
-      expect(frame.lights.pcfKernelSize).toBe(3);
+      const fine = computeDirectionalCsm(
+        vec3.create(0, -1, 0),
+        {
+          cascadeCount: 1,
+          splitLambda: 0.75,
+          cascadeBlend: 0.2,
+          mapSize: 2048,
+          shadowDistance: 100,
+          shadowFilter: 3,
+          shadowAngularRadius: 0.01,
+          maxPenumbraTexels: 32,
+        },
+        camera,
+      );
+      expect(fine?.splitPlanes[1]).toBeCloseTo((coarse?.splitPlanes[1] ?? 0) / 4, 4);
+      expect(
+        computeDirectionalCsm(
+          vec3.create(0, -1, 0),
+          {
+            cascadeCount: 1,
+            splitLambda: 0.75,
+            cascadeBlend: 0.2,
+            mapSize: Number.NaN,
+            shadowDistance: 100,
+            shadowFilter: 3,
+            shadowAngularRadius: 0.01,
+            maxPenumbraTexels: 32,
+          },
+          camera,
+        ),
+      ).toBeNull();
     });
   });
 });

package/src/__tests__/shadow-csm-runtime-vary.dawn.test.ts

@@ -20,6 +20,8 @@ import { World } from '@forgeax/engine-ecs';
 import { Camera, DirectionalLight } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
+import { projectDirectionalShadowInspection } from '../../../render/src/assembly/directional-shadow-inspection';
+import { resolveDirectionalShadowBackendAdmission } from '../../../render/src/render-pipeline';
 import { constructRuntimeRendererHost } from '../renderer-host';
 import { drawPublished } from './draw-published';
 
@@ -34,6 +36,51 @@ const ENGINE_MANIFEST_URL = `data:application/json,${encodeURIComponent(
 // biome-ignore lint/suspicious/noExplicitAny: dawn-node detection guard
 const dawnReady = typeof navigator !== 'undefined' && (navigator as any).gpu !== undefined;
 
+describe('M3 RhiNull structural admission', () => {
+  it('requires the structural-only RhiNull projection and explicit no-pixel claim', async () => {
+    const module = (await import('../../../render/src/render-pipeline')) as Record<string, unknown>;
+    const resolver = module.resolveDirectionalShadowBackendAdmission;
+    expect(typeof resolver).toBe('function');
+    const result = (
+      resolver as (input: {
+        backendKind: 'null';
+        requested: 'pcssMedium' | 'pcssHigh';
+        candidate: 'accepted' | 'failed';
+      }) => { effective: string; fallbackReason?: string; pixelEvidence: string }
+    )({ backendKind: 'null', requested: 'pcssMedium', candidate: 'accepted' });
+    expect(result).toMatchObject({
+      effective: 'rhi-null-structural',
+      fallbackReason: 'rhi-null-structural',
+      pixelEvidence: 'not-available',
+    });
+  });
+
+  it('keeps RhiNull recovery structural and generation-scoped', () => {
+    const inspection = projectDirectionalShadowInspection({
+      admission: resolveDirectionalShadowBackendAdmission({
+        backendKind: 'null',
+        requested: 'pcssMedium',
+        candidate: 'accepted',
+      }),
+      cascadeCount: 4,
+      mapSize: 1024,
+      atlasBytes: 16_777_216,
+      writerPasses: 4,
+      blockerTaps: 0,
+      filterTapUpperBound: 0,
+      seamTapUpperBound: 0,
+      deviceGeneration: 4,
+      graphGeneration: 9,
+    });
+    expect(inspection).toMatchObject({
+      effective: 'rhi-null-structural',
+      pixelEvidence: 'not-available',
+      deviceGeneration: 4,
+      graphGeneration: 9,
+    });
+  });
+});
+
 const WIDTH = 320;
 const HEIGHT = 240;
 
@@ -200,4 +247,29 @@ describe('CSM runtime cascade + mapSize variation (M5/w26)', () => {
     const { world } = buildScene(1, 1024);
     expect(drawPublished(renderer, world).ok).toBe(true);
   });
+
+  it('castShadow true -> false -> true toggles the directional graph without device error', async () => {
+    if (!dawnReady) return;
+    const canvas = createMockCanvas();
+    const host = await constructRuntimeRendererHost(
+      canvas as unknown as HTMLCanvasElement,
+      {},
+      { shaderManifestUrl: ENGINE_MANIFEST_URL },
+    );
+    expect(host.ok).toBe(true);
+    if (!host.ok) throw host.error;
+    const { renderer } = host.value;
+    const { world, shadowEntity } = buildScene(4, 1024);
+
+    expect(drawPublished(renderer, world).ok).toBe(true);
+    world.set(shadowEntity, DirectionalLight, { castShadow: false });
+    expect(drawPublished(renderer, world).ok).toBe(true);
+    world.set(shadowEntity, DirectionalLight, {
+      castShadow: true,
+      mapSize: 1024,
+      shadowDistance: 50,
+      cascadeCount: 4,
+    });
+    expect(drawPublished(renderer, world).ok).toBe(true);
+  });
 });

package/src/__tests__/shadow-csm-shader.dawn.test.ts

@@ -20,8 +20,15 @@
 // regression in the kernel logic itself. The kernel is the executable AC-06
 // spec; w18 implementation must derive identical behavior.
 
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import { describe, expect, it } from 'vitest';
 
+const directionalShader = readFileSync(
+  fileURLToPath(new URL('../../../shader/src/lighting-directional.wgsl', import.meta.url)),
+  'utf8',
+);
+
 // biome-ignore lint/suspicious/noExplicitAny: dawn-node detection guard
 const dawnReady = typeof navigator !== 'undefined' && (navigator as any).gpu !== undefined;
 
@@ -228,6 +235,18 @@ describe('CSM shader cascade selection + atlas UV + blend (M5/w17)', () => {
     expect(dawnReady).toBe(true);
   });
 
+  it('production Directional PCSS uses raw depth and comparison without new bindings', () => {
+    expect(directionalShader).toContain('fn _samplePcssForCascade');
+    expect(directionalShader).toContain('shadow_load_raw_depth');
+    expect(directionalShader).toContain('shadow_sample_compare');
+    expect(directionalShader).toContain('PCSS_MEDIUM_RAW_TAPS : u32 = 8u');
+    expect(directionalShader).toContain('PCSS_MEDIUM_COMPARE_TAPS : u32 = 16u');
+    expect(directionalShader).toContain('PCSS_HIGH_RAW_TAPS : u32 = 16u');
+    expect(directionalShader).toContain('PCSS_HIGH_COMPARE_TAPS : u32 = 32u');
+    expect(directionalShader).not.toMatch(/@binding\(/);
+    expect(directionalShader).not.toMatch(/frameIndex|frame_index|taaJitter|taa_jitter|jitter/);
+  });
+
   describe('cascade selection by viewZ (AC-03 / AC-06)', () => {
     it('viewZ < splits[0] -> layer 0', async () => {
       const r = await runKernel({