@forgeax/engine-render 0.1.29 → 0.1.31

package/src/pipeline/render-extent.ts

@@ -0,0 +1,111 @@
+/** Immutable dimensions shared by every Standard graph consumer. */
+export interface RenderExtent {
+  readonly outputWidth: number;
+  readonly outputHeight: number;
+  readonly internalWidth: number;
+  readonly internalHeight: number;
+  readonly scale: number;
+  readonly generation: number;
+}
+
+export interface RenderExtentInput {
+  readonly outputWidth: number;
+  readonly outputHeight: number;
+  readonly requestedScale: number;
+  readonly generation: number;
+}
+
+export type RenderExtentDomain = 'internal' | 'output' | 'authoring';
+
+/** Project the immutable extent into a graph texture descriptor size. */
+export function renderExtentSize(
+  extent: RenderExtent,
+  domain: RenderExtentDomain,
+): { readonly width: number; readonly height: number } {
+  if (domain === 'internal') {
+    return { width: extent.internalWidth, height: extent.internalHeight };
+  }
+  return { width: extent.outputWidth, height: extent.outputHeight };
+}
+
+export type StandardLightingLane = 'direct' | 'clustered' | 'cpu-webgl2';
+
+export interface StandardExtentDomainPlan {
+  readonly extent: RenderExtent;
+  readonly lane: StandardLightingLane;
+  readonly topologyKey: string;
+  readonly dynamicDelta: 0 | 1;
+  readonly domains: {
+    readonly internal: { readonly width: number; readonly height: number };
+    readonly output: { readonly width: number; readonly height: number };
+    readonly authoring: { readonly width: number; readonly height: number };
+  };
+  readonly resources: readonly {
+    readonly name: string;
+    readonly domain: 'internal' | 'output' | 'authoring';
+  }[];
+}
+
+const MIN_SCALE = 0.5;
+const MAX_SCALE = 1;
+const SCALE_STEPS = 32;
+const AXIS_ALIGNMENT = 8;
+
+function alignedAxis(output: number, scale: number): number {
+  return Math.max(AXIS_ALIGNMENT, Math.floor((output * scale) / AXIS_ALIGNMENT) * AXIS_ALIGNMENT);
+}
+
+function finiteDimension(value: number): number {
+  return Math.max(1, Math.floor(value));
+}
+
+/** Derive the one immutable Standard extent before graph construction. */
+export function deriveRenderExtent(input: RenderExtentInput): RenderExtent {
+  const outputWidth = finiteDimension(input.outputWidth);
+  const outputHeight = finiteDimension(input.outputHeight);
+  const clamped = Math.min(MAX_SCALE, Math.max(MIN_SCALE, input.requestedScale));
+  const scale = Math.round(clamped * SCALE_STEPS) / SCALE_STEPS;
+  const nativeSurface = outputWidth < AXIS_ALIGNMENT || outputHeight < AXIS_ALIGNMENT;
+  const internalWidth = nativeSurface ? outputWidth : alignedAxis(outputWidth, scale);
+  const internalHeight = nativeSurface ? outputHeight : alignedAxis(outputHeight, scale);
+  return Object.freeze({
+    outputWidth,
+    outputHeight,
+    internalWidth,
+    internalHeight,
+    scale: nativeSurface ? 1 : scale,
+    generation: input.generation,
+  });
+}
+
+/** Describe Standard's shared internal/output/authoring domain assignment. */
+export function standardExtentDomainPlan(
+  extent: RenderExtent,
+  lane: StandardLightingLane,
+): StandardExtentDomainPlan {
+  const domains = {
+    internal: { width: extent.internalWidth, height: extent.internalHeight },
+    output: { width: extent.outputWidth, height: extent.outputHeight },
+    authoring: { width: extent.outputWidth, height: extent.outputHeight },
+  } as const;
+  return Object.freeze({
+    extent,
+    lane,
+    topologyKey: `standard:${extent.internalWidth}x${extent.internalHeight}:${extent.outputWidth}x${extent.outputHeight}:g${extent.generation}`,
+    dynamicDelta: extent.scale === 1 ? 0 : 1,
+    domains,
+    resources: Object.freeze([
+      { name: 'scene', domain: 'internal' },
+      { name: 'depth', domain: 'internal' },
+      { name: 'g-buffer', domain: 'internal' },
+      { name: 'scene-temporal', domain: 'internal' },
+      { name: 'ssao', domain: 'internal' },
+      { name: 'taa-history', domain: 'output' },
+      { name: 'bloom', domain: 'output' },
+      { name: 'output', domain: 'output' },
+      { name: 'overlay', domain: 'output' },
+      { name: 'observation', domain: 'output' },
+      { name: 'shadow', domain: 'authoring' },
+    ] satisfies StandardExtentDomainPlan['resources']),
+  });
+}

package/src/pipeline/standard-build-context.ts

@@ -0,0 +1,7 @@
+import type { RenderPipelineBuildContext, RenderPipelineFrame } from '../render-pipeline';
+import type { TargetCoverageAttachment } from '../temporal/target-coverage-attachment';
+
+/** Standard-only graph input; custom pipeline consumers never see coverage. */
+export type StandardPipelineBuildContext = RenderPipelineBuildContext<RenderPipelineFrame> & {
+  readonly targetCoverage?: TargetCoverageAttachment;
+};

package/src/pipeline/standard-forward-lane.ts

@@ -13,7 +13,6 @@ import {
 } from '../gpu-texture-usage';
 import type {
   RenderPipeline,
-  RenderPipelineBuildContext,
   RenderPipelineFrame,
   RenderPipelineTopology,
 } from '../render-pipeline';
@@ -28,6 +27,7 @@ import {
   createStandardSceneDataTarget,
   standardTemporalLaneAdmission,
 } from '../temporal/standard-scene-data';
+import { addTargetCoveragePass } from '../temporal/target-coverage-attachment';
 import {
   addTransmissionBackdropPasses,
   addTransmissionBackdropTemporalPass,
@@ -42,6 +42,8 @@ import {
 } from '../typed-render-graph-primitives';
 import { addTypedShadowPasses } from '../typed-shadow-passes';
 import { addAuthoredVolumetricFogPasses } from '../volume/passes';
+import { renderExtentSize } from './render-extent';
+import type { StandardPipelineBuildContext } from './standard-build-context';
 import {
   addStandardClusterMembershipPass,
   importStandardClusterBuffers,
@@ -59,7 +61,7 @@ function target(
 }
 
 function buildUrp(
-  context: RenderPipelineBuildContext<RenderPipelineFrame>,
+  context: StandardPipelineBuildContext,
   topology: RenderPipelineTopology,
   lighting: StandardTopologyInputValue,
 ): ReturnType<RenderPipeline['build']> {
@@ -67,6 +69,9 @@ function buildUrp(
   const surface = importRenderPipelineSurface(graph, topology);
   if (!surface.ok) return surface;
 
+  const internalSize =
+    topology.extent === undefined ? 'surface' : renderExtentSize(topology.extent, 'internal');
+
   const clearOnly = topology.clearOnly === true;
   const msaa = !clearOnly && topology.camera.antialias === 'msaa' && topology.lane.multisample;
   const hdr =
@@ -94,7 +99,7 @@ function buildUrp(
 
   const depth = target(graph, 'scene-depth', {
     format: 'depth24plus-stencil8',
-    size: 'surface',
+    size: internalSize,
     sampleCount: msaa ? 4 : 1,
   });
   if (!depth.ok) return depth;
@@ -111,7 +116,7 @@ function buildUrp(
     : hdr || fxaa || linearLdr || msaa || rawOnly || needsTemporalIntermediate
       ? target(graph, 'scene-color', {
           format: sceneFormat,
-          size: 'surface',
+          size: internalSize,
           sampleCount: 1,
           domain: 'linear-ldr',
           ...(sceneFormat === topology.surface.storageFormat &&
@@ -131,7 +136,7 @@ function buildUrp(
   const scene = msaa
     ? target(graph, 'scene-color-msaa', {
         format: sceneFormat,
-        size: 'surface',
+        size: internalSize,
         sampleCount: 4,
         domain: 'linear-ldr',
         ...(sceneFormat === topology.surface.storageFormat &&
@@ -145,7 +150,7 @@ function buildUrp(
   const reflectionFallback = topology.reflectionFallback?.enabled
     ? target(graph, 'reflection-fallback-linear-hdr', {
         format: 'rgba16float',
-        size: 'surface',
+        size: internalSize,
         sampleCount: scene.value.sampleCount,
         domain: 'linear-hdr',
         usage:
@@ -191,22 +196,22 @@ function buildUrp(
   const clusterReads =
     clusterBuffers.value === null ? [] : standardClusterReadAccesses(clusterBuffers.value);
 
-  const skybox =
-    topology.atmosphere === true
-      ? addAtmosphereBackground(graph, scene.value)
-      : addTypedSkyboxPass(graph, scene.value);
-  if (!skybox.ok) return skybox;
-  // The GPU-driven Standard PBR raster adapter owns one color target. A
-  // reflection fallback adds a second attachment to this pass, so keep that
-  // topology on the ordinary producer rather than binding a one-target
-  // pipeline into a multi-target render pass.
-  const gpuDriven =
-    reflectionFallback.value === undefined
-      ? context.projectGpuDriven({
-          format: scene.value.format,
-          sampleCount: scene.value.sampleCount,
-        })
-      : ok(undefined);
+  const atmosphere =
+    topology.atmosphere === true ? addAtmosphereBackground(graph, scene.value) : ok(undefined);
+  if (!atmosphere.ok) return atmosphere;
+  if (atmosphere.value === undefined) {
+    const skybox = addTypedSkyboxPass(graph, scene.value);
+    if (!skybox.ok) return skybox;
+  }
+  const gpuDriven = context.projectGpuDriven({
+    format: scene.value.format,
+    sampleCount: scene.value.sampleCount,
+    ...(reflectionFallback.value === undefined
+      ? {}
+      : {
+          additionalColorFormats: [reflectionFallback.value.format],
+        }),
+  });
   if (!gpuDriven.ok) return gpuDriven;
   const transmissionDemand = transmissionDemandForTopology(topology);
   const transmissionActive = resolveTransmissionBackdropTopology({
@@ -214,6 +219,7 @@ function buildUrp(
     sourceSampleCount: scene.value.sampleCount,
   }).active;
   const main = addTypedScenePass(graph, {
+    environment: atmosphere.value,
     name: 'main',
     color: scene.value,
     ...(reflectionFallback.value === undefined
@@ -265,12 +271,18 @@ function buildUrp(
     );
   }
   const temporal =
-    temporalDemand.targetCount === 1 ? createStandardSceneDataTarget(graph) : ok(undefined);
+    temporalDemand.targetCount === 1
+      ? createStandardSceneDataTarget(graph, topology.extent)
+      : ok(undefined);
   if (!temporal.ok) return temporal;
   if (temporal.value !== undefined) {
     const producer = addStandardSceneDataPass(graph, temporal.value.temporal, depth.value);
     if (!producer.ok) return producer;
   }
+  if (context.targetCoverage !== undefined) {
+    const coverage = addTargetCoveragePass(graph, context.targetCoverage);
+    if (!coverage.ok) return coverage;
+  }
 
   const transmission = addTransmissionBackdropPasses({
     graph,
@@ -283,6 +295,7 @@ function buildUrp(
   if (!transmission.ok) return transmission;
   if (transmission.value.topology.active) {
     const transmissionPass = addTypedScenePass(graph, {
+      environment: atmosphere.value,
       name: 'transmission-forward',
       color: scene.value,
       depth: depth.value,
@@ -307,6 +320,7 @@ function buildUrp(
     if (!transmissionPass.ok) return transmissionPass;
 
     const transparentPass = addTypedScenePass(graph, {
+      environment: atmosphere.value,
       name: 'transparent',
       color: scene.value,
       depth: depth.value,
@@ -401,9 +415,12 @@ function buildUrp(
     depth.value,
     surface.value,
     temporal.value?.temporal,
+    undefined,
+    context.targetCoverage?.coverage,
+    context.targetCoverage?.depth,
   );
   if (!post.ok) return post;
-  const cubeCaptures = context.contributeCubeCaptures?.();
+  const cubeCaptures = context.contributeCubeCaptures?.(atmosphere.value);
   if (cubeCaptures !== undefined && !cubeCaptures.ok) return cubeCaptures;
   return ok(undefined);
 }

package/src/pipeline/standard-pipeline.ts

@@ -31,6 +31,7 @@ import {
   createStandardSceneDataTarget,
   standardTemporalLaneAdmission,
 } from '../temporal/standard-scene-data';
+import { addTargetCoveragePass } from '../temporal/target-coverage-attachment';
 import {
   addTransmissionBackdropPasses,
   addTransmissionBackdropTemporalPass,
@@ -46,6 +47,8 @@ import {
 } from '../typed-render-graph-primitives';
 import { addTypedShadowPasses } from '../typed-shadow-passes';
 import { addAuthoredVolumetricFogPasses } from '../volume/passes';
+import { renderExtentSize } from './render-extent';
+import type { StandardPipelineBuildContext } from './standard-build-context';
 import { buildStandardForwardLane } from './standard-forward-lane';
 import {
   addStandardClusterMembershipPass,
@@ -160,13 +163,15 @@ function target(
 }
 
 function buildStandardDeferredLane(
-  context: RenderPipelineBuildContext<RenderPipelineFrame>,
+  context: StandardPipelineBuildContext,
   topology: RenderPipelineTopology,
   lighting: StandardTopologyInputValue,
 ): ReturnType<RenderPipeline['build']> {
   const graph = context.graph;
   const surface = importRenderPipelineSurface(graph, topology);
   if (!surface.ok) return surface;
+  const internalSize =
+    topology.extent === undefined ? 'surface' : renderExtentSize(topology.extent, 'internal');
   const buffers = importStandardClusterBuffers(graph, lighting);
   if (!buffers.ok) return buffers;
   const membership =
@@ -186,7 +191,7 @@ function buildStandardDeferredLane(
 
   const depth = target(graph, 'hdrp-depth', {
     format: 'depth24plus-stencil8',
-    size: 'surface',
+    size: internalSize,
   });
   if (!depth.ok) return depth;
   const depthSample = graph.view(depth.value.texture, {
@@ -197,26 +202,26 @@ function buildStandardDeferredLane(
   if (!depthSample.ok) return depthSample;
   const gbuffer0 = target(graph, 'gbuffer-normal-roughness', {
     format: DEFERRED_COLOR_FORMATS[0] ?? 'rgba16float',
-    size: 'surface',
+    size: internalSize,
   });
   if (!gbuffer0.ok) return gbuffer0;
   const gbuffer1 = target(graph, 'gbuffer-albedo-metallic', {
     format: DEFERRED_COLOR_FORMATS[1] ?? 'rgba8unorm',
-    size: 'surface',
+    size: internalSize,
   });
   if (!gbuffer1.ok) return gbuffer1;
   const gbuffer2 = target(graph, 'gbuffer-specular-response-ao', {
     format: DEFERRED_COLOR_FORMATS[2] ?? 'rgba16float',
-    size: 'surface',
+    size: internalSize,
   });
   if (!gbuffer2.ok) return gbuffer2;
-  const scene = target(graph, 'hdrp-scene-color', { format: 'rgba16float', size: 'surface' });
+  const scene = target(graph, 'hdrp-scene-color', { format: 'rgba16float', size: internalSize });
   if (!scene.ok) return scene;
   const reflectionFallback =
     topology.reflectionFallback?.enabled === true || topology.ssr?.status === 'admitted'
       ? target(graph, 'reflection-fallback-linear-hdr', {
           format: 'rgba16float',
-          size: 'surface',
+          size: internalSize,
           domain: 'linear-hdr',
         })
       : ok(undefined);
@@ -252,6 +257,11 @@ function buildStandardDeferredLane(
   const gpuDriven = context.projectGpuDriven({
     format: scene.value.format,
     sampleCount: scene.value.sampleCount,
+    ...(reflectionFallback.value === undefined
+      ? {}
+      : {
+          additionalColorFormats: [reflectionFallback.value.format],
+        }),
   });
   if (!gpuDriven.ok) return gpuDriven;
   const gbuffer = addTypedScenePass(graph, {
@@ -283,11 +293,13 @@ function buildStandardDeferredLane(
 
   // Initialize the background before receiver lighting. The skybox recorder
   // has no depth attachment, so placing it later would cover lit geometry.
-  const skybox =
-    topology.atmosphere === true
-      ? addAtmosphereBackground(graph, scene.value)
-      : addTypedSkyboxPass(graph, scene.value);
-  if (!skybox.ok) return skybox;
+  const atmosphere =
+    topology.atmosphere === true ? addAtmosphereBackground(graph, scene.value) : ok(undefined);
+  if (!atmosphere.ok) return atmosphere;
+  if (atmosphere.value === undefined) {
+    const skybox = addTypedSkyboxPass(graph, scene.value);
+    if (!skybox.ok) return skybox;
+  }
 
   // The lighting lane is the deferred Standard receiver. It deliberately
   // selects Forward passes for the same material handles that wrote the
@@ -297,6 +309,7 @@ function buildStandardDeferredLane(
   // the later forward lane excludes these handles so SSR composition is not
   // overwritten by a second draw.
   const lightingPass = addTypedScenePass(graph, {
+    environment: atmosphere.value,
     name: 'lighting',
     color: scene.value,
     colorTargets: [
@@ -333,12 +346,18 @@ function buildStandardDeferredLane(
   // blur. Insert it before the spatial chain so the graph dependency order is
   // explicit and one producer serves every temporal consumer.
   const temporal =
-    temporalDemand.targetCount === 1 ? createStandardSceneDataTarget(graph) : ok(undefined);
+    temporalDemand.targetCount === 1
+      ? createStandardSceneDataTarget(graph, topology.extent)
+      : ok(undefined);
   if (!temporal.ok) return temporal;
   if (temporal.value !== undefined) {
     const producer = addStandardSceneDataPass(graph, temporal.value.temporal, depth.value);
     if (!producer.ok) return producer;
   }
+  if (context.targetCoverage !== undefined) {
+    const coverage = addTargetCoveragePass(graph, context.targetCoverage);
+    if (!coverage.ok) return coverage;
+  }
 
   const sceneOutput: RenderPipelineTarget = scene.value;
   let secondaryReactivity: GraphTextureView | undefined;
@@ -409,6 +428,7 @@ function buildStandardDeferredLane(
     buffers.value === null ? [] : [...standardClusterReadAccesses(buffers.value)];
 
   const forward = addTypedScenePass(graph, {
+    environment: atmosphere.value,
     name: 'forward',
     color: sceneOutput,
     depth: depth.value,
@@ -449,6 +469,7 @@ function buildStandardDeferredLane(
   if (!transmission.ok) return transmission;
   if (transmission.value.topology.active) {
     const transmissionPass = addTypedScenePass(graph, {
+      environment: atmosphere.value,
       name: 'transmission-forward',
       color: sceneOutput,
       depth: depth.value,
@@ -478,6 +499,7 @@ function buildStandardDeferredLane(
     if (!transmissionPass.ok) return transmissionPass;
 
     const transparentPass = addTypedScenePass(graph, {
+      environment: atmosphere.value,
       name: 'transparent',
       color: sceneOutput,
       depth: depth.value,
@@ -570,9 +592,11 @@ function buildStandardDeferredLane(
     surface.value,
     temporal.value?.temporal,
     secondaryReactivity,
+    context.targetCoverage?.coverage,
+    context.targetCoverage?.depth,
   );
   if (!post.ok) return post;
-  const cubeCaptures = context.contributeCubeCaptures?.();
+  const cubeCaptures = context.contributeCubeCaptures?.(atmosphere.value);
   if (cubeCaptures !== undefined && !cubeCaptures.ok) return cubeCaptures;
   return ok(undefined);
 }
@@ -634,7 +658,11 @@ function standardTopology(
 ): RenderPipelineTopology {
   const config = {
     ...(topology.config ?? {}),
-    ssao: { enabled: profile.ssao },
+    ssao: {
+      ...(topology.config?.ssao ?? {}),
+      ...(typeof profile.ssao === 'object' ? profile.ssao : {}),
+      enabled: profile.ssao !== false,
+    },
   };
   return {
     ...topology,
@@ -653,6 +681,7 @@ function buildStandard(
   context: RenderPipelineBuildContext<RenderPipelineFrame>,
   topology: RenderPipelineTopology,
 ): ReturnType<RenderPipeline['build']> {
+  const standardContext = context as StandardPipelineBuildContext;
   const profile = profileFor(topology);
   if (!STANDARD_LIGHT_COUNTS.some((count) => count === profile.lightCount)) {
     return err(
@@ -675,11 +704,11 @@ function buildStandard(
   // A missing Camera is an intentional clear-only frame. Keep it on the
   // forward raster lane so clustered resources cannot introduce work.
   if (effective.clearOnly === true) {
-    return buildStandardForwardLane(context, effective, lighting.value);
+    return buildStandardForwardLane(standardContext, effective, lighting.value);
   }
   return profile.renderPath === 'forward'
-    ? buildStandardForwardLane(context, effective, lighting.value)
-    : buildStandardDeferredLane(context, effective, lighting.value);
+    ? buildStandardForwardLane(standardContext, effective, lighting.value)
+    : buildStandardDeferredLane(standardContext, effective, lighting.value);
 }
 
 export const standardPipeline: StandardPipeline = Object.freeze({

package/src/pipeline/standard-post.ts

@@ -170,6 +170,8 @@ export function addStandardPost(
   surface: StandardPostSurface,
   sceneTemporal?: RenderPipelineTarget,
   secondaryReactivity?: GraphTextureView,
+  coverage?: RenderPipelineTarget,
+  coverageDepth?: RenderPipelineTarget,
 ): Result<void, RenderPipelineBuildError> {
   const clearOnly = topology.clearOnly === true;
   const outputPlan = createStandardOutputPlan({
@@ -240,6 +242,8 @@ export function addStandardPost(
       scene,
       depth,
       currentTemporal: sceneTemporal,
+      ...(coverage === undefined ? {} : { coverage }),
+      ...(coverageDepth === undefined ? {} : { coverageDepth }),
       ...(secondaryReactivity === undefined ? {} : { secondaryReactivity }),
       historyColor: history.previousColor,
       historyTemporal: history.previousTemporal,

package/src/pipeline/standard-profile.ts

@@ -1,3 +1,4 @@
+import type { SsaoParameterConfig } from '../ssao-config';
 export const STANDARD_PIPELINE_ID = 'forgeax::standard' as const;
 export const STANDARD_LIGHT_COUNTS = [1, 32, 256] as const;
 export {
@@ -34,7 +35,7 @@ export interface StandardProfile {
   readonly shadows: StandardShadowMode;
   readonly pbr: boolean;
   readonly ibl: boolean;
-  readonly ssao: boolean;
+  readonly ssao: boolean | SsaoParameterConfig;
   /** Renderer-owned 1080p volume profile; tile width/height remain surface-derived. */
   readonly volumetricFog?: StandardVolumetricFogProfile | undefined;
   readonly postStages: typeof STANDARD_POST_STAGE_NAMES;

package/src/pipeline-builder.ts

@@ -161,6 +161,8 @@ export interface PipelineBuilderContext {
     readonly storageBuffer: boolean;
     readonly rgba16floatRenderable: boolean;
   };
+  /** The output-domain binary coverage variant uses an r8unorm attachment. */
+  readonly coverageOnly?: boolean | undefined;
 }
 
 /**
@@ -175,7 +177,10 @@ export interface PipelineBuilderContext {
  */
 export function validateTemporalPipelineContract(
   source: string,
-  ctx: Pick<PipelineBuilderContext, 'colorFormat' | 'depthFormat' | 'capabilities'>,
+  ctx: Pick<
+    PipelineBuilderContext,
+    'colorFormat' | 'depthFormat' | 'capabilities' | 'coverageOnly'
+  >,
 ): Result<void, RhiError> {
   if (!source.includes('fn vs_temporal') || !source.includes('fn fs_temporal')) {
     return err(
@@ -186,12 +191,16 @@ export function validateTemporalPipelineContract(
       }),
     );
   }
-  if (ctx.colorFormat !== 'rgba16float') {
+  const validCoverageTarget = ctx.coverageOnly === true && ctx.colorFormat === 'r8unorm';
+  if (ctx.colorFormat !== 'rgba16float' && !validCoverageTarget) {
     return err(
       new RhiError({
         code: 'shader-compile-failed',
         expected: 'temporal material target format is rgba16float',
-        hint: `temporal producer received color format ${ctx.colorFormat}; use its physical rgba16float target`,
+        hint:
+          ctx.coverageOnly === true
+            ? `coverage temporal producer received unsupported color format ${ctx.colorFormat}; use r8unorm`
+            : `temporal producer received color format ${ctx.colorFormat}; use its physical rgba16float target`,
       }),
     );
   }

package/src/plugin.ts

@@ -3,12 +3,14 @@ import type { Plugin } from '@forgeax/engine-plugin';
 import { Atmosphere } from './components/atmosphere';
 import { Camera } from './components/camera';
 import { DirectionalLight } from './components/directional-light';
+import { DynamicResolution } from './components/dynamic-resolution';
 import { Instances } from './components/instances';
 import { Layer } from './components/layer';
 import { LightProbe } from './components/light-probe';
 import { Lines } from './components/lines';
 import { MeshFilter } from './components/mesh-filter';
 import { MeshRenderer } from './components/mesh-renderer';
+import { MotionBlur } from './components/motion-blur';
 import { PointLight } from './components/point-light';
 import { PointLightShadow } from './components/point-light-shadow';
 import { Points } from './components/points';
@@ -30,11 +32,13 @@ const RENDER_COMPONENTS: readonly Component[] = [
   Atmosphere,
   Camera,
   DirectionalLight,
+  DynamicResolution,
   Instances,
   Layer,
   LightProbe,
   MeshFilter,
   MeshRenderer,
+  MotionBlur,
   PointLight,
   PointLightShadow,
   Points,

package/src/post-process-errors.ts

@@ -3,7 +3,7 @@
 //  feat-20260609-learn-render-4-5-framebuffers-demo-offscreen-rt-an M1 / T-2
 //  added 'fullscreen-input-not-found').
 //
-// Closed 7-member PostProcessErrorCode union + PostProcessError discriminated-union class.
+// Closed PostProcessErrorCode union + PostProcessError discriminated-union class.
 //   - 'post-process-already-registered' (programmer error) -> fullscreen effect registration THROWS a
 //     PostProcessError, mirroring ShaderCatalog.installMaterialArtifact's Map.has -> throw
 //     fail-fast (research Finding M2-4). A second register under the same id is a coding
@@ -38,7 +38,7 @@
 /**
  * Closed union of fullscreen post-process error codes.
  *
- * Exactly 7 members; AI users perform exhaustive `switch (err.code)` without a default
+ * AI users perform exhaustive `switch (err.code)` without a default
  * and TS guards completeness (AC-08).
  *
  * | code | channel | trigger |
@@ -134,21 +134,23 @@ export interface PostProcessParamsUpdateSizeMismatchDetail {
  * `detail` parameter to the variant payload at compile time.
  */
 export type PostProcessErrorDetailFor<C extends PostProcessErrorCode> =
-  C extends 'post-process-already-registered'
-    ? PostProcessPreviouslyRegisteredDetail
-    : C extends 'post-process-not-found'
-      ? PostProcessNotFoundDetail
-      : C extends 'fullscreen-input-not-found'
-        ? FullscreenInputNotFoundDetail
-        : C extends 'ssao-radius-non-positive'
-          ? SsaoRadiusNonPositiveDetail
-          : C extends 'ssao-bias-negative'
-            ? SsaoBiasNegativeDetail
-            : C extends 'params-size-mismatch'
-              ? PostProcessParamsSizeMismatchDetail
-              : C extends 'params-update-size-mismatch'
-                ? PostProcessParamsUpdateSizeMismatchDetail
-                : never;
+  C extends 'ssao-parameter-invalid'
+    ? { readonly paramName: string; readonly value: unknown }
+    : C extends 'post-process-already-registered'
+      ? PostProcessPreviouslyRegisteredDetail
+      : C extends 'post-process-not-found'
+        ? PostProcessNotFoundDetail
+        : C extends 'fullscreen-input-not-found'
+          ? FullscreenInputNotFoundDetail
+          : C extends 'ssao-radius-non-positive'
+            ? SsaoRadiusNonPositiveDetail
+            : C extends 'ssao-bias-negative'
+              ? SsaoBiasNegativeDetail
+              : C extends 'params-size-mismatch'
+                ? PostProcessParamsSizeMismatchDetail
+                : C extends 'params-update-size-mismatch'
+                  ? PostProcessParamsUpdateSizeMismatchDetail
+                  : never;
 
 /**
  * Tagged union of `.detail` payloads. The variants are unique by structural fields
@@ -170,7 +172,8 @@ const POST_PROCESS_POLICY = {
     expected: 'typed fullscreen plan references a registered post-process id',
     hint: (detail) =>
       `no post-process is registered for id '${(detail as PostProcessNotFoundDetail).id}'. ` +
-      `Register '${(detail as PostProcessNotFoundDetail).id}' with the feature host ({source, reads?}), ` +
+      'For Engine-owned effects, rebuild the shader manifest with that Engine entry enabled. ' +
+      `For custom effects, register '${(detail as PostProcessNotFoundDetail).id}' with the feature host ({source, reads?}), ` +
       'then reference it from a typed fullscreen RenderFeaturePlan.',
   },
   'fullscreen-input-not-found': {
@@ -187,6 +190,11 @@ const POST_PROCESS_POLICY = {
       );
     },
   },
+  'ssao-parameter-invalid': {
+    expected: 'finite non-negative SSAO intensity and low, medium, or high quality',
+    hint: () =>
+      'Set ssao.intensity to a finite non-negative value and ssao.quality to low, medium, or high.',
+  },
   'ssao-radius-non-positive': {
     expected: 'SSAO radius must be > 0',
     hint: (detail) => {