@forgeax/engine-runtime 0.1.23 → 0.1.25

package/src/__tests__/ibl-pipeline-cache.cases.unit.test.ts

@@ -0,0 +1,415 @@
+// @ts-nocheck — merged file: indexed-access checks cascade across noUncheckedIndexedAccess for blocks originally outside src/ rootDir
+// Consolidated by feat-20260609-test-pool-startup-reduction-merge-tiny-test-files
+// biome-ignore-all lint/complexity/noUselessLoneBlockStatements: block-scope isolation between merged source files (consolidation paradigm)
+//
+// Source files (N=44):
+//   - packages/runtime/__tests__/antialias-from-f32.test.ts
+//   - packages/runtime/src/__tests__/bloom-gating.test.ts
+//   - packages/runtime/src/__tests__/camera-antialias.test.ts
+//   - packages/runtime/src/__tests__/camera-bloom.test.ts
+//   - packages/runtime/src/__tests__/camera-clear-schema.test.ts
+//   - packages/runtime/src/__tests__/camera-ortho.test.ts
+//   - packages/runtime/src/__tests__/fxaa-intermediate-texture.test.ts
+//   - packages/runtime/src/__tests__/fxaa-pipeline.test.ts
+//   - packages/runtime/src/__tests__/ibl-pipeline-cache.test.ts
+//   - packages/runtime/src/__tests__/ibl-runtime-probe.test.ts
+//   - packages/runtime/src/__tests__/render-system-record-warn-once.test.ts
+//   - packages/runtime/src/__tests__/shadow-skip-non-triangle.test.ts
+//   - packages/runtime/src/__tests__/skin-errors-kebab-case.test.ts
+//   - packages/runtime/src/__tests__/skybox-error.test.ts
+//   - packages/runtime/src/__tests__/skybox-shader-compile.test.ts
+//   - packages/runtime/src/__tests__/skylight-bind-group.test.ts
+//   - packages/runtime/src/__tests__/skylight-component.test.ts
+//   - packages/runtime/src/__tests__/skylight-fallback-path.test.ts
+//   - packages/runtime/src/__tests__/skylight-pipeline-layout.test.ts
+//   - packages/runtime/src/__tests__/tonemap-hdr-target.test.ts
+//   - packages/runtime/src/__tests__/tonemap-pipeline-split.test.ts
+//   - packages/runtime/src/__tests__/zero-camera-clear-fallback.test.ts
+//   - packages/runtime/src/components/__tests__/skin.test.ts
+//   - packages/runtime/src/systems/__tests__/advance-animation-player.test.ts
+//   - packages/runtime/src/systems/__tests__/graph-skybox.test.ts
+//   - packages/runtime/src/systems/__tests__/propagate-transforms.test.ts
+//   - packages/runtime/src/systems/__tests__/skin-cap-gate.test.ts
+//   - packages/runtime/src/systems/__tests__/skin-instances-coexist.test.ts
+//   - packages/runtime/src/systems/__tests__/skin-palette-extract.test.ts
+//   - packages/runtime/src/systems/__tests__/skin-pipeline-routing.test.ts
+//   - packages/runtime/src/systems/__tests__/skybox-extract.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-boundary.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-clamp.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-frame-duration-negative.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-frame-duration-zero.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-loop.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-override-probe.test.ts
+//   - packages/runtime/src/systems/__tests__/sprite-animation-tick-regions-mismatch.test.ts
+//   - packages/runtime/src/systems/__tests__/tonemap.test.ts
+//   - packages/runtime/src/systems/__tests__/transparent-sort-config-get.test.ts
+//   - packages/runtime/src/systems/__tests__/transparent-sort-config-set.test.ts
+//   - packages/runtime/src/systems/__tests__/transparent-sort.test.ts
+//   - packages/runtime/src/__tests__/render-system-multi-material.test.ts
+//   - packages/runtime/src/__tests__/render-system-record-submesh.test.ts
+//
+// Paradigm: each block-scope wraps a source file. ancestorTitles[0] is the
+// source-preserved inner describe (NOT the source filename for these 3 files
+// — recovery path: vitest report ancestorTitles -> grep this file -> upstream
+// `// ─── from <name>.test.ts ───` block separator -> source filename).
+// Top-level imports merged + deduped.
+
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { AnimationPlayer } from '@forgeax/engine-animation';
+import type { AssetRuntimeErrorCode } from '@forgeax/engine-assets-runtime';
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import type { EntityHandle, World as WorldType } from '@forgeax/engine-ecs';
+import { ENTITY_NULL_RAW, World } from '@forgeax/engine-ecs';
+import { SpriteAnimationInvalidError } from '@forgeax/engine-ecs/projection';
+import { mat4, vec3 } from '@forgeax/engine-math';
+import type { RenderErrorCode, Renderer as RendererType } from '@forgeax/engine-render';
+import {
+  ANTIALIAS_FXAA,
+  ANTIALIAS_NONE,
+  BLOOM_DISABLED,
+  BLOOM_ENABLED,
+  CAMERA_PROJECTION_ORTHOGRAPHIC,
+  CAMERA_PROJECTION_PERSPECTIVE,
+  Camera,
+  MeshFilter,
+  MeshRenderer,
+  SkyboxBackground,
+  Skylight,
+} from '@forgeax/engine-render';
+import type { BindGroupEntry, Buffer, Sampler, Texture, TextureView } from '@forgeax/engine-rhi';
+import { ok as rhiOk } from '@forgeax/engine-rhi';
+import { ChildOf, Name, propagateTransforms, Transform } from '@forgeax/engine-scene';
+import { TONEMAP_LUMINANCE_EPSILON } from '@forgeax/engine-shader';
+import type { SkinErrorCode } from '@forgeax/engine-skinning';
+import {
+  Skin,
+  SkinInstancesCoexistForbiddenError,
+  SkinJointCountExceededError,
+  SkinJointDespawnedError,
+  SkinJointPathUnresolvedError,
+} from '@forgeax/engine-skinning';
+import type {
+  Handle,
+  MaterialAsset,
+  MeshAsset,
+  SkeletonAsset,
+  TextureFormat,
+} from '@forgeax/engine-types';
+import { toShared } from '@forgeax/engine-types';
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { worldInternal } from '../../../ecs/src/world-internal';
+import {
+  SPRITE_PLAYBACK_MODE_CLAMP,
+  SPRITE_PLAYBACK_MODE_LOOP,
+  SpriteAnimation,
+  SpriteRegionOverride,
+} from '../../../render/src/components';
+import {
+  type CameraProjection,
+  cameraProjectionFromF32,
+} from '../../../render/src/components/camera';
+import {
+  assembleMaterialWithSkylightEntries,
+  createSkylightFallback,
+  mergeSkylightIntoMaterialBgl,
+} from '../../../render/src/ibl/skylight-bind-group';
+import { buildPbrPipelineLayouts, buildUnlitMaterialBgl } from '../../../render/src/pbr-pipeline';
+import { INSTANCE_STORAGE_STRIDE_FLOATS } from '../../../render/src/record/mesh-ssbo';
+import { selectSwapChainFormat } from '../../../render/src/render-system';
+import { createSkinPaletteAllocator } from '../../../render/src/systems/skin-palette-allocator';
+import type { TransparentEntry } from '../../../render/src/systems/transparent-sort-config';
+import { standardMaterialShaderVariants } from './helpers/standard-material-manifest';
+import { drawWithOwners } from './renderer-test-utils';
+
+function componentFieldType(component: { fields: Record<string, { type: string }> }, name: string) {
+  return component.fields[name]?.type;
+}
+
+function componentFieldDefault(
+  component: { fields: Record<string, { default?: unknown }> },
+  name: string,
+) {
+  return component.fields[name]?.default;
+}
+
+function componentSchemaTypes(component: { fields: Record<string, { type: string }> }) {
+  return Object.fromEntries(
+    Object.entries(component.fields).map(([name, field]) => [name, field.type]),
+  );
+}
+
+afterEach(() => vi.restoreAllMocks());
+
+type RendererErrorObservation = {
+  readonly code: string;
+  readonly detail?: unknown;
+  readonly hint?: string;
+};
+
+function unwrapRendererError(value: unknown): RendererErrorObservation {
+  let current = value as RendererErrorObservation;
+  while (
+    current.detail !== undefined &&
+    typeof current.detail === 'object' &&
+    current.detail !== null
+  ) {
+    const cause = (current.detail as { cause?: unknown }).cause;
+    if (
+      cause === undefined ||
+      typeof cause !== 'object' ||
+      cause === null ||
+      typeof (cause as { code?: unknown }).code !== 'string'
+    ) {
+      break;
+    }
+    current = cause as RendererErrorObservation;
+  }
+  return current;
+}
+
+function subscribeRendererErrors(
+  renderer: RendererType,
+  listener: (error: RendererErrorObservation) => void,
+): () => void {
+  return renderer.subscribe((event) => {
+    if (event.kind === 'error') listener(unwrapRendererError(event.error));
+  });
+}
+
+function drawPublished(renderer: RendererType, world: WorldType) {
+  const attached = renderer.attach(world);
+  if (!attached.ok) throw attached.error;
+  world.update().unwrap();
+  return drawWithOwners(renderer, world);
+}
+
+// feat-20260704-runtime-tier1-decomposition M2 / w12: reconstitute the
+// eliminated top-level RuntimeErrorCode aggregate union (D-3) as a test-local
+// alias so the exhaustive-switch bodies below stay byte-identical (AC-09).
+type RuntimeLayerErrorCode = RenderErrorCode | AssetRuntimeErrorCode | SkinErrorCode;
+
+import {
+  AnimationTargetId,
+  bindAnimationTargets,
+  advanceAnimationPlayer as canonicalAdvanceAnimationPlayer,
+} from '@forgeax/engine-animation';
+import { deriveAnimationTargetId } from '@forgeax/engine-animation/target-id';
+import { DeviceScope } from '../../../render/src/device/device-scope';
+import { GpuBuffer } from '../../../render/src/gpu-resource';
+import { getOrCreateIblCache, hasIblCache } from '../../../render/src/ibl/IblPipelineCache';
+import {
+  disposeInstanceBuffers,
+  type InstanceBufferCacheEntry,
+} from '../../../render/src/instance-buffer-cache';
+import { standardPipeline as urpPipeline } from '../../../render/src/pipeline/standard-pipeline';
+import { ZERO_CAMERA_CLEAR_FALLBACK } from '../../../render/src/record/frame-snapshot';
+import {
+  warnMultiLightDirectional,
+  warnMultiLightPoint,
+  warnMultiLightSpot,
+} from '../../../render/src/record/helpers';
+import type { CameraSnapshot } from '../../../render/src/render-contract';
+import {
+  type ExtractedLights,
+  extractFrame,
+  extractFrames,
+  prepareExtractContext,
+} from '../../../render/src/render-system-extract';
+import {
+  getTransparentSortConfig,
+  setTransparentSortConfig,
+  TRANSPARENT_SORT_CONFIG_KEY,
+  TRANSPARENT_SORT_MODE_LAYER_Y,
+  TRANSPARENT_SORT_MODE_LAYER_YZ,
+  TRANSPARENT_SORT_MODE_LAYER_Z,
+} from '../../../render/src/systems/transparent-sort-config';
+import { spriteAnimationTickSystem } from '../systems/sprite-animation-tick';
+import { REC709_LUMA_WEIGHTS, tonemapReinhardLuminance } from '../systems/tonemap';
+import { transparentSortEntries } from '../systems/transparent-sort';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+
+void [
+  ANTIALIAS_FXAA,
+  ANTIALIAS_NONE,
+  AnimationPlayer,
+  AnimationTargetId,
+  AssetRegistry,
+  BLOOM_DISABLED,
+  BLOOM_ENABLED,
+  CAMERA_PROJECTION_ORTHOGRAPHIC,
+  CAMERA_PROJECTION_PERSPECTIVE,
+  Camera,
+  ChildOf,
+  DeviceScope,
+  ENTITY_NULL_RAW,
+  GpuBuffer,
+  INSTANCE_STORAGE_STRIDE_FLOATS,
+  MeshFilter,
+  MeshRenderer,
+  Name,
+  REC709_LUMA_WEIGHTS,
+  SPRITE_PLAYBACK_MODE_CLAMP,
+  SPRITE_PLAYBACK_MODE_LOOP,
+  Skin,
+  SkinInstancesCoexistForbiddenError,
+  SkinJointCountExceededError,
+  SkinJointDespawnedError,
+  SkinJointPathUnresolvedError,
+  SkyboxBackground,
+  Skylight,
+  SpriteAnimation,
+  SpriteAnimationInvalidError,
+  SpriteRegionOverride,
+  TONEMAP_LUMINANCE_EPSILON,
+  TRANSPARENT_SORT_CONFIG_KEY,
+  TRANSPARENT_SORT_MODE_LAYER_Y,
+  TRANSPARENT_SORT_MODE_LAYER_YZ,
+  TRANSPARENT_SORT_MODE_LAYER_Z,
+  Transform,
+  World,
+  ZERO_CAMERA_CLEAR_FALLBACK,
+  afterEach,
+  assembleMaterialWithSkylightEntries,
+  beforeAll,
+  beforeEach,
+  bindAnimationTargets,
+  buildPbrPipelineLayouts,
+  buildUnlitMaterialBgl,
+  cameraProjectionFromF32,
+  canonicalAdvanceAnimationPlayer,
+  componentFieldDefault,
+  componentFieldType,
+  componentSchemaTypes,
+  createSkinPaletteAllocator,
+  createSkylightFallback,
+  deriveAnimationTargetId,
+  describe,
+  disposeInstanceBuffers,
+  drawPublished,
+  drawWithOwners,
+  expect,
+  extractFrame,
+  extractFrames,
+  fileURLToPath,
+  getOrCreateIblCache,
+  getTransparentSortConfig,
+  hasIblCache,
+  it,
+  makeMockShaderRegistry,
+  mat4,
+  mergeSkylightIntoMaterialBgl,
+  prepareExtractContext,
+  propagateTransforms,
+  readFileSync,
+  resolve,
+  rhiOk,
+  selectSwapChainFormat,
+  setTransparentSortConfig,
+  spriteAnimationTickSystem,
+  standardMaterialShaderVariants,
+  subscribeRendererErrors,
+  toShared,
+  tonemapReinhardLuminance,
+  transparentSortEntries,
+  unwrapRendererError,
+  urpPipeline,
+  vec3,
+  vi,
+  warnMultiLightDirectional,
+  warnMultiLightPoint,
+  warnMultiLightSpot,
+  worldInternal,
+];
+type __MergedKeep =
+  | AssetRuntimeErrorCode
+  | BindGroupEntry
+  | Buffer
+  | CameraProjection
+  | CameraSnapshot
+  | EntityHandle
+  | ExtractedLights
+  | Handle
+  | InstanceBufferCacheEntry
+  | MaterialAsset
+  | MeshAsset
+  | RenderErrorCode
+  | RendererErrorObservation
+  | RendererType
+  | RuntimeLayerErrorCode
+  | Sampler
+  | SkeletonAsset
+  | SkinErrorCode
+  | Texture
+  | TextureFormat
+  | TextureView
+  | TransparentEntry
+  | WorldType;
+
+{
+  // --- from ibl-pipeline-cache.test.ts ---
+
+  describe('t11 - IblPipelineCache counter invariant + deferred-replay', () => {
+    // (a) IblPipelineCache initializes one cache per DeviceScope generation
+    it('IblPipelineCache maintains per-scope ownership via getOrCreateIblCache', () => {
+      const scope1 = DeviceScope.create(1, 'systems-test-1');
+      const scope2 = DeviceScope.create(2, 'systems-test-2');
+
+      const cache1 = getOrCreateIblCache(scope1);
+      const cache2 = getOrCreateIblCache(scope2);
+
+      // Different devices get different cache instances.
+      expect(cache1).not.toBe(cache2);
+
+      // Same device returns same instance.
+      expect(getOrCreateIblCache(scope1)).toBe(cache1);
+
+      // hasIblCache confirms registration.
+      expect(hasIblCache(scope1)).toBe(true);
+      expect(hasIblCache(scope2)).toBe(true);
+      expect(hasIblCache(DeviceScope.create(3, 'systems-test-3'))).toBe(false);
+    });
+
+    // (d) counters initialized at 0
+    it('counters are initialized at 0 before any pass execution', () => {
+      const cache = getOrCreateIblCache(DeviceScope.create(4, 'systems-test-4'));
+      expect(cache.irradianceBakeCount).toBe(0);
+      expect(cache.prefilterBakeCount).toBe(0);
+      expect(cache.brdfLutBakeCount).toBe(0);
+    });
+
+    // (b) iblPrepass counters === 1 after pass execution
+    // These tests verify the counter slots exist and can be incremented.
+    // The actual GPU pass execution that sets these counters is wired in
+    // uploadCubemapFromEquirect (t20 in asset-registry.ts).
+    it('iblPrepass counters can be incremented post-execution', () => {
+      const cache = getOrCreateIblCache(DeviceScope.create(5, 'systems-test-5'));
+      cache.irradianceBakeCount += 1;
+      cache.prefilterBakeCount += 1;
+      cache.brdfLutBakeCount += 1;
+      expect(cache.irradianceBakeCount).toBe(1);
+      expect(cache.prefilterBakeCount).toBe(1);
+      expect(cache.brdfLutBakeCount).toBe(1);
+    });
+
+    it('iblPrepass counters stay independent across devices', () => {
+      const scopeA = DeviceScope.create(6, 'systems-test-6');
+      const scopeB = DeviceScope.create(7, 'systems-test-7');
+      const cacheA = getOrCreateIblCache(scopeA);
+      const cacheB = getOrCreateIblCache(scopeB);
+
+      cacheA.irradianceBakeCount += 1;
+      cacheB.prefilterBakeCount += 1;
+
+      expect(cacheA.irradianceBakeCount).toBe(1);
+      expect(cacheA.prefilterBakeCount).toBe(0);
+      expect(cacheB.irradianceBakeCount).toBe(0);
+      expect(cacheB.prefilterBakeCount).toBe(1);
+    });
+
+    // (c) configureGpuDevice deferred-replay replays pending upload
+    // This is exercised by the dawn-level integration tests (asset-registry
+    // deferred path) rather than unit-level mock assertions.
+  });
+}

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

@@ -0,0 +1,161 @@
+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;
+}
+
+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();
+}, 60000);