@forgeax/engine-runtime 0.1.19 → 0.1.21

package/src/__tests__/createRenderer.browser-no-webgpu.test.ts

@@ -13,8 +13,74 @@
 
 import { createRenderer, EngineEnvironmentError } from '@forgeax/engine-runtime';
 import { describe, expect, it } from 'vitest';
+import { projectDirectionalShadowInspection } from '../../../render/src/assembly/directional-shadow-inspection';
+import { resolveDirectionalShadowBackendAdmission } from '../../../render/src/render-pipeline';
 
 describe('createRenderer without navigator.gpu (browser-no-webgpu)', () => {
+  it('requires the shared backend admission truth table for WebGL2 fallback and capable failure', async () => {
+    const module = (await import('../../../render/src/render-pipeline')) as Record<string, unknown>;
+    const resolver = module.resolveDirectionalShadowBackendAdmission;
+    expect(typeof resolver).toBe('function');
+    const resolve = resolver as (input: {
+      backendKind: 'webgpu' | 'wgpu-webgl2';
+      requested: 'pcssMedium' | 'pcssHigh';
+      candidate: 'accepted' | 'failed';
+      lastKnownGood?: 'pcf3' | 'pcf5';
+    }) => {
+      effective: string;
+      status: string;
+      fallbackReason?: string;
+    };
+    expect(
+      resolve({ backendKind: 'wgpu-webgl2', requested: 'pcssMedium', candidate: 'accepted' }),
+    ).toMatchObject({
+      effective: 'pcf3',
+      status: 'fallback',
+      fallbackReason: 'webgl2-unsupported',
+    });
+    expect(
+      resolve({
+        backendKind: 'webgpu',
+        requested: 'pcssHigh',
+        candidate: 'failed',
+        lastKnownGood: 'pcf3',
+      }),
+    ).toMatchObject({ effective: 'pcf3', status: 'rejected', fallbackReason: 'candidate-failed' });
+  });
+
+  it('keeps capable candidate failure explicit while retaining the LKG inspection facts', () => {
+    const inspection = projectDirectionalShadowInspection({
+      admission: resolveDirectionalShadowBackendAdmission({
+        backendKind: 'webgpu',
+        requested: 'pcssHigh',
+        candidate: 'failed',
+        lastKnownGood: 'pcf3',
+      }),
+      cascadeCount: 4,
+      mapSize: 2048,
+      atlasBytes: 67_108_864,
+      writerPasses: 4,
+      blockerTaps: 0,
+      filterTapUpperBound: 9,
+      seamTapUpperBound: 9,
+      deviceGeneration: 2,
+      graphGeneration: 6,
+      error: {
+        code: 'shadow-candidate-failed',
+        expected: 'the capable backend candidate compiles and validates',
+        hint: 'fix the authoring input, then retry or recover',
+      },
+    });
+    expect(inspection).toMatchObject({
+      effective: 'pcf3',
+      status: 'rejected',
+      fallbackReason: 'candidate-failed',
+      lastKnownGood: true,
+      graphGeneration: 6,
+      error: { hint: expect.stringContaining('retry') },
+    });
+  });
+
   it('navigator.gpu is absent or non-functional in this browser environment', async () => {
     const nav = globalThis.navigator as { gpu?: GPU };
     if (nav.gpu === undefined) return;

package/src/__tests__/dawn/hello-sprite-nineslice-section.dawn.test.ts

@@ -62,6 +62,12 @@ const BUFFER_USAGE_MAP_READ = 0x0001;
 const BUFFER_USAGE_COPY_DST = 0x0008;
 const MAP_MODE_READ = 0x0001;
 
+// Windows Dawn first-touch construction for the two renderer/readback probes
+// can exceed Vitest's project-wide 30-second timeout while still completing
+// well inside the nightly platform budget. Keep this owner-specific gate
+// bounded so a valid cold-start probe is not retried as a false failure.
+const SPRITE_NINESLICE_DAWN_TEST_TIMEOUT_MS = 120_000;
+
 // Distinctive 4x4 texture: corners RED (cells (0,0)/(3,0)/(0,3)/(3,3)),
 // remaining cells BLUE. With slices=[0.25,0.25,0.25,0.25] in atlas-uv space
 // the 4 corners line up with the 4 corner texels -- making the central band
@@ -89,11 +95,10 @@ function makeCornerCheckerTexture(): TextureAsset {
   }
   return {
     kind: 'texture',
-    width: side,
-    height: side,
+    shape: { viewDimension: '2d', extent: { width: side, height: side } },
     format: 'rgba8unorm-srgb',
     colorSpace: 'srgb',
-    mipmap: false,
+    mips: { kind: 'none' },
     data: bytes,
   };
 }
@@ -326,7 +331,9 @@ function midBandDistance(a: CapturedFrame, b: CapturedFrame): number {
 }
 
 describe('feat-20260527-sprite-nineslice w14 dawn smoke (stretch vs tile divergence)', () => {
-  it('stretch + tile sprite frames diverge in the mid-band after w15 (red until w15 lands)', async () => {
+  it('stretch + tile sprite frames diverge in the mid-band after w15 (red until w15 lands)', {
+    timeout: SPRITE_NINESLICE_DAWN_TEST_TIMEOUT_MS,
+  }, async () => {
     // Asymmetric scale: x=4 vs y=1. With slices=[0.25,0.25,0.25,0.25] and the
     // 4x4 corner-checker texture, the post-w15 9-slice path keeps corner
     // zones at fixed world dimensions while the legacy pre-w15 path stretches

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

@@ -55,6 +55,17 @@ const MAP_MODE_READ = 0x0001;
 const INSTANCE_COUNT = 5;
 const SPACING = 2.5;
 
+const SHADOW_FILTER = (() => {
+  const value = (
+    globalThis as unknown as { process?: { env?: Record<string, string | undefined> } }
+  ).process?.env?.FORGEAX_SHADOW_FILTER;
+  if (value === 'pcssMedium') return 4;
+  if (value === 'pcssHigh') return 5;
+  if (value === 'pcf1') return 1;
+  if (value === 'pcf5') return 3;
+  return 2;
+})();
+
 function buildTranslationGrid(): Float32Array {
   const out = new Float32Array(INSTANCE_COUNT * 16);
   const half = ((INSTANCE_COUNT - 1) * SPACING) / 2;
@@ -263,7 +274,9 @@ describe('w10 -- shadow instanced dawn smoke (AC-05 behavioral)', () => {
         depthBias: 0.005,
         normalBias: 0.05,
         shadowDistance: 50,
-        pcfKernelSize: 3,
+        shadowFilter: SHADOW_FILTER,
+        shadowAngularRadius: 0.00465,
+        maxPenumbraTexels: 32,
       },
     });
 
@@ -285,7 +298,7 @@ describe('w10 -- shadow instanced dawn smoke (AC-05 behavioral)', () => {
       { component: Instances, data: { transforms: instanceTransforms } },
     );
 
-    // Render 300 frames for temporal stability (PCF shadow, light accumulation)
+    // Render 300 frames for temporal stability (PCF or PCSS shadow, light accumulation)
     const attachment = renderer.attach(world);
     expect(attachment.ok).toBe(true);
     if (!attachment.ok) throw attachment.error;

package/src/__tests__/dawn/material-alpha.dawn.test.ts

@@ -99,12 +99,11 @@ function textureBytes(color: readonly [number, number, number, number]): Uint8Ar
 function makeTexture(color: readonly [number, number, number, number]): TextureAsset {
   return {
     kind: 'texture',
-    width: 1,
-    height: 1,
+    shape: { viewDimension: '2d', extent: { width: 1, height: 1 } },
     format: 'rgba8unorm-srgb',
     data: textureBytes(color),
     colorSpace: 'srgb',
-    mipmap: false,
+    mips: { kind: 'none' },
   };
 }
 

package/src/__tests__/dawn/mipmap-srgb-linear.dawn.test.ts

@@ -42,12 +42,11 @@ function makeTexture(
 ): TextureAsset {
   return {
     kind: 'texture',
-    width,
-    height,
+    shape: { viewDimension: '2d', extent: { width, height } },
     format,
     data: new Uint8Array(width * height * 4),
     colorSpace,
-    mipmap,
+    mips: mipmap ? { kind: 'generate' } : { kind: 'none' },
   };
 }
 

package/src/__tests__/dawn/per-entity-material-texture-isolation.dawn.test.ts

@@ -60,12 +60,11 @@ function makeChequerTexture(primaryR: number, primaryG: number, primaryB: number
   }
   return {
     kind: 'texture',
-    width: side,
-    height: side,
+    shape: { viewDimension: '2d', extent: { width: side, height: side } },
     format: 'rgba8unorm',
     data: bytes,
     colorSpace: 'srgb',
-    mipmap: false,
+    mips: { kind: 'none' },
   };
 }
 

package/src/__tests__/dawn/sprite-nineslice-mesh-bind.dawn.test.ts

@@ -126,11 +126,10 @@ describe('feat-20260527-sprite-nineslice w13 dawn smoke (HANDLE_NINESLICE_QUAD b
     }
     const texAsset: TextureAsset = {
       kind: 'texture',
-      width: 4,
-      height: 4,
+      shape: { viewDimension: '2d', extent: { width: 4, height: 4 } },
       format: 'rgba8unorm-srgb',
       colorSpace: 'srgb',
-      mipmap: false,
+      mips: { kind: 'none' },
       data: pixels,
     };
     const texHandle = world.allocSharedRef<'TextureAsset', TextureAsset>('TextureAsset', texAsset);

package/src/__tests__/dawn/upload-texture.dawn.test.ts

@@ -72,12 +72,11 @@ function makeTexture(
 ): TextureAsset {
   return {
     kind: 'texture',
-    width,
-    height,
+    shape: { viewDimension: '2d', extent: { width, height } },
     format,
     data: new Uint8Array(width * height * 4),
     colorSpace,
-    mipmap,
+    mips: mipmap ? { kind: 'generate' } : { kind: 'none' },
   };
 }
 
@@ -182,12 +181,11 @@ describe('AC-04: uploadTexture non-256-aligned width (real GPU path)', () => {
 
     const tex: TextureAsset = {
       kind: 'texture',
-      width,
-      height,
+      shape: { viewDimension: '2d', extent: { width, height } },
       format: 'rgba8unorm',
       data: buf,
       colorSpace: 'linear',
-      mipmap: false,
+      mips: { kind: 'none' },
     };
 
     const handle = world.allocSharedRef('TextureAsset', tex);

package/src/__tests__/derive-bgl-integration.test.ts

@@ -87,6 +87,17 @@ const builtinSchemas: ReadonlyArray<{ id: string; schema: readonly ParamSchemaEn
 ];
 
 describe('derive(schema) integration over 5 built-in shader families (M3 w11)', () => {
+  it('derives array and volume texture schemas without a second binding path', () => {
+    for (const schema of [
+      [{ name: 'layers', type: 'texture2d_array' as const }],
+      [{ name: 'volume', type: 'texture3d' as const }],
+    ]) {
+      const out = derive(schema);
+      expect(out.bglEntries.map((entry) => entry.binding)).toEqual([0, 1, 2]);
+      expect(out.resourceBindings[1]?.name).toBe(schema[0]?.name);
+      expect(out.textureFieldNames).toContain(schema[0]?.name);
+    }
+  });
   it('(a) every built-in shader derives a well-formed BGL with consistent userRegionBindingEnd', () => {
     for (const { id, schema } of builtinSchemas) {
       const out = derive(schema);

package/src/__tests__/equirect-bc6h.integration.test.ts

@@ -145,12 +145,14 @@ describe.skipIf(!hasGpu)('equirect renderable-source integration (feat-20260707
     // POD mirrors that 2D surface.
     const source = {
       kind: 'texture' as const,
-      width: asset.width,
-      height: asset.height,
+      shape: { viewDimension: '2d' as const, extent: { width: asset.width, height: asset.height } },
       format: asset.format,
-      data: asset.data,
+      data:
+        asset.data instanceof Uint8ClampedArray
+          ? new Uint8Array(asset.data.buffer, asset.data.byteOffset, asset.data.byteLength)
+          : asset.data,
       colorSpace: asset.colorSpace,
-      mipmap: false,
+      mips: { kind: 'none' as const },
     };
     const res = deriveRenderDataCubemap(source);
     expect(res.ok).toBe(true);

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':
@@ -530,6 +549,16 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
               return 'points lines prepare failed';
             case 'transmission-capability-missing':
               return 'transmission capability missing';
+            case 'projector-binding-failed':
+              return 'projector binding failed';
+            case 'volume-owner-conflict':
+              return 'volume owner conflict';
+            case 'volume-density-shape-mismatch':
+              return 'volume density shape mismatch';
+            case 'volume-invalid-bounds':
+              return 'volume invalid bounds';
+            case 'volume-invalid-parameters':
+              return 'volume invalid parameters';
           }
         }
         expect(exhaustive('equirect-projection-failed')).toBe('equirect projection failed');
@@ -541,16 +570,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', () => {
@@ -581,6 +609,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';
@@ -626,9 +655,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';
@@ -640,7 +669,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';
@@ -680,9 +721,19 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
               return 'ok';
             case 'transmission-capability-missing':
               return 'ok';
+            case 'projector-binding-failed':
+              return 'ok';
+            case 'volume-owner-conflict':
+              return 'ok';
+            case 'volume-density-shape-mismatch':
+              return 'ok';
+            case 'volume-invalid-bounds':
+              return 'ok';
+            case 'volume-invalid-parameters':
+              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

@@ -171,52 +171,26 @@ function simulateMerge(
     }
     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,
+    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 +407,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 +628,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 +659,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__/four-path-compression.integration.test.ts

@@ -216,10 +216,10 @@ describe('w16: 4-path compressed-fixture loading', () => {
                   guid: GUID_TEX,
                   kind: 'texture',
                   payload: {
-                    width: 4,
-                    height: 4,
+                    shape: { viewDimension: '2d', extent: { width: 4, height: 4 } },
                     format: 'rgba8unorm',
                     colorSpace: 'srgb',
+                    mips: { kind: 'none' },
                   },
                   refs: [],
                   artifacts: {

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([]);
     });