@forgeax/engine-render 0.1.4 → 0.1.6

package/src/record/frame.ts

@@ -1,74 +1,47 @@
 // @forgeax/engine-runtime - RenderSystem record stage: frame.
 // Extracted from render-system-record.ts (feat-20260704 M3/w17, pure move).
 
+import { HANDLE_NINESLICE_QUAD, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import type { World } from '@forgeax/engine-ecs';
-import { createWorldProjection } from '@forgeax/engine-ecs/projection';
-import { type RhiCommandEncoder, RhiError, type TextureView } from '@forgeax/engine-rhi';
-import type { MaterialRenderState, MeshAsset } from '@forgeax/engine-types';
-import { toShared } from '@forgeax/engine-types';
-import { resolveRenderAsset } from '../assets/resolve-render-asset';
-import type { EngineMetrics } from '../engine-metrics';
-import type { ExtractedEnvironment } from '../environment/extracted-environment';
-import {
-  beginEnvironmentGeneration,
-  environmentConsumerSnapshot,
-  publishEnvironmentGeneration,
-} from '../environment/generation';
-import { createEnvironmentGpuBundle } from '../environment/gpu-bundle';
-import type { EnvironmentTransactionAttempt } from '../environment/graph';
+import type { RenderReadLease } from '@forgeax/engine-ecs/projection';
 import {
-  completeEnvironmentQueue,
-  destroyCompletedEnvironmentGenerations,
-  resizeEnvironmentGeneration,
-} from '../environment/lifecycle';
+  type CurrentFrameObservationLease,
+  createCurrentFrameObservationLease,
+} from '@forgeax/engine-render-graph';
 import {
-  deriveEnvironmentBundleDescriptors,
-  environmentBundleBytes,
-  environmentSignature,
-} from '../environment/signature';
-import { buildSubmissionCandidateMembership } from '../gpu-driven/batch-topology';
+  err,
+  ok,
+  type Result,
+  type RhiCommandEncoder,
+  RhiError,
+  type TextureFormat,
+  type TextureView,
+} from '@forgeax/engine-rhi';
+import type { MaterialRenderState, MeshAsset } from '@forgeax/engine-types';
+import { handleSlot, toShared } from '@forgeax/engine-types';
+import type { MeshGpuHandles } from '../device/gpu-residency';
+import { ObservationUnavailableError, type ObservationUnavailableReason } from '../errors/render';
 import type { GpuDrivenProduction, PreparedGpuDrivenFrame } from '../gpu-driven/production-raster';
-import type { CpuMultiViewVisibilityResult } from '../gpu-driven/view-gpu';
+import { GpuBuffer } from '../gpu-resource';
+import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_VERTEX } from '../gpu-usage';
 import { disposeTransientInstanceBuffers } from '../instance-buffer-cache';
-import type { PersistentGpuDrivenState } from '../persistent-render-scene';
-import type { _InternalRenderPipelineContext } from '../render-pipeline-context';
-import type { RenderSceneProjection, RenderSceneSubmissionDelta } from '../render-scene-projection';
-import type { MeshGpuHandles, RenderSystemInternals } from '../render-system';
+import type { CameraSnapshot, RenderRecordPhase } from '../render-contract';
 import type {
-  CameraSnapshot,
   DispatchEntry,
   ExtractedLights,
-  FogSnapshot,
   MaterialSnapshot,
   RenderableSnapshot,
+  SkyboxSnapshot,
+  SkylightSnapshot,
 } from '../render-system-extract';
-// feat-20260622-chunk-gpu-instancing-sprite-tilemap M1 / w4 (D-1 record-stage
-// fold operator). Pure linear-scan helper that groups transparent-dispatch
-// entries with equal (Layer.value, sortKey, materialHandle) into FoldBucket
-// descriptors. The drawIndexed swap (1 instanced draw per bucket vs N
-// per-entity draws) hooks into the sprite-pass dispatch loop below
-// (w4-record-swap), using {@link buildFoldDispatchPlan} to translate
-// renderableIndex-keyed buckets into validatedOrdered-index-keyed
-// head/skip maps.
-import {
-  buildFoldDispatchPlan,
-  evaluateFoldBucketUniformCap,
-  type FoldBucket,
-  type FoldDispatchPlan,
-  foldDispatchBuckets,
-  incrementFoldedDrawsMetric,
-} from '../render-system-fold';
-import type { RenderRecordPhase } from '../renderer';
+import type { PersistentGpuDrivenState } from '../scene/render-scene';
 import {
   getTransparentSortConfig,
   TRANSPARENT_SORT_MODE_LAYER_Y,
   TRANSPARENT_SORT_MODE_LAYER_Z,
 } from '../systems/transparent-sort-config';
-import type { TemporalCoverageSummary } from '../temporal-coverage';
-import type { TemporalFrameAttempt, TemporalFrameTransaction } from '../temporal-frame-transaction';
 import {
   buildPerFrameBindGroups,
-  createEnvironmentConsumerSnapshot,
   prepareFrameLighting,
   resolveSkyboxActive,
   warnZeroLightStandard,
@@ -78,16 +51,139 @@ import {
 } from './frame-lighting';
 import {
   type BindGroupCounts,
-  clampPcfKernelSize,
   type DirectionalShadowCache,
   type DirectionalShadowWorldState,
   type DispatchCounts,
+  type FrameObservationSource,
   makeZeroCameraFallbackSnapshot,
-  type RasterItemKey,
   type RenderFrameState,
   type ValidatedRenderable,
   worldEntityKey,
 } from './frame-snapshot';
+// feat-20260622-chunk-gpu-instancing-sprite-tilemap M1 / w4 (D-1 record-stage
+// fold operator). Pure linear-scan helper that groups transparent-dispatch
+// entries with equal (Layer.value, sortKey, materialHandle) into FoldBucket
+// descriptors. The drawIndexed swap (1 instanced draw per bucket vs N
+// per-entity draws) hooks into the sprite-pass dispatch loop below
+// (w4-record-swap), using {@link buildFoldDispatchPlan} to translate
+// renderableIndex-keyed buckets into validatedOrdered-index-keyed
+// head/skip maps.
+import {
+  buildFoldDispatchPlan,
+  evaluateFoldBucketUniformCap,
+  type FoldBucket,
+  type FoldDispatchPlan,
+  foldDispatchBuckets,
+  incrementFoldedDrawsMetric,
+} from './mesh-ssbo';
+import type {
+  _InternalRenderPipelineContext,
+  PipelineState,
+  RenderSystemInternals,
+} from './render-context';
+
+export type { FrameObservationSource } from './frame-snapshot';
+
+export type FrameObservationReadback = (
+  lease: CurrentFrameObservationLease,
+) => Promise<Result<Uint8Array, Error>>;
+
+export interface FrameObservationOptions {
+  readonly semantic: 'linear-hdr';
+  readonly readback: FrameObservationReadback;
+}
+
+export interface FrameObservationMetadata {
+  readonly format: TextureFormat;
+  readonly size: { readonly width: number; readonly height: number };
+  readonly usage: number;
+  readonly sample: number;
+  readonly frameId: number;
+  readonly lifetime: { readonly frameId: number; readonly state: 'active' | 'retired' };
+  readonly pipelineId: 'forgeax::standard';
+  readonly backendId: string;
+}
+
+export interface FrameObservation {
+  readonly bytes: Uint8Array;
+  readonly metadata: FrameObservationMetadata;
+}
+
+function unavailable(
+  reason: ObservationUnavailableReason,
+  hint: string,
+): Result<never, ObservationUnavailableError> {
+  return err(new ObservationUnavailableError(reason, hint));
+}
+
+function mapLeaseFailure(code: string, hint: string): Result<never, ObservationUnavailableError> {
+  let reason: ObservationUnavailableReason = 'resource';
+  if (code === 'observation-stale') reason = 'stale';
+  else if (code === 'observation-invalid-format') reason = 'format';
+  else if (code === 'observation-missing-copy-src') reason = 'copy-src';
+  return unavailable(reason, hint);
+}
+
+export async function observeCurrentFrame(
+  options: FrameObservationOptions,
+  source: FrameObservationSource | undefined,
+  currentFrameId: number,
+): Promise<Result<FrameObservation, ObservationUnavailableError>> {
+  if (options.semantic !== 'linear-hdr') {
+    return unavailable('identity', 'request the producer-owned linear-hdr semantic');
+  }
+  if (source === undefined) {
+    return unavailable(
+      'no-frame',
+      'draw a frame through the Standard producer before requesting observation',
+    );
+  }
+  if (source.pipelineId !== 'forgeax::standard' || source.backendId.length === 0) {
+    return unavailable(
+      'identity',
+      'observe a producer with explicit pipeline and backend identity',
+    );
+  }
+
+  const leaseResult = createCurrentFrameObservationLease(
+    { ...source.descriptor, texture: source.texture, frameId: source.frameId },
+    currentFrameId,
+  );
+  if (!leaseResult.ok) {
+    return mapLeaseFailure(leaseResult.error.code, leaseResult.error.hint);
+  }
+
+  let bytesResult: Result<Uint8Array, Error>;
+  try {
+    bytesResult = await options.readback(leaseResult.value);
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    return unavailable('readback-failed', `retry the current-frame readback after: ${message}`);
+  }
+  if (!bytesResult.ok) {
+    return unavailable('readback-failed', bytesResult.error.message);
+  }
+
+  const activeResult = leaseResult.value.beginReadback();
+  if (!activeResult.ok) {
+    return mapLeaseFailure(activeResult.error.code, activeResult.error.hint);
+  }
+
+  return ok({
+    bytes: bytesResult.value,
+    metadata: {
+      format: leaseResult.value.descriptor.format,
+      size: leaseResult.value.descriptor.size,
+      usage: leaseResult.value.descriptor.usage,
+      sample: source.descriptor.sample,
+      frameId: source.frameId,
+      lifetime: leaseResult.value.lifetime,
+      pipelineId: source.pipelineId,
+      backendId: source.backendId,
+    },
+  });
+}
+
 import {
   acquireSwapChainTarget,
   graphExecutionPhase,
@@ -102,62 +198,89 @@ import {
   warnMultiSkybox,
   warnMultiSkylight,
 } from './helpers';
-import { computeSplitLdrSprite } from './main-pass-sprite';
-import {
-  buildMaterialSlotPlan,
-  findRenderablePrefixForSlotCapacity,
-  materialSlotCountForPrefix,
-} from './material-slot-plan';
+import { computeSplitLdrSprite } from './main-pass-sprite-draws';
 import { cleanPerEntityCache, ensureMeshSsboCapacity, uploadMeshSsboBatch } from './mesh-ssbo';
-import { writeShadowCasterUniforms } from './shadow-caster-uniform';
-import { ensureCompiledFrameGraph, executeCompiledFrameGraph } from './typed-frame-graph';
+import { writeShadowCasterUniforms } from './shadow-pass';
+import {
+  ensureCompiledFrameGraph,
+  executeCompiledFrameGraph,
+  type RenderFeatureGraphCandidate,
+} from './typed-frame-graph';
 import { writeViewUbo } from './view-ubo';
 
-export type RecordProfileRunner = <T>(phase: RenderRecordPhase, action: () => T) => T;
-
-const EMPTY_RASTER_ITEM_KEYS: ReadonlySet<RasterItemKey> = new Set<RasterItemKey>();
-
-type ShadowSceneSlot = PersistentGpuDrivenState['slots'][number];
+/**
+ * A frame-local material table. Repeated snapshot objects share one UBO slot;
+ * each renderable keeps only the slot index used by each authored material.
+ */
+export interface MaterialSlotPlan<T extends object> {
+  readonly slotIndices: readonly (readonly number[])[];
+  readonly slots: readonly T[];
+  /** Index of the first renderable that referenced each slot. */
+  readonly slotOwners: readonly number[];
+}
 
-// PersistentRenderScene publishes the production O(1) stable-id join. The
-// compatibility path below deliberately rebuilds its small index per token
-// calculation: custom/test doubles may mutate a slots array in place, so an
-// identity cache would be able to return a stale slot and create a false hit.
-function shadowSlotIndex(slots: readonly ShadowSceneSlot[]): ReadonlyMap<number, ShadowSceneSlot> {
-  const index = new Map<number, ShadowSceneSlot>();
-  for (const slot of slots) index.set(slot.slot, slot);
-  return index;
+/**
+ * Intern identical material snapshots into one frame-local slot table.
+ * Snapshot identity is the extract layer's invalidation token, so this keeps
+ * the same correctness boundary while avoiding duplicate payload assembly and
+ * upload for repeated scene instances.
+ */
+export function buildMaterialSlotPlan<T extends object>(
+  materialGroups: readonly (readonly T[])[],
+): MaterialSlotPlan<T> {
+  const slotByMaterial = new Map<T, number>();
+  const slots: T[] = [];
+  const slotOwners: number[] = [];
+  const slotIndices = materialGroups.map((materials, ownerIndex) =>
+    materials.map((material) => {
+      const cached = slotByMaterial.get(material);
+      if (cached !== undefined) return cached;
+      const slot = slots.length;
+      slots.push(material);
+      slotOwners.push(ownerIndex);
+      slotByMaterial.set(material, slot);
+      return slot;
+    }),
+  );
+  return { slotIndices, slots, slotOwners };
 }
 
-function sortedUniqueStableIds(values: readonly number[]): number[] {
-  const sorted = [...values].sort((left, right) => left - right);
-  let write = 0;
-  for (const value of sorted) {
-    if (write > 0 && sorted[write - 1] === value) continue;
-    sorted[write] = value;
-    write += 1;
+/**
+ * Return the largest complete renderable prefix supported by a shared
+ * mesh/material capacity. Mesh rows consume one slot per renderable; material
+ * rows use the deduplicated slot indices assigned in first-seen order.
+ */
+export function findRenderablePrefixForSlotCapacity(
+  materialSlotIndices: readonly (readonly number[])[],
+  slotCapacity: number,
+): number {
+  const capacity = Math.max(0, Math.floor(slotCapacity));
+  const maxRenderableCount = Math.min(materialSlotIndices.length, capacity);
+  let renderableCount = 0;
+  while (renderableCount < maxRenderableCount) {
+    const slots = materialSlotIndices[renderableCount] ?? [];
+    if (slots.some((slot) => slot >= capacity)) break;
+    renderableCount += 1;
   }
-  sorted.length = write;
-  return sorted;
+  return renderableCount;
 }
 
-function visibilityCandidateIndices(
-  visibility: CpuMultiViewVisibilityResult | undefined,
-  kind: 'main' | 'cascade',
-  cascadeIndex?: number,
-): ReadonlySet<number> | undefined {
-  const view = visibility?.views.find(
-    (candidate) =>
-      candidate.kind === kind && (kind === 'main' || candidate.cascadeIndex === cascadeIndex),
-  );
-  if (view === undefined) return undefined;
-  return new Set(
-    view.compactVisible.flatMap((candidate) =>
-      candidate.candidateIndex === undefined ? [] : [candidate.candidateIndex],
-    ),
-  );
+/** Count material slots reachable from a prefix of a first-seen slot plan. */
+export function materialSlotCountForPrefix(
+  materialSlotIndices: readonly (readonly number[])[],
+  renderableCount: number,
+): number {
+  let maxSlot = -1;
+  for (let index = 0; index < renderableCount; index += 1) {
+    for (const slot of materialSlotIndices[index] ?? []) maxSlot = Math.max(maxSlot, slot);
+  }
+  return maxSlot + 1;
 }
 
+export type RecordProfileRunner = <T>(phase: RenderRecordPhase, action: () => T) => T;
+
+const EMPTY_ENTITY_KEYS: ReadonlySet<number> = new Set<number>();
+
 function runRecordProfilePhase<T>(
   runner: RecordProfileRunner | undefined,
   phase: RenderRecordPhase,
@@ -166,119 +289,6 @@ function runRecordProfilePhase<T>(
   return runner === undefined ? action() : runner(phase, action);
 }
 
-const ANALYTIC_SKY_QUALITY = Object.freeze({ skySize: 128, irradianceSize: 32, prefilterMips: 5 });
-const ANALYTIC_SKY_ALGORITHM = 'preetham-perez-1999-r1';
-
-function beginProductionEnvironmentGeneration(
-  internals: RenderSystemInternals,
-  frameState: RenderFrameState,
-  environment: ExtractedEnvironment,
-): EnvironmentTransactionAttempt | undefined {
-  if (environment.kind !== 'atmosphere') {
-    const state = frameState.environmentGeneration;
-    const oldHandles = [state.active?.handle, state.candidate?.handle].filter(
-      (handle): handle is NonNullable<typeof handle> => handle !== undefined,
-    );
-    if (oldHandles.length > 0) {
-      resizeEnvironmentGeneration(state);
-      void internals.device.queue.onSubmittedWorkDone().then(() => {
-        for (const handle of oldHandles) {
-          if (typeof handle === 'object' && handle !== null && 'destroy' in handle) {
-            (handle as { readonly destroy: (device: typeof internals.device) => unknown }).destroy(
-              internals.device,
-            );
-          }
-        }
-      });
-    }
-    return undefined;
-  }
-  const quality = ANALYTIC_SKY_QUALITY;
-  const signature = environmentSignature({
-    atmosphere: {
-      turbidity: environment.atmosphere.turbidity,
-      rayleigh: environment.atmosphere.rayleigh,
-      mieCoefficient: environment.atmosphere.mieCoefficient,
-      mieDirectionalG: environment.atmosphere.mieDirectionalG,
-      sunAngularRadius: environment.atmosphere.sunAngularRadius,
-    },
-    sun: {
-      direction: environment.atmosphere.sun.direction,
-      color: environment.atmosphere.sun.color,
-      illuminance: environment.atmosphere.sun.illuminance,
-    },
-    quality,
-    algorithmRevision: ANALYTIC_SKY_ALGORITHM,
-    worldId: environment.worldId,
-    entity: environment.atmosphere.entity,
-    deviceGeneration:
-      typeof frameState.environmentGeneration.deviceGeneration === 'number'
-        ? frameState.environmentGeneration.deviceGeneration
-        : 0,
-    outputFormat: 'rgba16float',
-  });
-  const state = frameState.environmentGeneration;
-  if (state.active?.signature === signature) {
-    return undefined;
-  }
-  if (state.candidate !== undefined) return undefined;
-  const descriptors = deriveEnvironmentBundleDescriptors(quality, 'rgba16float');
-  const attempt = beginEnvironmentGeneration(state, {
-    signature,
-    bytes: environmentBundleBytes(descriptors),
-  });
-  const bundle = createEnvironmentGpuBundle(internals.device, descriptors);
-  if (!bundle.ok) {
-    attempt.fail('readiness');
-    internals.errorRegistry.fire(bundle.error);
-    return undefined;
-  }
-  const candidateSnapshot = createEnvironmentConsumerSnapshot({
-    generation: attempt.generation,
-    signature: String(attempt.desired.signature),
-    direction: [
-      environment.atmosphere.sun.direction[0] ?? 0,
-      environment.atmosphere.sun.direction[1] ?? 0,
-      environment.atmosphere.sun.direction[2] ?? 0,
-    ],
-    color: [
-      environment.atmosphere.sun.color[0] ?? 0,
-      environment.atmosphere.sun.color[1] ?? 0,
-      environment.atmosphere.sun.color[2] ?? 0,
-    ],
-    illuminance: environment.atmosphere.sun.illuminance,
-    atmosphere: {
-      turbidity: environment.atmosphere.turbidity,
-      rayleigh: environment.atmosphere.rayleigh,
-      mieCoefficient: environment.atmosphere.mieCoefficient,
-      mieDirectionalG: environment.atmosphere.mieDirectionalG,
-      sunAngularRadius: environment.atmosphere.sunAngularRadius,
-    },
-    source: { worldId: environment.worldId, entity: environment.atmosphere.entity },
-  });
-  const candidate = attempt.complete(bundle.value, candidateSnapshot);
-  const queueCompletion = `analytic-sky:${candidate.generation}:${frameState.frameNumber}`;
-  let settled = false;
-  const abandonCandidate = (stage: 'execute' | 'finish' | 'submit'): void => {
-    if (settled) return;
-    settled = true;
-    attempt.fail(stage);
-    bundle.value.destroy(internals.device);
-  };
-  return {
-    abort: abandonCandidate,
-    publish: () => {
-      if (settled) return;
-      settled = true;
-      publishEnvironmentGeneration(state, candidate, queueCompletion);
-      void internals.device.queue.onSubmittedWorkDone().then(() => {
-        completeEnvironmentQueue(state, queueCompletion);
-        destroyCompletedEnvironmentGenerations(state, internals.device, queueCompletion);
-      });
-    },
-  };
-}
-
 export function recordFrame(
   internals: RenderSystemInternals,
   world: World,
@@ -289,14 +299,18 @@ export function recordFrame(
   frameState: RenderFrameState,
   dispatchCounts: DispatchCounts,
   bindGroupCounts: BindGroupCounts,
-  environment: ExtractedEnvironment,
+  skylight: SkylightSnapshot | undefined,
+  skylightCount: number,
+  skybox: SkyboxSnapshot | undefined,
+  skyboxCount: number,
   postProcessParams: ReadonlyMap<string, Uint8Array>,
   // feat-20260709-editor-world-partition ENGINE-fix-round2 (defect 2): the
-  // The ordered worlds[] remains the shadow-composition input. Renderer-owned
-  // snapshots use stable WorldRenderId values, so production passes the
-  // worldForRenderId lookup below instead of treating those ids as indexes.
-  // Direct unit callers without that lookup retain the historical array-index
-  // behavior.
+  // full worlds[] list passed to `renderer.draw`, indexed by
+  // RenderableSnapshot.worldId so the record stage resolves each renderable's
+  // mesh + material textures against the world it was extracted from (mirroring
+  // the per-world extract stage). Optional + defaulting to `[world]` keeps the
+  // pre-split single-world identity path (worldId always 0) byte-for-byte and
+  // the existing unit-test callers (which pass a single mock world) valid.
   worlds: readonly World[] = [world],
   profilePhase?: RecordProfileRunner,
   gpuDriven?: {
@@ -304,21 +318,9 @@ export function recordFrame(
     readonly scene: PersistentGpuDrivenState | undefined;
     readonly onCoverage: (ownsAll: boolean) => void;
   },
-  worldForRenderId?: (worldId: number) => World | undefined,
-  temporal?: {
-    readonly transaction: TemporalFrameTransaction;
-    readonly projection: RenderSceneProjection;
-    readonly coverage: TemporalCoverageSummary;
-    readonly reactiveRevision?: number | undefined;
-    readonly onSceneSubmitted?: ((delta: RenderSceneSubmissionDelta) => void) | undefined;
-  },
-  fog?: FogSnapshot | undefined,
+  renderReadLeases?: readonly RenderReadLease[],
+  featureGraphCandidate?: RenderFeatureGraphCandidate,
 ): boolean {
-  const skylight =
-    environment.kind === 'none' || environment.kind === 'image' ? environment.skylight : undefined;
-  const skylightCount = environment.skylightCount;
-  const skybox = environment.kind === 'image' ? environment.skybox : undefined;
-  const skyboxCount = environment.skyboxCount;
   // The `try / finally` wrapper advances `frameState.frameNumber` exactly
   // once per `recordFrame` invocation regardless of which early-return
   // branch is taken (camera missing, cap exceeded, pipeline pending,
@@ -338,9 +340,6 @@ export function recordFrame(
   // (no Camera = no scene), so geometry submission is a no-op and only
   // the swap-chain clear lands.
   let activeCameras = cameras;
-  let temporalAttempt: TemporalFrameAttempt | undefined;
-  let environmentAttempt: EnvironmentTransactionAttempt | undefined;
-  let frameSubmitted = false;
   if (activeCameras.length === 0) {
     internals.errorRegistry.fire(
       new RhiError({
@@ -369,11 +368,6 @@ export function recordFrame(
     frameState.currentFrameObservationSource = undefined;
     frameState.currentDirectionalShadowView = null;
     frameState.currentSpotShadowView = null;
-    environmentAttempt = beginProductionEnvironmentGeneration(internals, frameState, environment);
-    // `beginProductionEnvironmentGeneration` owns the producer snapshot and
-    // updates the active snapshot only after a successful submit. This keeps
-    // direct light/CSM consumers on the previous LKG while a replacement is
-    // still a candidate.
 
     // Record-stage fold operator linear scan (groups transparent-sort entries
     // into fold buckets + records the fold-eligible count metric). Extracted to
@@ -401,7 +395,7 @@ export function recordFrame(
         //   no Skylight (skylight === undefined)
         //   AND 0 direct light (totalLightCount === 0)
         //   AND StandardMaterial (renderables.some materialShaderId !== 'forgeax::default-unlit')
-        // All three true -> black + warn. Any one false -> no warn.
+        // All three true -> black + warn. A single false -> no warn.
         //
         // Multi-Skylight warn (F-4 nit + feat-20260630 M3 / w19): >1 Skylight
         // entity -> warn ONCE per RenderSystem lifetime (not per frame), naming the
@@ -454,8 +448,7 @@ export function recordFrame(
           spotLights,
           profilePhase,
           pipelineState.hdrpClusterMembershipPipeline !== null &&
-            internals.device.caps?.compute === true &&
-            internals.membershipTiming?.usesCpuControl() !== true,
+            internals.device.caps?.compute === true,
           pipelineState.hdrpClusterMembershipBindGroupLayout,
         );
       });
@@ -467,8 +460,6 @@ export function recordFrame(
       return { foldBuckets, light };
     });
 
-    void activeCameras; // referenced below
-
     // Case E (this commit): 0 renderables = legitimate scene (LO §1.1
     // hello-window minimum semantic). Mirrors the Case C softening for
     // 0 DirectionalLight (line 134 above; D-Q7). recordFrame() falls
@@ -493,40 +484,13 @@ export function recordFrame(
     const effectiveSpotShadowMapSize = resolveSpotShadowMapSize(internals, lights);
     const graphShadowMapSize = effectiveShadowMapSize ?? effectiveSpotShadowMapSize;
 
-    const validated = runRecordProfilePhase(profilePhase, 'record/validation', () =>
-      validateRenderables(
-        internals,
-        world,
-        worlds,
-        renderables,
-        transparentDispatch,
-        worldForRenderId,
-      ),
-    );
-    const residentMeshes = new Map<number, MeshGpuHandles>();
-    const meshWorlds = new Map<number, number>();
-    const ambiguousMeshHandles = new Set<number>();
-    for (const entry of validated) {
-      const handle = entry.source.assetHandle;
-      if (ambiguousMeshHandles.has(handle)) continue;
-      const priorWorld = meshWorlds.get(handle);
-      if (priorWorld !== undefined && priorWorld !== entry.source.worldId) {
-        residentMeshes.delete(handle);
-        ambiguousMeshHandles.add(handle);
-        continue;
-      }
-      meshWorlds.set(handle, entry.source.worldId);
-      residentMeshes.set(handle, entry.mesh);
-    }
-
     let preparedGpuDriven: PreparedGpuDrivenFrame | undefined;
     if (gpuDriven !== undefined) {
       const prepared = gpuDriven.owner.prepare({
         scene: gpuDriven.scene,
         camera,
-        meshes: residentMeshes,
+        meshes: pipelineState.meshes,
         viewBindGroupLayout: pipelineState.viewBindGroupLayout,
-        materialBindGroupLayout: pipelineState.materialBindGroupLayout,
         meshResidencyEpoch: internals.gpuStore.meshResidencyEpoch,
         hdrp: frameState.isHdrpActive,
       });
@@ -534,22 +498,16 @@ export function recordFrame(
       else if (prepared.error.code !== 'rhi-not-available')
         internals.errorRegistry.fire(prepared.error);
     }
-    const cpuVisibility = gpuDriven?.owner.inspect().cpuVisibility;
-    const multiViewSubmissions = gpuDriven?.owner.multiViewSubmissions() ?? [];
 
-    // The GPU lane owns only the primary opaque raster today. Shadow membership
-    // is owned by the batch-aligned multi-view submissions below; the existing
-    // shadow encoder consumes them through a one-way direct-RHI adapter.
+    // The GPU lane owns only the primary opaque raster today. Directional,
+    // point, and spot shadow views still consume the CPU-validated draw plan.
     const cpuShadowCastersActive =
       (effectiveShadowMapSize ?? 0) > 0 ||
       lights.pointShadow.length > 0 ||
       lights.spot.some((spot) => spot.castShadow);
-    const gpuOwnsAllPrimaryRaster = preparedGpuDriven?.ownsAllForwardItems === true;
+    const gpuOwnsAllPrimaryRaster = preparedGpuDriven?.ownsAllRenderables === true;
     gpuDriven?.onCoverage(gpuOwnsAllPrimaryRaster && !cpuShadowCastersActive);
 
-    const activeEnvironmentSignature =
-      frameState.environmentGeneration.candidate?.signature ??
-      frameState.environmentGeneration.active?.signature;
     const preflightGraph = runRecordProfilePhase(profilePhase, 'record/render-graph', () =>
       ensureCompiledFrameGraph(
         internals,
@@ -561,26 +519,10 @@ export function recordFrame(
         Math.max(1, internals.canvas.height),
         graphShadowMapSize,
         preparedGpuDriven,
-        temporal?.transaction,
+        featureGraphCandidate,
       ),
     );
     if (preflightGraph === null) return false;
-    temporalAttempt = temporal?.transaction.begin({
-      camera,
-      surfaceWidth: Math.max(1, internals.canvas.width),
-      surfaceHeight: Math.max(1, internals.canvas.height),
-      projection: temporal.projection,
-      visible: renderables,
-      coverage: temporal.coverage,
-      ...(Object.hasOwn(temporal, 'reactiveRevision')
-        ? { reactiveRevision: temporal.reactiveRevision }
-        : {}),
-      environmentSignature:
-        typeof activeEnvironmentSignature === 'string' ? activeEnvironmentSignature : undefined,
-      ...(temporal.onSceneSubmitted === undefined
-        ? {}
-        : { onSceneSubmitted: temporal.onSceneSubmitted }),
-    });
 
     // Acquire the swap-chain texture + colour view + target dimensions (with
     // one reconfigure-and-retry on surface-outdated). Extracted to
@@ -611,29 +553,6 @@ export function recordFrame(
 
     pipelineState.perPassResources.shadowMapSize = graphShadowMapSize ?? 0;
     pipelineState.perPassResources.shadowCascadeCount = lights.cascadeCount ?? 0;
-    pipelineState.perPassResources.shadowDepthBias = lights.depthBias ?? 0.005;
-    pipelineState.perPassResources.shadowNormalBias = lights.normalBias ?? 0.05;
-    pipelineState.perPassResources.shadowPcfKernelSize = clampPcfKernelSize(lights.pcfKernelSize);
-    const environmentSunDirection = environmentConsumerSnapshot(frameState.environmentGeneration)
-      ?.csm.direction;
-    const environmentShadowDirection =
-      environmentSunDirection === undefined
-        ? undefined
-        : [
-            -(environmentSunDirection[0] ?? 0),
-            -(environmentSunDirection[1] ?? 0),
-            -(environmentSunDirection[2] ?? 0),
-          ];
-    pipelineState.perPassResources.shadowLightDirection =
-      environmentShadowDirection !== undefined
-        ? new Float32Array(environmentShadowDirection)
-        : lights.directional === undefined
-          ? null
-          : new Float32Array([
-              lights.directional.direction[0] ?? 0,
-              lights.directional.direction[1] ?? 0,
-              lights.directional.direction[2] ?? 0,
-            ]);
     const firstDirectionalShadowMatrix = lights.lightViewProj?.[0];
     pipelineState.perPassResources.shadowLightSpaceMatrix =
       firstDirectionalShadowMatrix === undefined
@@ -655,7 +574,6 @@ export function recordFrame(
           : {
               viewMatrix: new Float32Array(computeViewMatrix(camera)),
               splitPlanes: new Float32Array(lights.splitPlanes),
-              cascadeBlend: lights.cascadeBlend ?? 0,
             };
     }
 
@@ -667,9 +585,6 @@ export function recordFrame(
       camera,
       skybox,
     );
-    const atmosphereActive =
-      frameState.environmentGeneration.active !== undefined ||
-      frameState.environmentGeneration.candidate !== undefined;
 
     // feat-20260604-learn-render-4.10-anti-aliasing-msaa M2 / w9 (D-6, C-9):
     // MSAA is a per-Camera switch derived from `camera.antialias`, never
@@ -703,13 +618,27 @@ export function recordFrame(
     // build a renderableIndex -> renderState map from dispatch entries
     // so each ValidatedRenderable carries its per-material renderState
     // override without an O(n^2) back-scan in the draw loop.
-    const gpuOwnedItemKeys = preparedGpuDriven?.ownedItemKeys ?? EMPTY_RASTER_ITEM_KEYS;
-    gpuDriven?.owner.recordCpuValidation(validated, gpuOwnedItemKeys);
+    const gpuOwnedEntityKeys = preparedGpuDriven?.entityKeys ?? EMPTY_ENTITY_KEYS;
+    const validated = runRecordProfilePhase(profilePhase, 'record/validation', () =>
+      gpuOwnsAllPrimaryRaster && !cpuShadowCastersActive
+        ? []
+        : validateRenderables(
+            internals,
+            world,
+            worlds,
+            pipelineState,
+            frameState,
+            renderables,
+            transparentDispatch,
+            cpuShadowCastersActive ? EMPTY_ENTITY_KEYS : gpuOwnedEntityKeys,
+          ),
+    );
+    gpuDriven?.owner.recordCpuValidation(validated, gpuOwnedEntityKeys);
 
     // Per-frame cache clean-up: drop per-entity BG cache entries + instance
     // buffers whose entityKey is absent from the current validated set (despawn
     // eviction). Extracted to cleanPerFrameCaches (M3/w18).
-    cleanPerFrameCaches(internals, frameState, validated);
+    cleanPerFrameCaches(internals, frameState, validated, gpuOwnedEntityKeys);
 
     // Dispatch-ordered render plan: reorder validated renderables to dispatch
     // order, run the mesh-SSBO capacity gate (graceful truncation), and build
@@ -718,44 +647,6 @@ export function recordFrame(
       buildDispatchPlan(internals, validated, transparentDispatch, foldBuckets),
     );
     const validatedOrdered = dispatchPlan.validatedOrdered;
-    // Build the candidate-index owner once at the frame boundary. Directional
-    // CPU fallback consumes the same multi-view membership contract as the
-    // indirect path and must not rediscover selected casters by scanning the
-    // complete dispatch for every cascade.
-    const validatedByCandidateIndex = new Map<number, ValidatedRenderable>();
-    const validatedIndexByCandidateIndex = new Map<number, number>();
-    for (let validatedIndex = 0; validatedIndex < validatedOrdered.length; validatedIndex += 1) {
-      const entry = validatedOrdered[validatedIndex];
-      if (entry === undefined) continue;
-      const candidateIndex = entry.source.candidateIndex ?? entry.renderableIndex;
-      if (!validatedByCandidateIndex.has(candidateIndex)) {
-        validatedByCandidateIndex.set(candidateIndex, entry);
-        validatedIndexByCandidateIndex.set(candidateIndex, validatedIndex);
-      }
-    }
-    // Build the compatibility shadow geometry owner once. Directional CSM
-    // uses its compact per-cascade submission; point/spot fallback passes
-    // need the main-view domain and the original validated slot for their
-    // dynamic mesh offset. Keeping both facts here removes a full
-    // validatedOrdered walk from every point face and spot tile while
-    // preserving the existing overflow-conservative behavior.
-    const mainSubmission = multiViewSubmissions.find((submission) => submission.kind === 'main');
-    const mainShadowCandidateIndices =
-      mainSubmission === undefined || mainSubmission.overflow
-        ? undefined
-        : mainSubmission.candidateIndices;
-    const validatedShadowEntries = Object.freeze(
-      validatedOrdered.flatMap((entry, validatedIndex) => {
-        const candidateIndex = entry.source.candidateIndex ?? entry.renderableIndex;
-        if (
-          mainShadowCandidateIndices !== undefined &&
-          !mainShadowCandidateIndices.has(candidateIndex)
-        ) {
-          return [];
-        }
-        return [{ entry, validatedIndex }];
-      }),
-    );
     const foldDispatchPlan = dispatchPlan.foldDispatchPlan;
     const materialSlotIndices = dispatchPlan.materialSlotIndices;
     const materialSlots = dispatchPlan.materialSlots;
@@ -794,12 +685,8 @@ export function recordFrame(
     // (clear-pass-only) path only when neither condition is met.
     // feat-20260531-skybox-env-background M2 / w6: gate relaxed from
     // `validatedOrdered.length > 0` to include skybox-only frames
-    // (plan-strategy D-3, R-3). Feature-only passes (for example VFX) also
-    // consume the View UBO through their group(0) contract even when the
-    // scene validation list is empty; keep that payload authoritative before
-    // the graph executes those passes.
-    const renderFeaturesActive = (internals.featureHost?.size ?? 0) > 0;
-    if (validatedOrdered.length > 0 || skyboxActive || atmosphereActive || renderFeaturesActive) {
+    // (plan-strategy D-3, R-3).
+    if (validatedOrdered.length > 0 || skyboxActive) {
       runRecordProfilePhase(profilePhase, 'record/uploads', () => {
         // View UBO + CSM/spot-shadow matrix pack: assembled + uploaded in one
         // queue.writeBuffer round-trip. Extracted to view-ubo.ts (M3/w18) so
@@ -811,8 +698,6 @@ export function recordFrame(
           light,
           lights,
           frameState.spotShadowSnapshots,
-          temporalAttempt?.view,
-          fog,
         );
         writeShadowCasterUniforms(
           internals.device.queue,
@@ -834,12 +719,11 @@ export function recordFrame(
           pipelineState.meshStorageBuffer,
           validatedOrdered,
           foldDispatchPlan,
-          temporalAttempt?.reactiveRevisionChanged ?? false,
         );
       });
     }
 
-    const preparedDirectionalShadowCache = runRecordProfilePhase(
+    const directionalShadowCache = runRecordProfilePhase(
       profilePhase,
       'record/scene-state/directional-shadow-cache',
       () =>
@@ -847,21 +731,12 @@ export function recordFrame(
           internals,
           frameState,
           worlds,
+          renderReadLeases,
           lights,
           effectiveShadowMapSize,
           validatedOrdered,
-          cpuVisibility,
-          gpuDriven?.scene,
         ),
     );
-    const directionalShadowTileClearPipeline =
-      internals.getDirectionalShadowTileClearPipeline?.() ?? null;
-    const directionalShadowCache =
-      !preparedDirectionalShadowCache.reuse &&
-      preparedDirectionalShadowCache.hitMask !== 0 &&
-      directionalShadowTileClearPipeline === null
-        ? { ...preparedDirectionalShadowCache, hitMask: 0 }
-        : preparedDirectionalShadowCache;
     frameState.directionalShadowCacheRecorded = false;
 
     const encoderResult = internals.device.createCommandEncoder({ label: 'render-system-frame' });
@@ -898,29 +773,13 @@ export function recordFrame(
     // errorRegistry + shader-cache lookups) surfaces (`internals` itself satisfies
     // `RenderSystemRuntime` so `runtime: internals` is a zero-cost reference). The
     // 0-consumed `skyboxCount` residual is dropped.
-    const csmPlan = lights.directionalCsm;
-    const mainMembership = visibilityCandidateIndices(cpuVisibility, 'main');
-    const mainDispatch =
-      mainMembership === undefined
-        ? transparentDispatch
-        : transparentDispatch.filter((entry) => {
-            const source = renderables[entry.renderableIndex];
-            const candidateIndex = source?.candidateIndex ?? entry.renderableIndex;
-            return mainMembership.has(candidateIndex);
-          });
-
     const passCtx: _InternalRenderPipelineContext = {
       assets: internals.assets,
       world,
-      gpuDrivenItemKeys: gpuOwnedItemKeys,
-      gpuDrivenOwnsAllForwardItems: gpuOwnsAllPrimaryRaster,
-      validatedByCandidateIndex,
-      validatedIndexByCandidateIndex,
-      validatedShadowEntries,
+      gpuDrivenEntityKeys: gpuOwnedEntityKeys,
       store: internals.gpuStore,
       pipelineState,
       runtime: internals,
-      temporalFrame: temporalAttempt,
       encoder,
       view,
       clear,
@@ -949,10 +808,7 @@ export function recordFrame(
       geometryColorResolveView,
       ldrSpriteColorView,
       postProcessParams,
-      dispatch: mainDispatch,
-      shadowDispatch: transparentDispatch,
-      directionalCsmPlan: csmPlan,
-      shadowDebugObservation: internals.shadowDebugObservation,
+      dispatch: transparentDispatch,
       hdrpClusterBindGroup,
       hdrpClusterMembershipBindGroup,
       foldDispatchPlan,
@@ -962,12 +818,9 @@ export function recordFrame(
       materialSlotCount,
       materialBgAssemblyCache: frameState.materialBgAssemblyCache,
       directionalShadowCacheReuse: directionalShadowCache.reuse,
-      directionalShadowCacheTokens: directionalShadowCache.cascadeTokens,
-      directionalShadowCacheHitMask: directionalShadowCache.hitMask,
-      multiViewSubmissions,
       ...(profilePhase !== undefined ? { profilePhase } : {}),
     };
-    frameSubmitted = runRecordProfilePhase(profilePhase, 'record/graph-execute', () =>
+    const submitted = runRecordProfilePhase(profilePhase, 'record/graph-execute', () =>
       executeCompiledFrameGraph(
         internals,
         frameState,
@@ -976,19 +829,15 @@ export function recordFrame(
         profilePhase === undefined
           ? undefined
           : (pass, encode) => profilePhase(graphExecutionPhase(pass.name), encode),
-        temporalAttempt,
-        environmentAttempt,
       ),
     );
-    if (frameSubmitted && !directionalShadowCache.reuse) {
+    if (submitted && !directionalShadowCache.reuse) {
       frameState.directionalShadowCache = frameState.directionalShadowCacheRecorded
         ? directionalShadowCache.next
         : null;
     }
-    return frameSubmitted;
+    return submitted;
   } finally {
-    temporalAttempt?.abort();
-    if (!frameSubmitted) environmentAttempt?.abort('execute');
     frameState.frameNumber += 1;
     // feat-20260608-cluster-lighting M5 / w22: clear HDRP once-per-frame fired
     // set so the next frame re-fires if the condition persists.
@@ -999,294 +848,63 @@ export function recordFrame(
 interface DirectionalShadowCacheDecision {
   readonly reuse: boolean;
   readonly next: DirectionalShadowCache | null;
-  readonly cascadeTokens: readonly string[];
-  readonly hitMask: number;
-}
-
-export type DirectionalShadowCacheMissReason =
-  | 'no-entry'
-  | 'shadow-map-size'
-  | 'cascade-count'
-  | 'pipeline'
-  | 'graph-topology'
-  | 'scene-mode'
-  | 'asset-catalog'
-  | 'mesh-residency'
-  | 'world-state'
-  | 'cascade-token';
-
-function observeDirectionalShadowTokenBuild(
-  metrics: EngineMetrics,
-  enabled: boolean,
-  built: { readonly tokens: readonly string[]; readonly productionSceneToken: boolean },
-): void {
-  if (!enabled || built.tokens.length === 0) return;
-  metrics.increment('shadow.csm.token-build');
-  metrics.increment(
-    built.productionSceneToken
-      ? 'shadow.csm.token-production-scene'
-      : 'shadow.csm.token-validated-fallback',
-  );
-  for (const _token of built.tokens) metrics.increment('shadow.csm.token-cascade');
-}
-
-function observeDirectionalShadowCacheDecision(
-  metrics: EngineMetrics,
-  enabled: boolean,
-  decision: Pick<DirectionalShadowCacheDecision, 'reuse' | 'cascadeTokens' | 'hitMask'>,
-  missReason: DirectionalShadowCacheMissReason | undefined,
-): void {
-  if (!enabled || decision.cascadeTokens.length === 0) return;
-  metrics.increment(decision.reuse ? 'shadow.csm.cache.reuse' : 'shadow.csm.cache.refresh');
-  if (decision.hitMask !== 0 && !decision.reuse) {
-    metrics.increment('shadow.csm.cache.partial-hit');
-  }
-  for (let index = 0; index < decision.cascadeTokens.length; index += 1) {
-    metrics.increment(
-      (decision.hitMask & (1 << index)) !== 0
-        ? 'shadow.csm.cache.cascade-hit'
-        : 'shadow.csm.cache.cascade-miss',
-    );
-  }
-  if (missReason !== undefined) metrics.increment(`shadow.csm.cache.miss.${missReason}`);
 }
 
-function classifyDirectionalShadowCacheMiss(input: {
-  readonly cached: DirectionalShadowCache | null;
-  readonly built: { readonly productionSceneToken: boolean };
-  readonly shadowMapSize: number | undefined;
-  readonly cascadeCount: number | undefined;
-  readonly pipelineHandle: number;
-  readonly graphTopologyKey: string | null;
-  readonly assetCatalogEpoch: number;
-  readonly meshResidencyEpoch: number;
-  readonly worldStateMatches: boolean;
-}): DirectionalShadowCacheMissReason {
-  const cached = input.cached;
-  if (cached === null) return 'no-entry';
-  if (cached.shadowMapSize !== input.shadowMapSize) return 'shadow-map-size';
-  if (cached.cascadeCount !== input.cascadeCount) return 'cascade-count';
-  if (cached.pipelineHandle !== input.pipelineHandle) return 'pipeline';
-  if (cached.graphTopologyKey !== input.graphTopologyKey) return 'graph-topology';
-  if (cached.productionSceneToken !== input.built.productionSceneToken) return 'scene-mode';
-  if (cached.assetCatalogEpoch !== input.assetCatalogEpoch) return 'asset-catalog';
-  if (cached.meshResidencyEpoch !== input.meshResidencyEpoch) return 'mesh-residency';
-  if (!input.built.productionSceneToken && !input.worldStateMatches) return 'world-state';
-  return 'cascade-token';
-}
-
-/**
- * @internal Pure cache decision owner used by recordFrame and its semantic
- * invalidation tests. Keeping the comparison separate makes the dangerous
- * path explicit: a hit is only reusable when every cascade token matches and
- * all frame/resource owners agree; a forced redraw is represented by
- * `reuse:false` even when one cascade happens to match.
- */
-export function evaluateDirectionalShadowCache(input: {
-  readonly cached: DirectionalShadowCache | null;
-  readonly cascadeTokens: readonly string[];
-  readonly productionSceneToken: boolean;
-  readonly shadowMapSize: number | undefined;
-  readonly cascadeCount: number | undefined;
-  readonly pipelineHandle: number;
-  readonly graphTopologyKey: string | null;
-  readonly assetCatalogEpoch: number;
-  readonly meshResidencyEpoch: number;
-  readonly worldStateMatches: boolean;
-}): {
-  readonly reuse: boolean;
-  readonly hitMask: number;
-  readonly missReason: DirectionalShadowCacheMissReason | undefined;
-} {
-  const cached = input.cached;
-  const commonHit =
-    cached !== null &&
-    cached.shadowMapSize === input.shadowMapSize &&
-    cached.cascadeCount === input.cascadeCount &&
-    cached.pipelineHandle === input.pipelineHandle &&
-    cached.graphTopologyKey === input.graphTopologyKey &&
-    cached.productionSceneToken === input.productionSceneToken &&
-    cached.assetCatalogEpoch === input.assetCatalogEpoch &&
-    cached.meshResidencyEpoch === input.meshResidencyEpoch &&
-    (input.productionSceneToken || input.worldStateMatches);
-  let hitMask = 0;
-  if (commonHit && cached !== null) {
-    for (let index = 0; index < input.cascadeTokens.length; index += 1) {
-      if (cached.cascadeTokens[index] === input.cascadeTokens[index]) hitMask |= 1 << index;
-    }
-  }
-  const reuse = input.cascadeTokens.length > 0 && hitMask === (1 << input.cascadeTokens.length) - 1;
+function readWorldState(lease: RenderReadLease): DirectionalShadowWorldState {
   return {
-    reuse,
-    hitMask,
-    missReason: reuse
-      ? undefined
-      : classifyDirectionalShadowCacheMiss({
-          cached,
-          built: { productionSceneToken: input.productionSceneToken },
-          shadowMapSize: input.shadowMapSize,
-          cascadeCount: input.cascadeCount,
-          pipelineHandle: input.pipelineHandle,
-          graphTopologyKey: input.graphTopologyKey,
-          assetCatalogEpoch: input.assetCatalogEpoch,
-          meshResidencyEpoch: input.meshResidencyEpoch,
-          worldStateMatches: input.worldStateMatches,
-        }),
+    worldIdentity: lease.worldIdentity,
+    changeCursor: lease.inspectCursor(),
   };
 }
 
-const SHADOW_TOKEN_NUMBER = new DataView(new ArrayBuffer(8));
-
-function hashShadowTokenByte(hash: number, value: number): number {
-  return Math.imul((hash ^ value) >>> 0, 16_777_619) >>> 0;
-}
-
-function hashShadowTokenNumber(hash: number, value: number | undefined): number {
-  SHADOW_TOKEN_NUMBER.setFloat64(0, value ?? Number.NaN, true);
-  let next = hash;
-  for (let index = 0; index < 8; index += 1) {
-    next = hashShadowTokenByte(next, SHADOW_TOKEN_NUMBER.getUint8(index));
-  }
-  return next;
-}
-
-function hashShadowTokenString(hash: number, value: string): number {
-  let next = hash;
-  for (let index = 0; index < value.length; index += 1) {
-    const code = value.charCodeAt(index);
-    next = hashShadowTokenByte(next, code & 0xff);
-    next = hashShadowTokenByte(next, code >>> 8);
-  }
-  return next;
-}
-
-function hashShadowTokenNumbers(hash: number, values: ArrayLike<number>): number {
-  let next = hash;
-  for (let index = 0; index < values.length; index += 1) {
-    next = hashShadowTokenNumber(next, values[index]);
-  }
-  return next;
-}
-
-/** @internal Deterministic cascade-local invalidation token producer. */
-export function buildCascadeLocalCacheTokens(input: {
-  readonly lights: ExtractedLights;
-  readonly visibility: CpuMultiViewVisibilityResult | undefined;
-  readonly scene: PersistentGpuDrivenState | undefined;
-  readonly validated: readonly ValidatedRenderable[];
-}): { readonly tokens: readonly string[]; readonly productionSceneToken: boolean } {
-  const plan = input.lights.directionalCsm;
-  if (plan === undefined) return { tokens: [], productionSceneToken: false };
-  const productionSceneToken = input.visibility !== undefined && input.scene !== undefined;
-  // PersistentRenderScene already owns O(1) slot lookup. The fallback map is
-  // retained only for older test/custom state doubles that do not expose the
-  // projection owner; it is intentionally not identity-cached because those
-  // doubles may mutate their slots array in place.
-  const slotByStableId =
-    input.scene === undefined || input.scene.projection !== undefined
-      ? undefined
-      : shadowSlotIndex(input.scene.slots);
-  const submissionMembership =
-    input.scene === undefined ? undefined : buildSubmissionCandidateMembership(input.scene.plan);
-  const cascadeCount = Math.min(input.lights.cascadeCount ?? 0, plan.cascades.length);
-  const tokens: string[] = [];
-  for (let cascadeIndex = 0; cascadeIndex < cascadeCount; cascadeIndex += 1) {
-    const cascade = plan.cascades[cascadeIndex];
-    if (cascade === undefined) continue;
-    let hash = 2_166_136_261;
-    hash = hashShadowTokenString(hash, 'csm-cache-v2');
-    hash = hashShadowTokenNumber(hash, cascadeIndex);
-    hash = hashShadowTokenNumber(hash, cascade.revision);
-    hash = hashShadowTokenNumbers(hash, cascade.lightViewProj);
-    hash = hashShadowTokenNumbers(hash, cascade.clipLightBounds);
-    hash = hashShadowTokenNumbers(hash, cascade.casterBroadphaseWorldAabb);
-    hash = hashShadowTokenNumber(hash, cascade.rasterViewport.x);
-    hash = hashShadowTokenNumber(hash, cascade.rasterViewport.y);
-    hash = hashShadowTokenNumber(hash, cascade.rasterViewport.w);
-    hash = hashShadowTokenNumber(hash, cascade.rasterViewport.h);
-
-    const visibilityView = input.visibility?.views.find(
-      (view) => view.kind === 'cascade' && view.cascadeIndex === cascadeIndex,
-    );
-    if (
-      productionSceneToken &&
-      visibilityView !== undefined &&
-      input.scene !== undefined &&
-      (slotByStableId !== undefined || input.scene.projection !== undefined)
-    ) {
-      const visibleStableIds = sortedUniqueStableIds(visibilityView.stableIds);
-      for (const stableId of visibleStableIds) {
-        const slot = input.scene.projection?.slotByIndex(stableId) ?? slotByStableId?.get(stableId);
-        if (slot === undefined) continue;
-        const revisions = slot.fact.revisions;
-        hash = hashShadowTokenNumber(hash, stableId);
-        hash = hashShadowTokenNumber(hash, slot.generation);
-        hash = hashShadowTokenNumber(hash, revisions.transform);
-        hash = hashShadowTokenNumber(hash, revisions.geometry);
-        hash = hashShadowTokenNumber(hash, revisions.material);
-        hash = hashShadowTokenNumber(hash, revisions.eligibility);
-        hash = hashShadowTokenNumber(hash, revisions.space);
-        hash = hashShadowTokenNumber(hash, revisions.batch);
-        hash = hashShadowTokenNumber(hash, revisions.resource);
-      }
-      const visibleBatchIds = new Set<number>();
-      if (submissionMembership !== undefined) {
-        for (const stableId of visibleStableIds) {
-          for (const entry of submissionMembership.byPrimitiveIndex.get(stableId) ?? []) {
-            visibleBatchIds.add(entry.batchId);
-          }
-        }
-        // SubmissionPlan owns a stable numeric batch order. Normalize the
-        // token input explicitly instead of inheriting Set insertion order
-        // from primitive/cascade traversal; a reorder must be a conservative
-        // miss at most, never a semantic token change by accident.
-        for (const batchId of [...visibleBatchIds].sort((left, right) => left - right)) {
-          const batch = submissionMembership.byBatchId.get(batchId);
-          if (batch === undefined) continue;
-          hash = hashShadowTokenNumber(hash, batch.batchId);
-          hash = hashShadowTokenNumber(hash, batch.generation);
-          hash = hashShadowTokenNumber(hash, batch.key.resourceRevision);
-          hash = hashShadowTokenNumber(hash, batch.key.materialRevision);
-          hash = hashShadowTokenString(hash, batch.key.pipelineClass);
-          hash = hashShadowTokenString(hash, batch.key.materialClass);
-          hash = hashShadowTokenString(hash, batch.key.materialResourceClass);
-        }
-      }
-    } else {
-      hash = hashShadowTokenNumbers(hash, cascade.casterRenderableIndices);
-      const casterMembership = new Set(cascade.casterRenderableIndices);
-      for (const entry of input.validated) {
-        const candidateIndex = entry.source.candidateIndex ?? entry.renderableIndex;
-        if (!casterMembership.has(candidateIndex)) continue;
-        const revisions = entry.source.sceneFact?.revisions;
-        hash = hashShadowTokenNumber(hash, candidateIndex);
-        hash = hashShadowTokenNumber(hash, revisions?.transform);
-        hash = hashShadowTokenNumber(hash, revisions?.geometry);
-        hash = hashShadowTokenNumber(hash, revisions?.material);
-        hash = hashShadowTokenNumber(hash, revisions?.eligibility);
-        hash = hashShadowTokenNumber(hash, revisions?.space);
-        hash = hashShadowTokenNumber(hash, revisions?.batch);
-        hash = hashShadowTokenNumber(hash, revisions?.resource);
-      }
-    }
-    tokens.push(`csm-${cascadeIndex}-${hash.toString(16).padStart(8, '0')}`);
+function sameWorldState(
+  cached: DirectionalShadowCache,
+  worlds: readonly World[],
+  leases: readonly RenderReadLease[] | undefined,
+): boolean {
+  if (leases === undefined || leases.length !== worlds.length) return false;
+  if (cached.worlds.length !== worlds.length || cached.worldStateTokens.length !== leases.length) {
+    return false;
   }
-  return { tokens: Object.freeze(tokens), productionSceneToken };
-}
-
-function snapshotWorldState(world: World): DirectionalShadowWorldState {
-  return { projection: createWorldProjection(world) };
-}
-
-function sameWorldState(cached: DirectionalShadowCache, worlds: readonly World[]): boolean {
-  if (cached.worlds.length !== worlds.length) return false;
   for (let index = 0; index < worlds.length; index += 1) {
     const world = worlds[index];
-    if (world === undefined || cached.worlds[index] !== world) return false;
+    const lease = leases[index];
+    if (world === undefined || lease === undefined || cached.worlds[index] !== world) return false;
     const cachedState = cached.worldStateTokens[index];
     if (cachedState === undefined) return false;
-    const evidence = cachedState.projection.poll();
-    if (evidence.status !== 'delta' || evidence.changes.length > 0) return false;
+    if (cachedState.worldIdentity !== lease.worldIdentity) return false;
+    let changes: ReturnType<RenderReadLease['readChanges']>;
+    try {
+      changes = lease.readChanges(cachedState.changeCursor);
+    } catch {
+      // A lease may have evicted an old cursor after another owner consumed
+      // its bounded cursor window. Treat that as stale render evidence and
+      // rebuild the atlas from the current lease rather than reaching into
+      // World for a second mutation clock.
+      return false;
+    }
+    if (changes.status !== 'ok') return false;
+    if (changes.world.records.length !== 0 || changes.sharedRefs.records.length !== 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function sameLightViewProj(
+  cached: DirectionalShadowCache,
+  current: readonly Float32Array[],
+): boolean {
+  if (cached.lightViewProj.length !== current.length) return false;
+  for (let matrixIndex = 0; matrixIndex < current.length; matrixIndex += 1) {
+    const previous = cached.lightViewProj[matrixIndex];
+    const next = current[matrixIndex];
+    if (previous === undefined || next === undefined || previous.length !== next.length) {
+      return false;
+    }
+    for (let valueIndex = 0; valueIndex < next.length; valueIndex += 1) {
+      if (previous[valueIndex] !== next[valueIndex]) return false;
+    }
   }
   return true;
 }
@@ -1295,21 +913,13 @@ function prepareDirectionalShadowCache(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
   worlds: readonly World[],
+  leases: readonly RenderReadLease[] | undefined,
   lights: ExtractedLights,
   shadowMapSize: number | undefined,
   validatedOrdered: readonly ValidatedRenderable[],
-  visibility: CpuMultiViewVisibilityResult | undefined,
-  scene: PersistentGpuDrivenState | undefined,
 ): DirectionalShadowCacheDecision {
-  const observeShadowCensus = internals.shadowDebugObservation === true;
   const cascadeCount = lights.cascadeCount;
-  const built = buildCascadeLocalCacheTokens({
-    lights,
-    visibility,
-    scene,
-    validated: validatedOrdered,
-  });
-  observeDirectionalShadowTokenBuild(internals.metrics, observeShadowCensus, built);
+  const lightViewProj = lights.lightViewProj;
   if (
     frameState.compiledFrameGraph === null ||
     frameState.compiledFrameGraphTopologyKey === null ||
@@ -1317,87 +927,49 @@ function prepareDirectionalShadowCache(
     shadowMapSize <= 0 ||
     cascadeCount === undefined ||
     cascadeCount <= 0 ||
-    built.tokens.length === 0 ||
+    lightViewProj === undefined ||
     validatedOrdered.length === 0
   ) {
-    if (observeShadowCensus && built.tokens.length > 0) {
-      internals.metrics.increment('shadow.csm.cache.precondition');
-    }
-    return { reuse: false, next: null, cascadeTokens: built.tokens, hitMask: 0 };
+    return { reuse: false, next: null };
   }
 
   const cached = frameState.directionalShadowCache;
-  const assetCatalogEpoch = internals.assets.epoch;
+  const assetCatalogEpoch = internals.assets.catalogEpoch;
   const meshResidencyEpoch = internals.gpuStore.meshResidencyEpoch;
-  const evaluation = evaluateDirectionalShadowCache({
-    cached,
-    cascadeTokens: built.tokens,
-    productionSceneToken: built.productionSceneToken,
-    shadowMapSize,
-    cascadeCount,
-    pipelineHandle: frameState.installedPipelineHandle,
-    graphTopologyKey: frameState.compiledFrameGraphTopologyKey,
-    assetCatalogEpoch,
-    meshResidencyEpoch,
-    worldStateMatches:
-      cached !== null ? built.productionSceneToken || sameWorldState(cached, worlds) : false,
-  });
-  if (evaluation.reuse) {
-    const decision = {
-      reuse: true,
-      next: null,
-      cascadeTokens: built.tokens,
-      hitMask: evaluation.hitMask,
-    };
-    observeDirectionalShadowCacheDecision(
-      internals.metrics,
-      observeShadowCensus,
-      decision,
-      undefined,
-    );
-    return decision;
+  if (
+    cached !== null &&
+    cached.shadowMapSize === shadowMapSize &&
+    cached.cascadeCount === cascadeCount &&
+    cached.pipelineHandle === frameState.installedPipelineHandle &&
+    cached.graphTopologyKey === frameState.compiledFrameGraphTopologyKey &&
+    cached.assetCatalogEpoch === assetCatalogEpoch &&
+    cached.meshResidencyEpoch === meshResidencyEpoch &&
+    sameWorldState(cached, worlds, leases) &&
+    sameLightViewProj(cached, lightViewProj)
+  ) {
+    return { reuse: true, next: null };
   }
 
-  const decision = {
-    reuse: false,
-    next: null,
-    cascadeTokens: built.tokens,
-    hitMask: evaluation.hitMask,
-  };
-  observeDirectionalShadowCacheDecision(
-    internals.metrics,
-    observeShadowCensus,
-    decision,
-    observeShadowCensus ? evaluation.missReason : undefined,
-  );
-
-  const worldStateTokens = worlds.map((world) => snapshotWorldState(world));
-  if (worldStateTokens.some((state) => state === null)) {
-    // A world that does not expose the ECS mutation tokens cannot safely
-    // participate in a static-shadow reuse decision. Keep the conservative
-    // path for custom/test worlds instead of collapsing token indexes with a
-    // filter and risking a false-positive match.
-    if (observeShadowCensus) {
-      internals.metrics.increment('shadow.csm.cache.world-state-unavailable');
-    }
-    return decision;
+  if (leases === undefined || leases.length !== worlds.length) {
+    // Direct record-stage test harnesses may omit the host-owned leases. They
+    // still exercise the real shadow encoder, but without the ECS read owner
+    // they must conservatively rebuild rather than inspect World internals.
+    return { reuse: false, next: null };
   }
+  const worldStateTokens = leases.map(readWorldState);
 
   return {
     reuse: false,
-    cascadeTokens: built.tokens,
-    hitMask: evaluation.hitMask,
     next: {
       worlds: worlds.slice(),
-      worldStateTokens,
+      worldStateTokens: worldStateTokens as DirectionalShadowWorldState[],
       assetCatalogEpoch,
       pipelineHandle: frameState.installedPipelineHandle,
       graphTopologyKey: frameState.compiledFrameGraphTopologyKey,
       shadowMapSize,
       cascadeCount,
+      lightViewProj: lightViewProj.map((matrix) => new Float32Array(matrix)),
       meshResidencyEpoch,
-      cascadeTokens: built.tokens,
-      productionSceneToken: built.productionSceneToken,
     },
   };
 }
@@ -1417,15 +989,17 @@ function validateRenderables(
   internals: RenderSystemInternals,
   world: World,
   // feat-20260709-editor-world-partition ENGINE-fix-round2 (defect 2): the full
-  // Each renderable's mesh handle is a slot in its OWN world's
-  // sharedRefs; resolving against a foreign world either misses or resolves
-  // the wrong slot payload. Production resolves stable WorldRenderId through
-  // the renderer-owned lookup. Direct tests without that lookup retain the
-  // historical ordered-array fallback.
+  // worlds[] list. Each renderable's mesh handle is a user-tier slot in its OWN
+  // world's sharedRefs; resolving against a foreign world either misses
+  // (asset-not-registered) or resolves the wrong slot payload. `world` (the
+  // resource-owner) is retained as the fallback for renderables whose worldId
+  // is out of range (defensive; extractFrames always stamps a valid index).
   worlds: readonly World[],
+  pipelineState: PipelineState,
+  frameState: RenderFrameState,
   renderables: readonly RenderableSnapshot[],
   transparentDispatch: readonly DispatchEntry[],
-  worldForRenderId?: (worldId: number) => World | undefined,
+  excludedEntityKeys: ReadonlySet<number> = new Set<number>(),
 ): ValidatedRenderable[] {
   // bug-20260527-renderstate-pipeline-dispatch-gap D-4:
   // build a renderableIndex -> renderState map from dispatch entries
@@ -1451,23 +1025,17 @@ function validateRenderables(
   for (let rIdx = 0; rIdx < renderables.length; rIdx++) {
     const r = renderables[rIdx];
     if (r === undefined) continue;
+    if (excludedEntityKeys.has(worldEntityKey(r.worldId, r.entityKey))) continue;
     // feat-20260709-editor-world-partition ENGINE-fix-round2 (defect 2): resolve
-    // this renderable's mesh against the world it was EXTRACTED from — NOT the
-    // single resource-owner `world`.
-    const renderableWorld =
-      worldForRenderId === undefined ? (worlds[r.worldId] ?? world) : worldForRenderId(r.worldId);
-    if (renderableWorld === undefined) {
-      internals.errorRegistry.fire(
-        new RhiError({
-          code: 'asset-not-registered',
-          expected: `attached renderer WorldRenderId ${r.worldId}`,
-          hint: 'keep every World passed to renderer.draw attached until its frame retires',
-          detail: { assetHandle: r.assetHandle },
-        }),
-      );
-      continue;
-    }
-    const assetRes = resolveRenderAsset<MeshAsset>(
+    // this renderable's mesh against the world it was EXTRACTED from
+    // (worlds[r.worldId]) — NOT the single resource-owner `world`. Builtin mesh
+    // slots (< BUILTIN_BASE) resolve process-statically regardless of world, so
+    // the per-world pick only matters for user-tier handles, but selecting it
+    // unconditionally keeps a single code path. Falls back to the resource-owner
+    // world if worldId is out of range (defensive; extractFrames always stamps
+    // a valid index into worlds[]).
+    const renderableWorld = worlds[r.worldId] ?? world;
+    const assetRes = resolveAssetHandle<MeshAsset>(
       renderableWorld,
       toShared<'MeshAsset'>(r.assetHandle),
     );
@@ -1475,20 +1043,28 @@ function validateRenderables(
       internals.errorRegistry.fire(
         new RhiError({
           code: 'asset-not-registered',
-          expected: 'MeshFilter.assetHandle in the owning World sharedRefs',
-          hint: 'allocate or intern the MeshAsset in the same World before assigning MeshFilter.assetHandle',
+          expected: 'MeshFilter.assetHandle in AssetRegistry',
+          hint: 'use HANDLE_CUBE / HANDLE_TRIANGLE imports; custom mesh register path: feat-future-asset-system',
           detail: { assetHandle: r.assetHandle },
         }),
       );
       continue;
     }
+    // feat-20260601-device/gpu-residency-extraction M1 (D-1): builtin meshes
+    // (slots through HANDLE_NINESLICE_QUAD) keep the createRenderer step-3
+    // direct-upload + `pipelineState.meshes` path -- they are NOT routed
+    // through `ensureResident`. User-registered meshes pull through the store
+    // on first access (the register->upload push was severed in this M1);
+    // the POD fetched above (assetRes.value) is passed in, store holds no
+    // registry ref (D-2). A first-access miss builds the GPU buffers; later
+    // frames hit the O(1) cache.
     const meshAssetHandle = toShared<'MeshAsset'>(r.assetHandle);
-    let meshHandles = internals.gpuStore.getMeshGpuHandles(meshAssetHandle, r.worldId);
-    if (meshHandles === undefined) {
+    let meshHandles = internals.gpuStore.getMeshGpuHandles(meshAssetHandle, renderableWorld);
+    if (meshHandles === undefined && r.assetHandle > handleSlot(HANDLE_NINESLICE_QUAD)) {
       const residentRes = internals.gpuStore.ensureResident(
         meshAssetHandle,
         assetRes.value,
-        r.worldId,
+        renderableWorld,
       );
       if (residentRes.ok) {
         meshHandles = residentRes.value;
@@ -1496,20 +1072,71 @@ function validateRenderables(
         internals.errorRegistry.fire(residentRes.error);
       }
     }
+    meshHandles = meshHandles ?? pipelineState.meshes.get(r.assetHandle);
     if (meshHandles === undefined) {
       internals.errorRegistry.fire(
         new RhiError({
           code: 'asset-not-registered',
           expected: 'GPU mesh buffers uploaded for assetHandle',
-          hint: 'await renderer.ready before draw; keep the MeshAsset live in the renderable World',
+          hint: 'await renderer.initialization before draw([world], { cameraOwner: 0, resourceOwner: 0 }); ensure AssetRegistry.configureGpuDevice ran so user meshes are uploaded',
           detail: { assetHandle: r.assetHandle },
         }),
       );
       continue;
     }
+    // feat-20260527-sprite-nineslice M2 / w11 (plan-strategy section D-2):
+    // sprite branch with non-zero `slicesAndMode` (post-w12 paramSnapshot
+    // entry name) overrides the user-supplied mesh handle (typically
+    // HANDLE_QUAD = 3) with the 16-vertex / 54-index HANDLE_NINESLICE_QUAD
+    // (id=5) topology so the vertex shader sees the 4x4 grid required for
+    // 9-region anchor mapping. Default slicesAndMode ([0, 0, 0, 0]) keeps
+    // the legacy HANDLE_QUAD path; a flip from zero to non-zero on the
+    // same entity routes here per-frame so AI users can toggle 9-slice
+    // on the fly without re-spawning the entity (charter F1 minimum
+    // surface). The HANDLE_NINESLICE_QUAD GPU buffers are seeded by
+    // createRenderer step-3.
+    //
+    // feat-20260625-refactor-sprite-as-transparent-mesh M3 / w13: judgement
+    // key migrated from `shadingModel === 'sprite'` to
+    // `materialShaderId === 'forgeax::sprite'` (plan-strategy D-10); slices
+    // sourced from `paramSnapshot.slicesAndMode` (post-w12 UBO-aligned
+    // overlay path).
+    //
+    // feat-20260624-sprite-lit-shading-model-pure-2d-lighting M1' / t7:
+    // sprite-lit shares the sprite paramSchema (5 fields, t4 mirror) so
+    // the 9-slices mesh swap applies identically.
+    let effectiveMeshHandles = meshHandles;
+    if (
+      r.material.materialShaderId === 'forgeax::sprite' ||
+      r.material.materialShaderId === 'forgeax::sprite-lit'
+    ) {
+      const slicesArr = r.material.paramSnapshot?.slicesAndMode as readonly number[] | undefined;
+      if (
+        slicesArr !== undefined &&
+        slicesArr.length >= 4 &&
+        (slicesArr[0] !== 0 || slicesArr[1] !== 0 || slicesArr[2] !== 0 || slicesArr[3] !== 0)
+      ) {
+        const nineSliceHandles = pipelineState.meshes.get(handleSlot(HANDLE_NINESLICE_QUAD));
+        if (nineSliceHandles !== undefined) {
+          effectiveMeshHandles = nineSliceHandles;
+        }
+      }
+    }
+    if (r.morph !== undefined) {
+      const morphed = prepareMorphMesh(
+        internals,
+        frameState,
+        worldEntityKey(r.worldId, r.entityKey),
+        effectiveMeshHandles,
+        assetRes.value,
+        r.morph,
+      );
+      if (morphed !== undefined) effectiveMeshHandles = morphed;
+    }
     validated.push({
       source: r,
-      mesh: meshHandles,
+      world: renderableWorld,
+      mesh: effectiveMeshHandles,
       renderableIndex: rIdx,
       renderState: renderStateByRenderableIdx.get(rIdx),
       variantSet: variantSetByRenderableIdx.get(rIdx),
@@ -1519,6 +1146,81 @@ function validateRenderables(
   return validated;
 }
 
+function prepareMorphMesh(
+  internals: RenderSystemInternals,
+  frameState: RenderFrameState,
+  cacheKey: number,
+  base: MeshGpuHandles,
+  mesh: MeshAsset,
+  morph: RenderableSnapshot['morph'],
+): MeshGpuHandles | undefined {
+  if (morph === undefined || frameState.morphBuffers === undefined) return undefined;
+  const targets = mesh.morphTargets;
+  if (targets === undefined || targets.length !== morph.targetCount) return undefined;
+  if (base.layoutProjection.arrayStride !== 48 || base.vertexCount <= 0) return undefined;
+  const stride = mesh.vertices.length / base.vertexCount;
+  if (!Number.isInteger(stride) || stride < 3) return undefined;
+
+  let active = false;
+  for (const weight of morph.weights) {
+    if (weight !== 0) {
+      active = true;
+      break;
+    }
+  }
+  if (!active) {
+    frameState.morphBuffers.get(cacheKey)?.buffer.destroy();
+    frameState.morphBuffers.delete(cacheKey);
+    return undefined;
+  }
+
+  const vertices = new Float32Array(mesh.vertices);
+  for (let targetIndex = 0; targetIndex < targets.length; targetIndex += 1) {
+    const weight = morph.weights[targetIndex] ?? 0;
+    const positions = targets[targetIndex]?.position;
+    if (positions === undefined || positions.length !== base.vertexCount * 3) return undefined;
+    for (let vertex = 0; vertex < base.vertexCount; vertex += 1) {
+      const vertexBase = vertex * stride;
+      const positionBase = vertex * 3;
+      vertices[vertexBase] = (vertices[vertexBase] ?? 0) + (positions[positionBase] ?? 0) * weight;
+      vertices[vertexBase + 1] =
+        (vertices[vertexBase + 1] ?? 0) + (positions[positionBase + 1] ?? 0) * weight;
+      vertices[vertexBase + 2] =
+        (vertices[vertexBase + 2] ?? 0) + (positions[positionBase + 2] ?? 0) * weight;
+    }
+  }
+
+  let cached = frameState.morphBuffers.get(cacheKey);
+  if (cached === undefined || cached.byteLength !== vertices.byteLength) {
+    if (cached !== undefined && !cached.buffer.isDestroyed) {
+      const destroyed = cached.buffer.destroy();
+      if (!destroyed.ok) internals.errorRegistry.fire(destroyed.error);
+    }
+    const created = internals.device.createBuffer({
+      label: `morph-${cacheKey}-vbo`,
+      size: vertices.byteLength,
+      usage: GPU_BUFFER_USAGE_VERTEX | GPU_BUFFER_USAGE_COPY_DST,
+      mappedAtCreation: false,
+    });
+    if (!created.ok) {
+      internals.errorRegistry.fire(created.error);
+      frameState.morphBuffers.delete(cacheKey);
+      return undefined;
+    }
+    cached = {
+      buffer: new GpuBuffer(internals.device, created.value),
+      byteLength: vertices.byteLength,
+    };
+    frameState.morphBuffers.set(cacheKey, cached);
+  }
+  const written = internals.device.queue.writeBuffer(cached.buffer.handle, 0, vertices);
+  if (!written.ok) {
+    internals.errorRegistry.fire(written.error);
+    return undefined;
+  }
+  return { ...base, vertexBuffer: cached.buffer };
+}
+
 /**
  * feat-20260704 M3/w18: build the dispatch-ordered render plan, extracted
  * verbatim from `recordFrame`. (1) M3/w26 dispatch-ordered reorder: reorder
@@ -1575,7 +1277,7 @@ function buildDispatchPlan(
         ordered.push(v);
       }
     }
-    // Append any renderables not in the dispatch list (e.g. default-material entities)
+    // Append renderables not in the dispatch list (e.g. default-material entities)
     for (const v of validated) {
       if (!seen.has(v.renderableIndex)) {
         ordered.push(v);
@@ -1610,7 +1312,7 @@ function buildDispatchPlan(
   //
   // bug-20260609: feat-20260608 M5 amend made the material UBO indexed by
   // cumulative *material-slot* count (one slot per submesh material),
-  // which is >= entity count once any entity carries `materials.length>1`.
+  // which is >= entity count once an entity carries `materials.length>1`.
   // The mesh + material buffer pair share `slotCount` (single allocator),
   // so we size against the larger of the two requirements: entity count
   // (mesh-SSBO consumer) vs cumulative material-slot count (material-UBO
@@ -1721,7 +1423,7 @@ function buildDispatchPlan(
     // Singleton buckets (mode-bypass under D-5, or non-foldable under
     // mode 0) carry `bucketSize === 1` and never enter `headBuckets`, so
     // the per-entity drawIndexed path correctly does not count.
-    // SSOT helper lives in `render-system-fold.ts` — engine code never
+    // SSOT helper lives in this record owner — engine code never
     // hardcodes the metric key string.
     incrementFoldedDrawsMetric(foldDispatchPlan, internals.metrics);
   }
@@ -1798,6 +1500,17 @@ function cleanPerFrameCaches(
       frameState.instanceBuffers.delete(key);
     }
   }
+
+  if (frameState.morphBuffers !== undefined) {
+    for (const [key, entry] of frameState.morphBuffers.entries()) {
+      if (validatedEntityKeys.has(key)) continue;
+      if (!entry.buffer.isDestroyed) {
+        const result = entry.buffer.destroy();
+        if (!result.ok) internals.errorRegistry.fire(result.error);
+      }
+      frameState.morphBuffers.delete(key);
+    }
+  }
 }
 
 /**