@forgeax/engine-render 0.1.23 → 0.1.24

package/src/record/__tests__/frame-targets-recovery.unit.test.ts

@@ -0,0 +1,60 @@
+import type { RhiCanvasContext, RhiDevice, Texture, TextureView } from '@forgeax/engine-rhi';
+import { err, ok, RhiError } from '@forgeax/engine-rhi';
+import { describe, expect, it, vi } from 'vitest';
+import { acquireSwapChainTarget } from '../frame-targets';
+import type { PipelineState, RenderSystemInternals } from '../render-context';
+
+function device(): RhiDevice {
+  return {
+    caps: { backendKind: 'webgpu', storageBuffer: true },
+    limits: {},
+    createTextureView: vi.fn(() => ok({} as TextureView)),
+  } as unknown as RhiDevice;
+}
+
+function unavailableSurfaceError(): RhiError {
+  return new RhiError({
+    code: 'webgpu-runtime-error',
+    expected: 'the surface has a current texture',
+    hint: 'configure the surface and retry',
+  });
+}
+
+describe('acquireSwapChainTarget recovery', () => {
+  it('resolves the recorder device before reconfiguring a recovered surface', () => {
+    const recorderDevice = device();
+    const configuredDevice = device();
+    const texture = {} as Texture;
+    const getCurrentTexture = vi
+      .fn()
+      .mockReturnValueOnce(err(unavailableSurfaceError()))
+      .mockReturnValueOnce(ok(texture));
+    const configure = vi.fn(() => ok(undefined));
+    const context = { configure, getCurrentTexture } as unknown as RhiCanvasContext;
+    const resolveSurfaceDevice = vi.fn(() => ok(configuredDevice));
+    const internals = {
+      context,
+      device: recorderDevice,
+      canvas: { width: 800, height: 600 },
+      resolveSurfaceDevice,
+      errorRegistry: { fire: vi.fn() },
+      healthRegistry: { fire: vi.fn() },
+    } as unknown as RenderSystemInternals;
+    const pipelineState = {
+      device: recorderDevice,
+      format: 'bgra8unorm',
+      colorAttachmentFormat: 'bgra8unorm',
+      perPassResources: { configured: false },
+    } as unknown as PipelineState;
+
+    const result = acquireSwapChainTarget(internals, pipelineState);
+
+    expect(result).toMatchObject({ currentTexture: texture, targetW: 800, targetH: 600 });
+    expect(resolveSurfaceDevice).toHaveBeenCalledWith(recorderDevice);
+    expect(configure).toHaveBeenCalledWith(
+      expect.objectContaining({ device: configuredDevice, format: 'bgra8unorm' }),
+    );
+    expect(getCurrentTexture).toHaveBeenCalledTimes(2);
+    expect(pipelineState.perPassResources.configured).toBe(true);
+  });
+});

package/src/record/__tests__/main-pass-geometry.unit.test.ts

@@ -1,5 +1,8 @@
 import { describe, expect, it } from 'vitest';
-import { geometryRenderStateForPass } from '../main-pass-geometry';
+import {
+  geometryRenderStateForPass,
+  requestsStandardTransmissionVariant,
+} from '../main-pass-geometry';
 
 describe('geometry pass render state', () => {
   it('keeps the main depth authority while admitting equal temporal depth', () => {
@@ -45,3 +48,25 @@ describe('geometry pass render state', () => {
     expect(accepted).toEqual([visibleDepth]);
   });
 });
+
+describe('Standard transmission variant selection', () => {
+  it('uses authored transmission presence instead of the canonical reserved schema', () => {
+    const baseOnly = {
+      materialShaderId: 'forgeax::default-standard-pbr',
+      paramSnapshot: { alphaCutoff: 0.25 },
+    } as const;
+    const transmission = {
+      materialShaderId: 'forgeax::default-standard-pbr',
+      paramSnapshot: { transmission: 0 },
+    } as const;
+
+    expect(requestsStandardTransmissionVariant(baseOnly)).toBe(false);
+    expect(requestsStandardTransmissionVariant(transmission)).toBe(true);
+    expect(
+      requestsStandardTransmissionVariant({
+        materialShaderId: 'custom::standard',
+        paramSnapshot: { transmission: 1 },
+      }),
+    ).toBe(false);
+  });
+});

package/src/record/__tests__/mesh-ssbo.unit.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { getOrCreateFromChain } from '../mesh-ssbo';
+
+describe('mesh bind-group cache chains', () => {
+  it('keeps variable-depth material resource chains isolated', () => {
+    const root = new WeakMap<object, unknown>();
+    const shared = { shared: true };
+    const coatSampler = { coatSampler: true };
+    const coatTexture = { coatTexture: true };
+    const counts = { createBindGroup: 0, keys: [] as string[] };
+    const long = getOrCreateFromChain(
+      root,
+      [shared, coatSampler, coatTexture],
+      'material-shared',
+      () => ({ id: 'long' }) as never,
+      counts,
+    );
+    const short = getOrCreateFromChain(
+      root,
+      [shared, coatSampler],
+      'material-shared',
+      () => ({ id: 'short' }) as never,
+      counts,
+    );
+
+    expect(
+      getOrCreateFromChain(
+        root,
+        [shared, coatSampler],
+        'material-shared',
+        () => ({ id: 'unexpected' }) as never,
+        counts,
+      ),
+    ).toBe(short);
+    expect(long).not.toBe(short);
+    expect(counts.createBindGroup).toBe(2);
+  });
+});

package/src/record/__tests__/recovery-pipeline.unit.test.ts

@@ -0,0 +1,124 @@
+import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
+import { describe, expect, it } from 'vitest';
+import { makeZeroCameraFallbackSnapshot, type ValidatedRenderable } from '../frame-snapshot';
+import {
+  createRecoveryColdWorkGuard,
+  prepareRecoveryPipelineReadiness,
+} from '../recovery-pipeline';
+import type { PipelineState, RenderSystemInternals } from '../render-context';
+
+function probeRenderable(probe: boolean): ValidatedRenderable {
+  const material = {
+    baseColor: [1, 1, 1],
+    metallic: 0,
+    roughness: 1,
+    materialShaderId: 'forgeax::default-standard-pbr',
+  } as never;
+  return {
+    source: {
+      material,
+      materials: [material],
+      ...(probe ? { probeBlendRecord: {} } : {}),
+    },
+    mesh: {
+      layoutProjection: deriveVertexLayoutProjection({
+        position: new Float32Array(0),
+        normal: new Float32Array(0),
+        uv: new Float32Array(0),
+        tangent: new Float32Array(0),
+      }),
+      indexFormat: 'uint32',
+      submeshes: [
+        {
+          indexOffset: 0,
+          indexCount: 3,
+          vertexCount: 3,
+          topology: 'triangle-list',
+          materialSlot: 0,
+        },
+      ],
+    },
+  } as never;
+}
+
+function recoveryReadinessFor(
+  renderable: ValidatedRenderable,
+  reflectionFallbackAvailable = false,
+) {
+  const pipeline = {} as never;
+  const internals = {
+    device: { caps: { backendKind: 'webgpu', storageBuffer: true } },
+    getMaterialShaderPipelineEntry: (..._args: unknown[]) => ({
+      pipeline,
+      group2Contract: 'cluster' as const,
+    }),
+  } as unknown as RenderSystemInternals;
+  const pipelineState = {
+    colorAttachmentFormat: 'bgra8unorm',
+  } as unknown as PipelineState;
+  return prepareRecoveryPipelineReadiness({
+    internals,
+    pipelineState,
+    camera: makeZeroCameraFallbackSnapshot(),
+    standardLighting: { kind: 'no-local-lights' } as never,
+    validated: [renderable],
+    dispatch: [],
+    shadowCastersActive: false,
+    splitLdrSprite: false,
+    reflectionFallbackAvailable,
+  });
+}
+
+describe('recovery first-frame cold-work guard', () => {
+  it('prepares the probe-enabled Standard PBR variant used by the live record path', () => {
+    const readiness = recoveryReadinessFor(probeRenderable(true));
+    const standardPbr = readiness.pipelineSpecs.find(
+      (spec) => spec.shader.id === 'forgeax::default-standard-pbr',
+    );
+
+    expect(standardPbr?.shader.variantSet).toContain('PROBE_BLEND_AVAILABLE=true');
+  });
+
+  it('does not add the probe ABI to a Standard PBR renderable without a record', () => {
+    const readiness = recoveryReadinessFor(probeRenderable(false));
+    const standardPbr = readiness.pipelineSpecs.find(
+      (spec) => spec.shader.id === 'forgeax::default-standard-pbr',
+    );
+
+    expect(standardPbr?.shader.variantSet).not.toContain('PROBE_BLEND_AVAILABLE=true');
+  });
+
+  it('prepares the Standard PBR reflection fallback MRT variant', () => {
+    const readiness = recoveryReadinessFor(probeRenderable(false), true);
+    const standardPbr = readiness.pipelineSpecs.find(
+      (spec) => spec.shader.id === 'forgeax::default-standard-pbr',
+    );
+
+    expect(standardPbr?.shader.variantSet).toContain('REFLECTION_FALLBACK_AVAILABLE=true');
+    expect(standardPbr?.attachments.colorFormats).toEqual(['rgba16float', 'rgba16float']);
+  });
+
+  it('accepts a prepared candidate with no first-frame cold work', () => {
+    const guard = createRecoveryColdWorkGuard();
+
+    guard.arm();
+    expect(() => guard.finish()).not.toThrow();
+    expect(() => guard.finish()).not.toThrow();
+  });
+
+  it.each([
+    [
+      'pipeline',
+      (guard: ReturnType<typeof createRecoveryColdWorkGuard>) => guard.notePipelineColdWork(),
+    ],
+    [
+      'upload',
+      (guard: ReturnType<typeof createRecoveryColdWorkGuard>) => guard.noteUploadColdWork(),
+    ],
+  ] as const)('hard-fails a first-frame %s miss before submission', (_kind, note) => {
+    const guard = createRecoveryColdWorkGuard();
+
+    guard.arm();
+    expect(() => note(guard)).toThrow(/recovery first frame performed cold/);
+  });
+});

package/src/record/__tests__/sprite-material-abi.unit.test.ts

@@ -1,10 +1,27 @@
 import type { Buffer, Sampler, TextureView } from '@forgeax/engine-rhi';
 import { describe, expect, it } from 'vitest';
 import { assembleMaterialWithSkylightEntries } from '../../ibl/skylight-bind-group';
+import { defaultViewForUserRegionField } from '../main-pass-material';
 import { buildSpritePassBaseMaterialEntries } from '../main-pass-sprite-draws';
 import type { PipelineState } from '../render-context';
 
 describe('sprite Standard material ABI', () => {
+  it('uses the dedicated neutral anisotropy fallback instead of white', () => {
+    const white = {} as TextureView;
+    const anisotropy = {} as TextureView;
+    const pipelineState = {
+      defaultWhiteTextureView: white,
+      defaultAnisotropyTextureView: anisotropy,
+      defaultNormalTextureView: {} as TextureView,
+      fallbackTextureView: {} as TextureView,
+    } as PipelineState;
+
+    expect(defaultViewForUserRegionField('anisotropyTexture', pipelineState)).toBe(anisotropy);
+    expect(defaultViewForUserRegionField('baseColorTexture', pipelineState)).toBe(
+      pipelineState.fallbackTextureView,
+    );
+  });
+
   it('covers transmission and thickness before IBL injection', () => {
     const sampler = {} as Sampler;
     const white = {} as TextureView;
@@ -21,14 +38,12 @@ describe('sprite Standard material ABI', () => {
     const entries = buildSpritePassBaseMaterialEntries(pipelineState, spriteTexture);
 
     expect(entries.map((entry) => entry.binding)).toEqual([
-      0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+      0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
     ]);
     expect(entries[13]).toMatchObject({ binding: 13, resource: { kind: 'sampler' } });
     expect(entries[14]).toMatchObject({ binding: 14, resource: { kind: 'textureView' } });
-    expect(entries[15]).toMatchObject({ binding: 15, resource: { kind: 'sampler' } });
-    expect(entries[16]).toMatchObject({ binding: 16, resource: { kind: 'textureView' } });
     expect(entries[2]?.resource).toMatchObject({ kind: 'textureView', value: spriteTexture });
-    expect(entries).toHaveLength(17);
+    expect(entries).toHaveLength(15);
 
     const merged = assembleMaterialWithSkylightEntries(entries, {
       irradianceView: {} as TextureView,
@@ -39,19 +54,19 @@ describe('sprite Standard material ABI', () => {
       brdfLutSampler: sampler,
       intensityBuffer: {} as Buffer,
     });
-    expect(merged[17]).toMatchObject({
-      binding: 17,
+    expect(merged[15]).toMatchObject({
+      binding: 15,
       resource: { kind: 'textureView' },
     });
-    expect(merged[24]).toMatchObject({
-      binding: 24,
+    expect(merged[22]).toMatchObject({
+      binding: 22,
       resource: { kind: 'sampler', value: sampler },
     });
-    expect(merged[25]).toMatchObject({
-      binding: 25,
+    expect(merged[23]).toMatchObject({
+      binding: 23,
       resource: { kind: 'textureView' },
     });
-    expect(merged).toHaveLength(26);
+    expect(merged).toHaveLength(24);
 
     const backdrop = {} as TextureView;
     const active = assembleMaterialWithSkylightEntries(
@@ -67,8 +82,8 @@ describe('sprite Standard material ABI', () => {
       },
       { sampler, backdropView: backdrop },
     );
-    expect(active[25]).toMatchObject({
-      binding: 25,
+    expect(active[23]).toMatchObject({
+      binding: 23,
       resource: { kind: 'textureView', value: backdrop },
     });
   });

package/src/record/__tests__/standard-pbr-ubo-layout.unit.test.ts

@@ -14,7 +14,7 @@ describe('Standard PBR UBO layout', () => {
       derived.coordinateRecords.map((record) => [record.parameter, record.offset]),
     );
 
-    expect(derived.totalBytes).toBe(384);
+    expect(derived.totalBytes).toBe(736);
     expect(numeric.get('normalScale')).toBe(92);
     expect(numeric.get('transmission')).toBe(96);
     expect(numeric.get('ior')).toBe(100);
@@ -26,6 +26,26 @@ describe('Standard PBR UBO layout', () => {
     expect(coordinates.get('thicknessTexture')).toBe(352);
   });
 
+  it('reserves the physical-layer tail required by the clearcoat shader ABI', () => {
+    const material = {
+      baseColor: vec3.create(0.7, 0.7, 0.7),
+      metallic: 0,
+      roughness: 0.4,
+      materialShaderId: 'forgeax::default-standard-pbr',
+      materialParamSchema: DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
+      paramSnapshot: {
+        clearcoat: 0.8,
+        clearcoatRoughness: 0.2,
+        clearcoatNormalScale: 0.75,
+      },
+    } satisfies MaterialSnapshot;
+    const payload = buildPbrMaterialUboPayload(material);
+    const f32 = new Float32Array(payload.buffer);
+
+    expect(payload.byteLength).toBe(736);
+    expect(f32.slice(108, 111)).toEqual(new Float32Array([0.8, 0.2, 0.75]));
+  });
+
   it('writes transmission scalars and defaults at the reflected offsets', () => {
     const material = {
       baseColor: vec3.create(0.7, 0.7, 0.7),
@@ -33,6 +53,7 @@ describe('Standard PBR UBO layout', () => {
       roughness: 0.4,
       normalScale: 0.25,
       materialShaderId: 'forgeax::default-standard-pbr',
+      materialParamSchema: DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
       paramSnapshot: {
         transmission: 0.75,
         ior: 1.6,
@@ -48,7 +69,7 @@ describe('Standard PBR UBO layout', () => {
     );
   });
 
-  it('uses all eight identity coordinate records in the no-snapshot fallback', () => {
+  it('uses all seven user-region identity coordinate records in the no-snapshot fallback', () => {
     const material = {
       baseColor: vec3.create(0.7, 0.7, 0.7),
       metallic: 0,
@@ -60,8 +81,30 @@ describe('Standard PBR UBO layout', () => {
     applyMaterialTextureUvScales(payload, material, new World());
 
     const f32 = new Float32Array(payload.buffer);
-    expect(f32.slice(32, 96)).toEqual(
-      new Float32Array(Array(8).fill([0, 0, 1, 1, 0, 0, 1, 1]).flat()),
+    expect(f32.slice(32, 88)).toEqual(
+      new Float32Array(Array(7).fill([0, 0, 1, 1, 0, 0, 1, 1]).flat()),
     );
   });
+
+  it('keeps the physical tail intact when standard coordinates are projected', () => {
+    const material = {
+      baseColor: vec3.create(0.7, 0.7, 0.7),
+      metallic: 0,
+      roughness: 0.4,
+      materialShaderId: 'forgeax::default-standard-pbr',
+      materialParamSchema: DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
+      paramSnapshot: {
+        clearcoat: 1,
+        clearcoatRoughness: 0.18,
+        clearcoatNormalScale: 0.75,
+      },
+    } satisfies MaterialSnapshot;
+    const payload = buildPbrMaterialUboPayload(material);
+
+    applyMaterialTextureUvScales(payload, material, new World());
+
+    const f32 = new Float32Array(payload.buffer);
+    expect(f32.slice(108, 111)).toEqual(new Float32Array([1, 0.18, 0.75]));
+    expect(f32.slice(32, 40)).toEqual(new Float32Array([0, 0, 1, 1, 0, 0, 1, 1]));
+  });
 });

package/src/record/__tests__/temporal-payload.unit.test.ts

@@ -2,7 +2,7 @@ import { vec3 } from '@forgeax/engine-math';
 import type { Buffer, RhiQueue } from '@forgeax/engine-rhi';
 import { describe, expect, it } from 'vitest';
 import type { CameraSnapshot } from '../../render-contract';
-import type { RenderableSnapshot, SpotLightSnapshot } from '../../render-system-extract';
+import type { RenderableSnapshot } from '../../render-system-extract';
 import type { TemporalView } from '../../temporal/temporal-view';
 import type { ValidatedRenderable } from '../frame-snapshot';
 import { uploadMeshSsboBatch } from '../mesh-ssbo';
@@ -98,27 +98,8 @@ function temporalView(): TemporalView {
 }
 
 describe('temporal GPU payloads', () => {
-  it('publishes a projector-only SpotLight matrix into the explicit lane-0 contract', () => {
+  it('keeps the zero-directional fallback direction finite and unscaled', () => {
     const { queue, uploads } = recordingQueue();
-    const projectorMatrix = translatedMatrix(9);
-    const projector: SpotLightSnapshot = {
-      kind: 'spot',
-      entity: 4,
-      position: vec3.create(0, 2, 0),
-      direction: vec3.create(0, -1, 0),
-      color: vec3.create(1, 1, 1),
-      intensity: 1,
-      invRangeSquared: 0.04,
-      cosInner: 0.95,
-      cosOuter: 0.8,
-      castShadow: false,
-      lightViewProj: projectorMatrix,
-      mapSize: 512,
-      nearPlane: 0.1,
-      farPlane: 25,
-      shadowAtlasTile: -1,
-      projectorAsset: { kind: 'texture' } as never,
-    };
     writeViewUbo(
       queue,
       {} as Buffer,
@@ -126,19 +107,20 @@ describe('temporal GPU payloads', () => {
       {
         kind: 'directional',
         direction: vec3.create(0, -1, 0),
-        color: vec3.create(1, 1, 1),
-        intensity: 1,
+        color: vec3.create(0, 0, 0),
+        intensity: 0,
       },
-      { point: [], spot: [projector] } as never,
-      [projector],
-      undefined,
-      0,
+      { point: [], spot: [] } as never,
+      [],
     );
+
     const payload = new Float32Array(uploads[0]?.buffer ?? new ArrayBuffer(0));
-    expect(payload[132 + 12]).toBe(9);
+    expect(Array.from(payload.slice(16, 19))).toEqual([0, -1, 0]);
+    expect(Array.from(payload.slice(20, 23))).toEqual([0, 0, 0]);
+    expect(Array.from(payload.slice(16, 23)).every(Number.isFinite)).toBe(true);
   });
 
-  it('writes temporal current/previous projection after the spot-light lanes', () => {
+  it('keeps directional orientation independent from light intensity', () => {
     const { queue, uploads } = recordingQueue();
     writeViewUbo(
       queue,
@@ -146,28 +128,20 @@ describe('temporal GPU payloads', () => {
       camera(),
       {
         kind: 'directional',
-        direction: vec3.create(0, -1, 0),
+        direction: vec3.create(0.25, -0.5, 0.75),
         color: vec3.create(1, 1, 1),
-        intensity: 1,
+        intensity: 4,
       },
       { point: [], spot: [] } as never,
       [],
-      temporalView(),
     );
 
     const payload = new Float32Array(uploads[0]?.buffer ?? new ArrayBuffer(0));
-    expect(payload.length).toBe(240);
-    expect(payload[196]).toBeCloseTo(Math.sqrt(3));
-    expect(payload[212]).toBe(3);
-    expect(payload[228]).toBeCloseTo(0.1);
-    expect(payload[229]).toBe(100);
-    expect(payload[230]).toBe(0);
+    expect(Array.from(payload.slice(16, 19))).toEqual([0.25, -0.5, 0.75]);
   });
 
-  it('keeps the accepted previous camera in the temporal ABI', () => {
+  it('writes temporal current/previous projection after the spot-light lanes', () => {
     const { queue, uploads } = recordingQueue();
-    const acceptedCamera = [7, 8, 9] as const;
-    const temporal = { ...temporalView(), previousCameraPosition: acceptedCamera };
     writeViewUbo(
       queue,
       {} as Buffer,
@@ -180,11 +154,16 @@ describe('temporal GPU payloads', () => {
       },
       { point: [], spot: [] } as never,
       [],
-      temporal as never,
+      temporalView(),
     );
 
     const payload = new Float32Array(uploads[0]?.buffer ?? new ArrayBuffer(0));
-    expect(Array.from(payload.slice(232, 236))).toEqual([...acceptedCamera, 1]);
+    expect(payload.length).toBe(240);
+    expect(payload[196]).toBeCloseTo(Math.sqrt(3));
+    expect(payload[212]).toBe(3);
+    expect(payload[228]).toBeCloseTo(0.1);
+    expect(payload[229]).toBe(100);
+    expect(payload[230]).toBe(0);
   });
 
   it('seeds previousWorld on the first frame and uses the submitted snapshot later', () => {

package/src/record/__tests__/typed-frame-graph-plan.unit.test.ts

@@ -52,7 +52,7 @@ function executeCapture(overrides: CaptureOverrides = {}) {
         usage: GPU_TEXTURE_USAGE_COPY_SRC,
         identity: overrides.identity ?? {
           graphGeneration: 7,
-          frameId: 12,
+          frameId: 13,
           textureIdentity: getTextureIdentity(texture),
         },
       },

package/src/record/frame-snapshot.ts

@@ -18,6 +18,7 @@ import type { DirectionalShadowQuality } from '../components/directional-shadow-
 import type { EnvironmentGeneration } from '../environment/generation';
 import type { EnvironmentLifecycle } from '../environment/lifecycle';
 import type { GpuBuffer } from '../gpu-resource';
+import type { IblBindingInspection } from '../mesh-material-bindings';
 import type { StandardLightingInspection } from '../pipeline/standard-lighting/inspection';
 import type { PointShadowInspection } from '../point-shadow-inspection';
 import type { TemporalGpuState } from '../temporal/gpu';
@@ -138,6 +139,18 @@ export interface CurrentGraphTarget {
 const textureIdentities = new WeakMap<object, number>();
 let nextTextureIdentity = 1;
 
+const opaqueResourceIdentities = new WeakMap<object, number>();
+let nextOpaqueResourceIdentity = 1;
+
+/** Stable detached identity for a renderer-owned opaque resource handle. */
+export function getOpaqueResourceIdentity(resource: object): number {
+  const existing = opaqueResourceIdentities.get(resource);
+  if (existing !== undefined) return existing;
+  const identity = nextOpaqueResourceIdentity++;
+  opaqueResourceIdentities.set(resource, identity);
+  return identity;
+}
+
 /**
  * Project an opaque RHI texture handle to a stable diagnostic identity.
  * RHI handles intentionally expose no serializable fields; object identity is
@@ -289,6 +302,8 @@ export function makeZeroCameraFallbackSnapshot(): CameraSnapshot {
  */
 export interface RenderFrameState {
   frameNumber: number;
+  /** Final-submit Standard IBL binding-chain receipt for this frame. */
+  iblBindingInspection?: IblBindingInspection;
   /** Demand for the frame-local Standard fallback MRT. */
   reflectionFallbackDemand?: boolean;
   /** Monotonic compiled-graph identity used by diagnostic readbacks. */

package/src/record/frame-targets.ts

@@ -75,9 +75,19 @@ export function acquireSwapChainTarget(
 
   let currentTextureResult = canvasContext.getCurrentTexture();
   if (!currentTextureResult.ok) {
+    const configuredDevice = internals.resolveSurfaceDevice?.(internals.device);
+    if (configuredDevice !== undefined && !configuredDevice.ok) {
+      internals.errorRegistry.fire(configuredDevice.error);
+      internals.healthRegistry.fire({
+        reason: 'internal-fault',
+        detail: { message: 'surface device resolution failed; current frame skipped' },
+        recoverable: true,
+      });
+      return null;
+    }
     const configured = configureSurface(
       canvasContext,
-      internals.device,
+      configuredDevice?.value ?? internals.device,
       pipelineState.format,
       pipelineState.colorAttachmentFormat,
     );

package/src/record/frame.ts

@@ -2484,7 +2484,7 @@ function prepareDirectionalShadowCache(
  *
  * @internal
  */
-function validateRenderables(
+export function validateRenderables(
   internals: RenderSystemInternals,
   world: World,
   // feat-20260709-editor-world-partition ENGINE-fix-round2 (defect 2): the full
@@ -2714,8 +2714,12 @@ function prepareMorphMesh(
       frameState.morphBuffers.delete(cacheKey);
       return undefined;
     }
+    const buffer = new GpuBuffer(internals.device, created.value);
+    internals.deviceScope._adopt('buffer', buffer, (owned) => {
+      if (!owned.isDestroyed) owned.destroy();
+    });
     cached = {
-      buffer: new GpuBuffer(internals.device, created.value),
+      buffer,
       byteLength: vertices.byteLength,
     };
     frameState.morphBuffers.set(cacheKey, cached);

package/src/record/helpers.ts

@@ -214,8 +214,8 @@ export function computeProjectionMatrix(camera: CameraSnapshot): Mat4 {
       proj,
       camera.orthoLeft,
       camera.orthoRight,
-      camera.orthoBottom,
       camera.orthoTop,
+      camera.orthoBottom,
       camera.near,
       camera.far,
     );