@forgeax/engine-render 0.0.0-dev.8d955ade1c79

package/src/render-system-extract.ts

@@ -0,0 +1,4585 @@
+// @forgeax/engine-runtime - RenderSystem Extract stage (D-S2 + plan-strategy R-15
+// fallback split). Pure ECS query phase: walks Camera / DirectionalLight /
+// the merged-MeshRenderer renderable archetype and produces SoA-free snapshot
+// arrays consumed by the Record stage.
+//
+// Carve-out from render-system.ts (review round 1 finding #3 - 505 line cap
+// fallback split into 3 files; main + extract + record). The public API remains
+// limited to the renderer contract; this module is an owner-local
+// implementation seam consumed through relative imports.
+//
+// w15 (feat-20260511-asset-system-v1 M5 / plan-strategy D-P4) +
+// feat-20260513-component-naming-bevy-align M3 / D-2 (merged) +
+// feat-20260517-merge-mesh-renderer-material-renderer M2 / w5 (rename) +
+// M3 / w9 (single-query convergence; this commit):
+//   The previous 4-query alpha split (one full-archetype query gating on
+//   Transform + MeshFilter + MeshRenderer without Instances; one direct
+//   archetype-graph walk for the instanced variant; two fallback queries
+//   on Transform+MeshFilter without MeshRenderer / MeshFilter without
+//   Transform; one trailing dispatch query gating on MeshRenderer alone)
+//   collapses into ONE archetype-graph walk gated on `MeshRenderer`
+//   component presence (plan-strategy section 2.2 case A archetype-
+//   natural-absence + section 3.2 sequence diagram "with: [MeshRenderer]
+//   (sole)"). Inside the loop
+//   the four D-Q7 dispositions land:
+//     - case A (no MeshRenderer)  : not in domain; archetype absent. No
+//                                   fire; no renderable; no dispatch.
+//     - case B (material === 0)   : missing-spec sentinel; defaultMaterial
+//                                   Snapshot fills the slot. No fire.
+//     - case C (handle unresolved): assets.get(handle).err with the entity
+//                                   carrying the full T+MF+MR renderable
+//                                   archetype -> structured RhiError(
+//                                   `asset-not-registered`) routed through
+//                                   the World Layer-3 ErrorHandler + entity
+//                                   skipped from RenderableSnapshot[] +
+//                                   from MaterialDispatchSnapshot[]; with a
+//                                   non-renderable archetype (MeshRenderer
+//                                   only / lacking T or MF) the dangling
+//                                   handle stays a silent skip (charter F1
+//                                   surface minimization: AI users without
+//                                   render intent should not see render
+//                                   errors).
+//     - resolved                  : populated MaterialSnapshot (5 fields)
+//                                   + MaterialDispatchSnapshot dispatch
+//                                   entry (regardless of T+MF presence,
+//                                   preserving the dispatch-only counter
+//                                   semantics).
+//
+// D-Q7 three-tier subtable (SSOT mirrored in `packages/runtime/README.md`
+// §ECS render bridge D-Q7 `MeshRenderer` three-tier subtable +
+// `components/mesh-renderer.ts` head JSDoc; AGENTS.md §Component naming
+// + §Breaking changes 2026-05-17 row references this surface):
+//   - case A archetype absent : silent skip; no onError; not in
+//                               RenderableSnapshot[]; hint literal N/A
+//                               (charter "ergonomic omission, not a
+//                               misuse"; AC-09).
+//   - case B missing-spec     : `material === undefined` ->
+//                               `defaultMaterialSnapshot()` mid-grey
+//                               unlit; no onError; entity present in
+//                               RenderableSnapshot[] with default
+//                               material; hint literal: `'pass
+//                               undefined or omit field to request
+//                               default material'` (AC-10).
+//   - case C dangling-ref     : `assets.get(handle).err` (strict path,
+//                               isRenderable === true) ->
+//                               `RhiError({ code: 'asset-not-
+//                               registered', detail: { assetHandle },
+//                               hint: 'register material via
+//                               assetRegistry.register(asset) before
+//                               spawn, or remove the material field
+//                               to fall back to default' })` routed
+//                               through World Layer-3 ErrorHandler;
+//                               entity skipped from
+//                               RenderableSnapshot[] +
+//                               MaterialDispatchSnapshot[]; mirrors
+//                               `MeshFilter.assetHandle` dangling path
+//                               (charter proposition 5; AC-11).
+//
+// feat-20260514-ecs-children-instances-managed-buffer-array M3 / w15:
+//   The legacy `Instances { buffer, count }` form (cross-coupled with the
+//   deleted `AssetRegistry.createInstancedBuffer` triplet + the retired
+//   `InstancedBufferAsset` POD) is gone. Per-entity instance transforms now
+//   live inside the ECS `Instances { transforms: 'array<f32>' }` column;
+//   extract materialises a `Float32Array` snapshot per Instances-bearing
+//   entity (via `world.get(e, Instances).transforms`) so the record stage
+//   can upload to a per-entity GPU storage buffer cached by entity packed
+//   u32.
+//
+// feat-20260515-buffer-array-vocab-collapse M3 / w15: the component-level
+// `arrayStride` hook on `Instances.transforms` was retired (decision section
+// 2.3 stride responsibility migration -- AI users gate at the set / push
+// call sites + RenderSystem extract entry holds a defensive fail-fast).
+// The extract entry checks `transforms.length % 16 === 0` directly after
+// the `world.get(entity, Instances)` snapshot is taken; violations route
+// `InstanceTransformsStrideMismatchError`
+// (`code: 'instance-transforms-stride-mismatch'`,
+// `detail: { actualLength, expectedStride: 16 }`) through the World
+// Layer-3 ErrorHandler and the renderable is skipped. The record stage
+// trusts the invariant and does not re-check.
+
+import type { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import {
+  resolveAssetHandle,
+  walkMaterialPassesOverSharedRefs,
+} from '@forgeax/engine-assets-runtime';
+import type { Component, ComponentSchema, EntityHandle, World } from '@forgeax/engine-ecs';
+import {
+  InstanceTransformsStrideMismatchError,
+  readRenderArrayView,
+  routeWorldError,
+  SpawnLightInvalidBoundsError,
+  SpriteInstancesCountMismatchError,
+  SpriteInstancesMutuallyExclusiveWithInstancesError,
+  SpriteInstancesRequiresSpriteShaderError,
+} from '@forgeax/engine-ecs/projection';
+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 {
+  JointCountMismatchError,
+  JointEntityDanglingError,
+  SkeletonResolveFailedError,
+  Skin,
+  SkinInstancesCoexistForbiddenError,
+} from '@forgeax/engine-skinning';
+import type {
+  Asset,
+  Handle,
+  MaterialAsset,
+  MaterialColorParameterSchema,
+  MaterialParameter,
+  MaterialPass,
+  MaterialRenderState,
+  MaterialTextureCoordinates,
+  MaterialTextureValue,
+  MeshAsset,
+  ParamSchemaEntry,
+  PrimitiveTopology,
+  SkeletonAsset,
+} from '@forgeax/engine-types';
+import {
+  ASSET_ERROR_HINTS,
+  AssetError,
+  derive,
+  materialGuidText,
+  materialValuesToLinearRuntime,
+  toShared,
+} from '@forgeax/engine-types';
+import {
+  antialiasFromF32,
+  bloomEnabledFromF32,
+  Camera,
+  cameraProjectionFromF32,
+  DirectionalLight,
+  Instances,
+  Layer,
+  Lines,
+  MeshFilter,
+  MeshRenderer,
+  PointLight,
+  PointLightShadow,
+  Points,
+  PostProcessParams,
+  pointShapeFromU32,
+  SkyboxBackground,
+  Skylight,
+  SortKey,
+  SpotLight,
+  SpriteInstances,
+  SpriteRegionOverride,
+  tonemapFromF32,
+  tonemapToU32,
+} from './components';
+import { GlyphText } from './components/glyph-text';
+import { computeInvRangeSquared, degToCos } from './components/light-helpers';
+import {
+  MaterialSkinAttrMissingError,
+  ShadowInvalidConfigError,
+  SkinMaterialMismatchError,
+} from './errors/render';
+import { resolveVisibility, type VisibilitySnapshot } from './extract/visibility';
+import type {
+  RenderFeatureHiddenEntityReport,
+  RenderFeatureWorldVisibilitySnapshot,
+} from './features/types';
+import { ensureGlyphMeshMaterialSlots } from './glyph-text-layout-system';
+import {
+  type MeshMaterialBindingDiagnostic,
+  type MeshMaterialBindingSource,
+  resolveMeshMaterialBindings,
+} from './mesh-material-bindings';
+import { isStandardPbrMaterialShader } from './pbr-pipeline';
+import { expandPointsLinesBounds } from './points-lines/bounds';
+import type { PointsLinesRetainedSnapshot, PointsLinesStyle } from './points-lines/snapshot';
+import { type CameraSnapshot, STANDARD_TONEMAP_FEATURE_ID } from './render-contract';
+import { getActiveCamera, selectActiveCameraIndex } from './systems/active-camera';
+import { selectPasses } from './systems/pass-selector';
+import type { SkinPaletteAllocator } from './systems/skin-palette-allocator';
+import type { SkinPaletteSlice } from './systems/skin-palette-types';
+
+/**
+ * DirectionalLightSnapshot — sun-like infinite light variant of the
+ * `LightSnapshot` discriminated union (M2 / w16 / AC-03). Host pre-multiplies
+ * `color * intensity` so the shader sees the radiance term directly (charter
+ * P4 host-side parity); `direction` stays in raw outgoing-vector form so the
+ * shader can negate it once for BRDF (`let l = normalize(-light.direction)`).
+ *
+ * Plan-strategy D-S1 (3) (LightSnapshot to GPU buffer bucket 1:1 mapping).
+ */
+export interface DirectionalLightSnapshot {
+  readonly kind: 'directional';
+  readonly direction: Vec3;
+  readonly color: Vec3;
+  readonly intensity: number;
+}
+
+/**
+ * PointLightSnapshot — omnidirectional point variant. `position` from the
+ * companion Transform; `invRangeSquared = 1 / range^2` host-folded via
+ * `computeInvRangeSquared` (range = +Infinity -> 0; range = 0 -> 1e8 NaN
+ * protection per D-S5).
+ */
+export interface PointLightSnapshot {
+  readonly kind: 'point';
+  readonly position: Vec3;
+  readonly color: Vec3;
+  readonly intensity: number;
+  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
+   * 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.
+   */
+  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.
+   */
+  readonly shadowNear?: number;
+  /**
+   * Per-face perspective far plane (matches `PointLightShadow.farPlane`).
+   * Rides `LightSlot.kind_and_pad.w` (byte 60..64).
+   */
+  readonly shadowFar?: number;
+}
+
+/**
+ * PointShadowSnapshot — extract-stage view of one shadow-casting point light
+ * (feat-20260612-point-light-shadows-urp-hdrp M1 / T-M1-7).
+ *
+ * `entity` is the spawning entity (joins PointLight + PointLightShadow on the
+ * same archetype); `position` is the light world-space position resolved from
+ * the companion Transform (mirrors PointLightSnapshot.position).
+ * `shadowMatrices` is the 96-float packed mat4[6] table (column-major,
+ * 6 mat4 * 16 floats = 384 bytes) ready for UBO upload.
+ *
+ * Plan-strategy §D-3: the record stage allocates a dynamic-offset uniform
+ * buffer (384 B per-light, aligned to minUniformBufferOffsetAlignment, WebGPU
+ * min 256 -> 512 B stride). Extract owns the host-side `Float32Array(96)`;
+ * record owns the GPU `RhiBuffer` lifetime.
+ *
+ * `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).
+ */
+export interface PointShadowSnapshot {
+  /** Spawning entity index (joins PointLight + PointLightShadow + Transform). */
+  readonly entity: number;
+  /** World-space light position (sourced from companion Transform). */
+  readonly position: Vec3;
+  /** PointLightShadow.mapSize (per-face cube square dimension; 512 default). */
+  readonly mapSize: number;
+  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).
+   */
+  readonly shadowAtlasLayer: number;
+  /**
+   * 6 view-proj mat4 in face order [+X, -X, +Y, -Y, +Z, -Z] packed into one
+   * Float32Array(96). 16 floats per face = 64 B; 6 * 64 = 384 B raw. The
+   * record stage pads each slot to 512 B (256 alignment) when packing into
+   * the per-light dynamic-offset UBO (plan-strategy §D-3).
+   */
+  readonly shadowMatrices: Float32Array;
+}
+
+/**
+ * SpotLightSnapshot — cone-restricted variant. `position` from companion
+ * Transform; `direction` raw outgoing-vector; `cosInner` / `cosOuter` host
+ * pre-converted via `degToCos` so the shader sees only cosines (D-S2).
+ *
+ * feat-20260625-spot-light-shadow-mapping M1 w5: added shadow fields.
+ * castShadow (bool) gates shadow projection; lightViewProj is the perspective
+ * light-view-projection matrix computed in extract (undefined when castShadow
+ * is false, dir degenerates, or the light is clipped). shadowAtlasTile
+ * (i32 sentinel -1) is the allocated tile index 0..3 or -1 for unassigned
+ * (plan-strategy D-4). mapSize / nearPlane / farPlane are the source
+ * component shadow parameters carried through to the record stage.
+ */
+export interface SpotLightSnapshot {
+  readonly kind: 'spot';
+  readonly position: Vec3;
+  readonly direction: Vec3;
+  readonly color: Vec3;
+  readonly intensity: number;
+  readonly invRangeSquared: number;
+  readonly cosInner: number;
+  readonly cosOuter: number;
+  // ── shadow fields (feat-20260625-spot-light-shadow-mapping M1) ──
+  readonly castShadow: boolean;
+  readonly lightViewProj: Float32Array | undefined;
+  readonly mapSize: number;
+  readonly nearPlane: number;
+  readonly farPlane: number;
+  readonly shadowAtlasTile: number;
+}
+
+/**
+ * LightSnapshot — discriminated union of the three KHR_lights_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;
+
+/**
+ * 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)
+ * `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
+ * pointCount / spotCount fields once the matching record-time fail-fast
+ * lands; for M2 the field stays directional-only to keep AC-06 (a) intact.
+ */
+export interface ExtractedLights {
+  readonly directional: DirectionalLightSnapshot | undefined;
+  readonly directionalCount: number;
+  readonly point: readonly PointLightSnapshot[];
+  readonly spot: readonly SpotLightSnapshot[];
+  /**
+   * feat-20260613-csm-cascaded-shadow-maps M2 / w9: per-cascade light-view-
+   * projection matrices (one per cascade, length 4 pre-allocated). Each matrix
+   * is a column-major 16-float mat4 with atlas tile UV inset baked in
+   * (plan-strategy D-3). cascadeCount < 4: unused slots are zero matrices.
+   * Undefined when castShadow=false or no directional light.
+   */
+  readonly lightViewProj: readonly Float32Array[] | undefined;
+  /**
+   * feat-20260613-csm-cascaded-shadow-maps M2 / w9: view-space z depths
+   * of the PSSM split planes (length 4, Float32Array). cascadeCount < 4:
+   * unused slots are 0.0f. Undefined when castShadow=false or no directional
+   * light.
+   */
+  readonly splitPlanes: Float32Array | undefined;
+  /**
+   * feat-20260613-csm-cascaded-shadow-maps M2 / w9: effective cascade count
+   * from the DirectionalLight component (1..4). Undefined when castShadow=false
+   * or no directional light.
+   */
+  readonly cascadeCount: number | undefined;
+  /**
+   * feat-20260613-csm-cascaded-shadow-maps M2 / w9: cascade blend width
+   * from the DirectionalLight component (0..0.5). Undefined when castShadow=false
+   * or no directional light.
+   */
+  readonly cascadeBlend: number | undefined;
+  /**
+   * feat-20260520-directional-light-shadow-mapping M1c / w8:
+   * shadowMapSize from DirectionalLight.mapSize. Drives shadow RT
+   * lazy-allocate (idempotency: same size -> no rebuild). Undefined when
+   * castShadow=false or no directional light.
+   */
+  readonly shadowMapSize: number | undefined;
+  /**
+   * feat-20260621-merge-directionallightshadow-into-directionallight M2:
+   * depthBias from the merged DirectionalLight (constant shadow-bias floor).
+   * Populated when castShadow=true on the first-hit directional light;
+   * undefined otherwise.
+   */
+  readonly depthBias: number | undefined;
+  /**
+   * feat-20260621-merge-directionallightshadow-into-directionallight M2:
+   * normalBias from the merged DirectionalLight (slope-based shadow-bias
+   * coefficient).
+   * Populated when castShadow=true on the first-hit directional light;
+   * 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;
+  /**
+   * 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).
+   *
+   * Empty array when no PointLightShadow components exist (zero-cost gate per
+   * AC-09; record stage skips atlas allocation + shadow pass dispatch).
+   */
+  readonly pointShadow: readonly PointShadowSnapshot[];
+  /**
+   * bug-20260710-editor-cross-world-shadow: the RAW directional-shadow config
+   * (cascadeCount / splitLambda / cascadeBlend / mapSize / shadowDistance) of
+   * the first-hit castShadow DirectionalLight, carried unconditionally of
+   * whether this world had a camera. The {@link extractFrames} merge layer
+   * re-runs {@link computeDirectionalCsm} with this config + the surfaced
+   * camera so directional shadows work when the light and camera live in
+   * DIFFERENT worlds (editor editorWorld/sceneWorld super-composite). Undefined
+   * when castShadow=false or no directional light. The `lightViewProj` /
+   * `splitPlanes` fields above remain the *computed* per-world outputs (correct
+   * for single-world; recomputed at merge for cross-world).
+   */
+  readonly directionalCsmConfig: DirectionalCsmConfig | undefined;
+  /**
+   * bug-20260710-editor-cross-world-shadow: the light-direction of the
+   * first-hit castShadow DirectionalLight, carried so the merge layer can
+   * rebuild the light-view matrix. Redundant with `directional.direction` but
+   * kept explicit so the CSM recompute reads a single config bundle. Undefined
+   * when castShadow=false or no directional light.
+   */
+  readonly directionalCsmDirection: Vec3 | undefined;
+}
+
+/**
+ * SkylightSnapshot -- extract-stage view of one Skylight entity
+ * (feat-20260520-skylight-ibl-cubemap M4 / t26).
+ *
+ * `equirectHandle` carries the packed u32 handle for
+ * `Handle<EquirectAsset, 'shared'>`; the record stage drives the internal
+ * lazy cubemap projection from it and resolves the projected GPU cubemap via
+ * `GpuResidencyCache.getCubemapGpuView(...)` and related helpers
+ * (feat-20260630 M3 / w16-w18). The snapshot carries NO projection status
+ * field: the status truth lives in the store's CubemapGpuEntry (D-3 SSOT);
+ * record queries it once per frame.
+ *
+ * `intensity` defaults to 1.0 via the Skylight component token defaults
+ * (plan-strategy D-6: Skylight data flows through existing extract->record
+ * pipeline; no independent ECS system).
+ */
+export interface SkylightSnapshot {
+  // 0 = no equirect supplied -> solid-color ambient via the white fallback
+  // cube (record falls to fallback resources when no IBL views are cached).
+  readonly equirectHandle: number;
+  readonly color: readonly [number, number, number];
+  readonly intensity: number;
+  /** Environment-space quaternion [x, y, z, w], identity by default. */
+  readonly rotation: readonly [number, number, number, number];
+  // feat-20260630 M3 / w19: the WINNING Skylight entity's packed handle (first
+  // archetype hit). Carried so the multi-Skylight once-warn can name which
+  // entity is used and which is ignored (F-8: warn carries conflicting entity
+  // info). 0 only if the bundle had no live entity (never happens for a hit).
+  readonly entityHandle: number;
+}
+
+/**
+ * SkyboxSnapshot -- extract-stage view of one SkyboxBackground entity
+ * (feat-20260531-skybox-env-background M2 / w5).
+ *
+ * `equirectHandle` carries the packed u32 handle for
+ * `Handle<EquirectAsset, 'shared'>`; the record stage resolves the projected
+ * GPU cubemap via `GpuResidencyCache.getCubemapGpuView(...)`.
+ *
+ * `mode` carries the raw `f32` column value (`SKYBOX_MODE_CUBEMAP = 0`).
+ * First hit wins per plan-strategy D-6; multi-entity once-warn in record stage.
+ */
+export interface SkyboxSnapshot {
+  readonly equirectHandle: number;
+  readonly mode: number;
+  /** Environment-space quaternion [x, y, z, w], identity by default. */
+  readonly rotation: readonly [number, number, number, number];
+  // feat-20260630 M3 / w19: the WINNING SkyboxBackground entity's packed handle
+  // (first archetype hit), so the multi-SkyboxBackground once-warn can name the
+  // used entity (F-8 parity with the Skylight warn).
+  readonly entityHandle: number;
+}
+
+export interface RenderableSnapshot {
+  readonly assetHandle: number;
+  readonly transform: TransformSnapshot;
+  /** 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. */
+  readonly gpuDrivenDraws?: readonly GpuDrivenDrawSnapshot[];
+  /**
+   * feat-20260608 M5 amend / w11-a: the entity's representative (first)
+   * material snapshot, kept as a same-name shorthand for `materials[0]`.
+   * Per-entity dispatch (shading model routing, sprite-vs-mesh split, the
+   * D-1/D-3 pipeline-tag pick) is uniform across the entity's submeshes
+   * today, so the existing 20+ `entry.source.material.X` consumers in the
+   * record stage stay unchanged. Per-submesh material data (baseColor /
+   * UBO payload / paramSnapshot) lives in `materials[i]`.
+   */
+  readonly material: MaterialSnapshot;
+  /**
+   * feat-20260608 M5 amend / w11-a: per-submesh MaterialSnapshot[]
+   * positionally aligned with `MeshAsset.submeshes[]` (plan §3.2 sequence
+   * step 6 + AC-08). Length always equals the entity's submesh count once
+   * the extract stage's count-mismatch validator (M2 / w12) has filtered
+   * misaligned spawns. The record stage reads `materials[i]` to upload the
+   * i-th material UBO slot before drawing the i-th submesh.
+   *
+   * Backward-compat: `materials[0] === material` (the legacy mid-grey
+   * default-material case-B path also routes through `materials = [default]`,
+   * keeping the legacy single-mesh-no-material spawn shape working without
+   * a special branch in record).
+   */
+  readonly materials: readonly MaterialSnapshot[];
+  /** Per-slot provenance trace from the shared mesh-material resolver. */
+  readonly materialBindingSources: readonly MeshMaterialBindingSource[];
+  /** Active structured override diagnostics for this renderable. */
+  readonly materialBindingDiagnostics?: readonly MeshMaterialBindingDiagnostic[];
+  /**
+   * feat-20260708-composited-multi-world-rendering M1 / D-1: the worldId
+   * of the world this renderable was extracted from. Defaults to 0 in
+   * single-world path (extractFrame always assigns 0). The merge layer
+   * (extractFrames in M2) stamps the correct worldId per world before
+   * the record stage consumes it. Combined with `entityKey` via
+   * `worldEntityKey(worldId, entityKey)` to form per-entity cache keys.
+   *
+   * Never rewrite `entityKey` itself — consumers that need the real
+   * entity handle (video provider, etc.) read the bare `entityKey`.
+   */
+  readonly worldId: number;
+  /**
+   * feat-20260531-per-frame-bind-group-cache M1 / w3: packed Entity u32
+   * (encodeEntity(indexSlot, generation)) surface'd from the extract
+   * stage. Stable per-entity identity for the record stage cache keys
+   * (material / instances / per-frame clean-up) without re-querying the
+   * World (charter P5 Pipeline Isolation: record stage only consumes
+   * snapshot POD). Reuses the encodeEntity calculation already performed
+   * at :1293 for the Instances path, and now also computed for plain
+   * (non-Instances) renderables.
+   *
+   * Never rewrite this field — cache keys use `worldEntityKey(worldId, entityKey)`,
+   * not the bare entityKey alone (D-1).
+   */
+  readonly entityKey: number;
+  /**
+   * feat-20260514 M3 (w15): when the entity carries an `Instances` component
+   * the extract stage materialises a fresh `Float32Array` snapshot of the
+   * packed mat4 transforms (16 f32 per instance, stride 16) plus a stable
+   * `cacheKey` (the entity's packed u32) and the `archVersion` (used by the
+   * record stage to invalidate its per-entity GPU buffer cache when the
+   * archetype storage grew). Absent (`undefined`) means the record stage
+   * falls back to the shared 1-element identity-mat4 storage buffer +
+   * `drawIndexed(.., 1, ..)`.
+   */
+  readonly instances?: InstancesSnapshot;
+  /**
+   * feat-20260625-sprite-instances-and-tilemap-terrain-static-batch M3 / w10
+   * (plan-strategy D-1 + D-9): when the entity carries a `SpriteInstances`
+   * component the extract stage materialises a paired snapshot — packed mat4
+   * `transforms` (16 f32, stride 16) + per-instance UV `regions` (4 f32,
+   * stride 4) — plus the same cache fingerprint pair (`cacheKey` = entity
+   * packed u32, `archVersion` = archetype version stamp at snapshot time).
+   * The record stage interleaves the two arrays into an 80B-per-instance
+   * single GPU buffer routed through `@group(3) @binding(0)` (BGL unchanged,
+   * D-1). Absent (`undefined`) means the entity is not a `SpriteInstances`
+   * carrier; the record stage falls back to its existing sprite path
+   * (material UBO region + identity-instance buffer).
+   *
+   * Three structured `EcsError` codes fire at extract entry and skip the
+   * renderable on violation (charter P3 explicit failure):
+   *   - `'sprite-instances-mutually-exclusive-with-instances'`
+   *   - `'sprite-instances-requires-sprite-shading-model'`
+   *   - `'sprite-instances-count-mismatch'`
+   */
+  readonly spriteInstances?: SpriteInstancesSnapshot;
+  /**
+   * feat-20260523-skin-skeleton-animation M2 / T-21: when the entity carries
+   * a `Skin` component the extract stage populates this field with the
+   * skin palette slice metadata. The record stage uses this to route the
+   * draw to `forgeax::pbr-skin` pipeline + set the palette dynamic offset.
+   * Absent (`undefined`) means the entity is not skinned.
+   */
+  readonly skin?: SkinPaletteSlice;
+  /**
+   * ECS-owned morph weights. Presence selects the Standard Pipeline CPU
+   * specialized deformation lane; the asset remains the source of target
+   * deltas and the record stage only receives this frozen POD snapshot.
+   */
+  readonly morph?: MorphSnapshot;
+  /** Detached M2 authoring facts for the optional Points/Lines projection. */
+  readonly pointsLines?: PointsLinesRetainedSnapshot;
+}
+
+export interface MorphSnapshot {
+  readonly weights: Float32Array;
+  readonly targetCount: number;
+}
+
+export interface GpuDrivenDrawSnapshot {
+  readonly kind: 'indexed' | 'non-indexed';
+  readonly first: number;
+  readonly count: number;
+  readonly baseVertex: number;
+  readonly materialSlot: number;
+  readonly topology: PrimitiveTopology;
+  readonly pipelineClass: string;
+  readonly materialResourceClass: string;
+}
+
+export interface InstancesSnapshot {
+  /** Packed column-major mat4 transforms (16 f32 per instance). */
+  readonly transforms: Float32Array;
+  /** Number of instances (transforms.length / 16). */
+  readonly instanceCount: number;
+  /** Stable per-entity GPU buffer cache key (the packed Entity u32). */
+  readonly cacheKey: number;
+  /**
+   * Archetype version stamp at snapshot time. The record stage compares this
+   * against its cached version per cacheKey; a bump means the underlying
+   * BufferPool slot may have grown / been reallocated, forcing a fresh
+   * `device.createBuffer + queue.writeBuffer` round.
+   */
+  readonly archVersion: number;
+}
+
+/**
+ * feat-20260625-sprite-instances-and-tilemap-terrain-static-batch M3 / w10:
+ * extract-stage view of a `SpriteInstances` carrier (2D peer of
+ * `InstancesSnapshot`).
+ *
+ * Field shapes mirror `InstancesSnapshot` so the record-stage cache protocol
+ * (`(cacheKey, archVersion, byteLength)` fingerprint triple) is reused
+ * verbatim. The byte length consumed at upload time is the sum
+ * `transforms.byteLength + regions.byteLength` (= 80*N for N instances,
+ * plan-strategy D-1 interleaved single-buffer); the record stage builds the
+ * 80B/instance interleaved buffer once per (entity, archVersion, byteLength)
+ * fingerprint change.
+ */
+export interface SpriteInstancesSnapshot {
+  /** Packed column-major mat4 transforms (16 f32 per instance, stride 16). */
+  readonly transforms: Float32Array;
+  /** Per-instance UV vec4 regions (4 f32 per instance, stride 4). */
+  readonly regions: Float32Array;
+  /**
+   * Number of instances. Derived from `transforms.length / 16` (equivalently
+   * `regions.length / 4`); the extract-entry validator guarantees the two
+   * derivations agree, otherwise it fires
+   * `'sprite-instances-count-mismatch'` and skips the renderable.
+   */
+  readonly instanceCount: number;
+  /** Stable per-entity GPU buffer cache key (the packed Entity u32, D-9). */
+  readonly cacheKey: number;
+  /** Archetype version stamp at snapshot time (cache invalidation fingerprint). */
+  readonly archVersion: number;
+}
+
+/**
+ * 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
+ * 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.
+ */
+export interface TransformSnapshot {
+  readonly world: Float32Array;
+}
+
+/**
+ * MaterialSnapshot: extract-stage view of one entity's material asset (M2 / w6
+ * of feat-20260517-merge-mesh-renderer-material-renderer; plan-strategy section 2.3).
+ *
+ * Adds optional `baseColorTexture` + `sampler` slots (consumed by the record
+ * stage's textured-material code path; M3 / w10 dropped the cast-over-firstMaterial
+ * pattern in favour of direct snapshot field reads).
+ *
+ * feat-20260522-learn-render-3-1-sponza-model-loading-with-multi-l M4 extends
+ * the snapshot with `metallicRoughnessTexture` and `normalTexture`
+ * so the record stage can wire PBR texture bindings 4 and 6
+ * from real GPU views instead of placeholder 1x1 white / flat-normal views.
+ *
+ * Bounded scope: the snapshot tracks only what the record stage actually
+ * consumes today (charter proposition 5 consistent abstraction; YAGNI for
+ * future-proof field bloat). Future MaterialAsset extensions (emissive / etc)
+ * drive snapshot extensions when the record stage starts consuming them, not
+ * vice-versa.
+ *
+ * tweak-20260701 M1: `shadingModel` field removed — shader identity via
+ * {@link materialShaderId} is the single source of truth for material dispatch.
+ */
+export interface MaterialSnapshot {
+  readonly baseColor: Vec3;
+  readonly metallic: number;
+  readonly roughness: number;
+  readonly clearcoat?: number | undefined;
+  readonly clearcoatRoughness?: number | undefined;
+  /** Authored Standard PBR specular tint in linear runtime color space. */
+  readonly specularTint?: readonly [number, number, number] | undefined;
+  /**
+   * Schema-driven material shader identifier (feat-20260523 M4-T05).
+   * Populated when the material asset uses the schema-driven path
+   * (payload.materialShader set). Undefined for unlit/sprite legacy
+   * materials and for case-B defaultMaterialSnapshot.
+   *
+   * The record stage uses this as the pipeline cache key first-level
+   * discriminator (M4-T06).
+   */
+  readonly materialShaderId?: string | undefined;
+  /**
+   * Stable source handle for the material asset. Record uses this only for
+   * same-frame assembly reuse; GPU bind-group validity still comes from the
+   * resource-identity cache.
+   */
+  readonly materialHandle?: number | undefined;
+  /**
+   * The selected forward-pass state for this exact material. A mesh can bind
+   * different materials to its submeshes, so pipeline selection must read the
+   * state from the submesh snapshot rather than the entity's first material.
+   */
+  readonly renderState?: MaterialRenderState | undefined;
+  /**
+   * Schema-driven parameter snapshot (feat-20260523 M4-T05).
+   * Populated alongside materialShaderId. Maps param name to its
+   * runtime-resolved value: number for scalar params, number[] for
+   * vec/color params, string (GUID) for texture2d/sampler params.
+   */
+  readonly paramSnapshot?: Readonly<Record<string, number | number[] | string>> | undefined;
+  /** Effective MaterialAsset parameter contract used to lay out this snapshot. */
+  readonly materialParamSchema?: readonly ParamSchemaEntry[] | undefined;
+  /** Authored per-slot UV set and KHR texture transform metadata. */
+  readonly textureCoordinates?: ReadonlyMap<string, MaterialTextureCoordinates> | undefined;
+  /**
+   * User-region texture handles keyed by paramSchema field name
+   * (feat-20260621-learn-render-5-5-parallax M2 / w7). The SSOT carrier for
+   * EVERY texture the shader's `derive(paramSchema).textureFieldNames`
+   * declares — `baseColorTexture` / `metallicRoughnessTexture` /
+   * `normalTexture` for built-in standard-PBR, plus each custom field such as
+   * `heightTexture` (LO 5.5 parallax). The record stage iterates this map to
+   * assemble the user-region bind group per the per-shader BGL (w8), so a 4th
+   * (or Nth) texture flows end-to-end without a hardcoded field list.
+   *
+   * Populated by iterating `textureFieldNames`; absent keys mean the
+   * paramValue was missing / mis-typed (record falls back to default white).
+   * `emissiveTexture` / `occlusionTexture` are NOT here — they live in the
+   * engine-injection lightmap region (their named fields below feed
+   * `appendInjection('lightmap')`, not the user-region).
+   */
+  readonly textureHandles?: ReadonlyMap<string, Handle<'TextureAsset', 'shared'>> | undefined;
+  /**
+   * User-region texture field names whose paramValue resolved to a VideoAsset
+   * (kind `'video'`) rather than a static TextureAsset
+   * (feat-20260623-world-space-video-asset M4 / w14, D-5). The video GUID
+   * occupies the same texture2d values slot a static texture would (P4:
+   * one binding shape), but extract routes it here instead of `textureHandles`
+   * so the record stage pulls the current-frame view from the transient
+   * DynamicTextureStore (D-3) instead of `GpuResidencyCache.ensureResident`
+   * (which has no `video` arm; AC-08). Each entry also carries the resolved
+   * clip handle so the record stage can key the per-frame upload.
+   *
+   * Producer/consumer split (charter P5 / AC-07 gate): extract owns the
+   * asset->snapshot translation; record consumes this POD field only — it never
+   * reaches back into the MaterialAsset to learn a field is video-sourced.
+   */
+  readonly videoTextureFields?: ReadonlyMap<string, Handle<'VideoAsset', 'shared'>> | undefined;
+  /** Authored sampler handles keyed by their matching texture parameter. */
+  readonly samplerHandles?: ReadonlyMap<string, Handle<'SamplerAsset', 'shared'>> | undefined;
+  readonly baseColorTexture?: Handle<'TextureAsset', 'shared'> | undefined;
+  /**
+   * PBR metallic-roughness texture handle (present for PBR/sprite/skin
+   * shaders). Undefined for the default-unlit shader
+   * (materialShaderId === 'forgeax::default-unlit'). The record stage reads
+   * this to write GPU view at material bind-group binding 4, falling
+   * back to a 1x1 white placeholder when undefined.
+   *
+   * feat-20260522-learn-render-3-1-sponza-model-loading-with-multi-l M4:
+   * field added so the record stage can wire real metallic-roughness
+   * textures from Sponza glTF materials (M3 writes the handle into
+   * SchemaDrivenMaterialAsset values; M4 extract carries it through to the snapshot).
+   */
+  readonly metallicRoughnessTexture?: Handle<'TextureAsset', 'shared'> | undefined;
+  /**
+   * PBR tangent-space normal texture handle (present for PBR/sprite/skin
+   * shaders). Undefined for the default-unlit shader
+   * (materialShaderId === 'forgeax::default-unlit'). The record stage reads
+   * this to write GPU view at material bind-group binding 6, falling
+   * back to a (0.5,0.5,1.0) flat-normal placeholder when undefined.
+   *
+   * feat-20260522-learn-render-3-1-sponza-model-loading-with-multi-l M4:
+   * field added symmetrically with metallicRoughnessTexture so the record
+   * stage can wire real normal textures from Sponza glTF materials.
+   */
+  readonly normalTexture?: Handle<'TextureAsset', 'shared'> | undefined;
+  /** Scalar applied to tangent-space normal XY after the normal texture sample. */
+  readonly normalScale?: number | undefined;
+  readonly emissive?: readonly [number, number, number] | undefined;
+  readonly emissiveIntensity?: number | undefined;
+  readonly emissiveTexture?: Handle<'TextureAsset', 'shared'> | undefined;
+  readonly occlusionTexture?: Handle<'TextureAsset', 'shared'> | undefined;
+  readonly occlusionStrength?: number | undefined;
+  /**
+   * Transparent composition flag derived from the first pass's
+   * `renderState.blend` presence on the underlying
+   * {@link MaterialPass} (feat-20260626-collapse M2: blend
+   * presence is the SSOT after `MaterialPass.transparent` was
+   * dropped in M1).
+   *
+   * The record stage reads this to drive both the LDR split-pass
+   * decision and the premultiplied-alpha blend resolution on the
+   * generic materialShaderId pipeline path — shader-agnostic, decoupled
+   * from the legacy `shadingModel` discriminant (feat-20260625 M2 D-3,
+   * finalised in w15; `shadingModel` field removed in tweak-20260701 M1).
+   *
+   * Extract derives this from the first pass's `renderState.blend !==
+   * undefined` (post-feat-20260626-collapse: blend presence is the
+   * single SSOT for "this material is transparent on the geometry
+   * pipeline cache key"). Multi-pass materials whose mix of opaque +
+   * transparent passes need finer routing should split into separate
+   * MaterialAsset entries (the normal forgeax pattern).
+   *
+   * Type is `boolean | undefined` (derived): `undefined` means "no
+   * passes / unknown"; consumers must read `=== true` / `!== true` to
+   * stay correct under both populated and absent cases.
+   */
+  readonly transparent?: boolean | undefined;
+}
+
+interface MaterialCacheChainIdentity {
+  readonly asset: MaterialAsset;
+  readonly parentGuid: string | undefined;
+}
+
+export interface MaterialSnapshotCacheEntry {
+  readonly snapshot: MaterialSnapshot;
+  readonly passes: readonly MaterialPass[];
+  /** Root/chain identities are present only on cross-frame-safe entries. */
+  readonly chain?: readonly MaterialCacheChainIdentity[];
+  /** AssetRegistry epoch at which the root/parent chain was last validated. */
+  readonly catalogEpoch?: number;
+  /** True only when every object reachable from the authored chain is frozen. */
+  readonly crossFrameSafe: boolean;
+}
+
+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,
+// replacing the old three-bucket opaque/transparent/overlay dispatch.
+// Each entry carries the per-pass render-state and entry-point
+// data from the resolved MaterialPass so the record stage
+// reads them without re-resolving the material.
+
+export interface DispatchEntry {
+  readonly entityIndex: number;
+  readonly materialHandle: number;
+  readonly renderableIndex: number;
+  readonly passIndex: number;
+  readonly queue: number;
+  /**
+   * Signed i32 from the entity's {@link Layer} component value (default 0 for
+   * entities without a Layer). Primary sort key for the transparent-dispatch
+   * sort in {@link render-system.ts}: lower value = drawn first (behind).
+   */
+  readonly layer: number;
+  readonly tags: Record<string, string>;
+  readonly renderState: MaterialRenderState | undefined;
+  readonly defines: Record<string, string> | undefined;
+  readonly vertexEntry: string | undefined;
+  readonly fragmentEntry: string | undefined;
+  readonly materialShaderId: string | undefined;
+  readonly paramSnapshot: Readonly<Record<string, number | number[] | string>> | undefined;
+  /**
+   * Stencil reference value from {@link MaterialPass.stencilReference}
+   * (draw-call dynamic state). Folded during extract for per-draw consumption
+   * in the record stage. `undefined` when the pass does not set a reference
+   * value (record stage falls back to WebGPU default 0).
+   */
+  readonly stencilReference?: number;
+}
+
+/**
+ * Stable-sort dispatch entries by `queue` value ascending.
+ * Returns a new sorted array (does not mutate the input).
+ * Same-queue entries preserve insertion order (AC-11 stable-order guarantee).
+ */
+export function sortDispatchByQueue<E extends { readonly queue: number }>(
+  entries: readonly E[],
+): E[] {
+  // Array.prototype.sort is stable per ES2019 spec (V8 7.0+ / Node 12+).
+  return entries.slice().sort((a, b) => a.queue - b.queue);
+}
+
+const DEFAULT_FORWARD_PASS: MaterialPass = {
+  name: 'forward',
+  program: { module: 'forgeax::default-unlit', vertexEntry: 'vs_main', fragmentEntry: 'fs_main' },
+  renderState: { tags: { LightMode: 'Forward' }, queue: 2000 },
+};
+
+function appendMaterialDispatchEntries(
+  pendingDispatch: DispatchEntry[],
+  passes: readonly MaterialPass[],
+  entity: EntityHandle,
+  materialHandle: number,
+  renderableIndex: number,
+  layer: number,
+  paramSnapshot: Readonly<Record<string, number | number[] | string>> | undefined,
+  passIndexOffset = 0,
+): void {
+  const matchedPasses = selectPasses(passes, {});
+  for (let pIdx = 0; pIdx < matchedPasses.length; pIdx++) {
+    const pass = matchedPasses[pIdx];
+    if (pass === undefined) continue;
+    const passState = (pass.renderState ?? {}) as MaterialRenderState & {
+      readonly tags?: Record<string, string>;
+      readonly queue?: number;
+      readonly stencilReference?: number;
+    };
+    pendingDispatch.push({
+      entityIndex: entity,
+      materialHandle,
+      renderableIndex,
+      passIndex: passIndexOffset + pIdx,
+      queue: passState.queue ?? 2000,
+      layer,
+      tags: passState.tags ?? {},
+      renderState: pipelineRenderState(passState),
+      // Material module identity is already closed in the cooked program.
+      // It must never become a draw-time define map.
+      defines: undefined,
+      vertexEntry: pass.program.vertexEntry,
+      fragmentEntry: pass.program.fragmentEntry,
+      materialShaderId: runtimeMaterialShaderId(pass.program.module, pass.name),
+      paramSnapshot,
+      ...(passState.stencilReference !== undefined && {
+        stencilReference: passState.stencilReference,
+      }),
+    });
+  }
+}
+
+export interface ExtractedFrame {
+  readonly cameras: CameraSnapshot[];
+  readonly lights: ExtractedLights;
+  readonly renderables: RenderableSnapshot[];
+  /**
+   * Single dispatch list sorted by queue value (ascending, stable sort).
+   * Replaces the old opaqueDispatch / transparentDispatch / overlayDispatch
+   * three-bucket model per plan-strategy D-3.
+   */
+  readonly dispatch: DispatchEntry[];
+  readonly skylight: SkylightSnapshot | undefined;
+  readonly skylightCount: number;
+  readonly skybox: SkyboxSnapshot | undefined;
+  readonly skyboxCount: number;
+  /**
+   * feat-20260528-frustum-culling M3 / w11: frustum culling statistics
+   * collected during the extract phase. `total` is the count of entities
+   * that reached the culling decision point; `culled` is the count of
+   * those that were removed from renderables by frustum culling.
+   */
+  readonly frustumStats: { readonly culled: number; readonly total: number };
+  /** Candidate entities rejected by author visibility before resource parsing. */
+  readonly visibilityStats: { readonly explicitlyHidden: number };
+  /**
+   * Per-frame post-process params snapshot collected from PostProcessParams
+   * entities (D-1: data-driven params channel). Maps shader id to the
+   * raw data bytes (Uint8Array = FieldValueType<'buffer'>). Last-one-wins
+   * when multiple entities bear the same shader id.
+   * Empty map when no PostProcessParams entities exist.
+   */
+  readonly postProcessParams: ReadonlyMap<string, Uint8Array>;
+  /** Visibility snapshots prepared for each contributing World. */
+  readonly visibilitySnapshots: readonly VisibilitySnapshot[];
+  /** World-labelled snapshots passed to generic RenderFeature extraction. */
+  readonly featureVisibilitySnapshots: readonly RenderFeatureWorldVisibilitySnapshot[];
+  /** Built-in hidden candidates, retained for host-side producer deduplication. */
+  readonly hiddenEntityReports: readonly RenderFeatureHiddenEntityReport[];
+}
+
+/**
+ * Internal world surface used by extract for archetype-graph traversal and
+ * error routing. The packed `Entity` handle for a row is read directly from
+ * the essential id=0 `Entity` column (`arch.columns.get(Entity.id).get('self')`)
+ * -- no generation lookup / encodeEntity rebuild (feat-20260602 M2).
+ */
+type RenderErrorContext = {
+  readonly systemName: string;
+  /** Retained as diagnostic metadata for legacy render call sites. */
+  readonly severity?: 'error' | 'warning';
+};
+
+type ArrayFieldView = ArrayLike<number>;
+
+/**
+ * Render's old zero-copy ECS calls now use the explicit public projection
+ * boundary. The optimized ECS owner keeps storage behind `World`; render
+ * receives a detached array snapshot and routes failures through the same
+ * projection owner.
+ */
+type WorldInternalView = {
+  _routeError(error: unknown, ctx: RenderErrorContext): void;
+  _getArrayView<N extends string, S extends ComponentSchema>(
+    entity: EntityHandle,
+    component: Component<N, S>,
+    fieldName: string,
+  ): ArrayFieldView | undefined;
+};
+
+const Severity = Object.freeze({ Error: 'error', Warning: 'warning' } as const);
+
+function createWorldInternalView(world: World): WorldInternalView {
+  return {
+    _routeError(error, ctx) {
+      routeWorldError(world, error, { systemName: ctx.systemName });
+    },
+    _getArrayView(entity, component, fieldName) {
+      return readRenderArrayView(world, entity, component, fieldName) as ArrayFieldView | 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
+ * (cross-worktree shader-late-register, plan R-4) so a built-in material still
+ * resolves its user-region textures. Mirrors `derive(default-standard-pbr).textureFieldNames`.
+ */
+const BUILTIN_USER_REGION_TEXTURE_FIELDS: readonly string[] = [
+  'baseColorTexture',
+  'metallicRoughnessTexture',
+  'normalTexture',
+  'specularTintTexture',
+];
+const BUILTIN_USER_REGION_TEXTURE_FIELD_SET = new Set(BUILTIN_USER_REGION_TEXTURE_FIELDS);
+const BUILTIN_BASE_COLOR_TEXTURE_FIELD_SET = new Set(['baseColorTexture']);
+
+function materialTextureFields(
+  shaderId: string | undefined,
+  fields: ReadonlySet<string> | undefined,
+): ReadonlySet<string> | undefined {
+  if (fields !== undefined && fields.size > 0) return fields;
+  if (
+    shaderId === 'forgeax::default-standard-pbr' ||
+    shaderId === 'forgeax::default-standard-pbr-skin' ||
+    shaderId === 'forgeax::pbr-skin'
+  ) {
+    return BUILTIN_USER_REGION_TEXTURE_FIELD_SET;
+  }
+  if (
+    shaderId === 'forgeax::default-unlit' ||
+    shaderId === 'forgeax::sprite' ||
+    shaderId === 'forgeax::sprite-lit'
+  ) {
+    return BUILTIN_BASE_COLOR_TEXTURE_FIELD_SET;
+  }
+  return fields;
+}
+
+/**
+ * The authored material surface uses the module IDs declared by built-in WGSL
+ * sources. Runtime pipeline caches still use the existing engine registration
+ * IDs, so this small projection keeps authored identity and renderer lookup
+ * identity in one place during the migration.
+ */
+function runtimeMaterialShaderId(
+  module: string | undefined,
+  passName?: string,
+): string | undefined {
+  if (
+    passName === 'shadow-caster' &&
+    (module === 'forgeax_material::standard' ||
+      module === 'forgeax_material::unlit' ||
+      module === 'forgeax::default-standard-pbr' ||
+      module === 'forgeax::default-unlit')
+  ) {
+    return 'forgeax::default-shadow-caster';
+  }
+  switch (module) {
+    case 'forgeax_material::standard':
+      return 'forgeax::default-standard-pbr';
+    case 'forgeax_material::unlit':
+      return 'forgeax::default-unlit';
+    case 'forgeax_material::sprite':
+      return 'forgeax::sprite';
+    case 'forgeax_material::sprite-lit':
+      return 'forgeax::sprite-lit';
+    default:
+      return module;
+  }
+}
+
+function pipelineRenderState(
+  renderState:
+    | (MaterialRenderState & {
+        readonly tags?: Readonly<Record<string, string>>;
+        readonly queue?: number;
+        readonly stencilReference?: number;
+      })
+    | undefined,
+): MaterialRenderState | undefined {
+  if (renderState === undefined) return undefined;
+  const {
+    cullMode,
+    depthCompare,
+    depthWriteEnabled,
+    blend,
+    alphaToCoverageEnabled,
+    stencil,
+    stencilReadMask,
+    stencilWriteMask,
+    frontFace,
+  } = renderState;
+  if (
+    cullMode === undefined &&
+    depthCompare === undefined &&
+    depthWriteEnabled === undefined &&
+    blend === undefined &&
+    alphaToCoverageEnabled === undefined &&
+    stencil === undefined &&
+    stencilReadMask === undefined &&
+    stencilWriteMask === undefined &&
+    frontFace === undefined
+  ) {
+    return undefined;
+  }
+  return {
+    ...(cullMode !== undefined && { cullMode }),
+    ...(depthCompare !== undefined && { depthCompare }),
+    ...(depthWriteEnabled !== undefined && { depthWriteEnabled }),
+    ...(blend !== undefined && { blend }),
+    ...(alphaToCoverageEnabled !== undefined && { alphaToCoverageEnabled }),
+    ...(stencil !== undefined && { stencil }),
+    ...(stencilReadMask !== undefined && { stencilReadMask }),
+    ...(stencilWriteMask !== undefined && { stencilWriteMask }),
+    ...(frontFace !== undefined && { frontFace }),
+  };
+}
+
+/**
+ * tweak-20260627-model-loading-smoke-build-perf M4: per-World intern cache for
+ * the loadByGuid texture/sampler resolution path. A MaterialAsset's
+ * texture/sampler values remain embedded GUID strings (dash-form) after
+ * loadByGuid; the extract stage re-resolves each GUID to a column handle every
+ * frame. Before this cache each resolution called `world.allocSharedRef`, which
+ * mints a NEW monotonically-increasing slot id per call. Because the GPU
+ * residency cache (`GpuResidencyCache.textureGpuHandles`) is keyed on
+ * `handleSlot(handle)`, a fresh slot every frame meant the residency check
+ * ALWAYS missed -> all textures re-uploaded to the GPU every frame, old GPU
+ * textures never freed (refcount never hits 0). Unbounded GPU memory +
+ * unbounded per-frame upload cost (628ms -> 2764ms over 12 frames, SIGKILL).
+ *
+ * The fix interns the GUID-string -> column-handle resolution: each unique
+ * `(guid, brand)` pair mints EXACTLY ONE stable shared handle per World, reused
+ * across frames (architecture-principle §6 idempotency: same GUID resolved N
+ * times yields the same handle). The handle is intentionally long-lived -- it
+ * lives as long as the World references the material, which is exactly the
+ * desired lifetime; the `onLastRelease` -> `gpuStore.evictTexture` wiring stays
+ * coherent because the handle is no longer churned per frame.
+ *
+ * Invariant boundary (asset-registry.ts:1958-1962): the AssetRegistry is a
+ * GUID -> payload catalogue with NO handle/World concept -- it cannot mint a
+ * column handle. So this intern cache lives in the extract/render layer, keyed
+ * per-World via a WeakMap (the World owns the SharedRefStore that mints slots).
+ *
+ * Inner key is `${lowercasedGuid}\u0000${brand}` -- a GUID catalogues to a
+ * single asset kind in practice, but the brand keeps the key correct if the
+ * same GUID is ever resolved under two brands.
+ *
+ * Cache hits are validated against the registry's current payload identity.
+ * Re-cataloguing the same GUID therefore retires the cache's allocation grant
+ * and mints a handle for the replacement payload. An invalidated GUID retires
+ * the entry immediately instead of keeping a stale payload alive.
+ */
+interface GuidHandleInternEntry {
+  readonly handle: number;
+  readonly payload: Asset;
+}
+
+const guidHandleInternByWorld = new WeakMap<World, Map<string, GuidHandleInternEntry>>();
+
+function internSharedRefFromGuid<B extends string>(
+  world: World,
+  assetsRef: AssetRegistry,
+  guid: string,
+  brand: B,
+): Handle<B, 'shared'> | undefined {
+  let perWorld = guidHandleInternByWorld.get(world);
+  if (perWorld === undefined) {
+    perWorld = new Map<string, GuidHandleInternEntry>();
+    guidHandleInternByWorld.set(world, perWorld);
+  }
+  const key = `${guid.toLowerCase()}\u0000${brand}`;
+  const cached = perWorld.get(key);
+  const payload = assetsRef.lookup(guid);
+  if (cached !== undefined && cached.payload === payload) {
+    const cachedHandle = toShared<B>(cached.handle);
+    if (world.sharedRefs.resolve(cachedHandle).ok) return cachedHandle;
+  }
+  if (cached !== undefined) {
+    world.sharedRefs.release(toShared<B>(cached.handle));
+    perWorld.delete(key);
+  }
+  if (payload === undefined) return undefined;
+  // Mint exactly once per (world, guid, brand). ECS owns the allocation grant
+  // and publishes release evidence through SharedRefStore; render does not
+  // attach a second deleter lifecycle to the World.
+  const handle = world.internSharedRef(brand, payload);
+  perWorld.set(key, { handle, payload });
+  return handle;
+}
+
+/**
+ * feat-20260623-world-space-video-asset M4 / w14 (D-5): if a user-region
+ * texture field's paramValue is an embedded GUID string that catalogues to a
+ * VideoAsset (`kind === 'video'`), mint a `VideoAsset`-branded column handle for
+ * it and return that handle; otherwise return undefined (the field is a static
+ * texture / sampler / scalar and flows through the normal TextureAsset path).
+ *
+ * The video GUID occupies the same texture2d values slot a static texture
+ * would (P4: identical binding shape) — extract just routes it to a different
+ * GPU lifecycle (the transient DynamicTextureStore, D-3) instead of the static
+ * `ensureResident` cache, whose switch has no `video` arm (AC-08). Minting a
+ * brand-`VideoAsset` handle keeps the snapshot self-describing: the record stage
+ * sees a video handle and resolves the per-frame view without reaching back into
+ * the asset (charter P5).
+ *
+ * A `number` paramValue (already a minted column handle) is not a GUID string so
+ * it cannot be a freshly-catalogued video; it passes through as undefined here.
+ */
+function resolveVideoFieldHandle(
+  value: unknown,
+  world: World,
+  assetsRef: AssetRegistry,
+): Handle<'VideoAsset', 'shared'> | undefined {
+  const texture = materialTextureValue(value);
+  const textureGuid = assetReferenceText(texture?.texture ?? value);
+  if (textureGuid === undefined) return undefined;
+  const payload = assetsRef.lookup(textureGuid);
+  if (payload === undefined || payload.kind !== 'video') return undefined;
+  // M4: intern so a video GUID mints one stable VideoAsset handle per World
+  // instead of a fresh slot every frame. The transient per-frame view is
+  // resolved downstream by this handle (DynamicTextureStore); minting the
+  // handle once does not freeze the view (P5: handle != frame data).
+  return internSharedRefFromGuid(world, assetsRef, textureGuid, 'VideoAsset');
+}
+
+function materialTextureValue(value: unknown): MaterialTextureValue | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
+  const textureValue = value as Partial<MaterialTextureValue>;
+  return typeof textureValue.texture === 'number' ||
+    typeof textureValue.texture === 'string' ||
+    textureValue.texture instanceof Uint8Array
+    ? (textureValue as MaterialTextureValue)
+    : undefined;
+}
+
+function assetReferenceText(value: unknown): string | undefined {
+  if (typeof value === 'string') return value;
+  if (value instanceof Uint8Array && isAssetGuidBytes(value)) return AssetGuid.format(value);
+  return undefined;
+}
+
+function isAssetGuidBytes(value: Uint8Array): value is AssetGuidBytes {
+  return value.byteLength === 16;
+}
+
+function materialNormalScale(values: Readonly<Record<string, unknown>>): number {
+  for (const [field, value] of Object.entries(values)) {
+    if (field !== 'normalTexture') continue;
+    const scale = materialTextureValue(value)?.normalScale;
+    return typeof scale === 'number' && Number.isFinite(scale) ? scale : 1;
+  }
+  return 1;
+}
+
+function materialTextureRef(value: unknown): unknown {
+  return materialTextureValue(value)?.texture ?? value;
+}
+
+function collectMaterialTextureCoordinates(
+  values: Readonly<Record<string, unknown>>,
+): Map<string, MaterialTextureCoordinates> {
+  const out = new Map<string, MaterialTextureCoordinates>();
+  for (const field of [
+    'baseColorTexture',
+    'metallicRoughnessTexture',
+    'normalTexture',
+    'specularTintTexture',
+    'emissiveTexture',
+    'occlusionTexture',
+  ]) {
+    const coordinates = materialTextureValue(values[field])?.coordinates;
+    if (coordinates !== undefined) out.set(field, coordinates);
+  }
+  return out;
+}
+
+function collectMaterialTextureSamplers(
+  values: Readonly<Record<string, unknown>>,
+  resolveSampler: (value: unknown) => Handle<'SamplerAsset', 'shared'> | undefined,
+): Map<string, Handle<'SamplerAsset', 'shared'>> {
+  const out = new Map<string, Handle<'SamplerAsset', 'shared'>>();
+  for (const [field, value] of Object.entries(values)) {
+    const sampler = resolveSampler(materialTextureValue(value)?.sampler);
+    if (sampler !== undefined) out.set(field, sampler);
+  }
+  const legacySampler = resolveSampler(values.sampler);
+  if (legacySampler !== undefined && !out.has('baseColorTexture')) {
+    out.set('baseColorTexture', legacySampler);
+  }
+  return out;
+}
+
+/**
+ * feat-20260621-learn-render-5-5-parallax M2 / w7 (D-3): collect the
+ * user-region texture handles for a material by iterating the shader's
+ * `derive(paramSchema).textureFieldNames` SSOT (via
+ * `AssetRegistry.materialShaderTextureFieldNames`). Each declared texture
+ * field whose paramValue resolves to a handle lands in the returned map keyed
+ * by field name; this is the single path through which an arbitrary number of user-region
+ * textures (4 standard or 5+ custom, e.g. parallax `heightTexture`) flow.
+ *
+ * When the shader is not registered the built-in 4-field set is used so
+ * standard materials still resolve. `emissiveTexture` / `occlusionTexture`
+ * are engine-injection (lightmap) textures and are NOT part of this set.
+ *
+ * feat-20260623-world-space-video-asset M4 / w14 (D-5): a field whose paramValue
+ * catalogues to a VideoAsset is routed into `videoOut` (a VideoAsset-branded
+ * handle) instead of the TextureAsset map, so the record stage pulls its view
+ * from the transient DynamicTextureStore (D-3) rather than the static
+ * ensureResident cache (AC-08). The video GUID still has to be in this
+ * `textureFieldNames` traversal set or it is never inspected (R-7) — that
+ * membership is asserted in w13.
+ */
+function collectUserRegionTextureHandles(
+  pv: Readonly<Record<string, unknown>>,
+  shaderId: string | undefined,
+  paramSchema: readonly ParamSchemaEntry[] | undefined,
+  assetsRef: AssetRegistry,
+  world: World,
+  resolveTex: (
+    value: unknown,
+    brand: 'TextureAsset',
+  ) => Handle<'TextureAsset', 'shared'> | undefined,
+  videoOut: Map<string, Handle<'VideoAsset', 'shared'>>,
+): Map<string, Handle<'TextureAsset', 'shared'>> {
+  const fields =
+    materialTextureFields(
+      shaderId,
+      paramSchema !== undefined
+        ? derive(paramSchema).textureFieldNames
+        : shaderId !== undefined
+          ? assetsRef.materialShaderTextureFieldNames(shaderId)
+          : undefined,
+    ) ?? BUILTIN_USER_REGION_TEXTURE_FIELDS;
+  const out = new Map<string, Handle<'TextureAsset', 'shared'>>();
+  for (const field of fields) {
+    // D-5: a video-kind paramValue is routed to the transient path (videoOut),
+    // NOT minted as a TextureAsset (which would crash the record-stage
+    // ensureResident, AC-08). A static field falls through to resolveTex.
+    const videoHandle = resolveVideoFieldHandle(pv[field], world, assetsRef);
+    if (videoHandle !== undefined) {
+      videoOut.set(field, videoHandle);
+      continue;
+    }
+    const handle = resolveTex(materialTextureRef(pv[field]), 'TextureAsset');
+    if (handle !== undefined) out.set(field, handle);
+  }
+  return out;
+}
+
+const ENGINE_INJECTED_TEXTURE_FIELDS = new Set(['emissiveTexture', 'occlusionTexture']);
+
+function isEngineInjectedTextureField(shaderId: string | undefined, fieldName: string): boolean {
+  return isStandardPbrMaterialShader(shaderId) && ENGINE_INJECTED_TEXTURE_FIELDS.has(fieldName);
+}
+
+function materialParametersToParamSchema(
+  parameters: readonly MaterialParameter[],
+  shaderId: string | undefined,
+): readonly ParamSchemaEntry[] {
+  const engineInjectedTextureFields = isStandardPbrMaterialShader(shaderId)
+    ? ENGINE_INJECTED_TEXTURE_FIELDS
+    : undefined;
+  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 (engineInjectedTextureFields?.has(parameter.name) === true) return [];
+      return [{ name: parameter.name, type: 'texture2d' }];
+    }
+    return [
+      {
+        name: parameter.name,
+        type: parameter.type,
+        ...(parameter.colorSpace === undefined ? {} : { colorSpace: parameter.colorSpace }),
+      },
+    ];
+  });
+}
+
+/**
+ * Resolve color semantics from the material asset first and the shader schema
+ * for fields the asset does not redeclare. Generated and historical pack
+ * materials commonly omit `parameters`, while the shader registry still owns
+ * the complete parameter contract.
+ */
+function materialColorParameterSchema(
+  parameters: readonly MaterialParameter[],
+  shaderId: string | undefined,
+  assets: AssetRegistry,
+): readonly MaterialColorParameterSchema[] {
+  if (shaderId === undefined) return parameters;
+  const shader = assets.shaderRegistry.findMaterialArtifact(shaderId);
+  if (!shader.ok) return parameters;
+
+  const byName = new Map<string, MaterialColorParameterSchema>(
+    shader.value.paramSchema.map((parameter) => [parameter.name, parameter]),
+  );
+  for (const parameter of parameters) byName.set(parameter.name, parameter);
+  return [...byName.values()];
+}
+
+const MATERIAL_PARENT_CHAIN_LIMIT = 128;
+
+function isDeepFrozen(value: unknown, seen = new Set<object>()): boolean {
+  if (typeof value !== 'object' || value === null) return true;
+  if (seen.has(value)) return true;
+  if (!Object.isFrozen(value)) return false;
+  seen.add(value);
+  for (const child of Object.values(value)) {
+    if (!isDeepFrozen(child, seen)) return false;
+  }
+  return true;
+}
+
+/**
+ * Capture the object identities that make a resolved material stable. The
+ * renderer owns this cache, but the AssetRegistry owns parent GUID lookup, so
+ * validation must walk the same chain on every cross-frame read. A malformed
+ * or cyclic chain is deliberately not cacheable.
+ */
+function captureMaterialCacheChain(
+  root: MaterialAsset,
+  assets: AssetRegistry,
+): readonly MaterialCacheChainIdentity[] | undefined {
+  const chain: MaterialCacheChainIdentity[] = [];
+  const visitedParentGuids = new Set<string>();
+  let current = root;
+  for (let depth = 0; depth < MATERIAL_PARENT_CHAIN_LIMIT; depth += 1) {
+    const parentRef = current.parent;
+    const parentGuid = parentRef === undefined ? undefined : materialGuidText(parentRef);
+    chain.push({ asset: current, parentGuid });
+    if (parentGuid === undefined) return chain;
+    if (parentRef === undefined) return undefined;
+    if (visitedParentGuids.has(parentGuid)) return undefined;
+    visitedParentGuids.add(parentGuid);
+    const parent = assets.lookup<Asset>(parentRef);
+    if (parent?.kind !== 'material') return undefined;
+    current = parent;
+  }
+  return undefined;
+}
+
+function readPersistentMaterialSnapshot(
+  cache: MaterialSnapshotCache | undefined,
+  handleRaw: number,
+  assets: AssetRegistry,
+): MaterialSnapshotCacheEntry | undefined {
+  const entry = cache?.get(handleRaw);
+  if (entry === undefined) return undefined;
+  if (
+    entry.crossFrameSafe &&
+    entry.chain !== undefined &&
+    entry.catalogEpoch === assets.catalogEpoch
+  )
+    return entry;
+  // The snapshot contains resolved texture and sampler handles as well as the
+  // material parent chain. Any registry mutation can replace one of those
+  // referenced payloads, so an epoch mismatch is a hard miss even when the
+  // material objects themselves are unchanged.
+  cache?.delete(handleRaw);
+  return undefined;
+}
+
+/**
+ * Fast path for a cache entry whose chain was already validated at the
+ * current registry epoch. The full reader needs the root asset only when an
+ * epoch changed; asking ECS to resolve that root before checking the epoch
+ * defeats the cross-frame cache on the ordinary stable frame.
+ */
+function readStablePersistentMaterialSnapshot(
+  cache: MaterialSnapshotCache | undefined,
+  handleRaw: number,
+  assets: AssetRegistry,
+): MaterialSnapshotCacheEntry | undefined {
+  const entry = cache?.get(handleRaw);
+  return entry?.crossFrameSafe === true &&
+    entry.chain !== undefined &&
+    entry.catalogEpoch === assets.catalogEpoch
+    ? entry
+    : undefined;
+}
+
+function storeMaterialSnapshot(
+  cache: MaterialSnapshotCache,
+  handleRaw: number,
+  snapshot: MaterialSnapshot,
+  passes: readonly MaterialPass[],
+  root: MaterialAsset,
+  assets: AssetRegistry,
+): MaterialSnapshotCacheEntry {
+  const chain = captureMaterialCacheChain(root, assets);
+  const entry: MaterialSnapshotCacheEntry = {
+    snapshot,
+    passes,
+    crossFrameSafe: chain?.every(({ asset }) => isDeepFrozen(asset)) === true,
+    ...(chain === undefined ? {} : { chain }),
+    ...(chain === undefined ? {} : { catalogEpoch: assets.catalogEpoch }),
+  };
+  cache.set(handleRaw, entry);
+  return entry;
+}
+
+/**
+ * feat-20260608 M5 amend / w11-a: resolve a single MaterialAsset handle into
+ * a per-submesh MaterialSnapshot. Used by the extractFrame archetype loop to
+ * build `RenderableSnapshot.materials[]` for indices >= 1 (the entity-level
+ * snapshot at index 0 is built inline because it also drives multi-pass
+ * DispatchEntry creation + sprite-region overrides; per-submesh secondary
+ * materials are non-sprite + single-pass-equivalent for the record stage's
+ * UBO upload, so this helper produces a plain MaterialSnapshot only).
+ *
+ * Returns `defaultMaterialSnapshot()` (mid-grey unlit) for handle=0 (case-B
+ * sentinel, mirroring the inline path) and on each unresolved / non-material
+ * asset (so a partially-mis-registered multi-material entity still renders
+ * the resolvable submeshes; the count-mismatch validator already filtered
+ * the count-disagreement case earlier).
+ */
+export function resolveMaterialSnapshot(
+  handleRaw: number,
+  world: World,
+  assetsRef: AssetRegistry,
+  materialSnapshotCache?: MaterialSnapshotCache,
+  persistentMaterialSnapshotCache?: MaterialSnapshotCache,
+): MaterialSnapshot {
+  if (handleRaw === 0) return defaultMaterialSnapshot(handleRaw);
+  const cached = materialSnapshotCache?.get(handleRaw);
+  if (cached !== undefined) return cached.snapshot;
+  const stablePersistentCached = readStablePersistentMaterialSnapshot(
+    persistentMaterialSnapshotCache,
+    handleRaw,
+    assetsRef,
+  );
+  if (stablePersistentCached !== undefined) {
+    materialSnapshotCache?.set(handleRaw, stablePersistentCached);
+    return stablePersistentCached.snapshot;
+  }
+  const tagged = toShared<'MaterialAsset'>(handleRaw);
+  const res = resolveAssetHandle(world, tagged);
+  if (!res.ok) return defaultMaterialSnapshot(handleRaw);
+  const asset = res.value;
+  if (asset.kind !== 'material') return defaultMaterialSnapshot(handleRaw);
+  const persistentCached = readPersistentMaterialSnapshot(
+    persistentMaterialSnapshotCache,
+    handleRaw,
+    assetsRef,
+  );
+  if (persistentCached !== undefined) {
+    materialSnapshotCache?.set(handleRaw, persistentCached);
+    return persistentCached.snapshot;
+  }
+  const resolvedResult = walkMaterialPassesOverSharedRefs(world, tagged, assetsRef);
+  if (!resolvedResult.ok) return defaultMaterialSnapshot(handleRaw);
+  const resolved = resolvedResult.value;
+  const allPasses = resolved.passes;
+  const firstPassShader =
+    allPasses.length > 0
+      ? runtimeMaterialShaderId(allPasses[0]?.program.module, allPasses[0]?.name)
+      : undefined;
+  const pv = materialValuesToLinearRuntime(
+    resolved.values,
+    materialColorParameterSchema(resolved.parameters ?? [], firstPassShader, assetsRef),
+    resolved.colorSpace,
+  ) as Readonly<Record<string, unknown>>;
+  const baseColorPv = pv.baseColor as readonly number[] | undefined;
+  const baseColor = vec3.create(
+    baseColorPv?.[0] ?? 1,
+    baseColorPv?.[1] ?? 1,
+    baseColorPv?.[2] ?? 1,
+  );
+  const metallicPv = typeof pv.metallic === 'number' ? pv.metallic : 0;
+  const roughnessPv = typeof pv.roughness === 'number' ? pv.roughness : 0.5;
+  const clearcoatPv = typeof pv.clearcoat === 'number' ? pv.clearcoat : 0;
+  const clearcoatRoughnessPv =
+    typeof pv.clearcoatRoughness === 'number' ? pv.clearcoatRoughness : 0.5;
+  const specularTintPv = pv.specularTint as readonly number[] | undefined;
+  const normalScalePv = materialNormalScale(pv);
+
+  const paramSnap: Record<string, number | number[] | string> = {};
+  for (const [k, v] of Object.entries(pv)) {
+    if (typeof v === 'number') paramSnap[k] = v;
+    else if (typeof v === 'string') paramSnap[k] = v;
+    else if (Array.isArray(v) && v.every((x) => typeof x === 'number')) {
+      paramSnap[k] = v as number[];
+    }
+  }
+  const materialParamSchema = materialParametersToParamSchema(
+    resolved.parameters ?? [],
+    firstPassShader,
+  );
+  // feat-20260614 M8 (D-19): texture / sampler values are embedded GUIDs
+  // (dash-form strings) after loadByGuid. Resolve each to a user-tier column
+  // handle by looking up the catalogued payload and minting via
+  // world.allocSharedRef; a numeric value (already a column handle from a
+  // directly-minted material) passes through unchanged.
+  const resolveTexLike = <B extends string>(
+    value: unknown,
+    brand: B,
+  ): Handle<B, 'shared'> | undefined => {
+    if (typeof value === 'number') return toShared<B>(value);
+    if (typeof value === 'string') {
+      // M4: intern the GUID -> column-handle resolution so each unique
+      // (world, guid, brand) mints exactly ONE stable handle reused across
+      // frames (stops the per-frame slot churn that defeated the GPU
+      // residency cache). feat-20260619 M2 / w8: TextureAsset brand wires
+      // onLastRelease -> gpuStore.evictTexture; other brands (SamplerAsset)
+      // bypass (releaseUnreferenced-fallback lifecycle).
+      return internSharedRefFromGuid(world, assetsRef, value, brand);
+    }
+    return undefined;
+  };
+  // feat-20260621-learn-render-5-5-parallax M2 / w7 (D-3): iterate the
+  // shader's derive(paramSchema).textureFieldNames SSOT instead of a hardcoded
+  // user-region field list, so an Nth texture (e.g. parallax heightTexture)
+  // resolves through the same path. emissive/occlusion are engine-injection
+  // (lightmap) textures, NOT in textureFieldNames, so they keep named reads.
+  const videoTextureFields = new Map<string, Handle<'VideoAsset', 'shared'>>();
+  const textureHandles = collectUserRegionTextureHandles(
+    pv,
+    firstPassShader,
+    materialParamSchema.length > 0 ? materialParamSchema : undefined,
+    assetsRef,
+    world,
+    resolveTexLike,
+    videoTextureFields,
+  );
+  const samplerHandles = collectMaterialTextureSamplers(pv, (value) =>
+    resolveTexLike(materialTextureRef(value), 'SamplerAsset'),
+  );
+  const emissiveTextureHandle = resolveTexLike(
+    materialTextureRef(pv.emissiveTexture),
+    'TextureAsset',
+  );
+  const occlusionTextureHandle = resolveTexLike(
+    materialTextureRef(pv.occlusionTexture),
+    'TextureAsset',
+  );
+  const textureCoordinates = collectMaterialTextureCoordinates(pv);
+  // Named user-region fields are derived from the map (sprite + legacy reads).
+  const baseColorTextureHandle = textureHandles.get('baseColorTexture');
+  const metallicRoughnessTextureHandle = textureHandles.get('metallicRoughnessTexture');
+  const normalTextureHandle = textureHandles.get('normalTexture');
+  const emissivePv = pv.emissive as readonly number[] | undefined;
+  const snapshot: MaterialSnapshot = {
+    baseColor,
+    metallic: metallicPv,
+    roughness: roughnessPv,
+    clearcoat: clearcoatPv,
+    clearcoatRoughness: clearcoatRoughnessPv,
+    ...(specularTintPv !== undefined && {
+      specularTint: [
+        specularTintPv[0] ?? 1,
+        specularTintPv[1] ?? 1,
+        specularTintPv[2] ?? 1,
+      ] as readonly [number, number, number],
+    }),
+    normalScale: normalScalePv,
+    materialShaderId: firstPassShader,
+    materialHandle: handleRaw,
+    renderState: pipelineRenderState(allPasses[0]?.renderState),
+    paramSnapshot: paramSnap,
+    ...(materialParamSchema.length > 0 && { materialParamSchema }),
+    ...(textureCoordinates.size > 0 && { textureCoordinates }),
+    ...(textureHandles.size > 0 && { textureHandles }),
+    ...(videoTextureFields.size > 0 && { videoTextureFields }),
+    ...(samplerHandles.size > 0 && { samplerHandles }),
+    ...(baseColorTextureHandle !== undefined && { baseColorTexture: baseColorTextureHandle }),
+    ...(metallicRoughnessTextureHandle !== undefined && {
+      metallicRoughnessTexture: metallicRoughnessTextureHandle,
+    }),
+    ...(normalTextureHandle !== undefined && { normalTexture: normalTextureHandle }),
+    ...(emissivePv !== undefined && {
+      emissive: [emissivePv[0] ?? 0, emissivePv[1] ?? 0, emissivePv[2] ?? 0] as readonly [
+        number,
+        number,
+        number,
+      ],
+    }),
+    ...(typeof pv.emissiveIntensity === 'number' && { emissiveIntensity: pv.emissiveIntensity }),
+    ...(emissiveTextureHandle !== undefined && { emissiveTexture: emissiveTextureHandle }),
+    ...(occlusionTextureHandle !== undefined && { occlusionTexture: occlusionTextureHandle }),
+    ...(typeof pv.occlusionStrength === 'number' && { occlusionStrength: pv.occlusionStrength }),
+    // feat-city-glb Bug 5 (per-submesh transparency): derive `transparent`
+    // from the first pass's `renderState.blend` presence, identical to the
+    // entity-level snapshot builder (extractFrame archetype loop). Without
+    // this, per-submesh materials (materials[i>=1], e.g. a glTF BLEND decal
+    // submesh on a multi-material mesh) never carry the transparent flag, so
+    // the record stage's LDR split + blend routing treats them as opaque and
+    // their alpha=0 texels composite as black.
+    transparent: allPasses[0]?.renderState?.blend !== undefined,
+  };
+  const stored =
+    materialSnapshotCache !== undefined
+      ? storeMaterialSnapshot(
+          materialSnapshotCache,
+          handleRaw,
+          snapshot,
+          allPasses,
+          asset,
+          assetsRef,
+        )
+      : undefined;
+  const cacheEntry =
+    stored ??
+    (persistentMaterialSnapshotCache !== undefined
+      ? storeMaterialSnapshot(
+          persistentMaterialSnapshotCache,
+          handleRaw,
+          snapshot,
+          allPasses,
+          asset,
+          assetsRef,
+        )
+      : undefined);
+  if (cacheEntry?.crossFrameSafe === true) {
+    persistentMaterialSnapshotCache?.set(handleRaw, cacheEntry);
+  }
+  return snapshot;
+}
+
+/**
+ * feat-20260612-skin-palette-per-frame-upload M2 / m2-6: narrow per-frame
+ * pipeline surface consumed by `extractFrame`. Today only `skinPaletteAllocator`
+ * crosses the seam (the allocator owns the per-frame palette buffer + cursor;
+ * extract calls `resetForFrame` at frame entry then `allocateSlice` +
+ * `writeJointPalette` per skinned entity). Kept narrow on purpose — extract
+ * does NOT see the rest of `PipelineState` to avoid a circular import via
+ * `render-system.ts`.
+ */
+export interface ExtractPipelineSurface {
+  readonly skinPaletteAllocator: SkinPaletteAllocator | null;
+}
+
+/**
+ * PSSM (Parallel-Split Shadow Maps) split plane computation.
+ *
+ * Formula (plan-strategy D-8, research F1):
+ *   C_i = λ·n·(f/n)^(i/m) + (1-λ)·(n + i/m·(f-n))
+ *   where i = 1..m, n = near, f = far, m = cascadeCount
+ *
+ * The coverage range is [camera near, DirectionalLight.shadowDistance] — the
+ * near end derives from the active camera, the far end is the shadowDistance
+ * knob. Returns strictly monotonic view-space z depths (positive).
+ *
+ * When `far <= near + ε` (ε=1e-6), throws ShadowInvalidConfigError
+ * (charter P3 explicit failure — research F2 guarantees formula stability
+ * but degenerate configuration must be surfaced to the caller).
+ *
+ * @param nearPlane - near of the shadow casting range (from the camera near)
+ * @param farPlane - far of the shadow casting range (DirectionalLight.shadowDistance)
+ * @param cascadeCount - number of cascades (1..4)
+ * @param splitLambda - PSSM split weight (0 = pure uniform, 1 = pure log)
+ * @returns Array of m split depths (view-space z); length = cascadeCount,
+ *   guaranteed strictly monotonic, last element = far.
+ *
+ * @internal exported for w6/w7 testing only; production callers route through
+ *   extractFrame which validates cascadeCount/splitLambda via component schema.
+ */
+/**
+ * Compute the 8 world-space corner points of a camera frustum slice.
+ *
+ * Uses mat4.unproject to map NDC cube corners back to world space.
+ * The slice is defined by view-space nearZ and farZ depths.
+ *
+ * For a WebGPU perspective matrix, ndcZ(viewZ) = camFar * (viewZ - camNear) /
+ * (viewZ * (camFar - camNear)). We compute the ndcZ for each slice boundary
+ * and unproject directly.
+ *
+ * @param vp - camera view-projection matrix (column-major 16 floats)
+ * @param camNear - camera near plane (used to derive NDC mapping)
+ * @param camFar - camera far plane (used to derive NDC mapping)
+ * @param nearZ - near depth of the frustum slice (view-space, positive)
+ * @param farZ - far depth of the frustum slice (view-space, positive)
+ * @returns Array of 8 Vec3 world-space corner positions.
+ */
+function computeFrustumCorners(
+  vp: Mat4,
+  camNear: number,
+  camFar: number,
+  nearZ: number,
+  farZ: number,
+  projection: 'perspective' | 'orthographic',
+): Vec3[] {
+  const invVP = mat4.create();
+  mat4.invert(invVP, vp);
+  const corners: Vec3[] = [];
+
+  // NDC z mapping is projection-dependent (WebGPU clip-space z in [0,1]):
+  //   perspective:  ndc(z) = camFar * (z - camNear) / (z * (camFar - camNear))
+  //   orthographic: ndc(z) = (z - camNear) / (camFar - camNear)
+  // feat-20260613-csm M6 / w22: orthographic cameras silently produced
+  // garbage NDC z (perspective formula divides by viewZ, but ortho NDC is
+  // linear), which mapped the cascade slab back to a degenerate world-space
+  // corner set and the AABB-fit collapsed to near zero -- shadow_caster
+  // wrote its triangles outside the [-1,1] clip volume so the depth
+  // attachment stayed at clear=1.0 (root cause for shadow-m2 / shadow-m3 /
+  // shadow-opt-out dawn red surfaced after w20's host-side ortho fix).
+  const span = camFar - camNear;
+  const ndcNear =
+    projection === 'orthographic'
+      ? (nearZ - camNear) / span
+      : (camFar * (nearZ - camNear)) / (nearZ * span);
+  const ndcFar =
+    projection === 'orthographic'
+      ? (farZ - camNear) / span
+      : (camFar * (farZ - camNear)) / (farZ * span);
+
+  const signs = [-1, 1];
+  for (const sx of signs) {
+    for (const sy of signs) {
+      corners.push(unprojectNDC(invVP, sx, sy, ndcNear));
+    }
+  }
+  for (const sx of signs) {
+    for (const sy of signs) {
+      corners.push(unprojectNDC(invVP, sx, sy, ndcFar));
+    }
+  }
+
+  return corners;
+}
+
+/**
+ * Unproject a single NDC point to world space.
+ */
+function unprojectNDC(invVP: Mat4, ndcX: number, ndcY: number, ndcZ: number): Vec3 {
+  const ndc = vec3.create(ndcX, ndcY, ndcZ);
+  const ws = vec3.create();
+  mat4.unproject(ws, ndc, invVP);
+  return ws;
+}
+
+export function pssmSplit(
+  nearPlane: number,
+  farPlane: number,
+  cascadeCount: number,
+  splitLambda: number,
+): Float32Array {
+  const EPS = 1e-6;
+  if (farPlane <= nearPlane + EPS) {
+    throw new ShadowInvalidConfigError('shadowDistance', farPlane, nearPlane + EPS);
+  }
+
+  const result = new Float32Array(cascadeCount);
+  const m = cascadeCount;
+  const n = nearPlane;
+  const f = farPlane;
+  const ratio = f / n;
+
+  for (let i = 1; i <= m; i++) {
+    const t = i / m;
+    const logPart = n * ratio ** t;
+    const uniformPart = n + t * (f - n);
+    result[i - 1] = splitLambda * logPart + (1 - splitLambda) * uniformPart;
+  }
+
+  return result;
+}
+
+// feat-20260612-point-light-shadows-urp-hdrp M1 / T-M1-5 (plan-strategy §D-3,
+// requirements §5.3): 6-face view-proj matrix table for one omnidirectional
+// shadow caster.
+//
+// Face order matches WebGPU cube layer convention (also LearnOpenGL 5.3.2):
+//   0 (+X) | look=(+1, 0, 0) | up=(0, -1, 0)
+//   1 (-X) | look=(-1, 0, 0) | up=(0, -1, 0)
+//   2 (+Y) | look=(0, +1, 0) | up=(0,  0, +1)
+//   3 (-Y) | look=(0, -1, 0) | up=(0,  0, -1)
+//   4 (+Z) | look=(0, 0, +1) | up=(0, -1, 0)
+//   5 (-Z) | look=(0, 0, -1) | up=(0, -1, 0)
+//
+// Projection: WebGPU [0, 1] NDC perspective (mat4.perspective short name).
+// fov=90deg, aspect=1, near/far from PointLightShadow component.
+const POINT_SHADOW_FACE_LOOK: readonly Vec3[] = [
+  vec3.create(1, 0, 0),
+  vec3.create(-1, 0, 0),
+  vec3.create(0, 1, 0),
+  vec3.create(0, -1, 0),
+  vec3.create(0, 0, 1),
+  vec3.create(0, 0, -1),
+];
+const POINT_SHADOW_FACE_UP: readonly Vec3[] = [
+  vec3.create(0, -1, 0),
+  vec3.create(0, -1, 0),
+  vec3.create(0, 0, 1),
+  vec3.create(0, 0, -1),
+  vec3.create(0, -1, 0),
+  vec3.create(0, -1, 0),
+];
+
+/**
+ * Build 6 face view-proj matrices for an omnidirectional shadow caster
+ * (point-light cube map). Returns 6 mat4 (column-major 16-float each) in face
+ * order [+X, -X, +Y, -Y, +Z, -Z] matching WebGPU cube layer convention.
+ *
+ * Each matrix is `proj * view` where:
+ *   - `view = lookAt(lightPos, lightPos + faceLook[i], faceUp[i])`
+ *   - `proj = perspective(PI/2, 1, near, far)` (WebGPU [0, 1] NDC short name)
+ *
+ * The returned `Mat4[]` length is always exactly 6. Caller can flatten into a
+ * 96-float (6 mat4) Float32Array for UBO upload (T-M1-7).
+ *
+ * @param lightPos world-space position of the point light (from companion Transform)
+ * @param near near plane distance (PointLightShadow.nearPlane)
+ * @param far  far plane distance  (PointLightShadow.farPlane)
+ */
+export function buildPointShadowMatrices(lightPos: Vec3, near: number, far: number): Mat4[] {
+  const fovY = Math.PI / 2; // 90 deg
+  const aspect = 1;
+  const proj = mat4.create();
+  mat4.perspective(proj, fovY, aspect, near, far);
+
+  const out: Mat4[] = [];
+  for (let i = 0; i < 6; i++) {
+    // biome-ignore lint/style/noNonNullAssertion: i in [0..6) and arrays are length-6 const
+    const look = POINT_SHADOW_FACE_LOOK[i]!;
+    // biome-ignore lint/style/noNonNullAssertion: i in [0..6) and arrays are length-6 const
+    const up = POINT_SHADOW_FACE_UP[i]!;
+    const target = vec3.create(
+      (lightPos[0] ?? 0) + (look[0] ?? 0),
+      (lightPos[1] ?? 0) + (look[1] ?? 0),
+      (lightPos[2] ?? 0) + (look[2] ?? 0),
+    );
+    const view = mat4.create();
+    mat4.lookAt(view, lightPos, target, up);
+    const vp = mat4.create();
+    mat4.multiply(vp, proj, view);
+    out.push(vp);
+  }
+  return out;
+}
+
+/**
+ * bug-20260710-editor-cross-world-shadow: the camera-frustum subset of
+ * {@link CameraSnapshot} that the directional-CSM matrix builder consumes.
+ * Extracted so the builder can run both inside {@link extractFrame} (single
+ * world) AND at the {@link extractFrames} merge layer, where the camera and the
+ * directional light may originate in DIFFERENT worlds (the editor
+ * editorWorld/sceneWorld super-composite). A cameraless world produces zero
+ * lightViewProj matrices, so the merge layer MUST recompute using the surfaced
+ * camera — see {@link computeDirectionalCsm}.
+ */
+export interface CsmCameraData {
+  readonly world: Float32Array;
+  readonly fov: number;
+  readonly aspect: number;
+  readonly near: number;
+  readonly far: number;
+  readonly projection: 'perspective' | 'orthographic';
+  readonly orthoLeft: number;
+  readonly orthoRight: number;
+  readonly orthoBottom: number;
+  readonly orthoTop: number;
+}
+
+/**
+ * bug-20260710-editor-cross-world-shadow: the raw directional-shadow config a
+ * DirectionalLight carries, threaded onto {@link ExtractedLights} so the merge
+ * layer can recompute CSM matrices against the surfaced camera. Distinct from
+ * the *computed* outputs (lightViewProj / splitPlanes) also on ExtractedLights.
+ */
+export interface DirectionalCsmConfig {
+  readonly cascadeCount: number;
+  readonly splitLambda: number;
+  readonly cascadeBlend: number;
+  readonly mapSize: number;
+  readonly shadowDistance: number;
+}
+
+/**
+ * bug-20260710-editor-cross-world-shadow: computed directional-CSM output —
+ * the per-cascade light-view-projection matrices plus the derived cascade
+ * metadata. Returned by {@link computeDirectionalCsm}; `undefined` when the
+ * config or camera is missing (caller leaves the fields undefined).
+ */
+export interface DirectionalCsmResult {
+  readonly lightViewProj: Float32Array[];
+  readonly splitPlanes: Float32Array;
+  readonly cascadeCount: number;
+  readonly cascadeBlend: number;
+  readonly shadowMapSize: number;
+}
+
+/**
+ * bug-20260710-editor-cross-world-shadow: pure directional-CSM matrix builder,
+ * extracted verbatim from the former inline block in {@link extractFrame} (the
+ * PSSM split + per-cascade frustum-slice AABB fit + orthographic light
+ * projection). It is now a free function so BOTH the per-world extract and the
+ * cross-world merge layer can call it — the merge layer is the only place that
+ * pairs the first-hit directional light of one world with the surfaced camera
+ * of another (editor super-composite). Returns `null` when there is no camera
+ * to fit against (a cameraless world's directional light yields no matrices —
+ * the caller leaves lightViewProj undefined rather than emitting zero matrices
+ * that the WGSL reader would sample as NaN → "fully lit").
+ *
+ * Byte-identical to the prior inline computation for the single-world case
+ * (same PSSM lambda, same toward-light Z reach RC-2 fix, same clip-space
+ * matrix / tile-placement-in-shader split).
+ */
+export function computeDirectionalCsm(
+  direction: Vec3,
+  config: DirectionalCsmConfig,
+  cameraData: CsmCameraData | undefined,
+): DirectionalCsmResult | null {
+  const cascadeCount = Math.round(config.cascadeCount);
+  // Coverage range: near from the active camera near (no separate near knob);
+  // far is the component's shadowDistance. Fallback near (0.1) only when no
+  // camera exists — but matrices are gated on cameraData below anyway.
+  const sNear = cameraData?.near ?? 0.1;
+  const sFar = config.shadowDistance;
+
+  // 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);
+  const lightView = mat4.create();
+  mat4.lookAt(lightView, vec3.create(0, 0, 0), lightTarget, vec3.create(0, 1, 0));
+
+  // Camera view-projection for frustum-corner computation. Without a camera the
+  // frustum cannot be fit — bail so the caller emits no matrices (undefined),
+  // NOT zero matrices (which read as NaN in the shadow shader → no shadow).
+  if (cameraData === undefined) return null;
+  const camProj = mat4.create();
+  if (cameraData.projection === 'orthographic') {
+    mat4.orthographic(
+      camProj,
+      cameraData.orthoLeft,
+      cameraData.orthoRight,
+      cameraData.orthoBottom,
+      cameraData.orthoTop,
+      cameraData.near,
+      cameraData.far,
+    );
+  } else {
+    mat4.perspective(camProj, cameraData.fov, cameraData.aspect, cameraData.near, cameraData.far);
+  }
+  const camView = mat4.create();
+  mat4.invert(camView, cameraData.world);
+  const cameraVP = mat4.create();
+  mat4.multiply(cameraVP, camProj, camView);
+
+  const resultLightViewProjs: Float32Array[] = [];
+
+  // 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
+  // shadow frustum (sNear..sFar) so casters between the light and a slice are
+  // admitted; X/Y stays per-cascade tight. Larger light-space z == closer to
+  // the light (lookAt forward = eye-target), so the full-frustum max-z is the
+  // toward-light reach used as -maxZ (the ortho near plane) per cascade.
+  let lightSpaceMaxZFull = -Infinity;
+  const fullCorners = computeFrustumCorners(
+    cameraVP,
+    cameraData.near,
+    cameraData.far,
+    sNear,
+    sFar,
+    cameraData.projection,
+  );
+  for (const ws of fullCorners) {
+    const ls = vec3.create();
+    mat4.transformVec3(ls, lightView, ws);
+    if ((ls[2] ?? 0) > lightSpaceMaxZFull) lightSpaceMaxZFull = ls[2] ?? 0;
+  }
+
+  // Pre-allocate 4-cascade array; fill in the effective cascades.
+  for (let cIdx = 0; cIdx < 4; cIdx++) {
+    if (cIdx >= cascadeCount) {
+      resultLightViewProjs.push(new Float32Array(16));
+      continue;
+    }
+    const cascadeNear = cIdx === 0 ? sNear : (splits[cIdx - 1] ?? sFar);
+    const cascadeFar = splits[cIdx] ?? sFar;
+    const corners = computeFrustumCorners(
+      cameraVP,
+      cameraData.near,
+      cameraData.far,
+      cascadeNear,
+      cascadeFar,
+      cameraData.projection,
+    );
+    const lightMVP = mat4.clone(lightView);
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minY = Infinity;
+    let maxY = -Infinity;
+    let minZ = Infinity;
+    let maxZ = -Infinity;
+    for (const ws of corners) {
+      const ls = vec3.create();
+      mat4.transformVec3(ls, lightMVP, ws);
+      if ((ls[0] ?? 0) < minX) minX = ls[0] ?? 0;
+      if ((ls[0] ?? 0) > maxX) maxX = ls[0] ?? 0;
+      if ((ls[1] ?? 0) < minY) minY = ls[1] ?? 0;
+      if ((ls[1] ?? 0) > maxY) maxY = ls[1] ?? 0;
+      if ((ls[2] ?? 0) < minZ) minZ = ls[2] ?? 0;
+      if ((ls[2] ?? 0) > maxZ) maxZ = ls[2] ?? 0;
+    }
+    // Orthographic projection from light-space AABB. RC-2: whole-frustum
+    // toward-light extreme for the near bound; per-cascade far (minZ) + X/Y.
+    const nearZ = Math.max(maxZ, lightSpaceMaxZFull);
+    const orthoProj = mat4.create();
+    mat4.orthographic(orthoProj, minX, maxX, minY, maxY, -nearZ, -minZ);
+    // 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;
+    resultLightViewProjs.push(new Float32Array(mat4.multiply(mat4.create(), orthoProj, lightView)));
+  }
+
+  return {
+    lightViewProj: resultLightViewProjs,
+    splitPlanes: paddedSplits,
+    cascadeCount,
+    cascadeBlend: config.cascadeBlend,
+    shadowMapSize: config.mapSize,
+  };
+}
+
+/**
+ * feat-20260709-editor-world-partition M1 / w4 (AC-08, plan-strategy §2 D-3):
+ * the owner index that previously served BOTH cameras and singleton render
+ * resources (skylight / skybox / postProcessParams) is split into two
+ * independent indices. `cameraOwner` selects the world whose cameras are
+ * surfaced; `resourceOwner` selects the world whose singleton resources are
+ * surfaced. A single number is accepted as the backward-compatible legacy form
+ * where `cameraOwner === resourceOwner === owner` (single-world callers +
+ * frame-loop stay byte-identical; the hard `{ owner }` cutover lands in M2).
+ */
+export interface ExtractFramesOwner {
+  readonly cameraOwner: number;
+  readonly resourceOwner: number;
+}
+
+export interface PreparedExtractContext {
+  readonly assets: AssetRegistry | null | undefined;
+  readonly pipelineState: ExtractPipelineSurface | null | undefined;
+  readonly materialSnapshotCache: MaterialSnapshotCache | undefined;
+  readonly cull: 'self' | 'none' | 'external';
+  readonly cullCameras: readonly CameraSnapshot[] | undefined;
+  readonly hierarchy: SceneHierarchySnapshot;
+  readonly visibility: VisibilitySnapshot;
+}
+
+export function extractCameraSnapshots(world: World): CameraSnapshot[] {
+  const worldInternal = createWorldInternalView(world);
+  const cameras: CameraSnapshot[] = [];
+  const cameraEntities: number[] = [];
+  const cameraQuery = world.query({ read: [Camera], with: [Transform] }).unwrap();
+  for (const row of cameraQuery) {
+    const cam = row.get(Camera);
+    const entity = row.entity;
+    const view = worldInternal._getArrayView(entity, Transform, 'world');
+    if (view === undefined) continue;
+    const worldMat = new Float32Array(view);
+    cameras.push({
+      entityKey: entity as number,
+      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,
+      ],
+    });
+    cameraEntities.push(entity as number);
+  }
+  const activeCameraIndex = selectActiveCameraIndex(cameraEntities, getActiveCamera(world)?.entity);
+  if (activeCameraIndex < 0) return cameras;
+  const selected = cameras[activeCameraIndex];
+  return selected === undefined ? cameras : [selected];
+}
+
+function tonemapParams(camera: CameraSnapshot): Uint8Array {
+  const bytes = new ArrayBuffer(16);
+  const floats = new Float32Array(bytes);
+  const integers = new Uint32Array(bytes);
+  floats[0] = camera.exposure;
+  floats[1] = camera.whitePoint;
+  integers[2] = tonemapToU32(camera.tonemap);
+  return new Uint8Array(bytes);
+}
+
+export function prepareExtractContext(
+  world: World,
+  options: {
+    readonly assets?: AssetRegistry | null;
+    readonly pipelineState?: ExtractPipelineSurface | null;
+    readonly materialSnapshotCache?: MaterialSnapshotCache;
+    readonly cull?: 'self' | 'none' | 'external';
+    readonly cullCameras?: readonly CameraSnapshot[];
+  } = {},
+): PreparedExtractContext {
+  const hierarchy = projectHierarchy(world);
+  return {
+    assets: options.assets,
+    pipelineState: options.pipelineState,
+    materialSnapshotCache: options.materialSnapshotCache,
+    cull: options.cull ?? 'self',
+    cullCameras: options.cullCameras,
+    hierarchy,
+    visibility: resolveVisibility(world, hierarchy),
+  };
+}
+
+export function extractFrames(
+  worlds: readonly World[],
+  owner: number | ExtractFramesOwner,
+  assets?: AssetRegistry | null,
+  pipelineState?: ExtractPipelineSurface | null,
+  materialSnapshotCachesByWorld?: MaterialSnapshotCachesByWorld,
+  options: { readonly cull?: 'normal' | 'none' } = {},
+): ExtractedFrame {
+  // w4: normalize the owner argument. A bare number is the legacy single-owner
+  // form (cameraOwner === resourceOwner); an object carries the two split
+  // indices. When they coincide the code path is byte-identical to the pre-w4
+  // single-owner behaviour (w1 contract combination 2).
+  const cameraOwner = typeof owner === 'number' ? owner : owner.cameraOwner;
+  const resourceOwner = typeof owner === 'number' ? owner : owner.resourceOwner;
+
+  // ── D-2: frame-level side effects live here ────────────────────────────
+  //
+  // resetForFrame is called exactly once per frame, at the extractFrames
+  // entry. The skinPaletteAllocator cursor is reset before each per-world
+  // extract runs, so sequential per-world allocation yields non-overlapping
+  // palette slices (AC-08).
+  const skinPaletteAllocator = pipelineState?.skinPaletteAllocator ?? null;
+  if (skinPaletteAllocator !== null) {
+    skinPaletteAllocator.resetForFrame();
+  }
+
+  const failedWorlds = new Set<World>();
+  // ── D-2: per-world extract with error isolation ────────────────────────
+  //
+  // Each world runs extractFrame over the final state published by
+  // world.update(). Failure in one world is caught, routed to that world's
+  // _routeError (systemName carries worldId for source identification),
+  // and the world's contribution is skipped (AC-09 graceful degradation).
+
+  // The camera-owner frame must be extracted first: non-owner worlds do not
+  // carry the surfaced camera, but their renderables still need to be tested
+  // against that camera's frustum. Frames are placed back into worlds[] order
+  // before merge so queue / directional-light / worldId semantics stay stable.
+  const succeededFrames: ExtractedFrame[] = [];
+  const succeededIndices: number[] = [];
+
+  const extractionOrder = Array.from({ length: worlds.length }, (_, wi) => wi).sort((a, b) => {
+    if (a === cameraOwner) return -1;
+    if (b === cameraOwner) return 1;
+    return a - b;
+  });
+  const framesByWorld = new Map<number, ExtractedFrame>();
+
+  for (const wi of extractionOrder) {
+    const world = worlds[wi];
+    if (world === undefined || failedWorlds.has(world)) continue;
+    try {
+      const isCameraOwner = wi === cameraOwner;
+      const cameraOwnerFrame = framesByWorld.get(cameraOwner);
+      const prepared = prepareExtractContext(world, {
+        ...(assets !== undefined ? { assets } : {}),
+        ...(pipelineState !== undefined ? { pipelineState } : {}),
+        ...(materialSnapshotCachesByWorld === undefined
+          ? {}
+          : {
+              materialSnapshotCache:
+                materialSnapshotCachesByWorld.get(world) ??
+                (() => {
+                  const cache: MaterialSnapshotCache = new Map();
+                  materialSnapshotCachesByWorld.set(world, cache);
+                  return cache;
+                })(),
+            }),
+        cull: options.cull === 'none' ? 'none' : isCameraOwner ? 'self' : 'external',
+        ...(cameraOwnerFrame === undefined ? {} : { cullCameras: cameraOwnerFrame.cameras }),
+      });
+      const frame = extractFrame(world, prepared);
+
+      framesByWorld.set(wi, frame);
+    } catch (err) {
+      // Per-world failure: route to world's own error handler, skip contribution.
+      try {
+        createWorldInternalView(world)._routeError(err, {
+          severity: Severity.Error,
+          systemName: `RenderSystem.extractFrames(world[${wi}])`,
+        });
+      } catch {
+        // If _routeError itself throws, the world already failed — skip silently.
+      }
+    }
+  }
+
+  // Restore the caller's world order after the camera-owner-first extraction.
+  for (let wi = 0; wi < worlds.length; wi++) {
+    const frame = framesByWorld.get(wi);
+    if (frame === undefined) continue;
+    succeededFrames.push(frame);
+    succeededIndices.push(wi);
+  }
+
+  // ── D-3: merge semantics ───────────────────────────────────────────────
+
+  // AC-04: renderables — concat by worlds[] order, stamp worldId.
+  const renderables: RenderableSnapshot[] = [];
+  const dispatchEntries: DispatchEntry[] = [];
+  const visibilitySnapshots: VisibilitySnapshot[] = [];
+  const featureVisibilitySnapshots: RenderFeatureWorldVisibilitySnapshot[] = [];
+  const hiddenEntityReports: RenderFeatureHiddenEntityReport[] = [];
+
+  for (let fi = 0; fi < succeededFrames.length; fi++) {
+    const f = succeededFrames[fi];
+    const wId = succeededIndices[fi];
+    if (f === undefined || wId === undefined) continue;
+
+    const base = renderables.length;
+    const visibilitySnapshot = f.visibilitySnapshots[0];
+    const world = worlds[wId];
+    if (visibilitySnapshot !== undefined) {
+      visibilitySnapshots.push(visibilitySnapshot);
+      if (world !== undefined)
+        featureVisibilitySnapshots.push({ world, snapshot: visibilitySnapshot });
+    }
+    hiddenEntityReports.push(...f.hiddenEntityReports);
+    for (const r of f.renderables) {
+      renderables.push({
+        ...r,
+        worldId: wId,
+        ...(r.pointsLines === undefined ? {} : { pointsLines: { ...r.pointsLines, worldId: wId } }),
+      });
+    }
+
+    // D-3: dispatch — per-world renderableIndex rebased by base offset.
+    for (const d of f.dispatch) {
+      dispatchEntries.push({ ...d, renderableIndex: (d.renderableIndex ?? 0) + base });
+    }
+  }
+
+  // Stable sort dispatch by queue value.
+  dispatchEntries.sort((a, b) => (a.queue ?? 0) - (b.queue ?? 0));
+
+  // AC-04: lights — point[]/spot[] concat; directional first-hit in
+  // succeededFrames order (which preserves worlds[] order for successful
+  // frames); directionalCount sum.
+  const point: PointLightSnapshot[] = [];
+  const spot: SpotLightSnapshot[] = [];
+  let directional: DirectionalLightSnapshot | undefined;
+  let directionalCount = 0;
+  let lightViewProj: readonly Float32Array[] | undefined;
+  let splitPlanes: Float32Array | undefined;
+  let cascadeCount: number | undefined;
+  let cascadeBlend: number | undefined;
+  let shadowMapSize: number | undefined;
+  let depthBias: number | undefined;
+  let normalBias: number | undefined;
+  let pcfKernelSize: number | 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
+  // matrices against the SURFACED (cameraOwner) camera — the light and the
+  // camera may live in different worlds (editor super-composite).
+  let directionalCsmConfig: DirectionalCsmConfig | undefined;
+  let directionalCsmDirection: Vec3 | undefined;
+  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 ps of f.lights.pointShadow) pointShadow.push(ps);
+    if (directional === undefined && f.lights.directional !== undefined) {
+      directional = f.lights.directional;
+      // Carry CSM shadow fields from the first-hit directional's world.
+      lightViewProj = f.lights.lightViewProj;
+      splitPlanes = f.lights.splitPlanes;
+      cascadeCount = f.lights.cascadeCount;
+      cascadeBlend = f.lights.cascadeBlend;
+      shadowMapSize = f.lights.shadowMapSize;
+      depthBias = f.lights.depthBias;
+      normalBias = f.lights.normalBias;
+      pcfKernelSize = f.lights.pcfKernelSize;
+      directionalCsmConfig = f.lights.directionalCsmConfig;
+      directionalCsmDirection = f.lights.directionalCsmDirection;
+    }
+    directionalCount += f.lights.directionalCount;
+  }
+
+  // AC-05/06 + w4 owner split (D-3 / R-6): cameras come from the cameraOwner
+  // world; skylight / skybox / postProcessParams come from the resourceOwner
+  // world (holistic snapshot selection). Scan succeededIndices once to locate
+  // each owner's surviving frame. When cameraOwner === resourceOwner both
+  // resolve to the same frame — byte-identical to the pre-w4 single-owner path.
+  let cameraOwnerFrame: ExtractedFrame | undefined;
+  let resourceOwnerFrame: ExtractedFrame | undefined;
+  for (let fi = 0; fi < succeededFrames.length; fi++) {
+    if (succeededIndices[fi] === cameraOwner) cameraOwnerFrame = succeededFrames[fi];
+    if (succeededIndices[fi] === resourceOwner) resourceOwnerFrame = succeededFrames[fi];
+  }
+  const cameras = cameraOwnerFrame !== undefined ? [...cameraOwnerFrame.cameras] : [];
+
+  // bug-20260710-editor-cross-world-shadow: RECOMPUTE directional CSM matrices
+  // against the surfaced camera. In a single-world app the per-world extract
+  // already produced correct matrices (light+camera share the world), and this
+  // recompute reproduces them byte-identically (same config, same camera). In
+  // the editor super-composite the directional light's world has NO camera, so
+  // its per-world `lightViewProj` is undefined/degenerate; the surfaced camera
+  // lives in the cameraOwner world. Pairing them here is the ONLY place both
+  // are visible. Point/spot shadows are camera-independent (light-space only)
+  // and need no merge-layer fix-up.
+  const mergeCam = cameras[0];
+  if (directionalCsmConfig !== undefined && directionalCsmDirection !== undefined) {
+    const mergeCameraData: CsmCameraData | undefined =
+      mergeCam !== undefined
+        ? {
+            world: mergeCam.world,
+            fov: mergeCam.fov,
+            aspect: mergeCam.aspect,
+            near: mergeCam.near,
+            far: mergeCam.far,
+            projection: mergeCam.projection,
+            orthoLeft: mergeCam.orthoLeft,
+            orthoRight: mergeCam.orthoRight,
+            orthoBottom: mergeCam.orthoBottom,
+            orthoTop: mergeCam.orthoTop,
+          }
+        : undefined;
+    const csm = computeDirectionalCsm(
+      directionalCsmDirection,
+      directionalCsmConfig,
+      mergeCameraData,
+    );
+    if (csm !== null) {
+      lightViewProj = csm.lightViewProj;
+      splitPlanes = csm.splitPlanes;
+      cascadeCount = csm.cascadeCount;
+      cascadeBlend = csm.cascadeBlend;
+      shadowMapSize = csm.shadowMapSize;
+    }
+    // csm === null (no surfaced camera at all): keep the per-world carry —
+    // there is no better data, and a cameraless frame renders nothing anyway.
+  }
+
+  const lights: ExtractedLights = {
+    directional,
+    directionalCount,
+    point,
+    spot,
+    lightViewProj,
+    splitPlanes,
+    cascadeCount,
+    cascadeBlend,
+    shadowMapSize,
+    depthBias,
+    normalBias,
+    pcfKernelSize,
+    pointShadow,
+    directionalCsmConfig,
+    directionalCsmDirection,
+  };
+  const skylight = resourceOwnerFrame?.skylight;
+  const skylightCount = resourceOwnerFrame?.skylightCount ?? 0;
+  const skybox = resourceOwnerFrame?.skybox;
+  const skyboxCount = resourceOwnerFrame?.skyboxCount ?? 0;
+  // User-authored PostProcessParams entities are singleton scene resources, so
+  // they come from the resourceOwner world (holistic snapshot selection).
+  const postProcessParams = new Map(resourceOwnerFrame?.postProcessParams);
+  // feat-20260709-editor-world-partition ENGINE-fix-round2 (defect 1): the
+  // engine built-in Standard tonemap param is NOT a scene resource — the
+  // per-world extractFrame bridges it from that world's own `cameras[0]`
+  // (Camera.exposure / whitePoint / tonemap is the SSOT). It therefore lives on
+  // the CAMERA-owner frame, not the resource-owner frame. In the split-owner
+  // editor topology the resourceOwner world has no Camera, so its frame carries
+  // no Standard tonemap entry; taking postProcessParams from resourceOwner
+  // alone drops it, the tonemap pass's params UBO stays zero-filled
+  // (exposure=0 => tonemapped output is uniformly black), and the whole frame
+  // reads black even though geometry drew into the HDR target. Overlay the
+  // camera-owner frame's tonemap param (its SSOT source) so the surfaced
+  // camera's exposure/whitePoint/mode reach the tonemap pass. When
+  // cameraOwner === resourceOwner this is a no-op (identical entry). The 'na'
+  // Standard tonemap identity mirrors the engine provider key set at the
+  // bottom of extractFrame (SSOT: same identity, same 16B layout).
+  const TONEMAP_PARAM_KEY = STANDARD_TONEMAP_FEATURE_ID;
+  const cameraTonemapParam = cameraOwnerFrame?.postProcessParams.get(TONEMAP_PARAM_KEY);
+  if (cameraTonemapParam !== undefined) {
+    postProcessParams.set(TONEMAP_PARAM_KEY, cameraTonemapParam);
+  } else {
+    // The camera-owner world produced no tonemap param (no Camera surfaced
+    // there this frame); do not leave a stale resource-owner entry that would
+    // apply a foreign camera's exposure. Removing it lets the tonemap pass fall
+    // back to its param-less zero path only when genuinely no camera exists.
+    postProcessParams.delete(TONEMAP_PARAM_KEY);
+  }
+
+  // D-3: frustumStats — culled/total summed across worlds.
+  const frustumStats = {
+    culled: succeededFrames.reduce((s, f) => s + f.frustumStats.culled, 0),
+    total: succeededFrames.reduce((s, f) => s + f.frustumStats.total, 0),
+  };
+  const visibilityStats = {
+    explicitlyHidden: succeededFrames.reduce((s, f) => s + f.visibilityStats.explicitlyHidden, 0),
+  };
+
+  return {
+    cameras,
+    lights,
+    renderables,
+    dispatch: dispatchEntries,
+    skylight,
+    skylightCount,
+    skybox,
+    skyboxCount,
+    frustumStats,
+    visibilityStats,
+    postProcessParams,
+    visibilitySnapshots,
+    featureVisibilitySnapshots,
+    hiddenEntityReports,
+  };
+}
+
+/**
+ * A MeshAsset participates in frustum culling only when its producer supplied
+ * the complete finite local-space bounds promised by the asset contract.
+ * Missing, malformed, and inverted-infinity empty bounds remain conservative
+ * (always visible) so a bad asset cannot turn into a false-negative render;
+ * they are not cull candidates and therefore do not inflate frustumStats.
+ */
+function hasFiniteOrderedLocalAabb(aabb: Float32Array | undefined): aabb is Float32Array {
+  if (aabb === undefined || aabb.length !== 6) return false;
+  const minX = aabb[0];
+  const minY = aabb[1];
+  const minZ = aabb[2];
+  const maxX = aabb[3];
+  const maxY = aabb[4];
+  const maxZ = aabb[5];
+  if (
+    minX === undefined ||
+    minY === undefined ||
+    minZ === undefined ||
+    maxX === undefined ||
+    maxY === undefined ||
+    maxZ === undefined
+  ) {
+    return false;
+  }
+  if (
+    !Number.isFinite(minX) ||
+    !Number.isFinite(minY) ||
+    !Number.isFinite(minZ) ||
+    !Number.isFinite(maxX) ||
+    !Number.isFinite(maxY) ||
+    !Number.isFinite(maxZ)
+  ) {
+    return false;
+  }
+  return minX <= maxX && minY <= maxY && minZ <= maxZ;
+}
+
+function morphSnapshotFor(
+  mesh: MeshAsset,
+  weights: ArrayLike<number> | undefined,
+): MorphSnapshot | undefined {
+  const targets = mesh.morphTargets;
+  if (targets === undefined || targets.length === 0 || weights === undefined) return undefined;
+  if (weights.length !== targets.length) return undefined;
+  const firstPositions = targets[0]?.position;
+  if (
+    firstPositions === undefined ||
+    firstPositions.length === 0 ||
+    firstPositions.length % 3 !== 0
+  ) {
+    return undefined;
+  }
+  const vertexCount = firstPositions.length / 3;
+  if (mesh.vertices.length % vertexCount !== 0) return undefined;
+  for (let targetIndex = 0; targetIndex < targets.length; targetIndex += 1) {
+    const target = targets[targetIndex];
+    if (target?.position?.length !== firstPositions.length) return undefined;
+  }
+  const copied = new Float32Array(weights.length);
+  for (let index = 0; index < weights.length; index += 1) {
+    const weight = weights[index] ?? Number.NaN;
+    if (!Number.isFinite(weight)) return undefined;
+    copied[index] = weight;
+  }
+  return { weights: copied, targetCount: targets.length };
+}
+
+export function extractFrame(world: World, context: PreparedExtractContext): ExtractedFrame {
+  // feat-20260708-composited-multi-world-rendering M2 / D-2: resetForFrame
+  // has been lifted to extractFrames (the frame-level entry point).
+  // extractFrame is now a pure world->snapshot function with no frame-level
+  // side effects. See plan-decisions PD2 for the reviewer ruling.
+  const {
+    assets,
+    pipelineState,
+    materialSnapshotCache: persistentMaterialSnapshotCache,
+    cull: cullMode,
+  } = context;
+  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
+  // propagateTransforms), not the retired GlobalTransform-column-switch.
+  //
+  // Each segment routes through a World-owned Query with explicit read and
+  // optional roles. The packed entity handle for `readWorldMat4Copy` /
+  // `_getArrayView` reads comes from `row.entity` -- the
+  // archetype-graph back-door (`graph.archetypes` / `arch.components.some`) is gone.
+  // Plan-decisions K-2 sniffing scheme B (archetype-edge sniff once via
+  // `row.get(X) !== undefined`); K-3 invariant preserved (`_getArrayView`
+  // calls survive untouched, only the entity source changes).
+  const worldInternal = createWorldInternalView(world);
+
+  const cameras = extractCameraSnapshots(world);
+
+  // Three-query union (M2 / w16 / AC-03): directional has no Transform
+  // dependency (sun-like infinite-source semantics); point + spot pull
+  // position from the companion Transform via the joined queries.
+  // Host-side pre-multiplication: color *= intensity (charter P4); cone
+  // deg -> cos (D-S2); range -> 1/range^2 (D-S5).
+  let directional: DirectionalLightSnapshot | undefined;
+  let directionalCount = 0;
+  // feat-20260621 M2: capture shadow fields from the first-hit DirectionalLight.
+  // castShadow defaults to true; the CSM path is gated on firstHitCastShadow !== false.
+  let firstHitCastShadow: boolean | undefined;
+  let firstHitShadowFields:
+    | {
+        cascadeCount: number;
+        splitLambda: number;
+        cascadeBlend: number;
+        mapSize: number;
+        depthBias: number;
+        normalBias: number;
+        shadowDistance: number;
+        pcfKernelSize: number;
+      }
+    | undefined;
+  for (const row of directionalLightQuery) {
+    const l = row.get(DirectionalLight);
+    directionalCount += 1;
+    const intensity = l.intensity;
+    const snapshot: DirectionalLightSnapshot = {
+      kind: 'directional',
+      direction: vec3.create(l.direction[0] ?? 0, l.direction[1] ?? -1, l.direction[2] ?? 0),
+      color: vec3.create(
+        (l.color[0] ?? 1) * intensity,
+        (l.color[1] ?? 1) * intensity,
+        (l.color[2] ?? 1) * intensity,
+      ),
+      intensity,
+    };
+    if (directional === undefined) {
+      // First hit wins; record-stage N>1 fail-fast (M3 / w19) flags duplicates.
+      directional = snapshot;
+      firstHitCastShadow = l.castShadow;
+      firstHitShadowFields = {
+        cascadeCount: l.cascadeCount,
+        splitLambda: l.splitLambda,
+        cascadeBlend: l.cascadeBlend,
+        mapSize: l.mapSize,
+        depthBias: l.depthBias,
+        normalBias: l.normalBias,
+        shadowDistance: l.shadowDistance,
+        pcfKernelSize: l.pcfKernelSize,
+      };
+    }
+  }
+
+  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
+  // `shadowAtlasLayer + shadowNear + shadowFar` onto the matching PointLight.
+  const pointSnapshotEntities: number[] = [];
+  const pointLightQuery = world
+    .query({
+      read: [PointLight],
+      optional: [Transform],
+    })
+    .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 intensity = p.intensity;
+    const range = p.range;
+    const entityId = row.entity;
+    // Position = world-space translation extracted from Transform.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');
+      if (view !== undefined) worldMat = new Float32Array(view);
+    }
+    const position =
+      worldMat !== undefined ? mat4.getTranslation(vec3.create(), worldMat) : vec3.create(0, 0, 0);
+    pointSnapshots.push({
+      kind: 'point',
+      position,
+      color: vec3.create(
+        (p.color[0] ?? 1) * intensity,
+        (p.color[1] ?? 1) * intensity,
+        (p.color[2] ?? 1) * intensity,
+      ),
+      intensity,
+      invRangeSquared: computeInvRangeSquared(range),
+    });
+    pointSnapshotEntities.push(entityId);
+  }
+
+  const spotSnapshots: SpotLightSnapshot[] = [];
+  const spotLightQuery = world
+    .query({
+      read: [SpotLight],
+      optional: [Transform],
+    })
+    .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;
+  for (const row of spotLightQuery) {
+    const s = row.get(SpotLight);
+    const hasTransform = row.get(Transform) !== undefined;
+    const intensity = s.intensity;
+    const range = s.range;
+    const innerConeDeg = s.innerConeDeg;
+    const outerConeDeg = s.outerConeDeg;
+    let worldMat: Float32Array | undefined;
+    if (hasTransform) {
+      const entity = row.entity;
+      const view = worldInternal._getArrayView(entity, Transform, 'world');
+      if (view !== undefined) worldMat = new Float32Array(view);
+    }
+    const position =
+      worldMat !== undefined ? mat4.getTranslation(vec3.create(), worldMat) : vec3.create(0, 0, 0);
+    const dir = vec3.create(s.direction[0] ?? 0, s.direction[1] ?? -1, s.direction[2] ?? 0);
+
+    // Extract is the single direction-normalization owner for direct-light
+    // snapshots. URP and HDRP preserve this value downstream.
+    const dirLen = Math.sqrt(
+      (dir[0] ?? 0) * (dir[0] ?? 0) + (dir[1] ?? 0) * (dir[1] ?? 0) + (dir[2] ?? 0) * (dir[2] ?? 0),
+    );
+    const EPSILON = 1e-6;
+    const hasValidDirection = dirLen > EPSILON;
+    if (!hasValidDirection) {
+      worldInternal._routeError(
+        new SpawnLightInvalidBoundsError('SpotLight', 'direction', [
+          dir[0] ?? 0,
+          dir[1] ?? 0,
+          dir[2] ?? 0,
+        ]),
+        {
+          severity: Severity.Error,
+          systemName: 'RenderSystem.extract (spot-direction)',
+        },
+      );
+    }
+    const dirN = vec3.create(
+      hasValidDirection ? (dir[0] ?? 0) / dirLen : (dir[0] ?? 0),
+      hasValidDirection ? (dir[1] ?? 0) / dirLen : (dir[1] ?? 0),
+      hasValidDirection ? (dir[2] ?? 0) / dirLen : (dir[2] ?? 0),
+    );
+
+    // ── shadow fields (feat-20260625-spot-light-shadow-mapping M1) ──
+    const castShadow = s.castShadow;
+    const sMapSize = s.mapSize;
+    const sNearPlane = s.nearPlane;
+    const sFarPlane = s.farPlane;
+
+    let lightViewProj: Float32Array | undefined;
+    let shadowAtlasTile = -1;
+
+    if (castShadow && hasValidDirection) {
+      const target = vec3.create(
+        (position[0] ?? 0) + (dirN[0] ?? 0),
+        (position[1] ?? 0) + (dirN[1] ?? 0),
+        (position[2] ?? 0) + (dirN[2] ?? 0),
+      );
+      // D-1: perspective(outerConeDeg*2, aspect=1, near, far) x lookAt(pos, pos+dir).
+      // FOV = outerConeDeg * 2 in degrees; mat4.perspective takes fov in radians.
+      const fov = outerConeDeg * 2 * (Math.PI / 180);
+      const proj = mat4.create();
+      mat4.perspective(proj, fov, 1, sNearPlane, sFarPlane);
+      const view = mat4.create();
+      mat4.lookAt(view, position, target, vec3.create(0, 1, 0));
+      lightViewProj = new Float32Array(16);
+      // Reinterpret the Float32Array surface field as a Mat4 out-param; a
+      // factory would force a needless alloc+copy. brand-cast-ok
+      mat4.multiply(lightViewProj as Mat4, proj, view);
+
+      // D-4: allocate tile 0..3; 5th+ = -1 sentinel.
+      if (spotTileNext < 4) {
+        shadowAtlasTile = spotTileNext;
+        spotTileNext += 1;
+      }
+    }
+
+    spotSnapshots.push({
+      kind: 'spot',
+      // D-6: position reflects world transform; direction stays sourced
+      // from SpotLight.direction (NOT rotated by the parent).
+      position,
+      direction: dirN,
+      color: vec3.create(
+        (s.color[0] ?? 1) * intensity,
+        (s.color[1] ?? 1) * intensity,
+        (s.color[2] ?? 1) * intensity,
+      ),
+      intensity,
+      invRangeSquared: computeInvRangeSquared(range),
+      cosInner: degToCos(innerConeDeg),
+      cosOuter: degToCos(outerConeDeg),
+      // ── shadow fields ──
+      castShadow,
+      lightViewProj,
+      mapSize: sMapSize,
+      nearPlane: sNearPlane,
+      farPlane: sFarPlane,
+      shadowAtlasTile,
+    });
+  }
+
+  // bug-20260710-editor-cross-world-shadow: CSM matrices are computed by the
+  // shared pure {@link computeDirectionalCsm}, called here per-world with THIS
+  // world's own `cameras[0]`. In a single-world app the light and camera share
+  // the world, so this per-world result is final (byte-identical to the prior
+  // inline block). In the editor super-composite the light's world may have no
+  // camera → this yields no matrices; {@link extractFrames} then RECOMPUTES at
+  // the merge layer using the surfaced (cameraOwner) camera + the raw config
+  // carried on ExtractedLights. The raw config + direction are surfaced
+  // unconditionally so the merge layer can re-run the builder.
+  let lightViewProj: Float32Array[] | undefined;
+  let splitPlanes: Float32Array | undefined;
+  let cascadeCount: number | undefined;
+  let cascadeBlend: number | undefined;
+  let shadowMapSize: number | undefined;
+  let directionalCsmConfig: DirectionalCsmConfig | undefined;
+  let directionalCsmDirection: Vec3 | undefined;
+
+  // Camera data needed for frustum corner computation (first camera only;
+  // multi-camera CSM is OOS-1). Undefined in a cameraless world.
+  const cam0 = cameras[0];
+  const cameraData: CsmCameraData | undefined =
+    cam0 !== undefined
+      ? {
+          world: cam0.world,
+          fov: cam0.fov,
+          aspect: cam0.aspect,
+          near: cam0.near,
+          far: cam0.far,
+          projection: cam0.projection,
+          orthoLeft: cam0.orthoLeft,
+          orthoRight: cam0.orthoRight,
+          orthoBottom: cam0.orthoBottom,
+          orthoTop: cam0.orthoTop,
+        }
+      : undefined;
+
+  // 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) {
+    const dirSnapshot = directional;
+    const sf = firstHitShadowFields;
+    if (sf !== undefined) {
+      directionalCsmConfig = {
+        cascadeCount: sf.cascadeCount,
+        splitLambda: sf.splitLambda,
+        cascadeBlend: sf.cascadeBlend,
+        mapSize: sf.mapSize,
+        shadowDistance: sf.shadowDistance,
+      };
+      directionalCsmDirection = dirSnapshot.direction;
+      const csm = computeDirectionalCsm(dirSnapshot.direction, directionalCsmConfig, cameraData);
+      // Cascade metadata (splitPlanes / count / blend / mapSize) is available
+      // even without a camera (splitPlanes needs only near/far); the matrices
+      // need the camera. When csm is null (no camera) leave lightViewProj
+      // undefined — the merge layer recomputes. Still surface the split/count
+      // metadata so a single-world path keeps its prior fields.
+      cascadeCount = Math.round(sf.cascadeCount);
+      cascadeBlend = sf.cascadeBlend;
+      shadowMapSize = sf.mapSize;
+      if (csm !== null) {
+        lightViewProj = csm.lightViewProj;
+        splitPlanes = csm.splitPlanes;
+      } 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;
+        splitPlanes = padded;
+      }
+    }
+  }
+
+  // feat-20260613-csm M3 / w14 (plan-strategy §D-7): pad the up-to-4
+  // splitPlanes into a fixed length-4 Float32Array (unused slots = 0) so
+  // 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);
+  if (splitPlanes !== undefined) {
+    for (let i = 0; i < splitPlanes.length; i++) {
+      paddedSplitPlanes[i] = splitPlanes[i] ?? 0;
+    }
+  }
+
+  // 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.
+  const pointShadowSnapshots: PointShadowSnapshot[] = [];
+  {
+    const pointShadowQuery = world
+      .query({ read: [Transform, 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;
+      // translation lives at indices 12..14, mirroring CameraSnapshot.world
+      // semantics in this file).
+      // feat-20260614 M4 / w13: TypedArrayFor for `array<f32, 16>` now
+      // resolves to a concrete `Float32Array` (was `never` pre-w11), which
+      // surfaces the row-window slicing -- `t.world` is the stride-16 flat
+      // column view; row i lives at `[i*16, (i+1)*16)`. The prior
+      // `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;
+      if (wRow === undefined) continue;
+      const px = wRow[12] ?? 0;
+      const py = wRow[13] ?? 0;
+      const pz = wRow[14] ?? 0;
+      const lightPos = vec3.create(px, py, pz);
+      const mapSize = ps.mapSize;
+      const nearPlane = ps.nearPlane;
+      const farPlane = ps.farPlane;
+      const layer = pointShadowSnapshots.length; // 0, 1, 2, 3 in spawn order
+
+      const matrices = buildPointShadowMatrices(lightPos, nearPlane, farPlane);
+      const packed = new Float32Array(96);
+      for (let f = 0; f < 6; f++) {
+        const m = matrices[f];
+        if (m === undefined) continue;
+        for (let k = 0; k < 16; k++) {
+          packed[f * 16 + k] = m[k] ?? 0;
+        }
+      }
+      pointShadowSnapshots.push({
+        entity: row.entity,
+        position: lightPos,
+        mapSize,
+        nearPlane,
+        farPlane,
+        shadowAtlasLayer: layer,
+        shadowMatrices: packed,
+      });
+    }
+  }
+
+  // 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).
+  // 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) {
+    const shadowByEntity = new Map<number, PointShadowSnapshot>();
+    for (const ps of pointShadowSnapshots) shadowByEntity.set(ps.entity, ps);
+    for (let i = 0; i < pointSnapshots.length; i++) {
+      const entityId = pointSnapshotEntities[i] ?? 0;
+      const ps = shadowByEntity.get(entityId);
+      if (ps !== undefined) {
+        pointSnapshots[i] = {
+          ...(pointSnapshots[i] as PointLightSnapshot),
+          shadowAtlasLayer: ps.shadowAtlasLayer,
+          shadowNear: ps.nearPlane,
+          shadowFar: ps.farPlane,
+        };
+      }
+    }
+  }
+
+  const lights: ExtractedLights = {
+    directional,
+    directionalCount,
+    point: pointSnapshots,
+    spot: spotSnapshots,
+    lightViewProj,
+    splitPlanes: splitPlanes !== undefined ? paddedSplitPlanes : undefined,
+    cascadeCount,
+    cascadeBlend,
+    shadowMapSize,
+    depthBias: firstHitCastShadow !== false ? firstHitShadowFields?.depthBias : undefined,
+    normalBias: firstHitCastShadow !== false ? firstHitShadowFields?.normalBias : undefined,
+    pcfKernelSize: firstHitCastShadow !== false ? firstHitShadowFields?.pcfKernelSize : undefined,
+    pointShadow: pointShadowSnapshots,
+    // bug-20260710-editor-cross-world-shadow: raw CSM config + light direction
+    // so the merge layer can recompute matrices against the surfaced camera.
+    directionalCsmConfig,
+    directionalCsmDirection,
+  };
+
+  // feat-20260520-skylight-ibl-cubemap M4 / t26+t27: query Skylight entities.
+  // First archetype hit wins (mirrors DirectionalLight pattern); multi-Skylight
+  // warn in record stage (t27) uses skylightCount.
+  const skylightQuery = world.query({ read: [Skylight] }).unwrap();
+  let skylight: SkylightSnapshot | undefined;
+  let skylightCount = 0;
+  for (const row of skylightQuery) {
+    const s = row.get(Skylight);
+    // equirect is OPTIONAL: an omitted field zero-inits to handle 0, which
+    // record treats as "no equirect" -> solid-color ambient via the white
+    // fallback cube. A Skylight WITHOUT an equirect is still a valid snapshot
+    // (the prior `equirectRaw !== undefined` gate dropped color-only
+    // skylights, leaving the scene black -- the downstream gap #4).
+    const equirectRaw = s.equirect;
+    const intensity = s.intensity;
+    const colorR = s.color[0] ?? 1.0;
+    const colorG = s.color[1] ?? 1.0;
+    const colorB = s.color[2] ?? 1.0;
+    const rotation: [number, number, number, number] = [
+      s.rotation[0] ?? 0,
+      s.rotation[1] ?? 0,
+      s.rotation[2] ?? 0,
+      s.rotation[3] ?? 1,
+    ];
+    skylightCount += 1;
+    if (skylight === undefined) {
+      skylight = {
+        equirectHandle: equirectRaw !== undefined ? Math.round(equirectRaw) : 0,
+        color: [colorR, colorG, colorB],
+        intensity,
+        rotation,
+        // w19: winning entity handle for the multi-Skylight once-warn (F-8).
+        entityHandle: row.entity,
+      };
+    }
+  }
+
+  // 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.
+  const skyboxQuery = world.query({ read: [SkyboxBackground] }).unwrap();
+  let skybox: SkyboxSnapshot | undefined;
+  let skyboxCount = 0;
+  for (const row of skyboxQuery) {
+    const s = row.get(SkyboxBackground);
+    const equirectRaw = s.equirect;
+    const modeRaw = s.mode;
+    const rotation: [number, number, number, number] = [
+      s.rotation[0] ?? 0,
+      s.rotation[1] ?? 0,
+      s.rotation[2] ?? 0,
+      s.rotation[3] ?? 1,
+    ];
+    skyboxCount += 1;
+    if (skybox === undefined && equirectRaw !== undefined) {
+      skybox = {
+        equirectHandle: Math.round(equirectRaw),
+        mode: modeRaw,
+        rotation,
+        // w19: winning entity handle for the multi-SkyboxBackground warn (F-8).
+        entityHandle: row.entity,
+      };
+    }
+  }
+
+  // feat-20260528-frustum-culling M3 / w10: precompute per-camera frustum
+  // planes so entities can be tested against all cameras in the inner loop.
+  // Cameras with degenerate projection parameters (e.g. zero fov, zero aspect)
+  // are skipped — entities are always-visible for those. Frustum plane cache
+  // stored as Float32Array[] parallel to the cameras[] array.
+  //
+  // feat-20260708-composited-multi-world-rendering M2 / D-4: a composite
+  // non-owner world uses the camera-owner snapshots, not its own cameras.
+  // This keeps culling correct when the surfaced camera and renderables live
+  // in different worlds. The explicit 'none' mode remains the always-visible
+  // escape hatch for callers that genuinely need it.
+  const frustumPlanes: Float32Array[] = [];
+  const cullingCameras = cullMode === 'external' ? (context.cullCameras ?? []) : cameras;
+  if (cullMode !== 'none') {
+    for (const cam of cullingCameras) {
+      // feat-20260613 M6 / w20: orthographic cameras have fov=0 by design;
+      // the previous degeneracy guard (`fov <= 0`) was rejecting valid ortho
+      // cameras and returning the always-visible escape hatch. Only the
+      // perspective path needs the fov check.
+      if (cam.projection === 'perspective' && (cam.fov <= 0 || cam.aspect <= 0)) {
+        frustumPlanes.push(new Float32Array(0)); // degenerate → always-visible
+        continue;
+      }
+      if (cam.near >= cam.far) {
+        frustumPlanes.push(new Float32Array(0));
+        continue;
+      }
+      const proj = mat4.create();
+      if (cam.projection === 'orthographic') {
+        mat4.orthographic(
+          proj,
+          cam.orthoLeft,
+          cam.orthoRight,
+          cam.orthoBottom,
+          cam.orthoTop,
+          cam.near,
+          cam.far,
+        );
+      } else {
+        mat4.perspective(proj, cam.fov, cam.aspect, cam.near, cam.far);
+      }
+      // feat-20260601 D-3: view = invert(camera world mat4). The camera scale is
+      // carried in the world basis columns; the cull frustum uses the same view
+      // the record stage derives, so cull stays same-source with render (AC-05).
+      const view = mat4.create();
+      mat4.invert(view, cam.world);
+      const vp = mat4.create();
+      mat4.multiply(vp, proj, view);
+      const f = frustum.create();
+      frustum.fromViewProjection(f, vp);
+      frustumPlanes.push(f);
+    }
+  }
+
+  const renderables: RenderableSnapshot[] = [];
+  // feat-20260528-frustum-culling M3 / w11: frustum culling counters.
+  let frustumCulled = 0;
+  let frustumTotal = 0;
+  const explicitlyHidden = new Set<EntityHandle>();
+  // feat-20260520-2d-sprite-layer-mvp M-3 / w22 (@new-surface): three-
+  // bucket dispatch arrays. The legacy `materialDispatch` field stays as
+  // a back-compat union (opaque + transparent + overlay back-compat
+  // entries) so the pre-w25 RenderSystem.draw consumer loop keeps
+  // working until M-3 / w25 lands the bucket-aware record. Plan-strategy
+  // §6.1 (back-compat field stays until M-4 acceptance round green).
+  // M3 / w26: single dispatch list replaces old three-bucket model
+  // (plan-strategy D-3). Entries built per-entity per-pass inside the
+  // archetype walk, then sorted by queue at the end.
+  let dispatch: DispatchEntry[] = [];
+  // Keep the derived material snapshot and its resolved passes local to this
+  // extraction. Shared handles are immutable inputs for the frame, while
+  // dispatch entries still need to be rebuilt for each entity.
+  const materialSnapshotCache: MaterialSnapshotCache = new Map();
+  // tweak-20260611 M1: MeshRenderer renderable archetype walk routes
+  // through one World-owned Query. K-2 sniffing scheme B
+  // (`row.get(X) !== undefined` edge sniff) replaces the prior
+  // `arch.components.some` row-internal back-door. K-3 invariant: the
+  // variable-length array reads (`MeshRenderer.materials`,
+  // `Instances.transforms`) still flow through `_getArrayView` /
+  // `world.get(e, Instances)` -- only the `entity` source switches to
+  // `row.entity`.
+  //
+  // archVersion plumbing exception: the `RenderableSnapshot.instances
+  // .archVersion` cache key is keyed off the live archetype's mutation
+  // counter (record stage `instanceBuffers` cache invalidation). The
+  // QueryRow does not surface this number, so a single archetype
+  // graph access is retained for instance-bearing rows -- match by entity
+  // packed handle. AC-01 grep ≤ current - 1 still holds: the stale
+  // archetype-graph traversal commentary at the prior call site is gone.
+  // feat-20260521-sprite-atlas-animation M3 / T-16: SpriteRegionOverride
+  // 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();
+  // 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.
+  const resolveArchVersion = (entity: EntityHandle): number => {
+    const values = [
+      worldInternal._getArrayView(entity, Instances, 'transforms'),
+      worldInternal._getArrayView(entity, SpriteInstances, 'transforms'),
+      worldInternal._getArrayView(entity, SpriteInstances, 'regions'),
+    ];
+    let hash = 2166136261;
+    for (const value of values) {
+      hash = Math.imul(hash ^ (value?.length ?? 0), 16777619) >>> 0;
+      if (value === undefined) continue;
+      for (let index = 0; index < value.length; index += 1) {
+        hash = Math.imul(hash ^ Math.fround(value[index] ?? 0), 16777619) >>> 0;
+      }
+    }
+    return hash;
+  };
+  // Pending entries are created with the current renderables.length, which is
+  // exactly the slot this entity receives if it survives culling. No other
+  // renderable can be pushed between staging and this entity's push, so publish
+  // the original fresh entries instead of cloning every submesh descriptor.
+  // A culled entity still discards its private pending array unchanged.
+  const flushPendingDispatch = (pending: readonly DispatchEntry[]): void => {
+    for (const entry of pending) dispatch.push(entry);
+  };
+  for (const row of meshRendererQuery) {
+    // K-2 archetype-edge sniff (scheme B): a missing optional component
+    // surfaces as an absent bundle key, not a row-internal optional chain.
+    // Presence-only checks use QueryRow.has so large array-bearing components
+    // are not materialised merely to answer a boolean question.
+    const hasTransform = row.has(Transform);
+    const meshFilter = row.get(MeshFilter);
+    const hasInstances = row.has(Instances);
+    const skin = row.get(Skin);
+    const morphWeightsView = worldInternal._getArrayView(row.entity, MorphWeights, 'weights');
+    const hasMeshFilter = meshFilter !== undefined;
+    const hasSkin = skin !== undefined;
+    // feat-20260625-sprite-instances-and-tilemap-terrain-static-batch M3 / w10:
+    // SpriteInstances optional component archetype-edge sniff. Three structured
+    // EcsError codes fire at the row-loop entry (D-6 fail-fast at extract):
+    //   - 'sprite-instances-mutually-exclusive-with-instances'
+    //       (hasInstances && hasSpriteInstances) — Instances + SpriteInstances peers.
+    //   - 'sprite-instances-requires-sprite-shading-model'
+    //       (materialSnap.materialShaderId !== 'forgeax::sprite') — non-sprite material.
+    //   - 'sprite-instances-count-mismatch'
+    //       (transforms.length / 16 !== regions.length / 4) — stride pair desync.
+    const hasSpriteInstances = row.has(SpriteInstances);
+    const points = row.get(Points);
+    const lines = row.get(Lines);
+    const sortKey = row.get(SortKey)?.value;
+    const pointsLinesComponent =
+      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.
+    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
+    // it as the primary transparent-sort key without a second ECS round-trip.
+    const fLayerValue = row.get(Layer)?.value;
+    // feat-20260608-tilemap-object-layer-rendering M3 / m3-t5: tilemap-spawned
+    // per-cell render entities (the ones `tilemap-chunk-extract-system`
+    // pushes via `spawnDerivedRenderEntities`) reach this loop via the same
+    // archetype edge that carries a sprite entity -- they all wear
+    // `MeshFilter.assetHandle === HANDLE_QUAD` + a `forgeax::sprite`-shaded
+    // material asset + the sprite-bucket `values.region` rectangle.
+    // For the per-entity Y-sort path (requirements §AC-12 / §AC-13):
+    //
+    //   sortKey = -(Transform.posY - effectivePivotY * |Transform.scaleY|)
+    //
+    // with `effectivePivotY = effectivePivotYForTilemapFlip(pivotY, pivotX,
+    // flipV, flipDiagonal)` from `tilemap-chunk-extract-system` (the SAME
+    // helper drives `spawnDerivedRenderEntities`, so the value the sort
+    // uses matches the value baked into `Transform.posY` -- charter P4
+    // single SSOT for the post-flip pivot). Sprite entities reuse the same
+    // formula but skip the flip composition (their pivot stays raw); both
+    // bucket types therefore feed one `transparentSortEntries` argsort
+    // step + share the `argsortInPlace` radix LSD primitive (plan-strategy
+    // §D-1 / §D-3). The detection lives on the material side -- detect a
+    // tilemap-spawned entity by `MeshFilter.assetHandle === HANDLE_QUAD`
+    // plus the `forgeax::sprite` shader id on `MeshRenderer.material`'s
+    // first pass + non-empty `values.region`; no new public ECS
+    // marker component lands (charter F1 minimum surface).
+    //
+    // Layer.value is now folded into each DispatchEntry.layer (fLayerValue
+    // column, read once per archetype pass above). render-system.ts
+    // `sortTransparentDispatch` applies (layer ASC, sortValue ASC) for all
+    // transparent-sort modes (0/1/2) using posY/pivotY/sizeY from the
+    // parallel renderables[] snapshot -- no second ECS round-trip needed.
+    // feat-20260527-sprite-nineslice M4 / w17 (AC-14): SpriteRegionOverride
+    // per-entity UV sub-rectangle. When the entity carries this component the
+    // 4-float `[uMin, vMin, uW, vH]` override displaces the asset-side
+    // `values.region` for this entity only — downstream 9-slice logic
+    // measures slices against this effective region.zw, so a half-width sub-
+    // sprite reduces the anchor budget to 0.5 rather than the asset's 1.0.
+    //
+    // SpriteRegionOverride.region is a fixed stride-4 value. Per-row reads
+    // route through `_getArrayView` for the zero-copy row window
+    // row-window slice (consistent with the variable-length array column
+    // reads -- K-3 carve-out keeps `_getArrayView` as the row-accessor of
+    // record for each non-scalar column).
+    const hasSpriteRegionOverride = row.has(SpriteRegionOverride);
+    // feat-20260523-skin-skeleton-animation M2 / T-21: Skin component
+    // column views for coexistence check + joint despawn fail-fast.
+    // `skeleton` holds the packed Handle<SkeletonAsset>; `joints` holds
+    // the packed Entity u32 array (N x one u32 each).
+    const skinSkeletonView = skin?.skeleton;
+
+    let archVersion = 0;
+    if (hasInstances || hasSpriteInstances) {
+      // All rows in this callback share one archetype.  Only these two
+      // instance-bearing paths consume the version in their cache key.
+      archVersion = resolveArchVersion(row.entity);
+    }
+
+    {
+      // feat-20260608 M2 / w11: read materials array via _getArrayView
+      const entity = row.entity;
+      if (isRenderable && visibility?.effective(entity) === 'hidden') {
+        explicitlyHidden.add(entity);
+        continue;
+      }
+      const layerVal = fLayerValue ?? 0;
+      // bug-20260709-builtin-quad-withoutaabb-disables-sprite-frustum-cu M2.5
+      // (carries PR #598 feat-20260703 D-7): dispatch entries for this entity
+      // are staged locally and flushed into the shared `dispatch[]` array
+      // ONLY when the entity survives the frustum-cull `continue` below —
+      // same cull-passed branch as the paired `renderables.push`. Prior to
+      // this fix the three `dispatch.push` sites ran before the cull check,
+      // so a culled entity left dangling entries whose `renderableIndex`
+      // aliased the slot a LATER visible entity occupied — surfacing as the
+      // pbr-mesh-array-bgl vs hdrp-unified-bgl-group2 BGL/PL mismatch on
+      // the deferred-shading smoke (PR #598 CI). Pure ordering fix; cull
+      // logic and MeshRenderer contract unchanged.
+      const pendingDispatch: DispatchEntry[] = [];
+      const materialsView = worldInternal._getArrayView(entity, MeshRenderer, 'materials') as
+        | Uint32Array
+        | undefined;
+      const materialCount = materialsView?.length ?? 0;
+      let materialHandles = Array.from(materialsView ?? []);
+      let materialBindingSources: MeshMaterialBindingSource[] = materialHandles.map(
+        () => 'renderer-override',
+      );
+      let materialBindingDiagnostics: MeshMaterialBindingDiagnostic[] = [];
+      let gpuDrivenSubmeshes: readonly MeshAsset['submeshes'][number][] = [];
+      let gpuDrivenIndexed = false;
+
+      // Resolve instance overrides against mesh-owned slot defaults once.
+      const fAssetHandleVal = fAssetHandle;
+      if (
+        fAssetHandleVal !== undefined &&
+        fAssetHandleVal !== 0 &&
+        assets !== undefined &&
+        assets !== null
+      ) {
+        const meshHandle = toShared<'MeshAsset'>(fAssetHandleVal);
+        const meshRes = resolveAssetHandle<Asset>(world, meshHandle);
+        if (meshRes.ok && meshRes.value.kind === 'mesh') {
+          const meshAsset = meshRes.value as MeshAsset;
+          gpuDrivenSubmeshes = meshAsset.submeshes;
+          gpuDrivenIndexed = meshAsset.indices !== undefined;
+          // 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
+          // and never infer slot topology from their submeshes.
+          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));
+              return resolved.ok && resolved.value.kind === 'material';
+            },
+            resolveMeshDefault(defaultGuid) {
+              const guidText = AssetGuid.format(defaultGuid);
+              if (assets.lookup<Asset>(guidText)?.kind !== 'material') return undefined;
+              return internSharedRefFromGuid(world, assets, guidText, 'MaterialAsset') as
+                | number
+                | undefined;
+            },
+          });
+          if (!resolvedBindings.ok) {
+            if (resolvedBindings.code === 'mesh-material-slots-missing') {
+              worldInternal._routeError(
+                new AssetError({
+                  code: 'load-failed',
+                  expected: 'every MeshAsset producer supplies materialSlots[]',
+                  hint: `fix the MeshAsset producer; renderer inheritance never guesses slot topology (mesh=${guid}, entity=${entity}, vertices=${meshAsset.vertices.length}, indices=${meshAsset.indices?.length ?? 0})`,
+                  detail: {
+                    referencedByGuid: guid,
+                    referencedByKind: 'mesh',
+                    subAssetGuid: '<material-slots-missing>',
+                    sourceField: { fieldName: 'materialSlots' },
+                  },
+                }),
+                {
+                  severity: Severity.Error,
+                  systemName: 'RenderSystem.extract (mesh-material-slots-missing)',
+                },
+              );
+              continue;
+            }
+            const materialGuid = AssetGuid.format(resolvedBindings.defaultMaterial);
+            worldInternal._routeError(
+              new AssetError({
+                code: 'load-failed',
+                expected: `MeshAsset materialSlots[${resolvedBindings.slotIndex}] default ${materialGuid} is ready and a MaterialAsset`,
+                hint: `loadByGuid(meshGuid) must recursively load the declared default material; mesh=${guid}, slot=${resolvedBindings.slotIndex}, material=${materialGuid}`,
+                detail: {
+                  referencedByGuid: guid,
+                  referencedByKind: 'mesh',
+                  subAssetGuid: materialGuid,
+                  sourceField: {
+                    fieldName: 'materialSlots',
+                    arrayIndex: resolvedBindings.slotIndex,
+                  },
+                },
+              }),
+              {
+                severity: Severity.Error,
+                systemName: 'RenderSystem.extract (mesh-default-not-ready)',
+              },
+            );
+            continue;
+          }
+          materialHandles = resolvedBindings.bindings.map((binding) => binding.handle);
+          materialBindingSources = resolvedBindings.bindings.map((binding) => binding.source);
+          materialBindingDiagnostics = resolvedBindings.diagnostics.map((diagnostic) => ({
+            ...diagnostic,
+            detail:
+              diagnostic.code === 'mesh-renderer-material-override-overflow'
+                ? {
+                    expectedCount: meshAsset.materialSlots.length,
+                    actualCount: materialCount,
+                    meshAssetGuid: guid,
+                  }
+                : {
+                    meshAssetGuid: guid,
+                    slotIndex: diagnostic.slotIndex,
+                    handle: diagnostic.handle ?? 0,
+                  },
+          }));
+          for (const diagnostic of resolvedBindings.diagnostics) {
+            worldInternal._routeError(
+              new AssetError({
+                code: diagnostic.code,
+                expected:
+                  diagnostic.code === 'mesh-renderer-material-override-overflow'
+                    ? `materials.length <= materialSlots.length (${meshAsset.materialSlots.length})`
+                    : `materials[${diagnostic.slotIndex}] resolves to a live MaterialAsset`,
+                hint: ASSET_ERROR_HINTS[diagnostic.code],
+                detail:
+                  diagnostic.code === 'mesh-renderer-material-override-overflow'
+                    ? {
+                        expectedCount: meshAsset.materialSlots.length,
+                        actualCount: materialCount,
+                        meshAssetGuid: guid,
+                      }
+                    : {
+                        meshAssetGuid: guid,
+                        slotIndex: diagnostic.slotIndex,
+                        handle: diagnostic.handle ?? 0,
+                      },
+              }),
+              {
+                severity: Severity.Warning,
+                systemName: `RenderSystem.extract (${diagnostic.code})`,
+              },
+            );
+          }
+        }
+      }
+
+      if (materialHandles.length === 0) {
+        materialHandles = [0];
+        materialBindingSources = ['engine-default'];
+      }
+
+      // Use the first material handle for the entity-level snapshot
+      // (shading-model dispatch routing + multi-pass DispatchEntry. Per-
+      // submesh materials[i>=1] are resolved by `resolveMaterialSnapshot`
+      // below into the `materials[]` array, used by the record stage to
+      // upload N material UBO slots and bind the i-th slot before the
+      // i-th submesh draw.) -- feat-20260608 M5 amend / w11-a.
+      const handleRaw = materialHandles[0] ?? 0;
+
+      const cachedMaterial =
+        handleRaw !== 0 && !hasSpriteRegionOverride && !hasSkin
+          ? materialSnapshotCache.get(handleRaw)
+          : undefined;
+
+      let materialSnap: MaterialSnapshot;
+
+      if (cachedMaterial !== undefined) {
+        materialSnap = cachedMaterial.snapshot;
+        if (isRenderable) {
+          appendMaterialDispatchEntries(
+            pendingDispatch,
+            cachedMaterial.passes,
+            entity,
+            handleRaw,
+            renderables.length,
+            layerVal,
+            materialSnap.paramSnapshot,
+          );
+        }
+      } else if (handleRaw === 0 || assets === undefined || assets === null) {
+        // case B: missing-spec sentinel -> mid-grey defaultMaterialSnapshot.
+        materialSnap = defaultMaterialSnapshot(handleRaw);
+      } else {
+        const tagged = toShared<'MaterialAsset'>(handleRaw);
+        const stablePersistentCached =
+          !hasSpriteRegionOverride && !hasSkin
+            ? readStablePersistentMaterialSnapshot(
+                persistentMaterialSnapshotCache,
+                handleRaw,
+                assets,
+              )
+            : undefined;
+        if (stablePersistentCached !== undefined) {
+          materialSnapshotCache.set(handleRaw, stablePersistentCached);
+          materialSnap = stablePersistentCached.snapshot;
+          if (isRenderable) {
+            appendMaterialDispatchEntries(
+              pendingDispatch,
+              stablePersistentCached.passes,
+              entity,
+              handleRaw,
+              renderables.length,
+              layerVal,
+              materialSnap.paramSnapshot,
+            );
+          }
+        } else {
+          const res = resolveAssetHandle(world, tagged);
+          if (!res.ok) {
+            if (isRenderable) {
+              const rhiErr = new RhiError({
+                code: 'asset-not-registered',
+                expected: 'MeshRenderer.material in AssetRegistry',
+                hint: 'catalog the material via assetRegistry.catalog(guid, asset) + world.allocSharedRef before spawn, or remove the material field to fall back to default',
+                detail: { assetHandle: handleRaw },
+              });
+              worldInternal._routeError(rhiErr, {
+                severity: Severity.Error,
+                systemName: 'RenderSystem.extract (material asset-not-registered)',
+              });
+            }
+            continue;
+          }
+          const asset = res.value;
+          if (asset.kind !== 'material') {
+            materialSnap = defaultMaterialSnapshot(handleRaw);
+          } else {
+            // feat-20260529 M3 / w11: material parent chain inheritance via
+            // read-through _materialWalk accessor (plan-strategy D-6).
+            // The old direct asset.passes / asset.values read never
+            // walked the parent chain, causing broken-inheritance (root cause).
+            const resolvedResult = walkMaterialPassesOverSharedRefs(world, tagged, assets);
+            if (!resolvedResult.ok) {
+              // AC-09 / S-7 / q8=A: passes-empty or cycle must fire structured
+              // error through _routeError (same routing as asset-not-registered
+              // branch above). Silent continue is forbidden because it produces
+              // a black screen indistinguishable from a content bug.
+              const err = resolvedResult.error;
+              switch (err.code) {
+                case 'material-parent-not-found':
+                case 'material-no-effective-pass':
+                case 'material-value-unknown':
+                case 'material-value-type-mismatch':
+                case 'material-contract-program-mismatch':
+                  worldInternal._routeError(err, {
+                    severity: Severity.Error,
+                    systemName: `RenderSystem.extract (${err.code})`,
+                  });
+                  break;
+                case 'material-circular-inheritance':
+                  worldInternal._routeError(err, {
+                    severity: Severity.Error,
+                    systemName: 'RenderSystem.extract (material-circular-inheritance)',
+                  });
+                  break;
+                default:
+                  // Exhaustive guard: unhandled error codes from _materialWalk
+                  // surface an internal assertion to avoid silent continuation.
+                  worldInternal._routeError(err, {
+                    severity: Severity.Error,
+                    systemName: `RenderSystem.extract (_materialWalk: ${err.code})`,
+                  });
+              }
+              continue;
+            }
+            const resolved = resolvedResult.value;
+            const allPasses = resolved.passes;
+            const firstPassShader =
+              allPasses.length > 0
+                ? runtimeMaterialShaderId(allPasses[0]?.program.module, allPasses[0]?.name)
+                : undefined;
+            const pv = materialValuesToLinearRuntime(
+              resolved.values,
+              materialColorParameterSchema(resolved.parameters ?? [], firstPassShader, assets),
+              resolved.colorSpace,
+            ) as Readonly<Record<string, unknown>>;
+
+            const baseColorPv = pv.baseColor as readonly number[] | undefined;
+            const baseColor = vec3.create(
+              baseColorPv?.[0] ?? 1,
+              baseColorPv?.[1] ?? 1,
+              baseColorPv?.[2] ?? 1,
+            );
+            const metallicPv = typeof pv.metallic === 'number' ? pv.metallic : 0;
+            const roughnessPv = typeof pv.roughness === 'number' ? pv.roughness : 0.5;
+            const clearcoatPv = typeof pv.clearcoat === 'number' ? pv.clearcoat : 0;
+            const clearcoatRoughnessPv =
+              typeof pv.clearcoatRoughness === 'number' ? pv.clearcoatRoughness : 0.5;
+            const specularTintPv = pv.specularTint as readonly number[] | undefined;
+            const normalScalePv = materialNormalScale(pv);
+
+            const paramSnap: Record<string, number | number[] | string> = {};
+            for (const [k, v] of Object.entries(pv)) {
+              if (typeof v === 'number') paramSnap[k] = v;
+              else if (typeof v === 'string') paramSnap[k] = v;
+              else if (Array.isArray(v) && v.every((x) => typeof x === 'number')) {
+                paramSnap[k] = v as number[];
+              }
+            }
+
+            const materialParamSchema = materialParametersToParamSchema(
+              resolved.parameters ?? [],
+              firstPassShader,
+            );
+            // feat-20260611-fox-skinning-vertex-attribute-chain M4 / w17 (D-5):
+            // bidirectional Skin <-> pbr-skin material fail-fast at extract.
+            // Skin component without a forgeax::pbr-skin first-pass material
+            // would draw with a non-skin shader against the 18-float vertex
+            // buffer (joints/weights bytes interpreted as garbage). Conversely
+            // a forgeax::pbr-skin material against a 12-float (unskinned) mesh
+            // would have @location(4)/@location(5) read uninitialized memory.
+            // Both cases route through `_routeError` + `continue` so a single
+            // misconfigured entity does NOT abort the whole frame's draw list
+            // (charter P3 explicit failure + plan-decisions D-5 over `return err`).
+            {
+              const hasSkinSkel =
+                hasSkin &&
+                skinSkeletonView !== undefined &&
+                skinSkeletonView !== undefined &&
+                skinSkeletonView !== 0;
+              const isPbrSkinMaterial = firstPassShader === 'forgeax::pbr-skin';
+              if (hasSkinSkel && !isPbrSkinMaterial) {
+                worldInternal._routeError(new SkinMaterialMismatchError(entity, firstPassShader), {
+                  severity: Severity.Error,
+                  systemName: 'RenderSystem.extract (skin-material-mismatch)',
+                });
+                continue;
+              }
+              if (isPbrSkinMaterial && fAssetHandleVal !== undefined && fAssetHandleVal !== 0) {
+                const meshHandleForSkinCheck = toShared<'MeshAsset'>(fAssetHandleVal);
+                const meshResForSkinCheck = resolveAssetHandle<MeshAsset>(
+                  world,
+                  meshHandleForSkinCheck,
+                );
+                if (meshResForSkinCheck.ok) {
+                  const meshAttrs = meshResForSkinCheck.value.attributes;
+                  const hasSkinIdx = meshAttrs.skinIndex !== undefined;
+                  const hasSkinWt = meshAttrs.skinWeight !== undefined;
+                  if (!hasSkinIdx || !hasSkinWt) {
+                    const missing: 'skinIndex' | 'skinWeight' | 'both' =
+                      !hasSkinIdx && !hasSkinWt ? 'both' : !hasSkinIdx ? 'skinIndex' : 'skinWeight';
+                    worldInternal._routeError(new MaterialSkinAttrMissingError(entity, missing), {
+                      severity: Severity.Error,
+                      systemName: 'RenderSystem.extract (material-skin-attr-missing)',
+                    });
+                    continue;
+                  }
+                }
+              }
+            }
+            // feat-20260625-refactor-sprite-as-transparent-mesh M3 / w12 (D-3):
+            // sprite materials now flow through the same generic paramSchema-
+            // driven extract path PBR / unlit use. The narrow `forgeax::sprite`
+            // exception block below covers exactly 2 plan-authorised cases:
+            //   1. SpriteRegionOverride per-entity region displacement (Q4=a)
+            //   2. flipX / flipY -> region fold (plan-strategy D-8)
+            // No legacy values field-name shim; demos and SpriteParamValues
+            // are UBO-aligned (no `texture` / `baseColor` / `pivot` / `slices`
+            // / `sliceMode` keys reaching this code path). AGENTS.md §Change
+            // stance: "no shim layer, no v1/v2 dual-path".
+            //
+            // feat-20260624 M1' / t6: `'forgeax::sprite-lit'` walks the same
+            // sprite-family vertex path (VsOut byte-identical, paramSchema
+            // mirror) so the SAME 2 folds apply — extending `isSprite` to
+            // cover both shader ids keeps the narrowing-point count at 1
+            // (plan-strategy §1.6 + D-1: mirror sprite, no new branch).
+            const isSprite =
+              firstPassShader === 'forgeax::sprite' || firstPassShader === 'forgeax::sprite-lit';
+
+            // feat-20260613-material-paramschema-driven-binding M4 / w23
+            // (D-5 graceful): paramSchema-driven texture-field validation.
+            // For each handle-shaped paramValue (typeof === 'number'),
+            // verify it actually points at a registered texture asset
+            // when the field is declared as a texture in the shader's
+            // paramSchema; mis-typed handles (e.g. a scalar f32 stored as
+            // int 0 the M4 / w22 graceful fallback resolved to a wrong
+            // sub-asset) are dropped here so the record stage falls back
+            // to MISSING_TEXTURE_HANDLE (default white) without raising.
+            const validateTextureHandle = (
+              fieldName: string,
+              raw: unknown,
+            ): Handle<'TextureAsset', 'shared'> | undefined => {
+              // feat-20260614 M8 (D-19): a string value is an embedded texture
+              // GUID; resolve it to a column handle via catalog + allocSharedRef
+              // before validation. A number is an already-minted column handle.
+              let handle: Handle<'TextureAsset', 'shared'>;
+              const textureRef = materialTextureRef(raw);
+              const textureGuid = assetReferenceText(textureRef);
+              if (textureGuid !== undefined) {
+                if (assets === null || assets === undefined) return undefined;
+                // M4: intern so the GUID mints one stable handle per World
+                // instead of a fresh slot every frame (GPU residency relies on
+                // a stable handleSlot). onLastRelease -> gpuStore.evictTexture.
+                const interned = internSharedRefFromGuid(
+                  world,
+                  assets,
+                  textureGuid,
+                  'TextureAsset',
+                );
+                if (interned === undefined) return undefined;
+                handle = interned;
+              } else if (typeof textureRef === 'number') {
+                handle = toShared<'TextureAsset'>(textureRef);
+              } else {
+                return undefined;
+              }
+              if (assets === null || assets === undefined) return handle;
+              const declaredFields = materialTextureFields(
+                firstPassShader,
+                materialParamSchema.length > 0
+                  ? derive(materialParamSchema).textureFieldNames
+                  : firstPassShader !== undefined
+                    ? assets.materialShaderTextureFieldNames(firstPassShader)
+                    : undefined,
+              );
+              // Shader not registered (R-4 cross-worktree path) -> trust the
+              // raw handle and let the record stage / GPU layer surface each
+              // mismatch via MISSING_TEXTURE_HANDLE.
+              if (declaredFields === undefined) return handle;
+              // Field is not declared as a texture by the shader -> the
+              // loader's "try every int" fallback misclassified a scalar;
+              // drop the slot so the record stage uses the default white.
+              if (
+                !declaredFields.has(fieldName) &&
+                !isEngineInjectedTextureField(firstPassShader, fieldName)
+              ) {
+                return undefined;
+              }
+              // Field declared as texture: verify the handle's asset kind.
+              const assetRes = resolveAssetHandle(world, handle);
+              if (!assetRes.ok) return undefined;
+              const kind = (assetRes.value as { kind?: string }).kind;
+              if (kind !== 'texture') return undefined;
+              return handle;
+            };
+            // feat-20260614 M8 (D-19): resolve a sampler / texture paramValue
+            // that may be an embedded GUID string (catalog + allocSharedRef) or
+            // an already-minted column handle (number passthrough).
+            const resolveParamHandle = <B extends string>(
+              raw: unknown,
+              brand: B,
+            ): Handle<B, 'shared'> | undefined => {
+              const value = materialTextureRef(raw);
+              if (typeof value === 'number') return toShared<B>(value);
+              const guid = assetReferenceText(value);
+              if (guid !== undefined) {
+                if (assets === null || assets === undefined) return undefined;
+                // M4: intern the GUID -> column-handle resolution (one stable
+                // handle per (world, guid, brand), reused across frames).
+                return internSharedRefFromGuid(world, assets, guid, brand);
+              }
+              return undefined;
+            };
+            // feat-20260621-learn-render-5-5-parallax M2 / w7 (D-3): iterate the
+            // shader's derive(paramSchema).textureFieldNames SSOT so the Nth
+            // user-region texture (e.g. parallax heightTexture) is validated +
+            // carried, replacing the hardcoded 3-field list. validateTextureHandle
+            // already drops fields a shader doesn't declare as a texture.
+            const userRegionFields =
+              materialTextureFields(
+                firstPassShader,
+                materialParamSchema.length > 0
+                  ? derive(materialParamSchema).textureFieldNames
+                  : firstPassShader !== undefined && assets !== null && assets !== undefined
+                    ? assets.materialShaderTextureFieldNames(firstPassShader)
+                    : undefined,
+              ) ?? BUILTIN_USER_REGION_TEXTURE_FIELDS;
+            const textureHandles = new Map<string, Handle<'TextureAsset', 'shared'>>();
+            const videoTextureFields = new Map<string, Handle<'VideoAsset', 'shared'>>();
+            for (const field of userRegionFields) {
+              // D-5: a video-kind paramValue routes to the transient path
+              // (videoTextureFields), NOT validateTextureHandle (which drops
+              // kind!=='texture', the R-7 silent-fail path). Static fields fall
+              // through to validateTextureHandle unchanged.
+              const videoHandle =
+                assets !== null && assets !== undefined
+                  ? resolveVideoFieldHandle(pv[field], world, assets)
+                  : undefined;
+              if (videoHandle !== undefined) {
+                videoTextureFields.set(field, videoHandle);
+                continue;
+              }
+              const handle = validateTextureHandle(field, pv[field]);
+              if (handle !== undefined) textureHandles.set(field, handle);
+            }
+            const baseColorTextureHandle = textureHandles.get('baseColorTexture');
+            const metallicRoughnessTextureHandle = textureHandles.get('metallicRoughnessTexture');
+            const normalTextureHandle = textureHandles.get('normalTexture');
+            const samplerHandles = collectMaterialTextureSamplers(pv, (value) =>
+              resolveParamHandle(materialTextureRef(value), 'SamplerAsset'),
+            );
+            const emissiveTextureHandle = validateTextureHandle(
+              'emissiveTexture',
+              pv.emissiveTexture,
+            );
+            const occlusionTextureHandle = validateTextureHandle(
+              'occlusionTexture',
+              pv.occlusionTexture,
+            );
+            const textureCoordinates = collectMaterialTextureCoordinates(pv);
+            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
+            // LDR split + premultiplied-alpha blend decision without
+            // re-reading passes[]. feat-20260626-collapse M2: derive from
+            // `passes[0].renderState.blend !== undefined` (blend presence is
+            // the SSOT after MaterialPass.transparent was dropped).
+            // Result is plain boolean (always defined here) — written as-is
+            // into the snapshot (`boolean | undefined` field, see L759).
+            const firstPassTransparent: boolean = allPasses[0]?.renderState?.blend !== undefined;
+
+            // feat-20260625-refactor-sprite-as-transparent-mesh M3 / w12 (D-8):
+            // narrow `forgeax::sprite` extract block --- folds the legacy user
+            // values format (flipX / flipY / slices / sliceMode + free
+            // region / pivot) into the UBO-aligned paramSnapshot vec4 fields
+            // (region / pivotAndSize / slicesAndMode + colorTint). Also folds
+            // per-entity SpriteRegionOverride (Q4=a). After this block the
+            // generic else branch picks up the snapshot via the same writer
+            // path PBR / unlit use; no more shadingModel='sprite' arm, no
+            // spriteFields POD (AC-02 / AC-07: extract has exactly 2 hard
+            // `forgeax::sprite` checks --- this fold + the slices mesh swap on
+            // the record side).
+            if (isSprite) {
+              // SpriteRegionOverride: per-entity per-frame region displacement.
+              let overrideRegion: readonly [number, number, number, number] | undefined;
+              if (hasSpriteRegionOverride) {
+                const overrideView = worldInternal._getArrayView(
+                  entity,
+                  SpriteRegionOverride,
+                  'region',
+                ) as Float32Array | undefined;
+                if (overrideView !== undefined && overrideView.length >= 4) {
+                  overrideRegion = [
+                    overrideView[0] ?? 0,
+                    overrideView[1] ?? 0,
+                    overrideView[2] ?? 1,
+                    overrideView[3] ?? 1,
+                  ];
+                }
+              }
+              // Region resolution priority: SpriteRegionOverride > paramSnapshot.
+              // region (UBO-aligned user input) > [0,0,1,1] identity.
+              const regionPv = paramSnap.region as readonly number[] | undefined;
+              let regionX = overrideRegion?.[0] ?? regionPv?.[0] ?? 0;
+              let regionY = overrideRegion?.[1] ?? regionPv?.[1] ?? 0;
+              let regionZ = overrideRegion?.[2] ?? regionPv?.[2] ?? 1;
+              let regionW = overrideRegion?.[3] ?? regionPv?.[3] ?? 1;
+              // flipX / flipY fold into region (D-8): the shader does
+              // `uv * region.zw + region.xy`, so flipping along U is a sign
+              // negation of region.z plus an origin offset.
+              const flipXPv = typeof pv.flipX === 'number' ? pv.flipX : 0;
+              const flipYPv = typeof pv.flipY === 'number' ? pv.flipY : 0;
+              if (flipXPv !== 0) {
+                regionX += regionZ;
+                regionZ = -regionZ;
+              }
+              if (flipYPv !== 0) {
+                regionY += regionW;
+                regionW = -regionW;
+              }
+              paramSnap.region = [regionX, regionY, regionZ, regionW];
+              // Guard: slicesAndMode must be present and zero for non-9-slice
+              // sprites so the record-stage UBO writer (applyParamSnapshotToUbo)
+              // writes [0,0,0,0] at offset 48 instead of leaving the
+              // buildPbrMaterialUboPayload PBR baseline (e.g. occlusionStrength=1
+              // at that slot). A non-zero slicesAndMode trips `useSlices=true`
+              // in sprite.wgsl, which degenerates HANDLE_QUAD geometry → invisible.
+              if (!('slicesAndMode' in paramSnap)) {
+                (paramSnap as Record<string, unknown>).slicesAndMode = [0, 0, 0, 0];
+              }
+            }
+
+            // Generic materialShaderId snapshot --- sprite included now flows
+            // through this single branch (plan-strategy D-3 / AC-01 / AC-02 /
+            // AC-07). The sprite block above only writes paramSnap.region (D-8
+            // SpriteRegionOverride + flip fold); the rest of the UBO is filled
+            // by the same paramSchema-driven path PBR / unlit use.
+            materialSnap = {
+              baseColor,
+              metallic: metallicPv,
+              roughness: roughnessPv,
+              clearcoat: clearcoatPv,
+              clearcoatRoughness: clearcoatRoughnessPv,
+              ...(specularTintPv !== undefined && {
+                specularTint: [
+                  specularTintPv[0] ?? 1,
+                  specularTintPv[1] ?? 1,
+                  specularTintPv[2] ?? 1,
+                ] as readonly [number, number, number],
+              }),
+              normalScale: normalScalePv,
+              materialShaderId: firstPassShader,
+              materialHandle: handleRaw,
+              renderState: pipelineRenderState(allPasses[0]?.renderState),
+              paramSnapshot: paramSnap,
+              ...(materialParamSchema.length > 0 && { materialParamSchema }),
+              ...(textureCoordinates.size > 0 && { textureCoordinates }),
+              ...(samplerHandles.size > 0 && { samplerHandles }),
+              ...(textureHandles.size > 0 && { textureHandles }),
+              ...(videoTextureFields.size > 0 && { videoTextureFields }),
+              ...(baseColorTextureHandle !== undefined && {
+                baseColorTexture: baseColorTextureHandle,
+              }),
+              ...(metallicRoughnessTextureHandle !== undefined && {
+                metallicRoughnessTexture: metallicRoughnessTextureHandle,
+              }),
+              ...(normalTextureHandle !== undefined && { normalTexture: normalTextureHandle }),
+              ...(emissivePv !== undefined && {
+                emissive: [emissivePv[0] ?? 0, emissivePv[1] ?? 0, emissivePv[2] ?? 0] as readonly [
+                  number,
+                  number,
+                  number,
+                ],
+              }),
+              ...(typeof pv.emissiveIntensity === 'number' && {
+                emissiveIntensity: pv.emissiveIntensity,
+              }),
+              ...(emissiveTextureHandle !== undefined && {
+                emissiveTexture: emissiveTextureHandle,
+              }),
+              ...(occlusionTextureHandle !== undefined && {
+                occlusionTexture: occlusionTextureHandle,
+              }),
+              ...(typeof pv.occlusionStrength === 'number' && {
+                occlusionStrength: pv.occlusionStrength,
+              }),
+              transparent: firstPassTransparent,
+            };
+
+            if (!hasSpriteRegionOverride && !hasSkin) {
+              const stored = storeMaterialSnapshot(
+                materialSnapshotCache,
+                handleRaw,
+                materialSnap,
+                allPasses,
+                asset,
+                assets,
+              );
+              if (stored.crossFrameSafe) persistentMaterialSnapshotCache?.set(handleRaw, stored);
+            }
+
+            // Build dispatch entries from resolved passes.
+            if (isRenderable) {
+              appendMaterialDispatchEntries(
+                pendingDispatch,
+                allPasses,
+                entity,
+                handleRaw,
+                renderables.length,
+                layerVal,
+                paramSnap,
+              );
+            }
+          }
+        }
+      }
+
+      // feat-20260609 M2/M5 corrective fixup: default-material entities
+      // (handleRaw===0 / case-B MeshRenderer{data:{}}) must produce
+      // ShadowCaster dispatch entries so the shadow pass includes them.
+      // The pre-existing logic only builds dispatch entries from
+      // resolved material assets; defaultMaterialSnapshot() (mid-grey unlit)
+      // left dispatch empty, causing shadow-m2/m3 test failures.
+      // Requirements §10.5: shadow-casting is default behaviour, opt-out
+      // via castShadow:false.  The default material has no opt-out, so
+      // it casts shadows.
+      //
+      // CHARTER NOTE (feat-20260609 T-005-a): the URP literals
+      // `LightMode: 'ShadowCaster'` / `LightMode: 'Forward'` below are a
+      // local URP-bridge — they mirror what `Materials.unlit({ castShadow:
+      // true })` produces at the asset layer.  The default-material
+      // handle=0 path bypasses asset registration, so we synthesize the
+      // same dispatch shape inline.  Follow-up cleanup (F-1 from
+      // implement-review R1): thread default materials through the
+      // Materials factory so this block can call into the shared
+      // passes[] producer.
+      // tweak-20260701 M1: `materialSnap.shadingModel === 'unlit'` removed —
+      // for handleRaw===0, defaultMaterialSnapshot() was always unlit
+      // (the shadingModel check was a tautology); the isRenderable &&
+      // handleRaw===0 guard alone preserves the exact same dispatch shape.
+      if (isRenderable && handleRaw === 0) {
+        const shadowCasterTags: Record<string, string> = { LightMode: 'ShadowCaster' };
+        const nextRenderableIndex = renderables.length;
+        // M2.5: stage into pendingDispatch; flushed at the renderable push
+        // site below only when the entity survives cull.
+        pendingDispatch.push({
+          entityIndex: entity,
+          materialHandle: 0,
+          renderableIndex: nextRenderableIndex,
+          passIndex: 0,
+          queue: 2000,
+          layer: layerVal,
+          tags: shadowCasterTags,
+          renderState: undefined,
+          defines: undefined,
+          vertexEntry: 'vs_main',
+          fragmentEntry: undefined,
+          materialShaderId: 'forgeax::default-shadow-caster',
+          paramSnapshot: {},
+        });
+        // Also add a Forward pass entry so the entity renders in the
+        // main scene pass (mirrors Materials.unlit default).
+        appendMaterialDispatchEntries(
+          pendingDispatch,
+          [DEFAULT_FORWARD_PASS],
+          entity,
+          0,
+          nextRenderableIndex,
+          layerVal,
+          {},
+          1,
+        );
+      }
+
+      if (isRenderable) {
+        // feat-20260612 M2 / m2-6: Skin + Instances coexistence + per-joint
+        // dangling fail-fast + real palette slice allocation. Replaces the
+        // T-21 placeholder ({0,0} discriminator-only sentinel) with full
+        // resolve / validate / write chain (D-9 reset already fired at
+        // extractFrame entry; per-entity allocate + writeJointPalette here).
+        let skinSlice: SkinPaletteSlice | undefined;
+        if (hasSkin) {
+          const skeletonHandleRaw = skinSkeletonView;
+          if (
+            skeletonHandleRaw !== undefined &&
+            skeletonHandleRaw !== 0 &&
+            assets !== undefined &&
+            assets !== null
+          ) {
+            // Skin + Instances coexistence is forbidden (D-10).
+            if (hasInstances) {
+              worldInternal._routeError(new SkinInstancesCoexistForbiddenError(entity), {
+                severity: Severity.Error,
+                systemName: 'RenderSystem.extract (skin-instances-coexist)',
+              });
+
+              continue;
+            }
+            // (a) Resolve skeleton asset; on failure -> skeleton-resolve-failed.
+            const skeletonHandle = toShared<'SkeletonAsset'>(skeletonHandleRaw);
+            const skeletonRes = resolveAssetHandle<SkeletonAsset>(world, skeletonHandle);
+            if (!skeletonRes.ok || skeletonRes.value.kind !== 'skeleton') {
+              worldInternal._routeError(new SkeletonResolveFailedError(entity, skeletonHandleRaw), {
+                severity: Severity.Error,
+                systemName: 'RenderSystem.extract (skeleton-resolve-failed)',
+              });
+              continue;
+            }
+            const skeleton = skeletonRes.value;
+            // (b) Reuse the Skin row already read for its skeleton handle;
+            // the old path repeated a second whole-row world.get here.
+            const skinJoints = skin?.joints;
+            if (skinJoints === undefined) continue;
+            const jointsLength = skinJoints.length;
+            if (jointsLength !== skeleton.jointCount) {
+              worldInternal._routeError(
+                new JointCountMismatchError(entity, skeleton.jointCount, jointsLength),
+                {
+                  severity: Severity.Error,
+                  systemName: 'RenderSystem.extract (joint-count-mismatch)',
+                },
+              );
+              continue;
+            }
+            // (c) Resolve only each joint's Transform.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.
+            // Build mat4 list eagerly so write happens once per entity (no
+            // half-written slice on dangling).
+            const jointWorlds = new Array<Mat4>(skeleton.jointCount);
+            let jointDangling = -1;
+            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');
+              if (jointWorld === undefined) {
+                jointDangling = jIdx;
+                break;
+              }
+              // The allocator consumes the canonical Mat4 brand. Copy the
+              // column view into that owner-created value so the ECS storage
+              // view never crosses the math brand boundary by assertion.
+              const jointWorldMat = mat4.create();
+              jointWorldMat.set(jointWorld);
+              jointWorlds[jIdx] = jointWorldMat;
+            }
+            if (jointDangling >= 0) {
+              worldInternal._routeError(new JointEntityDanglingError(entity, jointDangling), {
+                severity: Severity.Error,
+                systemName: 'RenderSystem.extract (joint-entity-dangling)',
+              });
+              continue;
+            }
+            // (d) Slice the IBM flat Float32Array into per-joint Float32Arrays.
+            //     skeleton.inverseBindMatrices length === jointCount * 16.
+            const ibmFlat = skeleton.inverseBindMatrices;
+            const ibms: Float32Array[] = new Array<Float32Array>(skeleton.jointCount);
+            for (let jIdx = 0; jIdx < skeleton.jointCount; jIdx++) {
+              ibms[jIdx] = ibmFlat.subarray(jIdx * 16, jIdx * 16 + 16);
+            }
+            // (e) Allocate slice + write palette via the allocator (D-9 reset
+            // already fired at extractFrame entry). When the pipelineState
+            // surface is absent (test fixtures that pass undefined) the
+            // hasSkin segment is skipped silently — bind-pose equivalent.
+            if (skinPaletteAllocator !== null) {
+              const slice = skinPaletteAllocator.allocateSlice(skeleton.jointCount);
+              skinPaletteAllocator.writeJointPalette(slice, ibms, jointWorlds);
+              skinSlice = {
+                jointCount: slice.jointCount,
+                byteOffset: slice.byteOffset,
+                buffer: slice.buffer,
+              };
+            }
+          }
+        }
+
+        // feat-20260601 D-3: read the resolved world mat4 (propagateTransforms
+        // output) straight from the Transform.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');
+        if (worldView === undefined) continue;
+        const worldMat = new Float32Array(worldView);
+        const transformSnap: TransformSnapshot = { world: worldMat };
+        // feat-20260608 M5 amend / w11-a: per-submesh `materials[]` array
+        // aligned 1-1 with `MeshAsset.submeshes[]`. materials[0] === the
+        // representative entity-level snapshot already built; materials[i>=1]
+        // are resolved via `resolveMaterialSnapshot` (a non-sprite, single-
+        // pass-equivalent resolver — sprite per-submesh is OOS-1). When the
+        // entity has no materialsView (case-B sentinel) the array is a single
+        // mid-grey default mirroring the legacy single-material path so the
+        // record stage's per-submesh UBO upload loop trivially writes one
+        // slot, no special branch.
+        const materialsArr: MaterialSnapshot[] = [materialSnap];
+        if (assets !== undefined && assets !== null) {
+          for (let mi = 1; mi < materialHandles.length; mi++) {
+            const subHandle = materialHandles[mi] ?? 0;
+            const cachedSubmaterial = materialSnapshotCache.get(subHandle);
+            materialsArr.push(
+              cachedSubmaterial?.snapshot ??
+                resolveMaterialSnapshot(
+                  subHandle,
+                  world,
+                  assets,
+                  materialSnapshotCache,
+                  persistentMaterialSnapshotCache,
+                ),
+            );
+          }
+        }
+        if (isRenderable && assets !== undefined && assets !== null) {
+          for (let mi = 1; mi < materialHandles.length; mi++) {
+            const subHandle = materialHandles[mi] ?? 0;
+            if (subHandle === handleRaw) continue;
+            const subEntry =
+              materialSnapshotCache.get(subHandle) ??
+              readPersistentMaterialSnapshot(persistentMaterialSnapshotCache, subHandle, assets);
+            appendMaterialDispatchEntries(
+              pendingDispatch,
+              subEntry?.passes ?? (subHandle === 0 ? [DEFAULT_FORWARD_PASS] : []),
+              entity,
+              subHandle,
+              renderables.length,
+              layerVal,
+              materialsArr[mi]?.paramSnapshot,
+            );
+          }
+        }
+
+        // feat-20260625-sprite-instances-and-tilemap-terrain-static-batch M3 /
+        // w10: SpriteInstances validation + snapshot materialisation.
+        // Three structured EcsError fires at this single point (plan-strategy
+        // D-6 "fail-fast at the render domain entry, not at ECS spawn-time"):
+        let spriteInstancesSnap: SpriteInstancesSnapshot | undefined;
+        if (hasSpriteInstances) {
+          // (1) mutually exclusive with Instances (peers — pick one).
+          if (hasInstances) {
+            worldInternal._routeError(
+              new SpriteInstancesMutuallyExclusiveWithInstancesError(entity),
+              {
+                severity: Severity.Error,
+                systemName: 'RenderSystem.extract (sprite-instances-mutually-exclusive)',
+              },
+            );
+            continue;
+          }
+          // (2) requires sprite shader — the per-instance UV region is
+          // consumed by the sprite vertex shader path only (plan-strategy D-4
+          // axis on sprite.wgsl). Post-collapse (PR #520): sprite is no longer
+          // a `shadingModel` enum member; identification is via the first-pass
+          // `materialShaderId === 'forgeax::sprite'` (OOS-1 path retained).
+          //
+          // feat-20260624 M1' / t6: `'forgeax::sprite-lit'` also walks the same
+          // per-instance UV region vertex path (VsOut byte-identical, paramSchema
+          // mirror); accept either shader id.
+          if (
+            materialSnap.materialShaderId !== 'forgeax::sprite' &&
+            materialSnap.materialShaderId !== 'forgeax::sprite-lit'
+          ) {
+            worldInternal._routeError(
+              new SpriteInstancesRequiresSpriteShaderError(
+                entity,
+                materialSnap.materialShaderId ?? 'undefined',
+              ),
+              {
+                severity: Severity.Error,
+                systemName: 'RenderSystem.extract (sprite-instances-requires-sprite-shader)',
+              },
+            );
+            continue;
+          }
+          // (3) count mismatch — transforms.length / 16 === regions.length / 4
+          // (transforms.length=0 + regions.length=0 is the zero-instance lawful
+          // boundary; both derivations are 0 and equality holds, so no fire).
+          const transforms = worldInternal._getArrayView(entity, SpriteInstances, 'transforms');
+          const regions = worldInternal._getArrayView(entity, SpriteInstances, 'regions');
+          if (transforms !== undefined && regions !== undefined) {
+            const transformsLength = transforms.length;
+            const regionsLength = regions.length;
+            // Stride sanity: transforms must be mod 16, regions must be mod 4.
+            // A stride violation expresses as a count mismatch under the
+            // canonical derivation transforms/16 vs regions/4 — fire the
+            // count-mismatch code (the same code carries detail.expectedStride).
+            const tCount = transformsLength / 16;
+            const rCount = regionsLength / 4;
+            if (transformsLength % 16 !== 0 || regionsLength % 4 !== 0 || tCount !== rCount) {
+              worldInternal._routeError(
+                new SpriteInstancesCountMismatchError(transformsLength, regionsLength),
+                {
+                  severity: Severity.Error,
+                  systemName: 'RenderSystem.extract (sprite-instances-count-mismatch)',
+                },
+              );
+              continue;
+            }
+            // Validation passes — build the snapshot. transforms.length === 0
+            // is lawful (zero-instance) and produces instanceCount=0; the
+            // record stage skips drawIndexed when instanceCount===0.
+            const transformsCopy = new Float32Array(transforms);
+            const regionsCopy = new Float32Array(regions);
+            spriteInstancesSnap = {
+              transforms: transformsCopy,
+              regions: regionsCopy,
+              instanceCount: tCount,
+              cacheKey: entity,
+              archVersion,
+            };
+          }
+        }
+
+        let localAabb: Float32Array | 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;
+            morph = morphSnapshotFor(meshAsset, morphWeightsView);
+            const meshAabb = meshAsset.aabb;
+            // Morph targets can expand the authored bounds. Keep the
+            // specialized lane conservative until a target-aware bounds
+            // projection is available; a false-positive draw is preferable
+            // to culling a valid deformed vertex.
+            if (morph === undefined && hasFiniteOrderedLocalAabb(meshAabb)) {
+              localAabb = new Float32Array(meshAabb);
+            }
+          }
+        }
+
+        const pointsLinesStyle: PointsLinesStyle | undefined =
+          points !== undefined
+            ? (() => {
+                const shape = pointShapeFromU32(points.shape);
+                return shape === undefined
+                  ? undefined
+                  : { kind: 'points' as const, sizePx: points.sizePx, shape };
+              })()
+            : lines === undefined
+              ? undefined
+              : { kind: 'lines' as const, widthPx: lines.widthPx };
+        const cullingLocalAabb = expandPointsLinesBounds(localAabb ?? [], pointsLinesStyle);
+        const pointsLines =
+          pointsLinesComponent === undefined
+            ? undefined
+            : ({
+                worldId: 0,
+                entityKey: entity,
+                component: pointsLinesComponent,
+                meshHandle: assetHandleRaw,
+                meshGeneration: assets?.catalogEpoch ?? 0,
+                materialHandle: handleRaw,
+                materialGeneration: assets?.catalogEpoch ?? 0,
+                style: pointsLinesStyle,
+                layer: layerVal,
+                sortKey,
+                visible: true,
+                sourceBounds: cullingLocalAabb,
+                viewport: { width: 0, height: 0, dpr: 1 },
+                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),
+            },
+          ];
+        });
+        const baseRenderable: RenderableSnapshot = {
+          assetHandle: Math.round(fAssetHandle ?? 0),
+          transform: transformSnap,
+          ...(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 } : {}),
+          ...(spriteInstancesSnap !== undefined ? { spriteInstances: spriteInstancesSnap } : {}),
+          ...(pointsLines !== undefined ? { pointsLines } : {}),
+        };
+
+        // feat-20260528-frustum-culling M3 / w10: frustum culling check.
+        // Skip the entity if a valid AABB exists AND ALL cameras' frusta
+        // reject the world-space AABB. Missing or malformed AABBs are
+        // conservative always-visible fallbacks; valid culling bounds are
+        // 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);
+          } 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);
+            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);
+        }
+      }
+
+      // feat-20260520-2d-sprite-layer-mvp M-3 / w22 + w25: finalise the
+      // pending TransparentEntry with the renderableIndex pointing at the
+      // RenderableSnapshot we just pushed (when isRenderable === true).
+      // The check below also covers a sprite entity that survives the
+      // dangling-Instances branch (silent skip with `dispatchEntry !==
+      // null` early-continue) — in that case renderableIndex is still set
+      // to the just-pushed slot which is correct because materialDispatch
+      // already captures the dispatch position.
+    }
+  }
+
+  // M3 / w26: sort dispatch entries by queue (ascending, stable sort)
+  // per plan-strategy D-3.
+  dispatch = sortDispatchByQueue(dispatch);
+
+  // D-1: collect PostProcessParams entities into Map<shaderId, Uint8Array>.
+  // Last-one-wins when multiple entities bear the same shader id (mirrors
+  // Camera.exposure -> CameraSnapshot pattern; extract stage only reads).
+  const postProcessParams: Map<string, Uint8Array> = new Map();
+  const postProcessParamsQuery = world.query({ with: [PostProcessParams] }).unwrap();
+  for (const row of postProcessParamsQuery) {
+    const entity = row.entity;
+    const read = world.get(entity, PostProcessParams);
+    if (!read.ok) continue;
+    postProcessParams.set(read.value.shader, read.value.data);
+  }
+
+  // feat-20260621 M-A3 / w13 (D-5): engine built-in tonemap data-driven
+  // provider. The engine bridges the active camera's `Camera.exposure /
+  // 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
+  // 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.
+  const tonemapCamera = cameras[0];
+  if (tonemapCamera !== undefined) {
+    postProcessParams.set(STANDARD_TONEMAP_FEATURE_ID, tonemapParams(tonemapCamera));
+  }
+
+  return {
+    cameras,
+    lights,
+    renderables,
+    dispatch,
+    skylight,
+    skylightCount,
+    skybox,
+    skyboxCount,
+    frustumStats: { culled: frustumCulled, total: frustumTotal },
+    visibilityStats: { explicitlyHidden: explicitlyHidden.size },
+    postProcessParams,
+    visibilitySnapshots: [context.visibility],
+    featureVisibilitySnapshots: [{ world, snapshot: context.visibility }],
+    hiddenEntityReports: [...explicitlyHidden].map((entity) => ({ world, entity })),
+  };
+}
+
+export function defaultMaterialSnapshot(materialHandle = 0): MaterialSnapshot {
+  // Mid-grey unlit fallback (D-Q7 case B + extract-stage missing-spec),
+  // matching the pre-w6 visual outcome where the record stage's force-cast
+  // read of `firstMaterial.baseColorTexture` returned undefined and the
+  // unlit fallback shader was selected.
+  return {
+    baseColor: vec3.create(0.5, 0.5, 0.5),
+    metallic: 0,
+    roughness: 1,
+    materialHandle,
+  };
+}
+
+function identityProjection(): Float32Array {
+  const projection = new Float32Array(16);
+  projection[0] = 1;
+  projection[5] = 1;
+  projection[10] = 1;
+  projection[15] = 1;
+  return projection;
+}