@forgeax/engine-render 0.1.7 → 0.1.20

package/src/record/view-ubo.ts

@@ -8,6 +8,7 @@
 
 import { mat4 } from '@forgeax/engine-math';
 import type { Buffer, RhiQueue } from '@forgeax/engine-rhi';
+import type { FogFrame } from '../extract/environment';
 import type { PointsLinesStyle } from '../points-lines/snapshot';
 import type { CameraSnapshot } from '../render-contract';
 import type {
@@ -15,6 +16,8 @@ import type {
   ExtractedLights,
   SpotLightSnapshot,
 } from '../render-system-extract';
+import type { TemporalView as LegacyTemporalView } from '../temporal/temporal-view';
+import type { TemporalView } from '../temporal/view';
 import { clampPcfKernelSize } from './frame-snapshot';
 import { computeProjectionMatrix, computeViewMatrix } from './helpers';
 
@@ -110,16 +113,34 @@ export function writeViewUbo(
   light: DirectionalLightSnapshot,
   lights: ExtractedLights,
   spotShadowSnapshots: readonly SpotLightSnapshot[],
+  fogOrTemporal?: FogFrame | TemporalView | LegacyTemporalView,
+  temporal?: TemporalView,
 ): void {
+  const isTemporal =
+    fogOrTemporal !== undefined &&
+    ('currentJitterUv' in fogOrTemporal || 'currentUnjitteredViewProjection' in fogOrTemporal);
+  const fog = isTemporal ? undefined : fogOrTemporal;
+  const resolvedTemporal = temporal ?? (isTemporal ? fogOrTemporal : undefined);
   // Compose worldViewProj once per frame (view * proj).
   const projMatrix = computeProjectionMatrix(camera);
   const viewMatrix = computeViewMatrix(camera);
-  const worldViewProj = mat4.create();
-  mat4.multiply(worldViewProj, projMatrix, viewMatrix);
+  const unjitteredViewProjection = mat4.create();
+  mat4.multiply(unjitteredViewProjection, projMatrix, viewMatrix);
+  const jitteredProjection = mat4.create();
+  if (resolvedTemporal?.currentJitterUv !== undefined) {
+    const jitter = mat4.identity(mat4.create());
+    jitter[12] = resolvedTemporal.currentJitterUv[0] * 2;
+    jitter[13] = resolvedTemporal.currentJitterUv[1] * -2;
+    mat4.multiply(jitteredProjection, jitter, projMatrix);
+  } else {
+    for (let i = 0; i < 16; i += 1) jitteredProjection[i] = projMatrix[i] ?? 0;
+  }
+  const mainProjection = mat4.create();
+  mat4.multiply(mainProjection, jitteredProjection, viewMatrix);
 
   const VIEW_PAYLOAD_FLOATS = 240;
   const viewPayload = new Float32Array(VIEW_PAYLOAD_FLOATS);
-  for (let i = 0; i < 16; i++) viewPayload[i] = worldViewProj[i] ?? 0;
+  for (let i = 0; i < 16; i++) viewPayload[i] = mainProjection[i] ?? 0;
   viewPayload[16] = (light.direction[0] ?? 0) * light.intensity;
   viewPayload[17] = (light.direction[1] ?? -1) * light.intensity;
   viewPayload[18] = (light.direction[2] ?? 0) * light.intensity;
@@ -137,7 +158,7 @@ export function writeViewUbo(
   // Host pre-computes mat4.invert so the skybox fragment shader avoids
   // per-pixel matrix inversion (charter P4 consistent abstraction).
   const inverseViewProj = mat4.create();
-  mat4.invert(inverseViewProj, worldViewProj);
+  mat4.invert(inverseViewProj, mainProjection);
   for (let i = 0; i < 16; i++) viewPayload[44 + i] = inverseViewProj[i] ?? 0;
   // lightViewProj[1..3] at [60..107].
   if (lights.lightViewProj !== undefined) {
@@ -149,6 +170,21 @@ export function writeViewUbo(
       }
     }
   }
+
+  // Temporal ABI tail: current and last-successful unjittered projections
+  // stay separate from the jittered main projection and never advance on a
+  // failed submission. The fixed 240-float payload already reserves these
+  // 36 slots at byte offsets 784..920.
+  const previous = resolvedTemporal?.previousUnjitteredViewProjection;
+  for (let i = 0; i < 16; i += 1) {
+    viewPayload[196 + i] = unjitteredViewProjection[i] ?? 0;
+    // No previous successful frame exists on first frame/reset. Keep this
+    // lane zeroed instead of copying current state into a history slot.
+    viewPayload[212 + i] = previous?.[i] ?? 0;
+  }
+  viewPayload[228] = camera.near;
+  viewPayload[229] = camera.far;
+  viewPayload[230] = camera.projection === 'orthographic' ? 1 : 0;
   // splitPlanes at [108], [112], [116], [120] (vec4 stride = 4 floats).
   if (lights.splitPlanes !== undefined) {
     for (let s = 0; s < 4; s++) {
@@ -202,6 +238,18 @@ export function writeViewUbo(
     }
   }
 
+  // Fog is a resource-owner semantic carried by the shared View ABI. Keep the
+  // disabled payload zeroed and write only the selected frame facts so both
+  // direct and clustered lanes consume the same owner projection.
+  if (fog !== undefined) {
+    viewPayload[232] = fog.color[0] ?? 0;
+    viewPayload[233] = fog.color[1] ?? 0;
+    viewPayload[234] = fog.color[2] ?? 0;
+    viewPayload[235] = fog.density;
+    viewPayload[236] = fog.heightFalloff;
+    viewPayload[237] = fog.maxOpacity;
+  }
+
   const viewUploadResult = queue.writeBuffer(viewUniformBuffer, 0, viewPayload);
   if (!viewUploadResult.ok) throw viewUploadResult.error;
 

package/src/render-contract.ts

@@ -3,11 +3,12 @@ import type { World } from '@forgeax/engine-ecs';
 import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
 import type { Vec3 } from '@forgeax/engine-math';
 import type { ProfileFrameToken, Profiler } from '@forgeax/engine-profiler';
-import type { RenderGraphError } from '@forgeax/engine-render-graph';
+import type { ColorValueDomain, RenderGraphError } from '@forgeax/engine-render-graph';
 import type {
   BindGroupLayout,
   Buffer,
   Result,
+  RhiCanvasSurfacePresentationProof,
   RhiCaps,
   RhiCommandEncoder,
   RhiDevice,
@@ -15,6 +16,7 @@ import type {
   RhiInstance,
   RhiRenderPassEncoder,
   RenderPipeline as RhiRenderPipeline,
+  Sampler,
   Texture,
   TextureFormat,
   TextureView,
@@ -23,16 +25,28 @@ import type { SkinError } from '@forgeax/engine-skinning';
 import type { ImageError } from '@forgeax/engine-types';
 import type { RhiBackendInstrumentation } from './assembly/backend-contract';
 import type { Antialias, BloomEnabled, Tonemap } from './components/camera';
+import type { EnvironmentInspection } from './environment/inspection';
 import type { RenderError } from './errors/render';
 import type { RenderFeature, RenderFeatureDiagnostics } from './features/types';
 import type { PostProcessShaderEntry } from './fullscreen-post-process-pass';
-import type { RenderSceneInspection } from './inspection-types';
-
+import type {
+  BloomInspection,
+  MotionBlurInspection,
+  RenderSceneInspection,
+  TemporalTargetInspection,
+  TransmissionInspection,
+} from './inspection-types';
+import type { TemporalInspection } from './temporal/inspection';
+
+export type { TransmissionInspection } from './inspection-types';
 export type { PointsLinesInspection } from './points-lines/inspection';
 
 import type { MeshMaterialBindingObservation } from './mesh-material-bindings';
 import type { StandardProfile } from './pipeline/standard-profile';
 import type { PostProcessError } from './post-process-errors';
+import type { VolumeTimingObservation } from './record/gpu-timing';
+import type { TemporalView } from './temporal/view';
+import type { VolumetricFogInspection } from './volume/inspection';
 
 export type RenderResult<T, E> =
   | { readonly ok: true; readonly value: T }
@@ -51,6 +65,10 @@ export type RenderWorldLease = RenderReadLease;
 export interface CameraSnapshot {
   /** Stable ECS identity used by the frame plan's camera authority fact. */
   readonly entityKey?: number;
+  /** World index supplied by the multi-world extract merge. */
+  readonly worldId?: number;
+  /** Camera-owned history generation forwarded into the frame plan. */
+  readonly historyVersion?: number;
   /** World-space camera translation (mat4.getTranslation of Transform.world). */
   readonly position: Vec3;
   /** Resolved world-space camera mat4, copied from Transform.world. */
@@ -74,10 +92,26 @@ export interface CameraSnapshot {
   readonly bloomIntensity: number;
   readonly bloomBlurRadius: number;
   readonly clearColor: readonly [number, number, number, number];
+  /** Renderer-owned temporal projection used by Standard's TAA producer. */
+  readonly temporal?: TemporalView;
+  /** Active-camera motion blur parameters, present only when demanded. */
+  readonly motionBlur?: {
+    readonly shutterAngle: number;
+    readonly maxRadiusPixels: number;
+    readonly sampleCount: number;
+  };
 }
 
-/** Stable identity owned by the Standard feature host for built-in tonemap. */
-export const STANDARD_TONEMAP_FEATURE_ID = 'forgeax::standard::tonemap';
+/** Stable identity owned by the Standard feature host for output transform. */
+export const STANDARD_OUTPUT_TRANSFORM_FEATURE_ID = 'forgeax::standard::output-transform';
+
+export type {
+  EnvironmentFrame,
+  EnvironmentSource,
+  FogFrame,
+  FramePlan,
+} from './extract/environment';
+export type { TemporalView } from './temporal/view';
 
 /**
  * Render-graph state exposed to pipeline declarations. Concrete pipeline
@@ -87,6 +121,14 @@ export const STANDARD_TONEMAP_FEATURE_ID = 'forgeax::standard::tonemap';
 interface RenderPipelineStateView {
   readonly format: TextureFormat;
   readonly colorAttachmentFormat: TextureFormat;
+  /** Renderer-owned View UBO shared by Standard lighting, shadows, and fog. */
+  readonly viewUniformBuffer: Buffer;
+  /** Renderer-owned SpotLight std430 buffer shared by Standard and volume. */
+  readonly pointLightsBuffer: Buffer;
+  readonly spotLightsBuffer: Buffer;
+  /** Fallback resources keep the shared view layout valid when no projector is authored. */
+  readonly defaultWhiteTextureView: TextureView;
+  readonly defaultSampler: Sampler;
 }
 
 /**
@@ -96,6 +138,16 @@ interface RenderPipelineStateView {
  */
 interface RenderPipelineRuntime {
   readonly device: RhiDevice;
+  /** Runtime-owned shader module factory used by built-in graph producers. */
+  readonly shaderModuleFactory?: {
+    createShaderModule(input: {
+      readonly code: string;
+      readonly label?: string | undefined;
+    }): import('@forgeax/engine-types').Result<
+      import('@forgeax/engine-rhi').ShaderModule,
+      RhiError
+    >;
+  };
   readonly errorRegistry: { fire(error: RendererError): void };
   readonly debugOverlay?: RenderDebugOverlay | undefined;
   readonly lookupPostProcess?: (id: string) => PostProcessShaderEntry | undefined;
@@ -139,6 +191,52 @@ export interface RenderPipelineContext {
   readonly msaaActive: boolean;
   readonly geometryColorResolveView: TextureView | null;
   readonly ldrSpriteColorView: TextureView | null;
+  /** Renderer-owned volume resources prepared from the authored ECS snapshot. */
+  readonly volumetricFog?: VolumetricFogFrameContext;
+  /** Renderer-owned SpotLight projector resources, independent of fog. */
+  readonly spotLightProjector?: SpotLightProjectorFrameContext;
+  /** Build-time composed utility sources for the renderer-owned volume passes. */
+  readonly volumetricFogShaders?: VolumetricFogShaderSources;
+}
+
+/** Stable utility entry-point sources emitted by the shader manifest. */
+export interface VolumetricFogShaderSources {
+  readonly inject: string;
+  readonly temporal: string;
+  readonly integrate: string;
+  readonly composite: string;
+}
+
+/**
+ * GPU resources for one validated volumetric-fog candidate.  The record stage
+ * owns residency and parameter uploads; graph passes consume this narrow view
+ * and never reach into AssetRegistry or World.
+ */
+export interface VolumetricFogFrameContext {
+  readonly densityTexture: Texture;
+  readonly densityView: TextureView;
+  readonly paramsBuffer: Buffer;
+  readonly densityGeneration: number;
+  /** Accepted graph-owned history slot; null means first frame/reset. */
+  readonly historyReadSlot: 0 | 1 | null;
+  /** Pending graph-owned history slot; promoted only after queue.submit succeeds. */
+  readonly historyWriteSlot: 0 | 1;
+  readonly historyValid: boolean;
+  /** Accepted SpotLight projector resources resolved by the GPU residency owner. */
+  readonly projectorTexture?: Texture;
+  readonly projectorView?: TextureView;
+  readonly projectorSampler?: Sampler;
+}
+
+/**
+ * GPU resources for the single surface SpotLight projector binding. The
+ * projector is a SpotLight-owned cookie and therefore remains available when
+ * volumetric fog is disabled; volume integration may reuse the same tuple.
+ */
+export interface SpotLightProjectorFrameContext {
+  readonly texture: Texture;
+  readonly view: TextureView;
+  readonly sampler: Sampler;
 }
 
 /**
@@ -243,6 +341,58 @@ export interface FrameReceiptObservation {
   readonly frameId: number;
   readonly deviceGeneration: number;
   readonly include: readonly ('timings' | 'draws' | 'bindings')[];
+  readonly timings?: VolumeTimingObservation;
+}
+
+/** Stable backend facts for the Standard output transform projection. */
+export interface RenderOutputInspection {
+  readonly outputTransform?: typeof STANDARD_OUTPUT_TRANSFORM_FEATURE_ID;
+  readonly displayEncoded: boolean;
+  readonly intermediateFormat?: TextureFormat;
+  /** Concrete surface route committed by configureSurface. */
+  readonly surfaceProfile?: 'dual-view' | 'raw-only';
+  /** Pass names from the same committed graph as the output facts. */
+  readonly graphPassNames: readonly string[];
+  /** Detached descriptor for the graph-owned output target, when present. */
+  readonly standardOutputColor?: RenderStandardOutputColorInspection;
+  readonly surfaceStorage: TextureFormat;
+  readonly surfaceDisplay: TextureFormat;
+  readonly endpoint: 'surface.storage.raw';
+  readonly capability: 'rgba16float-renderable' | 'surface-raw-endpoint' | 'unavailable';
+  readonly presentationProof?: RhiCanvasSurfacePresentationProof;
+  readonly error:
+    | {
+        readonly code: string;
+        readonly expected: string;
+        readonly hint: string;
+        readonly detail?: unknown;
+      }
+    | undefined;
+}
+
+/** Detached descriptor for the graph-owned display-encoded intermediate. */
+export interface RenderStandardOutputColorInspection {
+  readonly format: TextureFormat;
+  readonly domain?: ColorValueDomain;
+  readonly width: number;
+  readonly height: number;
+  readonly sampleCount: number;
+  readonly usage: number;
+}
+
+/** Stable identity refs for a renderer-owned frame observation. */
+export interface RenderObservationInspection {
+  readonly observationId: string;
+  readonly frameId: number;
+  /** Camera antialias mode used by the frame carrying this observation. */
+  readonly antialias?: Antialias;
+  /** Surface route committed for the same frame graph. */
+  readonly surfaceProfile?: 'dual-view' | 'raw-only';
+  /** Capability fact used when resolving a raw-only float target. */
+  readonly rgba16floatRenderable?: boolean;
+  /** Exact pass names and target descriptor from the committed graph. */
+  readonly passNames: readonly string[];
+  readonly standardOutputColor?: RenderStandardOutputColorInspection;
 }
 
 /**
@@ -260,18 +410,40 @@ export interface RenderInspection {
     readonly frameId: number;
     readonly deviceGeneration: number;
   };
+  /** Renderer-owned authored volume projection and submit/LKG state. */
+  readonly volumetricFog?: VolumetricFogInspection;
   readonly features: readonly string[];
   /** Truthful lifecycle facts for every registered declarative feature. */
   readonly featureDiagnostics: readonly RenderFeatureDiagnostics[];
   readonly frustumStats: { readonly culled: number; readonly total: number };
   readonly visibilityStats: { readonly explicitlyHidden: number };
   readonly renderScene: RenderSceneInspection;
+  /** Last completed transmission candidate facts, detached from GPU handles. */
+  readonly transmission?: TransmissionInspection;
   readonly meshMaterialBindings: readonly MeshMaterialBindingObservation[];
   readonly perFramePassNames: readonly string[];
   readonly bindGroupCounts: {
     readonly createBindGroup: number;
     readonly keys: readonly string[];
   };
+  /** Output transform facts; never includes fixture metrics or pixel bytes. */
+  readonly outputTransform?: typeof STANDARD_OUTPUT_TRANSFORM_FEATURE_ID;
+  readonly displayEncoded: boolean;
+  readonly intermediateFormat?: TextureFormat;
+  readonly surfaceStorage: TextureFormat;
+  readonly surfaceDisplay: TextureFormat;
+  readonly endpoint: 'surface.storage.raw';
+  readonly capability: RenderOutputInspection['capability'];
+  readonly presentationProof?: RhiCanvasSurfacePresentationProof;
+  readonly error: RenderOutputInspection['error'];
+  readonly observation: RenderObservationInspection;
+  readonly environment: EnvironmentInspection;
+  readonly temporal: TemporalInspection;
+  readonly bloom: BloomInspection;
+  /** Semantic Standard temporal target metadata; no graph or RHI handles. */
+  readonly temporalTarget?: TemporalTargetInspection;
+  /** Renderer-owned Motion Blur facts; absent when no component is active. */
+  readonly motionBlur?: MotionBlurInspection;
 }
 
 /** Backend marker — single-element union preserved for future extensibility (D-2). */
@@ -379,7 +551,8 @@ export const RENDER_GRAPH_EXECUTION_PHASE_CATALOG = [
   'record/graph-execute/forward/material-bind-groups',
   'record/graph-execute/forward/pipeline-selection',
   'record/graph-execute/forward/draw-submit',
-  'record/graph-execute/tonemap',
+  'record/graph-execute/output-transform',
+  'record/graph-execute/present',
   'record/graph-execute/debug-overlay',
   'record/graph-execute/shadow',
   'record/graph-execute/spot-shadow',
@@ -474,6 +647,8 @@ export interface RendererOptions {
   readonly standardProfile?: RenderProfile | undefined;
   /** Explicit profiler capability shared by App and Render. */
   readonly profiler?: Profiler | undefined;
+  /** Explicitly request timestamp-query for receipt-bound GPU profiling. */
+  readonly captureGpuTimings?: boolean | undefined;
   /** Optional host-owned RHI lifecycle instrumentation, such as recording. */
   readonly rhiInstrumentation?: RhiBackendInstrumentation | undefined;
   // feat-20260608-create-app-param-surface-trim / M1 / AC-02: `clearColor`

package/src/render-data.ts

@@ -15,7 +15,6 @@
 // GPU-resource kind would surface as a `tsc -b` exhaustiveness error at the
 // switch rather than a silent fallthrough (AC-06).
 
-import { numMipLevels } from '@forgeax/engine-assets-runtime';
 import {
   bytesPerRow as blockBytesPerRow,
   blockParamsForFormat,
@@ -29,9 +28,11 @@ import { err, ok, type Result } from '@forgeax/engine-rhi';
 import {
   ASSET_ERROR_HINTS,
   type AssetError,
+  deriveTextureLayout,
   type MeshAsset,
   type Submesh,
   type TextureAsset,
+  type TextureShape,
 } from '@forgeax/engine-types';
 import {
   GPU_TEXTURE_USAGE_COPY_DST,
@@ -88,12 +89,16 @@ export interface MeshRenderData {
   readonly submeshes: readonly Submesh[];
 }
 
-/** Descriptor for a 2D texture's GPU resource (projected from POD). */
+/** Descriptor for a sampled texture's GPU resource (projected from POD). */
 export interface TextureRenderData {
   /** Logical width retained for existing projection consumers. */
   readonly width: number;
   /** Logical height retained for existing projection consumers. */
   readonly height: number;
+  /** Authored shape; the residency layer must preserve this view dimension. */
+  readonly shape: TextureShape;
+  /** Array layers for `2d-array`, depth slices for `3d`, otherwise one. */
+  readonly depthOrArrayLayers: number;
   /** Authored content extent; TextureAsset remains the logical asset SSOT. */
   readonly logicalExtent: TextureExtent;
   /** GPU allocation extent, derived from format + logicalExtent. */
@@ -105,10 +110,10 @@ export interface TextureRenderData {
   readonly usage: number;
   /**
    * Row pitch for the BASE mip (level 0) the store passes to `writeTexture`.
-   * Uncompressed: `width * 4` (RGBA8). Block-compressed: the block-padded
-   * `ceil(width / blockW) * bytesPerBlock` (feat-20260707 M5 / w35, AC-08).
-   * The per-mip layout for a multi-level compressed upload comes from
-   * {@link deriveMipUploadLayout}.
+   * Derived from the canonical texture layout, so format-specific uncompressed
+   * widths (for example R8 density) and block-compressed widths stay aligned
+   * with the upload contract. The per-mip layout for a multi-level compressed
+   * upload comes from {@link deriveMipUploadLayout}.
    */
   readonly bytesPerRow: number;
   /** True iff `format` is a block-compressed format (drives the store's upload arm). */
@@ -262,6 +267,8 @@ export function deriveRenderDataMesh(mesh: MeshAsset): Result<MeshRenderData, As
  * inconsistent (a `-srgb` format requires an `srgb` colorSpace and vice versa).
  */
 export function deriveRenderDataTexture(tex: TextureAsset): Result<TextureRenderData, AssetError> {
+  const width = tex.shape.extent.width;
+  const height = tex.shape.extent.height;
   const isSrgbFormat = tex.format.endsWith('-srgb');
   const expectedColorSpace: 'srgb' | 'linear' = isSrgbFormat ? 'srgb' : 'linear';
   if (tex.colorSpace !== expectedColorSpace) {
@@ -275,14 +282,23 @@ export function deriveRenderDataTexture(tex: TextureAsset): Result<TextureRender
   }
 
   const compressed = isCompressedFormat(tex.format);
+  const layout = deriveTextureLayout({ shape: tex.shape, format: tex.format, mips: tex.mips });
+  if (!layout.ok) {
+    return err(
+      projectionError({
+        code: 'invalid-source-format',
+        expected: layout.error.expected,
+        hint: layout.error.hint,
+      }),
+    );
+  }
   // feat-20260707 M5 / w35 (AC-09, D-9): a block-compressed texture cannot have
   // its mips GPU-generated (F-7). An OFFLINE chain baked into `data`
   // (mipLevelCount > 1, e.g. a KTX2 level chain) is the normal compressed path
   // and passes; requesting RUNTIME mip generation (`mipmap:true` with no offline
   // chain) fails fast with a self-recovery hint (fail-fast at the projection
   // layer -- producer self-validate).
-  const hasOfflineMipChain = (tex.mipLevelCount ?? 1) > 1;
-  if (compressed && tex.mipmap === true && !hasOfflineMipChain) {
+  if (compressed && tex.mips.kind === 'generate') {
     return err(
       projectionError({
         code: 'mipgen-unsupported-compressed-format',
@@ -296,15 +312,19 @@ export function deriveRenderDataTexture(tex: TextureAsset): Result<TextureRender
   // Uncompressed: runtime mip-gen count from the pixel size. Compressed: the
   // level count is authored (offline chain) -- honour the POD's mipLevelCount,
   // never re-derive it from the size (a compressed chain may stop early).
-  const mipLevelCount = compressed
-    ? Math.max(1, tex.mipLevelCount ?? 1)
-    : tex.mipmap
-      ? numMipLevels(tex)
-      : 1;
+  const mipLevelCount = layout.value.levels.length;
 
-  const uncompressedBytesPerTexel =
-    tex.format === 'rgba32float' ? 16 : tex.format === 'rgba16float' ? 8 : 4;
-  if (!compressed && tex.data.byteLength < tex.width * tex.height * uncompressedBytesPerTexel) {
+  const baseLevel = layout.value.levels[0];
+  if (baseLevel === undefined) {
+    return err(
+      projectionError({
+        code: 'invalid-source-format',
+        expected: 'texture layout contains a base mip level',
+        hint: ASSET_ERROR_HINTS['invalid-source-format'],
+      }),
+    );
+  }
+  if (!compressed && tex.data.byteLength < baseLevel.byteLength) {
     return err(
       projectionError({
         code: 'invalid-source-format',
@@ -318,8 +338,8 @@ export function deriveRenderDataTexture(tex: TextureAsset): Result<TextureRender
   // from the format, not aggregate payload length: imported images may retain
   // trailing decoder bytes and offline mip chains contain more than the base mip.
   const bytesPerRow = compressed
-    ? (blockBytesPerRow(tex.format, tex.width) ?? tex.width * 4)
-    : tex.width * uncompressedBytesPerTexel;
+    ? (blockBytesPerRow(tex.format, width) ?? baseLevel.bytesPerRow)
+    : baseLevel.bytesPerRow;
 
   // Compressed formats are not renderable -- RENDER_ATTACHMENT would fail
   // createTexture validation, and the runtime mipmap blit (which needs it) never
@@ -333,9 +353,16 @@ export function deriveRenderDataTexture(tex: TextureAsset): Result<TextureRender
       GPU_TEXTURE_USAGE_COPY_SRC;
 
   return ok({
-    width: tex.width,
-    height: tex.height,
-    ...deriveTextureExtent(tex.format, tex.width, tex.height),
+    width,
+    height,
+    shape: tex.shape,
+    depthOrArrayLayers:
+      tex.shape.viewDimension === '2d'
+        ? 1
+        : tex.shape.viewDimension === '2d-array'
+          ? tex.shape.extent.layers
+          : tex.shape.extent.depth,
+    ...deriveTextureExtent(tex.format, width, height),
     format: tex.format,
     mipLevelCount,
     usage,
@@ -373,8 +400,9 @@ export function deriveRenderDataCubemap(source: TextureAsset): Result<CubeRender
       }),
     );
   }
+  const sourceHeight = source.shape.viewDimension === '2d' ? source.shape.extent.height : 0;
   return ok({
-    cubeFaceSize: source.height,
+    cubeFaceSize: sourceHeight,
     outputFormat: 'rgba16float',
     needsHalfConversion: source.format === 'rgba32float',
     cubeUsage:

package/src/render-graph-primitives.ts

@@ -665,7 +665,10 @@ function dispatchFullscreenPass(
   // the swap-chain path uses the backend-selected surface view format.
   let writeFormat = ctx.pipelineState?.colorAttachmentFormat ?? 'rgba8unorm-srgb';
   if (graphPass !== undefined) {
-    writeView = ctx.view;
+    // Typed graph passes must write their declared output target. The frame
+    // surface view is only the fallback for legacy passes; using it here
+    // leaves a typed output target cleared while the next pass samples it.
+    writeView = (resolveCtx?.resolve(color) as TextureView | undefined) ?? ctx.view;
     writeFormat = graphOutputFormat ?? writeFormat;
   } else if (rawSwapchainOutput && color === 'swapchain') {
     const rawViewRes = ctx.runtime.device.createTextureView(ctx.currentTexture, {});
@@ -733,6 +736,20 @@ function dispatchFullscreenPass(
     paramsBuffer,
     depthTexView,
     depthSampler,
+    built.extraColorBindings.map((binding, index) => {
+      const read = entry.reads?.filter(
+        (candidate) => typeof candidate === 'string' || candidate.sampleType !== 'depth',
+      )[index + 1];
+      const key = typeof read === 'string' ? read : read?.key;
+      const view = key === undefined ? undefined : resolveCtx?.resolve(key);
+      if (view === undefined) {
+        throw new PostProcessError({
+          code: 'fullscreen-input-not-found',
+          detail: { readsKey: key ?? 'additional-read', passName: name },
+        });
+      }
+      return { binding, view: view as TextureView };
+    }),
   );
   if (bindGroup === null) return;