@forgeax/engine-render 0.1.2

package/src/features/render-graph-raster.ts

@@ -0,0 +1,308 @@
+import type {
+  GraphBuffer,
+  GraphResourceResolver,
+  GraphTexture,
+  GraphTextureView,
+  RasterDepthStencilAttachment,
+  RenderGraphBuilder,
+  RenderGraphError,
+  RenderGraphFrame,
+} from '@forgeax/engine-render-graph';
+import type { BindGroup, RhiRenderPassEncoder } from '@forgeax/engine-rhi';
+import { err, ok, type Result } from '@forgeax/engine-types';
+import {
+  type RenderError,
+  RenderFeatureDrawRecordingFailedError,
+  RenderFeatureStageFailedError,
+} from '../errors/render';
+import type {
+  PreparedGraphicsResolvedResource,
+  PreparedGraphicsResolvedSnapshot,
+} from '../prepare/prepared-graphics-resolver';
+import type { RenderFeatureResolvedGpuBuffer } from './prepared-gpu-work';
+import type {
+  RenderFeatureGraphicsPassDescriptor,
+  RenderFeaturePreparedGraphicsState,
+  RenderFeaturePreparedRef,
+} from './prepared-graphics';
+import { validateRenderFeatureGraphicsPass } from './prepared-graphics';
+import { RenderFeatureGraphBufferRegistry } from './render-graph-resources';
+import type { RenderFeatureTargetHandle } from './targets';
+
+export interface RenderFeatureGraphTarget {
+  readonly texture: GraphTexture;
+  readonly view: GraphTextureView;
+  readonly resolveTarget?: GraphTextureView | undefined;
+}
+
+export type RenderFeatureGraphTargetResolver = (
+  resource: string | RenderFeatureTargetHandle,
+) => RenderFeatureGraphTarget | undefined;
+
+export type RenderFeatureGraphBindingsResolver<FrameCtx extends RenderGraphFrame> = (input: {
+  readonly frame: FrameCtx;
+  readonly binding: Extract<PreparedGraphicsResolvedResource, { readonly kind: 'bindings' }>;
+  readonly resources: GraphResourceResolver;
+  readonly resolveTarget: RenderFeatureGraphTargetResolver;
+}) => BindGroup | undefined;
+
+interface ResolvedDrawBuffers {
+  readonly vertex: ReadonlyMap<object, GraphBuffer>;
+  readonly index: ReadonlyMap<object, GraphBuffer>;
+  readonly indirect: ReadonlyMap<object, GraphBuffer>;
+}
+
+function missing(featureIdentity: string, order: number): RenderFeatureStageFailedError {
+  return new RenderFeatureStageFailedError(featureIdentity, order, 'record', 'renderer-recover');
+}
+
+function resolved(
+  snapshot: PreparedGraphicsResolvedSnapshot,
+  reference: RenderFeaturePreparedRef,
+): PreparedGraphicsResolvedResource | undefined {
+  return snapshot.resolve(reference);
+}
+
+export class RenderFeatureRasterGraphProjection<FrameCtx extends RenderGraphFrame> {
+  private readonly buffers: RenderFeatureGraphBufferRegistry<FrameCtx>;
+
+  constructor(
+    private readonly builder: RenderGraphBuilder<FrameCtx>,
+    private readonly resolveTarget: RenderFeatureGraphTargetResolver,
+    private readonly resolveBindings?: RenderFeatureGraphBindingsResolver<FrameCtx>,
+    buffers?: RenderFeatureGraphBufferRegistry<FrameCtx>,
+    private readonly reportError?: (error: RenderError) => void,
+  ) {
+    this.buffers = buffers ?? new RenderFeatureGraphBufferRegistry(builder);
+  }
+
+  addPass(
+    name: string,
+    featureIdentity: string,
+    order: number,
+    descriptor: RenderFeatureGraphicsPassDescriptor,
+    state: RenderFeaturePreparedGraphicsState,
+    snapshot: PreparedGraphicsResolvedSnapshot,
+  ): Result<void, RenderGraphError | RenderError> {
+    const validated = validateRenderFeatureGraphicsPass(featureIdentity, descriptor, state);
+    if (!validated.ok) return validated;
+
+    const accesses = [];
+    const colors = [];
+    for (const attachment of descriptor.attachments.colors) {
+      const target = this.resolveTarget(attachment.resource);
+      if (target === undefined) return err(missing(featureIdentity, order));
+      accesses.push({ resource: target.view, usage: 'color-attachment' } as const);
+      colors.push({
+        view: target.view,
+        ...(target.resolveTarget === undefined ? {} : { resolveTarget: target.resolveTarget }),
+        loadOp: attachment.loadOp,
+        storeOp: attachment.storeOp,
+      });
+    }
+
+    let depthStencilAttachment: RasterDepthStencilAttachment | undefined;
+    const depth = descriptor.attachments.depthStencil;
+    if (depth !== undefined) {
+      const target = this.resolveTarget(depth.resource);
+      if (target === undefined) return err(missing(featureIdentity, order));
+      const sampled = (descriptor.sampledTargets ?? []).some(
+        (candidate) =>
+          typeof depth.resource !== 'string' &&
+          candidate.kind === depth.resource.kind &&
+          candidate.format === depth.resource.format &&
+          candidate.sampleCount === depth.resource.sampleCount,
+      );
+      accesses.push({
+        resource: target.view,
+        usage: sampled ? ('depth-stencil-read' as const) : ('depth-stencil-write' as const),
+      });
+      depthStencilAttachment = sampled
+        ? { view: target.view, depthReadOnly: true, stencilReadOnly: true }
+        : {
+            view: target.view,
+            depthLoadOp: depth.depthLoadOp,
+            depthStoreOp: depth.depthStoreOp,
+            stencilLoadOp: depth.depthLoadOp,
+            stencilStoreOp: depth.depthStoreOp,
+          };
+    }
+
+    for (const sampled of descriptor.sampledTargets ?? []) {
+      const target = this.resolveTarget(sampled);
+      if (target === undefined) return err(missing(featureIdentity, order));
+      accesses.push({ resource: target.view, usage: 'sampled-read' } as const);
+    }
+
+    const drawBuffers = this.importDrawBuffers(name, featureIdentity, order, descriptor, snapshot);
+    if (!drawBuffers.ok) return drawBuffers;
+    for (const handle of drawBuffers.value.vertex.values()) {
+      accesses.push({ resource: handle, usage: 'vertex-read' } as const);
+    }
+    for (const handle of drawBuffers.value.index.values()) {
+      accesses.push({ resource: handle, usage: 'index-read' } as const);
+    }
+    for (const handle of drawBuffers.value.indirect.values()) {
+      accesses.push({ resource: handle, usage: 'indirect-read' } as const);
+    }
+
+    return this.builder.addRasterPass(name, {
+      accesses,
+      colorAttachments: colors,
+      ...(depthStencilAttachment === undefined ? {} : { depthStencilAttachment }),
+      encode: ({ pass, frame, resources }) => {
+        try {
+          this.encode(
+            featureIdentity,
+            order,
+            descriptor,
+            snapshot,
+            drawBuffers.value,
+            pass,
+            frame,
+            resources,
+          );
+        } catch (failure) {
+          this.reportError?.(
+            failure instanceof Error && typeof (failure as Partial<RenderError>).code === 'string'
+              ? (failure as RenderError)
+              : new RenderFeatureDrawRecordingFailedError(
+                  featureIdentity,
+                  order,
+                  name,
+                  'pipeline',
+                  'backend-recording-failed',
+                  failure instanceof Error ? failure.message : String(failure),
+                  'renderer-recover',
+                ),
+          );
+        }
+      },
+    });
+  }
+
+  private importDrawBuffers(
+    name: string,
+    featureIdentity: string,
+    order: number,
+    descriptor: RenderFeatureGraphicsPassDescriptor,
+    snapshot: PreparedGraphicsResolvedSnapshot,
+  ): Result<ResolvedDrawBuffers, RenderGraphError | RenderError> {
+    const vertex = new Map<object, GraphBuffer>();
+    const index = new Map<object, GraphBuffer>();
+    const indirect = new Map<object, GraphBuffer>();
+    const add = (
+      destination: Map<object, GraphBuffer>,
+      key: object,
+      resource: RenderFeatureResolvedGpuBuffer,
+    ): Result<void, RenderGraphError> => {
+      if (destination.has(key)) return ok(undefined);
+      const imported = this.buffers.import(name, resource);
+      if (!imported.ok) return imported;
+      destination.set(key, imported.value);
+      return ok(undefined);
+    };
+
+    for (const draw of descriptor.draws) {
+      for (const binding of draw.vertexData) {
+        const resource = resolved(snapshot, binding.resource);
+        if (resource?.kind !== 'vertex-data') return err(missing(featureIdentity, order));
+        const added = add(vertex, binding.resource as object, {
+          buffer: resource.handle,
+          size: resource.size,
+          physicalUsage: resource.physicalUsage,
+        });
+        if (!added.ok) return added;
+      }
+      if (draw.indexData !== undefined) {
+        const resource = resolved(snapshot, draw.indexData.resource);
+        if (resource?.kind !== 'index-data') return err(missing(featureIdentity, order));
+        const added = add(index, draw.indexData.resource as object, {
+          buffer: resource.handle,
+          size: resource.size,
+          physicalUsage: resource.physicalUsage,
+        });
+        if (!added.ok) return added;
+      }
+      if (draw.kind === 'draw-indirect' || draw.kind === 'draw-indexed-indirect') {
+        const resource = snapshot.resolveGpuBuffer?.(draw.command.buffer);
+        if (resource === undefined) return err(missing(featureIdentity, order));
+        const added = add(indirect, draw.command.buffer as object, resource);
+        if (!added.ok) return added;
+      }
+    }
+    return ok({ vertex, index, indirect });
+  }
+
+  private encode(
+    featureIdentity: string,
+    order: number,
+    descriptor: RenderFeatureGraphicsPassDescriptor,
+    snapshot: PreparedGraphicsResolvedSnapshot,
+    buffers: ResolvedDrawBuffers,
+    pass: RhiRenderPassEncoder,
+    frame: FrameCtx,
+    resources: GraphResourceResolver,
+  ): void {
+    for (const draw of descriptor.draws) {
+      const pipeline = resolved(snapshot, draw.pipeline);
+      if (pipeline?.kind !== 'pipeline') throw missing(featureIdentity, order);
+      pass.setPipeline(pipeline.handle);
+      for (const [group, reference] of draw.bindings.entries()) {
+        const binding = resolved(snapshot, reference);
+        if (binding?.kind !== 'bindings') throw missing(featureIdentity, order);
+        const handle =
+          binding.handle ??
+          this.resolveBindings?.({ frame, binding, resources, resolveTarget: this.resolveTarget });
+        if (handle === undefined) throw missing(featureIdentity, order);
+        pass.setBindGroup(group, handle, binding.dynamicOffsets);
+      }
+      for (const vertex of draw.vertexData) {
+        const handle = buffers.vertex.get(vertex.resource as object);
+        if (handle === undefined) throw missing(featureIdentity, order);
+        const physical = resources.buffer(handle);
+        if (!physical.ok) throw physical.error;
+        pass.setVertexBuffer(vertex.slot, physical.value);
+      }
+      if (draw.indexData !== undefined) {
+        const handle = buffers.index.get(draw.indexData.resource as object);
+        if (handle === undefined) throw missing(featureIdentity, order);
+        const physical = resources.buffer(handle);
+        if (!physical.ok) throw physical.error;
+        pass.setIndexBuffer(physical.value, draw.indexData.format);
+      }
+      switch (draw.kind) {
+        case 'draw':
+          pass.draw(
+            draw.command.vertexCount,
+            draw.command.instanceCount,
+            draw.command.firstVertex,
+            draw.command.firstInstance,
+          );
+          break;
+        case 'draw-indexed':
+          pass.drawIndexed(
+            draw.command.indexCount,
+            draw.command.instanceCount,
+            draw.command.firstIndex,
+            draw.command.baseVertex,
+            draw.command.firstInstance,
+          );
+          break;
+        case 'draw-indirect':
+        case 'draw-indexed-indirect': {
+          const handle = buffers.indirect.get(draw.command.buffer as object);
+          if (handle === undefined) throw missing(featureIdentity, order);
+          const physical = resources.buffer(handle);
+          if (!physical.ok) throw physical.error;
+          if (draw.kind === 'draw-indirect') {
+            pass.drawIndirect(physical.value, draw.command.offset ?? 0);
+          } else {
+            pass.drawIndexedIndirect(physical.value, draw.command.offset ?? 0);
+          }
+          break;
+        }
+      }
+    }
+  }
+}

package/src/features/render-graph-resources.ts

@@ -0,0 +1,36 @@
+import type {
+  GraphBuffer,
+  RenderGraphBuilder,
+  RenderGraphError,
+  RenderGraphFrame,
+} from '@forgeax/engine-render-graph';
+import type { Buffer } from '@forgeax/engine-rhi';
+import { ok, type Result } from '@forgeax/engine-types';
+import type { RenderFeatureResolvedGpuBuffer } from './prepared-gpu-work';
+
+export class RenderFeatureGraphBufferRegistry<FrameCtx extends RenderGraphFrame> {
+  private readonly handles = new Map<Buffer, GraphBuffer>();
+  private readonly labelCounts = new Map<string, number>();
+
+  constructor(private readonly builder: RenderGraphBuilder<FrameCtx>) {}
+
+  import(
+    label: string,
+    resource: RenderFeatureResolvedGpuBuffer,
+  ): Result<GraphBuffer, RenderGraphError> {
+    const existing = this.handles.get(resource.buffer);
+    if (existing !== undefined) {
+      return ok(existing);
+    }
+    const count = this.labelCounts.get(label) ?? 0;
+    this.labelCounts.set(label, count + 1);
+    const imported = this.builder.importBuffer(
+      count === 0 ? label : `${label}.${count}`,
+      { size: resource.size, usage: resource.physicalUsage },
+      () => resource.buffer,
+    );
+    if (!imported.ok) return imported;
+    this.handles.set(resource.buffer, imported.value);
+    return imported;
+  }
+}

package/src/features/scene-temporal.ts

@@ -0,0 +1,274 @@
+import type {
+  GraphAccess,
+  RenderGraphBuilder,
+  RenderGraphError,
+} from '@forgeax/engine-render-graph';
+import { ok, RenderQueue, type Result } from '@forgeax/engine-types';
+import type { RenderPipelineFrame } from '../render-pipeline';
+import { createRenderPipelineTarget, type RenderPipelineTarget } from '../render-pipeline-target';
+import type { DispatchEntry, RenderableSnapshot } from '../render-system-extract';
+import {
+  summarizeTemporalCoverage,
+  type TemporalCoverageContribution,
+  type TemporalCoverageSummary,
+  type TemporalProducerLane,
+  type TemporalReactiveReason,
+} from '../temporal-coverage';
+import { addTypedScenePass } from '../typed-render-graph-primitives';
+import type { RenderFeatureGraphContribution } from './graph-contribution';
+import { isRenderFeatureTargetHandle } from './targets';
+
+export const SCENE_TEMPORAL_TARGET_FORMAT = 'rgba16float' as const;
+export const SCENE_TEMPORAL_TARGET_SAMPLE_COUNT = 1 as const;
+export const SCENE_TEMPORAL_CLEAR_VALUE = Object.freeze({ r: 0, g: 0, b: -1, a: 1 });
+export const SCENE_TEMPORAL_PACKED_ABI = Object.freeze({
+  x: 'unjittered-currentUv-minus-previousUv-x',
+  y: 'unjittered-currentUv-minus-previousUv-y',
+  z: 'monotonic-view-depth',
+  w: 'reactive-0-to-1',
+});
+
+const REACTIVE_REVISION_IDENTITY = 'scene:temporal-reactive-revision';
+
+/** Add one existing current-only signal without creating a second temporal owner. */
+export function markSceneReactiveRevision(
+  coverage: TemporalCoverageSummary,
+  changed: boolean,
+): TemporalCoverageSummary {
+  if (
+    !changed ||
+    coverage.contributors.some(({ identity }) => identity === REACTIVE_REVISION_IDENTITY)
+  ) {
+    return coverage;
+  }
+  return summarizeTemporalCoverage([
+    ...coverage.contributors,
+    {
+      identity: REACTIVE_REVISION_IDENTITY,
+      lane: 'render-feature',
+      coverage: 'reactive',
+      reason: 'producer-reactive-fallback',
+    },
+  ]);
+}
+
+/** Allocate and initialize the TAA-only packed temporal target. */
+export function createSceneTemporalTarget(
+  graph: RenderGraphBuilder<RenderPipelineFrame>,
+): Result<RenderPipelineTarget, RenderGraphError> {
+  const target = createRenderPipelineTarget(graph, 'scene-temporal', {
+    format: SCENE_TEMPORAL_TARGET_FORMAT,
+    size: 'surface',
+    sampleCount: SCENE_TEMPORAL_TARGET_SAMPLE_COUNT,
+  });
+  if (!target.ok) return target;
+  const clear = graph.addRasterPass('scene-temporal-clear', {
+    accesses: [{ resource: target.value.view, usage: 'color-attachment' }],
+    colorAttachments: [
+      {
+        view: target.value.view,
+        loadOp: 'clear',
+        storeOp: 'store',
+        clearValue: SCENE_TEMPORAL_CLEAR_VALUE,
+      },
+    ],
+    encode: () => undefined,
+  });
+  return clear.ok ? ok(target.value) : clear;
+}
+
+/** Allocate the unjittered visibility authority consumed only by temporal replay. */
+export function createSceneTemporalDepthTarget(
+  graph: RenderGraphBuilder<RenderPipelineFrame>,
+): Result<RenderPipelineTarget, RenderGraphError> {
+  return createRenderPipelineTarget(graph, 'scene-temporal-depth', {
+    format: 'depth24plus-stencil8',
+    size: 'surface',
+    sampleCount: 1,
+  });
+}
+
+export interface SceneTemporalRasterOptions {
+  readonly target: RenderPipelineTarget;
+  readonly depth: RenderPipelineTarget;
+  readonly sampled?: readonly RenderPipelineTarget[] | undefined;
+  readonly directionalShadow?: RenderPipelineTarget | undefined;
+  readonly spotShadow?: RenderPipelineTarget | undefined;
+  readonly ssao?: RenderPipelineTarget | undefined;
+  readonly extraAccesses?: readonly GraphAccess[] | undefined;
+}
+
+/** Replay visible scene geometry once into the packed temporal attachment. */
+export function addSceneTemporalRasterPass(
+  graph: RenderGraphBuilder<RenderPipelineFrame>,
+  options: SceneTemporalRasterOptions,
+): Result<void, RenderGraphError> {
+  return addTypedScenePass(graph, {
+    name: 'scene-temporal',
+    color: options.target,
+    depth: options.depth,
+    selector: { LightMode: ['Forward'] },
+    passKind: 'temporal',
+    colorLoadOp: 'load',
+    depthLoadOp: 'clear',
+    ...(options.sampled === undefined ? {} : { sampled: options.sampled }),
+    ...(options.directionalShadow === undefined
+      ? {}
+      : { directionalShadow: options.directionalShadow }),
+    ...(options.spotShadow === undefined ? {} : { spotShadow: options.spotShadow }),
+    ...(options.ssao === undefined ? {} : { ssao: options.ssao }),
+    ...(options.extraAccesses === undefined ? {} : { extraAccesses: options.extraAccesses }),
+  });
+}
+
+function materialReactiveReason(snapshot: RenderableSnapshot): TemporalReactiveReason | undefined {
+  const reasons = snapshot.temporal?.reactiveReasons;
+  if (reasons?.includes('material-revision')) return 'material-revision';
+  if (reasons?.includes('geometry-revision')) return 'geometry-revision';
+  if (reasons?.includes('generation-reuse')) return 'generation-reuse';
+  if (reasons?.includes('reentered')) return 'visibility-reentry';
+  if (reasons?.includes('new-slot')) return 'first-observation';
+  return undefined;
+}
+
+function producerLane(snapshot: RenderableSnapshot, dispatch: DispatchEntry): TemporalProducerLane {
+  const shader = dispatch.materialShaderId ?? snapshot.material.materialShaderId;
+  if (shader === 'forgeax::sprite' || shader === 'forgeax::sprite-lit') return 'sprite';
+  if (dispatch.renderState?.blend !== undefined || dispatch.queue >= RenderQueue.Transparent) {
+    return 'transparent';
+  }
+  if (shader !== undefined && !shader.startsWith('forgeax::')) return 'custom-deformation';
+  if (dispatch.vertexEntry !== undefined && dispatch.vertexEntry !== 'vs_main') {
+    return 'custom-deformation';
+  }
+  if (snapshot.skin !== undefined) return 'skinning';
+  if (snapshot.morphWeights !== undefined) return 'morph';
+  if (snapshot.instances !== undefined) return 'instances';
+  const alphaCutoff = dispatch.paramSnapshot?.alphaCutoff;
+  if (
+    dispatch.queue === RenderQueue.AlphaTest ||
+    (typeof alphaCutoff === 'number' && alphaCutoff > 0)
+  ) {
+    return 'alpha-cutout';
+  }
+  return 'rigid';
+}
+
+function standardContribution(
+  snapshot: RenderableSnapshot,
+  dispatch: DispatchEntry,
+): TemporalCoverageContribution {
+  const identity = `scene:${snapshot.worldId}:${snapshot.entityKey}:${dispatch.passIndex}:${dispatch.materialHandle}`;
+  const lane = producerLane(snapshot, dispatch);
+  if (snapshot.temporal === undefined) {
+    return { identity, lane, coverage: 'missing', reason: 'previous-state-unavailable' };
+  }
+  if (lane === 'transparent' || lane === 'sprite' || lane === 'custom-deformation') {
+    return { identity, lane, coverage: 'reactive', reason: 'producer-reactive-fallback' };
+  }
+  if (
+    lane === 'skinning' &&
+    (snapshot.skin?.jointMatrices === undefined ||
+      (snapshot.temporal.previousSource === 'last-submitted' &&
+        snapshot.temporal.previousSkin?.jointMatrices === undefined))
+  ) {
+    return { identity, lane, coverage: 'missing', reason: 'previous-state-unavailable' };
+  }
+  const reactive = materialReactiveReason(snapshot);
+  if (reactive !== undefined) return { identity, lane, coverage: 'reactive', reason: reactive };
+  return {
+    identity,
+    lane,
+    coverage: 'exact',
+    previous: snapshot.temporal.previousSource,
+  };
+}
+
+function featureContributions(
+  contributions: readonly RenderFeatureGraphContribution[],
+): TemporalCoverageContribution[] {
+  const coverage: TemporalCoverageContribution[] = [];
+  for (const contribution of contributions) {
+    for (const pass of contribution.passes) {
+      const graphics = pass.graphics;
+      if (graphics === undefined || graphics.draws.length === 0) continue;
+      const writesScene = graphics.attachments.colors.some((attachment) => {
+        const resource = attachment.resource;
+        return (
+          resource === 'swapchain' ||
+          (isRenderFeatureTargetHandle(resource) && resource.kind === 'scene-color')
+        );
+      });
+      if (!writesScene) continue;
+      const identity = `feature:${contribution.featureIdentity}:${pass.name}`;
+      const writesTemporal = graphics.attachments.colors.some(
+        (attachment) =>
+          isRenderFeatureTargetHandle(attachment.resource) &&
+          attachment.resource.kind === 'scene-temporal',
+      );
+      if (graphics.temporalCoverage === 'reactive') {
+        coverage.push({
+          identity,
+          lane: contribution.featureIdentity.includes('vfx') ? 'vfx' : 'render-feature',
+          coverage: 'reactive',
+          reason: 'producer-reactive-fallback',
+        });
+      } else if (graphics.temporalCoverage === 'exact' && writesTemporal) {
+        coverage.push({
+          identity,
+          lane: 'render-feature',
+          coverage: 'exact',
+          previous: 'last-submitted',
+        });
+      } else {
+        coverage.push({
+          identity,
+          lane: 'render-feature',
+          coverage: 'missing',
+          reason:
+            graphics.temporalCoverage === 'exact'
+              ? 'exact-target-unwritten'
+              : 'feature-coverage-undeclared',
+        });
+      }
+    }
+  }
+  return coverage;
+}
+
+/** Classify every standard draw and visible feature pass exactly once. */
+export function sceneTemporalCoverage(input: {
+  readonly renderables: readonly RenderableSnapshot[];
+  readonly dispatch: readonly DispatchEntry[];
+  readonly features: readonly RenderFeatureGraphContribution[];
+}): TemporalCoverageSummary {
+  const contributions: TemporalCoverageContribution[] = [];
+  const dispatched = new Set<number>();
+  for (const entry of input.dispatch) {
+    const snapshot = input.renderables[entry.renderableIndex];
+    if (snapshot === undefined) continue;
+    dispatched.add(entry.renderableIndex);
+    contributions.push(standardContribution(snapshot, entry));
+  }
+  for (let index = 0; index < input.renderables.length; index += 1) {
+    if (dispatched.has(index)) continue;
+    const snapshot = input.renderables[index];
+    if (snapshot === undefined) continue;
+    contributions.push({
+      identity: `scene:${snapshot.worldId}:${snapshot.entityKey}:undispatched`,
+      lane: 'rigid',
+      coverage: 'missing',
+      reason: 'dispatch-unavailable',
+    });
+  }
+  contributions.push(...featureContributions(input.features));
+  const priority = { exact: 0, reactive: 1, missing: 2 } as const;
+  const byIdentity = new Map<string, TemporalCoverageContribution>();
+  for (const contribution of contributions) {
+    const current = byIdentity.get(contribution.identity);
+    if (current === undefined || priority[contribution.coverage] > priority[current.coverage]) {
+      byIdentity.set(contribution.identity, contribution);
+    }
+  }
+  return summarizeTemporalCoverage([...byIdentity.values()]);
+}