@forgeax/engine-render 0.1.20 → 0.1.23

package/src/render-system-extract.ts

@@ -112,15 +112,12 @@ import {
   SpriteInstancesMutuallyExclusiveWithInstancesError,
   SpriteInstancesRequiresSpriteShaderError,
 } from '@forgeax/engine-ecs/projection';
+import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
 import { box3, frustum, type Mat4, mat4, type Vec3, vec3 } from '@forgeax/engine-math';
 import { AssetGuid, type AssetGuid as AssetGuidBytes } from '@forgeax/engine-pack/guid';
 import { RhiError } from '@forgeax/engine-rhi';
-import {
-  MorphWeights,
-  projectHierarchy,
-  type SceneHierarchySnapshot,
-  Transform,
-} from '@forgeax/engine-scene';
+import { GlobalTransform, MorphWeights, Transform } from '@forgeax/engine-scene';
+import type { MaterialShaderArtifact } from '@forgeax/engine-shader';
 import {
   JointCountMismatchError,
   JointEntityDanglingError,
@@ -131,6 +128,7 @@ import {
 import type {
   Asset,
   Handle,
+  IesProfileAsset,
   MaterialAsset,
   MaterialColorParameterSchema,
   MaterialParameter,
@@ -139,6 +137,7 @@ import type {
   MaterialTextureCoordinates,
   MaterialTextureValue,
   MeshAsset,
+  MeshLodLevel,
   ParamSchemaEntry,
   PrimitiveTopology,
   SkeletonAsset,
@@ -148,53 +147,84 @@ import {
   ASSET_ERROR_HINTS,
   AssetError,
   derive,
+  handleSlot,
   materialGuidText,
   materialValuesToLinearRuntime,
   toShared,
 } from '@forgeax/engine-types';
 import {
   Atmosphere,
+  antialiasFromF32,
+  bloomEnabledFromF32,
+  Camera,
+  CubeCamera,
+  cameraProjectionFromF32,
+  cubeCameraUpdateIntentFromF32,
   DirectionalLight,
   Fog,
   Instances,
   Layer,
+  LightProbe,
   Lines,
   MeshFilter,
   MeshRenderer,
+  MotionBlur,
   PointLight,
   PointLightShadow,
   Points,
   PostProcessParams,
   pointShapeFromU32,
+  RectAreaLight,
+  ReflectionProbe,
+  reflectionProbeUpdateIntentFromF32,
   SkyboxBackground,
   Skylight,
   SortKey,
   SpotLight,
   SpriteInstances,
   SpriteRegionOverride,
+  tonemapFromF32,
   tonemapToU32,
 } from './components';
+import {
+  type DirectionalShadowQuality,
+  directionalShadowQualityFromF32,
+} from './components/directional-shadow-filter';
 import { GlyphText } from './components/glyph-text';
-import { computeInvRangeSquared, degToCos } from './components/light-helpers';
+import {
+  computeInvRangeSquared,
+  degToCos,
+  type LightValidationError,
+  validateDirectionalLightData,
+  validateLightProbeData,
+  validateRectAreaLightData,
+} from './components/light-helpers';
 import { selectEnvironment } from './environment/frame';
 import {
   MaterialSkinAttrMissingError,
   ShadowInvalidConfigError,
   SkinMaterialMismatchError,
 } from './errors/render';
-import { extractCameraSnapshots } from './extract/camera';
+import {
+  type DirectionalShadowCascadeFit,
+  projectDirectionalShadow,
+} from './extract/directional-shadow-projection';
 import type {
   EnvironmentCandidate,
   EnvironmentFrame,
   FogCandidate,
   FogFrame,
+  FogSelectionFailure,
 } from './extract/environment';
+import { buildGpuDrivenDraws, resolvePreparedGpuDrivenDraw } from './extract/gpu-driven';
 import { resolveVisibility, type VisibilitySnapshot } from './extract/visibility';
 import type {
   RenderFeatureHiddenEntityReport,
   RenderFeatureWorldVisibilitySnapshot,
 } from './features/types';
 import { ensureGlyphMeshMaterialSlots } from './glyph-text-layout-system';
+import type { GpuDrivenGeometryReceipt } from './gpu-driven/prepared-draw';
+import { deriveInstancesUnionBounds } from './instances-derived-bounds';
 import {
   type MeshMaterialBindingDiagnostic,
   type MeshMaterialBindingSource,
@@ -203,13 +233,22 @@ import {
 import { isStandardPbrMaterialShader } from './pbr-pipeline';
 import { expandPointsLinesBounds } from './points-lines/bounds';
 import type { PointsLinesRetainedSnapshot, PointsLinesStyle } from './points-lines/snapshot';
-import { type CameraSnapshot, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID } from './render-contract';
+import { COOKIE_SLICE_CAPACITY, IES_SLICE_CAPACITY } from './prepare/extended-lighting/resources';
+import { prepareCookieProjection } from './prepare/extended-lighting/spot-modifiers';
+import type { ReflectionProbeFact } from './reflection/projection';
+import {
+  type CameraSnapshot,
+  type CubeCameraSnapshot,
+  STANDARD_OUTPUT_TRANSFORM_FEATURE_ID,
+} from './render-contract';
+import { SHADOW_ATLAS_DEFAULT_LAYERS } from './shadow-atlas';
+import { getActiveCamera, selectActiveCameraIndex } from './systems/active-camera';
 import { selectPasses } from './systems/pass-selector';
 
-export { extractCameraSnapshots } from './extract/camera';
-
 import type { SkinPaletteAllocator } from './systems/skin-palette-allocator';
 import type { SkinPaletteSlice } from './systems/skin-palette-types';
+import type { RenderTarget, RenderTargetTextureSource } from './targets/contracts';
+import { resolveRenderTargetMaterialSource } from './targets/material-source';
 import { resolveSelectedVolumetricLight } from './volume/capability';
 import {
   type ValidatedVolumetricFog,
@@ -252,23 +291,25 @@ export interface PointLightSnapshot {
   readonly invRangeSquared: number;
   /**
    * feat-20260612-point-light-shadows-urp-hdrp M1 / T-M1-8 + M4 / T-M4-4:
-   * cube_array atlas layer index for this light's shadow map (0..3 for shadow
-   * casters; sentinel `-1` for non-shadow lights). Default `-1` per
+   * cube_array atlas layer index for this light's shadow map (0..capacity-1
+   * for admitted shadow casters; sentinel `-1` for non-admitted lights).
+   * Default `-1` per
    * plan-strategy §D-2 — record stage / shader skips shadow sampling when the
    * lane equals the sentinel. Joined with `pointShadow[]` by entity at the
    * end of extract; HDRP record stage threads `shadowAtlasLayer + shadowNear +
-   * shadowFar` through `packLightSlot` as the §D-8 pad-lane payload.
+   * shadowFar` through the unified direct-light metadata payload.
    */
   readonly shadowAtlasLayer?: number;
   /**
    * Per-face perspective near plane (matches `PointLightShadow.nearPlane`).
-   * Used by HDRP `evalPointShadowed` for depth-ref reconstruction; rides
-   * `LightSlot.kind_and_pad.z` (byte 56..60) on the std430 std layout.
+   * Used by HDRP `evalPointShadowed` for depth-ref reconstruction; URP keeps
+   * the projection constants in its dedicated shadow-parameter buffer.
    */
   readonly shadowNear?: number;
   /**
    * Per-face perspective far plane (matches `PointLightShadow.farPlane`).
-   * Rides `LightSlot.kind_and_pad.w` (byte 60..64).
+   * It is consumed with the shadow atlas layer through the shared
+   * shadow-parameter buffer; DirectLightSlot carries only the layer identity.
    */
   readonly shadowFar?: number;
 }
@@ -290,9 +331,9 @@ export interface PointLightSnapshot {
  *
  * `mapSize` / `nearPlane` / `farPlane` ride here so record stage can size the
  * cube atlas faces and feed shader the proj constants without re-querying ECS.
- * `shadowAtlasLayer` is assigned by extract in spawn order (0 .. cap-1) so the
- * downstream LightSlot / packPointLight packers carry the layer index in
- * pointPadW (T-M1-8 will rename to shadowAtlasLayer).
+ * `shadowAtlasLayer` is assigned by extract in spawn order up to the renderer
+ * atlas capacity; over-budget requests retain the sentinel `-1` so the
+ * downstream DirectLightSlot packing carries no invalid layer identity.
  */
 export interface PointShadowSnapshot {
   /** Spawning entity index (joins PointLight + PointLightShadow + Transform). */
@@ -304,9 +345,9 @@ export interface PointShadowSnapshot {
   readonly nearPlane: number;
   readonly farPlane: number;
   /**
-   * Atlas layer assigned by extract in spawn order (0..cap-1, where cap=4
-   * matches PointLightShadow cardinality). Sentinel -1 is reserved by the
-   * shader-side LightSlot for no-shadow lights (T-M1-8).
+   * Atlas layer assigned by extract in spawn order while capacity remains.
+   * Sentinel -1 is used for a request that cannot be admitted and is
+   * reserved by the shader-side DirectLightSlot metadata for no-shadow lights.
    */
   readonly shadowAtlasLayer: number;
   /**
@@ -345,6 +386,27 @@ export interface SpotLightSnapshot {
   readonly invRangeSquared: number;
   readonly cosInner: number;
   readonly cosOuter: number;
+  /** Shared asset identities projected from the authored modifier fields. */
+  readonly iesProfileHandle?: number;
+  readonly cookieHandle?: number;
+  /** Resource-array slice identities; absent means the modifier falls back. */
+  readonly iesProfileSlice?: number;
+  readonly cookieSlice?: number;
+  /** Resolved authored payloads; absent means the renderer keeps identity LKG. */
+  readonly iesProfileData?: Uint8Array;
+  readonly cookieData?: Uint8Array;
+  /** Aspect-only UV matrix paired with `cookieSlice`; upload is dirty-ranged. */
+  readonly cookieMatrix?: Float32Array;
+  /**
+   * Legacy projector payload projected into the shared Cookie array lane when
+   * the adapter exposes the extended-lighting topology. The projector keeps
+   * its lightViewProj sampling semantics; only the texture transport is
+   * shared with authored Cookie resources.
+   */
+  readonly projectorSlice?: number;
+  readonly projectorData?: Uint8Array;
+  readonly projectorMatrix?: Float32Array;
+  readonly rollDeg?: number;
   // ── shadow fields (feat-20260625-spot-light-shadow-mapping M1) ──
   readonly castShadow: boolean;
   readonly lightViewProj: Float32Array | undefined;
@@ -365,20 +427,111 @@ export interface SpotLightSnapshot {
   readonly projectorRevision?: number;
 }
 
+/** RectArea direct-light snapshot carried by the unified slot contract. */
+export interface RectAreaDirectLightSnapshot {
+  readonly kind: 'rect-area';
+  readonly position: Vec3;
+  readonly color: Vec3;
+  readonly intensity: number;
+  readonly invRangeSquared: number;
+  readonly halfWidth: number;
+  readonly halfHeight: number;
+  readonly axisX: Vec3;
+  readonly axisY: Vec3;
+  readonly shadowAtlasTile?: number;
+}
+
+/** Normalized world-space frame used by Rect extraction, culling, and BRDF. */
+export interface RectAreaWorldFrame {
+  readonly center: Vec3;
+  readonly axisX: Vec3;
+  readonly axisY: Vec3;
+  readonly normal: Vec3;
+  readonly halfWidth: number;
+  readonly halfHeight: number;
+}
+
+/** Build the single normalized Rect frame shared by direct and cluster paths. */
+export function buildRectAreaWorldFrame(input: {
+  readonly center: ArrayLike<number>;
+  readonly axisX: ArrayLike<number>;
+  readonly axisY: ArrayLike<number>;
+  readonly width: number;
+  readonly height: number;
+}): RectAreaWorldFrame {
+  const center = vec3.create(input.center[0] ?? 0, input.center[1] ?? 0, input.center[2] ?? 0);
+  const axisX = vec3.normalize(
+    vec3.create(),
+    vec3.create(input.axisX[0] ?? 0, input.axisX[1] ?? 0, input.axisX[2] ?? 0),
+  );
+  const axisY = vec3.normalize(
+    vec3.create(),
+    vec3.create(input.axisY[0] ?? 0, input.axisY[1] ?? 0, input.axisY[2] ?? 0),
+  );
+  const normal = vec3.normalize(vec3.create(), vec3.cross(vec3.create(), axisX, axisY));
+  normal[0] = normal[0] === 0 ? 0 : (normal[0] ?? 0);
+  normal[1] = normal[1] === 0 ? 0 : (normal[1] ?? 0);
+  normal[2] = normal[2] === 0 ? 0 : (normal[2] ?? 0);
+  return {
+    center,
+    axisX,
+    axisY,
+    normal,
+    halfWidth: Math.max(0, input.width * 0.5),
+    halfHeight: Math.max(0, input.height * 0.5),
+  };
+}
+
+/** Return true only on the authored front side of a one-sided Rect. */
+export function rectAreaFacesPoint(frame: RectAreaWorldFrame, point: ArrayLike<number>): boolean {
+  const toPoint = vec3.create(
+    (point[0] ?? 0) - (frame.center[0] ?? 0),
+    (point[1] ?? 0) - (frame.center[1] ?? 0),
+    (point[2] ?? 0) - (frame.center[2] ?? 0),
+  );
+  return vec3.dot(frame.normal, toPoint) > 0;
+}
+
+/** Project a world point onto the finite authored Rect boundary. */
+export function closestPointOnRectArea(frame: RectAreaWorldFrame, point: ArrayLike<number>): Vec3 {
+  const toPoint = vec3.create(
+    (point[0] ?? 0) - (frame.center[0] ?? 0),
+    (point[1] ?? 0) - (frame.center[1] ?? 0),
+    (point[2] ?? 0) - (frame.center[2] ?? 0),
+  );
+  const localX = Math.min(
+    frame.halfWidth,
+    Math.max(-frame.halfWidth, vec3.dot(toPoint, frame.axisX)),
+  );
+  const localY = Math.min(
+    frame.halfHeight,
+    Math.max(-frame.halfHeight, vec3.dot(toPoint, frame.axisY)),
+  );
+  return vec3.create(
+    (frame.center[0] ?? 0) + (frame.axisX[0] ?? 0) * localX + (frame.axisY[0] ?? 0) * localY,
+    (frame.center[1] ?? 0) + (frame.axisX[1] ?? 0) * localX + (frame.axisY[1] ?? 0) * localY,
+    (frame.center[2] ?? 0) + (frame.axisX[2] ?? 0) * localX + (frame.axisY[2] ?? 0) * localY,
+  );
+}
+
 /**
- * LightSnapshot — discriminated union of the three KHR_lights_punctual
+ * LightSnapshot — discriminated union of the directional and punctual
  * variants. AI users + the record stage perform an exhaustive switch on
  * `kind`; missing arms are caught at compile time (no `default`,
  * `assertNever`-style guards). Plan-strategy R-10.
  */
-export type LightSnapshot = DirectionalLightSnapshot | PointLightSnapshot | SpotLightSnapshot;
+export type LightSnapshot =
+  | DirectionalLightSnapshot
+  | PointLightSnapshot
+  | SpotLightSnapshot
+  | RectAreaDirectLightSnapshot;
 
 /**
  * ExtractedLights — three-bucket output of the extractFrame three-query
  * union (M2 / w16 / AC-03). Plan-strategy section 3.1 EXT node:
  *   - `directional` — at most one (record-stage N>1 fail-fast lands in M3)
- *   - `point[]` — first-slice cap of 4 enforced at record stage (M3)
- *   - `spot[]`  — first-slice cap of 4 enforced at record stage (M3)
+ *   - `point[]` / `spot[]` / `rect[]` — authored local-light snapshots; the
+ *     record stage preserves this order in one bounded Cluster corpus
  * `directionalCount` exposes the raw count of DirectionalLight entities the
  * extract observed (so the record stage can fire `render-system-multi-light`
  * when N>1 without re-running the query). M3 / w19 will widen this with
@@ -390,6 +543,7 @@ export interface ExtractedLights {
   readonly directionalCount: number;
   readonly point: readonly PointLightSnapshot[];
   readonly spot: readonly SpotLightSnapshot[];
+  readonly rect: readonly RectAreaDirectLightSnapshot[];
   /**
    * feat-20260613-csm-cascaded-shadow-maps M2 / w9: per-cascade light-view-
    * projection matrices (one per cascade, length 4 pre-allocated). Each matrix
@@ -404,6 +558,7 @@ export interface ExtractedLights {
    * unused slots are 0.0f. Undefined when castShadow=false or no directional
    * light.
    */
+  /** Four vec4 lanes: split, worldUnitsPerTexel, lightDepthWorldSpan, reserved. */
   readonly splitPlanes: Float32Array | undefined;
   /**
    * feat-20260613-csm-cascaded-shadow-maps M2 / w9: effective cascade count
@@ -439,19 +594,17 @@ export interface ExtractedLights {
    * undefined otherwise.
    */
   readonly normalBias: number | undefined;
-  /**
-   * feat-20260621-merge-directionallightshadow-into-directionallight M2:
-   * pcfKernelSize from the merged DirectionalLight (PCF kernel width, odd>=1).
-   * Populated when castShadow=true on the first-hit directional light;
-   * undefined otherwise.
-   */
-  readonly pcfKernelSize: number | undefined;
+  /** Accepted closed Directional filter projected from the first query result. */
+  readonly directionalShadowQuality: DirectionalShadowQuality | undefined;
+  /** Structured author-config failure; the candidate is withheld from record. */
+  readonly directionalShadowError: LightValidationError | undefined;
   /**
    * feat-20260612-point-light-shadows-urp-hdrp M1 / T-M1-7:
    * shadow-casting point lights (PointLight + PointLightShadow + Transform
    * archetype join). Each entry carries the per-light 6-face VP matrices and
    * the assigned cube_array atlas layer (0..3 in spawn order; sentinel -1 is
-   * reserved by the shader-side LightSlot for no-shadow point lights).
+   * reserved by the shader-side DirectLightSlot metadata for no-shadow point
+   * lights).
    *
    * Empty array when no PointLightShadow components exist (zero-cost gate per
    * AC-09; record stage skips atlas allocation + shadow pass dispatch).
@@ -511,6 +664,15 @@ export interface SkylightSnapshot {
   readonly entityHandle: number;
 }
 
+/** Local diffuse probe facts; specular remains owned by Skylight/ReflectionProbe. */
+export interface LightProbeSnapshot {
+  readonly identity: string;
+  readonly position: readonly [number, number, number];
+  readonly radius: number;
+  readonly irradiance: Float32Array;
+  readonly admitted: boolean;
+}
+
 /**
  * SkyboxSnapshot -- extract-stage view of one SkyboxBackground entity
  * (feat-20260531-skybox-env-background M2 / w5).
@@ -567,6 +729,9 @@ export interface ExtractedVolumetricFog {
 export interface RenderableSnapshot {
   readonly assetHandle: number;
   readonly transform: TransformSnapshot;
+  /** Producer-authored lower-detail references projected from MeshAsset. */
+  readonly lods?: readonly MeshLodLevel[];
+  readonly lodHysteresis?: number;
   /** Finite producer-owned local bounds retained for persistent CPU view work. */
   readonly localAabb?: Float32Array;
   /** Indexed single-submesh facts consumed by the first GPU-driven rigid lane. */
@@ -674,6 +839,8 @@ export interface RenderableSnapshot {
   readonly temporal?: RenderableTemporalSnapshot;
   /** Detached M2 authoring facts for the optional Points/Lines projection. */
   readonly pointsLines?: PointsLinesRetainedSnapshot;
+  /** Renderer-owned per-object probe record uploaded at group(3) binding(1). */
+  readonly probeBlendRecord?: import('./scene/probe-blend-record').ProbeBlendRecord;
 }
 
 export type RenderablePreviousSource = 'last-submitted' | 'current-seed';
@@ -710,6 +877,16 @@ export interface GpuDrivenDrawSnapshot {
   readonly topology: PrimitiveTopology;
   readonly pipelineClass: string;
   readonly materialResourceClass: string;
+  /** Producer-owned prepared ABI facts used by the Standard PBR GPU lane. */
+  readonly prepared?: import('./gpu-driven/prepared-draw').PreparedGpuDrivenDraw;
+  /** Optional projected height supplied by direct GPU-view evidence/tests. */
+  readonly projectedHeight?: number;
+  /** Root plus lower-detail index/vertex ranges, in LOD order. */
+  readonly lodRanges?: readonly {
+    readonly first: number;
+    readonly count: number;
+    readonly baseVertex: number;
+  }[];
 }
 
 export interface InstancesSnapshot {
@@ -762,7 +939,7 @@ export interface SpriteInstancesSnapshot {
 /**
  * TransformSnapshot: extract-stage view of one entity's resolved world
  * transform (feat-20260601 D-3). Holds the single `world` mat4 (column-major
- * 16 floats, copied from the entity's `Transform.world` view written by
+ * 16 floats, copied from the entity's `GlobalTransform.world` view written by
  * propagateTransforms). The record stage copies these 16 floats straight into
  * the mesh SSBO slot (zero `mat4.compose`); position / scale consumers derive
  * from the mat4 via `mat4.getTranslation` / basis-column lengths.
@@ -851,6 +1028,8 @@ export interface MaterialSnapshot {
    * them in a lightmap injection region.
    */
   readonly textureHandles?: ReadonlyMap<string, Handle<'TextureAsset', 'shared'>> | undefined;
+  /** Renderer-local target sources; never projected as TextureAsset handles. */
+  readonly textureSources?: ReadonlyMap<string, RenderTargetTextureSource> | undefined;
   /**
    * User-region texture field names whose paramValue resolved to a VideoAsset
    * (kind `'video'`) rather than a static TextureAsset
@@ -948,20 +1127,6 @@ export interface MaterialSnapshotCacheEntry {
 export type MaterialSnapshotCache = Map<number, MaterialSnapshotCacheEntry>;
 export type MaterialSnapshotCachesByWorld = WeakMap<World, MaterialSnapshotCache>;
 
-function gpuDrivenMaterialResourceClass(material: MaterialSnapshot): string {
-  const textures = [...(material.textureHandles?.entries() ?? [])]
-    .map(([name, handle]) => [name, Number(handle)] as const)
-    .sort(([left], [right]) => left.localeCompare(right));
-  const samplers = [...(material.samplerHandles?.entries() ?? [])]
-    .map(([name, handle]) => [name, Number(handle)] as const)
-    .sort(([left], [right]) => left.localeCompare(right));
-  return JSON.stringify({
-    textures,
-    samplers,
-    video: [...(material.videoTextureFields?.keys() ?? [])].sort(),
-  });
-}
-
 // === DispatchEntry — M3 / w26 single dispatch list (feat-20260526-material-asset-multipass-renderstate) ===
 //
 // Plan-strategy D-3: single dispatch list sorted by queue value,
@@ -1060,6 +1225,12 @@ function appendMaterialDispatchEntries(
 
 export interface ExtractedFrame {
   readonly cameras: CameraSnapshot[];
+  /** Auxiliary target cameras selected after the display camera is fixed. */
+  readonly auxiliaryCameras: readonly CameraSnapshot[];
+  /** Cube capture intents extracted beside the display camera in one pass. */
+  readonly cubeCameras: readonly CubeCameraSnapshot[];
+  /** Reflection probe facts projected from the same World extraction. */
+  readonly reflectionProbes?: readonly ReflectionProbeFact[];
   readonly lights: ExtractedLights;
   /** Resource-owner environment facts selected once at the extract boundary. */
   readonly environment: EnvironmentFrame | undefined;
@@ -1076,10 +1247,14 @@ export interface ExtractedFrame {
   readonly dispatch: DispatchEntry[];
   readonly skylight: SkylightSnapshot | undefined;
   readonly skylightCount: number;
+  /** World-local diffuse probe candidates; never a direct-light slot. */
+  readonly lightProbes?: readonly LightProbeSnapshot[];
   readonly skybox: SkyboxSnapshot | undefined;
   readonly skyboxCount: number;
   /** Resource-owner Fog facts selected once at the frame boundary. */
   readonly fog: FogFrame | undefined;
+  /** Last invalid Fog update retained alongside the current valid/LKG frame. */
+  readonly fogFailure?: FogSelectionFailure;
   /**
    * feat-20260528-frustum-culling M3 / w11: frustum culling statistics
    * collected during the extract phase. `total` is the count of entities
@@ -1105,6 +1280,65 @@ export interface ExtractedFrame {
   readonly hiddenEntityReports: readonly RenderFeatureHiddenEntityReport[];
 }
 
+export type CameraTargetUpdate = 'once' | 'on-demand' | 'continuous';
+
+export interface CameraTargetCandidate {
+  readonly worldId: number;
+  readonly entityKey: number;
+  readonly target?: RenderTarget;
+  readonly requestVersion: number;
+  readonly update: CameraTargetUpdate;
+}
+
+export interface CameraTargetRejection {
+  readonly entityKey: number;
+  readonly reason: 'budget' | 'display-target' | 'duplicate-target';
+}
+
+export interface CameraTargetSelection {
+  readonly display: CameraTargetCandidate | undefined;
+  readonly auxiliary: readonly CameraTargetCandidate[];
+  readonly rejected: readonly CameraTargetRejection[];
+}
+
+export function selectCameraTargetViews(
+  candidates: readonly CameraTargetCandidate[],
+  options: { readonly displayEntityKey?: number; readonly budget: number },
+): CameraTargetSelection {
+  const display = candidates.find(
+    (candidate) =>
+      candidate.entityKey === options.displayEntityKey && candidate.target === undefined,
+  );
+  const rejected: CameraTargetRejection[] = [];
+  const ordered = candidates
+    .filter((candidate) => candidate.target !== undefined)
+    .sort((left, right) => left.worldId - right.worldId || left.entityKey - right.entityKey);
+  const auxiliary: CameraTargetCandidate[] = [];
+  const seenTargets = new Set<RenderTarget>();
+  for (const candidate of ordered) {
+    const duplicate = candidate.target !== undefined && seenTargets.has(candidate.target);
+    if (candidate.target !== undefined) seenTargets.add(candidate.target);
+    if (candidate.entityKey === options.displayEntityKey) {
+      rejected.push({ entityKey: candidate.entityKey, reason: 'display-target' });
+      continue;
+    }
+    if (candidate.target === undefined || duplicate) {
+      rejected.push({ entityKey: candidate.entityKey, reason: 'duplicate-target' });
+      continue;
+    }
+    if (auxiliary.length >= Math.max(0, options.budget)) {
+      rejected.push({ entityKey: candidate.entityKey, reason: 'budget' });
+      continue;
+    }
+    auxiliary.push(candidate);
+  }
+  return {
+    display,
+    auxiliary: Object.freeze(auxiliary),
+    rejected: Object.freeze(rejected),
+  };
+}
+
 /**
  * Internal world surface used by extract for archetype-graph traversal and
  * error routing. The packed `Entity` handle for a row is read directly from
@@ -1147,6 +1381,14 @@ function createWorldInternalView(world: World): WorldInternalView {
   };
 }
 
+function resolveCameraTarget(world: World, raw: number | undefined): RenderTarget | undefined {
+  if (raw === undefined || raw <= 0) return undefined;
+  const resolved = world.sharedRefs.resolve<'RenderTarget', RenderTarget>(
+    toShared<'RenderTarget'>(Math.round(raw)),
+  );
+  return resolved.ok ? resolved.value : undefined;
+}
+
 /**
  * The user-region texture fields the built-in standard-PBR material declares.
  * Used as the fallback texture-field set when the shader id is not registered
@@ -1427,6 +1669,24 @@ function collectMaterialTextureCoordinates(
   return out;
 }
 
+function collectMaterialTextureSources(
+  values: Readonly<Record<string, unknown>>,
+  world: World,
+): Map<string, RenderTargetTextureSource> {
+  const out = new Map<string, RenderTargetTextureSource>();
+  for (const [field, value] of Object.entries(values)) {
+    const reference = materialTextureRef(value);
+    if (typeof reference !== 'number') continue;
+    const resolved = world.sharedRefs.resolve<
+      'RenderTargetTextureSource',
+      RenderTargetTextureSource
+    >(toShared<'RenderTargetTextureSource'>(reference));
+    if (!resolved.ok || resolveRenderTargetMaterialSource(resolved.value) === undefined) continue;
+    out.set(field, resolved.value);
+  }
+  return out;
+}
+
 function collectMaterialTextureSamplers(
   values: Readonly<Record<string, unknown>>,
   resolveSampler: (value: unknown) => Handle<'SamplerAsset', 'shared'> | undefined,
@@ -1517,9 +1777,14 @@ function materialParametersToParamSchema(
   return parameters.flatMap((parameter): ParamSchemaEntry[] => {
     // Boolean material values are runtime-only and have no UBO representation.
     if (parameter.type === 'bool') return [];
-    if (parameter.type === 'texture') {
+    if (parameter.type === 'texture' || parameter.type === 'texture_cube') {
       if (engineInjectedTextureFields?.has(parameter.name) === true) return [];
-      return [{ name: parameter.name, type: 'texture2d' }];
+      return [
+        {
+          name: parameter.name,
+          type: parameter.type === 'texture_cube' ? 'texture_cube' : 'texture2d',
+        },
+      ];
     }
     return [
       {
@@ -1779,6 +2044,7 @@ export function resolveMaterialSnapshot(
   const samplerHandles = collectMaterialTextureSamplers(pv, (value) =>
     resolveTexLike(materialTextureRef(value), 'SamplerAsset'),
   );
+  const textureSources = collectMaterialTextureSources(pv, world);
   const emissiveTextureHandle = resolveTexLike(
     materialTextureRef(pv.emissiveTexture),
     'TextureAsset',
@@ -1814,6 +2080,7 @@ export function resolveMaterialSnapshot(
     ...(materialParamSchema.length > 0 && { materialParamSchema }),
     ...(textureCoordinates.size > 0 && { textureCoordinates }),
     ...(textureHandles.size > 0 && { textureHandles }),
+    ...(textureSources.size > 0 && { textureSources }),
     ...(videoTextureFields.size > 0 && { videoTextureFields }),
     ...(samplerHandles.size > 0 && { samplerHandles }),
     ...(baseColorTextureHandle !== undefined && { baseColorTexture: baseColorTextureHandle }),
@@ -2117,6 +2384,9 @@ export interface DirectionalCsmConfig {
   readonly cascadeBlend: number;
   readonly mapSize: number;
   readonly shadowDistance: number;
+  readonly shadowFilter: number;
+  readonly shadowAngularRadius: number;
+  readonly maxPenumbraTexels: number;
 }
 
 /**
@@ -2131,6 +2401,7 @@ export interface DirectionalCsmResult {
   readonly cascadeCount: number;
   readonly cascadeBlend: number;
   readonly shadowMapSize: number;
+  readonly directionalShadowQuality: DirectionalShadowQuality;
 }
 
 /**
@@ -2163,9 +2434,6 @@ export function computeDirectionalCsm(
 
   // PSSM split planes: [camera near, shadowDistance], not the camera far.
   const splits = pssmSplit(sNear, sFar, cascadeCount, config.splitLambda);
-  const paddedSplits = new Float32Array(4);
-  for (let i = 0; i < splits.length; i++) paddedSplits[i] = splits[i] ?? 0;
-
   // Light view matrix: camera at origin, looking along the light direction.
   const lightDirN = vec3.normalize(vec3.create(), direction);
   const lightTarget = vec3.create(lightDirN[0] ?? 0, lightDirN[1] ?? 0, lightDirN[2] ?? 0);
@@ -2196,6 +2464,7 @@ export function computeDirectionalCsm(
   mat4.multiply(cameraVP, camProj, camView);
 
   const resultLightViewProjs: Float32Array[] = [];
+  const cascadeFits: DirectionalShadowCascadeFit[] = [];
 
   // bug-20260619 RC-2 (AC-05): toward-light Z reach. Extend the near (toward-
   // light) bound of EVERY cascade to the toward-light extreme of the WHOLE
@@ -2259,16 +2528,34 @@ export function computeDirectionalCsm(
     // lightViewProj = orthoProj * lightView — pure clip-space [-1,1]. Atlas
     // tile placement is handled by the per-cascade viewport + fragment-side UV
     // math (evalDirectional), so shadow_caster.gl_Position stays clip-space.
-    void cIdx;
+    cascadeFits.push({
+      split: splits[cIdx] ?? sFar,
+      minX,
+      maxX,
+      minY,
+      maxY,
+      minZ,
+      maxZ,
+    });
     resultLightViewProjs.push(new Float32Array(mat4.multiply(mat4.create(), orthoProj, lightView)));
   }
 
+  const projection = projectDirectionalShadow(
+    cascadeFits,
+    config.mapSize,
+    config.shadowFilter ?? 2,
+    config.shadowAngularRadius ?? 0.00465,
+    config.maxPenumbraTexels ?? 32,
+  );
+  if (projection === undefined) return null;
+
   return {
     lightViewProj: resultLightViewProjs,
-    splitPlanes: paddedSplits,
+    splitPlanes: projection.splitPlanes,
     cascadeCount,
     cascadeBlend: config.cascadeBlend,
     shadowMapSize: config.mapSize,
+    directionalShadowQuality: projection.directionalShadowQuality,
   };
 }
 
@@ -2296,8 +2583,177 @@ export interface PreparedExtractContext {
   readonly resourceOwnerFog: FogFrame | null | undefined;
   readonly cull: 'self' | 'none' | 'external';
   readonly cullCameras: readonly CameraSnapshot[] | undefined;
-  readonly hierarchy: SceneHierarchySnapshot;
+  readonly renderables: 'full' | 'none';
   readonly visibility: VisibilitySnapshot;
+  /** Producer-owned artifact lookup; extraction only, never record-time asset reads. */
+  readonly getMaterialShaderArtifact:
+    | ((materialShaderId: string) => MaterialShaderArtifact | undefined)
+    | undefined;
+}
+
+const ALL_VISIBLE: VisibilitySnapshot = {
+  diagnostics: [],
+  hasAnyIntent: false,
+  hasAnyHiddenIntent: false,
+  get: () => undefined,
+  effective: () => 'visible',
+};
+
+function collectCameraSnapshots(world: World): CameraSnapshot[] {
+  const worldInternal = createWorldInternalView(world);
+  const cameras: CameraSnapshot[] = [];
+  const cameraQuery = world
+    .query({ read: [Camera], optional: [MotionBlur], with: [Transform, GlobalTransform] })
+    .unwrap();
+  for (const row of cameraQuery) {
+    const cam = row.get(Camera);
+    const motionBlur = row.get(MotionBlur);
+    const entity = row.entity;
+    const view = worldInternal._getArrayView(entity, GlobalTransform, 'world');
+    if (view === undefined) continue;
+    const worldMat = new Float32Array(view);
+    const target = resolveCameraTarget(world, cam.target);
+    cameras.push({
+      entityKey: entity as number,
+      ...(target === undefined ? {} : { target }),
+      historyVersion: cam.historyVersion,
+      position: mat4.getTranslation(vec3.create(), worldMat),
+      world: worldMat,
+      fov: cam.fov,
+      aspect: cam.aspect,
+      near: cam.near,
+      far: cam.far,
+      projection: cameraProjectionFromF32(cam.projection),
+      orthoLeft: cam.left,
+      orthoRight: cam.right,
+      orthoBottom: cam.bottom,
+      orthoTop: cam.top,
+      tonemap: tonemapFromF32(cam.tonemap),
+      exposure: cam.exposure,
+      whitePoint: cam.whitePoint,
+      antialias: antialiasFromF32(cam.antialias),
+      bloom: bloomEnabledFromF32(cam.bloom),
+      bloomThreshold: cam.bloomThreshold,
+      bloomIntensity: cam.bloomIntensity,
+      bloomBlurRadius: cam.bloomBlurRadius,
+      clearColor: [
+        cam.clearColor[0] ?? 0,
+        cam.clearColor[1] ?? 0,
+        cam.clearColor[2] ?? 0,
+        cam.clearColor[3] ?? 1,
+      ],
+      ...(motionBlur === undefined
+        ? {}
+        : {
+            motionBlur: {
+              shutterAngle: motionBlur.shutterAngle,
+              maxRadiusPixels: motionBlur.maxRadiusPixels,
+              sampleCount: motionBlur.sampleCount,
+            },
+          }),
+    });
+  }
+  return cameras;
+}
+
+function collectCubeCameraSnapshots(world: World): CubeCameraSnapshot[] {
+  const worldInternal = createWorldInternalView(world);
+  const snapshots: CubeCameraSnapshot[] = [];
+  const query = world.query({ read: [CubeCamera], with: [Transform, GlobalTransform] }).unwrap();
+  for (const row of query) {
+    const camera = row.get(CubeCamera);
+    const target = resolveCameraTarget(world, camera.target);
+    if (target === undefined) continue;
+    const view = worldInternal._getArrayView(row.entity, GlobalTransform, 'world');
+    if (view === undefined) continue;
+    snapshots.push({
+      entityKey: row.entity as number,
+      target,
+      position: [view[12] ?? 0, view[13] ?? 0, view[14] ?? 0],
+      near: camera.near,
+      far: camera.far,
+      updateIntent: cubeCameraUpdateIntentFromF32(camera.updateIntent),
+      requestVersion: camera.requestVersion,
+      faceBudget: camera.faceBudget,
+    });
+  }
+  return snapshots;
+}
+
+function collectReflectionProbeFacts(world: World): ReflectionProbeFact[] {
+  const worldInternal = createWorldInternalView(world);
+  const facts: ReflectionProbeFact[] = [];
+  const query = world
+    .query({ read: [ReflectionProbe], with: [Transform, GlobalTransform] })
+    .unwrap();
+  for (const row of query) {
+    const probe = row.get(ReflectionProbe);
+    const view = worldInternal._getArrayView(row.entity, GlobalTransform, 'world');
+    if (view === undefined) {
+      continue;
+    }
+    facts.push({
+      worldId: 0,
+      entityKey: row.entity as number,
+      center: [view[12] ?? 0, view[13] ?? 0, view[14] ?? 0],
+      halfExtents: [
+        probe.halfExtents[0] ?? 0,
+        probe.halfExtents[1] ?? 0,
+        probe.halfExtents[2] ?? 0,
+      ],
+      priority: probe.priority,
+      intensity: probe.intensity,
+      resolution: probe.resolution,
+      revision: probe.invalidationVersion,
+      updateIntent: reflectionProbeUpdateIntentFromF32(probe.updateIntent),
+      invalidationVersion: probe.invalidationVersion,
+    });
+  }
+  return facts;
+}
+
+interface CameraRoleSelection {
+  readonly display: readonly CameraSnapshot[];
+  readonly auxiliary: readonly CameraSnapshot[];
+}
+
+function selectCameraRoles(world: World): CameraRoleSelection {
+  const cameras = collectCameraSnapshots(world);
+  const displayEntities = cameras
+    .filter((camera) => camera.target === undefined)
+    .map((camera) => camera.entityKey ?? 0);
+  const activeCameraIndex = selectActiveCameraIndex(
+    displayEntities,
+    getActiveCamera(world)?.entity,
+  );
+  const displayEntityKey = displayEntities[activeCameraIndex] ?? displayEntities[0];
+  const display =
+    displayEntityKey === undefined
+      ? []
+      : cameras.filter((camera) => camera.entityKey === displayEntityKey);
+  const candidates: CameraTargetCandidate[] = cameras.map((camera) => ({
+    worldId: 0,
+    entityKey: camera.entityKey ?? 0,
+    ...(camera.target === undefined ? {} : { target: camera.target }),
+    requestVersion: 0,
+    update: 'continuous',
+  }));
+  const selected = selectCameraTargetViews(candidates, {
+    ...(displayEntityKey === undefined ? {} : { displayEntityKey }),
+    budget: 1,
+  });
+  const auxiliary = selected.auxiliary.flatMap((candidate) =>
+    cameras.filter((camera) => camera.entityKey === candidate.entityKey),
+  );
+  return { display, auxiliary };
+}
+
+export function extractCameraSnapshots(world: World): CameraSnapshot[] {
+  return [...selectCameraRoles(world).display];
+}
+
+export function extractCameraTargetSnapshots(world: World): readonly CameraSnapshot[] {
+  return selectCameraRoles(world).auxiliary;
 }
 
 function tonemapParams(camera: CameraSnapshot): Uint8Array {
@@ -2319,9 +2775,13 @@ export function prepareExtractContext(
     readonly resourceOwnerFog?: FogFrame | null;
     readonly cull?: 'self' | 'none' | 'external';
     readonly cullCameras?: readonly CameraSnapshot[];
+    readonly renderables?: 'full' | 'none';
+    readonly getMaterialShaderArtifact?: (
+      materialShaderId: string,
+    ) => MaterialShaderArtifact | undefined;
   } = {},
 ): PreparedExtractContext {
-  const hierarchy = projectHierarchy(world);
+  const renderables = options.renderables ?? 'full';
   return {
     assets: options.assets,
     pipelineState: options.pipelineState,
@@ -2329,12 +2789,28 @@ export function prepareExtractContext(
     resourceOwnerFog: options.resourceOwnerFog,
     cull: options.cull ?? 'self',
     cullCameras: options.cullCameras,
-    hierarchy,
-    visibility: resolveVisibility(world, hierarchy),
+    renderables,
+    visibility: renderables === 'none' ? ALL_VISIBLE : resolveVisibility(world),
+    getMaterialShaderArtifact: options.getMaterialShaderArtifact,
   };
 }
 
 const fogQueries = new WeakMap<World, Query<readonly [typeof Fog]>>();
+const fogLkgStates = new WeakMap<
+  World,
+  { lkg: FogFrame | undefined; failure: FogSelectionFailure | undefined }
+>();
+
+function fogState(world: World): {
+  lkg: FogFrame | undefined;
+  failure: FogSelectionFailure | undefined;
+} {
+  const existing = fogLkgStates.get(world);
+  if (existing !== undefined) return existing;
+  const created = { lkg: undefined, failure: undefined };
+  fogLkgStates.set(world, created);
+  return created;
+}
 
 function selectFogFrame(world: World): FogFrame | undefined {
   // Query compilation is owned once per World; Query refreshes its matched
@@ -2362,10 +2838,22 @@ function selectFogFrame(world: World): FogFrame | undefined {
     suns: [],
     lane: 'direct',
   });
-  if (fogSelection.ok) return fogSelection.value.fog;
+  const state = fogState(world);
+  if (fogSelection.ok) {
+    state.lkg = fogSelection.value.fog;
+    state.failure = undefined;
+    return fogSelection.value.fog;
+  }
+  state.failure = {
+    code: fogSelection.error.code,
+    expected: fogSelection.error.expected,
+    hint: fogSelection.error.hint,
+    detail: Object.freeze({ ...fogSelection.error.detail }),
+  };
   routeWorldError(world, fogSelection.error, {
     systemName: 'RenderSystem.extract (fog-selection)',
   });
+  if (state.lkg !== undefined) return state.lkg;
   throw fogSelection.error;
 }
 
@@ -2547,7 +3035,13 @@ export function extractFrames(
   assets?: AssetRegistry | null,
   pipelineState?: ExtractPipelineSurface | null,
   materialSnapshotCachesByWorld?: MaterialSnapshotCachesByWorld,
-  options: { readonly cull?: 'normal' | 'none' } = {},
+  options: {
+    readonly cull?: 'normal' | 'none';
+    readonly renderables?: 'full' | 'none';
+    readonly getMaterialShaderArtifact?: (
+      materialShaderId: string,
+    ) => MaterialShaderArtifact | undefined;
+  } = {},
 ): ExtractedFrame {
   // w4: normalize the owner argument. A bare number is the legacy single-owner
   // form (cameraOwner === resourceOwner); an object carries the two split
@@ -2617,7 +3111,11 @@ export function extractFrames(
                 })(),
             }),
         cull: options.cull === 'none' ? 'none' : isCameraOwner ? 'self' : 'external',
+        ...(options.getMaterialShaderArtifact === undefined
+          ? {}
+          : { getMaterialShaderArtifact: options.getMaterialShaderArtifact }),
         ...(cameraOwnerFrame === undefined ? {} : { cullCameras: cameraOwnerFrame.cameras }),
+        renderables: options.renderables ?? 'full',
       });
       const frame = extractFrame(world, prepared);
 
@@ -2688,6 +3186,7 @@ export function extractFrames(
   // frames); directionalCount sum.
   const point: PointLightSnapshot[] = [];
   const spot: SpotLightSnapshot[] = [];
+  const rect: RectAreaDirectLightSnapshot[] = [];
   let directional: DirectionalLightSnapshot | undefined;
   let directionalCount = 0;
   let lightViewProj: readonly Float32Array[] | undefined;
@@ -2697,7 +3196,8 @@ export function extractFrames(
   let shadowMapSize: number | undefined;
   let depthBias: number | undefined;
   let normalBias: number | undefined;
-  let pcfKernelSize: number | undefined;
+  let directionalShadowQuality: DirectionalShadowQuality | undefined;
+  let directionalShadowError: LightValidationError | undefined;
   const pointShadow: PointShadowSnapshot[] = [];
   // bug-20260710-editor-cross-world-shadow: carry the raw CSM config +
   // direction of the first-hit directional so the merge layer can recompute
@@ -2708,6 +3208,7 @@ export function extractFrames(
   for (const f of succeededFrames) {
     for (const p of f.lights.point) point.push(p);
     for (const s of f.lights.spot) spot.push(s);
+    for (const r of f.lights.rect) rect.push(r);
     for (const ps of f.lights.pointShadow) pointShadow.push(ps);
     if (directional === undefined && f.lights.directional !== undefined) {
       directional = f.lights.directional;
@@ -2719,7 +3220,8 @@ export function extractFrames(
       shadowMapSize = f.lights.shadowMapSize;
       depthBias = f.lights.depthBias;
       normalBias = f.lights.normalBias;
-      pcfKernelSize = f.lights.pcfKernelSize;
+      directionalShadowQuality = f.lights.directionalShadowQuality;
+      directionalShadowError = f.lights.directionalShadowError;
       directionalCsmConfig = f.lights.directionalCsmConfig;
       directionalCsmDirection = f.lights.directionalCsmDirection;
     }
@@ -2738,6 +3240,9 @@ export function extractFrames(
     if (succeededIndices[fi] === resourceOwner) resourceOwnerFrame = succeededFrames[fi];
   }
   const cameras = cameraOwnerFrame !== undefined ? [...cameraOwnerFrame.cameras] : [];
+  const auxiliaryCameras =
+    cameraOwnerFrame !== undefined ? [...cameraOwnerFrame.auxiliaryCameras] : [];
+  const cubeCameras = cameraOwnerFrame !== undefined ? [...cameraOwnerFrame.cubeCameras] : [];
 
   // bug-20260710-editor-cross-world-shadow: RECOMPUTE directional CSM matrices
   // against the surfaced camera. In a single-world app the per-world extract
@@ -2776,6 +3281,7 @@ export function extractFrames(
       cascadeCount = csm.cascadeCount;
       cascadeBlend = csm.cascadeBlend;
       shadowMapSize = csm.shadowMapSize;
+      directionalShadowQuality = csm.directionalShadowQuality;
     }
     // csm === null (no surfaced camera at all): keep the per-world carry —
     // there is no better data, and a cameraless frame renders nothing anyway.
@@ -2786,6 +3292,7 @@ export function extractFrames(
     directionalCount,
     point,
     spot,
+    rect,
     lightViewProj,
     splitPlanes,
     cascadeCount,
@@ -2793,7 +3300,8 @@ export function extractFrames(
     shadowMapSize,
     depthBias,
     normalBias,
-    pcfKernelSize,
+    directionalShadowQuality,
+    directionalShadowError,
     pointShadow,
     directionalCsmConfig,
     directionalCsmDirection,
@@ -2804,7 +3312,9 @@ export function extractFrames(
   const skybox = resourceOwnerFrame?.skybox;
   const skyboxCount = resourceOwnerFrame?.skyboxCount ?? 0;
   const fog = resourceOwnerFrame?.fog;
+  const fogFailure = resourceOwnerFrame?.fogFailure;
   const environment = resourceOwnerFrame?.environment;
+  const lightProbes = succeededFrames.flatMap((frame) => frame.lightProbes ?? []);
   // User-authored PostProcessParams entities are singleton scene resources, so
   // they come from the resourceOwner world (holistic snapshot selection).
   const postProcessParams = new Map(resourceOwnerFrame?.postProcessParams);
@@ -2843,9 +3353,16 @@ export function extractFrames(
   const visibilityStats = {
     explicitlyHidden: succeededFrames.reduce((s, f) => s + f.visibilityStats.explicitlyHidden, 0),
   };
+  const reflectionProbes = succeededFrames.flatMap((f, index) => {
+    const worldId = succeededIndices[index] ?? 0;
+    return (f.reflectionProbes ?? []).map((probe) => ({ ...probe, worldId }));
+  });
 
   return {
     cameras,
+    auxiliaryCameras,
+    cubeCameras,
+    reflectionProbes,
     lights,
     ...(volumetricFog === undefined
       ? {}
@@ -2854,9 +3371,11 @@ export function extractFrames(
     dispatch: dispatchEntries,
     skylight,
     skylightCount,
+    lightProbes,
     skybox,
     skyboxCount,
     fog,
+    ...(fogFailure === undefined ? {} : { fogFailure }),
     environment,
     environmentReady: resourceOwnerFrame !== undefined && environment !== undefined,
     frustumStats,
@@ -2947,18 +3466,20 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     materialSnapshotCache: persistentMaterialSnapshotCache,
     cull: cullMode,
     resourceOwnerFog,
+    getMaterialShaderArtifact,
   } = context;
   // Environment reads are owned by the retained resource projection and are
   // established at the frame boundary; record never revisits World state.
   const fog =
     resourceOwnerFog === undefined ? selectFogFrame(world) : (resourceOwnerFog ?? undefined);
+  const fogFailure = fogState(world).failure;
   const visibility = context.visibility.hasAnyHiddenIntent ? context.visibility : undefined;
   const skinPaletteAllocator = pipelineState?.skinPaletteAllocator ?? null;
 
   const directionalLightQuery = world.query({ read: [DirectionalLight] }).unwrap();
 
   // feat-20260601 D-3: camera / point / spot light world transforms are read
-  // through the single resolved `Transform.world` mat4 (written by
+  // through the single resolved `GlobalTransform.world` mat4 (written by
   // propagateTransforms), not the retired GlobalTransform-column-switch.
   //
   // Each segment routes through a World-owned Query with explicit read and
@@ -2971,7 +3492,11 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   const worldInternal = createWorldInternalView(world);
   let volumetricFog = extractVolumeSnapshot(world, assets, worldInternal);
 
-  const cameras = extractCameraSnapshots(world);
+  const cameraRoles = selectCameraRoles(world);
+  const cameras = [...cameraRoles.display];
+  const auxiliaryCameras = cameraRoles.auxiliary;
+  const cubeCameras = collectCubeCameraSnapshots(world);
+  const reflectionProbes = collectReflectionProbeFacts(world);
 
   // Three-query union (M2 / w16 / AC-03): directional has no Transform
   // dependency (sun-like infinite-source semantics); point + spot pull
@@ -2992,7 +3517,9 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         depthBias: number;
         normalBias: number;
         shadowDistance: number;
-        pcfKernelSize: number;
+        shadowFilter: number;
+        shadowAngularRadius: number;
+        maxPenumbraTexels: number;
       }
     | undefined;
   for (const row of directionalLightQuery) {
@@ -3022,11 +3549,29 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         depthBias: l.depthBias,
         normalBias: l.normalBias,
         shadowDistance: l.shadowDistance,
-        pcfKernelSize: l.pcfKernelSize,
+        shadowFilter: l.shadowFilter,
+        shadowAngularRadius: l.shadowAngularRadius,
+        maxPenumbraTexels: l.maxPenumbraTexels,
       };
     }
   }
 
+  let directionalShadowError: LightValidationError | undefined;
+  if (directional !== undefined && firstHitShadowFields !== undefined) {
+    const validation = validateDirectionalLightData({
+      direction: directional.direction,
+      castShadow: firstHitCastShadow,
+      ...firstHitShadowFields,
+    });
+    if (!validation.ok) {
+      directionalShadowError = validation.error;
+      worldInternal._routeError(directionalShadowError, {
+        severity: Severity.Error,
+        systemName: 'RenderSystem.extract (directional-shadow)',
+      });
+    }
+  }
+
   const pointSnapshots: PointLightSnapshot[] = [];
   // feat-20260612-point-light-shadows-urp-hdrp M4 / T-M4-4: track entity per
   // pointSnapshots index so the post-extract pointShadow join can stamp
@@ -3035,22 +3580,22 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   const pointLightQuery = world
     .query({
       read: [PointLight],
-      optional: [Transform],
+      optional: [Transform, GlobalTransform],
     })
     .unwrap();
   for (const row of pointLightQuery) {
     const p = row.get(PointLight);
     // K-2 scheme B: archetype-edge sniff -- `bundle.Transform` key is absent
     // when the archetype does not carry the Transform column.
-    const hasTransform = row.get(Transform) !== undefined;
+    const hasTransform = row.get(GlobalTransform) !== undefined;
     const intensity = p.intensity;
     const range = p.range;
     const entityId = row.entity;
-    // Position = world-space translation extracted from Transform.world.
+    // Position = world-space translation extracted from GlobalTransform.world.
     // A point light archetype without a Transform column sits at the origin.
     let worldMat: Float32Array | undefined;
     if (hasTransform) {
-      const view = worldInternal._getArrayView(entityId, Transform, 'world');
+      const view = worldInternal._getArrayView(entityId, GlobalTransform, 'world');
       if (view !== undefined) worldMat = new Float32Array(view);
     }
     const position =
@@ -3074,16 +3619,19 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   const spotLightQuery = world
     .query({
       read: [SpotLight],
-      optional: [Transform],
+      optional: [Transform, GlobalTransform],
     })
     .unwrap();
   // feat-20260625-spot-light-shadow-mapping M1 w5: tile allocation for castShadow spots.
   // Cap = 4 (OOS-5), sentinel -1 = unassigned (plan-strategy D-4).
   // Direction degeneration (near-zero) also skips shadow (requirements $112).
   let spotTileNext = 0;
+  const iesSlices = new Map<number, number>();
+  const cookieSlices = new Map<number, number>();
+  const projectorSlices = new Map<number, number>();
   for (const row of spotLightQuery) {
     const s = row.get(SpotLight);
-    const hasTransform = row.get(Transform) !== undefined;
+    const hasTransform = row.get(GlobalTransform) !== undefined;
     const intensity = s.intensity;
     const range = s.range;
     const innerConeDeg = s.innerConeDeg;
@@ -3091,7 +3639,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     let worldMat: Float32Array | undefined;
     if (hasTransform) {
       const entity = row.entity;
-      const view = worldInternal._getArrayView(entity, Transform, 'world');
+      const view = worldInternal._getArrayView(entity, GlobalTransform, 'world');
       if (view !== undefined) worldMat = new Float32Array(view);
     }
     const position =
@@ -3129,13 +3677,93 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     const sMapSize = s.mapSize;
     const sNearPlane = s.nearPlane;
     const sFarPlane = s.farPlane;
+    const iesProfileAsset =
+      s.iesProfile === undefined
+        ? undefined
+        : resolveAssetHandle<IesProfileAsset>(world, s.iesProfile);
+    const cookieAsset =
+      s.cookie === undefined ? undefined : resolveAssetHandle<TextureAsset>(world, s.cookie);
+    // Resolve the projector before assigning array slices so the
+    // extended-lighting path can reuse its texture transport while retaining
+    // the authored lightViewProj projection semantics.
+    const hasProjector = Number(s.projector) > 0;
+    let projectorHandle: Handle<'TextureAsset', 'shared'> | undefined;
+    let projectorAsset: TextureAsset | undefined;
+    let projectorGuid: string | undefined;
+    if (hasProjector) {
+      const candidate = toShared<'TextureAsset'>(Math.round(Number(s.projector)));
+      const resolvedProjector = resolveAssetHandle<TextureAsset>(world, candidate);
+      if (!resolvedProjector.ok || resolvedProjector.value.kind !== 'texture') {
+        worldInternal._routeError(
+          resolvedProjector.ok
+            ? new RhiError({
+                code: 'asset-not-registered',
+                expected: 'SpotLight.projector resolves to a TextureAsset',
+                hint: 'load the authored projector TextureAsset before assigning SpotLight.projector',
+                detail: { assetHandle: Number(candidate) },
+              })
+            : resolvedProjector.error,
+          { severity: Severity.Error, systemName: 'RenderSystem.extract (spot-projector)' },
+        );
+      } else {
+        projectorHandle = candidate;
+        projectorAsset = resolvedProjector.value;
+        projectorGuid = assets?.guidOf(projectorAsset) ?? `handle:${Number(candidate)}`;
+      }
+    }
+    const iesProfileData =
+      iesProfileAsset?.ok && iesProfileAsset.value.kind === 'ies-profile'
+        ? new Uint8Array(iesProfileAsset.value.data)
+        : undefined;
+    const cookieProjection =
+      cookieAsset?.ok && cookieAsset.value.kind === 'texture'
+        ? prepareCookieProjection(cookieAsset.value)
+        : undefined;
+    const cookieData = cookieProjection?.data;
+    const projectorProjection =
+      projectorAsset === undefined ? undefined : prepareCookieProjection(projectorAsset);
+    const projectorData = projectorProjection?.data;
+    const iesProfileHandle = s.iesProfile === undefined ? undefined : handleSlot(s.iesProfile);
+    const cookieHandle = s.cookie === undefined ? undefined : handleSlot(s.cookie);
+    let iesProfileSlice =
+      iesProfileHandle === undefined ? undefined : iesSlices.get(iesProfileHandle);
+    if (
+      iesProfileSlice === undefined &&
+      iesProfileHandle !== undefined &&
+      iesProfileData !== undefined &&
+      iesSlices.size < IES_SLICE_CAPACITY
+    ) {
+      iesProfileSlice = iesSlices.size;
+      iesSlices.set(iesProfileHandle, iesProfileSlice);
+    }
+    let cookieSlice = cookieHandle === undefined ? undefined : cookieSlices.get(cookieHandle);
+    if (
+      cookieSlice === undefined &&
+      cookieHandle !== undefined &&
+      cookieData !== undefined &&
+      cookieSlices.size < COOKIE_SLICE_CAPACITY
+    ) {
+      cookieSlice = cookieSlices.size;
+      cookieSlices.set(cookieHandle, cookieSlice);
+    }
+    let projectorSlice =
+      projectorHandle === undefined
+        ? undefined
+        : (projectorSlices.get(projectorHandle) ?? cookieSlices.get(projectorHandle));
+    if (
+      projectorSlice === undefined &&
+      projectorHandle !== undefined &&
+      projectorData !== undefined &&
+      cookieSlices.size + projectorSlices.size < COOKIE_SLICE_CAPACITY
+    ) {
+      projectorSlice = cookieSlices.size + projectorSlices.size;
+      projectorSlices.set(projectorHandle, projectorSlice);
+    }
     const shadowIntensity = s.shadowIntensity;
     // `shared<T>` columns are u32-backed and zero-filled when the optional
     // field is absent. Treat only a positive handle as an authored projector;
     // checking nullish values alone would turn the zero sentinel into a
     // phantom projector matrix and an avoidable asset-not-found diagnostic.
-    const hasProjector = Number(s.projector) > 0;
-
     let lightViewProj: Float32Array | undefined;
     let shadowAtlasTile = -1;
 
@@ -3167,31 +3795,6 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       }
     }
 
-    let projectorHandle: Handle<'TextureAsset', 'shared'> | undefined;
-    let projectorAsset: TextureAsset | undefined;
-    let projectorGuid: string | undefined;
-    if (hasProjector) {
-      const candidate = toShared<'TextureAsset'>(Math.round(Number(s.projector)));
-      const resolvedProjector = resolveAssetHandle<TextureAsset>(world, candidate);
-      if (!resolvedProjector.ok || resolvedProjector.value.kind !== 'texture') {
-        worldInternal._routeError(
-          resolvedProjector.ok
-            ? new RhiError({
-                code: 'asset-not-registered',
-                expected: 'SpotLight.projector resolves to a TextureAsset',
-                hint: 'load the authored projector TextureAsset before assigning SpotLight.projector',
-                detail: { assetHandle: Number(candidate) },
-              })
-            : resolvedProjector.error,
-          { severity: Severity.Error, systemName: 'RenderSystem.extract (spot-projector)' },
-        );
-      } else {
-        projectorHandle = candidate;
-        projectorAsset = resolvedProjector.value;
-        projectorGuid = assets?.guidOf(projectorAsset) ?? `handle:${Number(candidate)}`;
-      }
-    }
-
     spotSnapshots.push({
       kind: 'spot',
       entity: row.entity,
@@ -3208,6 +3811,25 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       invRangeSquared: computeInvRangeSquared(range),
       cosInner: degToCos(innerConeDeg),
       cosOuter: degToCos(outerConeDeg),
+      ...(s.iesProfile === undefined
+        ? {}
+        : {
+            iesProfileHandle: handleSlot(s.iesProfile),
+            ...(iesProfileSlice === undefined ? {} : { iesProfileSlice }),
+          }),
+      ...(s.cookie === undefined
+        ? {}
+        : {
+            cookieHandle: handleSlot(s.cookie),
+            ...(cookieSlice === undefined ? {} : { cookieSlice }),
+          }),
+      ...(iesProfileData === undefined ? {} : { iesProfileData }),
+      ...(cookieData === undefined ? {} : { cookieData }),
+      ...(cookieProjection === undefined ? {} : { cookieMatrix: cookieProjection.matrix }),
+      ...(projectorSlice === undefined ? {} : { projectorSlice }),
+      ...(projectorData === undefined ? {} : { projectorData }),
+      ...(projectorProjection === undefined ? {} : { projectorMatrix: projectorProjection.matrix }),
+      rollDeg: s.rollDeg,
       // ── shadow fields ──
       castShadow,
       lightViewProj,
@@ -3233,6 +3855,59 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     });
   }
 
+  const rectSnapshots: RectAreaDirectLightSnapshot[] = [];
+  const rectLightQuery = world
+    .query({
+      read: [RectAreaLight],
+      optional: [Transform, GlobalTransform],
+    })
+    .unwrap();
+  for (const row of rectLightQuery) {
+    const light = row.get(RectAreaLight);
+    const validation = validateRectAreaLightData({
+      intensity: light.intensity,
+      color: light.color,
+      width: light.width,
+      height: light.height,
+      range: light.range,
+    });
+    if (!validation.ok) {
+      worldInternal._routeError(validation.error, {
+        severity: Severity.Error,
+        systemName: 'RenderSystem.extract (rect-area-light)',
+      });
+      continue;
+    }
+    const worldView = row.get(GlobalTransform);
+    const worldMat =
+      worldView === undefined
+        ? undefined
+        : new Float32Array(worldInternal._getArrayView(row.entity, GlobalTransform, 'world') ?? []);
+    const position =
+      worldMat !== undefined ? mat4.getTranslation(vec3.create(), worldMat) : vec3.create(0, 0, 0);
+    const frame = buildRectAreaWorldFrame({
+      center: position,
+      axisX: [worldMat?.[0] ?? 1, worldMat?.[1] ?? 0, worldMat?.[2] ?? 0],
+      axisY: [worldMat?.[4] ?? 0, worldMat?.[5] ?? 1, worldMat?.[6] ?? 0],
+      width: light.width,
+      height: light.height,
+    });
+    rectSnapshots.push({
+      kind: 'rect-area',
+      position,
+      color: vec3.create(
+        (light.color[0] ?? 1) * light.intensity,
+        (light.color[1] ?? 1) * light.intensity,
+        (light.color[2] ?? 1) * light.intensity,
+      ),
+      intensity: light.intensity,
+      invRangeSquared: computeInvRangeSquared(light.range),
+      halfWidth: frame.halfWidth,
+      halfHeight: frame.halfHeight,
+      axisX: frame.axisX,
+      axisY: frame.axisY,
+    });
+  }
   // The SpotLight is the sole projector owner. Once all light snapshots have
   // been extracted, publish its accepted TextureAsset tuple on the volume
   // snapshot so surface and volume consume the same identity and revision.
@@ -3282,6 +3957,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   let cascadeCount: number | undefined;
   let cascadeBlend: number | undefined;
   let shadowMapSize: number | undefined;
+  let directionalShadowQuality: DirectionalShadowQuality | undefined;
   let directionalCsmConfig: DirectionalCsmConfig | undefined;
   let directionalCsmDirection: Vec3 | undefined;
 
@@ -3307,7 +3983,11 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   // feat-20260621 M2: CSM computation gated on castShadow from the
   // merged DirectionalLight. castShadow defaults to true (first-hit-wins
   // semantics, D-6 no cardinality cap).
-  if (directional !== undefined && firstHitCastShadow !== false) {
+  if (
+    directional !== undefined &&
+    firstHitCastShadow !== false &&
+    directionalShadowError === undefined
+  ) {
     const dirSnapshot = directional;
     const sf = firstHitShadowFields;
     if (sf !== undefined) {
@@ -3317,6 +3997,9 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         cascadeBlend: sf.cascadeBlend,
         mapSize: sf.mapSize,
         shadowDistance: sf.shadowDistance,
+        shadowFilter: sf.shadowFilter,
+        shadowAngularRadius: sf.shadowAngularRadius,
+        maxPenumbraTexels: sf.maxPenumbraTexels,
       };
       directionalCsmDirection = dirSnapshot.direction;
       const csm = computeDirectionalCsm(dirSnapshot.direction, directionalCsmConfig, cameraData);
@@ -3331,13 +4014,19 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       if (csm !== null) {
         lightViewProj = csm.lightViewProj;
         splitPlanes = csm.splitPlanes;
+        directionalShadowQuality = csm.directionalShadowQuality;
       } else {
         const sNear = cameraData?.near ?? 0.1;
         const splits = pssmSplit(sNear, sf.shadowDistance, cascadeCount, sf.splitLambda);
-        const padded = new Float32Array(4);
-        for (let i = 0; i < splits.length; i++) padded[i] = splits[i] ?? 0;
+        const padded = new Float32Array(16);
+        for (let i = 0; i < splits.length; i++) padded[i * 4] = splits[i] ?? 0;
         splitPlanes = padded;
       }
+      directionalShadowQuality = directionalShadowQualityFromF32(
+        sf.shadowFilter,
+        sf.shadowAngularRadius,
+        sf.maxPenumbraTexels,
+      );
     }
   }
 
@@ -3346,7 +4035,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   // the View UBO tail keeps a stable layout regardless of the runtime
   // cascadeCount. Host-side correctness invariant: only the first
   // cascadeCount slots are ever read by the WGSL kernel.
-  const paddedSplitPlanes = new Float32Array(4);
+  const paddedSplitPlanes = new Float32Array(16);
   if (splitPlanes !== undefined) {
     for (let i = 0; i < splitPlanes.length; i++) {
       paddedSplitPlanes[i] = splitPlanes[i] ?? 0;
@@ -3356,18 +4045,17 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   // feat-20260612-point-light-shadows-urp-hdrp M1 / T-M1-7 (plan-strategy §D-3,
   // requirements §5.3): query (PointLight + PointLightShadow + Transform)
   // archetype join. For each shadow caster, build 6 face VP matrices and pack
-  // into Float32Array(96). Atlas layer assigned in spawn order (0..3); the
-  // sentinel -1 is shader-side and applies to non-shadow PointLights only.
-  // Cap of 4 is enforced by ECS cardinality on PointLightShadow.
+  // into Float32Array(96). Atlas layer is assigned in spawn order while the
+  // renderer-owned atlas has capacity; the sentinel -1 is shader-side and
+  // applies to non-admitted PointLightShadow requests as well.
   const pointShadowSnapshots: PointShadowSnapshot[] = [];
   {
     const pointShadowQuery = world
-      .query({ read: [Transform, PointLightShadow], with: [PointLight] })
+      .query({ read: [Transform, GlobalTransform, PointLightShadow], with: [PointLight] })
       .unwrap();
     for (const row of pointShadowQuery) {
-      const t = row.get(Transform);
       const ps = row.get(PointLightShadow);
-      // Read world-space position from Transform.world (mat4 column-major;
+      // Read world-space position from GlobalTransform.world (mat4 column-major;
       // translation lives at indices 12..14, mirroring CameraSnapshot.world
       // semantics in this file).
       // feat-20260614 M4 / w13: TypedArrayFor for `array<f32, 16>` now
@@ -3377,7 +4065,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       // `t.world?.[i]` form silently returned a single element under the
       // `never`-typed bundle path and `wRow[12]` widened to `undefined ?? 0`
       // so light positions clamped to the origin.
-      const wRow = t.world;
+      const wRow = row.get(GlobalTransform).world;
       if (wRow === undefined) continue;
       const px = wRow[12] ?? 0;
       const py = wRow[13] ?? 0;
@@ -3386,7 +4074,13 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       const mapSize = ps.mapSize;
       const nearPlane = ps.nearPlane;
       const farPlane = ps.farPlane;
-      const layer = pointShadowSnapshots.length; // 0, 1, 2, 3 in spawn order
+      // The renderer, not ECS, owns the atlas budget. Preserve every request
+      // for inspection, but emit the shader sentinel for entries that cannot
+      // acquire a layer so record never calls faceView outside the atlas.
+      const layer =
+        pointShadowSnapshots.length < SHADOW_ATLAS_DEFAULT_LAYERS
+          ? pointShadowSnapshots.length
+          : -1;
 
       const matrices = buildPointShadowMatrices(lightPos, nearPlane, farPlane);
       const packed = new Float32Array(96);
@@ -3412,7 +4106,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   // feat-20260612-point-light-shadows-urp-hdrp M4 / T-M4-4 (plan-strategy §D-8):
   // join pointShadow snapshots into the matching PointLightSnapshot so the
   // record stage threads `shadowAtlasLayer + shadowNear + shadowFar` through
-  // `packLightSlot` for the HDRP std430 LightSlot pad lanes (byte 52..64).
+  // the unified direct-light metadata payload.
   // Mutates the freshly-built PointLightSnapshot in place; the snapshot is
   // not exposed elsewhere this frame yet (consumed only by lights.point[]).
   if (pointShadowSnapshots.length > 0) {
@@ -3437,6 +4131,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     directionalCount,
     point: pointSnapshots,
     spot: spotSnapshots,
+    rect: rectSnapshots,
     lightViewProj,
     splitPlanes: splitPlanes !== undefined ? paddedSplitPlanes : undefined,
     cascadeCount,
@@ -3444,7 +4139,8 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     shadowMapSize,
     depthBias: firstHitCastShadow !== false ? firstHitShadowFields?.depthBias : undefined,
     normalBias: firstHitCastShadow !== false ? firstHitShadowFields?.normalBias : undefined,
-    pcfKernelSize: firstHitCastShadow !== false ? firstHitShadowFields?.pcfKernelSize : undefined,
+    directionalShadowQuality,
+    directionalShadowError,
     pointShadow: pointShadowSnapshots,
     // bug-20260710-editor-cross-world-shadow: raw CSM config + light direction
     // so the merge layer can recompute matrices against the surfaced camera.
@@ -3489,6 +4185,31 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     }
   }
 
+  const lightProbeQuery = world.query({ read: [LightProbe, GlobalTransform] }).unwrap();
+  const lightProbes: LightProbeSnapshot[] = [];
+  for (const row of lightProbeQuery) {
+    const probe = row.get(LightProbe);
+    const validation = validateLightProbeData({
+      irradiance: probe.irradiance,
+      radius: probe.radius,
+    });
+    if (!validation.ok) {
+      worldInternal._routeError(validation.error, {
+        severity: Severity.Error,
+        systemName: 'RenderSystem.extract (light-probe)',
+      });
+      continue;
+    }
+    const transform = row.get(GlobalTransform);
+    lightProbes.push({
+      identity: String(row.entity),
+      position: [transform.world[12] ?? 0, transform.world[13] ?? 0, transform.world[14] ?? 0],
+      radius: probe.radius,
+      irradiance: new Float32Array(probe.irradiance),
+      admitted: true,
+    });
+  }
+
   // feat-20260531-skybox-env-background M2 / w5: query SkyboxBackground entities.
   // First archetype hit wins (mirrors Skylight pattern); multi-entity
   // once-warn in record stage uses skyboxCount.
@@ -3683,24 +4404,28 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   // column id for the sprite-bucket per-entity region override read
   void SpriteRegionOverride;
 
-  const meshRendererQuery = world
-    .query({
-      read: [MeshRenderer],
-      optional: [
-        Transform,
-        MeshFilter,
-        Instances,
-        Skin,
-        Layer,
-        MorphWeights,
-        SpriteRegionOverride,
-        SpriteInstances,
-        Points,
-        Lines,
-        SortKey,
-      ],
-    })
-    .unwrap();
+  const meshRendererQuery =
+    context.renderables === 'none'
+      ? []
+      : world
+          .query({
+            read: [MeshRenderer],
+            optional: [
+              Transform,
+              GlobalTransform,
+              MeshFilter,
+              Instances,
+              Skin,
+              Layer,
+              MorphWeights,
+              SpriteRegionOverride,
+              SpriteInstances,
+              Points,
+              Lines,
+              SortKey,
+            ],
+          })
+          .unwrap();
   // QueryRow deliberately exposes component data, not an archetype version.
   // The optimized ECS owner keeps table storage private, so instance-buffer
   // invalidation uses a content fingerprint of the managed arrays instead.
@@ -3757,12 +4482,11 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       points !== undefined ? 'Points' : lines !== undefined ? 'Lines' : undefined;
     const isRenderable = hasTransform && hasMeshFilter;
 
-    // feat-20260601 D-3: the resolved world transform is read per-entity from
-    // the single `Transform.world` mat4 (propagateTransforms output) inside the
-    // row loop below. The retired GlobalTransform-column-switch + the
-    // ChildOf-without-GlobalTransform misconfig signal are gone: the world
-    // column always exists on a Transform-bearing entity, so the
-    // "ChildOf but forgot GlobalTransform" misconfiguration cannot occur.
+    // The resolved world transform is read per-entity from the single
+    // `GlobalTransform.world` mat4 (propagateTransforms output) inside the row
+    // loop below. Normal structural paths materialize this carrier through
+    // Transform's generic ECS requirement; keep the defensive row check because
+    // an owner can explicitly remove a required component during recovery.
     const fAssetHandle = meshFilter?.assetHandle;
     // feat-20260520-2d-sprite-layer-mvp M-3 / w22: Layer column read here;
     // value folded into each DispatchEntry so the render-system sort can use
@@ -3854,6 +4578,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       let materialBindingDiagnostics: MeshMaterialBindingDiagnostic[] = [];
       let gpuDrivenSubmeshes: readonly MeshAsset['submeshes'][number][] = [];
       let gpuDrivenIndexed = false;
+      let gpuDrivenGeometry: GpuDrivenGeometryReceipt | undefined;
 
       // Resolve instance overrides against mesh-owned slot defaults once.
       const fAssetHandleVal = fAssetHandle;
@@ -3867,8 +4592,20 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         const meshRes = resolveAssetHandle<Asset>(world, meshHandle);
         if (meshRes.ok && meshRes.value.kind === 'mesh') {
           const meshAsset = meshRes.value as MeshAsset;
+          const guid = (meshRes.value as { guid?: string }).guid ?? '<no-guid>';
           gpuDrivenSubmeshes = meshAsset.submeshes;
           gpuDrivenIndexed = meshAsset.indices !== undefined;
+          const layoutProjection = deriveVertexLayoutProjection(meshAsset.attributes);
+          gpuDrivenGeometry = {
+            identity: `${guid}:${layoutProjection.digest}`,
+            vertexInputs: layoutProjection.attributes.map((attribute) => ({
+              semantic: attribute.key,
+              location: attribute.shaderLocation,
+              format: attribute.format,
+            })),
+            topology: meshAsset.submeshes[0]?.topology ?? 'triangle-list',
+            indexed: gpuDrivenIndexed,
+          };
           // extractFrames is also a public read path and can run before the
           // Renderer.draw pre-render stage. GlyphText proves the derived mesh
           // owns exactly one Default slot; arbitrary meshes still fail closed
@@ -3876,7 +4613,6 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           if (!Array.isArray(meshAsset.materialSlots) && world.get(entity, GlyphText).ok) {
             ensureGlyphMeshMaterialSlots(world, meshHandle);
           }
-          const guid = (meshRes.value as { guid?: string }).guid ?? '<no-guid>';
           const resolvedBindings = resolveMeshMaterialBindings(meshAsset, materialsView ?? [], {
             isValidOverride(handle) {
               const resolved = resolveAssetHandle(world, toShared<'MaterialAsset'>(handle));
@@ -4336,6 +5072,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
               pv.occlusionTexture,
             );
             const textureCoordinates = collectMaterialTextureCoordinates(pv);
+            const textureSources = collectMaterialTextureSources(pv, world);
             const emissivePv = pv.emissive as readonly number[] | undefined;
             // feat-20260625 M2 / w6: first-pass transparency flag folds into
             // MaterialSnapshot.transparent so the record stage can drive the
@@ -4435,6 +5172,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
               ...(textureCoordinates.size > 0 && { textureCoordinates }),
               ...(samplerHandles.size > 0 && { samplerHandles }),
               ...(textureHandles.size > 0 && { textureHandles }),
+              ...(textureSources.size > 0 && { textureSources }),
               ...(videoTextureFields.size > 0 && { videoTextureFields }),
               ...(baseColorTextureHandle !== undefined && {
                 baseColorTexture: baseColorTextureHandle,
@@ -4600,7 +5338,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
               );
               continue;
             }
-            // (c) Resolve only each joint's Transform.world column. The
+            // (c) Resolve only each joint's GlobalTransform.world column. The
             // transient view is consumed before a structural mutation and
             // therefore preserves the same dangling-joint behavior without
             // constructing every other Transform field.
@@ -4611,7 +5349,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
             for (let jIdx = 0; jIdx < skeleton.jointCount; jIdx++) {
               const jointEntityRaw = skinJoints[jIdx] ?? 0;
               const jointEntity = jointEntityRaw as EntityHandle;
-              const jointWorld = worldInternal._getArrayView(jointEntity, Transform, 'world');
+              const jointWorld = worldInternal._getArrayView(jointEntity, GlobalTransform, 'world');
               if (jointWorld === undefined) {
                 jointDangling = jIdx;
                 break;
@@ -4653,14 +5391,23 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           }
         }
 
+        // A pbr-skin PSO requires the complete three-binding group(2) skin
+        // projection. Do not publish a renderable or its staged dispatch when
+        // palette extraction was unavailable; the record stage must never
+        // reinterpret a skinned vertex stream through an ordinary mesh group.
+        if (materialSnap.materialShaderId === 'forgeax::pbr-skin' && skinSlice === undefined) {
+          pendingDispatch.length = 0;
+          continue;
+        }
+
         // feat-20260601 D-3: read the resolved world mat4 (propagateTransforms
-        // output) straight from the Transform.world column array view. The
+        // output) straight from the GlobalTransform.world column array view. The
         // record stage copies these 16 floats into the mesh SSBO with zero
         // per-snapshot `mat4.compose` (AC-07). A stale slot (generation gone)
         // skips the renderable, mirroring the Instances dangling-row sweep.
         // tweak-20260611 M1 / K-3: `_getArrayView` call survives untouched;
         // only the `entity` source switched to `bundle.Entity.self[i]`.
-        const worldView = worldInternal._getArrayView(entity, Transform, 'world');
+        const worldView = worldInternal._getArrayView(entity, GlobalTransform, 'world');
         if (worldView === undefined) continue;
         const worldMat = new Float32Array(worldView);
         const transformSnap: TransformSnapshot = { world: worldMat };
@@ -4791,12 +5538,16 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         }
 
         let localAabb: Float32Array | undefined;
+        let lods: readonly MeshLodLevel[] | undefined;
+        let lodHysteresis: number | undefined;
         let morph: MorphSnapshot | undefined;
         const assetHandleRaw = Math.round(fAssetHandle ?? 0);
         if (assetHandleRaw !== 0) {
           const meshRes = resolveAssetHandle(world, toShared<'MeshAsset'>(assetHandleRaw));
           if (meshRes.ok && meshRes.value.kind === 'mesh') {
             const meshAsset = meshRes.value as MeshAsset;
+            lods = meshAsset.lods;
+            lodHysteresis = meshAsset.lodHysteresis;
             morph = morphSnapshotFor(meshAsset, morphWeightsView);
             const meshAabb = meshAsset.aabb;
             // Morph targets can expand the authored bounds. Keep the
@@ -4841,41 +5592,95 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                 projection: identityProjection(),
               } satisfies PointsLinesRetainedSnapshot);
 
-        let nonIndexedFirst = 0;
-        const gpuDrivenDraws = gpuDrivenSubmeshes.flatMap((submesh) => {
-          const drawMaterial = materialsArr[submesh.materialSlot] ?? materialSnap;
-          const first = gpuDrivenIndexed ? submesh.indexOffset : nonIndexedFirst;
-          nonIndexedFirst += submesh.vertexCount;
-          if (drawMaterial.transparent === true) return [];
-          return [
-            {
-              kind: gpuDrivenIndexed ? ('indexed' as const) : ('non-indexed' as const),
-              first,
-              count: gpuDrivenIndexed ? submesh.indexCount : submesh.vertexCount,
-              baseVertex: 0,
-              materialSlot: submesh.materialSlot,
-              topology: submesh.topology,
-              pipelineClass: `${drawMaterial.materialShaderId ?? 'forgeax::default-unlit'}|${submesh.topology}|${JSON.stringify(drawMaterial.renderState ?? null)}`,
-              materialResourceClass: gpuDrivenMaterialResourceClass(drawMaterial),
-            },
-          ];
-        });
+        // Instances are snapshotted before the CPU visibility decision so the
+        // culling owner can derive the union of every instance's transformed
+        // mesh bounds. The same detached snapshot is then carried to record;
+        // do not re-read the ECS array after culling (a structural write must
+        // not make the cull and draw disagree within one frame).
+        let instancesSnap: InstancesSnapshot | undefined;
+        if (hasInstances) {
+          const transforms = worldInternal._getArrayView(entity, Instances, 'transforms');
+          if (transforms === undefined) {
+            // A present component with an unavailable array is an empty
+            // instance contribution, not an absent component. Preserve the
+            // zero-draw contract so the record stage cannot synthesize one
+            // identity instance from an incomplete row.
+            instancesSnap = {
+              transforms: new Float32Array(),
+              instanceCount: 0,
+              cacheKey: entity,
+              archVersion,
+            };
+          } else {
+            const actualLength = transforms.length;
+            if (actualLength % 16 !== 0) {
+              worldInternal._routeError(new InstanceTransformsStrideMismatchError(actualLength), {
+                severity: Severity.Error,
+                systemName: 'RenderSystem.extract (Instances stride)',
+              });
+              continue;
+            }
+            const snapshotCopy = new Float32Array(transforms);
+            instancesSnap = {
+              transforms: snapshotCopy,
+              instanceCount: actualLength / 16,
+              cacheKey: entity,
+              archVersion,
+            };
+          }
+        }
+
         const baseRenderable: RenderableSnapshot = {
           assetHandle: Math.round(fAssetHandle ?? 0),
           transform: transformSnap,
+          ...(lods === undefined ? {} : { lods }),
+          ...(lodHysteresis === undefined ? {} : { lodHysteresis }),
           ...(localAabb !== undefined ? { localAabb: cullingLocalAabb } : {}),
           material: materialSnap,
           materials: materialsArr,
           materialBindingSources,
           materialBindingDiagnostics,
-          ...(morph === undefined && gpuDrivenDraws.length > 0 ? { gpuDrivenDraws } : {}),
           worldId: 0,
           entityKey: entity,
           ...(skinSlice !== undefined ? { skin: skinSlice } : {}),
           ...(morph !== undefined ? { morph } : {}),
+          ...(instancesSnap !== undefined ? { instances: instancesSnap } : {}),
           ...(spriteInstancesSnap !== undefined ? { spriteInstances: spriteInstancesSnap } : {}),
           ...(pointsLines !== undefined ? { pointsLines } : {}),
         };
+        const gpuDrivenDraws = buildGpuDrivenDraws({
+          submeshes: gpuDrivenSubmeshes,
+          indexed: gpuDrivenIndexed,
+          materials: materialsArr,
+          fallbackMaterial: materialSnap,
+          ...(gpuDrivenGeometry === undefined || getMaterialShaderArtifact === undefined
+            ? {}
+            : {
+                prepare(draw, drawMaterial) {
+                  const materialShaderId = drawMaterial.materialShaderId;
+                  if (materialShaderId === undefined) return undefined;
+                  const artifact = getMaterialShaderArtifact(materialShaderId);
+                  if (artifact?.receipt === undefined) return undefined;
+                  const geometry: GpuDrivenGeometryReceipt = {
+                    ...gpuDrivenGeometry,
+                    topology: draw.topology,
+                    indexed: draw.kind === 'indexed',
+                  };
+                  const result = resolvePreparedGpuDrivenDraw({
+                    snapshot: { ...baseRenderable, material: drawMaterial },
+                    artifact,
+                    geometry,
+                    generation: artifact.receipt.generation,
+                    draw,
+                  });
+                  return result.ok ? result.value : undefined;
+                },
+              }),
+        });
+        const renderable =
+          morph === undefined && gpuDrivenDraws.length > 0
+            ? { ...baseRenderable, gpuDrivenDraws }
+            : baseRenderable;
 
         // feat-20260528-frustum-culling M3 / w10: frustum culling check.
         // Skip the entity if a valid AABB exists AND ALL cameras' frusta
@@ -4884,66 +5689,70 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         // producer-owned finite local-space AABBs. Culling is unconditional
         // engine behavior; there is no per-entity opt-out.
         if (localAabb !== undefined) {
-          // feat-20260601 D-3: cull AABB uses the resolved world mat4
-          // directly (no compose) -- same source the record stage feeds
-          // the mesh SSBO, so cull stays same-source with render (AC-05).
-          const worldAabb = box3.create();
-          box3.transformBox3(worldAabb, cullingLocalAabb, transformSnap.world);
-
-          // Test against all cameras. Entity is visible if one camera
-          // frustum intersects the world-space AABB (or planes are empty
-          // from degenerate projection).
-          frustumTotal += 1;
-          let visible = frustumPlanes.length === 0;
-          for (let ci = 0; ci < frustumPlanes.length; ci++) {
-            const planes = frustumPlanes[ci] as Float32Array;
-            if (planes.length === 0) {
-              visible = true;
-              break;
-            }
-            if (frustum.intersectsBox(planes as frustum.Frustum, worldAabb as box3.Box3Like)) {
-              visible = true;
-              break;
-            }
-          }
-          if (!visible) {
-            frustumCulled += 1;
-            continue;
-          }
-        }
-
-        if (hasInstances) {
-          const transforms = worldInternal._getArrayView(entity, Instances, 'transforms');
-          if (transforms === undefined) {
-            flushPendingDispatch(pendingDispatch);
-            renderables.push(baseRenderable);
+          // An empty or malformed Instances payload has no meaningful bounds.
+          // Keep it conservative (the draw path later emits zero instances)
+          // instead of manufacturing the entity's identity bounds. For a
+          // valid payload, derive one world-space union for CPU culling while
+          // leaving the mesh-local AABB untouched for GPU per-instance cull.
+          const derivedInstancesBounds =
+            instancesSnap === undefined || instancesSnap.instanceCount === 0
+              ? undefined
+              : deriveInstancesUnionBounds({
+                  meshAabb: cullingLocalAabb,
+                  entityWorld: transformSnap.world,
+                  transforms: instancesSnap.transforms,
+                });
+          if (instancesSnap?.instanceCount === 0) {
+            // No instance can contribute a visible bound. The retained
+            // snapshot still records instanceCount=0 for the record stage.
+          } else if (
+            hasInstances &&
+            (instancesSnap === undefined || derivedInstancesBounds === undefined)
+          ) {
+            // Missing/malformed derived facts are a conservative no-cull
+            // result. The stride validator above already rejects malformed
+            // lengths; this branch covers non-finite producer matrices/AABB.
           } else {
-            const actualLength = transforms.length;
-            if (actualLength % 16 !== 0) {
-              worldInternal._routeError(new InstanceTransformsStrideMismatchError(actualLength), {
-                severity: Severity.Error,
-                systemName: 'RenderSystem.extract (Instances stride)',
-              });
+            // feat-20260601 D-3: cull AABB uses the resolved world mat4
+            // directly (no compose) -- same source the record stage feeds
+            // the mesh SSBO, so cull stays same-source with render (AC-05).
+            const worldAabb = box3.create();
+            if (derivedInstancesBounds !== undefined) {
+              worldAabb[0] = derivedInstancesBounds[0] ?? 0;
+              worldAabb[1] = derivedInstancesBounds[1] ?? 0;
+              worldAabb[2] = derivedInstancesBounds[2] ?? 0;
+              worldAabb[3] = derivedInstancesBounds[3] ?? 0;
+              worldAabb[4] = derivedInstancesBounds[4] ?? 0;
+              worldAabb[5] = derivedInstancesBounds[5] ?? 0;
+            } else {
+              box3.transformBox3(worldAabb, cullingLocalAabb, transformSnap.world);
+            }
 
+            // Test against all cameras. Entity is visible if one camera
+            // frustum intersects the world-space AABB (or planes are empty
+            // from degenerate projection).
+            frustumTotal += 1;
+            let visible = frustumPlanes.length === 0;
+            for (let ci = 0; ci < frustumPlanes.length; ci++) {
+              const planes = frustumPlanes[ci] as Float32Array;
+              if (planes.length === 0) {
+                visible = true;
+                break;
+              }
+              if (frustum.intersectsBox(planes as frustum.Frustum, worldAabb as box3.Box3Like)) {
+                visible = true;
+                break;
+              }
+            }
+            if (!visible) {
+              frustumCulled += 1;
               continue;
             }
-            const snapshotCopy = new Float32Array(transforms);
-            const instanceCount = Math.max(1, Math.floor(actualLength / 16));
-            flushPendingDispatch(pendingDispatch);
-            renderables.push({
-              ...baseRenderable,
-              instances: {
-                transforms: snapshotCopy,
-                instanceCount,
-                cacheKey: entity,
-                archVersion,
-              },
-            });
           }
-        } else {
-          flushPendingDispatch(pendingDispatch);
-          renderables.push(baseRenderable);
         }
+
+        flushPendingDispatch(pendingDispatch);
+        renderables.push(renderable);
       }
 
       // feat-20260520-2d-sprite-layer-mvp M-3 / w22 + w25: finalise the
@@ -4978,10 +5787,12 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   // whitePoint / tonemap` onto the SAME unified params channel custom
   // post-processes use — `Camera.exposure` stays the AI-user-facing SSOT (D-5),
   // the engine itself acts as the provider for the Standard tonemap shader
-  // id. The 16B layout is byte-identical to the prior recordTonemapPass packing
-  // (render-system-record.ts pre-w14): Float32 [exposure, whitePoint, _, pad]
-  // with the mode u32 occupying the third 4-byte slot via tonemapToU32 (SSOT in
-  // camera.ts). Run AFTER the user-entity collection above so the engine's
+  // id. The 16B layout keeps the prior recordTonemapPass packing
+  // (render-system-record.ts pre-w14): Float32 [exposure, whitePoint, _,
+  // ditherEnabled], with the mode u32 occupying the third 4-byte slot via
+  // tonemapToU32 (SSOT in camera.ts). The final Output Transform makes a
+  // per-pass copy and writes ditherEnabled at byte offset 12; the extracted
+  // camera snapshot remains the SSOT. Run AFTER the user-entity collection above so the engine's
   // built-in provider is authoritative for its own reserved key (a user entity
   // can never shadow the Standard tonemap identity. The single active camera mirrors
   // recordFrame's `activeCameras[0]` selection.
@@ -4992,6 +5803,9 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
 
   return {
     cameras,
+    auxiliaryCameras,
+    cubeCameras,
+    reflectionProbes,
     lights,
     environment,
     environmentReady: true,
@@ -5000,9 +5814,11 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     dispatch,
     skylight,
     skylightCount,
+    lightProbes,
     skybox,
     skyboxCount,
     fog,
+    ...(fogFailure === undefined ? {} : { fogFailure }),
     frustumStats: { culled: frustumCulled, total: frustumTotal },
     visibilityStats: { explicitlyHidden: explicitlyHidden.size },
     postProcessParams,