@forgeax/engine-render 0.1.6 → 0.1.19

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

@@ -0,0 +1,67 @@
+import { World } from '@forgeax/engine-ecs';
+import { vec3 } from '@forgeax/engine-math';
+import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA } from '@forgeax/engine-shader';
+import { derive } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import type { MaterialSnapshot } from '../../render-system-extract';
+import { applyMaterialTextureUvScales, buildPbrMaterialUboPayload } from '../main-pass-material';
+
+describe('Standard PBR UBO layout', () => {
+  it('keeps shader, derived schema, and record offsets aligned', () => {
+    const derived = derive(DEFAULT_STANDARD_PBR_PARAM_SCHEMA);
+    const numeric = new Map(derived.numericMembers.map((member) => [member.name, member.offset]));
+    const coordinates = new Map(
+      derived.coordinateRecords.map((record) => [record.parameter, record.offset]),
+    );
+
+    expect(derived.totalBytes).toBe(384);
+    expect(numeric.get('normalScale')).toBe(92);
+    expect(numeric.get('transmission')).toBe(96);
+    expect(numeric.get('ior')).toBe(100);
+    expect(numeric.get('thickness')).toBe(104);
+    expect(numeric.get('attenuationColor')).toBe(112);
+    expect(numeric.get('attenuationDistance')).toBe(124);
+    expect(coordinates.get('baseColorTexture')).toBe(128);
+    expect(coordinates.get('transmissionTexture')).toBe(320);
+    expect(coordinates.get('thicknessTexture')).toBe(352);
+  });
+
+  it('writes transmission scalars and defaults at the reflected offsets', () => {
+    const material = {
+      baseColor: vec3.create(0.7, 0.7, 0.7),
+      metallic: 0,
+      roughness: 0.4,
+      normalScale: 0.25,
+      materialShaderId: 'forgeax::default-standard-pbr',
+      paramSnapshot: {
+        transmission: 0.75,
+        ior: 1.6,
+        thickness: 0.2,
+        attenuationColor: [0.2, 0.4, 0.6],
+        attenuationDistance: 3,
+      },
+    } satisfies MaterialSnapshot;
+    const f32 = new Float32Array(buildPbrMaterialUboPayload(material).buffer);
+
+    expect(f32.slice(23, 32)).toEqual(
+      new Float32Array([0.25, 0.75, 1.6, 0.2, 0, 0.2, 0.4, 0.6, 3]),
+    );
+  });
+
+  it('uses all eight identity coordinate records in the no-snapshot fallback', () => {
+    const material = {
+      baseColor: vec3.create(0.7, 0.7, 0.7),
+      metallic: 0,
+      roughness: 0.4,
+      materialShaderId: 'forgeax::default-standard-pbr',
+    } satisfies MaterialSnapshot;
+    const payload = buildPbrMaterialUboPayload(material);
+
+    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()),
+    );
+  });
+});

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

@@ -0,0 +1,164 @@
+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 } from '../../render-system-extract';
+import type { TemporalView } from '../../temporal/temporal-view';
+import type { ValidatedRenderable } from '../frame-snapshot';
+import { uploadMeshSsboBatch } from '../mesh-ssbo';
+import { writeViewUbo } from '../view-ubo';
+
+function identityMatrix(): Float32Array {
+  const matrix = new Float32Array(16);
+  matrix[0] = 1;
+  matrix[5] = 1;
+  matrix[10] = 1;
+  matrix[15] = 1;
+  return matrix;
+}
+
+function translatedMatrix(x: number): Float32Array {
+  const matrix = identityMatrix();
+  matrix[12] = x;
+  return matrix;
+}
+
+function recordingQueue(): {
+  readonly queue: RhiQueue;
+  readonly uploads: readonly Uint8Array[];
+} {
+  const uploads: Uint8Array[] = [];
+  const queue = {
+    writeBuffer: (
+      _buffer: Buffer,
+      _bufferOffset: number,
+      data: ArrayBufferView | ArrayBuffer,
+      _dataOffset?: number,
+      size?: number,
+    ) => {
+      const bytes =
+        data instanceof ArrayBuffer
+          ? new Uint8Array(data, 0, size ?? data.byteLength)
+          : new Uint8Array(data.buffer, data.byteOffset, size ?? data.byteLength);
+      uploads.push(new Uint8Array(bytes));
+      return { ok: true, value: undefined } as const;
+    },
+  } as unknown as RhiQueue;
+  return { queue, uploads };
+}
+
+function camera(): CameraSnapshot {
+  return {
+    entityKey: 1,
+    worldId: 0,
+    historyVersion: 0,
+    position: vec3.create(0, 0, 5),
+    world: identityMatrix(),
+    fov: Math.PI / 3,
+    aspect: 1,
+    near: 0.1,
+    far: 100,
+    projection: 'perspective',
+    orthoLeft: -1,
+    orthoRight: 1,
+    orthoBottom: -1,
+    orthoTop: 1,
+    tonemap: 'none',
+    exposure: 1,
+    whitePoint: 4,
+    antialias: 'none',
+    bloom: 'off',
+    bloomThreshold: 1,
+    bloomIntensity: 1,
+    bloomBlurRadius: 4,
+    clearColor: [0, 0, 0, 1],
+  };
+}
+
+function temporalView(): TemporalView {
+  const current = identityMatrix();
+  current[0] = 2;
+  const previous = identityMatrix();
+  previous[0] = 3;
+  return {
+    viewId: '0:1:0',
+    historyVersion: 0,
+    temporalFrameIndex: 1,
+    historyValid: true,
+    resetReason: undefined,
+    currentJitterUv: [0, 0],
+    previousJitterUv: [0, 0],
+    currentJitteredViewProjection: current,
+    currentUnjitteredViewProjection: current,
+    previousUnjitteredViewProjection: previous,
+    projection: 'perspective',
+    near: 0.1,
+    far: 100,
+  };
+}
+
+describe('temporal GPU payloads', () => {
+  it('writes temporal current/previous projection after the spot-light lanes', () => {
+    const { queue, uploads } = recordingQueue();
+    writeViewUbo(
+      queue,
+      {} as Buffer,
+      camera(),
+      {
+        kind: 'directional',
+        direction: vec3.create(0, -1, 0),
+        color: vec3.create(1, 1, 1),
+        intensity: 1,
+      },
+      { 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);
+  });
+
+  it('seeds previousWorld on the first frame and uses the submitted snapshot later', () => {
+    const first = translatedMatrix(4);
+    const previous = translatedMatrix(2);
+    const second = translatedMatrix(6);
+    const makeEntry = (world: Float32Array, temporal?: object) =>
+      ({
+        source: {
+          transform: { world },
+          materials: [{ transparent: false }],
+          ...(temporal === undefined ? {} : { temporal }),
+        } as unknown as RenderableSnapshot,
+      }) as unknown as ValidatedRenderable;
+    const firstRecording = recordingQueue();
+    uploadMeshSsboBatch(firstRecording.queue, { buffer: {} as Buffer }, [makeEntry(first)], null);
+    const firstPayload = new Float32Array(firstRecording.uploads[0]?.buffer ?? new ArrayBuffer(0));
+    expect(firstPayload[12]).toBe(4);
+    expect(firstPayload[28 + 12]).toBe(4);
+
+    const secondRecording = recordingQueue();
+    uploadMeshSsboBatch(
+      secondRecording.queue,
+      { buffer: {} as Buffer },
+      [
+        makeEntry(second, {
+          previousTransform: { world: previous },
+          reactive: false,
+        }),
+      ],
+      null,
+    );
+    const secondPayload = new Float32Array(
+      secondRecording.uploads[0]?.buffer ?? new ArrayBuffer(0),
+    );
+    expect(secondPayload[12]).toBe(6);
+    expect(secondPayload[28 + 12]).toBe(2);
+    expect(secondPayload[44]).toBe(0);
+  });
+});

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

@@ -1,10 +1,88 @@
+import { ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import type { RenderFeaturePlannedFrame } from '../../features/plan';
+import { GPU_TEXTURE_USAGE_COPY_SRC } from '../../gpu-texture-usage';
+import { getTextureIdentity, validateGraphTargetCaptureReadback } from '../frame-snapshot';
 import {
+  executeCompiledFrameGraph,
   type RenderFeatureGraphCandidate,
   renderFeatureGraphPlanSignature,
 } from '../typed-frame-graph';
 
+const captureDescriptor = {
+  texture: {} as never,
+  format: 'rgba16float' as const,
+  size: { width: 4, height: 2 },
+  usage: GPU_TEXTURE_USAGE_COPY_SRC,
+  sample: 1,
+};
+
+type CaptureOverrides = {
+  readonly target?: boolean;
+  readonly descriptor?: {
+    readonly format?: 'rgba16float' | 'rgba8unorm';
+    readonly size?: { readonly width: number; readonly height: number };
+    readonly usage?: number;
+  };
+  readonly identity?: { graphGeneration: number; frameId: number; textureIdentity: number };
+};
+
+function executeCapture(overrides: CaptureOverrides = {}) {
+  const errors: unknown[] = [];
+  const copies: unknown[] = [];
+  const texture = {} as never;
+  const descriptor = { ...captureDescriptor, ...overrides.descriptor, texture };
+  const graph = {
+    execute: () => ok(undefined),
+  };
+  const frameState = {
+    compiledFrameGraph: graph,
+    frameNumber: 13,
+    graphTargetCapture: {
+      name: 'standard-output-color',
+      buffer: {} as never,
+      bytesPerRow: 256,
+      width: 4,
+      height: 2,
+      expected: {
+        format: 'rgba16float' as const,
+        width: 4,
+        height: 2,
+        usage: GPU_TEXTURE_USAGE_COPY_SRC,
+        identity: overrides.identity ?? {
+          graphGeneration: 7,
+          frameId: 12,
+          textureIdentity: getTextureIdentity(texture),
+        },
+      },
+    },
+    perFrameGraph:
+      overrides.target === false
+        ? undefined
+        : {
+            graphGeneration: 7,
+            getColorTargetTexture: () => (overrides.target === false ? undefined : texture),
+            getColorTargetDescriptor: () => (overrides.target === false ? undefined : descriptor),
+            getColorTargetView: () => undefined,
+          },
+  } as never;
+  const encoder = {
+    copyTextureToBuffer: (...args: unknown[]) => copies.push(args),
+    finish: () => ok({} as never),
+  } as never;
+  const internals = {
+    errorRegistry: { fire: (error: unknown) => errors.push(error) },
+    device: { queue: { submit: () => ok(undefined) } },
+  } as never;
+  const submitted = executeCompiledFrameGraph(internals, frameState, {} as never, encoder);
+  return { submitted, errors, copies };
+}
+
+function failureReason(errors: readonly unknown[]): string {
+  const error = errors[0] as { detail?: { error?: { message?: string } } } | undefined;
+  return error?.detail?.error?.message ?? '';
+}
+
 function planned(generation: number, signature: string): RenderFeaturePlannedFrame {
   return {
     featureIdentity: 'synthetic.feature',
@@ -38,4 +116,53 @@ describe('typed frame graph feature plan authority', () => {
     };
     void invalid;
   });
+
+  it.each([
+    ['missing target', { target: false }, 'target-not-present-in-current-graph'],
+    ['format mismatch', { descriptor: { format: 'rgba8unorm' as const } }, 'descriptor-mismatch'],
+    ['extent mismatch', { descriptor: { size: { width: 2, height: 2 } } }, 'extent-mismatch'],
+    ['COPY_SRC missing', { descriptor: { usage: 0 } }, 'copy-src-usage-missing'],
+    [
+      'identity mismatch',
+      { identity: { graphGeneration: 8, frameId: 12, textureIdentity: 999 } },
+      'identity-mismatch',
+    ],
+  ])('fails closed for capture %s', (_name, overrides, expectedReason) => {
+    const result = executeCapture(overrides);
+    expect(result.submitted).toBe(true);
+    expect(result.copies).toHaveLength(0);
+    expect(result.errors).toHaveLength(1);
+    expect(failureReason(result.errors)).toContain(`"reason":"${expectedReason}"`);
+  });
+
+  it('copies the exact target only after all capture identity and descriptor checks pass', () => {
+    const result = executeCapture();
+    expect(result.submitted).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    expect(result.copies).toHaveLength(1);
+  });
+
+  it.each([
+    [
+      'missing same-submit copy / untouched sentinel',
+      new Uint8Array([0xa5, 0xa5, 0xa5, 0xa5]),
+      new Uint8Array([0xa5, 0xa5]),
+      'capture-readback-untouched-sentinel',
+    ],
+    ['all-empty readback', new Uint8Array(4), undefined, 'capture-readback-empty'],
+    [
+      'non-finite float16',
+      new Uint8Array([0x01, 0x7c, 0, 0]),
+      undefined,
+      'capture-readback-non-finite',
+    ],
+  ])('returns a structured failure for %s readback', (_name, bytes, sentinel, expectedCode) => {
+    const result = validateGraphTargetCaptureReadback({
+      bytes,
+      expectedByteLength: 4,
+      ...(sentinel === undefined ? {} : { sentinel }),
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.code).toBe(expectedCode);
+  });
 });

package/src/record/frame-lighting.ts

@@ -57,7 +57,7 @@ import {
 } from './helpers';
 import { getOrCreateFromChain, MESH_SSBO_BYTES, MESH_UBO_FULL_ARRAY_BYTES } from './mesh-ssbo';
 import type { PipelineState, RecordProfileRunner, RenderSystemInternals } from './render-context';
-import { VIEW_UNIFORM_BYTES } from './view-ubo';
+import { POINTS_LINES_VIEW_BYTES, VIEW_UNIFORM_BYTES } from './view-ubo';
 
 function runHdrpClusterProfilePhase<T>(
   runner: RecordProfileRunner | undefined,
@@ -161,6 +161,7 @@ export function buildPerFrameBindGroups(
           b5View,
           pipelineState.shadowParamsBuffer,
           b8View,
+          pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer,
         ],
         'view-main',
         () => {
@@ -248,10 +249,21 @@ export function buildPerFrameBindGroups(
                   value: b8View,
                 },
               },
+              {
+                binding: 10,
+                resource: {
+                  kind: 'buffer',
+                  value: {
+                    buffer: pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer,
+                    size: POINTS_LINES_VIEW_BYTES,
+                  },
+                },
+              },
               // feat-20260625-spot-light-shadow-mapping w25: the per-spot
               // fragment-read lightViewProj matrices fold into the View UBO
               // (binding 0, `view.spotLightViewProj`) — no standalone binding 9
-              // (WebGL2 fragment uniform-buffer budget). binding 8 is the last.
+              // (WebGL2 fragment uniform-buffer budget). binding 10 is the
+              // dedicated vertex-only Points/Lines viewport UBO.
             ],
           });
           if (!viewBindGroupResult.ok) throw viewBindGroupResult.error;

package/src/record/frame-snapshot.ts

@@ -6,7 +6,16 @@ import { vec3 } from '@forgeax/engine-math';
 import type { ResolvedColorTargetDescriptor } from '@forgeax/engine-render-graph';
 import type { Texture } from '@forgeax/engine-rhi';
 import type { ClusterBinScratch } from '../cluster-binner';
+import type { EnvironmentGeneration } from '../environment/generation';
+import type { EnvironmentLifecycle } from '../environment/lifecycle';
 import type { GpuBuffer } from '../gpu-resource';
+import type { TemporalGpuState } from '../temporal/gpu';
+import type { TemporalView } from '../temporal/view';
+
+export type TemporalCommitOutcome =
+  | { readonly kind: 'none' }
+  | { readonly kind: 'off'; readonly view: TemporalView }
+  | { readonly kind: 'taa'; readonly view: TemporalView };
 
 /**
  * feat-20260708-composited-multi-world-rendering M1 / D-1 / D-9:
@@ -84,6 +93,88 @@ export interface FrameObservationSource {
   readonly backendId: string;
 }
 
+/** Internal test/diagnostic view of one compiled graph color target. */
+export interface CurrentGraphTarget {
+  readonly name: string;
+  readonly texture: Texture;
+  /** Stable opaque identity for this RHI handle during the renderer lifetime. */
+  readonly textureIdentity: number;
+  readonly descriptor: ResolvedColorTargetDescriptor;
+  readonly frameId: number;
+  /** Monotonic identity of the compiled graph that owns this texture. */
+  readonly graphGeneration: number;
+}
+
+const textureIdentities = new WeakMap<object, number>();
+let nextTextureIdentity = 1;
+
+/**
+ * Project an opaque RHI texture handle to a stable diagnostic identity.
+ * RHI handles intentionally expose no serializable fields; object identity is
+ * the only valid comparison boundary for a copy-time capture.
+ */
+export function getTextureIdentity(texture: Texture): number {
+  const object = texture as object;
+  const existing = textureIdentities.get(object);
+  if (existing !== undefined) return existing;
+  const identity = nextTextureIdentity++;
+  textureIdentities.set(object, identity);
+  return identity;
+}
+
+export type GraphTargetCaptureReadbackValidation =
+  | { readonly ok: true }
+  | {
+      readonly ok: false;
+      readonly code:
+        | 'capture-readback-length'
+        | 'capture-readback-untouched-sentinel'
+        | 'capture-readback-empty'
+        | 'capture-readback-non-finite';
+    };
+
+/** Validate a mapped rgba16float capture before a consumer decodes its values. */
+export function validateGraphTargetCaptureReadback(input: {
+  readonly bytes: Uint8Array;
+  readonly expectedByteLength: number;
+  readonly sentinel?: Uint8Array;
+}): GraphTargetCaptureReadbackValidation {
+  const { bytes, expectedByteLength, sentinel } = input;
+  if (bytes.byteLength !== expectedByteLength)
+    return { ok: false, code: 'capture-readback-length' };
+  if (sentinel?.every((value, index) => bytes[index] === value)) {
+    return { ok: false, code: 'capture-readback-untouched-sentinel' };
+  }
+  if (bytes.every((value) => value === 0)) return { ok: false, code: 'capture-readback-empty' };
+  for (let index = 0; index + 1 < bytes.length; index += 2) {
+    const exponent = ((bytes[index + 1] ?? 0) >>> 2) & 0x1f;
+    if (exponent === 0x1f) return { ok: false, code: 'capture-readback-non-finite' };
+  }
+  return { ok: true };
+}
+
+/** Internal readback request consumed by the record encoder in the same submit. */
+export interface GraphTargetCaptureRequest {
+  readonly name: string;
+  readonly buffer: Buffer;
+  readonly bytesPerRow: number;
+  readonly width: number;
+  readonly height: number;
+  /** Descriptor contract checked against the resolved target at copy time. */
+  readonly expected: {
+    readonly format: ResolvedColorTargetDescriptor['format'];
+    readonly width: number;
+    readonly height: number;
+    readonly usage: number;
+    /** Optional caller binding; when present it is checked at copy time. */
+    readonly identity?: {
+      readonly graphGeneration: number;
+      readonly frameId: number;
+      readonly textureIdentity: number;
+    };
+  };
+}
+
 /**
  * Build a synthetic CameraSnapshot the record stage uses when the world
  * carries no Camera entity. Identity-shaped projection / view inputs
@@ -160,14 +251,24 @@ export function clampPcfKernelSize(value: number | undefined): number {
  */
 export interface RenderFrameState {
   frameNumber: number;
+  /** Monotonic compiled-graph identity used by diagnostic readbacks. */
+  graphGeneration: number;
+  /** Number of successfully submitted TAA frames; failed attempts do not advance it. */
+  successfulTemporalFrameIndex?: number;
   /** Optional graph resource lookup used by low-level record helpers and tests. */
-  readonly perFrameGraph?: {
+  perFrameGraph?: {
     readonly getColorTargetDescriptor: (key: string) => ResolvedColorTargetDescriptor | undefined;
     readonly getColorTargetView: (key: string) => TextureView | undefined;
     readonly getColorTargetTexture: (key: string) => Texture | undefined;
+    readonly graphGeneration: number;
   } | null;
+  graphTargetCapture?: GraphTargetCaptureRequest | undefined;
   /** Last successfully rendered static directional shadow atlas token. */
   directionalShadowCache: DirectionalShadowCache | null;
+  /** Last successfully submitted camera post-process mode. */
+  lastSuccessfulBloom: 'off' | 'on';
+  /** Bloom record receipts staged by this frame; cleared on abort. */
+  bloomFrameReceipts?: BloomFrameReceipts | undefined;
   /** Set by a directional shadow pass when this frame refreshed the atlas. */
   directionalShadowCacheRecorded: boolean;
   /** The sole compiled owner for compute, copy, feature, and raster work. */
@@ -176,6 +277,20 @@ export interface RenderFrameState {
   readonly retiredCompiledFrameGraphs: Set<CompiledRenderGraph<RenderPipelineFrame>>;
   /** Physical outputs projected by typed graph passes for downstream observers. */
   currentFrameObservationSource: FrameObservationSource | undefined;
+  /** Camera antialias mode for the last successfully submitted graph. */
+  lastSuccessfulCameraAntialias: CameraSnapshot['antialias'] | undefined;
+  /** Staged TAA GPU state is promoted only after queue.submit succeeds. */
+  temporalGpuState: TemporalGpuState | undefined;
+  /** Last successful TAA GPU state; candidate replacement stays staged until submit. */
+  activeTemporalGpuState: TemporalGpuState | undefined;
+  /** Submitted temporal generations retained until their queue fence resolves. */
+  readonly retiringTemporalGpuStates: Set<TemporalGpuState>;
+  /** Last successful projection; candidate frames never overwrite it. */
+  lastSuccessfulTemporalView: TemporalView | undefined;
+  pendingTemporalCommit: TemporalCommitOutcome;
+  /** Staged environment generation is promoted only after queue.submit succeeds. */
+  environmentGeneration: EnvironmentGeneration | undefined;
+  readonly environmentLifecycle: EnvironmentLifecycle | undefined;
   currentDirectionalShadowView: TextureView | null;
   currentSpotShadowView: TextureView | null;
   readonly instanceBuffers: Map<number, InstanceBufferCacheEntry>;
@@ -342,10 +457,9 @@ export interface RenderFrameState {
    */
   installedPipelineConfig: RenderPipelineAsset['config'];
   /**
-   * feat-20260608-cluster-lighting M2 / w10: HDRP active flag.
-   * True iff the currently installed RenderPipelineAsset has
-   * `pipelineId === 'forgeax::hdrp'`. URP-only code paths gate on
-   * `!isHdrpActive` so HDRP demos do not double-count light contributions.
+   * Whether the configured standard graph resolved to the clustered lane.
+   * Capability gating keeps URP forward bindings on WebGL2 fallback even
+   * when a clustered profile was requested.
    */
   isHdrpActive: boolean;
   /**
@@ -432,6 +546,16 @@ export interface BindGroupCounts {
   keys: string[];
 }
 
+/**
+ * Successful Bloom record operations staged for the current frame. These
+ * counters are promoted only after the shared renderer queue submission.
+ */
+export interface BloomFrameReceipts {
+  readonly uploadCount: number;
+  readonly bindGroupCount: number;
+  readonly encodeCount: number;
+}
+
 /**
  * A renderable resolved against the AssetRegistry for the current frame:
  * its source snapshot, the GPU mesh handles, the row index used to correlate

package/src/record/frame-targets.ts

@@ -20,9 +20,12 @@ export function graphExecutionPhase(passName: string): RenderGraphExecutionPhase
     case 'lighting':
       return 'record/graph-execute/lighting';
     case 'forward':
+    case 'transmission-forward':
       return 'record/graph-execute/forward';
-    case 'tonemap':
-      return 'record/graph-execute/tonemap';
+    case 'output-transform':
+      return 'record/graph-execute/output-transform';
+    case 'present':
+      return 'record/graph-execute/present';
     case 'debug-overlay':
       return 'record/graph-execute/debug-overlay';
     case 'shadow':
@@ -55,17 +58,23 @@ export function acquireSwapChainTarget(
 
   let currentTextureResult = canvasContext.getCurrentTexture();
   if (!currentTextureResult.ok) {
-    pipelineState.perPassResources.configured = false;
     const configured = configureSurface(
       canvasContext,
       internals.device,
       pipelineState.format,
       pipelineState.colorAttachmentFormat,
     );
-    if (configured.ok) {
-      pipelineState.perPassResources.configured = true;
-      (globalThis as Record<string, unknown>).__forgeaxSwapChainFormat = pipelineState.format;
+    if (!configured.ok) {
+      internals.errorRegistry.fire(configured.error);
+      internals.healthRegistry.fire({
+        reason: 'internal-fault',
+        detail: { message: 'surface configure candidate failed; current frame skipped' },
+        recoverable: true,
+      });
+      return null;
     }
+    pipelineState.perPassResources.configured = true;
+    (globalThis as Record<string, unknown>).__forgeaxSwapChainFormat = pipelineState.format;
     const retry = canvasContext.getCurrentTexture();
     if (!retry.ok) {
       internals.errorRegistry.fire(retry.error);