@forgeax/engine-render 0.1.32 → 0.1.33

package/src/gpu-driven/material-artifacts.ts

@@ -2,6 +2,7 @@ import type { MaterialShaderArtifact } from '@forgeax/engine-shader';
 import { gpuDrivenMaterialArtifactKey } from '../extract/gpu-driven';
 import type { RenderSystemInternals } from '../record/render-context';
 import type { DispatchEntry, RenderableSnapshot } from '../render-system-extract';
+import { hasRequiredVertexInputs } from './prepared-draw';
 
 type ArtifactRow = { readonly source: RenderableSnapshot; readonly renderableIndex: number };
 
@@ -136,13 +137,7 @@ export function collectGpuDrivenMaterialArtifacts({
         const shadowVertexInputsMatch =
           pass !== 'shadow' ||
           (receipt !== undefined &&
-            receipt.vertexInputs.length === prepared.vertexInputs.length &&
-            receipt.vertexInputs.every(
-              (input, index) =>
-                input.semantic === prepared.vertexInputs[index]?.semantic &&
-                input.location === prepared.vertexInputs[index]?.location &&
-                input.format === prepared.vertexInputs[index]?.format,
-            ));
+            hasRequiredVertexInputs(receipt.vertexInputs, prepared.vertexInputs));
         if (
           selectedIdentityArtifact === undefined ||
           receipt === undefined ||

package/src/gpu-driven/prepared-draw.ts

@@ -75,18 +75,23 @@ function failure(
   return { ok: false, error: new GpuDrivenPreparationError(code, detail) };
 }
 
-function sameVertexInputs(
+/**
+ * A material receipt declares the inputs its shader consumes. Geometry may
+ * carry additional authored attributes (for example an unused TEXCOORD_1),
+ * so admission checks required locations and formats without treating those
+ * producer-owned extras as an ABI mismatch.
+ */
+export function hasRequiredVertexInputs(
   expected: readonly MaterialShaderVertexInput[],
   actual: readonly MaterialShaderVertexInput[],
 ): boolean {
-  return (
-    expected.length === actual.length &&
-    expected.every(
-      (input, index) =>
-        input.semantic === actual[index]?.semantic &&
-        input.location === actual[index]?.location &&
-        input.format === actual[index]?.format,
-    )
+  return expected.every((input) =>
+    actual.some(
+      (candidate) =>
+        candidate.semantic === input.semantic &&
+        candidate.location === input.location &&
+        candidate.format === input.format,
+    ),
   );
 }
 
@@ -167,7 +172,7 @@ export function prepareGpuDrivenDraw(
       actual: `${input.geometry.vertexInputs.filter((vertex) => vertex.semantic.startsWith('uv')).length} geometry UV sets`,
     });
   }
-  if (!sameVertexInputs(receipt.vertexInputs, input.geometry.vertexInputs)) {
+  if (!hasRequiredVertexInputs(receipt.vertexInputs, input.geometry.vertexInputs)) {
     return failure('vertex-input-mismatch', {
       reason: 'vertex-semantic-mismatch',
       owner: 'geometry',

package/src/gpu-driven/production-raster.ts

@@ -84,7 +84,12 @@ import {
   type ShadowViewUpdateInput,
   shadowViewIdentityKey,
 } from './shadow-views';
-import { type GpuDrivenLodSelectionInspection, GpuDrivenView, selectGpuLodLane } from './view-gpu';
+import {
+  type GpuDrivenLodSelectionInspection,
+  type GpuDrivenLodSubmitIdentity,
+  GpuDrivenView,
+  selectGpuLodLane,
+} from './view-gpu';
 
 export interface StandardPbrSceneCandidate {
   readonly primitiveIndex: number;
@@ -2246,6 +2251,8 @@ export class GpuDrivenProduction {
     readonly activeEntityRevision?: number;
     /** Total extracted candidates, including facet-suppressed rows. */
     readonly telemetryCandidateCount?: number;
+    /** Public receipt identity for the GPU telemetry copy encoded this frame. */
+    readonly telemetrySubmit?: GpuDrivenLodSubmitIdentity;
     readonly occlusion?: OcclusionFrameProjection;
     /** Per-frame deltas from the existing RenderScene/GPU Scene/palette owners. */
     readonly structureMetrics?: GpuDrivenStructureMetrics;
@@ -2560,6 +2567,7 @@ export class GpuDrivenProduction {
     }
     const updated = this.view.update(filtered.plan, scene.scene, activeFrustum(input.camera));
     if (!updated.ok) return updated;
+    this.view.setTelemetrySubmit(input.telemetrySubmit);
     this.telemetryPrepared = true;
     const view = this.view;
     const visibleBuffer = view.visibleBuffer;
@@ -3638,11 +3646,49 @@ export class GpuDrivenProduction {
           this.laneReason = 'overflow';
         }
       }
-      if (selection === undefined || telemetryCandidateCount <= 0) return selection;
+      if (selection === undefined) return selection;
       if (filtered === undefined) return selection;
-      const preparedByBatchId = new Map(
-        filtered.batches.map((prepared) => [prepared.batch.batchId, prepared] as const),
+      type LodBatchAttribution = {
+        readonly batch: GpuDrivenBatch;
+        readonly worldKey: number;
+        readonly primitiveSlot: number;
+        readonly slotGeneration: number;
+      };
+      const preparedByBatchId = new Map<number, LodBatchAttribution>(
+        filtered.batches.map((prepared) => [
+          prepared.batch.batchId,
+          {
+            batch: prepared.batch,
+            worldKey: prepared.worldKey,
+            primitiveSlot: prepared.primitiveSlot,
+            slotGeneration: prepared.slotGeneration,
+          },
+        ]),
       );
+      // Selector-only batches remain in filtered.plan so their GPU counters
+      // can describe candidates suppressed from the raster admission lane.
+      // They have no PreparedBatch entry because no draw is encoded, but they
+      // still need the same World join for receipt attribution. Recover that
+      // metadata from the stable primitive slot instead of dropping the whole
+      // readback when the first such batch is encountered.
+      const filteredSlots = this.filteredCache?.slots;
+      const filteredWorldKeys = this.filteredCache?.worldKeys;
+      if (filteredSlots !== undefined) {
+        const slotByPrimitive = new Map(filteredSlots.map((slot) => [slot.slot, slot] as const));
+        for (const batch of filtered.plan.batches) {
+          if (preparedByBatchId.has(batch.batchId)) continue;
+          const candidate = batch.candidates[0];
+          const slot =
+            candidate === undefined ? undefined : slotByPrimitive.get(candidate.primitiveIndex);
+          if (slot === undefined) continue;
+          preparedByBatchId.set(batch.batchId, {
+            batch,
+            worldKey: filteredWorldKeys?.[slot.snapshot.worldId] ?? slot.snapshot.worldId,
+            primitiveSlot: slot.slot,
+            slotGeneration: slot.generation,
+          });
+        }
+      }
       const worldSelections = new Map<
         number,
         {
@@ -3655,9 +3701,33 @@ export class GpuDrivenProduction {
           readonly lodHistogram: Map<number, number>;
         }
       >();
+      const lodHistogram = new Map<number, number>();
+      // The selector visits the full captured plan, including candidates that
+      // the CPU visibility projection suppressed. Use that same plan for the
+      // LOD denominator so World attribution cannot fail merely because the
+      // two lanes have different frustum scopes.
+      let lodCandidateCount = 0;
+      let lodVisible = 0;
       for (const batchSelection of selection.batches) {
         const prepared = preparedByBatchId.get(batchSelection.batchId);
-        if (prepared === undefined) return selection;
+        if (prepared === undefined) return undefined;
+        // The GPU selector also visits ordinary GPU-driven meshes so one
+        // compact compute path can populate their indirect args. Those rows
+        // are level-0 by construction, but they are not LOD candidates and
+        // must not enter receipt-bound LOD attribution. Batch topology keeps
+        // LOD coverage/ranges in the grouping key, so a batch is expected to
+        // be homogeneous; fail closed if a producer violates that invariant
+        // instead of guessing a split for aggregate counters.
+        const lodCandidateRows = prepared.batch.candidates.filter(
+          (candidate) => (candidate.lodCoverages?.length ?? 0) > 1,
+        );
+        if (lodCandidateRows.length === 0) continue;
+        if (lodCandidateRows.length !== batchSelection.candidateCount) return undefined;
+        lodCandidateCount += batchSelection.candidateCount;
+        lodVisible += batchSelection.visible;
+        for (const row of batchSelection.lodHistogram) {
+          lodHistogram.set(row.level, (lodHistogram.get(row.level) ?? 0) + row.count);
+        }
         let aggregate = worldSelections.get(prepared.worldKey);
         if (aggregate === undefined) {
           aggregate = {
@@ -3683,8 +3753,14 @@ export class GpuDrivenProduction {
       }
       return {
         ...selection,
-        candidateCount: telemetryCandidateCount,
-        occluded: Math.max(0, telemetryCandidateCount - selection.visible),
+        candidateCount: lodCandidateCount,
+        visible: lodVisible,
+        occluded: Math.max(0, lodCandidateCount - lodVisible),
+        lodHistogram: Object.freeze(
+          [...lodHistogram.entries()]
+            .sort(([left], [right]) => left - right)
+            .map(([level, count]) => Object.freeze({ level, count })),
+        ),
         worldSelections: Object.freeze(
           [...worldSelections.values()].map((aggregate) =>
             Object.freeze({

package/src/gpu-driven/view-gpu.ts

@@ -302,8 +302,14 @@ type LodTelemetryCopy = {
   readonly buffers: ViewBuffers;
   readonly plan: SubmissionPlan;
   readonly resourceGeneration: number;
+  readonly submit?: GpuDrivenLodSubmitIdentity;
 };
 
+export interface GpuDrivenLodSubmitIdentity {
+  readonly frameId: number;
+  readonly deviceGeneration: number;
+}
+
 export interface GpuDrivenViewGraphResources {
   readonly primitive: GraphBuffer;
   readonly instance: GraphBuffer;
@@ -369,6 +375,8 @@ export interface GpuDrivenLodSelectionInspection {
   }[];
   readonly geometryWork: number;
   readonly rootGeometryWork: number;
+  /** Public receipt identity captured when the telemetry copy was encoded. */
+  readonly submit?: GpuDrivenLodSubmitIdentity;
 }
 
 function nextCapacity(required: number): number {
@@ -431,6 +439,8 @@ export class GpuDrivenView {
   private resourceGeneration = 0;
   /** The last readback copy that was actually encoded and is not consumed. */
   private telemetryPending: LodTelemetryCopy | undefined;
+  /** Receipt identity for the copy pass encoded by the current frame. */
+  private telemetrySubmit: GpuDrivenLodSubmitIdentity | undefined;
   /** Coalesce observers while the readback buffer is map-pending. */
   private lodSelectionReadback:
     | {
@@ -449,6 +459,10 @@ export class GpuDrivenView {
     private readonly labelPrefix: string,
   ) {}
 
+  setTelemetrySubmit(identity: GpuDrivenLodSubmitIdentity | undefined): void {
+    this.telemetrySubmit = identity;
+  }
+
   static create(input: {
     readonly device: RhiDevice;
     readonly shaderModuleFactory: PipelineBuilderShaderModuleFactory;
@@ -848,6 +862,7 @@ export class GpuDrivenView {
         ),
         geometryWork,
         rootGeometryWork,
+        ...(copy.submit === undefined ? {} : { submit: copy.submit }),
       });
       this.telemetryPending = undefined;
       return this.lodSelection;
@@ -1048,6 +1063,7 @@ export class GpuDrivenView {
             buffers,
             plan: submittedPlan,
             resourceGeneration: graphResourceGeneration,
+            ...(this.telemetrySubmit === undefined ? {} : { submit: this.telemetrySubmit }),
           };
         }
       },
@@ -1080,6 +1096,7 @@ export class GpuDrivenView {
     this.sceneMaterial = undefined;
     this.sceneCapacity = 0;
     this.telemetryPending = undefined;
+    this.telemetrySubmit = undefined;
     this.lodSelectionReadback = undefined;
     this.lodSelection = undefined;
     this.destroyAfterSubmittedWork(buffers);

package/src/gpu-scene.ts

@@ -17,6 +17,9 @@ import type { RenderSceneApplyResult, RenderSceneSlot } from './scene/render-sce
 
 export type { GpuSceneInspection } from './inspection-types';
 
+type GpuSceneTemporalSnapshot = NonNullable<RenderSceneSlot['snapshot']['temporal']>;
+type GpuSceneTemporalResolver = (slot: RenderSceneSlot) => GpuSceneTemporalSnapshot | undefined;
+
 const PRIMITIVE = GPU_SCENE_LAYOUTS.primitive;
 const INSTANCE = GPU_SCENE_LAYOUTS.instance;
 const TRANSFORM = GPU_SCENE_LAYOUTS.transform;
@@ -219,6 +222,56 @@ function coalesceSlots(
   return ranges;
 }
 
+/**
+ * Build a lookup from the current instance identity to its submitted ordinal.
+ * The GPU table is physically compacted by ordinal, so this small CPU lookup
+ * is the seam that keeps a stable logical instance from inheriting another
+ * row's previous transform after reorder. A missing or duplicate generation
+ * deliberately returns no proof and makes the caller seed the current pose.
+ */
+function previousInstanceOrdinals(
+  current: NonNullable<RenderSceneSlot['snapshot']['instances']> | undefined,
+  temporal: GpuSceneTemporalSnapshot | undefined,
+): Map<number, number> | undefined {
+  const previous = temporal?.previousInstances;
+  const currentGenerations = current?.generations;
+  const previousGenerations = previous?.generations;
+  if (
+    temporal?.motionValid !== true ||
+    current === undefined ||
+    previous === undefined ||
+    currentGenerations === undefined ||
+    previousGenerations === undefined ||
+    currentGenerations.length !== current.instanceCount ||
+    previousGenerations.length !== previous.instanceCount ||
+    current.transforms.length < current.instanceCount * 16 ||
+    previous.transforms.length < previous.instanceCount * 16
+  ) {
+    return undefined;
+  }
+  const currentSet = new Set<number>();
+  for (const generation of currentGenerations) {
+    if (generation === 0 || currentSet.has(generation)) return undefined;
+    currentSet.add(generation);
+  }
+  const ordinals = new Map<number, number>();
+  for (let ordinal = 0; ordinal < previousGenerations.length; ordinal += 1) {
+    const generation = previousGenerations[ordinal] ?? 0;
+    if (generation === 0 || ordinals.has(generation)) return undefined;
+    ordinals.set(generation, ordinal);
+  }
+  return ordinals;
+}
+
+function instanceIdentityChanged(
+  resident: Uint32Array | undefined,
+  current: Uint32Array | undefined,
+  ordinal: number,
+): boolean {
+  if (resident === undefined || current === undefined) return resident !== current;
+  return resident[ordinal] !== current[ordinal];
+}
+
 /** Persistent GPU tables derived only from renderer projection slots. */
 export class GpuScene {
   private disposed = false;
@@ -238,6 +291,8 @@ export class GpuScene {
   private sceneContentRevision = 0;
   private identityUploaded = false;
   private readonly allocations = new Map<number, PrimitiveAllocation>();
+  /** Current stable instance identities retained beside compact GPU rows. */
+  private readonly instanceGenerations = new Map<number, Uint32Array>();
   private readonly instances = new StableRangeAllocator();
   private readonly transforms = new StableRangeAllocator();
   private readonly draws = new StableRangeAllocator();
@@ -322,7 +377,10 @@ export class GpuScene {
     return allocation.materialStart + materialSlot;
   }
 
-  sync(delta: RenderSceneApplyResult): Result<GpuSceneSyncResult, RhiError> {
+  sync(
+    delta: RenderSceneApplyResult,
+    temporalResolver?: GpuSceneTemporalResolver,
+  ): Result<GpuSceneSyncResult, RhiError> {
     for (const transformIndex of this.pendingTemporalUploads) {
       this.writesByTable.transform.push(transformIndex);
     }
@@ -393,11 +451,11 @@ export class GpuScene {
     for (const record of publications) {
       const reset = newSlots.has(record.slot) || allocationResets.has(record.slot);
       if (reset || contentUpdatedSlotIds.has(record.slot)) {
-        this.writeSlot(record, reset, writesByTable);
+        this.writeSlot(record, reset, writesByTable, temporalResolver?.(record));
         continue;
       }
       if (instanceUpdatedSlotIds.has(record.slot))
-        this.writeInstanceTransforms(record, writesByTable);
+        this.writeInstanceTransforms(record, writesByTable, temporalResolver?.(record));
       this.writeRootTransform(record, false, writesByTable);
     }
     const uploaded = this.uploadRows(writesByTable);
@@ -459,6 +517,7 @@ export class GpuScene {
 
   rebuild(slots: readonly RenderSceneSlot[]): Result<GpuSceneSyncResult, RhiError> {
     this.allocations.clear();
+    this.instanceGenerations.clear();
     this.instances.reset();
     this.transforms.reset(1);
     this.draws.reset();
@@ -551,6 +610,7 @@ export class GpuScene {
     record: RenderSceneSlot,
     resetPrevious: boolean,
     writes: Record<GpuSceneTableName, number[]>,
+    temporal?: GpuSceneTemporalSnapshot,
   ): void {
     const allocation = this.allocations.get(record.slot);
     if (allocation === undefined) throw new RangeError('GPU Scene allocation unavailable');
@@ -610,6 +670,11 @@ export class GpuScene {
 
     const instance = new DataView(this.tableBytes.instance);
     const transform = this.transformView;
+    const instances = record.snapshot.instances;
+    const previousInstances = temporal?.previousInstances;
+    const previousOrdinals = previousInstanceOrdinals(instances, temporal);
+    const currentGenerations = instances?.generations;
+    const residentGenerations = this.instanceGenerations.get(record.slot);
     for (let ordinal = 0; ordinal < allocation.instanceCount; ordinal += 1) {
       const instanceIndex = allocation.instanceStart + ordinal;
       const instanceOffset = instanceIndex * INSTANCE.stride;
@@ -636,7 +701,7 @@ export class GpuScene {
         writeChangedU32(instance, instanceOffset + offset(INSTANCE, 'flags'), PRIMITIVE_ACTIVE) ||
         metadataChanged;
       if (allocation.instanceTransformCount > 0) {
-        const transforms = record.snapshot.instances?.transforms;
+        const transforms = instances?.transforms;
         const hasLocal = transforms !== undefined && transforms.length >= (ordinal + 1) * 16;
         const local = hasLocal ? transforms : IDENTITY_MATRIX;
         const sourceOffset = hasLocal ? ordinal * 16 : 0;
@@ -647,19 +712,66 @@ export class GpuScene {
           local,
           sourceOffset,
         );
-        if (resetPrevious)
-          writeChangedMat4(
-            transform,
-            localOffset + offset(TRANSFORM, 'previousWorld'),
-            local,
-            sourceOffset,
-          );
-        else if (changed) this.pendingTemporalTransforms.add(transformIndex);
-        if (changed || resetPrevious) writes.transform.push(transformIndex);
+        const identityChanged = instanceIdentityChanged(
+          residentGenerations,
+          currentGenerations,
+          ordinal,
+        );
+        if (resetPrevious) {
+          const previousOrdinal = previousOrdinals?.get(currentGenerations?.[ordinal] ?? 0);
+          const previousSource =
+            previousOrdinal === undefined || previousInstances === undefined
+              ? undefined
+              : previousInstances.transforms;
+          if (previousSource === undefined || previousOrdinal === undefined) {
+            writeChangedMat4(
+              transform,
+              localOffset + offset(TRANSFORM, 'previousWorld'),
+              local,
+              sourceOffset,
+            );
+          } else {
+            writeChangedMat4(
+              transform,
+              localOffset + offset(TRANSFORM, 'previousWorld'),
+              previousSource,
+              previousOrdinal * 16,
+            );
+            this.pendingTemporalTransforms.add(transformIndex);
+          }
+        } else if (changed || identityChanged) {
+          const previousOrdinal = previousOrdinals?.get(currentGenerations?.[ordinal] ?? 0);
+          const previousSource =
+            previousOrdinal === undefined || previousInstances === undefined
+              ? undefined
+              : previousInstances.transforms;
+          if (previousSource === undefined || previousOrdinal === undefined) {
+            // A changed row without an identity proof must not borrow the
+            // compacted row's old velocity. Seed only this row and keep other
+            // stable instances eligible for motion.
+            writeChangedMat4(
+              transform,
+              localOffset + offset(TRANSFORM, 'previousWorld'),
+              local,
+              sourceOffset,
+            );
+          } else {
+            writeChangedMat4(
+              transform,
+              localOffset + offset(TRANSFORM, 'previousWorld'),
+              previousSource,
+              previousOrdinal * 16,
+            );
+          }
+          this.pendingTemporalTransforms.add(transformIndex);
+        }
+        if (changed || identityChanged || resetPrevious) writes.transform.push(transformIndex);
       }
       if (metadataChanged || resetPrevious) writes.instance.push(instanceIndex);
     }
 
+    this.rememberInstanceGenerations(record.slot, currentGenerations, allocation.instanceCount);
+
     this.writeRootTransform(record, resetPrevious, writes);
     writes.primitive.push(record.slot);
 
@@ -740,6 +852,7 @@ export class GpuScene {
   private writeInstanceTransforms(
     record: RenderSceneSlot,
     writes: Record<GpuSceneTableName, number[]>,
+    temporal?: GpuSceneTemporalSnapshot,
   ): void {
     const allocation = this.allocations.get(record.slot);
     const instances = record.snapshot.instances;
@@ -749,21 +862,74 @@ export class GpuScene {
     if (allocation.instanceTransformCount !== instances.instanceCount) {
       throw new RangeError('GPU Scene instance update changed instance count');
     }
+    const previousOrdinals = previousInstanceOrdinals(instances, temporal);
+    const previousInstances = temporal?.previousInstances;
+    const currentGenerations = instances.generations;
+    const residentGenerations = this.instanceGenerations.get(record.slot);
     for (let ordinal = 0; ordinal < allocation.instanceTransformCount; ordinal += 1) {
       const transformIndex = allocation.instanceTransformStart + ordinal;
       const transformOffset = transformIndex * TRANSFORM.stride;
-      if (
-        writeChangedMat4(
-          this.transformView,
-          transformOffset + offset(TRANSFORM, 'currentWorld'),
-          instances.transforms,
-          ordinal * 16,
-        )
-      ) {
+      const changed = writeChangedMat4(
+        this.transformView,
+        transformOffset + offset(TRANSFORM, 'currentWorld'),
+        instances.transforms,
+        ordinal * 16,
+      );
+      const identityChanged = instanceIdentityChanged(
+        residentGenerations,
+        currentGenerations,
+        ordinal,
+      );
+      if (changed || identityChanged) {
+        const previousOrdinal = previousOrdinals?.get(currentGenerations?.[ordinal] ?? 0);
+        const previousSource =
+          previousOrdinal === undefined || previousInstances === undefined
+            ? undefined
+            : previousInstances.transforms;
+        if (previousSource === undefined || previousOrdinal === undefined) {
+          writeChangedMat4(
+            this.transformView,
+            transformOffset + offset(TRANSFORM, 'previousWorld'),
+            instances.transforms,
+            ordinal * 16,
+          );
+        } else {
+          writeChangedMat4(
+            this.transformView,
+            transformOffset + offset(TRANSFORM, 'previousWorld'),
+            previousSource,
+            previousOrdinal * 16,
+          );
+        }
         this.pendingTemporalTransforms.add(transformIndex);
         writes.transform.push(transformIndex);
       }
     }
+    this.rememberInstanceGenerations(
+      record.slot,
+      currentGenerations,
+      allocation.instanceTransformCount,
+    );
+  }
+
+  private rememberInstanceGenerations(
+    slot: number,
+    generations: Uint32Array | undefined,
+    instanceCount: number,
+  ): void {
+    if (generations === undefined || generations.length !== instanceCount) {
+      this.instanceGenerations.delete(slot);
+      return;
+    }
+    const resident = this.instanceGenerations.get(slot);
+    if (
+      resident !== undefined &&
+      resident.length === generations.length &&
+      resident.every((generation, ordinal) => generation === generations[ordinal])
+    ) {
+      return;
+    }
+    this.instanceGenerations.set(slot, generations.slice());
   }
 
   private writeRootTransform(
@@ -795,6 +961,7 @@ export class GpuScene {
     }
     const allocation = this.allocations.get(slot);
     if (allocation === undefined) return;
+    this.instanceGenerations.delete(slot);
     this.clearAllocation(allocation, writes);
     this.allocations.delete(slot);
   }

package/src/index.ts

@@ -37,6 +37,14 @@ export {
   ANTIALIAS_TAA,
   BLOOM_DISABLED,
   BLOOM_ENABLED,
+  CAMERA_BLOOM_INTENSITY_MAX,
+  CAMERA_BLOOM_INTENSITY_MIN,
+  CAMERA_BLOOM_SCATTER_MAX,
+  CAMERA_BLOOM_SCATTER_MIN,
+  CAMERA_BLOOM_SOFT_KNEE_MAX,
+  CAMERA_BLOOM_SOFT_KNEE_MIN,
+  CAMERA_BLOOM_THRESHOLD_MAX,
+  CAMERA_BLOOM_THRESHOLD_MIN,
   CAMERA_EXPOSURE_MODE_AUTO,
   CAMERA_EXPOSURE_MODE_MANUAL,
   CAMERA_PROJECTION_ORTHOGRAPHIC,
@@ -59,6 +67,7 @@ export {
   TONEMAP_NONE,
   TONEMAP_REINHARD,
   TONEMAP_REINHARD_EXTENDED,
+  validateCameraBloom,
   validateCameraColorGrading,
   validateCameraExposure,
 } from './components/camera.js';
@@ -155,6 +164,10 @@ export {
   createDynamicGeometryLifecycle,
   DynamicGeometryError,
 } from './dynamic-geometry.js';
+// The environment selector owns this structured recovery error. Keep the
+// class on the public environment path so consumers can branch by `code` and
+// inspect its typed `detail` without importing an owner-private module.
+export { SunCardinalityError } from './environment/frame.js';
 export type {
   EnvironmentInspection,
   EnvironmentInspectionFailure,
@@ -225,6 +238,22 @@ export {
   validateDepthOfFieldFrameParams,
   validateDepthOfFieldParams,
 } from './features/depth-of-field/depth-of-field-params.js';
+export type {
+  MotionBlurInvalidParamsDetail,
+  MotionBlurParams,
+  MotionBlurSampleTier,
+} from './features/motion-blur/motion-blur-params.js';
+export {
+  DEFAULT_MOTION_BLUR_PARAMS,
+  effectiveMotionBlurSampleCount,
+  isMotionBlurIntervalValid,
+  MotionBlurValidationError,
+  motionBlurExposureScale,
+  motionBlurSampleDelta,
+  motionBlurTemporalDemand,
+  resolveMotionBlurParams,
+  validateMotionBlurParams,
+} from './features/motion-blur/motion-blur-params.js';
 export type {
   RenderFeatureLogicalTarget,
   RenderFeatureMaterialShaderBindingContract,
@@ -273,7 +302,10 @@ export type {
   LightInspection,
   LodOcclusionInspection,
   MaterialTextureSourceInspection,
+  MotionBlurExecutionPass,
+  MotionBlurExecutionReceipt,
   MotionBlurInspection,
+  MotionBlurInspectionLane,
   MotionBlurInspectionStatus,
   ReflectionFallbackFailureStage,
   ReflectionFallbackInspection,