@forgeax/engine-render 0.1.4 → 0.1.6

package/src/glyph-text-layout-system.ts

@@ -28,6 +28,7 @@
 // AABB and the entity carries MeshFilter + MeshRenderer + Transform, so the
 // existing `pick()` raycast walk catches it for free.
 
+import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import type { EntityHandle, World } from '@forgeax/engine-ecs';
 import { PROCEDURAL_FLOATS_PER_VERTEX } from '@forgeax/engine-geometry';
 import {
@@ -38,12 +39,10 @@ import {
   trackFontConcurrency,
 } from '@forgeax/engine-graphics-extras';
 import type { FontAsset, Handle, MaterialAsset, MeshAsset, Submesh } from '@forgeax/engine-types';
-import { err, ok, type Result, TextError, unpackSlot } from '@forgeax/engine-types';
-import { resolveRenderAsset } from './assets/resolve-render-asset';
+import { err, ok, type Result, TextError, toShared, unpackSlot } from '@forgeax/engine-types';
 import { MeshFilter, MeshRenderer } from './components';
 import { GlyphText } from './components/glyph-text';
-import type { GpuResourceStore } from './gpu-resource-store';
-import { materialTextureValue } from './materials';
+import type { GpuResidencyCache } from './device/gpu-residency';
 
 // Per-entity bake bookkeeping: the baked mesh handle id + the authoring
 // signature it was baked from. A WeakMap owns one cache per World and each
@@ -51,10 +50,10 @@ import { materialTextureValue } from './materials';
 // EntityHandle, so slot reuse replaces stale state instead of aliasing it or
 // growing one historical entry per generation.
 interface BakeRecord {
-  readonly meshHandleId: number;
+  readonly meshHandle: Handle<'MeshAsset', 'shared'>;
   signature: string;
   /** The MeshRenderer.material handle assigned on first observation. */
-  readonly materialHandleId: number;
+  readonly materialHandle: Handle<'MaterialAsset', 'shared'>;
 }
 interface BakeCacheEntry {
   readonly handle: EntityHandle;
@@ -65,14 +64,18 @@ let bakeCache = new WeakMap<World, Map<number, BakeCacheEntry>>();
 // One current material producer handle per GlyphText entity slot. Continuous
 // tint edits replace and release the previous producer instead of growing a
 // historical color-key cache.
-let materialCache = new WeakMap<World, Map<number, number>>();
-let liveGlyphHandles = new WeakMap<World, Set<number>>();
+let materialCache = new WeakMap<World, Map<number, Handle<'MaterialAsset', 'shared'>>>();
+let liveGlyphSlots = new WeakMap<World, Set<number>>();
+
+function entitySlot(entity: EntityHandle): number {
+  return unpackSlot(entity as number);
+}
 
 /** Clear the per-entity bake + per-font material caches (test isolation). */
 export function resetGlyphBakeCache(): void {
   bakeCache = new WeakMap();
   materialCache = new WeakMap();
-  liveGlyphHandles = new WeakMap();
+  liveGlyphSlots = new WeakMap();
 }
 
 function worldBakeCache(world: World): Map<number, BakeCacheEntry> {
@@ -84,7 +87,7 @@ function worldBakeCache(world: World): Map<number, BakeCacheEntry> {
   return cache;
 }
 
-function worldMaterialCache(world: World): Map<number, number> {
+function worldMaterialCache(world: World): Map<number, Handle<'MaterialAsset', 'shared'>> {
   let cache = materialCache.get(world);
   if (cache === undefined) {
     cache = new Map();
@@ -95,22 +98,22 @@ function worldMaterialCache(world: World): Map<number, number> {
 
 /** Release renderer-derived producer refs at GlyphText removal time. */
 function releaseGlyphProducers(world: World, entity: EntityHandle): void {
-  const slot = unpackSlot(entity as unknown as number);
+  const slot = entitySlot(entity);
   const bake = bakeCache.get(world)?.get(slot);
   if (bake?.handle === entity) {
-    world.sharedRefs.release(asMeshHandle(bake.record.meshHandleId));
+    world.sharedRefs.release(bake.record.meshHandle);
     bakeCache.get(world)?.delete(slot);
   }
   const material = materialCache.get(world)?.get(slot);
   if (material !== undefined) {
-    world.sharedRefs.release(asMaterialHandle(material));
+    world.sharedRefs.release(material);
     materialCache.get(world)?.delete(slot);
   }
 }
 
 /** Remove stale renderer-derived state when a previously baked font is rejected. */
 function clearRejectedGlyphState(world: World, entity: EntityHandle): void {
-  const slot = unpackSlot(entity as unknown as number);
+  const slot = entitySlot(entity);
   const bake = bakeCache.get(world)?.get(slot);
   if (bake?.handle !== entity) return;
 
@@ -143,6 +146,7 @@ interface GlyphTextData {
   readonly color: ArrayLike<number>;
 }
 
+/** @internal archetype-walk view (same shape reached for in render-system-extract). */
 /**
  * Lay out + bake every `GlyphText` entity, attaching MeshFilter + MeshRenderer
  * on first observation and re-baking in place on a text / size / color change.
@@ -154,21 +158,20 @@ interface GlyphTextData {
  */
 export function glyphTextLayoutSystem(
   world: World,
-  gpuStore: GpuResourceStore,
+  gpuStore: GpuResidencyCache,
 ): Result<void, TextError> {
   resetFontConcurrency();
 
-  // No GlyphText entity in this World -> empty collection -> no-op pass. The
-  // former per-World `_getComponentByName(GlyphText.name)` registration probe
-  // is gone (feat-20260602 dropped the registered concept); column presence is
-  // read directly from the archetype graph by `collectGlyphEntities`.
+  // No GlyphText entity in this World -> empty query -> no-op pass. The
+  // ECS query is the single owner of component presence and entity iteration;
+  // the renderer does not reach into archetype storage internals.
   const entities = collectGlyphEntities(world);
-  const live = liveGlyphHandles.get(world) ?? new Set<number>();
+  const live = liveGlyphSlots.get(world) ?? new Set<number>();
   live.clear();
-  for (const entity of entities) live.add(entity as unknown as number);
-  liveGlyphHandles.set(world, live);
+  for (const entity of entities) live.add(entitySlot(entity));
+  liveGlyphSlots.set(world, live);
   for (const entry of worldBakeCache(world).values()) {
-    if (!live.has(entry.handle as unknown as number)) releaseGlyphProducers(world, entry.handle);
+    if (!live.has(entitySlot(entry.handle))) releaseGlyphProducers(world, entry.handle);
   }
 
   let firstError: TextError | null = null;
@@ -183,25 +186,26 @@ export function glyphTextLayoutSystem(
 
 /** Collect every Entity handle carrying GlyphText (single archetype walk). */
 function collectGlyphEntities(world: World): EntityHandle[] {
-  const query = world.query({ read: [GlyphText] });
-  if (!query.ok) return [];
   const entities: EntityHandle[] = [];
-  for (const row of query.value) entities.push(row.entity);
+  const query = world.query({ read: [GlyphText] }).unwrap();
+  for (const row of query) {
+    entities.push(row.entity);
+  }
   return entities;
 }
 
 /**
  * Process one GlyphText entity. Returns a TextError when the concurrency limit
- * is exceeded after clearing any stale derived state; returns null otherwise.
+ * is exceeded after clearing stale derived state; returns null otherwise.
  */
 function processEntity(
   world: World,
-  gpuStore: GpuResourceStore,
+  gpuStore: GpuResidencyCache,
   entity: EntityHandle,
 ): TextError | null {
   const gtRes = world.get(entity, GlyphText);
   if (!gtRes.ok) return null;
-  const gt = gtRes.value as unknown as GlyphTextData;
+  const gt = gtRes.value;
 
   // Unresolved font handle (zero sentinel) -> skip (entity not yet wired).
   if (gt.fontHandle === 0) return null;
@@ -217,19 +221,19 @@ function processEntity(
     throw e;
   }
 
-  const fontRes = resolveRenderAsset<FontAsset>(world, asFontHandle(gt.fontHandle));
+  const fontRes = resolveAssetHandle<FontAsset>(world, asFontHandle(gt.fontHandle));
   if (!fontRes.ok) return null; // font not registered yet -> skip silently
   const font = fontRes.value;
 
   const signature = signatureOf(gt);
   const entityCache = worldBakeCache(world);
-  const slot = unpackSlot(entity as unknown as number);
+  const slot = entitySlot(entity);
   const cachedEntry = entityCache.get(slot);
   if (cachedEntry !== undefined && cachedEntry.handle !== entity) {
-    world.sharedRefs.release(asMeshHandle(cachedEntry.record.meshHandleId));
+    world.sharedRefs.release(cachedEntry.record.meshHandle);
     const staleMaterial = worldMaterialCache(world).get(slot);
     if (staleMaterial !== undefined) {
-      world.sharedRefs.release(asMaterialHandle(staleMaterial));
+      world.sharedRefs.release(staleMaterial);
       worldMaterialCache(world).delete(slot);
     }
     entityCache.delete(slot);
@@ -238,15 +242,15 @@ function processEntity(
 
   // Dirty path: same entity already baked, but the authoring signature changed.
   if (cached !== undefined) {
-    ensureGlyphMeshMaterialSlots(world, asMeshHandle(cached.meshHandleId));
+    ensureGlyphMeshMaterialSlots(world, cached.meshHandle);
     if (cached.signature === signature) return null; // clean -> nothing to do
     const layout = layoutGlyphText(font, gt.text, gt.fontSize);
-    // feat-20260601-gpu-resource-store-extraction M1: in-place GPU mesh update
+    // feat-20260601-device/gpu-residency-extraction M1: in-place GPU mesh update
     // moved to the store. The mesh became GPU-resident on the first render
     // frame's `ensureResident` pull; the dirty re-layout overwrites those
     // buffers in place (a no-op if not yet resident -- the next render's
     // ensureResident then uploads the latest registered POD).
-    const meshHandle = asMeshHandle(cached.meshHandleId);
+    const meshHandle = cached.meshHandle;
     const submeshes = [
       {
         indexOffset: 0,
@@ -261,35 +265,34 @@ function processEntity(
     // dirty layout; otherwise the GPU buffers update but the render walk still
     // rejects the label as an empty mesh.
     const mesh = world.sharedRefs.resolve<'MeshAsset', MeshAsset>(meshHandle);
-    if (!mesh.ok) return null;
-    // Consume the Result before publishing the new CPU POD. A resident shape
-    // change takes the explicit transactional replacement path; a nonresident
-    // mesh can publish directly because ensureResident will pull this POD.
-    if (!updateGlyphMesh(gpuStore, meshHandle, layout.vertices, layout.indices, submeshes)) {
-      return null;
+    if (mesh.ok) {
+      const aabb = conservativeCubeAabb(layout.radius);
+      // Keep both sides of the pull boundary coherent. A zero-glyph first
+      // bake may have no resident GPU buffers yet, so updating only the GPU
+      // store would lose the new text on the next ensureResident pull.
+      Object.assign(mesh.value, {
+        vertices: layout.vertices,
+        indices: layout.indices,
+        submeshes,
+        materialSlots: [{ slotName: 'Default' }],
+        aabb,
+      });
     }
-    const aabb = conservativeCubeAabb(layout.radius);
-    Object.assign(mesh.value, {
-      vertices: layout.vertices,
-      indices: layout.indices,
-      submeshes,
-      materialSlots: [{ slotName: 'Default' }],
-      aabb,
-    });
+    gpuStore.updateMesh(meshHandle, layout.vertices, layout.indices, 0, submeshes);
     // A color change replaces the material payload at this entity's stable
     // derived slot and re-binds the new producer handle in place.
     const materialId = resolveTextMaterial(world, gt, font, slot);
-    if (materialId !== cached.materialHandleId) {
+    if (materialId !== cached.materialHandle) {
       world.set(entity, MeshRenderer, {
-        materials: [materialId] as unknown as never,
+        materials: [materialId],
       });
     }
     entityCache.set(slot, {
       handle: entity,
       record: {
-        meshHandleId: cached.meshHandleId,
+        meshHandle: cached.meshHandle,
         signature,
-        materialHandleId: materialId,
+        materialHandle: materialId,
       },
     });
     return null;
@@ -301,10 +304,7 @@ function processEntity(
   // so the column probe needs no registration guard (feat-20260602).
   const existingFilter = world.get(entity, MeshFilter);
   if (existingFilter.ok) {
-    ensureGlyphMeshMaterialSlots(
-      world,
-      asMeshHandle((existingFilter.value as { assetHandle: number }).assetHandle),
-    );
+    ensureGlyphMeshMaterialSlots(world, existingFilter.value.assetHandle);
     return null;
   }
 
@@ -318,42 +318,25 @@ function processEntity(
   // handle 0 -> default mid-grey unlit, and the atlas would never be sampled.
   const materialId = resolveTextMaterial(world, gt, font, slot);
 
-  world.addComponent(entity, { component: MeshFilter, data: { assetHandle: bake.value.handle } });
+  world.addComponent(entity, {
+    component: MeshFilter,
+    data: { assetHandle: bake.value.handle },
+  });
   world.addComponent(entity, {
     component: MeshRenderer,
-    data: { materials: [materialId] as unknown as never },
+    data: { materials: [materialId] },
   });
   entityCache.set(slot, {
     handle: entity,
     record: {
-      meshHandleId: handleId(bake.value.handle),
+      meshHandle: bake.value.handle,
       signature,
-      materialHandleId: materialId,
+      materialHandle: materialId,
     },
   });
   return null;
 }
 
-/** Apply a dirty glyph mesh atomically across the GPU residency boundary. */
-function updateGlyphMesh(
-  gpuStore: GpuResourceStore,
-  meshHandle: Handle<'MeshAsset', 'shared'>,
-  vertices: Float32Array,
-  indices: Uint16Array | Uint32Array,
-  submeshes: readonly Submesh[],
-): boolean {
-  const updated = gpuStore.updateMesh(meshHandle, vertices, indices, 0, submeshes);
-  if (updated.ok) return true;
-  if (updated.error.code === 'mesh-shape-mismatch') {
-    const replaced = gpuStore.replaceMesh(meshHandle, vertices, indices, 0, submeshes);
-    if (replaced.ok) return true;
-    return (
-      replaced.error.code === 'mesh-not-resident' || replaced.error.code === 'rhi-not-available'
-    );
-  }
-  return updated.error.code === 'mesh-not-resident' || updated.error.code === 'rhi-not-available';
-}
-
 export function ensureGlyphMeshMaterialSlots(
   world: World,
   meshHandle: Handle<'MeshAsset', 'shared'>,
@@ -378,7 +361,7 @@ function resolveTextMaterial(
   gt: GlyphTextData,
   font: FontAsset,
   slot: number,
-): number {
+): Handle<'MaterialAsset', 'shared'> {
   const cache = worldMaterialCache(world);
   const material = {
     kind: 'material',
@@ -406,7 +389,7 @@ function resolveTextMaterial(
         font.common.atlasHeight,
         0,
       ],
-      baseColorTexture: materialTextureValue({ texture: font.atlas }),
+      baseColorTexture: { texture: font.atlas },
     },
     parameters: [
       { name: 'tintColor', type: 'color', default: [1, 1, 1, 1] },
@@ -416,11 +399,11 @@ function resolveTextMaterial(
       { name: 'normalTexture', type: 'texture', optional: true },
     ],
   } satisfies MaterialAsset;
-  const id = world.allocSharedRef('MaterialAsset', material) as unknown as number;
+  const id = world.allocSharedRef('MaterialAsset', material);
   const previous = cache.get(slot);
   cache.set(slot, id);
   if (previous !== undefined && previous !== id) {
-    world.sharedRefs.release(asMaterialHandle(previous));
+    world.sharedRefs.release(previous);
   }
   return id;
 }
@@ -434,14 +417,5 @@ function signatureOf(gt: GlyphTextData): string {
 // (runtime value is the raw number), so a cast is the canonical bridge
 // (mirrors pick.ts toShared).
 function asFontHandle(raw: number): Handle<'FontAsset', 'shared'> {
-  return raw as unknown as Handle<'FontAsset', 'shared'>;
-}
-function asMeshHandle(id: number): Handle<'MeshAsset', 'shared'> {
-  return id as unknown as Handle<'MeshAsset', 'shared'>;
-}
-function asMaterialHandle(id: number): Handle<'MaterialAsset', 'shared'> {
-  return id as unknown as Handle<'MaterialAsset', 'shared'>;
-}
-function handleId(handle: Handle<'MeshAsset', 'shared'>): number {
-  return handle as unknown as number;
+  return toShared<'FontAsset'>(raw);
 }

package/src/gpu-driven/batch-topology.ts

@@ -1,11 +1,8 @@
-import { RenderQueue } from '@forgeax/engine-types';
-import { isStandardPbrMaterialShader } from '../pbr-pipeline';
-import type { RenderSceneApplyResult, RenderSceneProjectionSlot } from '../render-scene-projection';
-import type {
-  GpuDrivenDrawSnapshot,
-  MaterialSnapshot,
-  RenderableSnapshot,
-} from '../render-system-extract';
+import type { PrimitiveTopology } from '@forgeax/engine-types';
+import type { BatchTopologyInspection } from '../inspection-types';
+import type { RenderSceneApplyResult, RenderSceneSlot } from '../scene/render-scene-types';
+
+export type { BatchTopologyInspection } from '../inspection-types';
 
 export interface GpuDrivenBatchKey {
   readonly assetHandle: number;
@@ -14,42 +11,9 @@ export interface GpuDrivenBatchKey {
   readonly count: number;
   readonly baseVertex: number;
   readonly materialSlot: number;
-  readonly submeshIndex: number;
-  readonly passIndex: number;
-  readonly queue: number;
-  readonly topology: string;
-  readonly pipelineClass: string;
-  readonly materialResourceClass: string;
-  /** Material shader identity is part of topology, not a record-time guess. */
-  readonly materialClass: string;
-  /** Scene Fact resource revision invalidates stale resource bindings. */
-  readonly resourceRevision: number;
-  /** Scene Fact material revision keeps material payload changes isolated. */
-  readonly materialRevision: number;
-  /** Explicit alpha-test qualification (queue or alphaCutoff > 0). */
-  readonly alphaTest: boolean;
-  /** `true` means the raster state intentionally keeps both faces. */
-  readonly doubleSided: boolean;
-  /** Standard/custom PBR qualification used by the capability lane. */
-  readonly pbr: boolean;
-  /**
-   * ShadowCaster batch qualification; only explicit ineligible excludes a
-   * candidate. Unknown facts stay in the pool until the existing ShadowCaster
-   * dispatch and CascadeVolumeSet membership make the per-view decision.
-   */
-  readonly shadowCaster: boolean;
-}
-
-export interface GpuDrivenBatchSemantics {
+  readonly topology: PrimitiveTopology;
   readonly pipelineClass: string;
-  readonly materialClass: string;
   readonly materialResourceClass: string;
-  readonly resourceRevision: number;
-  readonly materialRevision: number;
-  readonly alphaTest: boolean;
-  readonly doubleSided: boolean;
-  readonly pbr: boolean;
-  readonly shadowCaster: boolean;
 }
 
 export interface GpuDrivenCandidate {
@@ -76,106 +40,6 @@ export interface SubmissionPlan {
   readonly visibleCapacity: number;
 }
 
-export interface SubmissionCandidateMembershipEntry {
-  readonly batchId: number;
-  readonly candidate: GpuDrivenCandidate;
-}
-
-/**
- * Immutable reverse membership for one submission topology.
- *
- * Candidate-domain owners publish stable primitive ids, while both the
- * shadow view projector and cascade-local cache tokens need to answer the
- * inverse question: which source batches contain this primitive? Keep that
- * join beside the immutable SubmissionPlan so each consumer pays O(D) once
- * per topology instead of rescanning every batch for every view/cascade.
- */
-export interface SubmissionCandidateMembership {
-  readonly source: SubmissionPlan;
-  readonly byPrimitiveIndex: ReadonlyMap<number, readonly SubmissionCandidateMembershipEntry[]>;
-  /** O(1) lookup for batch metadata after a primitive-to-batch join. */
-  readonly byBatchId: ReadonlyMap<number, SubmissionPlan['batches'][number]>;
-}
-
-const submissionCandidateMembershipCache = new WeakMap<
-  SubmissionPlan,
-  SubmissionCandidateMembership
->();
-
-export function buildSubmissionCandidateMembership(
-  source: SubmissionPlan,
-): SubmissionCandidateMembership {
-  const cached = submissionCandidateMembershipCache.get(source);
-  if (cached !== undefined) return cached;
-
-  const mutable = new Map<number, SubmissionCandidateMembershipEntry[]>();
-  const byBatchId = new Map<number, SubmissionPlan['batches'][number]>();
-  for (const batch of source.batches) {
-    byBatchId.set(batch.batchId, batch);
-    for (const candidate of batch.candidates) {
-      const entries = mutable.get(candidate.primitiveIndex) ?? [];
-      entries.push({ batchId: batch.batchId, candidate });
-      mutable.set(candidate.primitiveIndex, entries);
-    }
-  }
-  const byPrimitiveIndex = new Map<number, readonly SubmissionCandidateMembershipEntry[]>();
-  for (const [primitiveIndex, entries] of mutable) {
-    byPrimitiveIndex.set(primitiveIndex, Object.freeze(entries));
-  }
-  const membership: SubmissionCandidateMembership = {
-    source,
-    byPrimitiveIndex,
-    byBatchId,
-  };
-  submissionCandidateMembershipCache.set(source, membership);
-  return membership;
-}
-
-/**
- * Build a submission while retaining the source topology identity.
- *
- * Visibility is allowed to replace candidates and capacities per view, but it
- * must not allocate a second batch identity or change indirect slot ownership.
- * This helper is shared by the forward and shadow capability lanes so compact
- * arrays, aligned bases, and indirect offsets have one producer.
- */
-export function buildBatchAlignedSubmission(
-  source: SubmissionPlan,
-  candidatesByBatch: ReadonlyMap<number, readonly GpuDrivenCandidate[]>,
-): SubmissionPlan {
-  let visibleBase = 0;
-  const batches: GpuDrivenBatch[] = [];
-  for (const sourceBatch of source.batches) {
-    const candidates = candidatesByBatch.get(sourceBatch.batchId) ?? [];
-    if (candidates.length === 0) continue;
-    visibleBase = alignInstanceBase(visibleBase);
-    batches.push(
-      Object.freeze({
-        ...sourceBatch,
-        candidates: Object.freeze([...candidates]),
-        visibleBase,
-        visibleCapacity: candidates.length,
-      }),
-    );
-    visibleBase += candidates.length;
-  }
-  return Object.freeze({
-    revision: source.revision,
-    batches: Object.freeze(batches),
-    candidateCount: batches.reduce((total, batch) => total + batch.candidates.length, 0),
-    visibleCapacity: visibleBase,
-  });
-}
-
-export interface BatchTopologyInspection {
-  readonly revision: number;
-  readonly batchCount: number;
-  readonly candidateCount: number;
-  readonly rebuilds: number;
-  readonly patches: number;
-  readonly ineligible: number;
-}
-
 interface MutableBatch {
   readonly batchId: number;
   readonly generation: number;
@@ -183,71 +47,29 @@ interface MutableBatch {
   readonly candidates: Map<string, GpuDrivenCandidate>;
 }
 
-function materialForDraw(
-  snapshot: RenderableSnapshot,
-  draw: GpuDrivenDrawSnapshot,
-): MaterialSnapshot {
-  return snapshot.materials[draw.materialSlot] ?? snapshot.material;
-}
-
-export function deriveGpuDrivenBatchSemantics(
-  snapshot: RenderableSnapshot,
-  draw: GpuDrivenDrawSnapshot,
-): GpuDrivenBatchSemantics {
-  const material = materialForDraw(snapshot, draw);
-  const cutoff = material.paramSnapshot?.alphaCutoff;
-  const alphaTest =
-    draw.queue === RenderQueue.AlphaTest || (typeof cutoff === 'number' && cutoff > 0);
-  const materialClass = material.materialShaderId ?? 'forgeax::default-unlit';
-  const pbr =
-    isStandardPbrMaterialShader(material.materialShaderId) ||
-    materialClass.toLowerCase().includes('pbr') ||
-    draw.pipelineClass.toLowerCase().includes('pbr');
-  return {
-    pipelineClass: draw.pipelineClass,
-    materialClass,
-    materialResourceClass: draw.materialResourceClass,
-    resourceRevision: snapshot.sceneFact?.revisions?.resource ?? 0,
-    materialRevision: snapshot.sceneFact?.revisions?.material ?? 0,
-    alphaTest,
-    doubleSided: material.renderState?.cullMode === 'none',
-    pbr,
-    // Material pass ownership is the authoritative per-slot caster fact. The
-    // scene fact remains a conservative fallback for older/test snapshots
-    // that predate the material projection field.
-    shadowCaster: material.shadowCaster ?? snapshot.sceneFact?.casterEligibility !== 'ineligible',
-  };
-}
-
-export function buildGpuDrivenBatchKey(
-  snapshot: RenderableSnapshot,
-  draw: GpuDrivenDrawSnapshot,
-): GpuDrivenBatchKey {
-  const semantics = deriveGpuDrivenBatchSemantics(snapshot, draw);
-  return {
+function eligibleKeys(slot: RenderSceneSlot): readonly GpuDrivenBatchKey[] {
+  const snapshot = slot.snapshot;
+  const draws = snapshot.gpuDrivenDraws;
+  if (
+    draws === undefined ||
+    draws.length === 0 ||
+    snapshot.localAabb === undefined ||
+    snapshot.skin !== undefined ||
+    snapshot.spriteInstances !== undefined
+  ) {
+    return [];
+  }
+  return draws.map((draw) => ({
     assetHandle: snapshot.assetHandle,
     drawKind: draw.kind,
     first: draw.first,
     count: draw.count,
     baseVertex: draw.baseVertex,
     materialSlot: draw.materialSlot,
-    submeshIndex: draw.submeshIndex,
-    passIndex: draw.passIndex,
-    queue: draw.queue,
     topology: draw.topology,
-    ...semantics,
-  };
-}
-
-function eligibleKeys(slot: RenderSceneProjectionSlot): readonly GpuDrivenBatchKey[] {
-  const snapshot = slot.snapshot;
-  const draws = snapshot.gpuDrivenDraws;
-  // Batch topology is pass-agnostic. Rigid forward raster capability is
-  // decided by production-raster; excluding skin, sprites, or missing local
-  // bounds here would also remove valid ShadowCaster work from the shared
-  // indirect submission owner.
-  if (draws === undefined || draws.length === 0) return [];
-  return draws.map((draw) => buildGpuDrivenBatchKey(snapshot, draw));
+    pipelineClass: draw.pipelineClass,
+    materialResourceClass: draw.materialResourceClass,
+  }));
 }
 
 function keyText(key: GpuDrivenBatchKey): string {
@@ -278,7 +100,7 @@ export class BatchTopology {
   private patches = 0;
   private cachedPlan: SubmissionPlan | undefined;
 
-  rebuild(slots: readonly RenderSceneProjectionSlot[]): void {
+  rebuild(slots: readonly RenderSceneSlot[]): void {
     this.batches.clear();
     this.membershipByPrimitive.clear();
     this.ineligiblePrimitives.clear();
@@ -367,7 +189,7 @@ export class BatchTopology {
     };
   }
 
-  private add(slot: RenderSceneProjectionSlot): boolean {
+  private add(slot: RenderSceneSlot): boolean {
     const keys = eligibleKeys(slot);
     if (keys.length === 0) {
       this.ineligiblePrimitives.add(slot.slot);