@forgeax/engine-render 0.1.21 → 0.1.23

package/src/errors/recover.ts

@@ -7,6 +7,38 @@
 // channel (see render-contract.ts RendererError composition).
 
 import type { DeviceScopeReceipt } from '../device/resource-types';
+import type { ReflectionFallbackRecoveryAction } from '../inspection-types';
+import type { SsrAdmissionError, SsrOwnerRecoveryAction } from '../ssr/errors';
+
+export type { ReflectionFallbackRecoveryAction } from '../inspection-types';
+
+export function reflectionFallbackRecoveryAction(
+  source: 'probe' | 'skylight' | 'neutral',
+  hasLastKnownGood: boolean,
+): ReflectionFallbackRecoveryAction {
+  if (source === 'probe' && hasLastKnownGood) return 'use-LKG';
+  if (source === 'skylight') return 'use-Skylight';
+  return 'use-neutral';
+}
+
+/**
+ * Maps a detached admission failure to the owning producer action. This is
+ * an instruction projection only; SSR never performs the recovery itself.
+ */
+export function ssrAdmissionRecoveryAction(error: SsrAdmissionError): SsrOwnerRecoveryAction {
+  switch (error.code) {
+    case 'ssr-not-requested':
+    case 'ssr-receipt-stale':
+      return 'retry';
+    case 'ssr-reflection-fallback-unavailable':
+      return error.detail.action;
+    case 'ssr-format-unavailable':
+    case 'ssr-temporal-unavailable':
+      return error.detail.action;
+    case 'ssr-receipt-identity-mismatch':
+      return 'rebuild';
+  }
+}
 
 // ── RecoverError (feat-20260621-renderer-health-recover-skeleton M1) ─────────
 

package/src/errors/render.ts

@@ -116,6 +116,60 @@ export function createRenderSurfaceError(
   return new RenderSurfaceError(`surface-${kind}-failed` as SurfaceFailureCode, detail);
 }
 
+export type LightResourceFailureReason = 'asset' | 'format' | 'capability' | 'capacity';
+
+export interface LightResourceUnavailableDetail {
+  readonly entity: number;
+  readonly feature: 'ies' | 'cookie' | 'probe';
+  readonly generation: number;
+  readonly sourceKey: string;
+  readonly reason: LightResourceFailureReason;
+}
+
+export class LightResourceUnavailableError extends Error {
+  readonly code = 'light-resource-unavailable' as const;
+  readonly expected: string;
+  readonly hint: string;
+  readonly detail: LightResourceUnavailableDetail;
+
+  constructor(
+    detail: LightResourceUnavailableDetail,
+    expected: string,
+    actual: string,
+    hint: string,
+  ) {
+    super(`light-resource-unavailable: ${detail.feature} ${actual}`);
+    this.name = 'LightResourceUnavailableError';
+    this.expected = expected;
+    this.hint = hint;
+    this.detail = detail;
+  }
+}
+
+export function createLightResourceUnavailable(input: {
+  readonly entity: number;
+  readonly feature: LightResourceUnavailableDetail['feature'];
+  readonly generation: number;
+  readonly sourceKey: string;
+  readonly reason: LightResourceFailureReason;
+  readonly expected: string;
+  readonly actual: string;
+  readonly hint: string;
+}): LightResourceUnavailableError {
+  return new LightResourceUnavailableError(
+    {
+      entity: input.entity,
+      feature: input.feature,
+      generation: input.generation,
+      sourceKey: input.sourceKey,
+      reason: input.reason,
+    },
+    input.expected,
+    input.actual,
+    input.hint,
+  );
+}
+
 export interface TemporalFrameSubmitDetail {
   readonly reason: 'queue-submit-failed';
 }
@@ -132,7 +186,6 @@ export class TemporalFrameSubmitError extends Error {
     this.detail = { reason };
   }
 }
-
 // ── ShadowInvalidConfigError ──────────────────────────────────────────────
 
 /**
@@ -1821,6 +1874,7 @@ export type RenderError =
   | PointsLinesMaterialUnsupportedError
   | PointsLinesBudgetExceededError
   | PointsLinesPrepareFailedError
+  | LightResourceUnavailableError
   | RenderTargetDescriptorInvalidError
   | RenderTargetCapabilityMissingError
   | RenderTargetStateInvalidError

package/src/extract/camera.ts

@@ -1,7 +1,7 @@
 import type { EntityHandle, World } from '@forgeax/engine-ecs';
 import { readRenderArrayView } from '@forgeax/engine-ecs/projection';
 import { mat4, vec3 } from '@forgeax/engine-math';
-import { Transform } from '@forgeax/engine-scene';
+import { GlobalTransform } from '@forgeax/engine-scene';
 import {
   antialiasFromF32,
   bloomEnabledFromF32,
@@ -14,7 +14,7 @@ import type { CameraSnapshot } from '../render-contract';
 import { getActiveCamera, selectActiveCameraIndex } from '../systems/active-camera';
 
 function readWorldMatrix(world: World, entity: EntityHandle): Float32Array | undefined {
-  const view = readRenderArrayView(world, entity, Transform, 'world');
+  const view = readRenderArrayView(world, entity, GlobalTransform, 'world');
   return view === undefined ? undefined : new Float32Array(view);
 }
 
@@ -23,7 +23,7 @@ export function extractCameraSnapshots(world: World): CameraSnapshot[] {
   const cameras: CameraSnapshot[] = [];
   const cameraEntities: number[] = [];
   const cameraQuery = world
-    .query({ read: [Camera], optional: [MotionBlur], with: [Transform] })
+    .query({ read: [Camera], optional: [MotionBlur], with: [GlobalTransform] })
     .unwrap();
   for (const row of cameraQuery) {
     const cam = row.get(Camera);

package/src/extract/gpu-driven.ts

@@ -0,0 +1,108 @@
+import type { MaterialShaderArtifact } from '@forgeax/engine-shader';
+import type { MeshAsset } from '@forgeax/engine-types';
+import {
+  type GpuDrivenDrawRange,
+  type PreparedGpuDrivenDraw,
+  type PrepareGpuDrivenDrawInput,
+  prepareGpuDrivenDraw,
+} from '../gpu-driven/prepared-draw';
+import type { MaterialSnapshot } from '../render-system-extract';
+
+export {
+  GpuDrivenPreparationError,
+  type GpuDrivenPreparationErrorCode,
+  type GpuDrivenPreparationErrorDetail,
+  type GpuDrivenPreparationReason,
+} from '../errors/gpu-driven';
+export {
+  type GpuDrivenDrawRange,
+  type GpuDrivenGeometryReceipt,
+  type GpuDrivenSkinReceipt,
+  type PreparedGpuDrivenDraw,
+  type PrepareGpuDrivenDrawInput,
+  prepareGpuDrivenDraw,
+} from '../gpu-driven/prepared-draw';
+
+export interface GpuDrivenDrawSnapshot {
+  readonly kind: GpuDrivenDrawRange['kind'];
+  readonly first: GpuDrivenDrawRange['first'];
+  readonly count: GpuDrivenDrawRange['count'];
+  readonly baseVertex: GpuDrivenDrawRange['baseVertex'];
+  readonly materialSlot: number;
+  readonly topology: GpuDrivenDrawRange['topology'];
+  readonly pipelineClass: string;
+  readonly materialResourceClass: string;
+  /** Producer-owned prepared ABI facts used by the PBR GPU lane. */
+  readonly prepared?: PreparedGpuDrivenDraw;
+}
+
+/**
+ * Resolves prepared facts once at extract time; record never re-reads assets.
+ * The resolver surfaces UV, reflection, vertex, alpha, resource, and
+ * generation failures as GpuDrivenPreparationError before recording.
+ */
+export function resolvePreparedGpuDrivenDraw(input: PrepareGpuDrivenDrawInput):
+  | { readonly ok: true; readonly value: PreparedGpuDrivenDraw }
+  | {
+      readonly ok: false;
+      readonly error: import('../errors/gpu-driven').GpuDrivenPreparationError;
+    } {
+  return prepareGpuDrivenDraw(input);
+}
+
+/** Keeps the artifact type visible at this owner boundary for contract checks. */
+export type PreparedGpuDrivenArtifact = MaterialShaderArtifact;
+
+/**
+ * Derives the resource identity consumed by the existing GPU-driven batch
+ * owner. The extract stage is the only place that resolves material values;
+ * this helper keeps the batch adapter from re-reading assets later.
+ */
+export function gpuDrivenMaterialResourceClass(material: MaterialSnapshot): string {
+  const textures = [...(material.textureHandles?.entries() ?? [])]
+    .map(([name, handle]) => [name, Number(handle)] as const)
+    .sort(([left], [right]) => left.localeCompare(right));
+  const samplers = [...(material.samplerHandles?.entries() ?? [])]
+    .map(([name, handle]) => [name, Number(handle)] as const)
+    .sort(([left], [right]) => left.localeCompare(right));
+  return JSON.stringify({
+    textures,
+    samplers,
+    video: [...(material.videoTextureFields?.keys() ?? [])].sort(),
+  });
+}
+
+/**
+ * Projects already-resolved mesh facts into the existing GPU-driven draw
+ * snapshot. No World or AssetRegistry access is permitted at this boundary.
+ */
+export function buildGpuDrivenDraws(input: {
+  readonly submeshes: readonly MeshAsset['submeshes'][number][];
+  readonly indexed: boolean;
+  readonly materials: readonly MaterialSnapshot[];
+  readonly fallbackMaterial: MaterialSnapshot;
+  readonly prepare?: (
+    draw: GpuDrivenDrawSnapshot,
+    material: MaterialSnapshot,
+  ) => PreparedGpuDrivenDraw | undefined;
+}): GpuDrivenDrawSnapshot[] {
+  let nonIndexedFirst = 0;
+  return input.submeshes.flatMap((submesh) => {
+    const drawMaterial = input.materials[submesh.materialSlot] ?? input.fallbackMaterial;
+    const first = input.indexed ? submesh.indexOffset : nonIndexedFirst;
+    nonIndexedFirst += submesh.vertexCount;
+    if (drawMaterial.transparent === true) return [];
+    const draw: GpuDrivenDrawSnapshot = {
+      kind: input.indexed ? ('indexed' as const) : ('non-indexed' as const),
+      first,
+      count: input.indexed ? submesh.indexCount : submesh.vertexCount,
+      baseVertex: 0,
+      materialSlot: submesh.materialSlot,
+      topology: submesh.topology,
+      pipelineClass: `${drawMaterial.materialShaderId ?? 'forgeax::default-unlit'}|${submesh.topology}|${JSON.stringify(drawMaterial.renderState ?? null)}`,
+      materialResourceClass: gpuDrivenMaterialResourceClass(drawMaterial),
+    };
+    const prepared = input.prepare?.(draw, drawMaterial);
+    return [prepared === undefined ? draw : { ...draw, prepared }];
+  });
+}

package/src/extract/visibility.ts

@@ -1,5 +1,4 @@
 import type { EntityHandle, World } from '@forgeax/engine-ecs';
-import { createWorldProjection } from '@forgeax/engine-ecs/projection';
 import {
   projectHierarchy,
   type SceneHierarchyDiagnostic,
@@ -38,14 +37,6 @@ interface ResolutionState {
   readonly source: VisibilitySource;
 }
 
-interface VisibilityCacheEntry {
-  readonly changes: ReturnType<typeof createWorldProjection>;
-  readonly hierarchy: SceneHierarchySnapshot;
-  readonly snapshot: VisibilitySnapshot;
-}
-
-const VISIBILITY_CACHE = new WeakMap<World, VisibilityCacheEntry>();
-
 /**
  * Resolve author intent against the scene-owned valid parent projection.
  * Diagnostics are preserved for callers to repair hierarchy input before retry.
@@ -54,19 +45,6 @@ export function resolveVisibility(
   world: World,
   hierarchy: SceneHierarchySnapshot = projectHierarchy(world),
 ): VisibilitySnapshot {
-  const cached = VISIBILITY_CACHE.get(world);
-  const changes = cached?.changes ?? createWorldProjection(world, { components: [Visibility] });
-  if (cached !== undefined) {
-    const evidence = changes.poll();
-    if (
-      evidence.status === 'delta' &&
-      evidence.changes.length === 0 &&
-      cached.hierarchy === hierarchy
-    ) {
-      return cached.snapshot;
-    }
-  }
-
   // Visibility is an opt-in component. Query only the owning archetypes
   // instead of walking every Entity row with an optional column; the latter
   // made a World with no visibility intents pay a full-scene scan on each
@@ -158,6 +136,5 @@ export function resolveVisibility(
       return resolveEntity?.(entity)?.effective ?? 'visible';
     },
   };
-  VISIBILITY_CACHE.set(world, { changes, hierarchy, snapshot });
   return snapshot;
 }

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

@@ -1,6 +1,10 @@
 import type { PrimitiveTopology } from '@forgeax/engine-types';
 import type { BatchTopologyInspection } from '../inspection-types';
+import type { CameraSnapshot } from '../render-contract';
 import type { RenderSceneApplyResult, RenderSceneSlot } from '../scene/render-scene-types';
+import { type GpuLodRow, selectGpuLod } from '../scene/visibility/gpu-lod';
+import { projectedHeight as measureProjectedHeight } from '../scene/visibility/lod-selector';
+import type { PreparedGpuDrivenDraw } from './prepared-draw';
 
 export type { BatchTopologyInspection } from '../inspection-types';
 
@@ -14,6 +18,12 @@ export interface GpuDrivenBatchKey {
   readonly topology: PrimitiveTopology;
   readonly pipelineClass: string;
   readonly materialResourceClass: string;
+  /** Stable producer-owned identity; topology never derives this from a shader name. */
+  readonly preparedIdentity?: string;
+  /** Resource identity projected by the prepared material contract. */
+  readonly resourceIdentity?: string;
+  /** Closed admission lane for the prepared Standard PBR draw. */
+  readonly admission?: 'opaque' | 'alpha-mask';
 }
 
 export interface GpuDrivenCandidate {
@@ -21,6 +31,16 @@ export interface GpuDrivenCandidate {
   readonly generation: number;
   readonly drawItemIndex: number;
   readonly instanceOrdinal: number;
+  /** Absolute coverage rows uploaded to the GPU selector; root is implicit. */
+  readonly lodCoverages?: readonly number[];
+  readonly lodHysteresis?: number;
+  readonly projectedHeight?: number;
+  readonly lodRanges?: readonly {
+    readonly first: number;
+    readonly count: number;
+    readonly baseVertex: number;
+  }[];
+  readonly prepared?: PreparedGpuDrivenDraw;
 }
 
 export interface GpuDrivenBatch {
@@ -40,6 +60,32 @@ export interface SubmissionPlan {
   readonly visibleCapacity: number;
 }
 
+export interface GpuLodCandidateInput {
+  readonly candidate: GpuDrivenCandidate;
+  readonly rows: readonly GpuLodRow[];
+  readonly projectedHeight: number;
+  readonly previousLevel: number;
+  readonly historyValid: boolean;
+}
+
+export interface GpuLodCompactCandidate {
+  readonly candidate: GpuDrivenCandidate;
+  readonly level: number;
+  readonly confidence: number;
+}
+
+/** Selects one level per stable topology candidate without mutating membership. */
+export function compactGpuLodCandidates(
+  inputs: readonly GpuLodCandidateInput[],
+): readonly GpuLodCompactCandidate[] {
+  return Object.freeze(
+    inputs.map((input) => {
+      const selection = selectGpuLod(input.rows, input);
+      return Object.freeze({ candidate: input.candidate, ...selection });
+    }),
+  );
+}
+
 interface MutableBatch {
   readonly batchId: number;
   readonly generation: number;
@@ -56,27 +102,97 @@ function eligibleKeys(slot: RenderSceneSlot): readonly GpuDrivenBatchKey[] {
     snapshot.instances?.instanceCount === 0 ||
     snapshot.localAabb === undefined ||
     snapshot.skin !== undefined ||
+    snapshot.morph !== 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,
-    topology: draw.topology,
-    pipelineClass: draw.pipelineClass,
-    materialResourceClass: draw.materialResourceClass,
-  }));
+  return draws.flatMap((draw) => {
+    const prepared = draw.prepared;
+    const material = snapshot.materials[draw.materialSlot] ?? snapshot.material;
+    if (prepared !== undefined) {
+      const isStandardPbr =
+        (material.materialShaderId === 'forgeax::default-standard-pbr' &&
+          prepared.identity.material === 'forgeax::default-standard-pbr') ||
+        (material.materialShaderId === 'forgeax::default-standard-pbr-skin' &&
+          prepared.identity.material === 'forgeax::default-standard-pbr-skin');
+      const isAlphaBlend =
+        material.transparent === true || material.renderState?.blend !== undefined;
+      if (!isStandardPbr || isAlphaBlend || prepared.identity.deformation !== 'rigid') return [];
+      const preparedIdentity = `${prepared.identity.material}|${prepared.identity.geometry}|${prepared.identity.deformation}`;
+      const admission =
+        typeof material.paramSnapshot?.alphaCutoff === 'number' ? 'alpha-mask' : 'opaque';
+      return [
+        {
+          assetHandle: snapshot.assetHandle,
+          drawKind: draw.kind,
+          first: prepared.first,
+          count: prepared.count,
+          baseVertex: prepared.baseVertex,
+          materialSlot: draw.materialSlot,
+          topology: prepared.topology,
+          pipelineClass: preparedIdentity,
+          materialResourceClass: draw.materialResourceClass,
+          preparedIdentity,
+          resourceIdentity: draw.materialResourceClass,
+          admission,
+        },
+      ];
+    }
+    return [
+      {
+        assetHandle: snapshot.assetHandle,
+        drawKind: draw.kind,
+        first: draw.first,
+        count: draw.count,
+        baseVertex: draw.baseVertex,
+        materialSlot: draw.materialSlot,
+        topology: draw.topology,
+        pipelineClass: draw.pipelineClass,
+        materialResourceClass: draw.materialResourceClass,
+      },
+    ];
+  });
 }
 
 function keyText(key: GpuDrivenBatchKey): string {
   return JSON.stringify(key);
 }
 
+/**
+ * A GPU indirect draw has one index/vertex range for the whole batch.  LOD
+ * selection is per candidate, so sharing a batch between LOD candidates would
+ * let `finalizeView` pick the first candidate's range for every visible
+ * instance. Keep LOD candidates in single-candidate batches; ordinary meshes
+ * retain the existing compatibility batching path.
+ */
+function candidateBatchText(
+  key: GpuDrivenBatchKey,
+  primitiveIndex: number,
+  drawItemIndex: number,
+  instanceOrdinal: number,
+  hasLod: boolean,
+): string {
+  return hasLod
+    ? `${keyText(key)}|lod:${primitiveIndex}:${drawItemIndex}:${instanceOrdinal}`
+    : keyText(key);
+}
+
+function membershipTexts(slot: RenderSceneSlot): readonly string[] {
+  const keys = eligibleKeys(slot);
+  const instanceCount = slot.snapshot.instances?.instanceCount ?? 1;
+  const hasLod = (slot.snapshot.lods?.length ?? 0) > 0;
+  const texts: string[] = [];
+  for (let drawItemIndex = 0; drawItemIndex < keys.length; drawItemIndex += 1) {
+    const key = keys[drawItemIndex];
+    if (key === undefined) continue;
+    for (let instanceOrdinal = 0; instanceOrdinal < instanceCount; instanceOrdinal += 1) {
+      texts.push(candidateBatchText(key, slot.slot, drawItemIndex, instanceOrdinal, hasLod));
+    }
+  }
+  return texts;
+}
+
 function alignInstanceBase(value: number): number {
   // Raster binds each batch's visible-index and compact-transform segment at
   // a static storage-buffer offset. WebGPU requires those offsets to satisfy
@@ -86,6 +202,42 @@ function alignInstanceBase(value: number): number {
   return Math.ceil(value / 64) * 64;
 }
 
+export function projectedHeightForCandidate(slot: RenderSceneSlot, camera: CameraSnapshot): number {
+  const aabb = slot.snapshot.localAabb;
+  if (aabb === undefined || aabb.length < 6) return Number.NaN;
+  const halfX = Math.abs((aabb[3] ?? 0) - (aabb[0] ?? 0)) * 0.5;
+  const halfY = Math.abs((aabb[4] ?? 0) - (aabb[1] ?? 0)) * 0.5;
+  const halfZ = Math.abs((aabb[5] ?? 0) - (aabb[2] ?? 0)) * 0.5;
+  const world = slot.snapshot.transform.world;
+  // Transform the local AABB's half extents through the absolute value of the
+  // world 3x3. This is the conservative world-space sphere bound for every
+  // rotation and signed/non-uniform scale, and keeps CPU projection aligned
+  // with the world transform uploaded to the GPU selector.
+  const worldHalfX =
+    Math.abs(world[0] ?? 0) * halfX +
+    Math.abs(world[4] ?? 0) * halfY +
+    Math.abs(world[8] ?? 0) * halfZ;
+  const worldHalfY =
+    Math.abs(world[1] ?? 0) * halfX +
+    Math.abs(world[5] ?? 0) * halfY +
+    Math.abs(world[9] ?? 0) * halfZ;
+  const worldHalfZ =
+    Math.abs(world[2] ?? 0) * halfX +
+    Math.abs(world[6] ?? 0) * halfY +
+    Math.abs(world[10] ?? 0) * halfZ;
+  const radius = Math.hypot(worldHalfX, worldHalfY, worldHalfZ);
+  const dx = (world[12] ?? 0) - (camera.position[0] ?? 0);
+  const dy = (world[13] ?? 0) - (camera.position[1] ?? 0);
+  const dz = (world[14] ?? 0) - (camera.position[2] ?? 0);
+  return measureProjectedHeight({
+    radius,
+    depth: Math.hypot(dx, dy, dz),
+    projection: camera.projection,
+    fov: camera.fov,
+    orthoHeight: Math.abs(camera.orthoTop - camera.orthoBottom),
+  });
+}
+
 /** Stable compatibility grouping; per-view visibility never mutates this owner. */
 export class BatchTopology {
   private readonly batches = new Map<string, MutableBatch>();
@@ -120,15 +272,17 @@ export class BatchTopology {
       changed = this.remove(slot.slot) || changed;
       changed = this.add(slot) || changed;
     }
+    // Most updated slots are transform-only. A full renderable update can
+    // still carry a changed material/geometry/draw topology, so compare the
+    // stable batch memberships and patch only when that key actually changed.
+    // This keeps moving entities on the zero-work transform lane while making
+    // same-entity resource edits visible to the GPU-driven owner.
     for (const slot of delta.updatedSlots) {
-      const instanceCount = slot.snapshot.instances?.instanceCount ?? 1;
-      const nextTexts = eligibleKeys(slot).flatMap((key) =>
-        Array.from({ length: instanceCount }, () => keyText(key)),
-      );
-      const current = this.membershipByPrimitive.get(slot.slot) ?? [];
+      const previous = this.membershipByPrimitive.get(slot.slot) ?? [];
+      const next = membershipTexts(slot);
       if (
-        current.length === nextTexts.length &&
-        current.every((membership, index) => membership.batchText === nextTexts[index])
+        previous.length === next.length &&
+        previous.every((membership, index) => membership.batchText === next[index])
       ) {
         continue;
       }
@@ -199,26 +353,50 @@ export class BatchTopology {
     this.ineligiblePrimitives.delete(slot.slot);
     const memberships: Array<{ batchText: string; candidateKey: string }> = [];
     const instanceCount = slot.snapshot.instances?.instanceCount ?? 1;
+    const hasLod = (slot.snapshot.lods?.length ?? 0) > 0;
     for (let drawItemIndex = 0; drawItemIndex < keys.length; drawItemIndex += 1) {
       const key = keys[drawItemIndex];
       if (key === undefined) continue;
-      const text = keyText(key);
-      let batch = this.batches.get(text);
-      if (batch === undefined) {
-        const reused = this.freeBatchIds.pop();
-        const batchId = reused ?? this.generationByBatchId.length;
-        const generation = reused === undefined ? 0 : (this.generationByBatchId[batchId] ?? -1) + 1;
-        this.generationByBatchId[batchId] = generation;
-        batch = { batchId, generation, key, candidates: new Map() };
-        this.batches.set(text, batch);
-      }
       for (let instanceOrdinal = 0; instanceOrdinal < instanceCount; instanceOrdinal += 1) {
+        const text = candidateBatchText(key, slot.slot, drawItemIndex, instanceOrdinal, hasLod);
+        let batch = this.batches.get(text);
+        if (batch === undefined) {
+          const reused = this.freeBatchIds.pop();
+          const batchId = reused ?? this.generationByBatchId.length;
+          const generation =
+            reused === undefined ? 0 : (this.generationByBatchId[batchId] ?? -1) + 1;
+          this.generationByBatchId[batchId] = generation;
+          batch = { batchId, generation, key, candidates: new Map() };
+          this.batches.set(text, batch);
+        }
         const candidateKey = `${slot.slot}:${drawItemIndex}:${instanceOrdinal}`;
+        const draw = slot.snapshot.gpuDrivenDraws?.[drawItemIndex];
+        const prepared = draw?.prepared;
         batch.candidates.set(candidateKey, {
           primitiveIndex: slot.slot,
           generation: slot.generation,
           drawItemIndex,
           instanceOrdinal,
+          ...(draw?.projectedHeight === undefined ? {} : { projectedHeight: draw.projectedHeight }),
+          ...(slot.snapshot.lods === undefined
+            ? {}
+            : {
+                lodCoverages: [1, ...slot.snapshot.lods.map((lod) => lod.screenCoverage)],
+                ...(slot.snapshot.gpuDrivenDraws?.[drawItemIndex]?.lodRanges === undefined
+                  ? {}
+                  : {
+                      lodRanges: slot.snapshot.gpuDrivenDraws[drawItemIndex]
+                        ?.lodRanges as readonly {
+                        readonly first: number;
+                        readonly count: number;
+                        readonly baseVertex: number;
+                      }[],
+                    }),
+                ...(slot.snapshot.lodHysteresis === undefined
+                  ? {}
+                  : { lodHysteresis: slot.snapshot.lodHysteresis }),
+              }),
+          ...(prepared === undefined ? {} : { prepared }),
         });
         memberships.push({ batchText: text, candidateKey });
       }