@forgeax/engine-runtime 0.1.24 → 0.1.26

package/src/__tests__/instances-renderer-lifecycle.integration.test.ts

@@ -0,0 +1,164 @@
+import { HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
+import { World } from '@forgeax/engine-ecs';
+import { Camera, Instances, MeshFilter, MeshRenderer } from '@forgeax/engine-render';
+import { RhiNullAdapter, rhi } from '@forgeax/engine-rhi-null';
+import { Transform } from '@forgeax/engine-scene';
+import { ok } from '@forgeax/engine-types';
+import { expect, it } from 'vitest';
+import { constructRendererHost } from '../../../render/src/construct-renderer';
+
+function requireValue<T>(
+  result:
+    | { readonly ok: true; readonly value: T }
+    | { readonly ok: false; readonly error: unknown },
+): T {
+  if (!result.ok) throw result.error;
+  return result.value;
+}
+
+const manifest = `data:application/json,${encodeURIComponent(
+  JSON.stringify({
+    schemaVersion: '1.0.0',
+    entries: [
+      { hash: 'pbr00000', wgsl: 'f_schlick(', glsl: '', bindings: '' },
+      { hash: 'unlit000', wgsl: 'unlit', glsl: '', bindings: '' },
+      { hash: 'tonemap0', wgsl: 'struct TonemapParams {}', glsl: '', bindings: '' },
+    ],
+    materialShaders: [
+      {
+        identifier: 'forgeax::default-unlit',
+        sourcePath: 'unlit.wgsl',
+        composedWgsl: '/* null backend shader */',
+        paramSchema: '[]',
+        variants: [],
+      },
+    ],
+  }),
+)}`;
+function canvas(): HTMLCanvasElement {
+  return { width: 32, height: 32, getContext: () => null } as unknown as HTMLCanvasElement;
+}
+function matrices(x: number, count = 1): Float32Array {
+  const result = new Float32Array(16 * count);
+  for (let i = 0; i < count; i++)
+    result.set([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, 0, 0, 1], i * 16);
+  return result;
+}
+
+// Coverage instrumentation plus a contended heavy runner can make the
+// 20,000-instance recovery case exceed the normal one-minute budget even
+// though the operation remains bounded and completes quickly uninstrumented.
+it.each([
+  1, 129, 20000,
+])('renders %i World instances after replacing and recovering the Renderer', async (count) => {
+  const adapter = new RhiNullAdapter();
+  const device = (await adapter.requestDevice()).unwrap();
+  const replacementDevice = (await adapter.requestDevice()).unwrap();
+  const replacement = new Proxy(replacementDevice, {
+    get(target, property) {
+      if (property === 'caps' && count < 20000)
+        return { ...target.caps, storageBuffer: false, compute: false };
+      const value = Reflect.get(target, property, target);
+      return typeof value === 'function' ? value.bind(target) : value;
+    },
+  });
+  let lose!: (reason: unknown) => void;
+  const lost = new Promise<never>((_, reject) => {
+    lose = reject;
+  });
+  const first = new Proxy(device, {
+    get(target, property) {
+      if (property === 'lost') return lost;
+      if (property === 'caps' && count < 20000)
+        return { ...target.caps, storageBuffer: false, compute: false };
+      const value = Reflect.get(target, property, target);
+      return typeof value === 'function' ? value.bind(target) : value;
+    },
+  });
+  let requests = 0;
+  const recoverable = {
+    // Recorder-wrapped backends expose only the asynchronous shader factory.
+    acquireCanvasContext: rhi.acquireCanvasContext,
+    createShaderModule: rhi.createShaderModule,
+    requestAdapter: async () =>
+      ok({
+        features: adapter.features,
+        limits: adapter.limits,
+        requestDevice: async () => ok(++requests === 1 ? first : replacement),
+      } as never),
+  } as never;
+  const world = new World();
+  const material = world.allocSharedRef('MaterialAsset', {
+    kind: 'material',
+    passes: [
+      {
+        name: 'Forward',
+        program: { module: 'forgeax::default-unlit' },
+        renderState: { tags: { LightMode: 'Forward' }, queue: 2000 },
+      },
+    ],
+    values: { baseColor: [1, 0, 0] },
+  });
+  const entity = world
+    .spawn(
+      { component: Transform, data: {} },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
+      { component: MeshRenderer, data: { materials: [material] } },
+      { component: Instances, data: { transforms: matrices(0, count) } },
+    )
+    .unwrap();
+  world
+    .spawn(
+      { component: Transform, data: { pos: [0, 0, 5] } },
+      { component: Camera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 } },
+    )
+    .unwrap();
+  const a = requireValue(
+    await constructRendererHost(canvas(), { rhi }, { shaderManifestUrl: manifest }),
+  ).renderer;
+  const b = requireValue(
+    await constructRendererHost(canvas(), { rhi: recoverable }, { shaderManifestUrl: manifest }),
+  ).renderer;
+  const la = requireValue(a.attach(world));
+  const lb = requireValue(b.attach(world));
+  const ra = { leases: [la], camera: { lease: la }, environment: { lease: la } };
+  const rb = { leases: [lb], camera: { lease: lb }, environment: { lease: lb } };
+  world.update(0).unwrap();
+  requireValue(a.draw(ra));
+  requireValue(b.draw(rb));
+  expect(a.inspect().instanceCollections[0]?.count).toBe(count);
+  expect(b.inspect().instanceCollections[0]?.count).toBe(count);
+  expect(b.inspect().instanceCollections[0]?.uploadedBytes).toBeGreaterThan(0);
+  requireValue(b.draw(rb));
+  expect(b.inspect().instanceCollections[0]?.uploadedBytes).toBe(0);
+  const firstRevision = b.inspect().instanceCollections[0]?.revision;
+  world.set(entity, Instances, { transforms: matrices(0.25, count) }).unwrap();
+  requireValue(a.draw(ra));
+  world.set(entity, Instances, { transforms: matrices(0.5, count) }).unwrap();
+  requireValue(a.draw(ra));
+  await a.dispose();
+  expect(world.get(entity, Instances).unwrap().transforms[12]).toBe(0.5);
+  requireValue(b.draw(rb));
+  expect(b.inspect().instanceCollections[0]?.revision).toBeGreaterThan(firstRevision ?? 0);
+  lose({ reason: 'unknown', message: 'instance recovery regression' });
+  await Promise.resolve();
+  await Promise.resolve();
+  expect(b.state()).toBe('device-lost');
+  const finalX = count === 129 ? 0.75 : 0.5;
+  if (count === 129) world.set(entity, Instances, { transforms: matrices(finalX, count) }).unwrap();
+  const recovered = await b.recover();
+  expect(recovered.ok, recovered.ok ? '' : JSON.stringify(recovered.error)).toBe(true);
+  requireValue(b.draw(rb));
+  expect(b.inspect().instanceCollections[0]?.uploadedBytes).toBe(count === 129 ? count * 64 : 0);
+  expect(b.inspect().recoveryEvidence.submissions.lastGeneration).toBe(1);
+  expect(b.inspect().frame.deviceGeneration).toBe(1);
+  // The GPU-driven primary lane owns no legacy instance buffer; its published
+  // device generation is evidenced by the submitted frame above.
+  if (count < 20000) expect(b.inspect().instanceCollections[0]?.residentGeneration).toBe(1);
+  const retained = world.get(entity, Instances).unwrap().transforms;
+  expect(retained.length).toBe(count * 16);
+  expect(retained[12]).toBe(finalX);
+  expect(retained[(count - 1) * 16 + 12]).toBe(finalX);
+  expect(b.inspect().instanceCollections[0]?.count).toBe(count);
+  await b.dispose();
+}, 120_000);

package/src/__tests__/loader-extract-graceful.test.ts

@@ -99,24 +99,25 @@ describe('loader-extract graceful handoff (M4 w24)', () => {
     expect('baseColorTexture' in pv).toBe(false);
   });
 
-  it('(3) shader NOT registered (R-4 cross-worktree) -> graceful "try every int" fallback', () => {
-    // No paramSchema lookup available -> getMaterialShaderTextureFieldNames
-    // returns undefined for every shader id.
+  it('(3) shader NOT registered (R-4 cross-worktree) -> graceful structured texture fallback', () => {
+    // No paramSchema lookup is available, so the loader cannot classify bare
+    // integers as texture refs. Explicit structured texture values remain
+    // resolvable across worktrees without guessing at scalar fields.
     const ctx = makeCtx({
       shaderTextureFieldNames: () => undefined,
     });
     const out = materialLoader.load(
       {
         passes: [{ program: { module: 'forgeax::user-defined' } }],
-        values: { customTexture: 0 },
+        values: { customTexture: { texture: 0 } },
       },
       ['tex-guid'],
       ctx,
     );
     expect(out).toMatchObject({ kind: 'material' });
     const pv = (out as { values: Record<string, unknown> }).values;
-    // Graceful fallback resolves any in-range int to its refs[] GUID string.
-    expect(pv.customTexture).toBe('tex-guid');
+    // Explicit structured refs resolve to the enclosing refs[] GUID.
+    expect(pv.customTexture).toEqual({ texture: 'tex-guid' });
   });
 
   it('(4) shader registered + scalar paramValue with refs[] index in range -> NOT misclassified', () => {

package/src/__tests__/loader-registry.cases.unit.test.ts

@@ -546,29 +546,22 @@ type __MergedKeep =
       expect(out).toMatchObject({ kind: 'material', parentGuid: 'parent-guid' });
     });
 
-    it('materialLoader resolves heightTexture from refs index to its GUID (M4 / w22, D-19)', () => {
-      // feat-20260613-material-paramschema-driven-binding M4 / w22:
-      // the legacy hardcoded texture-field allowlist Set has been deleted.
-      // When the shader is not yet registered (mock ctx returns undefined
-      // from getMaterialShaderTextureFieldNames), the loader falls back to
-      // a graceful "try every int paramValue in [0, refs.length)" walk and
-      // resolves heightTexture (any field name) to the refs[] entry.
-      //
-      // feat-20260614 M8 (D-19): the embedded sub-asset ref is stored as its
-      // GUID string verbatim (dash-form) -- the ECS/render side resolves the
-      // GUID -> column handle at use time via world.allocSharedRef; the loader
-      // no longer mints a numeric handle (resolveRefSync is deleted). Mirrors
-      // the sibling `parentGuid` contract (refs index -> GUID string).
+    it('materialLoader resolves an explicit heightTexture ref index to its GUID (M4 / w22, D-19)', () => {
+      // Texture references use the explicit `{ texture: refsIndex }` wire
+      // shape. This remains safe when the shader is not registered because
+      // the loader does not guess whether a bare integer is a scalar.
       const out = materialLoader.load(
         {
           passes: [{ shader: 'test' }],
-          values: { heightTexture: 0 },
+          values: { heightTexture: { texture: 0 } },
         },
         ['height-guid'],
         mockCtx(),
       );
       expect(out).toMatchObject({ kind: 'material' });
-      expect((out as Record<string, unknown>)?.values?.heightTexture).toBe('height-guid');
+      expect((out as Record<string, unknown>)?.values?.heightTexture).toEqual({
+        texture: 'height-guid',
+      });
     });
 
     it('materialLoader returns normally when values has no heightTexture field', () => {

package/src/__tests__/material-programs.browser.test.ts

@@ -0,0 +1,145 @@
+import { HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
+import { World } from '@forgeax/engine-ecs';
+import { Camera, MeshFilter, MeshRenderer } from '@forgeax/engine-render';
+import { Transform } from '@forgeax/engine-scene';
+import type { MaterialAsset } from '@forgeax/engine-types';
+import { expect, it } from 'vitest';
+import { page } from 'vitest/browser';
+import { constructRuntimeRendererHost } from '../renderer-host';
+import { drawPublished } from './draw-published';
+
+it.each([
+  false,
+  true,
+])('draws every selected material Pass with mixed blending=%s', async (mixed) => {
+  if (!navigator.gpu) throw new Error('WebGPU is required');
+  const canvas = document.createElement('canvas');
+  canvas.width = 384;
+  canvas.height = 256;
+  document.body.append(canvas);
+  const requestAdapter = navigator.gpu.requestAdapter.bind(navigator.gpu);
+  const validation: string[] = [];
+  const entries: string[] = [];
+  const devices: GPUDevice[] = [];
+  navigator.gpu.requestAdapter = async (options) => {
+    const adapter = await requestAdapter(options);
+    if (adapter === null) return adapter;
+    const requestDevice = adapter.requestDevice.bind(adapter);
+    adapter.requestDevice = async (descriptor) => {
+      const device = await requestDevice(descriptor);
+      devices.push(device);
+      device.addEventListener('uncapturederror', (event) => validation.push(event.error.message));
+      const record = (descriptor: GPURenderPipelineDescriptor) =>
+        entries.push(`${descriptor.vertex.entryPoint}/${descriptor.fragment?.entryPoint}`);
+      const create = device.createRenderPipeline.bind(device);
+      device.createRenderPipeline = (descriptor) => {
+        record(descriptor);
+        return create(descriptor);
+      };
+      const createAsync = device.createRenderPipelineAsync.bind(device);
+      device.createRenderPipelineAsync = async (descriptor) => {
+        record(descriptor);
+        return createAsync(descriptor);
+      };
+      return device;
+    };
+    return adapter;
+  };
+  const host = await constructRuntimeRendererHost(
+    canvas,
+    {},
+    { shaderManifestUrl: '/shaders/manifest.json' },
+  );
+  if (!host.ok) {
+    navigator.gpu.requestAdapter = requestAdapter;
+    canvas.remove();
+    throw host.error;
+  }
+  const errors: string[] = [];
+  const unsubscribe = host.value.renderer.subscribe((event) => {
+    if (event.kind === 'error') errors.push(event.error.message);
+  });
+  try {
+    const assets = host.value.assets;
+    assets.configurePackIndex(
+      mixed ? '/__material-programs-mixed/pack-index.json' : '/__material-programs/pack-index.json',
+    );
+    const material = (
+      await assets.loadByGuid<MaterialAsset>(
+        assets.parseGuid('8f50ae65-6e0a-40b4-8949-b47006edab90'),
+      )
+    ).unwrap();
+    const projection = assets.getMaterialProjectionForPayload(material);
+    expect(
+      new Set(
+        projection?.passes.flatMap((pass) =>
+          pass.programs.map((program) => program.specializationKey),
+        ),
+      ).size,
+    ).toBe(2);
+    const world = new World();
+    const handle = world.allocSharedRef<'MaterialAsset', MaterialAsset>('MaterialAsset', material);
+    world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 3], scale: [1, 1, 1], quat: [0, 0, 0, 1] } },
+        {
+          component: Camera,
+          data: {
+            fov: Math.PI / 4,
+            aspect: 1.5,
+            near: 0.1,
+            far: 100,
+            clearColor: [0.02, 0.02, 0.02, 1],
+          },
+        },
+      )
+      .unwrap();
+    world
+      .spawn(
+        { component: Transform, data: { pos: [0, 0, 0], scale: [1, 1, 1], quat: [0, 0, 0, 1] } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
+        { component: MeshRenderer, data: { materials: [handle] } },
+      )
+      .unwrap();
+    for (let frame = 0; frame < 40; frame++) {
+      const receipt = drawPublished(host.value.renderer, world);
+      if (!receipt.ok) throw receipt.error;
+      const completed = await receipt.value.completed;
+      if (!completed.ok) throw completed.error;
+      await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+    }
+    await Promise.all(devices.map((device) => device.queue.onSubmittedWorkDone()));
+    const shot = await page.elementLocator(canvas).screenshot({ base64: true });
+    const bytes = Uint8Array.from(atob(typeof shot === 'string' ? shot : shot.base64), (char) =>
+      char.charCodeAt(0),
+    );
+    const bitmap = await createImageBitmap(new Blob([bytes], { type: 'image/png' }));
+    const surface = new OffscreenCanvas(bitmap.width, bitmap.height);
+    const ctx = surface.getContext('2d');
+    if (ctx === null) throw new Error('pixel readback unavailable');
+    ctx.drawImage(bitmap, 0, 0);
+    bitmap.close();
+    const pixels = ctx.getImageData(0, 0, surface.width, surface.height);
+    for (const [fraction, channel] of [
+      [0.2, 0],
+      [0.5, 1],
+      [0.8, 2],
+    ] as const) {
+      const offset =
+        (Math.floor(surface.height * 0.5) * surface.width + Math.floor(surface.width * fraction)) *
+        4;
+      const color = [...pixels.data.slice(offset, offset + 3)];
+      expect(color[channel], `Pass color at ${fraction}: ${color}`).toBeGreaterThan(200);
+      expect(color.filter((_, index) => index !== channel).every((value) => value < 40)).toBe(true);
+    }
+    expect(entries).toContain('vs_right/fs_blue');
+    expect(validation).toEqual([]);
+    expect(errors).toEqual([]);
+  } finally {
+    unsubscribe();
+    host.value.renderer.dispose();
+    for (const device of devices) device.destroy();
+    navigator.gpu.requestAdapter = requestAdapter;
+    canvas.remove();
+  }
+}, 60_000);

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

@@ -80,10 +80,10 @@ describe('Materials.standard multi-pass (w14)', () => {
       expect(shadowPass).toBeDefined();
     });
 
-    it('shadow-caster pass uses forgeax_material::standard shader', () => {
+    it('shadow-caster pass uses the canonical depth-only shader', () => {
       const mat = Materials.standard({ baseColor: [0.5, 0.5, 0.5, 1] });
       const shadowPass = mat.passes?.find((p) => p.name === ('shadow-caster' as PassKind));
-      expect(shadowPass?.program.module).toBe('forgeax_material::standard');
+      expect(shadowPass?.program.module).toBe('forgeax::default-shadow-caster');
     });
 
     it('castShadow=false suppresses the shadow-caster pass', () => {

package/src/__tests__/parse-asset-payload-material.cases.unit.test.ts

@@ -502,7 +502,7 @@ type __MergedKeep =
       expect(asset).toBeUndefined();
     });
 
-    it('(AC-06) payload with parent ref + valid passes -> returns MaterialAsset with both passes and parentGuid', () => {
+    it('(AC-06) payload with parent ref + own passes -> returns undefined (strict child contract)', () => {
       const reg = new AssetRegistry(makeMockShaderRegistry());
       const fn = makeParseFn(reg);
 
@@ -520,18 +520,8 @@ type __MergedKeep =
       };
       const refs = [PARENT_GUID];
 
-      const asset = fn('material', payload, refs) as
-        | (MaterialAsset & { parentGuid?: string })
-        | undefined;
-
-      expect(asset).toBeDefined();
-      if (!asset) return;
-      expect(asset.kind).toBe('material');
-      expect(asset.passes).toBeDefined();
-      expect(asset.passes?.length).toBe(1);
-      expect(asset.parentGuid).toBe(PARENT_GUID);
-      // values should still be present when both passes + parent are provided
-      expect(asset.values).toEqual({ baseColor: [1, 0, 0, 1] });
+      // A child may override values only; root-owned passes must be inherited.
+      expect(fn('material', payload, refs)).toBeUndefined();
     });
 
     it('(regression) payload with passes and without parent ref -> returns MaterialAsset with passes, no parentGuid', () => {

package/src/__tests__/pipeline-cache-keying.unit.test.ts

@@ -53,6 +53,18 @@ function specOf(
 describe('cacheKeyOf passKind dimension', () => {
   const SHADER_ID = 'forgeax::default-unlit';
 
+  it('separates authored entry selections within one published module', () => {
+    const base = specOf('custom::two-entries', false);
+    const first = {
+      ...base,
+      shader: { ...base.shader, vertexEntry: 'vs_main', fragmentEntry: 'fs_main' },
+    };
+    const second = { ...base, shader: { ...first.shader, fragmentEntry: 'fs_readability' } };
+    const shadow = { ...base, shader: { ...first.shader, vertexEntry: 'vs_shadow' } };
+    expect(new Set([first, second, shadow].map(cacheKeyOf)).size).toBe(3);
+    expect(cacheKeyOf({ ...first })).toBe(cacheKeyOf(first));
+  });
+
   it('same shaderId + entries produce different keys for forward vs shadow-caster', () => {
     const forwardKey = cacheKeyOf(specOf(SHADER_ID, false, 'forward'));
     const shadowKey = cacheKeyOf(specOf(SHADER_ID, false, 'shadow-caster'));

package/src/__tests__/pipeline-spec.test.ts

@@ -490,6 +490,20 @@ describe('buildPipelineDescriptor (M2-T3-TEST)', () => {
     };
   }
 
+  it('uses the entry selection carried by the pipeline spec', () => {
+    const base = makeForwardSpec();
+    const spec: PipelineSpec = {
+      ...base,
+      shader: { ...base.shader, vertexEntry: 'vs_custom', fragmentEntry: 'fs_readability' },
+    };
+    const descriptor = buildPipelineDescriptor(spec, {
+      vertex: mockVertexModule,
+      fragment: mockFragmentModule,
+    });
+    expect(descriptor.vertex.entryPoint).toBe('vs_custom');
+    expect(descriptor.fragment?.entryPoint).toBe('fs_readability');
+  });
+
   function makeShadowCasterSpec(sampleCount: 1 | 4 = 1): PipelineSpec {
     return {
       shader: { id: 'forgeax::shadow-caster', passKind: 'shadow-caster', variantSet: undefined },

package/src/__tests__/point-light-shadow.dawn.test.ts

@@ -14,8 +14,12 @@
 import { describe, expect, it } from 'vitest';
 import { drawPublished } from './draw-published';
 
-const WIDTH = 512;
-const HEIGHT = 512;
+const LIGHTWEIGHT_DAWN = process.env.FORGEAX_DAWN_LIGHTWEIGHT === '1';
+// The comparison-sampler contract only depends on cube topology and depth
+// ordering. Keep the local/nightly 512px atlas for diagnostics, but avoid
+// allocating six 512px lavapipe depth attachments on the overloaded PR lane.
+const WIDTH = LIGHTWEIGHT_DAWN ? 64 : 512;
+const HEIGHT = LIGHTWEIGHT_DAWN ? 64 : 512;
 const LAYERS = 6; // one cube (6 faces)
 
 // WebGPU bitmask constants per spec (avoids needing @webgpu/types globals
@@ -37,6 +41,11 @@ const navWithGpu = globalThis.navigator as unknown as NavigatorWithGpu | undefin
 const dawnReady =
   typeof globalThis.navigator !== 'undefined' && navWithGpu?.gpu?.requestAdapter !== undefined;
 
+// The renderer/readback e2e includes the first full point-shadow setup. Hosted
+// Linux Dawn cold starts can exceed the project-wide 30-second timeout while
+// still completing inside the bounded Dawn job budget.
+const POINT_LIGHT_SHADOW_DAWN_TEST_TIMEOUT_MS = 120_000;
+
 describe('M0 cube_array comparison sampler (dawn)', () => {
   it.skipIf(!dawnReady)("'dawn-binding-missing' -- dawn.node binding injection failed", () => {
     expect(dawnReady).toBe(true);
@@ -536,8 +545,15 @@ async function doReadPixelsM5(
 }
 
 describe('Round-2 F-3 / Issue 3: createRenderer e2e dawn (T-M5-1)', () => {
+  // The isolated fresh-process Dawn lane can spend ~90s constructing the
+  // shader manifest and two renderer states on lavapipe. Keep this owner-
+  // specific budget above that cold-start cost instead of treating a valid
+  // integration probe as a default-30s timeout failure.
   it.skipIf(!dawnReady)(
     "'createRenderer e2e' -- spawn PointLight + PointLightShadow + cube + camera; renderer.draw runs; frame is non-black AND pixel-differs vs no-shadow baseline",
+    {
+      timeout: POINT_LIGHT_SHADOW_DAWN_TEST_TIMEOUT_MS,
+    },
     async () => {
       // Lazy-load the runtime + manifest builder (matches fxaa-pixel-diff
       // pattern). buildEngineShaderManifest produces the data: URL the
@@ -556,8 +572,11 @@ describe('Round-2 F-3 / Issue 3: createRenderer e2e dawn (T-M5-1)', () => {
       const manifestUrl = `data:application/json,${encodeURIComponent(JSON.stringify(manifest))}`;
 
       const TEX_USAGE_E2E = TEX_USAGE_RENDER_ATTACHMENT | TEX_USAGE_COPY_SRC;
-      const FRAME_W = 128;
-      const FRAME_H = 128;
+      // The end-to-end assertion is non-black output, not a resolution
+      // benchmark. Preserve the local 128px target while bounding the PR
+      // readback and point-shadow atlas work on software Vulkan.
+      const FRAME_W = LIGHTWEIGHT_DAWN ? 64 : 128;
+      const FRAME_H = LIGHTWEIGHT_DAWN ? 64 : 128;
 
       let sharedDevice: GPUDevice | undefined;
       const originalRequestAdapter = globalThis.navigator.gpu.requestAdapter.bind(
@@ -762,7 +781,7 @@ describe('Round-2 F-3 / Issue 3: createRenderer e2e dawn (T-M5-1)', () => {
         },
         {
           component: PointLightShadow,
-          data: { mapSize: 256, nearPlane: 0.1, farPlane: 25 },
+          data: { mapSize: LIGHTWEIGHT_DAWN ? 128 : 256, nearPlane: 0.1, farPlane: 25 },
         },
       );
 

package/src/__tests__/record-worldid-isolation.test.ts

@@ -45,7 +45,7 @@ function expectWorldEntityKeyAt(
 
   for (let i = start; i < end; i++) {
     const l = lines[i];
-    if (l?.includes('worldEntityKey')) {
+    if (l?.includes('worldEntityKey') || l?.includes('instanceCollectionCacheKey')) {
       // Found — passes
       return;
     }
@@ -103,7 +103,6 @@ const SPRITE_FILE = fileURLToPath(
 describe('production-path shared instance bind-group resolver', () => {
   it('sprite identity and sprite-instance paths use the shared resolver', () => {
     const src = readFileSync(SPRITE_FILE, 'utf8');
-    expect(src).toContain('const identityInstBg = resolveGeometryInstancesBindGroup(');
     expect(src).toContain('const spriteInstBg = resolveGeometryInstancesBindGroup(');
     expect(src).toContain('const spriteInstancesBg = resolveGeometryInstancesBindGroup(');
   });
@@ -156,20 +155,11 @@ const SHADOW_FILE = fileURLToPath(
 );
 
 describe('production-path shadow instanceBuffers worldEntityKey', () => {
-  it('shadowInst.cacheKey get uses worldEntityKey', () => {
-    expectWorldEntityKeyAt(
-      SHADOW_FILE,
-      findLine(SHADOW_FILE, 'c.frameState.instanceBuffers.get(', 0),
-      'shadow-pass instanceBuffers.get',
-    );
-  });
-
-  it('shadowInst.cacheKey set uses worldEntityKey', () => {
-    expectWorldEntityKeyAt(
-      SHADOW_FILE,
-      findLine(SHADOW_FILE, 'c.frameState.instanceBuffers.set('),
-      'shadow-pass instanceBuffers.set',
-    );
+  it('shares the world-aware geometry instance residency owner', () => {
+    const src = readFileSync(SHADOW_FILE, 'utf8');
+    expect(src).toMatch(/resolveGeometryInstanceBuffer\(\s*c,\s*entry,/);
+    expect(src).not.toContain('instanceBuffers.get(');
+    expect(src).not.toContain('instanceBuffers.set(');
   });
 
   it('spot shadow uses the shared world-aware caster recorder', () => {
@@ -183,16 +173,6 @@ describe('production-path shadow instanceBuffers worldEntityKey', () => {
   });
 });
 
-describe('production-path shadow shared instance bind-group resolver', () => {
-  it('shadow pass resolves the bind group from the world-aware buffer cache', () => {
-    const src = readFileSync(SHADOW_FILE, 'utf8');
-    expect(src).toContain(
-      'const shadowInstancesBg = resolveGeometryInstancesBindGroup(c, shadowInstanceBuffer);',
-    );
-    expect(src).toContain('worldEntityKey(entry.source.worldId, shadowInst.cacheKey)');
-  });
-});
-
 // ── Fold-bucket negative half NOT worldEntityKey (D-1a #1 invariant) ───────
 
 describe('production-path fold-bucket key NOT worldEntityKey', () => {