@forgeax/engine-render 0.1.4 → 0.1.7

package/src/render-system-extract.ts

@@ -4,9 +4,9 @@
 // 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). Public API
-// unchanged for engine-owned consumers: RenderSystem lives at
-// '@forgeax/engine-render/internal'.
+// 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) +
@@ -77,7 +77,7 @@
 //
 // feat-20260514-ecs-children-instances-managed-buffer-array M3 / w15:
 //   The legacy `Instances { buffer, count }` form (cross-coupled with the
-//   deleted `RenderAssetPort.createInstancedBuffer` triplet + the retired
+//   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
@@ -97,16 +97,23 @@
 // Layer-3 ErrorHandler and the renderable is skipped. The record stage
 // trusts the invariant and does not re-check.
 
-import type { EntityHandle, World } from '@forgeax/engine-ecs';
+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 } from '@forgeax/engine-pack/guid';
+import { AssetGuid, type AssetGuid as AssetGuidBytes } from '@forgeax/engine-pack/guid';
 import { RhiError } from '@forgeax/engine-rhi';
 import {
   MorphWeights,
@@ -114,7 +121,6 @@ import {
   type SceneHierarchySnapshot,
   Transform,
 } from '@forgeax/engine-scene';
-import { DEFAULT_UNLIT_PARAM_SCHEMA } from '@forgeax/engine-shader';
 import {
   JointCountMismatchError,
   JointEntityDanglingError,
@@ -124,11 +130,9 @@ import {
 } from '@forgeax/engine-skinning';
 import type {
   Asset,
-  DerivedMaterialInterface,
   Handle,
   MaterialAsset,
   MaterialColorParameterSchema,
-  MaterialError,
   MaterialParameter,
   MaterialPass,
   MaterialRenderState,
@@ -138,369 +142,66 @@ import type {
   ParamSchemaEntry,
   PrimitiveTopology,
   SkeletonAsset,
-  TextureAsset,
 } from '@forgeax/engine-types';
 import {
   ASSET_ERROR_HINTS,
   AssetError,
   derive,
-  err,
   materialGuidText,
   materialValuesToLinearRuntime,
-  ok,
-  RenderQueue,
-  type Result,
   toShared,
 } from '@forgeax/engine-types';
-import type { RenderAssetPort } from './assets/render-asset-port';
-import { resolveRenderAsset } from './assets/resolve-render-asset';
-
-function reportRenderError(error: unknown, _context?: unknown): never {
-  throw error;
-}
-
 import {
-  type Antialias,
   antialiasFromF32,
-  type BloomEnabled,
   bloomEnabledFromF32,
   Camera,
   cameraProjectionFromF32,
   DirectionalLight,
-  Fog,
   Instances,
   Layer,
+  Lines,
   MeshFilter,
   MeshRenderer,
   PointLight,
   PointLightShadow,
+  Points,
   PostProcessParams,
+  pointShapeFromU32,
   SkyboxBackground,
   Skylight,
+  SortKey,
   SpotLight,
   SpriteInstances,
   SpriteRegionOverride,
-  type Tonemap,
   tonemapFromF32,
   tonemapToU32,
 } from './components';
 import { GlyphText } from './components/glyph-text';
+import { computeInvRangeSquared, degToCos } from './components/light-helpers';
 import {
-  computeInvRangeSquared,
-  degToCos,
-  validateDirectionalLightData,
-  validatePointLightData,
-  validatePointLightShadowData,
-  validateSpotLightData,
-} from './components/light-helpers';
-import {
-  type ExtractedEnvironment,
-  selectEnvironmentSource,
-} from './environment/extracted-environment';
-import {
-  FogOwnerConflictError,
-  FogParametersInvalidError,
   MaterialSkinAttrMissingError,
-  type RenderError,
+  ShadowInvalidConfigError,
   SkinMaterialMismatchError,
 } from './errors/render';
-import {
-  type CsmCameraData,
-  computeDirectionalCsm,
-  type DirectionalCsmConfig,
-  type DirectionalCsmResult,
-  pssmSplit,
-} from './extract/directional-csm';
-import {
-  createMaterialInterfaceOwner,
-  type DerivedMaterialSlotProjection,
-  defaultMaterialTextureCoordinates,
-  deriveMaterialSlotProjection,
-  hasShadowCasterPass,
-  resolveMaterialFromPort,
-} from './extract/material-interface';
-import {
-  deriveParamSchemaForCensus,
-  type ParamSchemaProjectionCensus,
-} from './param-schema-projection-census';
-import {
-  buildRenderCandidateDomain,
-  type RenderCandidateDomain,
-  type RenderDispatchMembership,
-  renderCandidateCsmCandidates,
-} from './render-dispatch-membership';
-
-export {
-  type CascadeVolume,
-  type CascadeVolumeSet,
-  CascadeVolumeSetBuilder,
-  type CsmCameraData,
-  computeDirectionalCsm,
-  type DirectionalCsmConfig,
-  type DirectionalCsmResult,
-  directionalCascadeAtlasSize,
-  directionalCascadeRasterViewport,
-  pssmSplit,
-} from './extract/directional-csm';
-
 import { resolveVisibility, type VisibilitySnapshot } from './extract/visibility';
 import type {
   RenderFeatureHiddenEntityReport,
   RenderFeatureWorldVisibilitySnapshot,
 } from './features/types';
 import { ensureGlyphMeshMaterialSlots } from './glyph-text-layout-system';
-import type { RenderSceneFactInput } from './gpu-scene-schema';
 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';
-
-export interface CameraSnapshot {
-  /** Renderer-local World attachment identity. */
-  readonly worldId: number;
-  /** Packed ECS entity handle; its high bits retain the entity generation. */
-  readonly entityKey: number;
-  /** World-space camera translation (mat4.getTranslation of Transform.world). */
-  readonly position: Vec3;
-  /**
-   * Resolved world-space camera mat4 (column-major 16 floats), copied from the
-   * entity's `Transform.world` view. The record stage derives the view matrix
-   * as `mat4.invert(world)` (feat-20260601 D-3: read world mat4 -> invert; no
-   * recompose from decomposed TRS).
-   */
-  readonly world: Float32Array;
-  readonly fov: number;
-  readonly aspect: number;
-  readonly near: number;
-  readonly far: number;
-  /**
-   * Camera projection variant (`'perspective'` | `'orthographic'`),
-   * surfaced through the closed string-literal union narrowed from the
-   * Camera schema's `projection` f32 discriminator. Drives the CSM
-   * frustum-corner builder in render-system-extract: perspective uses
-   * mat4.perspective(fov, aspect, ...); orthographic uses mat4.ortho
-   * (left, right, bottom, top, ...). Without this discrimination an
-   * orthographic camera (fov=0) would feed a degenerate matrix into
-   * the CSM AABB-fit and the shadow atlas would never be written
-   * (feat-20260613 M6 / w20 fix).
-   */
-  readonly projection: 'perspective' | 'orthographic';
-  /** Orthographic left frustum plane (only consumed when projection === 'orthographic'). */
-  readonly orthoLeft: number;
-  /** Orthographic right frustum plane. */
-  readonly orthoRight: number;
-  /** Orthographic bottom frustum plane. */
-  readonly orthoBottom: number;
-  /** Orthographic top frustum plane. */
-  readonly orthoTop: number;
-  /**
-   * feat-20260519-tonemap-reinhard-mvp / M3 / T-M3.1: tone-map mode
-   * surfaced through the closed string-literal union (`tonemapFromF32`
-   * narrows the schema's `f32` discriminator). The record stage branches
-   * on this field to pick the geometry pipeline target format
-   * (`bgra8unorm-srgb` for `'none'` / `'rgba16float'` for
-   * `'reinhard-extended'`) and to decide whether to emit the post-process
-   * tonemap fullscreen pass.
-   */
-  readonly tonemap: Tonemap;
-  /** Linear pre-multiplier applied before the luminance compute (T-M3.3). */
-  readonly exposure: number;
-  /** Bright-end break point Lw for the extended Reinhard curve (T-M3.3). */
-  readonly whitePoint: number;
-  /**
-   * feat-20260528-fxaa-post-processing / w3: anti-alias mode surfaced
-   * through the closed string-literal union (antialiasFromF32 narrows
-   * the schema's f32 discriminator). The record stage branches on this
-   * field to decide whether to emit the FXAA post-process pass.
-   */
-  readonly antialias: Antialias;
-  /** Explicit authoring fence for discontinuous view changes. */
-  readonly historyVersion: number;
-  /**
-   * feat-20260531-bloom-first-declarative-render-graph-pass / w4: bloom
-   * enabled discriminator surfaced through the closed string-literal union
-   * (bloomEnabledFromF32 narrows the schema's f32 discriminator). The record
-   * stage branches on this field to decide whether to emit the bloom
-   * post-process pipeline.
-   */
-  readonly bloom: BloomEnabled;
-  /** HDR luminance threshold for bright-pass extraction (D-3 default 1.0). */
-  readonly bloomThreshold: number;
-  /** Multiplier applied to the blurred bloom contribution in composite (D-3 default 1.0). */
-  readonly bloomIntensity: number;
-  /** Gaussian blur kernel radius, clamped [1.0, 4.0] in shader (D-3 default 4.0). */
-  readonly bloomBlurRadius: number;
-  /**
-   * feat-20260709 M3 / D-3: clear-color RGBA sourced from the Camera entity's
-   * inline `array<f32,4>` column (first-archetype-hit per OOS-2). Collapsed
-   * from the feat-20260608 clearR/G/B/A snapshot quartet into one field aligned
-   * with the light snapshot shape. AI users override per-camera by setting
-   * `clearColor` when spawning the Camera entity; default is opaque black
-   * `[0, 0, 0, 1]` (D-5). The record stage reads these values verbatim into
-   * the LoadOp::Clear color slot.
-   */
-  readonly clearColor: readonly [number, number, number, number];
-}
-
-export type RenderVisibilityViewKind = 'main' | 'cascade';
-
-/**
- * One of the four CPU visibility views. Cascade membership is copied from the
- * canonical CascadeVolumeSet; this descriptor never derives a second volume.
- */
-export interface RenderVisibilityViewDescriptor {
-  readonly viewId: string;
-  readonly kind: RenderVisibilityViewKind;
-  readonly cascadeIndex: number | undefined;
-  readonly planes: Float32Array;
-  /** Conservative world AABB used by the persistent spatial owner. */
-  readonly broadphaseWorldAabb?: Float32Array | undefined;
-  /** Canonical raster matrix for a cascade; absent for the main view. */
-  readonly lightViewProj?: Float32Array | undefined;
-  readonly casterCandidateIndices: ReadonlySet<number>;
-  readonly volumeRevision: number | undefined;
-  readonly spatialIndexRevision: number | undefined;
-}
-
-function cameraVisibilityPlanes(camera: CameraSnapshot): Float32Array {
-  if (
-    (camera.projection === 'perspective' && (camera.fov <= 0 || camera.aspect <= 0)) ||
-    !Number.isFinite(camera.near) ||
-    !Number.isFinite(camera.far) ||
-    camera.near >= camera.far
-  ) {
-    return new Float32Array(0);
-  }
-  const projection = mat4.create();
-  if (camera.projection === 'orthographic') {
-    mat4.orthographic(
-      projection,
-      camera.orthoLeft,
-      camera.orthoRight,
-      camera.orthoBottom,
-      camera.orthoTop,
-      camera.near,
-      camera.far,
-    );
-  } else {
-    mat4.perspective(projection, camera.fov, camera.aspect, camera.near, camera.far);
-  }
-  const view = mat4.invert(mat4.create(), camera.world);
-  return frustum.fromViewProjection(
-    frustum.create(),
-    mat4.multiply(mat4.create(), projection, view),
-  );
-}
-
-function cameraVisibilityBroadphaseAabb(camera: CameraSnapshot): Float32Array | undefined {
-  if (
-    (camera.projection === 'perspective' && (camera.fov <= 0 || camera.aspect <= 0)) ||
-    !Number.isFinite(camera.near) ||
-    !Number.isFinite(camera.far) ||
-    camera.near >= camera.far
-  ) {
-    return undefined;
-  }
-  const projection = mat4.create();
-  if (camera.projection === 'orthographic') {
-    mat4.orthographic(
-      projection,
-      camera.orthoLeft,
-      camera.orthoRight,
-      camera.orthoBottom,
-      camera.orthoTop,
-      camera.near,
-      camera.far,
-    );
-  } else {
-    mat4.perspective(projection, camera.fov, camera.aspect, camera.near, camera.far);
-  }
-  const view = mat4.invert(mat4.create(), camera.world);
-  const inverseViewProjection = mat4.invert(
-    mat4.create(),
-    mat4.multiply(mat4.create(), projection, view),
-  );
-  const span = camera.far - camera.near;
-  const nearNdc =
-    camera.projection === 'orthographic'
-      ? 0
-      : (camera.far * (camera.near - camera.near)) / (camera.near * span);
-  const farNdc =
-    camera.projection === 'orthographic'
-      ? 1
-      : (camera.far * (camera.far - camera.near)) / (camera.far * span);
-  let minX = Infinity;
-  let minY = Infinity;
-  let minZ = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let maxZ = -Infinity;
-  for (const ndcZ of [nearNdc, farNdc]) {
-    for (const ndcX of [-1, 1]) {
-      for (const ndcY of [-1, 1]) {
-        const point = mat4.unproject(
-          vec3.create(),
-          new Float32Array([ndcX, ndcY, ndcZ]),
-          inverseViewProjection,
-        );
-        if (![point[0], point[1], point[2]].every(Number.isFinite)) return undefined;
-        minX = Math.min(minX, point[0] ?? 0);
-        minY = Math.min(minY, point[1] ?? 0);
-        minZ = Math.min(minZ, point[2] ?? 0);
-        maxX = Math.max(maxX, point[0] ?? 0);
-        maxY = Math.max(maxY, point[1] ?? 0);
-        maxZ = Math.max(maxZ, point[2] ?? 0);
-      }
-    }
-  }
-  return new Float32Array([minX, minY, minZ, maxX, maxY, maxZ]);
-}
-
-/** Build the main camera plus exactly three CSM view descriptors. */
-export function buildRenderVisibilityViewDescriptors(input: {
-  readonly camera: CameraSnapshot | undefined;
-  readonly directionalCsm: DirectionalCsmResult | undefined;
-  readonly spatialIndexRevision?: number | undefined;
-}): readonly RenderVisibilityViewDescriptor[] {
-  const main = {
-    viewId: 'main',
-    kind: 'main' as const,
-    cascadeIndex: undefined,
-    planes: input.camera === undefined ? new Float32Array(0) : cameraVisibilityPlanes(input.camera),
-    broadphaseWorldAabb:
-      input.camera === undefined ? undefined : cameraVisibilityBroadphaseAabb(input.camera),
-    lightViewProj: undefined,
-    casterCandidateIndices: new Set<number>(),
-    volumeRevision: undefined,
-    spatialIndexRevision: input.spatialIndexRevision,
-  } satisfies RenderVisibilityViewDescriptor;
-  const cascades = Array.from({ length: 3 }, (_, cascadeIndex) => {
-    const volume = input.directionalCsm?.volumes[cascadeIndex];
-    return {
-      viewId: `cascade-${cascadeIndex}`,
-      kind: 'cascade' as const,
-      cascadeIndex,
-      // CascadeVolumeSet owns the exact boundary and membership. The CPU
-      // executor consumes the stable candidate IDs below instead of fitting a
-      // second frustum or re-running CSM math.
-      planes:
-        volume === undefined
-          ? new Float32Array(0)
-          : frustum.fromViewProjection(frustum.create(), volume.lightViewProj),
-      broadphaseWorldAabb:
-        volume === undefined ? undefined : new Float32Array(volume.casterBroadphaseWorldAabb),
-      lightViewProj: volume === undefined ? undefined : new Float32Array(volume.lightViewProj),
-      casterCandidateIndices: new Set(volume?.casterRenderableIndices ?? []),
-      volumeRevision: volume?.revision,
-      spatialIndexRevision: input.spatialIndexRevision,
-    } satisfies RenderVisibilityViewDescriptor;
-  });
-  return Object.freeze([main, ...cascades]);
-}
+import type { SkinPaletteSlice } from './systems/skin-palette-types';
 
 /**
  * DirectionalLightSnapshot — sun-like infinite light variant of the
@@ -613,8 +314,6 @@ export interface PointShadowSnapshot {
  */
 export interface SpotLightSnapshot {
   readonly kind: 'spot';
-  /** ECS entity handle in the source World; diagnostic identity only. */
-  readonly entity: number;
   readonly position: Vec3;
   readonly direction: Vec3;
   readonly color: Vec3;
@@ -744,10 +443,6 @@ export interface ExtractedLights {
    * when castShadow=false or no directional light.
    */
   readonly directionalCsmDirection: Vec3 | undefined;
-  /** Canonical receiver/caster plan consumed by persistent scene and record. */
-  readonly directionalCsm?: DirectionalCsmResult;
-  /** Internal compatibility projection; the plan above remains canonical. */
-  readonly cascades?: DirectionalCsmResult['cascades'];
 }
 
 /**
@@ -757,7 +452,7 @@ export interface ExtractedLights {
  * `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
- * `GpuResourceStore.getCubemapGpuView(...)` and related helpers
+ * `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.
@@ -781,128 +476,13 @@ export interface SkylightSnapshot {
   readonly entityHandle: number;
 }
 
-/** Retained scene-radiance Fog facts; parameters remain outside inspection. */
-export interface FogSnapshot {
-  readonly color: readonly [number, number, number];
-  readonly density: number;
-  readonly heightFalloff: number;
-  readonly maxOpacity: number;
-  readonly revision: number;
-}
-
-/** Internal owner facts needed to publish a Fog snapshot transactionally. */
-export interface FogSelection {
-  readonly snapshot: FogSnapshot | undefined;
-  readonly resourceOwner: number;
-  readonly entity: EntityHandle | undefined;
-}
-
-export type FogSelectionError = Extract<
-  RenderError,
-  FogOwnerConflictError | FogParametersInvalidError
->;
-
-export type FogSelectionResult = Result<FogSelection, FogSelectionError>;
-
-const FOG_ENTITY_DETAIL_LIMIT = 8;
-
-function fogRevision(world: World, resourceOwner: number, entity: EntityHandle): number {
-  let hash = 2166136261 >>> 0;
-  const fog = world.get(entity, Fog);
-  const source = fog.ok
-    ? `${world.identity}:${resourceOwner}:${entity}:${Array.from(fog.value.color).join(',')}:${fog.value.density}:${fog.value.heightFalloff}:${fog.value.maxOpacity}`
-    : `${world.identity}:${resourceOwner}:${entity}`;
-  for (let index = 0; index < source.length; index += 1) {
-    hash ^= source.charCodeAt(index);
-    hash = Math.imul(hash, 16777619) >>> 0;
-  }
-  return hash === 0 ? 1 : hash;
-}
-
-function fogInvalid(
-  entity: EntityHandle,
-  field: string,
-  expected: string,
-  actual: unknown,
-): FogSelectionResult {
-  return err(new FogParametersInvalidError(entity as number, field, expected, actual));
-}
-
-/** Select and validate the single Fog authoring entity from resourceOwner. */
-export function selectFog(world: World | undefined, resourceOwner: number): FogSelectionResult {
-  if (world === undefined) return ok({ snapshot: undefined, resourceOwner, entity: undefined });
-  const entities: EntityHandle[] = [];
-  const query = world.query({ read: [Fog] }).unwrap();
-  for (const row of query) entities.push(row.entity);
-  if (entities.length === 0) {
-    return ok({ snapshot: undefined, resourceOwner, entity: undefined });
-  }
-  if (entities.length > 1) {
-    const bounded = entities.slice(0, FOG_ENTITY_DETAIL_LIMIT).map((entity) => entity as number);
-    return err(
-      new FogOwnerConflictError(
-        resourceOwner,
-        bounded,
-        Math.max(0, entities.length - bounded.length),
-      ),
-    );
-  }
-
-  const entity = entities[0];
-  if (entity === undefined) return ok({ snapshot: undefined, resourceOwner, entity: undefined });
-  const read = world.get(entity, Fog);
-  if (!read.ok) return ok({ snapshot: undefined, resourceOwner, entity: undefined });
-  const color = read.value.color;
-  if (
-    color.length !== 3 ||
-    color.some((value) => typeof value !== 'number' || !Number.isFinite(value) || value < 0)
-  ) {
-    return fogInvalid(
-      entity,
-      'color',
-      'a three-component finite non-negative array',
-      Array.from(color),
-    );
-  }
-  const density = read.value.density;
-  if (!Number.isFinite(density) || density < 0) {
-    return fogInvalid(entity, 'density', 'a finite non-negative number', density);
-  }
-  const heightFalloff = read.value.heightFalloff;
-  if (!Number.isFinite(heightFalloff) || heightFalloff < 0) {
-    return fogInvalid(entity, 'heightFalloff', 'a finite non-negative number', heightFalloff);
-  }
-  const maxOpacity = read.value.maxOpacity;
-  if (!Number.isFinite(maxOpacity) || maxOpacity < 0 || maxOpacity > 1) {
-    return fogInvalid(entity, 'maxOpacity', 'a finite number in [0, 1]', maxOpacity);
-  }
-  const normalizedColor: [number, number, number] = [color[0] ?? 0, color[1] ?? 0, color[2] ?? 0];
-  const snapshot: FogSnapshot = Object.freeze({
-    color: normalizedColor,
-    density,
-    heightFalloff,
-    maxOpacity,
-    revision: fogRevision(world, resourceOwner, entity),
-  });
-  return ok({ snapshot, resourceOwner, entity });
-}
-
-function routeFogSelectionError(world: World | undefined, error: FogSelectionError): void {
-  if (world === undefined) return;
-  try {
-    routeWorldError(world, error, { systemName: 'RenderSystem.extractFog' });
-  } catch {
-    // World error policy owns whether a routed error throws.
-  }
-}
-
 /**
  * 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 `GpuResourceStore.getCubemapGpuView(...)`.
+ * 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.
@@ -921,27 +501,9 @@ export interface SkyboxSnapshot {
 export interface RenderableSnapshot {
   readonly assetHandle: number;
   readonly transform: TransformSnapshot;
-  /**
-   * Bounds-only transform derived from authored local TRS when the resolved
-   * world column is still its identity default. This preserves the producer
-   * bounds source for direct extract-before-propagate paths without changing
-   * the render SSOT, which remains `transform.world`.
-   */
-  readonly boundsWorld?: Float32Array;
-  /** Candidate-domain copy of all instance transforms, retained before cull. */
-  readonly candidateInstanceTransforms?: Float32Array;
   /** Finite producer-owned local bounds retained for persistent CPU view work. */
   readonly localAabb?: Float32Array;
-  /**
-   * Optional authoring/pack-owned scene facts. The projection supplies
-   * explicit `unknown` defaults when this field is absent; it never infers
-   * staticness or shadow eligibility from frame-local behavior.
-   */
-  readonly sceneFact?: RenderSceneFactInput;
-  /**
-   * Forward raster item facts consumed by the first GPU-driven rigid lane.
-   * Each entry carries its source submesh, pass identity, and resolved queue.
-   */
+  /** 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)
@@ -997,8 +559,6 @@ export interface RenderableSnapshot {
    * not the bare entityKey alone (D-1).
    */
   readonly entityKey: number;
-  /** Stable pre-main-cull candidate index used by the directional CSM plan. */
-  readonly candidateIndex?: number;
   /**
    * feat-20260514 M3 (w15): when the entity carries an `Instances` component
    * the extract stage materialises a fresh `Float32Array` snapshot of the
@@ -1038,41 +598,22 @@ export interface RenderableSnapshot {
    * Absent (`undefined`) means the entity is not skinned.
    */
   readonly skin?: SkinPaletteSlice;
-  /** Current morph producer weights; previous values come from the submitted projection epoch. */
-  readonly morphWeights?: Float32Array;
-  /** Previous facts from the renderer's last successful submission epoch. */
-  readonly temporal?: RenderableTemporalSnapshot;
+  /**
+   * 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 type RenderablePreviousSource = 'last-submitted' | 'current-seed';
-
-export type RenderableReactiveReason =
-  | 'new-slot'
-  | 'generation-reuse'
-  | 'reentered'
-  | 'geometry-revision'
-  | 'material-revision'
-  | 'skinning-deformation'
-  | 'morph-deformation';
-
-export interface RenderableTemporalSnapshot {
-  readonly previousEpoch: number | undefined;
-  readonly previousSource: RenderablePreviousSource;
-  readonly reactive: boolean;
-  readonly reactiveReasons: readonly RenderableReactiveReason[];
-  readonly previousTransform: TransformSnapshot;
-  readonly previousInstances: InstancesSnapshot | undefined;
-  readonly previousSkin: SkinPaletteSlice | undefined;
-  readonly previousMorphWeights: Float32Array | undefined;
+export interface MorphSnapshot {
+  readonly weights: Float32Array;
+  readonly targetCount: number;
 }
 
 export interface GpuDrivenDrawSnapshot {
-  /** Index into the resolved mesh submesh array. */
-  readonly submeshIndex: number;
-  /** Index of the corresponding material pass in the resolved pass list. */
-  readonly passIndex: number;
-  /** Effective queue copied from that pass; always resolved at extract time. */
-  readonly queue: number;
   readonly kind: 'indexed' | 'non-indexed';
   readonly first: number;
   readonly count: number;
@@ -1083,41 +624,6 @@ export interface GpuDrivenDrawSnapshot {
   readonly materialResourceClass: string;
 }
 
-/**
- * feat-20260523-skin-skeleton-animation M2 / T-21 + T-24:
- * per-draw palette slice metadata. Joint count + byte offset into the
- * shared skin palette storage buffer.
- *
- * plan-strategy D-10: SkinPaletteSlice naming mirroring Bevy SkinByteOffset
- * but with forgeax vocabulary (byteOffset not offset, jointCount not joint_count).
- */
-export interface SkinPaletteSlice {
-  readonly jointCount: number;
-  /** CPU snapshot of the exact palette written for this extract epoch. */
-  readonly jointMatrices: Float32Array;
-  /**
-   * Byte offset INTO `buffer` for this slice. On the storage path the
-   * allocator returns one shared buffer + a per-entity cursor offset; on
-   * the uniform fallback path each slice owns its own GPU buffer (cap
-   * `maxUniformBufferBindingSize` 16 KiB cannot host shared dynOffset
-   * windows for >1 entity), so `byteOffset === 0` for every slice and
-   * `buffer` is the per-slice handle. Record stage reads both fields and
-   * does not branch on the path -- BG cache key includes `buffer`, so
-   * two paths converge at the same code.
-   */
-  readonly byteOffset: number;
-  /**
-   * Per-slice GPU buffer handle. M6: feat-20260612 collapsed the prior
-   * shared-buffer assumption (record-stage read `pipelineState
-   * .skinPaletteAllocator.buffer`) into a per-slice carrier so the
-   * uniform fallback path can return a per-entity buffer without
-   * branching the record stage.
-   */
-  readonly buffer: import('@forgeax/engine-rhi').Buffer;
-  /** Previous successful-submit palette, paired with {@link buffer}. */
-  readonly previousBuffer?: import('@forgeax/engine-rhi').Buffer | undefined;
-}
-
 export interface InstancesSnapshot {
   /** Packed column-major mat4 transforms (16 f32 per instance). */
   readonly transforms: Float32Array;
@@ -1177,56 +683,6 @@ export interface TransformSnapshot {
   readonly world: Float32Array;
 }
 
-function authoredBoundsWorld(
-  world: ArrayLike<number>,
-  local:
-    | {
-        readonly pos: ArrayLike<number>;
-        readonly quat: ArrayLike<number>;
-        readonly scale: ArrayLike<number>;
-      }
-    | undefined,
-): Float32Array | undefined {
-  if (local === undefined || world.length < 16) return undefined;
-  let worldIsIdentity = true;
-  const identity = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
-  for (let index = 0; index < 16; index += 1) {
-    const value = world[index];
-    if (
-      value === undefined ||
-      !Number.isFinite(value) ||
-      Math.abs(value - (identity[index] ?? 0)) > 1e-6
-    ) {
-      worldIsIdentity = false;
-      break;
-    }
-  }
-  if (!worldIsIdentity || local.pos.length < 3 || local.quat.length < 4 || local.scale.length < 3) {
-    return undefined;
-  }
-  const hasAuthoredTransform =
-    (local.pos[0] ?? 0) !== 0 ||
-    (local.pos[1] ?? 0) !== 0 ||
-    (local.pos[2] ?? 0) !== 0 ||
-    (local.quat[0] ?? 0) !== 0 ||
-    (local.quat[1] ?? 0) !== 0 ||
-    (local.quat[2] ?? 0) !== 0 ||
-    (local.quat[3] ?? 1) !== 1 ||
-    (local.scale[0] ?? 1) !== 1 ||
-    (local.scale[1] ?? 1) !== 1 ||
-    (local.scale[2] ?? 1) !== 1;
-  if (!hasAuthoredTransform) return undefined;
-  for (const values of [local.pos, local.quat, local.scale]) {
-    for (let index = 0; index < values.length; index += 1) {
-      const value = values[index];
-      if (value === undefined || !Number.isFinite(value)) return undefined;
-    }
-  }
-  const composed = mat4.create();
-  mat4.compose(composed, local.pos, local.quat, local.scale);
-  return composed;
-}
-
 /**
  * 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).
@@ -1267,16 +723,12 @@ export interface MaterialSnapshot {
    * discriminator (M4-T06).
    */
   readonly materialShaderId?: string | undefined;
-  /** Canonical RenderAssetPort GUID used to join the production readiness tuple. */
-  readonly materialGuid?: 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;
-  /** Whether the resolved material owns a ShadowCaster pass. */
-  readonly shadowCaster?: boolean | 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
@@ -1292,10 +744,6 @@ export interface MaterialSnapshot {
   readonly paramSnapshot?: Readonly<Record<string, number | number[] | string>> | undefined;
   /** Effective MaterialAsset parameter contract used to lay out this snapshot. */
   readonly materialParamSchema?: readonly ParamSchemaEntry[] | undefined;
-  /** Typed per-slot projection produced from the effective root schema. */
-  readonly derivedMaterialSlot?: DerivedMaterialSlotProjection | undefined;
-  /** Structured extract failure that the record stage must propagate and stop. */
-  readonly derivedMaterialError?: MaterialError | undefined;
   /** Authored per-slot UV set and KHR texture transform metadata. */
   readonly textureCoordinates?: ReadonlyMap<string, MaterialTextureCoordinates> | undefined;
   /**
@@ -1303,7 +751,7 @@ export interface MaterialSnapshot {
    * (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 any custom field such as
+   * `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.
@@ -1322,7 +770,7 @@ export interface MaterialSnapshot {
    * 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 `GpuResourceStore.ensureResident`
+   * 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.
    *
@@ -1403,7 +851,7 @@ export interface MaterialSnapshotCacheEntry {
   readonly passes: readonly MaterialPass[];
   /** Root/chain identities are present only on cross-frame-safe entries. */
   readonly chain?: readonly MaterialCacheChainIdentity[];
-  /** RenderAssetPort epoch at which the root/parent chain was last validated. */
+  /** 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;
@@ -1426,44 +874,11 @@ function gpuDrivenMaterialResourceClass(material: MaterialSnapshot): string {
   });
 }
 
-function gpuDrivenForwardPass(
-  material: MaterialSnapshot,
-  cache: MaterialSnapshotCache,
-): { readonly passIndex: number; readonly queue: number } | undefined {
-  // Test-only snapshots and the engine default material do not have a cached
-  // authored pass list. Their forward pass is the canonical Geometry pass.
-  if (material.materialHandle === undefined) {
-    return { passIndex: 0, queue: RenderQueue.Geometry };
-  }
-  if (material.materialHandle === 0) {
-    // The synthesized default dispatch keeps ShadowCaster at index 0 and
-    // Forward at index 1; use the same identity for GPU/CPU ownership.
-    return { passIndex: 1, queue: RenderQueue.Geometry };
-  }
-  const passes = cache.get(material.materialHandle)?.passes;
-  if (passes === undefined) return undefined;
-  for (let passIndex = 0; passIndex < passes.length; passIndex += 1) {
-    const pass = passes[passIndex];
-    if (pass === undefined) continue;
-    const state = pass.renderState as
-      | (Readonly<Record<string, unknown>> & {
-          readonly tags?: Readonly<Record<string, string>>;
-          readonly queue?: unknown;
-        })
-      | undefined;
-    const lightMode = state?.tags?.LightMode;
-    if (lightMode !== 'Forward' && pass.name !== 'forward') continue;
-    const queue = typeof state?.queue === 'number' ? state.queue : RenderQueue.Geometry;
-    return { passIndex, queue };
-  }
-  return undefined;
-}
-
 // === 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, defines, and entry-point
+// 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.
 
@@ -1507,6 +922,12 @@ export function sortDispatchByQueue<E extends { readonly queue: number }>(
   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[],
@@ -1515,6 +936,7 @@ function appendMaterialDispatchEntries(
   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++) {
@@ -1529,12 +951,14 @@ function appendMaterialDispatchEntries(
       entityIndex: entity,
       materialHandle,
       renderableIndex,
-      passIndex: pIdx,
-      queue: passState.queue ?? RenderQueue.Geometry,
+      passIndex: passIndexOffset + pIdx,
+      queue: passState.queue ?? 2000,
       layer,
       tags: passState.tags ?? {},
       renderState: pipelineRenderState(passState),
-      defines: pass.program.moduleSlots,
+      // 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),
@@ -1550,23 +974,16 @@ export interface ExtractedFrame {
   readonly cameras: CameraSnapshot[];
   readonly lights: ExtractedLights;
   readonly renderables: RenderableSnapshot[];
-  /** Author-visible snapshots retained before the main-view frustum cull. */
-  readonly candidateRenderables?: readonly RenderableSnapshot[];
-  /** Pass dispatch for the same pre-main-cull candidate domain. */
-  readonly candidateDispatch?: readonly DispatchEntry[];
-  /** Shared membership owner for the candidate dispatch domain. */
-  readonly candidateDispatchMembership?: RenderDispatchMembership;
-  /** Shared immutable candidate array/dispatch/index owner. */
-  readonly candidateDomain?: RenderCandidateDomain;
-  /** Resource-owner Fog snapshot retained for direct extract consumers. */
-  readonly fog?: FogSnapshot | undefined;
   /**
    * 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 environment: ExtractedEnvironment;
+  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
@@ -1593,53 +1010,82 @@ export interface ExtractedFrame {
 }
 
 /**
- * Transparent-bucket dispatch entry — extends the dispatch snapshot with
- * per-entity sort inputs precomputed at extract time.
- *
- * Field semantics:
- *   - `layer` — primary sort key (signed i32 from `Layer.value`; default 0
- *     for entities without a Layer component).
- *   - `posX` / `posY` / `posZ` — world position from the entity's Transform.
- *   - `pivotY` / `sizeY` — sprite's Y-axis foot offset inputs. `pivotY =
- *     SpriteMaterialAsset.pivot[1]` (default 0.5); `sizeY` = Transform's
- *     world scale Y (sprite quad's world-space height in unit-quad world
- *     space — the unit quad is 1x1 so `Transform.scaleY` directly maps to
- *     world height). The foot-Y formula `posY - pivotY * sizeY` is the
- *     SSOT for the JRPG Y-sort path (mode=1, requirements §AC-10).
- *   - `sortKey` — optional per-entity override from `SortKey.value`. When
- *     present, `transparentSortEntries` uses it INSTEAD of the mode formula
- *     for this entry (still gated by `layer` as the primary key).
- *
- * Plan-strategy §3.3 interface example + §AC-10 sort path + §AC-19
- * derivation row 13 (this is the true new POD shape `@new-surface`; not a
- * mere rename of an existing snapshot).
+ * 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).
  */
-export interface TransparentEntry {
-  readonly entityIndex: number;
-  readonly materialHandle: number;
-  readonly layer: number;
-  readonly posX: number;
-  readonly posY: number;
-  readonly posZ: number;
-  readonly pivotY: number;
-  readonly sizeY: number;
-  // `number | undefined` rather than the strict `?: number` form so AI
-  // users that construct TransparentEntry literals with
-  // `sortKey: maybeUndefined` (the typical SoA projection pattern) do
-  // not trip `exactOptionalPropertyTypes: true` (the engine's tsconfig
-  // base). Absent === undefined consumer semantics are identical; the
-  // sort helper checks `e.sortKey !== undefined` either way.
-  readonly sortKey?: number | undefined;
-  /**
-   * Index into the parallel `ExtractedFrame.renderables[]` array. M-3 /
-   * w25 record stage uses this to look up the `RenderableSnapshot`
-   * (Transform + mesh + material snapshot) belonging to this transparent
-   * entry after `transparentSortEntries` reorders the bucket. Optional
-   * for test fixtures that construct TransparentEntry literals by hand
-   * (w16 sort tests bypass renderables[] correlation); the real extract
-   * path always sets a non-negative integer index here.
-   */
-  readonly renderableIndex?: number | undefined;
+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;
 }
 
 /**
@@ -1724,12 +1170,12 @@ function pipelineRenderState(
 
 /**
  * tweak-20260627-model-loading-smoke-build-perf M4: per-World intern cache for
- * the typed AssetRegistry.load texture/sampler resolution path. A MaterialAsset's
+ * the loadByGuid texture/sampler resolution path. A MaterialAsset's
  * texture/sampler values remain embedded GUID strings (dash-form) after
- * AssetRegistry.load; the extract stage re-resolves each GUID to a column handle every
+ * 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 (`GpuResourceStore.textureGpuHandles`) is keyed on
+ * 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 +
@@ -1740,11 +1186,10 @@ function pipelineRenderState(
  * 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. Final release is published as structured evidence by the
- * World-owned SharedRefStore; the renderer owner consumes that evidence and
- * owns GPU disposal.
+ * 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 RenderAssetPort is a
+ * 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).
@@ -1767,7 +1212,7 @@ const guidHandleInternByWorld = new WeakMap<World, Map<string, GuidHandleInternE
 
 function internSharedRefFromGuid<B extends string>(
   world: World,
-  assetsRef: RenderAssetPort,
+  assetsRef: AssetRegistry,
   guid: string,
   brand: B,
 ): Handle<B, 'shared'> | undefined {
@@ -1780,19 +1225,19 @@ function internSharedRefFromGuid<B extends string>(
   const cached = perWorld.get(key);
   const payload = assetsRef.lookup(guid);
   if (cached !== undefined && cached.payload === payload) {
-    const cachedHandle = cached.handle as unknown as Handle<B, 'shared'>;
+    const cachedHandle = toShared<B>(cached.handle);
     if (world.sharedRefs.resolve(cachedHandle).ok) return cachedHandle;
   }
   if (cached !== undefined) {
-    world.sharedRefs.release(cached.handle as unknown as Handle<B, 'shared'>);
+    world.sharedRefs.release(toShared<B>(cached.handle));
     perWorld.delete(key);
   }
   if (payload === undefined) return undefined;
-  // Mint exactly once per (world, guid, brand). The World-owned store
-  // publishes structured final-release evidence; disposal remains with the
-  // renderer owner effect rather than a per-handle callback.
-  const handle = world.allocSharedRef(brand, payload);
-  perWorld.set(key, { handle: handle as unknown as number, payload });
+  // 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;
 }
 
@@ -1817,7 +1262,7 @@ function internSharedRefFromGuid<B extends string>(
 function resolveVideoFieldHandle(
   value: unknown,
   world: World,
-  assetsRef: RenderAssetPort,
+  assetsRef: AssetRegistry,
 ): Handle<'VideoAsset', 'shared'> | undefined {
   const texture = materialTextureValue(value);
   const textureGuid = assetReferenceText(texture?.texture ?? value);
@@ -1843,11 +1288,14 @@ function materialTextureValue(value: unknown): MaterialTextureValue | undefined
 
 function assetReferenceText(value: unknown): string | undefined {
   if (typeof value === 'string') return value;
-  if (value instanceof Uint8Array && value.byteLength === 16)
-    return AssetGuid.format(value as never);
+  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;
@@ -1863,14 +1311,16 @@ function materialTextureRef(value: unknown): unknown {
 
 function collectMaterialTextureCoordinates(
   values: Readonly<Record<string, unknown>>,
-  schema: readonly ParamSchemaEntry[],
-  derivedInterface?: DerivedMaterialInterface,
-  paramSchemaProjectionCensus?: ParamSchemaProjectionCensus,
 ): Map<string, MaterialTextureCoordinates> {
   const out = new Map<string, MaterialTextureCoordinates>();
-  for (const field of (
-    derivedInterface ?? deriveParamSchemaForCensus(schema, paramSchemaProjectionCensus, 'submesh')
-  ).textureFieldNames) {
+  for (const field of [
+    'baseColorTexture',
+    'metallicRoughnessTexture',
+    'normalTexture',
+    'specularTintTexture',
+    'emissiveTexture',
+    'occlusionTexture',
+  ]) {
     const coordinates = materialTextureValue(values[field])?.coordinates;
     if (coordinates !== undefined) out.set(field, coordinates);
   }
@@ -1897,14 +1347,14 @@ function collectMaterialTextureSamplers(
  * 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
- * `RenderAssetPort.materialShaderTextureFieldNames`). Each declared texture
+ * `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 any number of user-region
+ * 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 effective schema is unavailable no user-region field is inferred.
- * `emissiveTexture` / `occlusionTexture` are engine-injection (lightmap)
- * textures and are NOT part of this set.
+ * 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
@@ -1918,8 +1368,7 @@ function collectUserRegionTextureHandles(
   pv: Readonly<Record<string, unknown>>,
   shaderId: string | undefined,
   paramSchema: readonly ParamSchemaEntry[] | undefined,
-  derivedInterface: DerivedMaterialInterface | undefined,
-  assetsRef: RenderAssetPort,
+  assetsRef: AssetRegistry,
   world: World,
   resolveTex: (
     value: unknown,
@@ -1928,38 +1377,16 @@ function collectUserRegionTextureHandles(
   videoOut: Map<string, Handle<'VideoAsset', 'shared'>>,
 ): Map<string, Handle<'TextureAsset', 'shared'>> {
   const fields =
-    derivedInterface !== undefined
-      ? derivedInterface.textureFieldNames
-      : paramSchema !== undefined && paramSchema.length > 0
+    materialTextureFields(
+      shaderId,
+      paramSchema !== undefined
         ? derive(paramSchema).textureFieldNames
-        : paramSchema !== undefined
-          ? new Set(
-              Object.entries(pv)
-                .filter(([, value]) => {
-                  if (materialTextureValue(value) !== undefined) return true;
-                  if (typeof value === 'number') {
-                    const resolved = resolveRenderAsset<Asset>(
-                      world,
-                      value as Handle<string, 'shared'>,
-                    );
-                    return (
-                      resolved.ok &&
-                      (resolved.value.kind === 'texture' || resolved.value.kind === 'video')
-                    );
-                  }
-                  if (typeof value === 'string') {
-                    const payload = assetsRef.lookup(value);
-                    return payload?.kind === 'texture' || payload?.kind === 'video';
-                  }
-                  return false;
-                })
-                .map(([field]) => field),
-            )
-          : shaderId !== undefined
-            ? assetsRef.materialShaderTextureFieldNames(shaderId)
-            : undefined;
+        : shaderId !== undefined
+          ? assetsRef.materialShaderTextureFieldNames(shaderId)
+          : undefined,
+    ) ?? BUILTIN_USER_REGION_TEXTURE_FIELDS;
   const out = new Map<string, Handle<'TextureAsset', 'shared'>>();
-  for (const field of fields ?? []) {
+  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.
@@ -1974,34 +1401,31 @@ function collectUserRegionTextureHandles(
   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,
-  assets: RenderAssetPort,
 ): readonly ParamSchemaEntry[] {
-  if (parameters.length === 0 && shaderId !== undefined) {
-    const shader = assets.shaderRegistry.findMaterialArtifact(shaderId);
-    if (shader.ok) return shader.value.paramSchema;
-  }
+  const engineInjectedTextureFields = isStandardPbrMaterialShader(shaderId)
+    ? ENGINE_INJECTED_TEXTURE_FIELDS
+    : undefined;
   return parameters.flatMap((parameter): ParamSchemaEntry[] => {
-    // Static values select a cooked specialization and boolean material
-    // values have no runtime UBO representation in ParamSchemaEntry.
-    if (parameter.static || parameter.type === 'bool') return [];
+    // 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' }];
     }
-    const defaultValue = parameter.default;
-    const numericDefault =
-      typeof defaultValue === 'number' ||
-      (Array.isArray(defaultValue) && defaultValue.every((item) => typeof item === 'number'))
-        ? { default: defaultValue }
-        : {};
     return [
       {
         name: parameter.name,
         type: parameter.type,
         ...(parameter.colorSpace === undefined ? {} : { colorSpace: parameter.colorSpace }),
-        ...numericDefault,
       },
     ];
   });
@@ -2016,7 +1440,7 @@ function materialParametersToParamSchema(
 function materialColorParameterSchema(
   parameters: readonly MaterialParameter[],
   shaderId: string | undefined,
-  assets: RenderAssetPort,
+  assets: AssetRegistry,
 ): readonly MaterialColorParameterSchema[] {
   if (shaderId === undefined) return parameters;
   const shader = assets.shaderRegistry.findMaterialArtifact(shaderId);
@@ -2044,13 +1468,13 @@ function isDeepFrozen(value: unknown, seen = new Set<object>()): boolean {
 
 /**
  * Capture the object identities that make a resolved material stable. The
- * renderer owns this cache, but the RenderAssetPort owns parent GUID lookup, so
+ * 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: RenderAssetPort,
+  assets: AssetRegistry,
 ): readonly MaterialCacheChainIdentity[] | undefined {
   const chain: MaterialCacheChainIdentity[] = [];
   const visitedParentGuids = new Set<string>();
@@ -2063,7 +1487,7 @@ function captureMaterialCacheChain(
     if (parentRef === undefined) return undefined;
     if (visitedParentGuids.has(parentGuid)) return undefined;
     visitedParentGuids.add(parentGuid);
-    const parent = assets.lookup<Asset>(parentGuid);
+    const parent = assets.lookup<Asset>(parentRef);
     if (parent?.kind !== 'material') return undefined;
     current = parent;
   }
@@ -2073,11 +1497,15 @@ function captureMaterialCacheChain(
 function readPersistentMaterialSnapshot(
   cache: MaterialSnapshotCache | undefined,
   handleRaw: number,
-  assets: RenderAssetPort,
+  assets: AssetRegistry,
 ): MaterialSnapshotCacheEntry | undefined {
   const entry = cache?.get(handleRaw);
   if (entry === undefined) return undefined;
-  if (entry.crossFrameSafe && entry.chain !== undefined && entry.catalogEpoch === assets.epoch)
+  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
@@ -2096,12 +1524,12 @@ function readPersistentMaterialSnapshot(
 function readStablePersistentMaterialSnapshot(
   cache: MaterialSnapshotCache | undefined,
   handleRaw: number,
-  assets: RenderAssetPort,
+  assets: AssetRegistry,
 ): MaterialSnapshotCacheEntry | undefined {
   const entry = cache?.get(handleRaw);
   return entry?.crossFrameSafe === true &&
     entry.chain !== undefined &&
-    entry.catalogEpoch === assets.epoch
+    entry.catalogEpoch === assets.catalogEpoch
     ? entry
     : undefined;
 }
@@ -2112,7 +1540,7 @@ function storeMaterialSnapshot(
   snapshot: MaterialSnapshot,
   passes: readonly MaterialPass[],
   root: MaterialAsset,
-  assets: RenderAssetPort,
+  assets: AssetRegistry,
 ): MaterialSnapshotCacheEntry {
   const chain = captureMaterialCacheChain(root, assets);
   const entry: MaterialSnapshotCacheEntry = {
@@ -2120,7 +1548,7 @@ function storeMaterialSnapshot(
     passes,
     crossFrameSafe: chain?.every(({ asset }) => isDeepFrozen(asset)) === true,
     ...(chain === undefined ? {} : { chain }),
-    ...(chain === undefined ? {} : { catalogEpoch: assets.epoch }),
+    ...(chain === undefined ? {} : { catalogEpoch: assets.catalogEpoch }),
   };
   cache.set(handleRaw, entry);
   return entry;
@@ -2136,124 +1564,211 @@ function storeMaterialSnapshot(
  * 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 any unresolved / non-material
+ * 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).
  */
-const materialInterfaceOwner = createMaterialInterfaceOwner({
-  defaultMaterialSnapshot,
-  readStablePersistentMaterialSnapshot,
-  readPersistentMaterialSnapshot,
-  storeMaterialSnapshot,
-  runtimeMaterialShaderId,
-  pipelineRenderState,
-  materialColorParameterSchema,
-  materialNormalScale,
-  materialParametersToParamSchema,
-  collectUserRegionTextureHandles,
-  collectMaterialTextureSamplers,
-  materialTextureRef,
-  collectMaterialTextureCoordinates,
-  internSharedRefFromGuid,
-});
-
-export const resolveMaterialSnapshot = materialInterfaceOwner.resolveMaterialSnapshot;
-
-function materialPassTopologySignature(passes: readonly MaterialPass[]): string {
-  return JSON.stringify(
-    passes.map((pass) => {
-      const state = pass.renderState as
-        | (MaterialRenderState & {
-            readonly tags?: Readonly<Record<string, string>>;
-            readonly queue?: number;
-            readonly stencilReference?: number;
-          })
-        | undefined;
-      return {
-        name: pass.name,
-        module: pass.program.module,
-        vertexEntry: pass.program.vertexEntry,
-        fragmentEntry: pass.program.fragmentEntry,
-        moduleSlots: pass.program.moduleSlots,
-        queue: state?.queue,
-        tags: state?.tags,
-        renderState: pipelineRenderState(state),
-        stencilReference: state?.stencilReference,
-      };
-    }),
-  );
-}
-
-export function refreshRenderableMaterialSnapshot(
-  renderable: RenderableSnapshot,
-  materialHandle: number,
+export function resolveMaterialSnapshot(
+  handleRaw: number,
   world: World,
-  assets: RenderAssetPort,
-  gpuStore?: import('./gpu-resource-store').GpuResourceStore,
+  assetsRef: AssetRegistry,
+  materialSnapshotCache?: MaterialSnapshotCache,
   persistentMaterialSnapshotCache?: MaterialSnapshotCache,
-  paramSchemaProjectionCensus?: ParamSchemaProjectionCensus,
-): RenderableSnapshot | undefined {
-  const previousCacheEntry = persistentMaterialSnapshotCache?.get(materialHandle);
-  const previousPassTopology =
-    previousCacheEntry === undefined
-      ? undefined
-      : materialPassTopologySignature(previousCacheEntry.passes);
-  persistentMaterialSnapshotCache?.delete(materialHandle);
-  const refreshed = resolveMaterialSnapshot(
-    materialHandle,
-    world,
-    assets,
-    gpuStore,
-    new Map(),
+): MaterialSnapshot {
+  if (handleRaw === 0) return defaultMaterialSnapshot(handleRaw);
+  const cached = materialSnapshotCache?.get(handleRaw);
+  if (cached !== undefined) return cached.snapshot;
+  const stablePersistentCached = readStablePersistentMaterialSnapshot(
     persistentMaterialSnapshotCache,
-    paramSchemaProjectionCensus,
+    handleRaw,
+    assetsRef,
   );
-  const materials = renderable.materials.map((material) =>
-    (material.materialHandle ?? 0) === materialHandle ? refreshed : material,
+  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 (persistentMaterialSnapshotCache !== undefined) {
-    const nextCacheEntry = persistentMaterialSnapshotCache.get(materialHandle);
-    if (
-      previousPassTopology === undefined ||
-      nextCacheEntry === undefined ||
-      materialPassTopologySignature(nextCacheEntry.passes) !== previousPassTopology
-    ) {
-      // A delta snapshot is insufficient to rebuild dispatch entries. If the
-      // resolved pass topology changed, let PersistentRenderScene rebuild the
-      // complete candidate domain so ShadowCaster membership and pass order
-      // come from the same extract owner.
-      return undefined;
+  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 topologyChanged = materials.some((material, index) => {
-    const previous = renderable.materials[index];
-    return (
-      previous === undefined ||
-      previous.shadowCaster !== material.shadowCaster ||
-      previous.transparent !== material.transparent ||
-      previous.materialShaderId !== material.materialShaderId ||
-      JSON.stringify(previous.renderState ?? null) !== JSON.stringify(material.renderState ?? null)
-    );
-  });
-  if (topologyChanged) return undefined;
-  const material = materials[0] ?? renderable.material;
-  const draws = renderable.gpuDrivenDraws;
-  return {
-    ...renderable,
-    material,
-    materials,
-    ...(draws === undefined
-      ? {}
-      : {
-          gpuDrivenDraws: draws.map((draw) => ({
-            ...draw,
-            materialResourceClass: gpuDrivenMaterialResourceClass(
-              materials[draw.materialSlot] ?? material,
-            ),
-          })),
-        }),
+  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;
 }
 
 /**
@@ -2269,6 +1784,132 @@ 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.
@@ -2342,8 +1983,196 @@ export function buildPointShadowMatrices(lightPos: Vec3, near: number, far: numb
   return out;
 }
 
-// Directional CSM math is owned by extract/directional-csm.ts; this file keeps
-// the historical internal export seam and feeds the owner with snapshots.
+/**
+ * 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
@@ -2360,42 +2189,29 @@ export interface ExtractFramesOwner {
 }
 
 export interface PreparedExtractContext {
-  /** Renderer-local identity of the World whose singleton resources are read. */
-  readonly worldId?: number | undefined;
-  readonly assets: RenderAssetPort | null | undefined;
+  readonly assets: AssetRegistry | null | undefined;
   readonly pipelineState: ExtractPipelineSurface | null | undefined;
-  readonly gpuStore: import('./gpu-resource-store').GpuResourceStore | undefined;
   readonly materialSnapshotCache: MaterialSnapshotCache | undefined;
   readonly cull: 'self' | 'none' | 'external';
   readonly cullCameras: readonly CameraSnapshot[] | undefined;
   readonly hierarchy: SceneHierarchySnapshot;
-  readonly visibility: VisibilitySnapshot;
-  /** @internal Debug-only ParamSchema compatibility census. */
-  readonly paramSchemaProjectionCensus?: ParamSchemaProjectionCensus | undefined;
-  /** @internal Refresh only compact lighting resources over an existing frame. */
-  readonly resourceRefreshBase?: ExtractedFrame;
-  /**
-   * @internal Restrict the MeshRenderer row source to known entities. The
-   * query is addressed through Query.at(), so this path does not iterate the
-   * world's renderable tables. Resource queries remain unchanged.
-   */
-  readonly targetRenderableEntities?: readonly EntityHandle[];
+  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, Transform] }).unwrap();
+  const cameraQuery = world.query({ read: [Camera], with: [Transform] }).unwrap();
   for (const row of cameraQuery) {
     const cam = row.get(Camera);
     const entity = row.entity;
-    const transform = row.get(Transform);
-    if (transform === undefined) continue;
-    const worldMat = new Float32Array(transform.world);
+    const view = worldInternal._getArrayView(entity, Transform, 'world');
+    if (view === undefined) continue;
+    const worldMat = new Float32Array(view);
     cameras.push({
-      worldId: 0,
       entityKey: entity as number,
-      position: mat4.getTranslation(vec3.create(), worldMat as unknown as mat4.Mat4Like),
+      position: mat4.getTranslation(vec3.create(), worldMat),
       world: worldMat,
       fov: cam.fov,
       aspect: cam.aspect,
@@ -2410,7 +2226,6 @@ export function extractCameraSnapshots(world: World): CameraSnapshot[] {
       exposure: cam.exposure,
       whitePoint: cam.whitePoint,
       antialias: antialiasFromF32(cam.antialias),
-      historyVersion: cam.historyVersion,
       bloom: bloomEnabledFromF32(cam.bloom),
       bloomThreshold: cam.bloomThreshold,
       bloomIntensity: cam.bloomIntensity,
@@ -2440,114 +2255,35 @@ function tonemapParams(camera: CameraSnapshot): Uint8Array {
   return new Uint8Array(bytes);
 }
 
-function extractPostProcessParams(
-  world: World,
-  cameras: readonly CameraSnapshot[],
-): Map<string, Uint8Array> {
-  const postProcessParams = new Map<string, Uint8Array>();
-  const query = world.query({ with: [PostProcessParams] }).unwrap();
-  for (const row of query) {
-    const read = world.get(row.entity, PostProcessParams);
-    if (!read.ok) continue;
-    postProcessParams.set(read.value.shader, read.value.data);
-  }
-  const tonemapCamera = cameras[0];
-  if (tonemapCamera !== undefined) {
-    postProcessParams.set('forgeax::tonemap', tonemapParams(tonemapCamera));
-  }
-  return postProcessParams;
-}
-
-export function refreshExtractedFrameCameras(world: World, frame: ExtractedFrame): ExtractedFrame {
-  const cameras = extractCameraSnapshots(world);
-  const camera = cameras[0];
-  const config = frame.lights.directionalCsmConfig;
-  const direction = frame.lights.directionalCsmDirection;
-  const csm =
-    camera === undefined || config === undefined || direction === undefined
-      ? null
-      : computeDirectionalCsm(direction, config, camera);
-  const postProcessParams = new Map(frame.postProcessParams);
-  postProcessParams.delete('forgeax::tonemap');
-  if (camera !== undefined) postProcessParams.set('forgeax::tonemap', tonemapParams(camera));
-  return {
-    ...frame,
-    cameras,
-    lights: {
-      ...frame.lights,
-      lightViewProj: csm?.lightViewProj,
-      splitPlanes: csm?.splitPlanes,
-      cascadeCount: csm?.cascadeCount,
-      cascadeBlend: csm?.cascadeBlend,
-      shadowMapSize: csm?.shadowMapSize,
-    },
-    postProcessParams,
-  };
-}
-
-/**
- * Refresh only the resource-owned PostProcessParams map after an ECS journal
- * update. Post-process parameter entities are not render-domain slots; making
- * their transient byte payload visible must not rebuild candidates, dispatch,
- * topology, or the GPU scene.
- */
-export function refreshExtractedFramePostProcessParams(
-  world: World,
-  frame: ExtractedFrame,
-): ExtractedFrame {
-  const postProcessParams = new Map<string, Uint8Array>();
-  const query = world.query({ with: [PostProcessParams] }).unwrap();
-  for (const row of query) {
-    const read = world.get(row.entity, PostProcessParams);
-    if (!read.ok) continue;
-    postProcessParams.set(read.value.shader, read.value.data);
-  }
-  const tonemap = frame.postProcessParams.get('forgeax::tonemap');
-  if (tonemap !== undefined) postProcessParams.set('forgeax::tonemap', tonemap);
-  return { ...frame, postProcessParams };
-}
-
 export function prepareExtractContext(
   world: World,
   options: {
-    readonly worldId?: number;
-    readonly assets?: RenderAssetPort | null;
+    readonly assets?: AssetRegistry | null;
     readonly pipelineState?: ExtractPipelineSurface | null;
-    readonly gpuStore?: import('./gpu-resource-store').GpuResourceStore;
     readonly materialSnapshotCache?: MaterialSnapshotCache;
     readonly cull?: 'self' | 'none' | 'external';
     readonly cullCameras?: readonly CameraSnapshot[];
-    readonly paramSchemaProjectionCensus?: ParamSchemaProjectionCensus;
   } = {},
 ): PreparedExtractContext {
   const hierarchy = projectHierarchy(world);
   return {
-    worldId: options.worldId ?? 0,
     assets: options.assets,
     pipelineState: options.pipelineState,
-    gpuStore: options.gpuStore,
     materialSnapshotCache: options.materialSnapshotCache,
     cull: options.cull ?? 'self',
     cullCameras: options.cullCameras,
     hierarchy,
     visibility: resolveVisibility(world, hierarchy),
-    ...(options.paramSchemaProjectionCensus === undefined
-      ? {}
-      : { paramSchemaProjectionCensus: options.paramSchemaProjectionCensus }),
   };
 }
 
 export function extractFrames(
   worlds: readonly World[],
   owner: number | ExtractFramesOwner,
-  assets?: RenderAssetPort | null,
+  assets?: AssetRegistry | null,
   pipelineState?: ExtractPipelineSurface | null,
-  gpuStore?: import('./gpu-resource-store').GpuResourceStore,
   materialSnapshotCachesByWorld?: MaterialSnapshotCachesByWorld,
-  options: {
-    readonly cull?: 'normal' | 'none';
-    readonly paramSchemaProjectionCensus?: ParamSchemaProjectionCensus;
-  } = {},
+  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
@@ -2559,7 +2295,7 @@ export function extractFrames(
   // ── 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 any per-world
+  // 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;
@@ -2567,55 +2303,7 @@ export function extractFrames(
     skinPaletteAllocator.resetForFrame();
   }
 
-  // The ordinary game path owns exactly one World. extractFrame already emits
-  // the canonical single-world shape: worldId=0, sorted dispatch, owner
-  // cameras/resources, visibility projections, and CSM matrices fitted to its
-  // own camera. Returning that snapshot directly avoids routing every frame
-  // through the multi-world reconciliation machinery below (ordering arrays,
-  // Maps, and per-renderable/dispatch object copies). This is an intra-frame
-  // structural fast path, not a cross-frame cache; every ECS query and derived
-  // snapshot is still refreshed on every call.
-  const onlyWorld = worlds.length === 1 ? worlds[0] : undefined;
   const failedWorlds = new Set<World>();
-  if (onlyWorld !== undefined && cameraOwner === 0 && resourceOwner === 0) {
-    try {
-      const prepared = prepareExtractContext(onlyWorld, {
-        ...(assets !== undefined ? { assets } : {}),
-        ...(pipelineState !== undefined ? { pipelineState } : {}),
-        ...(gpuStore !== undefined ? { gpuStore } : {}),
-        ...(materialSnapshotCachesByWorld === undefined
-          ? {}
-          : {
-              materialSnapshotCache:
-                materialSnapshotCachesByWorld.get(onlyWorld) ??
-                (() => {
-                  const cache: MaterialSnapshotCache = new Map();
-                  materialSnapshotCachesByWorld.set(onlyWorld, cache);
-                  return cache;
-                })(),
-            }),
-        ...(options.cull === 'none' ? { cull: 'none' as const } : {}),
-        ...(options.paramSchemaProjectionCensus === undefined
-          ? {}
-          : { paramSchemaProjectionCensus: options.paramSchemaProjectionCensus }),
-      });
-      const frame = extractFrame(onlyWorld, prepared);
-      const fog = selectFog(onlyWorld, 0);
-      if (!fog.ok) {
-        routeFogSelectionError(onlyWorld, fog.error);
-        return frame;
-      }
-      return { ...frame, fog: fog.value.snapshot };
-    } catch (err) {
-      try {
-        reportRenderError(err);
-      } catch {
-        // The World error channel may throw under the default policy.
-      }
-      failedWorlds.add(onlyWorld);
-    }
-  }
-
   // ── D-2: per-world extract with error isolation ────────────────────────
   //
   // Each world runs extractFrame over the final state published by
@@ -2644,10 +2332,8 @@ export function extractFrames(
       const isCameraOwner = wi === cameraOwner;
       const cameraOwnerFrame = framesByWorld.get(cameraOwner);
       const prepared = prepareExtractContext(world, {
-        worldId: wi,
         ...(assets !== undefined ? { assets } : {}),
         ...(pipelineState !== undefined ? { pipelineState } : {}),
-        ...(gpuStore !== undefined ? { gpuStore } : {}),
         ...(materialSnapshotCachesByWorld === undefined
           ? {}
           : {
@@ -2661,9 +2347,6 @@ export function extractFrames(
             }),
         cull: options.cull === 'none' ? 'none' : isCameraOwner ? 'self' : 'external',
         ...(cameraOwnerFrame === undefined ? {} : { cullCameras: cameraOwnerFrame.cameras }),
-        ...(options.paramSchemaProjectionCensus === undefined
-          ? {}
-          : { paramSchemaProjectionCensus: options.paramSchemaProjectionCensus }),
       });
       const frame = extractFrame(world, prepared);
 
@@ -2671,7 +2354,10 @@ export function extractFrames(
     } catch (err) {
       // Per-world failure: route to world's own error handler, skip contribution.
       try {
-        reportRenderError(err);
+        createWorldInternalView(world)._routeError(err, {
+          severity: Severity.Error,
+          systemName: `RenderSystem.extractFrames(world[${wi}])`,
+        });
       } catch {
         // If _routeError itself throws, the world already failed — skip silently.
       }
@@ -2690,9 +2376,7 @@ export function extractFrames(
 
   // AC-04: renderables — concat by worlds[] order, stamp worldId.
   const renderables: RenderableSnapshot[] = [];
-  const candidateRenderables: RenderableSnapshot[] = [];
   const dispatchEntries: DispatchEntry[] = [];
-  const candidateDispatchEntries: DispatchEntry[] = [];
   const visibilitySnapshots: VisibilitySnapshot[] = [];
   const featureVisibilitySnapshots: RenderFeatureWorldVisibilitySnapshot[] = [];
   const hiddenEntityReports: RenderFeatureHiddenEntityReport[] = [];
@@ -2703,7 +2387,6 @@ export function extractFrames(
     if (f === undefined || wId === undefined) continue;
 
     const base = renderables.length;
-    const candidateBase = candidateRenderables.length;
     const visibilitySnapshot = f.visibilitySnapshots[0];
     const world = worlds[wId];
     if (visibilitySnapshot !== undefined) {
@@ -2716,18 +2399,7 @@ export function extractFrames(
       renderables.push({
         ...r,
         worldId: wId,
-        ...(r.candidateIndex !== undefined
-          ? { candidateIndex: candidateBase + r.candidateIndex }
-          : {}),
-      });
-    }
-    for (const r of f.candidateRenderables ?? f.renderables) {
-      candidateRenderables.push({
-        ...r,
-        worldId: wId,
-        ...(r.candidateIndex !== undefined
-          ? { candidateIndex: candidateBase + r.candidateIndex }
-          : {}),
+        ...(r.pointsLines === undefined ? {} : { pointsLines: { ...r.pointsLines, worldId: wId } }),
       });
     }
 
@@ -2735,22 +2407,10 @@ export function extractFrames(
     for (const d of f.dispatch) {
       dispatchEntries.push({ ...d, renderableIndex: (d.renderableIndex ?? 0) + base });
     }
-    for (const d of f.candidateDispatch ?? f.dispatch) {
-      candidateDispatchEntries.push({
-        ...d,
-        renderableIndex: (d.renderableIndex ?? 0) + candidateBase,
-      });
-    }
   }
 
   // Stable sort dispatch by queue value.
   dispatchEntries.sort((a, b) => (a.queue ?? 0) - (b.queue ?? 0));
-  candidateDispatchEntries.sort((a, b) => (a.queue ?? 0) - (b.queue ?? 0));
-  const candidateDomain = buildRenderCandidateDomain(
-    candidateRenderables,
-    candidateDispatchEntries,
-  );
-  const candidateDispatchMembership = candidateDomain.membership;
 
   // AC-04: lights — point[]/spot[] concat; directional first-hit in
   // succeededFrames order (which preserves worlds[] order for successful
@@ -2767,7 +2427,6 @@ export function extractFrames(
   let depthBias: number | undefined;
   let normalBias: number | undefined;
   let pcfKernelSize: number | undefined;
-  let directionalCsm: DirectionalCsmResult | 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
@@ -2807,10 +2466,7 @@ export function extractFrames(
     if (succeededIndices[fi] === cameraOwner) cameraOwnerFrame = succeededFrames[fi];
     if (succeededIndices[fi] === resourceOwner) resourceOwnerFrame = succeededFrames[fi];
   }
-  const cameras =
-    cameraOwnerFrame !== undefined
-      ? cameraOwnerFrame.cameras.map((camera) => ({ ...camera, worldId: cameraOwner }))
-      : [];
+  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
@@ -2842,10 +2498,8 @@ export function extractFrames(
       directionalCsmDirection,
       directionalCsmConfig,
       mergeCameraData,
-      renderCandidateCsmCandidates(candidateDomain),
     );
     if (csm !== null) {
-      directionalCsm = csm;
       lightViewProj = csm.lightViewProj;
       splitPlanes = csm.splitPlanes;
       cascadeCount = csm.cascadeCount;
@@ -2872,35 +2526,30 @@ export function extractFrames(
     pointShadow,
     directionalCsmConfig,
     directionalCsmDirection,
-    ...(directionalCsm !== undefined ? { directionalCsm, cascades: directionalCsm.cascades } : {}),
   };
-  const environment =
-    resourceOwnerFrame?.environment ??
-    ({
-      kind: 'none',
-      worldId: resourceOwner,
-      skylightCount: 0,
-      skyboxCount: 0,
-    } satisfies ExtractedEnvironment);
+  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 `'forgeax::tonemap'` param is NOT a scene resource — 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 `forgeax::tonemap` entry; taking postProcessParams from resourceOwner
+  // 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'
-  // literal 'forgeax::tonemap' mirrors the engine provider key set at the
-  // bottom of extractFrame (SSOT: same string, same 16B layout).
-  const TONEMAP_PARAM_KEY = 'forgeax::tonemap';
+  // 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);
@@ -2920,21 +2569,16 @@ export function extractFrames(
   const visibilityStats = {
     explicitlyHidden: succeededFrames.reduce((s, f) => s + f.visibilityStats.explicitlyHidden, 0),
   };
-  const resourceWorld = worlds[resourceOwner];
-  const fog = selectFog(resourceWorld, resourceOwner);
-  if (!fog.ok) routeFogSelectionError(resourceWorld, fog.error);
 
   return {
     cameras,
     lights,
     renderables,
     dispatch: dispatchEntries,
-    candidateRenderables,
-    candidateDispatch: candidateDispatchEntries,
-    candidateDispatchMembership,
-    candidateDomain,
-    fog: fog.ok ? fog.value.snapshot : undefined,
-    environment,
+    skylight,
+    skylightCount,
+    skybox,
+    skyboxCount,
     frustumStats,
     visibilityStats,
     postProcessParams,
@@ -2982,6 +2626,36 @@ function hasFiniteOrderedLocalAabb(aabb: Float32Array | undefined): aabb is Floa
   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).
@@ -2990,16 +2664,9 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   const {
     assets,
     pipelineState,
-    gpuStore,
     materialSnapshotCache: persistentMaterialSnapshotCache,
     cull: cullMode,
   } = context;
-  const reportRenderError = (
-    error: unknown,
-    errorContext?: { readonly systemName: string },
-  ): void => {
-    routeWorldError(world, error, errorContext);
-  };
   const visibility = context.visibility.hasAnyHiddenIntent ? context.visibility : undefined;
   const skinPaletteAllocator = pipelineState?.skinPaletteAllocator ?? null;
 
@@ -3011,11 +2678,13 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   //
   // Each segment routes through a World-owned Query with explicit read and
   // optional roles. The packed entity handle for `readWorldMat4Copy` /
-  // row reads come from `row.entity` -- the
+  // `_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 (row access
+  // `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
@@ -3042,14 +2711,6 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     | undefined;
   for (const row of directionalLightQuery) {
     const l = row.get(DirectionalLight);
-    const validation = validateDirectionalLightData(
-      l as unknown as Readonly<Record<string, unknown>>,
-    );
-    if (!validation.ok) {
-      reportRenderError(validation.error, {
-        systemName: 'RenderSystem.extract (directional-light)',
-      });
-    }
     directionalCount += 1;
     const intensity = l.intensity;
     const snapshot: DirectionalLightSnapshot = {
@@ -3092,24 +2753,21 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     .unwrap();
   for (const row of pointLightQuery) {
     const p = row.get(PointLight);
-    const validation = validatePointLightData(p as unknown as Readonly<Record<string, unknown>>);
-    if (!validation.ok) {
-      reportRenderError(validation.error, { systemName: 'RenderSystem.extract (point-light)' });
-    }
     // K-2 scheme B: archetype-edge sniff -- `bundle.Transform` key is absent
     // when the archetype does not carry the Transform column.
-    const transform = row.get(Transform);
+    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 (transform !== undefined) worldMat = new Float32Array(transform.world);
+    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 as unknown as mat4.Mat4Like)
-        : vec3.create(0, 0, 0);
+      worldMat !== undefined ? mat4.getTranslation(vec3.create(), worldMat) : vec3.create(0, 0, 0);
     pointSnapshots.push({
       kind: 'point',
       position,
@@ -3137,21 +2795,19 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   let spotTileNext = 0;
   for (const row of spotLightQuery) {
     const s = row.get(SpotLight);
-    const validation = validateSpotLightData(s as unknown as Readonly<Record<string, unknown>>);
-    if (!validation.ok) {
-      reportRenderError(validation.error, { systemName: 'RenderSystem.extract (spot-light)' });
-    }
-    const transform = row.get(Transform);
+    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 (transform !== undefined) worldMat = new Float32Array(transform.world);
+    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 as unknown as mat4.Mat4Like)
-        : vec3.create(0, 0, 0);
+      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
@@ -3161,6 +2817,19 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     );
     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),
@@ -3203,7 +2872,6 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
 
     spotSnapshots.push({
       kind: 'spot',
-      entity: row.entity,
       // D-6: position reflects world transform; direction stays sourced
       // from SpotLight.direction (NOT rotated by the parent).
       position,
@@ -3276,7 +2944,6 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         cascadeBlend: sf.cascadeBlend,
         mapSize: sf.mapSize,
         shadowDistance: sf.shadowDistance,
-        pcfKernelSize: sf.pcfKernelSize,
       };
       directionalCsmDirection = dirSnapshot.direction;
       const csm = computeDirectionalCsm(dirSnapshot.direction, directionalCsmConfig, cameraData);
@@ -3327,14 +2994,6 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     for (const row of pointShadowQuery) {
       const t = row.get(Transform);
       const ps = row.get(PointLightShadow);
-      const validation = validatePointLightShadowData(
-        ps as unknown as Readonly<Record<string, unknown>>,
-      );
-      if (!validation.ok) {
-        reportRenderError(validation.error, {
-          systemName: 'RenderSystem.extract (point-light-shadow)',
-        });
-      }
       // Read world-space position from Transform.world (mat4 column-major;
       // translation lives at indices 12..14, mirroring CameraSnapshot.world
       // semantics in this file).
@@ -3400,7 +3059,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     }
   }
 
-  let lights: ExtractedLights = {
+  const lights: ExtractedLights = {
     directional,
     directionalCount,
     point: pointSnapshots,
@@ -3485,56 +3144,6 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     }
   }
 
-  const environmentResult = selectEnvironmentSource({
-    resourceOwner: world,
-    worldId: context.worldId ?? 0,
-    skylight,
-    skylightCount,
-    skybox,
-    skyboxCount,
-  });
-  if (!environmentResult.ok) throw environmentResult.error;
-  const environment = environmentResult.value;
-
-  const resourceRefreshBase = context.resourceRefreshBase;
-  if (resourceRefreshBase !== undefined) {
-    const candidateDomain =
-      resourceRefreshBase.candidateDomain ??
-      buildRenderCandidateDomain(
-        resourceRefreshBase.candidateRenderables ?? resourceRefreshBase.renderables,
-        resourceRefreshBase.candidateDispatch ?? resourceRefreshBase.dispatch,
-      );
-    const finalizedDirectionalCsm =
-      directionalCsmConfig !== undefined && directionalCsmDirection !== undefined
-        ? computeDirectionalCsm(
-            directionalCsmDirection,
-            directionalCsmConfig,
-            cameraData,
-            renderCandidateCsmCandidates(candidateDomain),
-          )
-        : undefined;
-    const refreshedLights =
-      finalizedDirectionalCsm === undefined || finalizedDirectionalCsm === null
-        ? lights
-        : {
-            ...lights,
-            lightViewProj: finalizedDirectionalCsm.lightViewProj,
-            splitPlanes: finalizedDirectionalCsm.splitPlanes,
-            cascadeCount: finalizedDirectionalCsm.cascadeCount,
-            cascadeBlend: finalizedDirectionalCsm.cascadeBlend,
-            shadowMapSize: finalizedDirectionalCsm.shadowMapSize,
-            directionalCsm: finalizedDirectionalCsm,
-            cascades: finalizedDirectionalCsm.cascades,
-          };
-    return {
-      ...resourceRefreshBase,
-      cameras,
-      lights: refreshedLights,
-      environment,
-      postProcessParams: extractPostProcessParams(world, cameras),
-    };
-  }
-
   // 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)
@@ -3580,7 +3189,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       // 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 as unknown as mat4.Mat4Like);
+      mat4.invert(view, cam.world);
       const vp = mat4.create();
       mat4.multiply(vp, proj, view);
       const f = frustum.create();
@@ -3591,7 +3200,6 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
 
   const renderables: RenderableSnapshot[] = [];
   // feat-20260528-frustum-culling M3 / w11: frustum culling counters.
-  const candidateRenderables: RenderableSnapshot[] = [];
   let frustumCulled = 0;
   let frustumTotal = 0;
   const explicitlyHidden = new Set<EntityHandle>();
@@ -3614,7 +3222,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   // (`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 row values /
+  // `Instances.transforms`) still flow through `_getArrayView` /
   // `world.get(e, Instances)` -- only the `entity` source switches to
   // `row.entity`.
   //
@@ -3637,46 +3245,53 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         MeshFilter,
         Instances,
         Skin,
-        MorphWeights,
         Layer,
+        MorphWeights,
         SpriteRegionOverride,
         SpriteInstances,
+        Points,
+        Lines,
+        SortKey,
       ],
     })
     .unwrap();
-  // QueryRow deliberately exposes component data, not the matching
-  // archetype.  Instance snapshots need that archetype's version for the
-  // record-stage GPU-buffer cache key, but ordinary renderables do not.  The
-  // old path scanned every graph archetype for every matched query callback,
-  // even when the callback had no Instances/SpriteInstances column.  Keep the
-  // lookup lazy: the common mesh-rendering path does no graph walk, and an
-  // instance-bearing frame builds one first-entity -> version index instead of
-  // repeating a full scan per matched archetype.
-  // Pending entries use the stable pre-main-cull candidate index. Persistent
-  // scene may later materialize a main/shadow union, so the visible array
-  // index is intentionally not used as the producer identity.
-  const candidateDispatch: DispatchEntry[] = [];
+  // 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) candidateDispatch.push(entry);
+    for (const entry of pending) dispatch.push(entry);
   };
-  const meshRendererRows =
-    context.targetRenderableEntities === undefined
-      ? meshRendererQuery
-      : context.targetRenderableEntities.flatMap((entity) => {
-          const row = meshRendererQuery.at(entity);
-          return row === undefined ? [] : [row];
-        });
-  for (const row of meshRendererRows) {
+  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 transformData = row.get(Transform);
-    const hasTransform = transformData !== undefined;
+    const hasTransform = row.has(Transform);
     const meshFilter = row.get(MeshFilter);
     const hasInstances = row.has(Instances);
     const skin = row.get(Skin);
-    const morphWeights = row.get(MorphWeights)?.weights;
+    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:
@@ -3689,6 +3304,11 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     //   - '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
@@ -3705,8 +3325,8 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     // 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 any sprite entity -- they all wear
-    // a unit-quad MeshFilter + a `forgeax::sprite`-shaded
+    // 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):
     //
@@ -3721,7 +3341,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     // 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 its unit-quad MeshFilter
+    // 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).
@@ -3739,10 +3359,10 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     // 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 row values for the zero-copy row window
+    // 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 the row accessor as the owner of
-    // record for any non-scalar 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.
@@ -3754,11 +3374,11 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     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 = 0;
+      archVersion = resolveArchVersion(row.entity);
     }
 
     {
-      // feat-20260608 M2 / w11: read materials array via the component row
+      // feat-20260608 M2 / w11: read materials array via _getArrayView
       const entity = row.entity;
       if (isRenderable && visibility?.effective(entity) === 'hidden') {
         explicitlyHidden.add(entity);
@@ -3777,9 +3397,9 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       // the deferred-shading smoke (PR #598 CI). Pure ordering fix; cull
       // logic and MeshRenderer contract unchanged.
       const pendingDispatch: DispatchEntry[] = [];
-      const candidateIndex = candidateRenderables.length;
-      const rendererValue = row.get(MeshRenderer);
-      const materialsView = rendererValue?.materials as unknown as Uint32Array | undefined;
+      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(
@@ -3798,7 +3418,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         assets !== null
       ) {
         const meshHandle = toShared<'MeshAsset'>(fAssetHandleVal);
-        const meshRes = resolveRenderAsset<Asset>(world, meshHandle);
+        const meshRes = resolveAssetHandle<Asset>(world, meshHandle);
         if (meshRes.ok && meshRes.value.kind === 'mesh') {
           const meshAsset = meshRes.value as MeshAsset;
           gpuDrivenSubmeshes = meshAsset.submeshes;
@@ -3813,7 +3433,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           const guid = (meshRes.value as { guid?: string }).guid ?? '<no-guid>';
           const resolvedBindings = resolveMeshMaterialBindings(meshAsset, materialsView ?? [], {
             isValidOverride(handle) {
-              const resolved = resolveRenderAsset<Asset>(world, toShared<'MaterialAsset'>(handle));
+              const resolved = resolveAssetHandle(world, toShared<'MaterialAsset'>(handle));
               return resolved.ok && resolved.value.kind === 'material';
             },
             resolveMeshDefault(defaultGuid) {
@@ -3826,7 +3446,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           });
           if (!resolvedBindings.ok) {
             if (resolvedBindings.code === 'mesh-material-slots-missing') {
-              reportRenderError(
+              worldInternal._routeError(
                 new AssetError({
                   code: 'load-failed',
                   expected: 'every MeshAsset producer supplies materialSlots[]',
@@ -3837,19 +3457,20 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                     subAssetGuid: '<material-slots-missing>',
                     sourceField: { fieldName: 'materialSlots' },
                   },
-                }) as unknown as Error,
+                }),
                 {
+                  severity: Severity.Error,
                   systemName: 'RenderSystem.extract (mesh-material-slots-missing)',
                 },
               );
               continue;
             }
             const materialGuid = AssetGuid.format(resolvedBindings.defaultMaterial);
-            reportRenderError(
+            worldInternal._routeError(
               new AssetError({
                 code: 'load-failed',
                 expected: `MeshAsset materialSlots[${resolvedBindings.slotIndex}] default ${materialGuid} is ready and a MaterialAsset`,
-                hint: `AssetRegistry.load(meshGuid, meshAssetKind) must recursively load the declared default material; mesh=${guid}, slot=${resolvedBindings.slotIndex}, material=${materialGuid}`,
+                hint: `loadByGuid(meshGuid) must recursively load the declared default material; mesh=${guid}, slot=${resolvedBindings.slotIndex}, material=${materialGuid}`,
                 detail: {
                   referencedByGuid: guid,
                   referencedByKind: 'mesh',
@@ -3859,8 +3480,9 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                     arrayIndex: resolvedBindings.slotIndex,
                   },
                 },
-              }) as unknown as Error,
+              }),
               {
+                severity: Severity.Error,
                 systemName: 'RenderSystem.extract (mesh-default-not-ready)',
               },
             );
@@ -3884,7 +3506,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                   },
           }));
           for (const diagnostic of resolvedBindings.diagnostics) {
-            reportRenderError(
+            worldInternal._routeError(
               new AssetError({
                 code: diagnostic.code,
                 expected:
@@ -3904,8 +3526,9 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                         slotIndex: diagnostic.slotIndex,
                         handle: diagnostic.handle ?? 0,
                       },
-              }) as unknown as Error,
+              }),
               {
+                severity: Severity.Warning,
                 systemName: `RenderSystem.extract (${diagnostic.code})`,
               },
             );
@@ -3941,7 +3564,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
             cachedMaterial.passes,
             entity,
             handleRaw,
-            candidateIndex,
+            renderables.length,
             layerVal,
             materialSnap.paramSnapshot,
           );
@@ -3968,22 +3591,23 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
               stablePersistentCached.passes,
               entity,
               handleRaw,
-              candidateIndex,
+              renderables.length,
               layerVal,
               materialSnap.paramSnapshot,
             );
           }
         } else {
-          const res = resolveRenderAsset<Asset>(world, tagged);
+          const res = resolveAssetHandle(world, tagged);
           if (!res.ok) {
             if (isRenderable) {
               const rhiErr = new RhiError({
                 code: 'asset-not-registered',
-                expected: 'MeshRenderer.material in RenderAssetPort',
+                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 },
               });
-              reportRenderError(rhiErr as unknown as Error, {
+              worldInternal._routeError(rhiErr, {
+                severity: Severity.Error,
                 systemName: 'RenderSystem.extract (material asset-not-registered)',
               });
             }
@@ -3993,12 +3617,11 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           if (asset.kind !== 'material') {
             materialSnap = defaultMaterialSnapshot(handleRaw);
           } else {
-            const materialGuid = assets.guidOf(asset);
             // 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 = resolveMaterialFromPort(asset, assets);
+            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
@@ -4011,26 +3634,29 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                 case 'material-value-unknown':
                 case 'material-value-type-mismatch':
                 case 'material-contract-program-mismatch':
-                  reportRenderError(err as unknown as Error, {
+                  worldInternal._routeError(err, {
+                    severity: Severity.Error,
                     systemName: `RenderSystem.extract (${err.code})`,
                   });
                   break;
                 case 'material-circular-inheritance':
-                  reportRenderError(err as unknown as Error, {
+                  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.
-                  reportRenderError(err as unknown as Error, {
+                  worldInternal._routeError(err, {
+                    severity: Severity.Error,
                     systemName: `RenderSystem.extract (_materialWalk: ${err.code})`,
                   });
               }
               continue;
             }
             const resolved = resolvedResult.value;
-            const allPasses = resolved.passes ?? [];
+            const allPasses = resolved.passes;
             const firstPassShader =
               allPasses.length > 0
                 ? runtimeMaterialShaderId(allPasses[0]?.program.module, allPasses[0]?.name)
@@ -4064,50 +3690,10 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
               }
             }
 
-            const registeredShader =
-              firstPassShader === undefined
-                ? undefined
-                : assets.shaderRegistry.findMaterialArtifact(firstPassShader);
-            const registeredProjection =
-              registeredShader?.ok === true
-                ? registeredShader.value.paramSchemaProjection
-                : undefined;
-            const materialParamSchema =
-              registeredProjection?.schema ??
-              materialParametersToParamSchema(resolved.parameters ?? [], firstPassShader, assets);
-            // An admitted empty schema is valid for vertex-only/shadow
-            // shaders, but older authored material payloads can still carry
-            // texture values while their manifest schema is empty. Keep that
-            // compatibility inference alive; a non-empty admitted schema is
-            // always the sole runtime projection owner.
-            const derivedMaterialInterface =
-              registeredProjection !== undefined && registeredProjection.schema.length > 0
-                ? registeredProjection.derivedInterface
-                : materialParamSchema.length > 0
-                  ? deriveParamSchemaForCensus(
-                      materialParamSchema,
-                      context.paramSchemaProjectionCensus,
-                      'entity-extract',
-                    )
-                  : undefined;
-            if (
-              context.paramSchemaProjectionCensus !== undefined &&
-              registeredProjection !== undefined
-            ) {
-              context.paramSchemaProjectionCensus.record(
-                'registered-projection-read',
-                'entity-extract',
-              );
-              if (
-                registeredProjection.schema.length === 0 &&
-                Object.keys(resolved.values ?? {}).some((name) => name.endsWith('Texture'))
-              ) {
-                context.paramSchemaProjectionCensus.record(
-                  'empty-schema-legacy-inference',
-                  'entity-extract',
-                );
-              }
-            }
+            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
@@ -4126,20 +3712,15 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                 skinSkeletonView !== 0;
               const isPbrSkinMaterial = firstPassShader === 'forgeax::pbr-skin';
               if (hasSkinSkel && !isPbrSkinMaterial) {
-                reportRenderError(
-                  new SkinMaterialMismatchError(
-                    entity as unknown as number,
-                    firstPassShader,
-                  ) as unknown as Error,
-                  {
-                    systemName: 'RenderSystem.extract (skin-material-mismatch)',
-                  },
-                );
+                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 = resolveRenderAsset<MeshAsset>(
+                const meshResForSkinCheck = resolveAssetHandle<MeshAsset>(
                   world,
                   meshHandleForSkinCheck,
                 );
@@ -4150,15 +3731,10 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                   if (!hasSkinIdx || !hasSkinWt) {
                     const missing: 'skinIndex' | 'skinWeight' | 'both' =
                       !hasSkinIdx && !hasSkinWt ? 'both' : !hasSkinIdx ? 'skinIndex' : 'skinWeight';
-                    reportRenderError(
-                      new MaterialSkinAttrMissingError(
-                        entity as unknown as number,
-                        missing,
-                      ) as unknown as Error,
-                      {
-                        systemName: 'RenderSystem.extract (material-skin-attr-missing)',
-                      },
-                    );
+                    worldInternal._routeError(new MaterialSkinAttrMissingError(entity, missing), {
+                      severity: Severity.Error,
+                      systemName: 'RenderSystem.extract (material-skin-attr-missing)',
+                    });
                     continue;
                   }
                 }
@@ -4183,32 +3759,6 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
             const isSprite =
               firstPassShader === 'forgeax::sprite' || firstPassShader === 'forgeax::sprite-lit';
 
-            const emptySchemaTextureFields =
-              materialParamSchema.length === 0
-                ? new Set(
-                    Object.entries(pv)
-                      .filter(([, value]) => {
-                        if (materialTextureValue(value) !== undefined) return true;
-                        if (typeof value === 'number' && assets !== null && assets !== undefined) {
-                          const resolved = resolveRenderAsset<Asset>(
-                            world,
-                            value as Handle<string, 'shared'>,
-                          );
-                          return (
-                            resolved.ok &&
-                            (resolved.value.kind === 'texture' || resolved.value.kind === 'video')
-                          );
-                        }
-                        if (typeof value === 'string' && assets !== null && assets !== undefined) {
-                          const payload = assets.lookup(value);
-                          return payload?.kind === 'texture' || payload?.kind === 'video';
-                        }
-                        return false;
-                      })
-                      .map(([field]) => field),
-                  )
-                : undefined;
-
             // feat-20260613-material-paramschema-driven-binding M4 / w23
             // (D-5 graceful): paramSchema-driven texture-field validation.
             // For each handle-shaped paramValue (typeof === 'number'),
@@ -4232,7 +3782,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                 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). Final release is owner evidence.
+                // a stable handleSlot). onLastRelease -> gpuStore.evictTexture.
                 const interned = internSharedRefFromGuid(
                   world,
                   assets,
@@ -4242,34 +3792,34 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                 if (interned === undefined) return undefined;
                 handle = interned;
               } else if (typeof textureRef === 'number') {
-                handle = textureRef as unknown as Handle<'TextureAsset', 'shared'>;
+                handle = toShared<'TextureAsset'>(textureRef);
               } else {
                 return undefined;
               }
               if (assets === null || assets === undefined) return handle;
-              const declaredFields =
-                derivedMaterialInterface !== undefined
-                  ? derivedMaterialInterface.textureFieldNames
-                  : (emptySchemaTextureFields ??
-                    (firstPassShader !== undefined
-                      ? assets.materialShaderTextureFieldNames(firstPassShader)
-                      : undefined));
+              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 any
+              // 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.
-              const declared =
-                declaredFields instanceof Set
-                  ? declaredFields.has(fieldName)
-                  : Array.from(declaredFields).includes(fieldName);
-              if (!declared) {
+              if (
+                !declaredFields.has(fieldName) &&
+                !isEngineInjectedTextureField(firstPassShader, fieldName)
+              ) {
                 return undefined;
               }
               // Field declared as texture: verify the handle's asset kind.
-              const assetRes = resolveRenderAsset<Asset>(world, handle);
+              const assetRes = resolveAssetHandle(world, handle);
               if (!assetRes.ok) return undefined;
               const kind = (assetRes.value as { kind?: string }).kind;
               if (kind !== 'texture') return undefined;
@@ -4283,7 +3833,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
               brand: B,
             ): Handle<B, 'shared'> | undefined => {
               const value = materialTextureRef(raw);
-              if (typeof value === 'number') return value as unknown as Handle<B, 'shared'>;
+              if (typeof value === 'number') return toShared<B>(value);
               const guid = assetReferenceText(value);
               if (guid !== undefined) {
                 if (assets === null || assets === undefined) return undefined;
@@ -4299,15 +3849,17 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
             // carried, replacing the hardcoded 3-field list. validateTextureHandle
             // already drops fields a shader doesn't declare as a texture.
             const userRegionFields =
-              derivedMaterialInterface !== undefined
-                ? derivedMaterialInterface.textureFieldNames
-                : (emptySchemaTextureFields ??
-                  (firstPassShader !== undefined && assets !== null && assets !== undefined
+              materialTextureFields(
+                firstPassShader,
+                materialParamSchema.length > 0
+                  ? derive(materialParamSchema).textureFieldNames
+                  : firstPassShader !== undefined && assets !== null && assets !== undefined
                     ? assets.materialShaderTextureFieldNames(firstPassShader)
-                    : undefined));
+                    : 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 ?? []) {
+            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
@@ -4329,20 +3881,15 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
             const samplerHandles = collectMaterialTextureSamplers(pv, (value) =>
               resolveParamHandle(materialTextureRef(value), 'SamplerAsset'),
             );
-            const emissiveTextureHandle = textureHandles.get('emissiveTexture');
-            const occlusionTextureHandle = textureHandles.get('occlusionTexture');
-            const textureCoordinates = collectMaterialTextureCoordinates(
-              pv,
-              materialParamSchema,
-              derivedMaterialInterface,
+            const emissiveTextureHandle = validateTextureHandle(
+              'emissiveTexture',
+              pv.emissiveTexture,
             );
-            const textureFacts = new Map<string, TextureAsset>();
-            for (const [name, handle] of textureHandles) {
-              const resolvedTexture = resolveRenderAsset<Asset>(world, handle);
-              if (resolvedTexture.ok && resolvedTexture.value.kind === 'texture') {
-                textureFacts.set(name, resolvedTexture.value);
-              }
-            }
+            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
@@ -4369,10 +3916,11 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
               // SpriteRegionOverride: per-entity per-frame region displacement.
               let overrideRegion: readonly [number, number, number, number] | undefined;
               if (hasSpriteRegionOverride) {
-                const overrideValue = world.get(entity, SpriteRegionOverride);
-                const overrideView = overrideValue.ok
-                  ? (overrideValue.value.region as unknown as Float32Array)
-                  : undefined;
+                const overrideView = worldInternal._getArrayView(
+                  entity,
+                  SpriteRegionOverride,
+                  'region',
+                ) as Float32Array | undefined;
                 if (overrideView !== undefined && overrideView.length >= 4) {
                   overrideRegion = [
                     overrideView[0] ?? 0,
@@ -4402,36 +3950,18 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                 regionY += regionW;
                 regionW = -regionW;
               }
-              paramSnap.region = [regionX, regionY, regionZ, regionW] as unknown as number[];
+              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] rather than leaving unrelated derived payload
-              // values in that slot. A non-zero slicesAndMode trips
-              // `useSlices=true` in sprite.wgsl, which degenerates a four-vertex quad
-              // geometry -> invisible.
+              // 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];
               }
             }
 
-            // Sprite-specific region/slice values are folded into paramSnap
-            // above. Build the derived projection afterwards so the record
-            // stage writes those values through the same schema-owned payload
-            // as every other material parameter.
-            const derivedMaterialSlot =
-              materialParamSchema.length > 0
-                ? deriveMaterialSlotProjection({
-                    material: String(handleRaw),
-                    schema: materialParamSchema,
-                    ...(derivedMaterialInterface === undefined
-                      ? {}
-                      : { derivedInterface: derivedMaterialInterface }),
-                    values: { ...pv, ...paramSnap },
-                    coordinates: textureCoordinates,
-                    textures: textureFacts,
-                  })
-                : undefined;
-
             // 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
@@ -4452,18 +3982,10 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
               }),
               normalScale: normalScalePv,
               materialShaderId: firstPassShader,
-              ...(materialGuid === undefined ? {} : { materialGuid }),
               materialHandle: handleRaw,
-              shadowCaster: hasShadowCasterPass(allPasses),
               renderState: pipelineRenderState(allPasses[0]?.renderState),
               paramSnapshot: paramSnap,
               ...(materialParamSchema.length > 0 && { materialParamSchema }),
-              ...(derivedMaterialSlot?.ok === true && {
-                derivedMaterialSlot: derivedMaterialSlot.value,
-              }),
-              ...(derivedMaterialSlot?.ok === false && {
-                derivedMaterialError: derivedMaterialSlot.error,
-              }),
               ...(textureCoordinates.size > 0 && { textureCoordinates }),
               ...(samplerHandles.size > 0 && { samplerHandles }),
               ...(textureHandles.size > 0 && { textureHandles }),
@@ -4516,7 +4038,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                 allPasses,
                 entity,
                 handleRaw,
-                candidateIndex,
+                renderables.length,
                 layerVal,
                 paramSnap,
               );
@@ -4550,7 +4072,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
       // handleRaw===0 guard alone preserves the exact same dispatch shape.
       if (isRenderable && handleRaw === 0) {
         const shadowCasterTags: Record<string, string> = { LightMode: 'ShadowCaster' };
-        const nextRenderableIndex = candidateIndex;
+        const nextRenderableIndex = renderables.length;
         // M2.5: stage into pendingDispatch; flushed at the renderable push
         // site below only when the entity survives cull.
         pendingDispatch.push({
@@ -4558,7 +4080,7 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           materialHandle: 0,
           renderableIndex: nextRenderableIndex,
           passIndex: 0,
-          queue: RenderQueue.Geometry,
+          queue: 2000,
           layer: layerVal,
           tags: shadowCasterTags,
           renderState: undefined,
@@ -4570,22 +4092,16 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         });
         // Also add a Forward pass entry so the entity renders in the
         // main scene pass (mirrors Materials.unlit default).
-        const forwardTags: Record<string, string> = { LightMode: 'Forward' };
-        pendingDispatch.push({
-          entityIndex: entity,
-          materialHandle: 0,
-          renderableIndex: nextRenderableIndex,
-          passIndex: 1,
-          queue: RenderQueue.Geometry,
-          layer: layerVal,
-          tags: forwardTags,
-          renderState: undefined,
-          defines: undefined,
-          vertexEntry: 'vs_main',
-          fragmentEntry: 'fs_main',
-          materialShaderId: 'forgeax::default-unlit',
-          paramSnapshot: {},
-        });
+        appendMaterialDispatchEntries(
+          pendingDispatch,
+          [DEFAULT_FORWARD_PASS],
+          entity,
+          0,
+          nextRenderableIndex,
+          layerVal,
+          {},
+          1,
+        );
       }
 
       if (isRenderable) {
@@ -4605,30 +4121,21 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           ) {
             // Skin + Instances coexistence is forbidden (D-10).
             if (hasInstances) {
-              reportRenderError(
-                new SkinInstancesCoexistForbiddenError(
-                  entity as unknown as number,
-                ) as unknown as Error,
-                {
-                  systemName: 'RenderSystem.extract (skin-instances-coexist)',
-                },
-              );
+              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 = resolveRenderAsset<SkeletonAsset>(world, skeletonHandle);
+            const skeletonRes = resolveAssetHandle<SkeletonAsset>(world, skeletonHandle);
             if (!skeletonRes.ok || skeletonRes.value.kind !== 'skeleton') {
-              reportRenderError(
-                new SkeletonResolveFailedError(
-                  entity as unknown as number,
-                  skeletonHandleRaw,
-                ) as unknown as Error,
-                {
-                  systemName: 'RenderSystem.extract (skeleton-resolve-failed)',
-                },
-              );
+              worldInternal._routeError(new SkeletonResolveFailedError(entity, skeletonHandleRaw), {
+                severity: Severity.Error,
+                systemName: 'RenderSystem.extract (skeleton-resolve-failed)',
+              });
               continue;
             }
             const skeleton = skeletonRes.value;
@@ -4638,20 +4145,17 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
             if (skinJoints === undefined) continue;
             const jointsLength = skinJoints.length;
             if (jointsLength !== skeleton.jointCount) {
-              reportRenderError(
-                new JointCountMismatchError(
-                  entity as unknown as number,
-                  skeleton.jointCount,
-                  jointsLength,
-                ) as unknown as Error,
+              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 any structural mutation and
+            // 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
@@ -4660,27 +4164,24 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
             let jointDangling = -1;
             for (let jIdx = 0; jIdx < skeleton.jointCount; jIdx++) {
               const jointEntityRaw = skinJoints[jIdx] ?? 0;
-              const jointEntity = jointEntityRaw as unknown as EntityHandle;
-              const jointTransform = world.get(jointEntity, Transform);
-              if (!jointTransform.ok) {
+              const jointEntity = jointEntityRaw as EntityHandle;
+              const jointWorld = worldInternal._getArrayView(jointEntity, Transform, 'world');
+              if (jointWorld === undefined) {
                 jointDangling = jIdx;
                 break;
               }
-              // The view aliases the column-stored 16-float mat4 (column-major).
-              // Allocator's writeJointPalette expects a Mat4-shaped Float32Array.
-              // brand-cast-ok: reinterpret an existing storage view, no alloc.
-              jointWorlds[jIdx] = jointTransform.value.world as unknown as Mat4;
+              // 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) {
-              reportRenderError(
-                new JointEntityDanglingError(
-                  entity as unknown as number,
-                  jointDangling,
-                ) as unknown as Error,
-                {
-                  systemName: 'RenderSystem.extract (joint-entity-dangling)',
-                },
-              );
+              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.
@@ -4699,7 +4200,6 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
               skinPaletteAllocator.writeJointPalette(slice, ibms, jointWorlds);
               skinSlice = {
                 jointCount: slice.jointCount,
-                jointMatrices: new Float32Array(slice.jointMatrices),
                 byteOffset: slice.byteOffset,
                 buffer: slice.buffer,
               };
@@ -4712,14 +4212,11 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         // 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: row access stays zero-copy;
+        // tweak-20260611 M1 / K-3: `_getArrayView` call survives untouched;
         // only the `entity` source switched to `bundle.Entity.self[i]`.
-        if (transformData === undefined) continue;
-        const worldMat = new Float32Array(transformData.world);
-        const boundsWorld = authoredBoundsWorld(worldMat, transformData);
-        const candidateInstanceTransforms = hasInstances
-          ? (row.get(Instances)?.transforms as unknown as Float32Array | undefined)
-          : undefined;
+        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
@@ -4741,14 +4238,30 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
                   subHandle,
                   world,
                   assets,
-                  gpuStore,
                   materialSnapshotCache,
                   persistentMaterialSnapshotCache,
-                  context.paramSchemaProjectionCensus,
                 ),
             );
           }
         }
+        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.
@@ -4758,11 +4271,10 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         if (hasSpriteInstances) {
           // (1) mutually exclusive with Instances (peers — pick one).
           if (hasInstances) {
-            reportRenderError(
-              new SpriteInstancesMutuallyExclusiveWithInstancesError(
-                entity as unknown as number,
-              ) as unknown as Error,
+            worldInternal._routeError(
+              new SpriteInstancesMutuallyExclusiveWithInstancesError(entity),
               {
+                severity: Severity.Error,
                 systemName: 'RenderSystem.extract (sprite-instances-mutually-exclusive)',
               },
             );
@@ -4781,12 +4293,13 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
             materialSnap.materialShaderId !== 'forgeax::sprite' &&
             materialSnap.materialShaderId !== 'forgeax::sprite-lit'
           ) {
-            reportRenderError(
+            worldInternal._routeError(
               new SpriteInstancesRequiresSpriteShaderError(
-                entity as unknown as number,
+                entity,
                 materialSnap.materialShaderId ?? 'undefined',
-              ) as unknown as Error,
+              ),
               {
+                severity: Severity.Error,
                 systemName: 'RenderSystem.extract (sprite-instances-requires-sprite-shader)',
               },
             );
@@ -4795,9 +4308,8 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           // (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 spriteValue = row.get(SpriteInstances);
-          const transforms = spriteValue?.transforms as unknown as Float32Array | undefined;
-          const regions = spriteValue?.regions as unknown as Float32Array | undefined;
+          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;
@@ -4808,12 +4320,10 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
             const tCount = transformsLength / 16;
             const rCount = regionsLength / 4;
             if (transformsLength % 16 !== 0 || regionsLength % 4 !== 0 || tCount !== rCount) {
-              reportRenderError(
-                new SpriteInstancesCountMismatchError(
-                  transformsLength,
-                  regionsLength,
-                ) as unknown as Error,
+              worldInternal._routeError(
+                new SpriteInstancesCountMismatchError(transformsLength, regionsLength),
                 {
+                  severity: Severity.Error,
                   systemName: 'RenderSystem.extract (sprite-instances-count-mismatch)',
                 },
               );
@@ -4828,35 +4338,71 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
               transforms: transformsCopy,
               regions: regionsCopy,
               instanceCount: tCount,
-              cacheKey: entity as unknown as number,
+              cacheKey: entity,
               archVersion,
             };
           }
         }
 
         let localAabb: Float32Array | undefined;
+        let morph: MorphSnapshot | undefined;
         const assetHandleRaw = Math.round(fAssetHandle ?? 0);
         if (assetHandleRaw !== 0) {
-          const meshRes = resolveRenderAsset<MeshAsset>(
-            world,
-            toShared<'MeshAsset'>(assetHandleRaw),
-          );
-          const meshAabb = meshRes.ok ? (meshRes.value as MeshAsset).aabb : undefined;
-          if (hasFiniteOrderedLocalAabb(meshAabb)) localAabb = new Float32Array(meshAabb);
+          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, submeshIndex) => {
+        const gpuDrivenDraws = gpuDrivenSubmeshes.flatMap((submesh) => {
           const drawMaterial = materialsArr[submesh.materialSlot] ?? materialSnap;
-          const forwardPass = gpuDrivenForwardPass(drawMaterial, materialSnapshotCache);
           const first = gpuDrivenIndexed ? submesh.indexOffset : nonIndexedFirst;
           nonIndexedFirst += submesh.vertexCount;
-          if (drawMaterial.transparent === true || forwardPass === undefined) return [];
+          if (drawMaterial.transparent === true) return [];
           return [
             {
-              submeshIndex,
-              passIndex: forwardPass.passIndex,
-              queue: forwardPass.queue,
               kind: gpuDrivenIndexed ? ('indexed' as const) : ('non-indexed' as const),
               first,
               count: gpuDrivenIndexed ? submesh.indexCount : submesh.vertexCount,
@@ -4871,53 +4417,20 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
         const baseRenderable: RenderableSnapshot = {
           assetHandle: Math.round(fAssetHandle ?? 0),
           transform: transformSnap,
-          ...(boundsWorld !== undefined ? { boundsWorld } : {}),
-          ...(candidateInstanceTransforms !== undefined
-            ? { candidateInstanceTransforms: new Float32Array(candidateInstanceTransforms) }
-            : {}),
-          ...(localAabb !== undefined ? { localAabb } : {}),
+          ...(localAabb !== undefined ? { localAabb: cullingLocalAabb } : {}),
           material: materialSnap,
           materials: materialsArr,
           materialBindingSources,
           materialBindingDiagnostics,
-          ...(gpuDrivenDraws.length === 0 ? {} : { gpuDrivenDraws }),
+          ...(morph === undefined && gpuDrivenDraws.length > 0 ? { gpuDrivenDraws } : {}),
           worldId: 0,
-          entityKey: entity as unknown as number,
-          candidateIndex,
+          entityKey: entity,
           ...(skinSlice !== undefined ? { skin: skinSlice } : {}),
-          ...(morphWeights === undefined ? {} : { morphWeights: new Float32Array(morphWeights) }),
+          ...(morph !== undefined ? { morph } : {}),
           ...(spriteInstancesSnap !== undefined ? { spriteInstances: spriteInstancesSnap } : {}),
+          ...(pointsLines !== undefined ? { pointsLines } : {}),
         };
 
-        let publishedRenderable = baseRenderable;
-        if (hasInstances) {
-          const instanceValue = row.get(Instances);
-          const transforms = instanceValue?.transforms as unknown as Float32Array | undefined;
-          if (transforms !== undefined) {
-            const actualLength = transforms.length;
-            if (actualLength % 16 !== 0) {
-              reportRenderError(new InstanceTransformsStrideMismatchError(actualLength), {
-                systemName: 'RenderSystem.extract (Instances stride)',
-              });
-
-              continue;
-            }
-            publishedRenderable = {
-              ...baseRenderable,
-              instances: {
-                transforms: new Float32Array(transforms),
-                instanceCount: Math.max(1, Math.floor(actualLength / 16)),
-                cacheKey: entity as unknown as number,
-                archVersion,
-              },
-            };
-          }
-        }
-
-        // Publish only the final, validated candidate snapshot. Its index is
-        // the current candidate-domain slot used by the staged dispatch.
-        candidateRenderables.push(publishedRenderable);
-
         // 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
@@ -4929,13 +4442,9 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           // 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,
-            localAabb,
-            transformSnap.world as unknown as Parameters<typeof box3.transformBox3>[2],
-          );
+          box3.transformBox3(worldAabb, cullingLocalAabb, transformSnap.world);
 
-          // Test against all cameras. Entity is visible if any camera
+          // 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;
@@ -4953,13 +4462,42 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
           }
           if (!visible) {
             frustumCulled += 1;
-            for (const entry of pendingDispatch) candidateDispatch.push(entry);
             continue;
           }
         }
 
-        flushPendingDispatch(pendingDispatch);
-        renderables.push(publishedRenderable);
+        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
@@ -4973,53 +4511,9 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     }
   }
 
-  // M3 / w26: sort dispatch entries by queue (ascending, stable sort). The
-  // candidate dispatch stays pre-main-cull; the legacy dispatch is projected
-  // back to the visible subset for existing callers.
-  const visibleByCandidate = new Map<number, number>();
-  for (let index = 0; index < renderables.length; index += 1) {
-    const candidateIndex = renderables[index]?.candidateIndex;
-    if (candidateIndex !== undefined) visibleByCandidate.set(candidateIndex, index);
-  }
-  const sortedCandidateDispatch = sortDispatchByQueue(candidateDispatch);
-  const candidateDomain = buildRenderCandidateDomain(candidateRenderables, sortedCandidateDispatch);
-  const candidateDispatchMembership = candidateDomain.membership;
-  dispatch = sortDispatchByQueue(
-    sortedCandidateDispatch.flatMap((entry) => {
-      const renderableIndex = visibleByCandidate.get(entry.renderableIndex);
-      return renderableIndex === undefined ? [] : [{ ...entry, renderableIndex }];
-    }),
-  );
-  const finalizedDirectionalCsm =
-    directionalCsmConfig !== undefined && directionalCsmDirection !== undefined
-      ? computeDirectionalCsm(
-          directionalCsmDirection,
-          directionalCsmConfig,
-          cameraData,
-          renderCandidateCsmCandidates(candidateDomain),
-        )
-      : undefined;
-  if (finalizedDirectionalCsm !== null && finalizedDirectionalCsm !== undefined) {
-    lightViewProj = finalizedDirectionalCsm.lightViewProj;
-    splitPlanes = finalizedDirectionalCsm.splitPlanes;
-    cascadeCount = finalizedDirectionalCsm.cascadeCount;
-    cascadeBlend = finalizedDirectionalCsm.cascadeBlend;
-    shadowMapSize = finalizedDirectionalCsm.shadowMapSize;
-  }
-  lights = {
-    ...lights,
-    lightViewProj,
-    splitPlanes: splitPlanes !== undefined ? paddedSplitPlanes : undefined,
-    cascadeCount,
-    cascadeBlend,
-    shadowMapSize,
-    ...(finalizedDirectionalCsm !== null && finalizedDirectionalCsm !== undefined
-      ? {
-          directionalCsm: finalizedDirectionalCsm,
-          cascades: finalizedDirectionalCsm.cascades,
-        }
-      : {}),
-  };
+  // 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
@@ -5037,17 +4531,17 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   // 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 `'forgeax::tonemap'` shader
+  // 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 `'forgeax::tonemap'`). The single active camera mirrors
+  // 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('forgeax::tonemap', tonemapParams(tonemapCamera));
+    postProcessParams.set(STANDARD_TONEMAP_FEATURE_ID, tonemapParams(tonemapCamera));
   }
 
   return {
@@ -5055,11 +4549,10 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
     lights,
     renderables,
     dispatch,
-    candidateRenderables,
-    candidateDispatch: sortedCandidateDispatch,
-    candidateDispatchMembership,
-    candidateDomain,
-    environment,
+    skylight,
+    skylightCount,
+    skybox,
+    skyboxCount,
     frustumStats: { culled: frustumCulled, total: frustumTotal },
     visibilityStats: { explicitlyHidden: explicitlyHidden.size },
     postProcessParams,
@@ -5069,135 +4562,24 @@ export function extractFrame(world: World, context: PreparedExtractContext): Ext
   };
 }
 
-/**
- * Extract the complete render-domain facts for one known entity.
- *
- * This deliberately reuses extractFrame's MeshRenderer row body instead of
- * maintaining a second material/skin/sprite implementation. Query.at() makes
- * the row source identity-addressed; callers must supply a visibility snapshot
- * appropriate for the current persistent owner and must keep hierarchy-affecting
- * changes on the conservative rebuild lane.
- */
-export interface ExtractedRenderableEntity {
-  readonly snapshot: RenderableSnapshot;
-  readonly candidateDispatch: readonly DispatchEntry[];
-}
-
-export function extractRenderableEntity(
-  world: World,
-  entity: EntityHandle,
-  context: PreparedExtractContext,
-): ExtractedRenderableEntity | undefined {
-  const frame = extractFrame(world, {
-    ...context,
-    cull: 'none',
-    cullCameras: undefined,
-    targetRenderableEntities: [entity],
-  });
-  const domain =
-    frame.candidateDomain ??
-    buildRenderCandidateDomain(
-      frame.candidateRenderables ?? frame.renderables,
-      frame.candidateDispatch ?? frame.dispatch,
-    );
-  const candidateIndex = domain.indexByIdentity.get(`0:${entity}`);
-  if (candidateIndex === undefined) return undefined;
-  const snapshot = domain.renderables[candidateIndex];
-  if (snapshot === undefined) return undefined;
-  return {
-    snapshot,
-    candidateDispatch: domain.dispatch.filter((entry) => entry.renderableIndex === candidateIndex),
-  };
-}
-
-const RESOURCE_REFRESH_HIERARCHY: SceneHierarchySnapshot = {
-  parentOf: new Map(),
-  diagnostics: [],
-  getParent: () => undefined,
-};
-
-const RESOURCE_REFRESH_VISIBILITY: VisibilitySnapshot = {
-  diagnostics: [],
-  hasAnyIntent: false,
-  hasAnyHiddenIntent: false,
-  get: () => undefined,
-  effective: () => 'visible',
-};
-
-/**
- * Refresh only light, shadow, sky, and post-process resources over an existing
- * persistent frame. The resource path intentionally skips hierarchy,
- * renderable, material, cull, dispatch, and candidate-domain extraction.
- */
-export function refreshExtractedFrameLights(world: World, frame: ExtractedFrame): ExtractedFrame {
-  const refreshed = extractFrame(world, {
-    assets: undefined,
-    pipelineState: undefined,
-    gpuStore: undefined,
-    materialSnapshotCache: undefined,
-    cull: 'none',
-    cullCameras: undefined,
-    hierarchy: RESOURCE_REFRESH_HIERARCHY,
-    visibility: frame.visibilitySnapshots[0] ?? RESOURCE_REFRESH_VISIBILITY,
-    resourceRefreshBase: frame,
-  });
-  const fog = selectFog(world, 0);
-  if (!fog.ok) {
-    routeFogSelectionError(world, fog.error);
-    return refreshed;
-  }
-  return { ...refreshed, fog: fog.value.snapshot };
-}
-
-export function defaultTransformSnapshot(): TransformSnapshot {
-  // Identity world mat4 (column-major 16 floats).
-  return {
-    world: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
-  };
-}
-
-// The default material path is hit once per renderable. Deriving its schema
-// also hashes the layout, so retain the immutable projection instead of doing
-// that work for every entity in a frame.
-const DEFAULT_UNLIT_DERIVED_MATERIAL_SLOT = (() => {
-  const derived = deriveMaterialSlotProjection({
-    material: '0',
-    schema: DEFAULT_UNLIT_PARAM_SCHEMA,
-    values: { baseColor: [0.5, 0.5, 0.5, 1], alphaCutoff: 0 },
-    coordinates: defaultMaterialTextureCoordinates(DEFAULT_UNLIT_PARAM_SCHEMA),
-  });
-  if (!derived.ok) throw new Error('engine default material schema must derive');
-  return derived.value;
-})();
-const DEFAULT_MATERIAL_SNAPSHOT: MaterialSnapshot = Object.freeze({
-  baseColor: vec3.create(0.5, 0.5, 0.5),
-  metallic: 0,
-  roughness: 1,
-  materialHandle: 0,
-  materialParamSchema: DEFAULT_UNLIT_PARAM_SCHEMA,
-  derivedMaterialSlot: DEFAULT_UNLIT_DERIVED_MATERIAL_SLOT,
-});
-
 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.
-  const materialParamSchema = DEFAULT_UNLIT_PARAM_SCHEMA;
-  if (materialHandle === 0) return DEFAULT_MATERIAL_SNAPSHOT;
-  const derivedMaterialSlot = deriveMaterialSlotProjection({
-    material: String(materialHandle),
-    schema: materialParamSchema,
-    values: { baseColor: [0.5, 0.5, 0.5, 1], alphaCutoff: 0 },
-    coordinates: defaultMaterialTextureCoordinates(materialParamSchema),
-  }).unwrap();
   return {
     baseColor: vec3.create(0.5, 0.5, 0.5),
     metallic: 0,
     roughness: 1,
     materialHandle,
-    shadowCaster: true,
-    materialParamSchema,
-    derivedMaterialSlot,
   };
 }
+
+function identityProjection(): Float32Array {
+  const projection = new Float32Array(16);
+  projection[0] = 1;
+  projection[5] = 1;
+  projection[10] = 1;
+  projection[15] = 1;
+  return projection;
+}