@forgeax/engine-render 0.1.21 → 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,6 +147,7 @@ import {
   ASSET_ERROR_HINTS,
   AssetError,
   derive,
+  handleSlot,
   materialGuidText,
   materialValuesToLinearRuntime,
   toShared,
@@ -164,6 +164,7 @@ import {
   Fog,
   Instances,
   Layer,
+  LightProbe,
   Lines,
   MeshFilter,
   MeshRenderer,
@@ -173,6 +174,7 @@ import {
   Points,
   PostProcessParams,
   pointShapeFromU32,
+  RectAreaLight,
   ReflectionProbe,
   reflectionProbeUpdateIntentFromF32,
   SkyboxBackground,
@@ -194,6 +196,8 @@ import {
   degToCos,
   type LightValidationError,
   validateDirectionalLightData,
+  validateLightProbeData,
+  validateRectAreaLightData,
 } from './components/light-helpers';
 import { selectEnvironment } from './environment/frame';
 import {
@@ -212,12 +216,14 @@ import type {
   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,
@@ -227,6 +233,8 @@ import {
 import { isStandardPbrMaterialShader } from './pbr-pipeline';
 import { expandPointsLinesBounds } from './points-lines/bounds';
 import type { PointsLinesRetainedSnapshot, PointsLinesStyle } from './points-lines/snapshot';
+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,
@@ -289,18 +297,19 @@ export interface PointLightSnapshot {
    * 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;
 }
@@ -324,8 +333,7 @@ export interface PointLightSnapshot {
  * cube atlas faces and feed shader the proj constants without re-querying ECS.
  * `shadowAtlasLayer` is assigned by extract in spawn order up to the renderer
  * atlas capacity; over-budget requests retain the sentinel `-1` so the
- * downstream LightSlot / packPointLight packers carry no invalid layer in
- * pointPadW (T-M1-8 will rename to shadowAtlasLayer).
+ * downstream DirectLightSlot packing carries no invalid layer identity.
  */
 export interface PointShadowSnapshot {
   /** Spawning entity index (joins PointLight + PointLightShadow + Transform). */
@@ -339,7 +347,7 @@ export interface PointShadowSnapshot {
   /**
    * 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 LightSlot for no-shadow lights (T-M1-8).
+   * reserved by the shader-side DirectLightSlot metadata for no-shadow lights.
    */
   readonly shadowAtlasLayer: number;
   /**
@@ -378,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;
@@ -398,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
@@ -423,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
@@ -482,7 +603,8 @@ export interface ExtractedLights {
    * 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).
@@ -542,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).
@@ -598,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. */
@@ -705,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';
@@ -741,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 {
@@ -793,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.
@@ -981,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,
@@ -1115,6 +1247,8 @@ 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. */
@@ -2449,21 +2583,33 @@ 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] })
+    .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, Transform, 'world');
+    const view = worldInternal._getArrayView(entity, GlobalTransform, 'world');
     if (view === undefined) continue;
     const worldMat = new Float32Array(view);
     const target = resolveCameraTarget(world, cam.target);
@@ -2513,12 +2659,12 @@ function collectCameraSnapshots(world: World): CameraSnapshot[] {
 function collectCubeCameraSnapshots(world: World): CubeCameraSnapshot[] {
   const worldInternal = createWorldInternalView(world);
   const snapshots: CubeCameraSnapshot[] = [];
-  const query = world.query({ read: [CubeCamera], with: [Transform] }).unwrap();
+  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, Transform, 'world');
+    const view = worldInternal._getArrayView(row.entity, GlobalTransform, 'world');
     if (view === undefined) continue;
     snapshots.push({
       entityKey: row.entity as number,
@@ -2537,10 +2683,12 @@ function collectCubeCameraSnapshots(world: World): CubeCameraSnapshot[] {
 function collectReflectionProbeFacts(world: World): ReflectionProbeFact[] {
   const worldInternal = createWorldInternalView(world);
   const facts: ReflectionProbeFact[] = [];
-  const query = world.query({ read: [ReflectionProbe], with: [Transform] }).unwrap();
+  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, Transform, 'world');
+    const view = worldInternal._getArrayView(row.entity, GlobalTransform, 'world');
     if (view === undefined) {
       continue;
     }
@@ -2627,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,
@@ -2637,8 +2789,9 @@ 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,
   };
 }
 
@@ -2882,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
@@ -2952,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);
 
@@ -3023,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;
@@ -3044,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;
@@ -3127,6 +3292,7 @@ export function extractFrames(
     directionalCount,
     point,
     spot,
+    rect,
     lightViewProj,
     splitPlanes,
     cascadeCount,
@@ -3148,6 +3314,7 @@ export function extractFrames(
   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);
@@ -3204,6 +3371,7 @@ export function extractFrames(
     dispatch: dispatchEntries,
     skylight,
     skylightCount,
+    lightProbes,
     skybox,
     skyboxCount,
     fog,
@@ -3298,6 +3466,7 @@ 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.
@@ -3310,7 +3479,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   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
@@ -3411,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 =
@@ -3450,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;
@@ -3467,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 =
@@ -3505,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;
 
@@ -3543,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,
@@ -3584,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,
@@ -3609,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.
@@ -3752,12 +4051,11 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   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
@@ -3767,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;
@@ -3808,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) {
@@ -3833,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,
@@ -3886,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.
@@ -4080,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.
@@ -4154,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
@@ -4251,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;
@@ -4264,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
@@ -4273,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));
@@ -4999,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.
@@ -5010,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;
@@ -5062,13 +5401,13 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         }
 
         // 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 };
@@ -5199,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
@@ -5287,34 +5630,16 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           }
         }
 
-        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),
-            },
-          ];
-        });
         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 } : {}),
@@ -5323,6 +5648,39 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           ...(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
@@ -5394,7 +5752,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         }
 
         flushPendingDispatch(pendingDispatch);
-        renderables.push(baseRenderable);
+        renderables.push(renderable);
       }
 
       // feat-20260520-2d-sprite-layer-mvp M-3 / w22 + w25: finalise the
@@ -5456,6 +5814,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     dispatch,
     skylight,
     skylightCount,
+    lightProbes,
     skybox,
     skyboxCount,
     fog,