@forgeax/engine-runtime 0.1.4 → 0.1.7

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

@@ -12,16 +12,15 @@
 // mapSize 2048 -> 1024 -> 2048 the same way. Asserts every draw returns
 // `ok: true` and no device-lost / structured RhiError fires.
 //
-// best-effort: we do not pixel-readback (M3 atlas slot debugReadback was
-// retuned in w28 transitional); the gate is "render loop completes
-// without device error".
+// This is a structural GPU behavior gate: the unified Standard shadow graph
+// must rebuild its atlas and continue drawing without device errors.
 
 import type { EntityHandle } from '@forgeax/engine-ecs';
 import { World } from '@forgeax/engine-ecs';
-import { Camera, DirectionalLight } from '@forgeax/engine-render/internal';
+import { Camera, DirectionalLight } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
-import { createRenderer } from '../createRenderer';
+import { constructRuntimeRendererHost } from '../renderer-host';
 import { drawPublished } from './draw-published';
 
 const ENGINE_MANIFEST = await (async () => {
@@ -127,13 +126,15 @@ describe('CSM runtime cascade + mapSize variation (M5/w26)', () => {
   it('cascadeCount 4 -> 2 -> 4 round-trip without device error', async () => {
     if (!dawnReady) return;
     const canvas = createMockCanvas();
-    const renderer = await createRenderer(
+    const host = await constructRuntimeRendererHost(
       canvas as unknown as HTMLCanvasElement,
       {},
       { shaderManifestUrl: ENGINE_MANIFEST_URL },
     );
-    const ready = await renderer.ready;
-    expect(ready.ok).toBe(true);
+    expect(host.ok).toBe(true);
+    if (!host.ok) throw host.error;
+    const { renderer } = host.value;
+    expect(renderer.inspect().state).toBe('alive');
     const { world, shadowEntity } = buildScene(4, 2048);
 
     expect(drawPublished(renderer, world).ok).toBe(true);
@@ -156,13 +157,15 @@ describe('CSM runtime cascade + mapSize variation (M5/w26)', () => {
   it('mapSize 2048 -> 1024 -> 2048 RT rebuild without device error', async () => {
     if (!dawnReady) return;
     const canvas = createMockCanvas();
-    const renderer = await createRenderer(
+    const host = await constructRuntimeRendererHost(
       canvas as unknown as HTMLCanvasElement,
       {},
       { shaderManifestUrl: ENGINE_MANIFEST_URL },
     );
-    const ready = await renderer.ready;
-    expect(ready.ok).toBe(true);
+    expect(host.ok).toBe(true);
+    if (!host.ok) throw host.error;
+    const { renderer } = host.value;
+    expect(renderer.inspect().state).toBe('alive');
     const { world, shadowEntity } = buildScene(4, 2048);
 
     expect(drawPublished(renderer, world).ok).toBe(true);
@@ -185,13 +188,15 @@ describe('CSM runtime cascade + mapSize variation (M5/w26)', () => {
   it('cascadeCount=1 renders through the unified pathway (AC-10)', async () => {
     if (!dawnReady) return;
     const canvas = createMockCanvas();
-    const renderer = await createRenderer(
+    const host = await constructRuntimeRendererHost(
       canvas as unknown as HTMLCanvasElement,
       {},
       { shaderManifestUrl: ENGINE_MANIFEST_URL },
     );
-    const ready = await renderer.ready;
-    expect(ready.ok).toBe(true);
+    expect(host.ok).toBe(true);
+    if (!host.ok) throw host.error;
+    const { renderer } = host.value;
+    expect(renderer.inspect().state).toBe('alive');
     const { world } = buildScene(1, 1024);
     expect(drawPublished(renderer, world).ok).toBe(true);
   });

package/src/__tests__/shadow-csm-tile-consistency.test.ts

@@ -26,10 +26,8 @@ import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import type { World as WorldType } from '@forgeax/engine-ecs';
 import type { Renderer as RendererType } from '@forgeax/engine-render';
-import { directionalCascadeRasterViewport } from '@forgeax/engine-render/internal';
 import type { Handle } from '@forgeax/engine-types';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { TEST_CUBE_HANDLE, withPrimitiveMeshes } from './helpers/primitive-world';
 
 const ENGINE = '../createRenderer';
 
@@ -196,17 +194,29 @@ async function importEngine(): Promise<{
     opts?: unknown,
     bundler?: unknown,
   ) => Promise<{
-    ready: Promise<void>;
+    subscribe: (listener: (event: unknown) => void) => () => void;
     draw: (worlds: unknown, opts: { cameraOwner: number; resourceOwner: number }) => void;
-    onError: (cb: (err: { code: string }) => void) => () => void;
   }>;
 }> {
-  return (await import(ENGINE)) as never;
+  const engine = (await import(ENGINE)) as {
+    createRenderer: (...args: readonly unknown[]) => Promise<unknown>;
+  };
+  return {
+    createRenderer: async (...args: readonly unknown[]) => {
+      const result = (await engine.createRenderer(...args)) as
+        | { readonly ok: true; readonly value: unknown }
+        | { readonly ok: false; readonly error: unknown };
+      if (!result.ok) throw result.error;
+      return result.value as {
+        subscribe: (listener: (event: unknown) => void) => () => void;
+        draw: (worlds: unknown, opts: { cameraOwner: number; resourceOwner: number }) => void;
+      };
+    },
+  };
 }
 
 async function importEcs(): Promise<{ World: new () => unknown }> {
-  const { World: BaseWorld } = await import('@forgeax/engine-ecs');
-  return { World: withPrimitiveMeshes(BaseWorld) } as never;
+  return (await import('@forgeax/engine-ecs')) as never;
 }
 
 async function importComponents(): Promise<{
@@ -218,9 +228,9 @@ async function importComponents(): Promise<{
   HANDLE_CUBE: Handle<'MeshAsset', 'shared'>;
 }> {
   return {
-    ...(await import('@forgeax/engine-render/internal')),
+    ...(await import('@forgeax/engine-render')),
     ...(await import('@forgeax/engine-scene')),
-    HANDLE_CUBE: TEST_CUBE_HANDLE,
+    ...(await import('@forgeax/engine-assets-runtime')),
   } as never;
 }
 
@@ -238,7 +248,6 @@ async function captureCascadeViewports(cascadeCount: number, mapSize: number): P
     {},
     { shaderManifestUrl: buildManifestDataUrl() },
   );
-  await renderer.ready;
   const { World } = await importEcs();
   const C = await importComponents();
   const world = new (World as new () => { spawn: (...componentDatas: unknown[]) => unknown })();
@@ -274,8 +283,8 @@ async function captureCascadeViewports(cascadeCount: number, mapSize: number): P
     { component: C.MeshRenderer, data: {} },
     { component: C.Transform, data: identityTransform() },
   );
-  renderer.onError(() => undefined);
-  if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
+  renderer.subscribe(() => undefined);
+  if (!(renderer as unknown as RendererType).attach(world as WorldType).ok) {
     throw new Error('World attachment failed');
   }
   (world as WorldType).update().unwrap();
@@ -291,13 +300,13 @@ function canonicalTile(layer: number, count: number): { col: number; row: number
 }
 
 // Read the WGSL the GPU actually compiles and evaluate its _atlasTileGrid
-// branch-free columns rule (select(2u, 1u, count<=1u)) so the sampler-side
-// mapping is pinned to the real shader source, not a hand-copy.
+// column rule (select(2u, 1u, count<=1u)) so the sampler-side mapping is pinned
+// to the real shader source, not a hand-copy.
 const LIGHTING_WGSL = fileURLToPath(
   new URL('../../../shader/src/lighting-directional.wgsl', import.meta.url),
 );
 
-function wgslAtlasGrid(count: number): { columns: number; rows: number } {
+function wgslAtlasTilesPerSide(count: number): number {
   const src = readFileSync(LIGHTING_WGSL, 'utf8');
   // The shader rule lives in _atlasTileGrid: columns = select(2u,1u,count<=1u).
   // We assert that exact expression is present, then evaluate it here.
@@ -307,13 +316,12 @@ function wgslAtlasGrid(count: number): { columns: number; rows: number } {
       'lighting-directional.wgsl _atlasTileGrid columns rule changed; update AC-04 test',
     );
   }
-  const columns = count <= 1 ? 1 : 2;
-  return { columns, rows: Math.ceil(count / columns) };
+  return count <= 1 ? 1 : 2;
 }
 
 function wgslAtlasTile(layer: number, count: number): { col: number; row: number } {
-  const { columns } = wgslAtlasGrid(count);
-  return { col: layer % columns, row: Math.floor(layer / columns) };
+  const tilesPerSide = wgslAtlasTilesPerSide(count);
+  return { col: layer % tilesPerSide, row: Math.floor(layer / tilesPerSide) };
 }
 
 describe('CSM cascade tile / matrix / viewport three-way agreement (AC-04, AC-06)', () => {
@@ -355,18 +363,16 @@ describe('CSM cascade tile / matrix / viewport three-way agreement (AC-04, AC-06
 
         // (3) matrix slot: layer index maps 1:1 to lightViewProj_A..D, so the
         // slot index IS the layer. The depth pass uses cascadeIndex=layer to
-        // pick the same matrix (urp-pipeline addShadowPass cascadeIndex: i).
+        // pick the same matrix used by the typed shadow cascade at index i.
         const matrixSlot = layer;
-        const producerViewport = directionalCascadeRasterViewport(layer, count, mapSize);
 
         // Three-way: all point at the same tile, and the matrix slot is the
         // layer that produced it.
         expect(depthTile).toEqual(samplerTile);
         expect(depthTile).toEqual(canonicalTile(layer, count));
-        expect(vp).toEqual(producerViewport);
         expect(matrixSlot).toBe(layer);
       }
-    });
+    }, 30_000);
   }
 
   it('AC-06: count=1 collapses to tile (0,0), matrix slot 0, viewport (0,0)', async () => {
@@ -377,7 +383,7 @@ describe('CSM cascade tile / matrix / viewport three-way agreement (AC-04, AC-06
     expect(vp).toEqual({ x: 0, y: 0, w: mapSize, h: mapSize });
     expect(wgslAtlasTile(0, 1)).toEqual({ col: 0, row: 0 });
     expect(canonicalTile(0, 1)).toEqual({ col: 0, row: 0 });
-  });
+  }, 30_000);
 });
 
 // AC-07 (9-tap PCF offset coordinate-system self-consistency).
@@ -412,8 +418,8 @@ describe('AC-07: PCF offset coordinate-system self-consistency (static source ch
     // of kernels {1,3,5} in-tile).
     expect(src).toMatch(/let\s+tileLo\s*=\s*tileOrigin\s*\+\s*texel/);
     expect(src).toMatch(/let\s+tileHi\s*=\s*tileOrigin\s*\+\s*tileScale\s*-\s*texel/);
-    // count=1 => grid=1x1 => tileScale=1, tileOrigin=(0,0) => uv === tileUv, so
+    // count=1 => columns=1 => tileScale=(1,1), tileOrigin=(0,0) => uv === tileUv, so
     // the OOB guard space and sample space coincide regardless of the clamp.
-    expect(wgslAtlasGrid(1)).toEqual({ columns: 1, rows: 1 });
+    expect(wgslAtlasTilesPerSide(1)).toBe(1);
   });
 });

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

@@ -5,20 +5,22 @@
 // back. Validates lightViewProj[4] + splitPlanes[4] + cascadeCount/cascadeBlend
 // survive the queue.writeBuffer round-trip without corruption.
 //
-// Layout matches shadow-csm-ubo.test.ts — 240 f32 / 960 B std140 after
+// Layout matches shadow-csm-ubo.test.ts — 196 f32 / 784 B std140 after
 // feat-20260625 w25 folded the spot lightViewProj array into the View UBO tail.
 // The directional cascade offsets [0..125] this test exercises are unchanged;
 // the extra tail (floats 132..195) stays zero in this round-trip.
 //
-// The payload includes the appended Fog lanes after the temporal projection
-// facts; the round-trip keeps those values in the existing View uniform slot.
+// Red phase: common.wgsl still has lightSpaceMatrix (not lightViewProj array);
+// record.ts still writes single lightSpaceMatrix. This test writes the NEW
+// layout directly and reads back independently — it will be red until w16/w25
+// land.
 
 import { describe, expect, it } from 'vitest';
 
 // ── Constants (mirrors current View UBO layout) ─────────────────────────────
 
-const VIEW_UBO_FLOAT_COUNT = 240;
-const VIEW_UBO_BYTES = 960;
+const VIEW_UBO_FLOAT_COUNT = 196;
+const VIEW_UBO_BYTES = 784;
 
 // f32 indices matching std140 byte offsets.
 const OFF = {
@@ -33,10 +35,6 @@ const OFF = {
   SP3: 120, // splitPlanes[3] — byte 480
   CC: 124, // cascadeCount — byte 496
   CB: 125, // cascadeBlend — byte 500
-  FOG_COLOR: 232, // fog.color.xyz — byte 928
-  FOG_DENSITY: 235, // fog.density — byte 940
-  FOG_HEIGHT_FALLOFF: 236, // fog.heightFalloff — byte 944
-  FOG_MAX_OPACITY: 237, // fog.maxOpacity — byte 948
 } as const;
 
 const GPUMapMode: { readonly READ: number } = ((): { readonly READ: number } => {
@@ -68,17 +66,8 @@ const UNIFORM = 0x0040; // GPUBufferUsage.UNIFORM
 // biome-ignore lint/suspicious/noExplicitAny: dawn-node detection guard
 const dawnReady = typeof navigator !== 'undefined' && (navigator as any).gpu !== undefined;
 
-const commonViewSource = await (async () => {
-  const { readFile } = await import('node:fs/promises');
-  const { fileURLToPath } = await import('node:url');
-  return readFile(
-    fileURLToPath(new URL('../../../shader/src/common.wgsl', import.meta.url)),
-    'utf8',
-  );
-})();
-
 /**
- * Build a 240-float View UBO payload with known test values.
+ * Build a 196-float View UBO payload with known test values.
  * All 4 lightViewProj matrices are identity; splitPlanes use
  * monotonic values; cascadeCount=4, cascadeBlend=0.2.
  */
@@ -119,14 +108,6 @@ function buildTestPayload(cascadeCount: number, cascadeBlend: number): Float32Ar
   f32[OFF.CC] = cascadeCount;
   f32[OFF.CB] = cascadeBlend;
 
-  // Fog payload occupies the tail of the same View uniform slot.
-  f32[OFF.FOG_COLOR] = 0.2;
-  f32[OFF.FOG_COLOR + 1] = 0.4;
-  f32[OFF.FOG_COLOR + 2] = 0.8;
-  f32[OFF.FOG_DENSITY] = 0.035;
-  f32[OFF.FOG_HEIGHT_FALLOFF] = 0.28;
-  f32[OFF.FOG_MAX_OPACITY] = 0.92;
-
   return f32;
 }
 
@@ -194,14 +175,6 @@ describe('View UBO CSM round-trip (w15)', () => {
       // Verify lightViewProj[3] diagonal element.
       expect(readback[OFF.LVP3 + 10]).toBeCloseTo(0.4, 5);
 
-      // Verify Fog remains in the same View slot after the CSM tail.
-      expect(readback[OFF.FOG_COLOR]).toBeCloseTo(0.2, 5);
-      expect(readback[OFF.FOG_COLOR + 1]).toBeCloseTo(0.4, 5);
-      expect(readback[OFF.FOG_COLOR + 2]).toBeCloseTo(0.8, 5);
-      expect(readback[OFF.FOG_DENSITY]).toBeCloseTo(0.035, 5);
-      expect(readback[OFF.FOG_HEIGHT_FALLOFF]).toBeCloseTo(0.28, 5);
-      expect(readback[OFF.FOG_MAX_OPACITY]).toBeCloseTo(0.92, 5);
-
       staging.unmap();
       staging.destroy();
       stagingUpload.destroy();
@@ -277,17 +250,3 @@ describe('View UBO CSM round-trip (w15)', () => {
     });
   });
 });
-
-describe('Fog View ABI Dawn transport shape (M2)', () => {
-  it('uses the expanded View slot for the Fog payload', () => {
-    expect(VIEW_UBO_FLOAT_COUNT).toBe(240);
-    expect(VIEW_UBO_BYTES).toBe(960);
-    expect(VIEW_UBO_BYTES).toBeLessThanOrEqual(1024);
-  });
-
-  it('keeps Fog as a field of the existing View uniform binding', () => {
-    expect(commonViewSource).toContain('fog                 : FogViewParams');
-    expect(commonViewSource).toContain('@group(0) @binding(0) var<uniform> view : View;');
-    expect(commonViewSource).not.toContain('@group(0) @binding(10)');
-  });
-});

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

@@ -260,15 +260,13 @@ describe('pcfKernelSize tail-pad slot wiring (M0, AC-14)', () => {
     );
   });
 
-  it('record appends two temporal view-projection matrices after the folded spot matrices', () => {
+  it('record carries the folded spot matrices in the complete View UBO payload (w25)', () => {
     // feat-20260625 w25: the per-spot fragment-read lightViewProj matrices fold
-    // into the View UBO tail, so VIEW_PAYLOAD_FLOATS now includes temporal
-    // projection and Fog lanes after the folded matrices.
+    // into the View UBO tail. The current View struct also carries temporal and
+    // fog fields, so the complete payload is 240 floats.
     expect(recordSrc).toMatch(/VIEW_PAYLOAD_FLOATS\s*=\s*240/);
     // The spot matrix array is written at base float 132.
     expect(recordSrc).toMatch(/SPOT_LVP_BASE_FLOAT\s*=\s*132/);
-    expect(recordSrc).toContain('viewPayload[196 + index]');
-    expect(recordSrc).toContain('viewPayload[212 + index]');
   });
 
   it('common.wgsl View struct declares depthBias/normalBias/pcfKernelSize after cascadeBlend', () => {
@@ -278,23 +276,3 @@ describe('pcfKernelSize tail-pad slot wiring (M0, AC-14)', () => {
     expect(m).not.toBeNull();
   });
 });
-
-describe('Fog View ABI host shape (M2)', () => {
-  const recordSrc = readFileSync(
-    fileURLToPath(new URL('../../../render/src/record/view-ubo.ts', import.meta.url)),
-    'utf8',
-  );
-
-  it('uses the current host payload shape rather than the stale 784 B prefix', () => {
-    expect(recordSrc).toMatch(/VIEW_UNIFORM_BYTES\s*=\s*960/);
-    expect(recordSrc).toMatch(/VIEW_PAYLOAD_FLOATS\s*=\s*240/);
-    expect(recordSrc).not.toContain('VIEW_UNIFORM_BYTES = 928');
-  });
-
-  it('packs all four Fog parameters in the View write path', () => {
-    expect(recordSrc).toContain('fog.color');
-    expect(recordSrc).toContain('fog.density');
-    expect(recordSrc).toContain('fog.heightFalloff');
-    expect(recordSrc).toContain('fog.maxOpacity');
-  });
-});

package/src/__tests__/shadow-csm-viewport.browser.test.ts

@@ -7,7 +7,7 @@
 // setViewport against atlas-sized target), so this browser test covers the
 // real GPU path.
 //
-// AC-05: atlas tile viewports; D-5: cascadeCount=4 → 4 addShadowPass calls;
+// AC-05: atlas tile viewports; D-5: cascadeCount=4 -> 4 typed shadow passes;
 // D-6: pass names shadowCascade0..3.
 
 import { describe, expect, it } from 'vitest';

package/src/__tests__/shadow-fields-observable.dawn.test.ts

@@ -8,24 +8,25 @@
 // ShadowCaster pass (nothing written into shadow depth atlas), (b) floor
 // position outside camera frustum. Both fixed in the harness below.
 //
-// Each pixel A/B pair gets its own `it()` with a fresh createRenderer call --
+// Each pixel A/B pair gets its own `it()` with a fresh runtime host --
 // shadow-atlas state and device-lost crashes from prior A/B rounds cannot
 // contaminate the current comparison.
 
+import { HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
+import type { Renderer } from '@forgeax/engine-render';
 import {
   Camera,
   DirectionalLight,
   Instances,
   MeshFilter,
   MeshRenderer,
-  validateDirectionalLightData,
-} from '@forgeax/engine-render/internal';
-import { createRenderer } from '@forgeax/engine-runtime';
+} from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import type { MaterialAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
+import { validateDirectionalLightData } from '../../../render/src/components/light-helpers';
+import { constructRuntimeRendererHost } from '../renderer-host';
 import { drawPublished } from './draw-published';
 
 const WIDTH = 256;
@@ -128,7 +129,6 @@ function spawnScene(
 ) {
   const cm = casterMat(world);
   const fm = floorMat(world);
-  const cubeHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
   world.spawn(
     {
       component: Transform,
@@ -138,7 +138,7 @@ function spawnScene(
         scale: [8, 0.1, 8],
       },
     },
-    { component: MeshFilter, data: { assetHandle: cubeHandle } },
+    { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
     { component: MeshRenderer, data: { materials: [fm] } },
   );
   world.spawn(
@@ -184,7 +184,7 @@ function spawnScene(
         scale: [0.5, 0.5, 0.5],
       },
     },
-    { component: MeshFilter, data: { assetHandle: cubeHandle } },
+    { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
     { component: MeshRenderer, data: { materials: [cm] } },
     { component: Instances, data: { transforms: buildTranslationGrid() } },
   );
@@ -272,16 +272,23 @@ async function renderConfig(
     removeEventListener() {},
   } as unknown as HTMLCanvasElement;
 
-  let renderer: Awaited<ReturnType<typeof createRenderer>> | undefined;
+  let renderer: Renderer | undefined;
   try {
     try {
-      renderer = await createRenderer(mc, {}, { shaderManifestUrl: ENGINE_MANIFEST_URL });
+      const host = await constructRuntimeRendererHost(
+        mc,
+        {},
+        {
+          shaderManifestUrl: ENGINE_MANIFEST_URL,
+        },
+      );
+      if (!host.ok) throw host.error;
+      renderer = host.value.renderer;
     } finally {
       globalThis.navigator.gpu.requestAdapter = _s;
     }
     if (renderer === undefined) throw new Error('renderer not initialized');
-    const ready = await renderer.ready;
-    if (!ready.ok) throw ready.error;
+    if (renderer.inspect().state !== 'alive') throw new Error('renderer not alive');
     if (sd === undefined) throw new Error('device not initialized');
     const dev = sd;
 
@@ -386,16 +393,23 @@ async function renderConfigWithSpy(
     removeEventListener() {},
   } as unknown as HTMLCanvasElement;
 
-  let renderer: Awaited<ReturnType<typeof createRenderer>> | undefined;
+  let renderer: Renderer | undefined;
   try {
     try {
-      renderer = await createRenderer(mc, {}, { shaderManifestUrl: ENGINE_MANIFEST_URL });
+      const host = await constructRuntimeRendererHost(
+        mc,
+        {},
+        {
+          shaderManifestUrl: ENGINE_MANIFEST_URL,
+        },
+      );
+      if (!host.ok) throw host.error;
+      renderer = host.value.renderer;
     } finally {
       globalThis.navigator.gpu.requestAdapter = _s;
     }
     if (renderer === undefined) throw new Error('renderer not initialized');
-    const ready = await renderer.ready;
-    if (!ready.ok) throw ready.error;
+    if (renderer.inspect().state !== 'alive') throw new Error('renderer not alive');
     if (sd === undefined) throw new Error('device not initialized');
     const dev = sd;
 
@@ -452,46 +466,43 @@ describe('M6 shadow fields observability', () => {
 
   // --- Gate D: validate() rejections ---
   it('validate() accepts pcfKernelSize=9 (odd), rejects 2 (even) and 0', () => {
-    const v = (d: Record<string, number | boolean | readonly number[]>) => {
-      const result = validateDirectionalLightData(d);
-      return result.ok ? null : result.error;
-    };
-    expect(
-      v?.({
-        direction: [0, -1, 0],
-        castShadow: true,
-        cascadeCount: 4,
-        splitLambda: 0.75,
-        cascadeBlend: 0.2,
-        mapSize: 2048,
-        shadowDistance: 50,
-        pcfKernelSize: 9,
-      }),
-    ).toBeNull();
-    expect(
-      v?.({
-        direction: [0, -1, 0],
-        castShadow: true,
-        cascadeCount: 4,
-        splitLambda: 0.75,
-        cascadeBlend: 0.2,
-        mapSize: 2048,
-        shadowDistance: 50,
-        pcfKernelSize: 2,
-      })?.code,
-    ).toBe('shadow-invalid-config');
-    expect(
-      v?.({
-        direction: [0, -1, 0],
-        castShadow: true,
-        cascadeCount: 4,
-        splitLambda: 0.75,
-        cascadeBlend: 0.2,
-        mapSize: 2048,
-        shadowDistance: 50,
-        pcfKernelSize: 0,
-      })?.code,
-    ).toBe('shadow-invalid-config');
+    const valid = validateDirectionalLightData({
+      direction: [0, -1, 0],
+      castShadow: true,
+      cascadeCount: 4,
+      splitLambda: 0.75,
+      cascadeBlend: 0.2,
+      mapSize: 2048,
+      shadowDistance: 50,
+      pcfKernelSize: 9,
+    });
+    expect(valid.ok).toBe(true);
+
+    const even = validateDirectionalLightData({
+      direction: [0, -1, 0],
+      castShadow: true,
+      cascadeCount: 4,
+      splitLambda: 0.75,
+      cascadeBlend: 0.2,
+      mapSize: 2048,
+      shadowDistance: 50,
+      pcfKernelSize: 2,
+    });
+    expect(even.ok).toBe(false);
+    if (!even.ok) expect(even.error.code).toBe('shadow-invalid-config');
+
+    const zero = validateDirectionalLightData({
+      direction: [0, -1, 0],
+      castShadow: true,
+      cascadeCount: 4,
+      splitLambda: 0.75,
+      cascadeBlend: 0.2,
+      mapSize: 2048,
+      shadowDistance: 50,
+      pcfKernelSize: 0,
+    });
+    expect(zero.ok).toBe(false);
+    if (!zero.ok) expect(zero.error.code).toBe('shadow-invalid-config');
   });
 
   // --- Gate C: pixel A/B — castShadow ON vs OFF (control) ---

package/src/__tests__/shadow-m1.dawn.test.ts

@@ -86,19 +86,18 @@ describe('shadow M1a dawn (w2 RED)', () => {
       // lightSpaceMatrix is a 16-element f32 array, col-major mat4.
       // With non-degenerate direction, element-wise epsilon <= 1e-5.
       expect(refMat.length).toBe(16);
-      // AC-11 lightSpaceMatrix shape verified: the host-side reference
-      // computation produces a 16-element mat4. Real GPU verification
-      // of the matrix contents is covered by shadow-m2.dawn.test.ts
-      // (AC-10/11 canonical coverage via debugReadback + debugSampleShadowFactor).
+      // AC-11 lightSpaceMatrix shape is verified by the host-side reference
+      // computation; the real GPU shadow graph is covered by the current
+      // Standard Dawn shadow suites.
     });
   });
 
-  // ── AC-10: debugReadback shape ────────────────────────────────────────
-  describe('AC-10 debugReadback shape', () => {
-    it('debugReadback returns { center, corners: {tl,tr,bl,br}, mapSize } POD', () => {
+  // ── AC-10: shadow fixture shape ───────────────────────────────────────
+  describe('AC-10 shadow fixture shape', () => {
+    it('keeps the canonical shadow map size for Standard graph coverage', () => {
       // M1 scope: verify the fixture constant matches expected value.
-      // Real GPU readback assertions are in shadow-m2.dawn.test.ts
-      // (AC-10/11 canonical coverage via debugReadback GPU probe).
+      // Real GPU behavior is covered by the current Standard Dawn shadow
+      // graph and pixel-observation suites.
       expect(FIXTURE_MAP_SIZE).toBe(1024);
     });
   });