@forgeax/engine-render 0.1.2

package/src/systems/transparent-sort-config.ts

@@ -0,0 +1,211 @@
+// @forgeax/engine-runtime - TransparentSortConfig KV resource + helpers.
+//
+// feat-20260520-2d-sprite-layer-mvp M-2 w14 / requirements AC-08 + AC-18
+// path (2)/(3) + AC-19 derivation audit (5).
+//
+// Surface:
+//   - interface  TransparentSortConfig { mode: number; yzAlpha: number }
+//   - constant   TRANSPARENT_SORT_CONFIG_KEY   = 'TransparentSortConfig'
+//   - constants  TRANSPARENT_SORT_MODE_LAYER_Z  = 0  (horizontal-z)
+//                TRANSPARENT_SORT_MODE_LAYER_Y  = 1  (Y-sort)
+//                TRANSPARENT_SORT_MODE_LAYER_YZ = 2  (Y-Z blend)
+//   - helper     getTransparentSortConfig(world): TransparentSortConfig
+//   - helper     setTransparentSortConfig(world, cfg):
+//                  Result<void, ResourceInvalidValueError>
+//
+// 5-view selection table (charter F1 progressive disclosure for AI users
+// reading IDE hover on this header; same SSOT mirrored in
+// apps/hello/sprite/README.md M-4 w33):
+//
+//   | view              | mode | yzAlpha | sortValue formula              |
+//   |:------------------|:----:|:-------:|:--------------------------------|
+//   | horizontal (side) |  0   |   ---   | posZ                            |
+//   | top-down          |  1   |   ---   | -(posY - pivot.y * size.y)      |
+//   | Don't Starve      |  2   |   1.0   | (posY - pivot.y * size.y) + posZ|
+//   | isometric         |  2   |   0.5   | (posY - pivot.y * size.y) + 0.5*posZ |
+//   | JRPG (foot pivot) |  1   |   ---   | -(posY - pivot.y * size.y)      |
+//
+// AC-18 path (2): @fallback getTransparentSortConfig KV missing returns
+//   default; no warn; no throw (legal default state, not an error state).
+// AC-18 path (3): @fallback setTransparentSortConfig mode out-of-range
+//   does NOT silently coerce to mode=0 — returns Result.err with the
+//   4 SSOT fields locked by plan-strategy D-4 so AI users can self-repair
+//   via .code / .expected / .hint / .detail property access (charter P3).
+// AC-18 path (3) carve-out: yzAlpha range is intentionally NOT validated;
+//   mode=0 / mode=1 ignore the field entirely, mode=2 reads it, mode=3
+//   (distance) also reads it for compat but ignores it (squared-distance
+//   formula does not use yzAlpha). The silent-ignore is the documented
+//   charter P3 "legal default" boundary.
+//
+// @new-surface KV resource: ECS has no defineResource factory at this
+//   feat's commit time; the TS POD interface + string KV key form is the
+//   minimum-new-surface route. The world resource store
+//   (insertResource / getResource / hasResource) is reused unchanged
+//   (requirements §2.2.G derivation row 5).
+// @derives world.hasResource / world.insertResource / world.getResource
+//   KV API (packages/ecs/src/resource.ts + world.ts: insertResource l.490,
+//   getResource l.498, hasResource l.503).
+// @fallback getTransparentSortConfig KV missing returns
+//   { mode: 0, yzAlpha: 1.0 }; no warn; no throw.
+// @fallback setTransparentSortConfig mode out-of-range returns Result.err
+//   with code='resource-invalid-value'; never silently coerced.
+//
+// charter mapping: F1 (single-import barrel + 5-view JSDoc table on
+// hover) + P3 (structured failure on mode out-of-range; legal-default
+// fallback distinguished from error fallback) + P4 (consistent
+// abstraction — same world.{has,get,insert}Resource KV API as every
+// other engine resource consumer).
+
+import type { World } from '@forgeax/engine-ecs';
+import type { Result } from '@forgeax/engine-types';
+import { err, ok } from '@forgeax/engine-types';
+import { ResourceInvalidValueError } from '../errors';
+
+// ────────────────────────────────────────────────────────────────────────────
+// POD interface + KV key + 3 named mode constants
+// ────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Transparent-bucket sort configuration (plain-data POD). Lives as a
+ * world-level resource keyed by `TRANSPARENT_SORT_CONFIG_KEY`.
+ *
+ * Fields:
+ *   - `mode \u2208 {0, 1, 2, 3}` selects the sort formula
+ *     (`TRANSPARENT_SORT_MODE_LAYER_Z` / `_LAYER_Y` / `_LAYER_YZ` / `_DISTANCE`).
+ *   - `yzAlpha` (mode=2 only) blends Y-axis into Z-axis: 1.0 weights
+ *     posZ equally with `posY - pivot.y * size.y` (Don't-Starve style),
+ *     0.5 weights posZ at half (isometric). mode=0 / mode=1 ignore the
+ *     field (documented charter P3 legal-default boundary).
+ */
+export interface TransparentSortConfig {
+  readonly mode: number;
+  readonly yzAlpha: number;
+}
+
+/** World resource key for `TransparentSortConfig` KV entry. */
+export const TRANSPARENT_SORT_CONFIG_KEY = 'TransparentSortConfig' as const;
+
+/** horizontal / side-scroller: sortValue = posZ. */
+export const TRANSPARENT_SORT_MODE_LAYER_Z = 0;
+
+/** top-down / JRPG: sortValue = -(posY - pivot.y * size.y) (foot pivot Y-sort). */
+export const TRANSPARENT_SORT_MODE_LAYER_Y = 1;
+
+/** Don't-Starve / isometric: sortValue = (posY - pivot.y * size.y) + yzAlpha * posZ. */
+export const TRANSPARENT_SORT_MODE_LAYER_YZ = 2;
+
+/** 3D distance: sortValue = -(dist^2) to cameraPos, back-to-front (far first). */
+export const TRANSPARENT_SORT_MODE_DISTANCE = 3;
+
+// ────────────────────────────────────────────────────────────────────────────
+// Internal: silent default + mode validity check
+// ────────────────────────────────────────────────────────────────────────────
+
+const DEFAULT_CONFIG: TransparentSortConfig = Object.freeze({
+  mode: TRANSPARENT_SORT_MODE_LAYER_Z,
+  yzAlpha: 1.0,
+});
+
+const VALID_MODES: ReadonlySet<number> = new Set<number>([
+  TRANSPARENT_SORT_MODE_LAYER_Z,
+  TRANSPARENT_SORT_MODE_LAYER_Y,
+  TRANSPARENT_SORT_MODE_LAYER_YZ,
+  TRANSPARENT_SORT_MODE_DISTANCE,
+]);
+
+// The expected / hint literals are the SSOT locked by plan-strategy D-4.
+// They MUST round-trip byte-for-byte into ResourceInvalidValueError so AI
+// users can read err.expected / err.hint for self-repair (charter P3).
+// `\u2208` is the math "is-element-of" symbol; the ASCII source escape
+// keeps the file English-only per AGENTS.md §Conventions.
+const EXPECTED_MODE = 'mode \u2208 {0, 1, 2, 3}';
+const HINT_MODE = '0=layer-z, 1=layer-y, 2=layer-yz, 3=distance';
+
+// ────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Read the world's `TransparentSortConfig` resource.
+ *
+ * @fallback KV missing returns `{ mode: 0, yzAlpha: 1.0 }`
+ * (`TRANSPARENT_SORT_MODE_LAYER_Z`, horizontal-z safe default).
+ * NO warn, NO throw — KV missing is a legal state (not an error state),
+ * mirroring how a sprite-free scene is a legal state for the renderer
+ * even though render-system has a transparent bucket. plan-strategy D-2:
+ * `hasResource` guard precedes the read so this helper never trips
+ * `ResourceNotFoundError` from `world.getResource`.
+ *
+ * @example
+ *   const cfg = getTransparentSortConfig(world);
+ *   // cfg.mode === 0, cfg.yzAlpha === 1.0 when no resource inserted.
+ *
+ * @example
+ *   world.insertResource(TRANSPARENT_SORT_CONFIG_KEY,
+ *     { mode: TRANSPARENT_SORT_MODE_LAYER_Y, yzAlpha: 1.0 });
+ *   const cfg = getTransparentSortConfig(world);
+ *   // cfg.mode === 1, cfg.yzAlpha === 1.0 (yzAlpha ignored by mode=1).
+ */
+export function getTransparentSortConfig(world: World): TransparentSortConfig {
+  if (!world.hasResource(TRANSPARENT_SORT_CONFIG_KEY)) {
+    return DEFAULT_CONFIG;
+  }
+  return world.getResource<TransparentSortConfig>(TRANSPARENT_SORT_CONFIG_KEY);
+}
+
+/**
+ * Write the world's `TransparentSortConfig` resource, validating `mode`.
+ *
+ * Returns `Result<void, ResourceInvalidValueError>`:
+ *
+ *   - `ok` — mode is in `{0, 1, 2, 3}`; the resource is inserted /
+ *     overwritten via `world.insertResource`.
+ *   - `err` — mode is out of range; the resource is NOT mutated;
+ *     `err.error` is a `ResourceInvalidValueError` instance carrying:
+ *       `.code === 'resource-invalid-value'`
+ *       `.expected === 'mode \u2208 {0, 1, 2, 3}'`
+ *       `.hint === '0=layer-z, 1=layer-y, 2=layer-yz, 3=distance'`
+ *       `.detail.receivedMode === <the rejected mode>`
+ *
+ * @fallback mode out-of-range is NEVER silently coerced to mode=0 —
+ * `Result.err` is the only fail-mode (charter P3 structured failure).
+ * AI users read `.code / .expected / .hint / .detail` properties to
+ * self-repair, NOT the human-readable `.message` string.
+ *
+ * @fallback yzAlpha range is intentionally not validated; mode=0 / mode=1
+ * ignore the field, mode=2 reads it. The silent-ignore is the
+ * documented charter P3 "legal default" boundary (plan-strategy D-4 +
+ * AC-18 path (3) carve-out).
+ *
+ * @example success path:
+ *   const r = setTransparentSortConfig(world,
+ *     { mode: TRANSPARENT_SORT_MODE_LAYER_YZ, yzAlpha: 0.5 });
+ *   if (!r.ok) return r;
+ *
+ * @example failure path:
+ *   const r = setTransparentSortConfig(world, { mode: 99, yzAlpha: 1.0 });
+ *   if (!r.ok) {
+ *     // r.error.code === 'resource-invalid-value'
+ *     // r.error.expected === 'mode \u2208 {0, 1, 2, 3}'
+ *     // r.error.hint === '0=layer-z, 1=layer-y, 2=layer-yz, 3=distance'
+ *     // r.error.detail.receivedMode === 99
+ *   }
+ */
+export function setTransparentSortConfig(
+  world: World,
+  cfg: TransparentSortConfig,
+): Result<void, ResourceInvalidValueError> {
+  if (!VALID_MODES.has(cfg.mode)) {
+    return err(
+      new ResourceInvalidValueError(EXPECTED_MODE, HINT_MODE, {
+        receivedMode: cfg.mode,
+        receivedKey: TRANSPARENT_SORT_CONFIG_KEY,
+      }),
+    );
+  }
+  world.insertResource<TransparentSortConfig>(TRANSPARENT_SORT_CONFIG_KEY, {
+    mode: cfg.mode,
+    yzAlpha: cfg.yzAlpha,
+  });
+  return ok(undefined);
+}

package/src/taa-history-store.ts

@@ -0,0 +1,429 @@
+import type {
+  CompiledRenderGraph,
+  GraphTexture,
+  GraphTextureView,
+  RenderGraphBuilder,
+  RenderGraphError,
+} from '@forgeax/engine-render-graph';
+import type { RhiDevice, RhiError, Texture, TextureFormat } from '@forgeax/engine-rhi';
+import { err, ok, type Result } from '@forgeax/engine-types';
+import {
+  GPU_TEXTURE_USAGE_COPY_SRC,
+  GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING,
+} from './gpu-texture-usage';
+import type { RenderPipelineFrame } from './render-pipeline';
+import type { TemporalHistoryDirection } from './temporal-frame-transaction';
+import type { TemporalView, TemporalViewResetReason } from './temporal-view';
+
+const HISTORY_FORMAT: TextureFormat = 'rgba16float';
+const HISTORY_TEXTURE_COUNT = 4;
+const RGBA16FLOAT_BYTES_PER_PIXEL = 8;
+const HISTORY_USAGE =
+  GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING | GPU_TEXTURE_USAGE_COPY_SRC;
+
+export type TaaHistoryResetReason =
+  | TemporalViewResetReason
+  | 'resize'
+  | 'format-changed'
+  | 'pipeline-owner-changed'
+  | 'world-detached'
+  | 'coverage-incomplete'
+  | 'environment-published'
+  | 'device-recovery';
+
+export interface TaaHistoryInspection {
+  readonly enabled: boolean;
+  readonly ownerGeneration: number;
+  readonly viewId: string | undefined;
+  readonly width: number;
+  readonly height: number;
+  readonly format: TextureFormat | undefined;
+  readonly direction: TemporalHistoryDirection;
+  readonly valid: boolean;
+  readonly resetReason: TaaHistoryResetReason | undefined;
+  readonly historyBytes: number;
+  readonly retiringGenerations: number;
+}
+
+export interface TaaHistoryPrepareInput {
+  readonly enabled: boolean;
+  readonly width: number;
+  readonly height: number;
+  readonly viewId: string;
+  readonly pipelineOwnerGeneration: number;
+  readonly surfaceFormat: TextureFormat;
+}
+
+export interface TaaHistoryGraphResources {
+  readonly colorRead: { readonly texture: GraphTexture; readonly view: GraphTextureView };
+  readonly colorWrite: { readonly texture: GraphTexture; readonly view: GraphTextureView };
+  readonly temporalRead: { readonly texture: GraphTexture; readonly view: GraphTextureView };
+  readonly temporalWrite: { readonly texture: GraphTexture; readonly view: GraphTextureView };
+}
+
+interface TaaHistoryConfig {
+  readonly width: number;
+  readonly height: number;
+  readonly viewId: string;
+  readonly pipelineOwnerGeneration: number;
+  readonly surfaceFormat: TextureFormat;
+}
+
+interface TaaHistoryGeneration {
+  readonly ownerGeneration: number;
+  readonly config: TaaHistoryConfig;
+  readonly textures: readonly [Texture, Texture, Texture, Texture];
+  readonly bytes: number;
+  refs: number;
+  abandoned: boolean;
+  destroyed: boolean;
+}
+
+export interface TaaHistoryPreparation {
+  readonly enabled: boolean;
+  readonly ownerGeneration: number;
+  readonly resetReason: TaaHistoryResetReason | undefined;
+  importResources(
+    graph: RenderGraphBuilder<RenderPipelineFrame>,
+  ): Result<TaaHistoryGraphResources | undefined, RenderGraphError>;
+}
+
+export interface TaaHistoryFrameAttempt {
+  readonly direction: TemporalHistoryDirection;
+  readonly valid: boolean;
+  readonly resetReason: TaaHistoryResetReason | undefined;
+  commit(): void;
+  abort(): void;
+}
+
+interface MutablePreparation extends TaaHistoryPreparation {
+  readonly generation: TaaHistoryGeneration | undefined;
+  readonly created: boolean;
+  state: 'prepared' | 'committed' | 'aborted';
+}
+
+function historyTextureIndex(
+  semanticIndex: number,
+  direction: TemporalHistoryDirection,
+): 0 | 1 | 2 | 3 {
+  const readOffset = direction === 'a-to-b' ? 0 : 1;
+  if (semanticIndex < 2) return (semanticIndex === 0 ? readOffset : 1 - readOffset) as 0 | 1;
+  return (semanticIndex === 2 ? readOffset + 2 : 3 - readOffset) as 2 | 3;
+}
+
+function configResetReason(
+  current: TaaHistoryGeneration | undefined,
+  next: TaaHistoryConfig,
+): TaaHistoryResetReason | undefined {
+  if (current === undefined) return 'first-frame';
+  if (current.config.width !== next.width || current.config.height !== next.height) return 'resize';
+  if (current.config.surfaceFormat !== next.surfaceFormat) return 'format-changed';
+  if (current.config.viewId !== next.viewId) return 'camera-switch';
+  if (current.config.pipelineOwnerGeneration !== next.pipelineOwnerGeneration) {
+    return 'pipeline-owner-changed';
+  }
+  return undefined;
+}
+
+function sameConfig(left: TaaHistoryConfig, right: TaaHistoryConfig): boolean {
+  return (
+    left.width === right.width &&
+    left.height === right.height &&
+    left.viewId === right.viewId &&
+    left.pipelineOwnerGeneration === right.pipelineOwnerGeneration &&
+    left.surfaceFormat === right.surfaceFormat
+  );
+}
+
+/** Renderer-owned active-view TAA history and compiled-graph generation leases. */
+export class TaaHistoryStore {
+  private active: TaaHistoryGeneration | undefined;
+  private readonly generations = new Set<TaaHistoryGeneration>();
+  private readonly graphGenerations = new WeakMap<object, TaaHistoryGeneration>();
+  private nextOwnerGeneration = 1;
+  private direction: TemporalHistoryDirection = 'a-to-b';
+  private valid = false;
+  private resetReason: TaaHistoryResetReason | undefined;
+  private forcedResetReason: TaaHistoryResetReason | undefined;
+  private disposed = false;
+
+  constructor(private readonly device: RhiDevice) {}
+
+  prepare(input: TaaHistoryPrepareInput): Result<TaaHistoryPreparation, RhiError> {
+    if (!input.enabled) return ok(this.preparation(undefined, false, undefined));
+    const config: TaaHistoryConfig = {
+      width: Math.max(1, Math.trunc(input.width)),
+      height: Math.max(1, Math.trunc(input.height)),
+      viewId: input.viewId,
+      pipelineOwnerGeneration: input.pipelineOwnerGeneration,
+      surfaceFormat: input.surfaceFormat,
+    };
+    const reusable =
+      this.forcedResetReason === undefined &&
+      this.active !== undefined &&
+      !this.active.destroyed &&
+      sameConfig(this.active.config, config)
+        ? this.active
+        : undefined;
+    if (reusable !== undefined) return ok(this.preparation(reusable, false, undefined));
+    const resetReason = this.forcedResetReason ?? configResetReason(this.active, config);
+    const created = this.allocate(config);
+    return created.ok ? ok(this.preparation(created.value, true, resetReason)) : created;
+  }
+
+  commitGraph(
+    graph: CompiledRenderGraph<RenderPipelineFrame>,
+    preparation: TaaHistoryPreparation,
+  ): void {
+    const mutable = preparation as MutablePreparation;
+    if (mutable.state !== 'prepared') return;
+    mutable.state = 'committed';
+    this.forcedResetReason = undefined;
+    if (mutable.generation === undefined) {
+      this.active = undefined;
+      this.direction = 'a-to-b';
+      this.valid = false;
+      this.resetReason = undefined;
+      return;
+    }
+    mutable.generation.refs += 1;
+    this.graphGenerations.set(graph, mutable.generation);
+    if (this.active !== mutable.generation) {
+      this.active = mutable.generation;
+      this.direction = 'a-to-b';
+      this.valid = false;
+      this.resetReason = mutable.resetReason;
+    }
+  }
+
+  abort(preparation: TaaHistoryPreparation): void {
+    const mutable = preparation as MutablePreparation;
+    if (mutable.state !== 'prepared') return;
+    mutable.state = 'aborted';
+    if (mutable.created && mutable.generation !== undefined) this.destroy(mutable.generation);
+  }
+
+  retireGraph(
+    graph: CompiledRenderGraph<RenderPipelineFrame>,
+  ): ReturnType<CompiledRenderGraph<RenderPipelineFrame>['retire']> {
+    const generation = this.graphGenerations.get(graph);
+    this.graphGenerations.delete(graph);
+    const retired = graph.retire();
+    if (generation !== undefined) {
+      retired.finally(() => this.release(generation)).catch(() => undefined);
+    }
+    return retired;
+  }
+
+  beginFrame(view: TemporalView | undefined, coverageComplete = true): TaaHistoryFrameAttempt {
+    const direction = this.direction;
+    const resetReason = !coverageComplete
+      ? 'coverage-incomplete'
+      : !this.valid &&
+          this.resetReason !== undefined &&
+          this.resetReason !== 'environment-published'
+        ? this.resetReason
+        : (view?.resetReason ?? this.resetReason);
+    const valid =
+      view !== undefined &&
+      coverageComplete &&
+      this.active !== undefined &&
+      this.valid &&
+      view.historyValid;
+    let state: 'active' | 'committed' | 'aborted' = 'active';
+    return {
+      direction,
+      valid,
+      resetReason,
+      commit: () => {
+        if (state !== 'active') return;
+        state = 'committed';
+        if (view === undefined || this.active === undefined) {
+          this.direction = 'a-to-b';
+          this.valid = false;
+          return;
+        }
+        this.direction = direction === 'a-to-b' ? 'b-to-a' : 'a-to-b';
+        this.valid = coverageComplete;
+        this.resetReason = coverageComplete
+          ? (view.resetReason ?? this.resetReason)
+          : 'coverage-incomplete';
+      },
+      abort: () => {
+        if (state === 'active') state = 'aborted';
+      },
+    };
+  }
+
+  invalidate(reason: TaaHistoryResetReason): void {
+    this.valid = false;
+    this.direction = 'a-to-b';
+    this.resetReason = reason;
+    this.forcedResetReason = reason;
+  }
+
+  inspect(): TaaHistoryInspection {
+    const active = this.active;
+    return {
+      enabled: active !== undefined,
+      ownerGeneration: active?.ownerGeneration ?? 0,
+      viewId: active?.config.viewId,
+      width: active?.config.width ?? 0,
+      height: active?.config.height ?? 0,
+      format: active === undefined ? undefined : HISTORY_FORMAT,
+      direction: this.direction,
+      valid: this.valid,
+      resetReason: this.resetReason,
+      historyBytes: active?.bytes ?? 0,
+      retiringGenerations: [...this.generations].filter(
+        (generation) => generation !== active && !generation.destroyed,
+      ).length,
+    };
+  }
+
+  resetForRecover(): void {
+    for (const generation of this.generations) generation.abandoned = true;
+    this.active = undefined;
+    this.direction = 'a-to-b';
+    this.valid = false;
+    this.resetReason = 'device-recovery';
+    this.forcedResetReason = 'device-recovery';
+  }
+
+  dispose(): void {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.active = undefined;
+    for (const generation of this.generations) {
+      if (generation.refs === 0) this.destroy(generation);
+    }
+  }
+
+  private allocate(config: TaaHistoryConfig): Result<TaaHistoryGeneration, RhiError> {
+    const textures: Texture[] = [];
+    for (let index = 0; index < HISTORY_TEXTURE_COUNT; index += 1) {
+      const created = this.device.createTexture({
+        label: `taa-history-${index}`,
+        size: { width: config.width, height: config.height, depthOrArrayLayers: 1 },
+        mipLevelCount: 1,
+        sampleCount: 1,
+        dimension: '2d',
+        format: HISTORY_FORMAT,
+        usage: HISTORY_USAGE,
+        textureBindingViewDimension: undefined,
+        viewFormats: [],
+      });
+      if (!created.ok) {
+        for (const texture of textures) this.device.destroyTexture(texture);
+        return err(created.error);
+      }
+      textures.push(created.value);
+    }
+    const generation: TaaHistoryGeneration = {
+      ownerGeneration: this.nextOwnerGeneration,
+      config,
+      textures: textures as unknown as readonly [Texture, Texture, Texture, Texture],
+      bytes: HISTORY_TEXTURE_COUNT * RGBA16FLOAT_BYTES_PER_PIXEL * config.width * config.height,
+      refs: 0,
+      abandoned: false,
+      destroyed: false,
+    };
+    this.nextOwnerGeneration += 1;
+    this.generations.add(generation);
+    return ok(generation);
+  }
+
+  private preparation(
+    generation: TaaHistoryGeneration | undefined,
+    created: boolean,
+    resetReason: TaaHistoryResetReason | undefined,
+  ): MutablePreparation {
+    const preparation: MutablePreparation = {
+      enabled: generation !== undefined,
+      ownerGeneration: generation?.ownerGeneration ?? 0,
+      resetReason,
+      generation,
+      created,
+      state: 'prepared',
+      importResources: (graph) => this.importResources(graph, generation),
+    };
+    return preparation;
+  }
+
+  private importResources(
+    graph: RenderGraphBuilder<RenderPipelineFrame>,
+    generation: TaaHistoryGeneration | undefined,
+  ): Result<TaaHistoryGraphResources | undefined, RenderGraphError> {
+    if (generation === undefined) return ok(undefined);
+    const labels = ['color-read', 'color-write', 'temporal-read', 'temporal-write'] as const;
+    const textures: GraphTexture[] = [];
+    const views: GraphTextureView[] = [];
+    for (let index = 0; index < labels.length; index += 1) {
+      const semanticIndex = index;
+      const texture = graph.importTexture(
+        `taa-history-${labels[index]}`,
+        {
+          format: HISTORY_FORMAT,
+          size: {
+            width: generation.config.width,
+            height: generation.config.height,
+            depthOrArrayLayers: 1,
+          },
+          mipLevelCount: 1,
+          sampleCount: 1,
+          dimension: '2d',
+          usage: HISTORY_USAGE,
+          viewFormats: [],
+        },
+        (frame) => {
+          const temporalFrame = (
+            frame as RenderPipelineFrame & {
+              readonly temporalFrame?: { readonly historyDirection: TemporalHistoryDirection };
+            }
+          ).temporalFrame;
+          if (temporalFrame === undefined) {
+            throw new RangeError('TAA history resolution requires an active temporal frame');
+          }
+          const physicalIndex = historyTextureIndex(semanticIndex, temporalFrame.historyDirection);
+          return generation.textures[physicalIndex] as Texture;
+        },
+      );
+      if (!texture.ok) return texture;
+      const view = graph.view(texture.value, { label: `taa-history-${labels[index]}.view` });
+      if (!view.ok) return view;
+      textures.push(texture.value);
+      views.push(view.value);
+    }
+    return ok({
+      colorRead: {
+        texture: textures[0] as GraphTexture,
+        view: views[0] as GraphTextureView,
+      },
+      colorWrite: {
+        texture: textures[1] as GraphTexture,
+        view: views[1] as GraphTextureView,
+      },
+      temporalRead: {
+        texture: textures[2] as GraphTexture,
+        view: views[2] as GraphTextureView,
+      },
+      temporalWrite: {
+        texture: textures[3] as GraphTexture,
+        view: views[3] as GraphTextureView,
+      },
+    });
+  }
+
+  private release(generation: TaaHistoryGeneration): void {
+    generation.refs = Math.max(0, generation.refs - 1);
+    if (generation.refs === 0 && generation !== this.active) this.destroy(generation);
+  }
+
+  private destroy(generation: TaaHistoryGeneration): void {
+    if (generation.destroyed) return;
+    generation.destroyed = true;
+    this.generations.delete(generation);
+    if (generation.abandoned) return;
+    for (const texture of generation.textures) this.device.destroyTexture(texture);
+  }
+}