@forgeax/engine-runtime 0.1.28 → 0.1.29

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

@@ -72,7 +72,7 @@ import {
   propagateTransforms,
   Transform,
 } from '@forgeax/engine-scene';
-import type { Handle, LocalEntityId, SceneAsset, SceneEntity } from '@forgeax/engine-types';
+import type { Handle, SceneAsset, SceneEntity } from '@forgeax/engine-types';
 import { toShared } from '@forgeax/engine-types';
 import { describe, expect, expectTypeOf, it } from 'vitest';
 import { tonemapFromF32 } from '../../../render/src/components/camera';
@@ -182,9 +182,9 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
       expect(schemaRecord.materials).toBe('array<shared<MaterialAsset>>');
     });
 
-    it('Camera has 21 fields (17 f32 + historyVersion u32 + clearColor array<f32,4> + autoAspect bool + target)', () => {
+    it('Camera has 29 fields including target, exposure, and color grading columns', () => {
       expect(Camera.name).toBe('Camera');
-      expect(Object.keys(componentSchema(Camera)).length).toBe(21);
+      expect(Object.keys(componentSchema(Camera)).length).toBe(29);
       expect(componentSchema(Camera).fov).toBe('f32');
       expect(componentSchema(Camera).aspect).toBe('f32');
       expect(componentSchema(Camera).near).toBe('f32');
@@ -215,6 +215,14 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
       // feat-20260617-host-engine-contract-and-video-cutscene / M3: aspect-sync
       // opt-out flag (bool column tier, not f32).
       expect(componentSchema(Camera).autoAspect).toBe('bool');
+      expect(componentSchema(Camera).exposureMode).toBe('f32');
+      expect(componentSchema(Camera).compensationEv).toBe('f32');
+      expect(componentSchema(Camera).rangeEv).toBe('array<f32, 2>');
+      expect(componentSchema(Camera).rates).toBe('array<f32, 2>');
+      expect(componentSchema(Camera).temperature).toBe('f32');
+      expect(componentSchema(Camera).tint).toBe('f32');
+      expect(componentSchema(Camera).colorLut).toBe('shared<TextureAsset>');
+      expect(componentSchema(Camera).colorLutStrength).toBe('f32');
     });
 
     it('DirectionalLight has 14 fields: 3 light + castShadow bool + closed shadow quality fields', () => {
@@ -806,12 +814,16 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
     state: { type: 'unique<SceneInstanceState>' },
   });
 
-  function localId(n: number): LocalEntityId {
-    return n as LocalEntityId;
-  }
-
-  function buildScene(nodes: readonly SceneEntity[]): SceneAsset {
-    return { kind: 'scene', entities: nodes };
+  function buildScene(nodes: readonly (SceneEntity & { readonly key: string })[]): SceneAsset {
+    return {
+      kind: 'scene',
+      entities: Object.fromEntries(
+        nodes.map(({ key, components, instance }) => [
+          key,
+          { components, ...(instance === undefined ? {} : { instance }) },
+        ]),
+      ),
+    };
   }
 
   function registerSceneAsset(
@@ -847,7 +859,7 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
 
       const nodes: SceneEntity[] = [
         {
-          localId: localId(0),
+          key: 'entity-0',
           components: { Transform: { pos: [1.5, 0, 0] } },
         },
       ];
@@ -878,7 +890,7 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
       // asserted in the next test).
       const nodes: SceneEntity[] = [
         {
-          localId: localId(0),
+          key: 'entity-0',
           components: { Transform: {} },
         },
       ];
@@ -905,7 +917,7 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
       // defaults. AC-12 mandates this path is SILENT (no error code).
       const nodes: SceneEntity[] = [
         {
-          localId: localId(0),
+          key: 'entity-0',
           components: { Transform: {} },
         },
       ];
@@ -935,7 +947,7 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
       //   - read layer:    null is what the AI user observes after world.get
       const nodes: SceneEntity[] = [
         {
-          localId: localId(0),
+          key: 'entity-0',
           components: { TargetSlot: {} },
         },
       ];
@@ -970,7 +982,7 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
 
       const nodes: SceneEntity[] = [
         {
-          localId: localId(0),
+          key: 'entity-0',
           components: { Transform: { pos: [1.5, 0, 0] } },
         },
       ];
@@ -996,7 +1008,7 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
       const world = new World();
       world.components.register(Transform).unwrap();
 
-      const nodes: SceneEntity[] = [{ localId: localId(0), components: { Transform: {} } }];
+      const nodes: SceneEntity[] = [{ key: 'entity-0', components: { Transform: {} } }];
       const handle = registerSceneAsset(world, buildScene(nodes), [Transform]);
       const r = SceneOwner.worldInstantiateScene(world, handle);
       expect(r.ok).toBe(true);
@@ -1398,14 +1410,14 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
       expect(pod.tonemap).toBe(TONEMAP_NONE);
     });
 
-    it('perspective + orthographic 20-field counts (20 Camera columns)', () => {
+    it('perspective + orthographic 28-field counts (28 Camera columns)', () => {
       const p = perspective({ fov: 60, aspect: 4 / 3 });
       const o = orthographic({ left: -1, right: 1, bottom: -1, top: 1 });
-      // Both return exactly 20 fields (17 f32 + historyVersion u32 + one clearColor array +
+      // Both return exactly 28 fields (including exposure and color grading columns +
       // autoAspect bool column; feat-20260709 M3 collapsed the 4-scalar
       // clear-color quartet into one inline array<f32,4>).
-      expect(Object.keys(p).length).toBe(20);
-      expect(Object.keys(o).length).toBe(20);
+      expect(Object.keys(p).length).toBe(28);
+      expect(Object.keys(o).length).toBe(28);
     });
   });
 
@@ -1414,7 +1426,7 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
   // ────────────────────────────────────────────────────────────────────────────
 
   describe('Camera.fields reflection (w14 AC-07 SSOT)', () => {
-    it('Camera.fields has exactly 21 keys matching the Camera column set', () => {
+    it('Camera.fields has exactly 28 keys matching the Camera column set', () => {
       const keys = Object.keys(Camera.fields).sort();
       expect(keys).toEqual([
         'antialias',
@@ -1426,15 +1438,23 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
         'bloomThreshold',
         'bottom',
         'clearColor',
+        'colorLut',
+        'colorLutStrength',
+        'compensationEv',
         'exposure',
+        'exposureMode',
         'far',
         'fov',
         'historyVersion',
         'left',
         'near',
         'projection',
+        'rangeEv',
+        'rates',
         'right',
         'target',
+        'temperature',
+        'tint',
         'tonemap',
         'top',
         'whitePoint',
@@ -1448,11 +1468,15 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
             ? 'bool'
             : key === 'clearColor'
               ? 'array<f32, 4>'
-              : key === 'historyVersion'
-                ? 'u32'
-                : key === 'target'
-                  ? 'shared<RenderTarget>'
-                  : 'f32';
+              : key === 'rangeEv' || key === 'rates'
+                ? 'array<f32, 2>'
+                : key === 'colorLut'
+                  ? 'shared<TextureAsset>'
+                  : key === 'historyVersion'
+                    ? 'u32'
+                    : key === 'target'
+                      ? 'shared<RenderTarget>'
+                      : 'f32';
         expect(Camera.fields[key].type).toBe(expected);
       }
     });
@@ -1487,6 +1511,14 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
       expect(Array.from(d.clearColor.default as Float32Array)).toEqual([0, 0, 0, 0]);
       // aspect-sync opt-out default (feat-20260617 / M3).
       expect(d.autoAspect.default).toBe(true);
+      expect(d.exposureMode.default).toBe(0);
+      expect(d.compensationEv.default).toBe(0);
+      expect(Array.from(d.rangeEv.default as Float32Array)).toEqual([-8, 8]);
+      expect(Array.from(d.rates.default as Float32Array)).toEqual([3, 1]);
+      expect(d.temperature.default).toBe(6504);
+      expect(d.tint.default).toBe(0);
+      expect(d.colorLut.default).toBe(0);
+      expect(d.colorLutStrength.default).toBe(0);
       // Perspective quartet defaults intentionally absent (OOS-5).
       expect(d.fov.default).toBeUndefined();
       expect(d.aspect.default).toBeUndefined();
@@ -1496,7 +1528,7 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
   });
 
   describe('componentDefinition(Camera).defaults — frozen token defaults map (AC-07 + feat-20260528-fxaa-post-processing + feat-20260531-bloom + feat-20260608-clear-color)', () => {
-    it('componentDefinition(Camera).defaults equals { projection: 0, left: -1, right: 1, bottom: -1, top: 1, tonemap: 0, exposure: 1.0, whitePoint: 4.0, antialias: 0, bloom: 0, bloomThreshold: 1.0, bloomIntensity: 1.0, bloomBlurRadius: 4.0, clearColor: [0,0,0,0], autoAspect: true }', () => {
+    it('componentDefinition(Camera).defaults includes exposure and color grading defaults', () => {
       expect(componentDefinition(Camera).defaults).toEqual({
         projection: 0,
         left: -1,
@@ -1514,6 +1546,14 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
         bloomBlurRadius: 4.0,
         clearColor: new Float32Array([0, 0, 0, 0]),
         autoAspect: true,
+        exposureMode: 0,
+        compensationEv: 0,
+        rangeEv: new Float32Array([-8, 8]),
+        rates: new Float32Array([3, 1]),
+        temperature: 6504,
+        tint: 0,
+        colorLut: 0,
+        colorLutStrength: 0,
       });
     });
 
@@ -1722,7 +1762,7 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
       expect(pod.exposure).toBeCloseTo(1.0, 6);
     });
 
-    it('perspective return value has all 20 Camera fields', () => {
+    it('perspective return value has all 28 Camera fields', () => {
       const pod = perspective({ fov: 60, aspect: 4 / 3 });
       const keys = Object.keys(pod).sort();
       expect(keys).toEqual([
@@ -1735,14 +1775,22 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
         'bloomThreshold',
         'bottom',
         'clearColor',
+        'colorLut',
+        'colorLutStrength',
+        'compensationEv',
         'exposure',
+        'exposureMode',
         'far',
         'fov',
         'historyVersion',
         'left',
         'near',
         'projection',
+        'rangeEv',
+        'rates',
         'right',
+        'temperature',
+        'tint',
         'tonemap',
         'top',
         'whitePoint',

package/src/__tests__/composite-skybox-cross-world.browser.test.ts

@@ -62,8 +62,10 @@ if (typeof window !== 'undefined') {
 
 const browserReady = typeof navigator !== 'undefined' && navigator.gpu !== undefined;
 
-const CANVAS_W = 256;
-const CANVAS_H = 256;
+// This gate checks world ownership and non-black presentation, not detail.
+// Keep all composite frames while reducing software rasterization in CI.
+const CANVAS_W = import.meta.env.FORGEAX_BROWSER_CI_LIGHTWEIGHT === '1' ? 128 : 256;
+const CANVAS_H = CANVAS_W;
 const FRAMES = 8;
 
 // Build a bright, uniform equirect (all channels = 0.8 linear) so the projected

package/src/__tests__/dawn/instances-per-instance-pbr.dawn.test.ts

@@ -168,6 +168,7 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06)', () => {
     const { renderer, assets } = host.value;
     expect(renderer.inspect().state).toBe('alive');
     expect(assets).toBeInstanceOf(AssetRegistry);
+    const collectionN = renderer.instances.create({ transforms: transformsN }).unwrap();
 
     // Material creation (PBR standard). D-18: a shared-ref handle is per-World;
     // each frame's World allocs the same payload to get a handle it can resolve.
@@ -207,7 +208,7 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06)', () => {
       },
       { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [matHandleN] } },
-      { component: Instances, data: { transforms: transformsN } },
+      { component: Instances, data: { collectionId: collectionN.collectionId } },
     );
     worldN.spawn(
       {
@@ -270,6 +271,7 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06)', () => {
     singleTransform[5] = 1;
     singleTransform[10] = 1;
     singleTransform[15] = 1;
+    const collection1 = renderer.instances.create({ transforms: singleTransform }).unwrap();
 
     const world1 = new World();
     const matHandle1 = world1.allocSharedRef<'MaterialAsset', MaterialAsset>(
@@ -287,7 +289,7 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06)', () => {
       },
       { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [matHandle1] } },
-      { component: Instances, data: { transforms: singleTransform } },
+      { component: Instances, data: { collectionId: collection1.collectionId } },
     );
     world1.spawn(
       {
@@ -465,6 +467,7 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06)', () => {
     } as MaterialAsset;
 
     const transformsN2 = buildTranslationGrid();
+    const collectionN2 = renderer2.instances.create({ transforms: transformsN2 }).unwrap();
 
     // Frame A: N instances
     const worldN2 = new World();
@@ -483,7 +486,7 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06)', () => {
       },
       { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [matHandleN2] } },
-      { component: Instances, data: { transforms: transformsN2 } },
+      { component: Instances, data: { collectionId: collectionN2.collectionId } },
     );
     worldN2.spawn(
       {
@@ -545,6 +548,7 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06)', () => {
     singleTransform2[5] = 1;
     singleTransform2[10] = 1;
     singleTransform2[15] = 1;
+    const collection12 = renderer2.instances.create({ transforms: singleTransform2 }).unwrap();
 
     const world12 = new World();
     const matHandle12 = world12.allocSharedRef<'MaterialAsset', MaterialAsset>(
@@ -562,7 +566,7 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06)', () => {
       },
       { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [matHandle12] } },
-      { component: Instances, data: { transforms: singleTransform2 } },
+      { component: Instances, data: { collectionId: collection12.collectionId } },
     );
     world12.spawn(
       {

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

@@ -284,6 +284,9 @@ describe('w10 -- shadow instanced dawn smoke (AC-05 behavioral)', () => {
     const instanceTransforms = FALSIFY_COLLAPSED
       ? buildIdentityTransforms()
       : buildTranslationGrid();
+    const instanceCollection = renderer.instances
+      .create({ transforms: instanceTransforms })
+      .unwrap();
     world.spawn(
       {
         component: Transform,
@@ -295,7 +298,7 @@ describe('w10 -- shadow instanced dawn smoke (AC-05 behavioral)', () => {
       },
       { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [matHandle] } },
-      { component: Instances, data: { transforms: instanceTransforms } },
+      { component: Instances, data: { collectionId: instanceCollection.collectionId } },
     );
 
     // Render 300 frames for temporal stability (PCF or PCSS shadow, light accumulation)

package/src/__tests__/dawn/instances-uniform-fallback.dawn.test.ts

@@ -1,10 +1,28 @@
-// World-authored Instances render through storage and uniform bindings on Dawn.
-// The restricted RHI advertises no storage buffers while retaining the real
-// WebGPU device, shader compiler, validation and pixel readback. This proves
-// the uniform lane and its 128-instance chunks, not WebGL2 backend parity.
+// instances-uniform-fallback.dawn.test.ts -- feat-20260604-instances-per-instance-transform-shader-group3-bin
+// M1 / w6.
+//
+// AC-07: storage-buffer path + uniform-fallback path both compile and render
+// correctly for <=128 instances.
+//
+// Primary path: dawn-node renders <=128 instances through the normal storage
+// buffer path (caps.storageBuffer===true on dawn) and asserts frames are
+// non-clear (proves the storage variant renders).
+//
+// Degraded path (research R-C partial): dawn-node always has
+// caps.storageBuffer===true, so we cannot force the uniform-fallback variant
+// at the GPU level. Instead, we verify that:
+//   (a) The uniform-fallback #else form `var<uniform> instances : array<InstanceData, 128>`
+//       is present in common.wgsl (source-level structural check).
+//   (b) The variant count stays at 2 (verified by w1 unit test).
+//   (c) A non-trivial Instances render (<=128) works on the storage path.
+//
+// This is the best-effort degraded path per research R-C: "if dawn cannot
+// construct caps.storageBuffer===false, fall back to a vitest unit that
+// asserts the #else uniform array<..,128> form compiles, with reason
+// recorded."
 
 import type { MaterialAsset } from '@forgeax/engine-types';
-import { beforeAll, describe, expect, it } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import { drawPublished } from '../draw-published';
 
 // Source-level structural check: common.wgsl must carry both the storage
@@ -27,16 +45,7 @@ const STORAGE_PATTERN =
 const UNIFORM_PATTERN =
   /@group\(3\)\s+@binding\(0\)\s+var<uniform>\s+instances\s*:\s*array<InstanceData,\s*128>/;
 
-describe('World Instances storage and uniform submission', () => {
-  let ENGINE_MANIFEST_URL_W6: string;
-  beforeAll(async () => {
-    // Shader production is fixture setup; keep the render assertion's 30s
-    // deadline independent of a cold compiler/manifest build.
-    const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
-    const manifest = await buildEngineShaderManifest();
-    ENGINE_MANIFEST_URL_W6 = `data:application/json,${encodeURIComponent(JSON.stringify(manifest))}`;
-  }, 180_000);
-
+describe('w6 -- AC-07 storage+uniform variant test (degraded best-effort)', () => {
   it('(a) common.wgsl declares uniform-fallback array<InstanceData,128> under #else', async () => {
     const fsId = 'node:fs';
     const pathId = 'node:path';
@@ -79,41 +88,39 @@ describe('World Instances storage and uniform submission', () => {
     expect(commonSrc).toMatch(/localFromInstance\s*:\s*mat4x4<f32>/);
   });
 
-  it.each([
-    { storage: true, grid: 8 },
-    { storage: false, grid: 8 },
-    { storage: false, grid: 12 },
-  ])('renders $grid x $grid instances with storage=$storage', async ({ storage, grid }) => {
+  // (b) deg-path rationale: dawn-node always has caps.storageBuffer===true, so
+  // the uniform-fallback path cannot be exercised at the GPU level in this
+  // dawn test. The uniform-fallback variant is structurally verified via:
+  //   - w1 source-level variant=2 unit test (AC-11)
+  //   - w6 (a) source-level uniform array<..,128> form check above
+  //   - naga_oil compiles both variants at build-time (vite-plugin-shader)
+  // Restore as a real `it()` if a dawn-side uniform-fallback path becomes
+  // reachable (feat-20260608-ci-time-cut converted from `expect(true)`).
+  it.todo('(b) deg-path rationale recorded: dawn-node always storageBuffer=true');
+
+  it('(c) storage path renders Instances (dawn smoke integration)', async () => {
     const dawnAvailable = typeof globalThis.navigator?.gpu?.requestAdapter === 'function';
     if (!dawnAvailable) {
       throw new Error('dawn-node navigator.gpu not injected; vitest.setup-webgpu.ts regressed');
     }
 
+    // Render <=128 instances on the storage path and assert non-clear output.
+    // This proves the storage-buffer variant of @group(3) instances works
+    // end-to-end on dawn.
+
     const { World } = await import('@forgeax/engine-ecs');
-    const { rhi } = await import('@forgeax/engine-rhi-webgpu');
-    const restrictedRhi: typeof rhi = {
-      ...rhi,
-      async requestAdapter(...args) {
-        const adapter = await rhi.requestAdapter(...args);
-        if (!adapter.ok) return adapter;
-        const requestDevice = adapter.value.requestDevice.bind(adapter.value);
-        adapter.value.requestDevice = async (options) => {
-          const result = await requestDevice(options);
-          if (result.ok && !storage)
-            Object.defineProperty(result.value, 'caps', {
-              value: { ...result.value.caps, storageBuffer: false, compute: false },
-            });
-          return result;
-        };
-        return adapter;
-      },
-    };
     const { AssetRegistry, HANDLE_CUBE } = await import('@forgeax/engine-assets-runtime');
     const { Camera, MeshRenderer } = await import('@forgeax/engine-render');
     const { Instances } = await import('@forgeax/engine-render');
     const { constructRuntimeRendererHost } = await import('../../renderer-host');
     const { MeshFilter } = await import('@forgeax/engine-render');
     const { Transform } = await import('@forgeax/engine-scene');
+    const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
+    const ENGINE_MANIFEST_W6 = await buildEngineShaderManifest();
+    const ENGINE_MANIFEST_URL_W6 = `data:application/json,${encodeURIComponent(
+      JSON.stringify(ENGINE_MANIFEST_W6),
+    )}`;
+
     const W6_WIDTH = 256;
     const W6_HEIGHT = 256;
 
@@ -125,20 +132,15 @@ describe('World Instances storage and uniform submission', () => {
       const originalRequestDevice = rawAdapter.requestDevice.bind(rawAdapter);
       rawAdapter.requestDevice = async (desc) => {
         const dev = await originalRequestDevice(desc);
-        if (sharedDevice === undefined) {
-          sharedDevice = dev;
-          dev.pushErrorScope('validation');
-        }
+        if (sharedDevice === undefined) sharedDevice = dev;
         return dev;
       };
       return rawAdapter;
     };
 
     let renderTarget: GPUTexture | undefined;
-    let targetFormat: GPUTextureFormat = 'rgba8unorm';
     const ensureTarget = (device: GPUDevice, format: GPUTextureFormat): GPUTexture => {
       if (renderTarget !== undefined) return renderTarget;
-      targetFormat = format;
       renderTarget = device.createTexture({
         size: { width: W6_WIDTH, height: W6_HEIGHT, depthOrArrayLayers: 1 },
         format,
@@ -175,18 +177,15 @@ describe('World Instances storage and uniform submission', () => {
     try {
       host = await constructRuntimeRendererHost(
         mockCanvas,
-        { rhi: restrictedRhi },
+        {},
         { shaderManifestUrl: ENGINE_MANIFEST_URL_W6 },
       );
     } finally {
       globalThis.navigator.gpu.requestAdapter = origReq;
     }
+    expect(host.ok).toBe(true);
     if (!host.ok) throw host.error;
     const { renderer, assets } = host.value;
-    const errors: string[] = [];
-    renderer.subscribe((event) => {
-      if (event.kind === 'error') errors.push(JSON.stringify(event.error));
-    });
     expect(renderer.inspect().state).toBe('alive');
     expect(assets).toBeInstanceOf(AssetRegistry);
 
@@ -202,8 +201,9 @@ describe('World Instances storage and uniform submission', () => {
       values: { baseColor: [0.9, 0.2, 0.2, 1], metallic: 0, roughness: 0.5 },
     } as MaterialAsset;
 
-    const GRID = grid;
-    const COUNT = GRID * GRID;
+    // Build ~60 instances (well under 128 uniform cap), 2D grid
+    const GRID = 8;
+    const COUNT = GRID * GRID; // 64
     const SP = 3.0;
     const transforms = new Float32Array(COUNT * 16);
     let idx = 0;
@@ -220,6 +220,7 @@ describe('World Instances storage and uniform submission', () => {
         idx++;
       }
     }
+    const instanceCollection = renderer.instances.create({ transforms }).unwrap();
 
     const world = new World();
     const matHandle = world.allocSharedRef<'MaterialAsset', MaterialAsset>(
@@ -237,7 +238,7 @@ describe('World Instances storage and uniform submission', () => {
       },
       { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [matHandle] } },
-      { component: Instances, data: { transforms } },
+      { component: Instances, data: { collectionId: instanceCollection.collectionId } },
     );
     world.spawn(
       {
@@ -295,45 +296,18 @@ describe('World Instances storage and uniform submission', () => {
     readbackBuf.unmap();
     readbackBuf.destroy();
 
-    expect(errors).toEqual([]);
-    expect((await device.popErrorScope())?.message).toBeUndefined();
-
-    // Count actual red material pixels; comparing against guessed clear bytes
-    // could pass an empty frame because the target applies sRGB conversion.
-    let redPixels = 0;
-    for (let y = 0; y < W6_HEIGHT; y++) {
-      for (let x = 0; x < W6_WIDTH; x++) {
-        const offset = y * bytesPerRow + x * 4;
-        const r = bytes[offset + (targetFormat.startsWith('bgra') ? 2 : 0)] ?? 0;
-        const g = bytes[offset + 1] ?? 0;
-        const b = bytes[offset + (targetFormat.startsWith('bgra') ? 0 : 2)] ?? 0;
-        if (r > g + 30 && r > b + 30) redPixels++;
-      }
-    }
-    expect(redPixels).toBeGreaterThan(COUNT * 2);
-    // The last row crosses the 128-instance boundary for the 12x12 case.
-    // Verify its last matrix reaches a distinct screen location, not a
-    // duplicate of the first chunk or merely some non-clear geometry.
-    const edge = ((GRID - 1) / 2) * SP * 0.3;
-    const ndcEdge = edge / (25 * Math.tan(Math.PI / 8));
-    const lastX = Math.round(((1 + ndcEdge) * W6_WIDTH) / 2);
-    const lastY = Math.round(((1 - ndcEdge) * W6_HEIGHT) / 2);
-    let lastInstancePixels = 0;
-    for (let y = lastY - 3; y <= lastY + 3; y++) {
-      for (let x = lastX - 3; x <= lastX + 3; x++) {
-        const offset = y * bytesPerRow + x * 4;
-        const r = bytes[offset + (targetFormat.startsWith('bgra') ? 2 : 0)] ?? 0;
-        const g = bytes[offset + 1] ?? 0;
-        const b = bytes[offset + (targetFormat.startsWith('bgra') ? 0 : 2)] ?? 0;
-        if (r > g + 30 && r > b + 30) lastInstancePixels++;
-      }
-    }
-    expect(lastInstancePixels).toBeGreaterThan(0);
-    if (!storage) {
-      const residency = renderer.inspect().instanceCollections[0];
-      expect(residency?.lane).toBe(COUNT > 128 ? 'chunked-uniform' : 'direct-uniform');
-      expect(residency?.uploadedBytes).toBe(0);
-    }
-    await renderer.dispose();
+    // Sample multiple positions — the 8x8 grid should fill a substantial
+    // portion of the frame. Center should NOT be clear-color.
+    const cx = W6_WIDTH >> 1;
+    const cy = W6_HEIGHT >> 1;
+    const readPixel = (px: number, py: number): [number, number, number] => {
+      const off = py * bytesPerRow + px * 4;
+      return [bytes[off + 2] ?? 0, bytes[off + 1] ?? 0, bytes[off + 0] ?? 0];
+    };
+    const [cr, cg, cb] = readPixel(cx, cy);
+    // Clear color is ~(13, 13, 20) in sRGB bytes. Center should be
+    // significantly different (red cubes).
+    const distFromClear = Math.sqrt((cr - 13) ** 2 + (cg - 13) ** 2 + (cb - 20) ** 2);
+    expect(distFromClear).toBeGreaterThan(30);
   });
 });