@forgeax/engine-render 0.1.2

package/src/render-scene-projection.ts

@@ -0,0 +1,1738 @@
+import type {
+  RenderSceneFact,
+  RenderSceneFactInput,
+  SceneCasterEligibility,
+  SceneFactDiagnostic,
+  SceneFactRevisionDomain,
+  SceneFactRevisions,
+  SceneMobility,
+} from './gpu-scene-schema';
+import type {
+  RenderableReactiveReason,
+  RenderableSnapshot,
+  RenderableTemporalSnapshot,
+} from './render-system-extract';
+
+interface RenderSceneIdentity {
+  readonly worldId: number;
+  readonly entityKey: number;
+  /** Generation observed by the producer when the operation was authored. */
+  readonly expectedGeneration?: number;
+}
+
+export type RenderSceneOperation =
+  | {
+      readonly kind: 'create';
+      readonly snapshot: RenderableSnapshot;
+      readonly expectedGeneration?: number;
+    }
+  | (RenderSceneIdentity & {
+      readonly kind: 'update-transform';
+      readonly world: Float32Array;
+    })
+  | (RenderSceneIdentity & { readonly kind: 'remove' });
+
+export interface RenderSceneFactDelta {
+  readonly slot: number;
+  readonly generation: number;
+  readonly changedDomains: readonly SceneFactRevisionDomain[];
+  readonly previous: RenderSceneFact | undefined;
+  readonly current: RenderSceneFact;
+}
+
+export interface RenderSceneApplyResult {
+  readonly created: number;
+  readonly updated: number;
+  readonly removed: number;
+  readonly recreated: number;
+  readonly ignoredLateUpdates: number;
+  readonly createdSlots: readonly RenderSceneProjectionSlot[];
+  readonly updatedSlots: readonly RenderSceneProjectionSlot[];
+  readonly removedSlots: readonly RenderSceneProjectionRecord[];
+  readonly recreatedSlots: readonly RenderSceneProjectionSlot[];
+  /** Fine-grained Scene Fact updates consumed by GPU tables and later views. */
+  readonly factDeltas: readonly RenderSceneFactDelta[];
+  /** Non-fatal diagnostics; malformed facts never become implicit casters. */
+  readonly diagnostics: readonly SceneFactDiagnostic[];
+  /** Spatial owner revisions produced by this projection update. */
+  readonly spatialIndex?: SpatialIndexUpdate;
+}
+
+export interface RenderSceneProjectionRecord
+  extends Omit<RenderSceneIdentity, 'expectedGeneration'> {
+  readonly slot: number;
+  readonly generation: number;
+}
+
+export interface RenderSceneProjectionInspection {
+  readonly current: readonly RenderSceneProjectionRecord[];
+  readonly lastSubmitted: {
+    readonly epoch: number;
+    readonly records: readonly RenderSceneProjectionRecord[];
+  };
+  readonly slotCapacity: number;
+  readonly freeSlots: number;
+  readonly factDiagnostics: readonly SceneFactDiagnostic[];
+  readonly spatialIndex: SpatialIndexInspection;
+}
+
+export interface RenderSceneProjectionSlot extends RenderSceneProjectionRecord {
+  readonly snapshot: RenderableSnapshot;
+  readonly fact: RenderSceneFact;
+}
+
+type ProjectionSlot = RenderSceneProjectionSlot;
+
+function submittedIdentity(slot: number, generation: number): string {
+  return `${slot}:${generation}`;
+}
+
+export interface RenderSceneSubmissionCapture {
+  readonly revision: number;
+  readonly slots: readonly {
+    readonly slot: number;
+    readonly current: RenderSceneProjectionSlot | undefined;
+  }[];
+  readonly visible: ReadonlySet<string>;
+}
+
+export interface RenderSceneSubmissionDelta {
+  readonly epoch: number;
+  readonly slots: readonly number[];
+}
+
+export type SpatialIndexOwnerKind = 'static-bvh' | 'dynamic-loose-tree';
+
+export interface SpatialQueryHit extends RenderSceneProjectionRecord {
+  readonly owner: SpatialIndexOwnerKind;
+  readonly mobility: SceneMobility;
+  readonly worldAabb: Float32Array | undefined;
+}
+
+export interface SpatialQueryResult {
+  readonly hits: readonly SpatialQueryHit[];
+  readonly staticRevision: number;
+  readonly dynamicRevision: number;
+  readonly visitedNodes: number;
+  readonly testedEntries: number;
+  readonly falseNegativeSlots: readonly number[];
+}
+
+export interface SpatialIndexOwnerInspection {
+  readonly revision: number;
+  readonly entries: number;
+  readonly boundedEntries: number;
+  readonly unboundedEntries: number;
+  readonly nodes: number;
+  readonly rebuilds: number;
+  readonly patches: number;
+  readonly queries: number;
+  readonly visitedNodes: number;
+  readonly testedEntries: number;
+  readonly returnedEntries: number;
+}
+
+export interface SpatialIndexInspection {
+  readonly revision: number;
+  readonly static: SpatialIndexOwnerInspection;
+  readonly dynamic: SpatialIndexOwnerInspection & {
+    readonly dynamicEntries: number;
+    readonly unknownEntries: number;
+    readonly reinserts: number;
+  };
+  readonly broadphaseQueries: number;
+  readonly bruteForceComparisons: number;
+  readonly falseNegatives: number;
+}
+
+export interface SpatialIndexUpdate {
+  readonly revision: number;
+  readonly staticRevision: number;
+  readonly dynamicRevision: number;
+  readonly staticChanged: boolean;
+  readonly dynamicChanged: boolean;
+  readonly inspection: SpatialIndexInspection;
+}
+
+interface SpatialRecord {
+  readonly slot: number;
+  readonly generation: number;
+  readonly worldId: number;
+  readonly entityKey: number;
+  readonly mobility: SceneMobility;
+  readonly worldAabb: Float32Array | undefined;
+}
+
+interface SpatialQueryOwnerResult {
+  readonly records: readonly SpatialRecord[];
+  readonly visitedNodes: number;
+  readonly testedEntries: number;
+}
+
+interface ConservativeSpatialIndexOwner {
+  query(bounds: Float32Array): SpatialQueryOwnerResult;
+}
+
+interface StaticBvhNode {
+  readonly bounds: Float32Array;
+  readonly left: StaticBvhNode | undefined;
+  readonly right: StaticBvhNode | undefined;
+  readonly record: SpatialRecord | undefined;
+}
+
+interface DynamicLooseNode {
+  parent: DynamicLooseNode | undefined;
+  left: DynamicLooseNode | undefined;
+  right: DynamicLooseNode | undefined;
+  bounds: Float32Array;
+  record: SpatialRecord | undefined;
+}
+
+function spatialRecord(slot: RenderSceneProjectionSlot): SpatialRecord {
+  return {
+    slot: slot.slot,
+    generation: slot.generation,
+    worldId: slot.worldId,
+    entityKey: slot.entityKey,
+    mobility: slot.fact.mobility,
+    worldAabb:
+      slot.fact.bounds.status === 'present'
+        ? new Float32Array(slot.fact.bounds.worldAabb)
+        : undefined,
+  };
+}
+
+function sameSpatialRecord(left: SpatialRecord | undefined, right: SpatialRecord): boolean {
+  return (
+    left !== undefined &&
+    left.generation === right.generation &&
+    left.worldId === right.worldId &&
+    left.entityKey === right.entityKey &&
+    left.mobility === right.mobility &&
+    sameFloatArray(left.worldAabb, right.worldAabb)
+  );
+}
+
+function mergeAabbInto(target: Float32Array, left: Float32Array, right: Float32Array): void {
+  target[0] = Math.min(left[0] ?? 0, right[0] ?? 0);
+  target[1] = Math.min(left[1] ?? 0, right[1] ?? 0);
+  target[2] = Math.min(left[2] ?? 0, right[2] ?? 0);
+  target[3] = Math.max(left[3] ?? 0, right[3] ?? 0);
+  target[4] = Math.max(left[4] ?? 0, right[4] ?? 0);
+  target[5] = Math.max(left[5] ?? 0, right[5] ?? 0);
+}
+
+function mergeAabb(left: Float32Array, right: Float32Array): Float32Array {
+  const merged = new Float32Array(6);
+  mergeAabbInto(merged, left, right);
+  return merged;
+}
+
+function overlapsAabb(left: Float32Array, right: Float32Array): boolean {
+  return (
+    (left[3] ?? -Infinity) >= (right[0] ?? Infinity) &&
+    (left[0] ?? Infinity) <= (right[3] ?? -Infinity) &&
+    (left[4] ?? -Infinity) >= (right[1] ?? Infinity) &&
+    (left[1] ?? Infinity) <= (right[4] ?? -Infinity) &&
+    (left[5] ?? -Infinity) >= (right[2] ?? Infinity) &&
+    (left[2] ?? Infinity) <= (right[5] ?? -Infinity)
+  );
+}
+
+function containsAabb(outer: Float32Array, inner: Float32Array): boolean {
+  return (
+    (outer[0] ?? Infinity) <= (inner[0] ?? -Infinity) &&
+    (outer[1] ?? Infinity) <= (inner[1] ?? -Infinity) &&
+    (outer[2] ?? Infinity) <= (inner[2] ?? -Infinity) &&
+    (outer[3] ?? -Infinity) >= (inner[3] ?? Infinity) &&
+    (outer[4] ?? -Infinity) >= (inner[4] ?? Infinity) &&
+    (outer[5] ?? -Infinity) >= (inner[5] ?? Infinity)
+  );
+}
+
+function aabbCost(bounds: Float32Array): number {
+  const x = Math.max(0, (bounds[3] ?? 0) - (bounds[0] ?? 0));
+  const y = Math.max(0, (bounds[4] ?? 0) - (bounds[1] ?? 0));
+  const z = Math.max(0, (bounds[5] ?? 0) - (bounds[2] ?? 0));
+  return 2 * (x * y + x * z + y * z);
+}
+
+/** Compute the union surface area without allocating a temporary AABB. */
+function mergedAabbCost(left: Float32Array, right: Float32Array): number {
+  const x = Math.max(
+    0,
+    Math.max(left[3] ?? 0, right[3] ?? 0) - Math.min(left[0] ?? 0, right[0] ?? 0),
+  );
+  const y = Math.max(
+    0,
+    Math.max(left[4] ?? 0, right[4] ?? 0) - Math.min(left[1] ?? 0, right[1] ?? 0),
+  );
+  const z = Math.max(
+    0,
+    Math.max(left[5] ?? 0, right[5] ?? 0) - Math.min(left[2] ?? 0, right[2] ?? 0),
+  );
+  return 2 * (x * y + x * z + y * z);
+}
+
+function looseBounds(bounds: Float32Array): Float32Array {
+  const extent = Math.max(
+    (bounds[3] ?? 0) - (bounds[0] ?? 0),
+    (bounds[4] ?? 0) - (bounds[1] ?? 0),
+    (bounds[5] ?? 0) - (bounds[2] ?? 0),
+  );
+  const margin = Math.max(0.01, extent * 0.125);
+  return new Float32Array([
+    (bounds[0] ?? 0) - margin,
+    (bounds[1] ?? 0) - margin,
+    (bounds[2] ?? 0) - margin,
+    (bounds[3] ?? 0) + margin,
+    (bounds[4] ?? 0) + margin,
+    (bounds[5] ?? 0) + margin,
+  ]);
+}
+
+function buildStaticBvh(records: readonly SpatialRecord[]): StaticBvhNode | undefined {
+  if (records.length === 0) return undefined;
+  if (records.length === 1) {
+    const record = records[0];
+    if (record?.worldAabb === undefined) return undefined;
+    return { bounds: record.worldAabb, left: undefined, right: undefined, record };
+  }
+  let bounds = records[0]?.worldAabb;
+  if (bounds === undefined) return undefined;
+  bounds = new Float32Array(bounds);
+  for (let index = 1; index < records.length; index += 1) {
+    const next = records[index]?.worldAabb;
+    if (next !== undefined) bounds = mergeAabb(bounds, next);
+  }
+  const extents = [
+    (bounds[3] ?? 0) - (bounds[0] ?? 0),
+    (bounds[4] ?? 0) - (bounds[1] ?? 0),
+    (bounds[5] ?? 0) - (bounds[2] ?? 0),
+  ];
+  let axis = 0;
+  if ((extents[1] ?? 0) > (extents[axis] ?? 0)) axis = 1;
+  if ((extents[2] ?? 0) > (extents[axis] ?? 0)) axis = 2;
+  const ordered = [...records].sort((left, right) => {
+    const leftBounds = left.worldAabb;
+    const rightBounds = right.worldAabb;
+    return (
+      ((leftBounds?.[axis] ?? 0) + (leftBounds?.[axis + 3] ?? 0)) * 0.5 -
+      ((rightBounds?.[axis] ?? 0) + (rightBounds?.[axis + 3] ?? 0)) * 0.5
+    );
+  });
+  const middle = Math.floor(ordered.length / 2);
+  const left = buildStaticBvh(ordered.slice(0, middle));
+  const right = buildStaticBvh(ordered.slice(middle));
+  if (left === undefined) return right;
+  if (right === undefined) return left;
+  return { bounds: mergeAabb(left.bounds, right.bounds), left, right, record: undefined };
+}
+
+function countStaticNodes(node: StaticBvhNode | undefined): number {
+  return node === undefined ? 0 : 1 + countStaticNodes(node.left) + countStaticNodes(node.right);
+}
+
+class StaticBvhOwner implements ConservativeSpatialIndexOwner {
+  private readonly records = new Map<number, SpatialRecord>();
+  private readonly unbounded = new Map<number, SpatialRecord>();
+  private root: StaticBvhNode | undefined;
+  private nodeCount = 0;
+  private revision = 0;
+  private rebuilds = 0;
+  private queries = 0;
+  private visitedNodes = 0;
+  private testedEntries = 0;
+  private returnedEntries = 0;
+
+  replace(records: readonly SpatialRecord[]): boolean {
+    const next = new Map(records.map((record) => [record.slot, record]));
+    const changed =
+      next.size !== this.records.size ||
+      [...next].some(([slot, record]) => !sameSpatialRecord(this.records.get(slot), record));
+    if (!changed) return false;
+    this.records.clear();
+    this.unbounded.clear();
+    for (const record of records) {
+      this.records.set(record.slot, record);
+      if (record.worldAabb === undefined) this.unbounded.set(record.slot, record);
+    }
+    this.rebuild();
+    this.revision += 1;
+    this.rebuilds += 1;
+    return true;
+  }
+
+  patch(records: readonly SpatialRecord[], removedSlots: readonly number[]): boolean {
+    let changed = false;
+    for (const slot of removedSlots) {
+      if (!this.records.delete(slot)) continue;
+      this.unbounded.delete(slot);
+      changed = true;
+    }
+    for (const record of records) {
+      if (record.mobility !== 'static') {
+        if (!this.records.delete(record.slot)) continue;
+        this.unbounded.delete(record.slot);
+        changed = true;
+        continue;
+      }
+      if (sameSpatialRecord(this.records.get(record.slot), record)) continue;
+      this.records.set(record.slot, record);
+      if (record.worldAabb === undefined) this.unbounded.set(record.slot, record);
+      else this.unbounded.delete(record.slot);
+      changed = true;
+    }
+    if (!changed) return false;
+    this.rebuild();
+    this.revision += 1;
+    this.rebuilds += 1;
+    return true;
+  }
+
+  query(bounds: Float32Array): SpatialQueryOwnerResult {
+    const records = [...this.unbounded.values()];
+    let visitedNodes = 0;
+    let testedEntries = this.unbounded.size;
+    const stack = this.root === undefined ? [] : [this.root];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node === undefined) continue;
+      visitedNodes += 1;
+      if (!overlapsAabb(node.bounds, bounds)) continue;
+      if (node.record !== undefined) {
+        testedEntries += 1;
+        records.push(node.record);
+      } else {
+        if (node.left !== undefined) stack.push(node.left);
+        if (node.right !== undefined) stack.push(node.right);
+      }
+    }
+    this.queries += 1;
+    this.visitedNodes += visitedNodes;
+    this.testedEntries += testedEntries;
+    this.returnedEntries += records.length;
+    return { records, visitedNodes, testedEntries };
+  }
+
+  snapshot(): readonly SpatialRecord[] {
+    return [...this.records.values()];
+  }
+
+  inspect(): SpatialIndexOwnerInspection {
+    return {
+      revision: this.revision,
+      entries: this.records.size,
+      boundedEntries: this.records.size - this.unbounded.size,
+      unboundedEntries: this.unbounded.size,
+      nodes: this.nodeCount,
+      rebuilds: this.rebuilds,
+      patches: 0,
+      queries: this.queries,
+      visitedNodes: this.visitedNodes,
+      testedEntries: this.testedEntries,
+      returnedEntries: this.returnedEntries,
+    };
+  }
+
+  private rebuild(): void {
+    this.root = buildStaticBvh(
+      [...this.records.values()].filter((record) => record.worldAabb !== undefined),
+    );
+    this.nodeCount = countStaticNodes(this.root);
+  }
+}
+
+class DynamicLooseTreeOwner implements ConservativeSpatialIndexOwner {
+  private readonly records = new Map<number, SpatialRecord>();
+  private readonly leaves = new Map<number, DynamicLooseNode>();
+  private readonly unbounded = new Map<number, SpatialRecord>();
+  private root: DynamicLooseNode | undefined;
+  private nodeCount = 0;
+  private dynamicEntries = 0;
+  private unknownEntries = 0;
+  private revision = 0;
+  private patches = 0;
+  private reinserts = 0;
+  private queries = 0;
+  private visitedNodes = 0;
+  private testedEntries = 0;
+  private returnedEntries = 0;
+
+  replace(records: readonly SpatialRecord[]): boolean {
+    const next = new Map(records.map((record) => [record.slot, record]));
+    let changed = false;
+    for (const slot of this.records.keys()) {
+      if (!next.has(slot)) {
+        this.remove(slot);
+        changed = true;
+      }
+    }
+    if (
+      !changed &&
+      [...next].every(([slot, record]) => sameSpatialRecord(this.records.get(slot), record))
+    ) {
+      return false;
+    }
+    this.records.clear();
+    this.leaves.clear();
+    this.unbounded.clear();
+    this.root = undefined;
+    this.nodeCount = 0;
+    this.dynamicEntries = 0;
+    this.unknownEntries = 0;
+    for (const record of records) {
+      this.records.set(record.slot, record);
+      this.addCategory(record);
+      if (record.worldAabb === undefined) this.unbounded.set(record.slot, record);
+    }
+    this.rebuild(records);
+    this.patches += records.length;
+    this.revision += 1;
+    return true;
+  }
+
+  patch(records: readonly SpatialRecord[], removedSlots: readonly number[]): boolean {
+    let changed = false;
+    for (const slot of removedSlots) {
+      if (!this.records.has(slot)) continue;
+      this.remove(slot);
+      changed = true;
+    }
+    for (const record of records) {
+      if (record.mobility === 'static') {
+        if (!this.records.has(record.slot)) continue;
+        this.remove(record.slot);
+        changed = true;
+        continue;
+      }
+      if (sameSpatialRecord(this.records.get(record.slot), record)) continue;
+      this.upsert(record);
+      changed = true;
+    }
+    if (changed) this.revision += 1;
+    return changed;
+  }
+
+  query(bounds: Float32Array): SpatialQueryOwnerResult {
+    const records = [...this.unbounded.values()];
+    let visitedNodes = 0;
+    let testedEntries = this.unbounded.size;
+    const stack = this.root === undefined ? [] : [this.root];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node === undefined) continue;
+      visitedNodes += 1;
+      if (!overlapsAabb(node.bounds, bounds)) continue;
+      if (node.record !== undefined) {
+        testedEntries += 1;
+        if (node.record.worldAabb === undefined || overlapsAabb(node.record.worldAabb, bounds)) {
+          records.push(node.record);
+        }
+      } else {
+        if (node.left !== undefined) stack.push(node.left);
+        if (node.right !== undefined) stack.push(node.right);
+      }
+    }
+    this.queries += 1;
+    this.visitedNodes += visitedNodes;
+    this.testedEntries += testedEntries;
+    this.returnedEntries += records.length;
+    return { records, visitedNodes, testedEntries };
+  }
+
+  snapshot(): readonly SpatialRecord[] {
+    return [...this.records.values()];
+  }
+
+  inspect(): SpatialIndexInspection['dynamic'] {
+    return {
+      revision: this.revision,
+      entries: this.records.size,
+      boundedEntries: this.records.size - this.unbounded.size,
+      unboundedEntries: this.unbounded.size,
+      nodes: this.nodeCount,
+      rebuilds: 0,
+      patches: this.patches,
+      queries: this.queries,
+      visitedNodes: this.visitedNodes,
+      testedEntries: this.testedEntries,
+      returnedEntries: this.returnedEntries,
+      dynamicEntries: this.dynamicEntries,
+      unknownEntries: this.unknownEntries,
+      reinserts: this.reinserts,
+    };
+  }
+
+  private upsert(record: SpatialRecord): void {
+    const previous = this.records.get(record.slot);
+    if (previous !== undefined) this.removeCategory(previous);
+    this.records.set(record.slot, record);
+    this.addCategory(record);
+    this.patches += 1;
+    if (record.worldAabb === undefined) {
+      this.removeLeaf(record.slot);
+      this.unbounded.set(record.slot, record);
+      return;
+    }
+    this.unbounded.delete(record.slot);
+    const leaf = this.leaves.get(record.slot);
+    if (
+      leaf !== undefined &&
+      previous?.generation === record.generation &&
+      containsAabb(leaf.bounds, record.worldAabb)
+    ) {
+      leaf.record = record;
+      return;
+    }
+    this.removeLeaf(record.slot);
+    this.insertLeaf({
+      parent: undefined,
+      left: undefined,
+      right: undefined,
+      bounds: looseBounds(record.worldAabb),
+      record,
+    });
+    if (leaf !== undefined) this.reinserts += 1;
+  }
+
+  private remove(slot: number): void {
+    const previous = this.records.get(slot);
+    if (previous === undefined) return;
+    this.records.delete(slot);
+    this.removeCategory(previous);
+    this.unbounded.delete(slot);
+    this.removeLeaf(slot);
+    this.patches += 1;
+  }
+
+  private addCategory(record: SpatialRecord): void {
+    if (record.mobility === 'dynamic') this.dynamicEntries += 1;
+    else this.unknownEntries += 1;
+  }
+
+  private removeCategory(record: SpatialRecord): void {
+    if (record.mobility === 'dynamic') this.dynamicEntries -= 1;
+    else this.unknownEntries -= 1;
+  }
+
+  private rebuild(records: readonly SpatialRecord[]): void {
+    const ordered = records
+      .filter((record) => record.worldAabb !== undefined)
+      .slice()
+      .sort(
+        (left, right) =>
+          ((left.worldAabb?.[0] ?? 0) + (left.worldAabb?.[3] ?? 0)) * 0.5 -
+          ((right.worldAabb?.[0] ?? 0) + (right.worldAabb?.[3] ?? 0)) * 0.5,
+      );
+    const build = (start: number, end: number): DynamicLooseNode | undefined => {
+      if (start >= end) return undefined;
+      if (end - start === 1) {
+        const record = ordered[start];
+        if (record === undefined || record.worldAabb === undefined) return undefined;
+        const leaf: DynamicLooseNode = {
+          parent: undefined,
+          left: undefined,
+          right: undefined,
+          bounds: looseBounds(record.worldAabb),
+          record,
+        };
+        this.leaves.set(record.slot, leaf);
+        this.nodeCount += 1;
+        return leaf;
+      }
+      const middle = start + Math.floor((end - start) / 2);
+      const left = build(start, middle);
+      const right = build(middle, end);
+      if (left === undefined) return right;
+      if (right === undefined) return left;
+      const parent: DynamicLooseNode = {
+        parent: undefined,
+        left,
+        right,
+        bounds: mergeAabb(left.bounds, right.bounds),
+        record: undefined,
+      };
+      left.parent = parent;
+      right.parent = parent;
+      this.nodeCount += 1;
+      return parent;
+    };
+    this.root = build(0, ordered.length);
+  }
+
+  private insertLeaf(leaf: DynamicLooseNode): void {
+    const slot = leaf.record?.slot;
+    if (slot === undefined) return;
+    this.leaves.set(slot, leaf);
+    if (this.root === undefined) {
+      this.root = leaf;
+      this.nodeCount += 1;
+      return;
+    }
+    let sibling = this.root;
+    while (sibling.record === undefined) {
+      const left = sibling.left;
+      const right = sibling.right;
+      if (left === undefined || right === undefined) break;
+      const leftCost = mergedAabbCost(left.bounds, leaf.bounds) - aabbCost(left.bounds);
+      const rightCost = mergedAabbCost(right.bounds, leaf.bounds) - aabbCost(right.bounds);
+      sibling = leftCost <= rightCost ? left : right;
+    }
+    const previousParent = sibling.parent;
+    const parent: DynamicLooseNode = {
+      parent: previousParent,
+      left: sibling,
+      right: leaf,
+      bounds: mergeAabb(sibling.bounds, leaf.bounds),
+      record: undefined,
+    };
+    sibling.parent = parent;
+    leaf.parent = parent;
+    if (previousParent === undefined) this.root = parent;
+    else if (previousParent.left === sibling) previousParent.left = parent;
+    else previousParent.right = parent;
+    this.nodeCount += 2;
+    this.refit(parent);
+  }
+
+  private removeLeaf(slot: number): void {
+    const leaf = this.leaves.get(slot);
+    if (leaf === undefined) return;
+    this.leaves.delete(slot);
+    if (leaf === this.root) {
+      this.root = undefined;
+      this.nodeCount -= 1;
+      return;
+    }
+    const parent = leaf.parent;
+    const sibling = parent?.left === leaf ? parent.right : parent?.left;
+    const grandparent = parent?.parent;
+    if (sibling === undefined) return;
+    sibling.parent = grandparent;
+    if (grandparent === undefined) this.root = sibling;
+    else if (grandparent.left === parent) grandparent.left = sibling;
+    else grandparent.right = sibling;
+    this.nodeCount -= 2;
+    this.refit(grandparent);
+  }
+
+  private refit(start: DynamicLooseNode | undefined): void {
+    let node = start;
+    while (node !== undefined) {
+      if (node.left !== undefined && node.right !== undefined) {
+        // Parent nodes own their bounds, so update in place. Dynamic
+        // transform/topology patches can refit thousands of ancestors per
+        // frame; allocating a Float32Array at every ancestor turns an
+        // O(delta log N) spatial update into a GC-heavy hot path.
+        mergeAabbInto(node.bounds, node.left.bounds, node.right.bounds);
+      }
+      node = node.parent;
+    }
+  }
+}
+
+class RenderSceneSpatialIndex {
+  private readonly staticOwner = new StaticBvhOwner();
+  private readonly dynamicOwner = new DynamicLooseTreeOwner();
+  private revision = 0;
+  private broadphaseQueries = 0;
+  private bruteForceComparisons = 0;
+  private falseNegatives = 0;
+
+  replace(slots: readonly RenderSceneProjectionSlot[]): SpatialIndexUpdate {
+    const records = slots.map(spatialRecord);
+    const staticChanged = this.staticOwner.replace(
+      records.filter((record) => record.mobility === 'static'),
+    );
+    const dynamicChanged = this.dynamicOwner.replace(
+      records.filter((record) => record.mobility !== 'static'),
+    );
+    if (staticChanged || dynamicChanged) this.revision += 1;
+    const inspection = this.inspect();
+    return {
+      revision: this.revision,
+      staticRevision: inspection.static.revision,
+      dynamicRevision: inspection.dynamic.revision,
+      staticChanged,
+      dynamicChanged,
+      inspection,
+    };
+  }
+
+  patch(
+    slots: readonly RenderSceneProjectionSlot[],
+    removedSlots: readonly RenderSceneProjectionRecord[],
+  ): SpatialIndexUpdate {
+    const records = slots.map(spatialRecord);
+    const removed = removedSlots.map((record) => record.slot);
+    const staticChanged = this.staticOwner.patch(records, removed);
+    const dynamicChanged = this.dynamicOwner.patch(records, removed);
+    if (staticChanged || dynamicChanged) this.revision += 1;
+    const inspection = this.inspect();
+    return {
+      revision: this.revision,
+      staticRevision: inspection.static.revision,
+      dynamicRevision: inspection.dynamic.revision,
+      staticChanged,
+      dynamicChanged,
+      inspection,
+    };
+  }
+
+  query(bounds: Float32Array, verifyAgainstBruteForce: boolean): SpatialQueryResult {
+    if (bounds.length < 6 || ![...bounds.slice(0, 6)].every(Number.isFinite)) {
+      throw new RangeError('spatial query requires a finite world AABB');
+    }
+    const fromStatic = this.staticOwner.query(bounds);
+    const fromDynamic = this.dynamicOwner.query(bounds);
+    const records = [...fromStatic.records, ...fromDynamic.records].sort(
+      (left, right) => left.slot - right.slot,
+    );
+    const falseNegativeSlots: number[] = [];
+    if (verifyAgainstBruteForce) {
+      this.bruteForceComparisons += 1;
+      const actual = new Set(records.map((record) => record.slot));
+      for (const reference of this.bruteForce(bounds)) {
+        if (!actual.has(reference.slot)) falseNegativeSlots.push(reference.slot);
+      }
+      this.falseNegatives += falseNegativeSlots.length;
+    }
+    this.broadphaseQueries += 1;
+    const inspection = this.inspect();
+    return {
+      hits: records.map((record) => ({
+        slot: record.slot,
+        generation: record.generation,
+        worldId: record.worldId,
+        entityKey: record.entityKey,
+        owner: record.mobility === 'static' ? 'static-bvh' : 'dynamic-loose-tree',
+        mobility: record.mobility,
+        worldAabb: record.worldAabb === undefined ? undefined : new Float32Array(record.worldAabb),
+      })),
+      staticRevision: inspection.static.revision,
+      dynamicRevision: inspection.dynamic.revision,
+      visitedNodes: fromStatic.visitedNodes + fromDynamic.visitedNodes,
+      testedEntries: fromStatic.testedEntries + fromDynamic.testedEntries,
+      falseNegativeSlots,
+    };
+  }
+
+  inspect(): SpatialIndexInspection {
+    return {
+      revision: this.revision,
+      static: this.staticOwner.inspect(),
+      dynamic: this.dynamicOwner.inspect(),
+      broadphaseQueries: this.broadphaseQueries,
+      bruteForceComparisons: this.bruteForceComparisons,
+      falseNegatives: this.falseNegatives,
+    };
+  }
+
+  private bruteForce(bounds: Float32Array): readonly SpatialRecord[] {
+    return [...this.staticOwner.snapshot(), ...this.dynamicOwner.snapshot()].filter(
+      (record) => record.worldAabb === undefined || overlapsAabb(record.worldAabb, bounds),
+    );
+  }
+}
+
+interface PendingIdentity {
+  readonly worldId: number;
+  readonly entityKey: number;
+  readonly initial: ProjectionSlot | undefined;
+  current: RenderableSnapshot | undefined;
+  removed: boolean;
+  touched: boolean;
+}
+
+const FACT_DOMAINS: readonly SceneFactRevisionDomain[] = [
+  'transform',
+  'geometry',
+  'material',
+  'eligibility',
+  'space',
+  'batch',
+  'resource',
+];
+
+const ZERO_REVISIONS: SceneFactRevisions = Object.freeze({
+  transform: 0,
+  geometry: 0,
+  material: 0,
+  eligibility: 0,
+  space: 0,
+  batch: 0,
+  resource: 0,
+});
+
+function ownSnapshot(snapshot: RenderableSnapshot): RenderableSnapshot {
+  const { temporal: _temporal, ...current } = snapshot;
+  return {
+    ...current,
+    transform: { ...snapshot.transform, world: new Float32Array(snapshot.transform.world) },
+    ...(snapshot.boundsWorld !== undefined && {
+      boundsWorld: new Float32Array(snapshot.boundsWorld),
+    }),
+    ...(snapshot.candidateInstanceTransforms !== undefined && {
+      candidateInstanceTransforms: new Float32Array(snapshot.candidateInstanceTransforms),
+    }),
+    ...(snapshot.localAabb !== undefined && { localAabb: new Float32Array(snapshot.localAabb) }),
+    ...(snapshot.instances !== undefined && {
+      instances: {
+        ...snapshot.instances,
+        transforms: new Float32Array(snapshot.instances.transforms),
+      },
+    }),
+    ...(snapshot.spriteInstances !== undefined && {
+      spriteInstances: {
+        ...snapshot.spriteInstances,
+        transforms: new Float32Array(snapshot.spriteInstances.transforms),
+        regions: new Float32Array(snapshot.spriteInstances.regions),
+      },
+    }),
+    ...(snapshot.skin !== undefined && {
+      skin: {
+        ...snapshot.skin,
+        jointMatrices: new Float32Array(snapshot.skin.jointMatrices),
+      },
+    }),
+    ...(snapshot.gpuDrivenDraws !== undefined && {
+      gpuDrivenDraws: snapshot.gpuDrivenDraws.map((draw) => ({ ...draw })),
+    }),
+    ...(snapshot.morphWeights !== undefined && {
+      morphWeights: new Float32Array(snapshot.morphWeights),
+    }),
+    materials: [...snapshot.materials],
+    materialBindingSources: [...snapshot.materialBindingSources],
+  };
+}
+
+function withWorld(snapshot: RenderableSnapshot, world: Float32Array): RenderableSnapshot {
+  return ownSnapshot({
+    ...snapshot,
+    transform: { ...snapshot.transform, world: new Float32Array(world) },
+  });
+}
+
+function sameFloatArray(left: Float32Array | undefined, right: Float32Array | undefined): boolean {
+  if (left === right) return true;
+  if (left === undefined || right === undefined || left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index += 1) {
+    if (left[index] !== right[index]) return false;
+  }
+  return true;
+}
+
+interface ComparedObjectPairs {
+  readonly leftToRight: Map<object, object>;
+  readonly rightToLeft: Map<object, object>;
+}
+
+function sameValue(
+  left: unknown,
+  right: unknown,
+  seen: ComparedObjectPairs = { leftToRight: new Map(), rightToLeft: new Map() },
+): boolean {
+  if (Object.is(left, right)) return true;
+  if (left === null || right === null || typeof left !== 'object' || typeof right !== 'object') {
+    return false;
+  }
+  const previousRight = seen.leftToRight.get(left);
+  if (previousRight !== undefined || seen.leftToRight.has(left)) return previousRight === right;
+  const previousLeft = seen.rightToLeft.get(right);
+  if (previousLeft !== undefined || seen.rightToLeft.has(right)) return previousLeft === left;
+  seen.leftToRight.set(left, right);
+  seen.rightToLeft.set(right, left);
+  if (ArrayBuffer.isView(left) && ArrayBuffer.isView(right)) {
+    if (left.byteLength !== right.byteLength) return false;
+    const leftBytes = new Uint8Array(left.buffer, left.byteOffset, left.byteLength);
+    const rightBytes = new Uint8Array(right.buffer, right.byteOffset, right.byteLength);
+    for (let index = 0; index < leftBytes.length; index += 1) {
+      if (leftBytes[index] !== rightBytes[index]) return false;
+    }
+    return true;
+  }
+  if (left instanceof Map && right instanceof Map) {
+    if (left.size !== right.size) return false;
+    for (const [key, value] of left) {
+      if (!right.has(key) || !sameValue(value, right.get(key), seen)) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length) return false;
+    return left.every((value, index) => sameValue(value, right[index], seen));
+  }
+  const leftKeys = Object.keys(left).sort();
+  const rightKeys = Object.keys(right).sort();
+  if (
+    leftKeys.length !== rightKeys.length ||
+    leftKeys.some((key, index) => key !== rightKeys[index])
+  ) {
+    return false;
+  }
+  return leftKeys.every((key) =>
+    sameValue(
+      (left as Record<string, unknown>)[key],
+      (right as Record<string, unknown>)[key],
+      seen,
+    ),
+  );
+}
+
+function validMobility(value: unknown): SceneMobility {
+  return value === 'static' || value === 'dynamic' || value === 'unknown' ? value : 'unknown';
+}
+
+function validCasterEligibility(value: unknown): SceneCasterEligibility {
+  return value === 'eligible' || value === 'ineligible' || value === 'unknown' ? value : 'unknown';
+}
+
+function localBoundsFact(snapshot: RenderableSnapshot): RenderSceneFact['bounds'] {
+  const local = snapshot.localAabb;
+  if (local === undefined) return { status: 'missing', reason: 'missing-local-aabb' };
+  const minX = local[0] ?? Number.NaN;
+  const minY = local[1] ?? Number.NaN;
+  const minZ = local[2] ?? Number.NaN;
+  const maxX = local[3] ?? Number.NaN;
+  const maxY = local[4] ?? Number.NaN;
+  const maxZ = local[5] ?? Number.NaN;
+  if (
+    local.length < 6 ||
+    ![minX, minY, minZ, maxX, maxY, maxZ].every(Number.isFinite) ||
+    minX > maxX ||
+    minY > maxY ||
+    minZ > maxZ
+  ) {
+    return { status: 'missing', reason: 'invalid-local-aabb' };
+  }
+  const world = snapshot.transform.world;
+  if (world.length < 16 || !world.slice(0, 16).every(Number.isFinite)) {
+    return { status: 'missing', reason: 'invalid-world-transform' };
+  }
+  const m00 = world[0] ?? 0;
+  const m01 = world[1] ?? 0;
+  const m02 = world[2] ?? 0;
+  const m10 = world[4] ?? 0;
+  const m11 = world[5] ?? 0;
+  const m12 = world[6] ?? 0;
+  const m20 = world[8] ?? 0;
+  const m21 = world[9] ?? 0;
+  const m22 = world[10] ?? 0;
+  const tx = world[12] ?? 0;
+  const ty = world[13] ?? 0;
+  const tz = world[14] ?? 0;
+  const minimum = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+  const maximum = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  for (const x of [minX, maxX]) {
+    for (const y of [minY, maxY]) {
+      for (const z of [minZ, maxZ]) {
+        const worldX = m00 * x + m10 * y + m20 * z + tx;
+        const worldY = m01 * x + m11 * y + m21 * z + ty;
+        const worldZ = m02 * x + m12 * y + m22 * z + tz;
+        minimum[0] = Math.min(minimum[0] as number, worldX);
+        minimum[1] = Math.min(minimum[1] as number, worldY);
+        minimum[2] = Math.min(minimum[2] as number, worldZ);
+        maximum[0] = Math.max(maximum[0] as number, worldX);
+        maximum[1] = Math.max(maximum[1] as number, worldY);
+        maximum[2] = Math.max(maximum[2] as number, worldZ);
+      }
+    }
+  }
+  return {
+    status: 'present',
+    localAabb: new Float32Array([minX, minY, minZ, maxX, maxY, maxZ]),
+    worldAabb: new Float32Array([
+      minimum[0] as number,
+      minimum[1] as number,
+      minimum[2] as number,
+      maximum[0] as number,
+      maximum[1] as number,
+      maximum[2] as number,
+    ]),
+  };
+}
+
+function sameMaterials(left: RenderableSnapshot, right: RenderableSnapshot): boolean {
+  return sameValue(left.materials, right.materials) && sameValue(left.material, right.material);
+}
+
+function diagnosticForBounds(
+  snapshot: RenderableSnapshot,
+  slot: number,
+  generation: number,
+  bounds: RenderSceneFact['bounds'],
+): SceneFactDiagnostic | undefined {
+  if (bounds.status === 'present') return undefined;
+  return {
+    code: 'missing-bounds',
+    slot,
+    generation,
+    worldId: snapshot.worldId,
+    entityKey: snapshot.entityKey,
+    reason: bounds.reason,
+  };
+}
+
+function normalizeRevision(
+  value: number | undefined,
+  previous: number,
+  domain: SceneFactRevisionDomain,
+  snapshot: RenderableSnapshot,
+  slot: number,
+  generation: number,
+  diagnostics: SceneFactDiagnostic[],
+): number {
+  if (value === undefined) return previous;
+  if (!Number.isInteger(value) || value < 0 || value < previous) {
+    diagnostics.push({
+      code: 'invalid-revision',
+      slot,
+      generation,
+      worldId: snapshot.worldId,
+      entityKey: snapshot.entityKey,
+      domain,
+      reason: value < previous ? 'non-monotonic' : 'expected-non-negative-integer',
+    });
+    return previous;
+  }
+  return value;
+}
+
+function factFor(
+  snapshot: RenderableSnapshot,
+  slot: number,
+  generation: number,
+  previous: RenderSceneFact | undefined,
+  changedDomains: ReadonlySet<SceneFactRevisionDomain>,
+  diagnostics: SceneFactDiagnostic[],
+  emitBoundsDiagnostic: boolean,
+): RenderSceneFact {
+  const bounds = localBoundsFact(snapshot);
+  if (emitBoundsDiagnostic) {
+    const boundsDiagnostic = diagnosticForBounds(snapshot, slot, generation, bounds);
+    if (boundsDiagnostic !== undefined) diagnostics.push(boundsDiagnostic);
+  }
+  const input: RenderSceneFactInput | undefined = snapshot.sceneFact;
+  const previousRevisions = previous?.revisions ?? ZERO_REVISIONS;
+  const revisions = Object.fromEntries(
+    FACT_DOMAINS.map((domain) => {
+      const explicit = input?.revisions?.[domain];
+      let value = normalizeRevision(
+        explicit,
+        previousRevisions[domain],
+        domain,
+        snapshot,
+        slot,
+        generation,
+        diagnostics,
+      );
+      if (explicit === undefined && changedDomains.has(domain)) value += 1;
+      if (
+        explicit !== undefined &&
+        changedDomains.has(domain) &&
+        value === previousRevisions[domain]
+      ) {
+        value += 1;
+      }
+      return [domain, value];
+    }),
+  ) as unknown as SceneFactRevisions;
+  return {
+    slot,
+    generation,
+    worldId: snapshot.worldId,
+    entityKey: snapshot.entityKey,
+    bounds,
+    mobility: validMobility(input?.mobility),
+    casterEligibility:
+      bounds.status === 'present' ? validCasterEligibility(input?.casterEligibility) : 'unknown',
+    revisions,
+  };
+}
+
+function changedFactDomains(
+  previous: RenderSceneProjectionSlot,
+  next: RenderableSnapshot,
+): Set<SceneFactRevisionDomain> {
+  const changed = new Set<SceneFactRevisionDomain>();
+  if (!sameFloatArray(previous.snapshot.transform.world, next.transform.world)) {
+    changed.add('transform');
+    changed.add('space');
+  }
+  if (
+    previous.snapshot.assetHandle !== next.assetHandle ||
+    !sameFloatArray(previous.snapshot.localAabb, next.localAabb)
+  ) {
+    changed.add('geometry');
+    changed.add('space');
+  }
+  if (
+    !sameFloatArray(
+      previous.snapshot.candidateInstanceTransforms,
+      next.candidateInstanceTransforms,
+    ) ||
+    !sameFloatArray(previous.snapshot.boundsWorld, next.boundsWorld) ||
+    !sameValue(previous.snapshot.instances, next.instances) ||
+    !sameValue(previous.snapshot.spriteInstances, next.spriteInstances)
+  ) {
+    changed.add('space');
+  }
+  if (!sameValue(previous.snapshot.gpuDrivenDraws, next.gpuDrivenDraws)) {
+    changed.add('geometry');
+    changed.add('batch');
+  }
+  if (!sameMaterials(previous.snapshot, next)) {
+    changed.add('material');
+    changed.add('resource');
+    changed.add('batch');
+  }
+  if (
+    !sameValue(previous.snapshot.materialBindingSources, next.materialBindingSources) ||
+    !sameValue(previous.snapshot.materialBindingDiagnostics, next.materialBindingDiagnostics)
+  ) {
+    changed.add('resource');
+  }
+  const previousInput = previous.snapshot.sceneFact;
+  const nextInput = next.sceneFact;
+  if (validMobility(previousInput?.mobility) !== validMobility(nextInput?.mobility)) {
+    changed.add('space');
+    changed.add('eligibility');
+  }
+  if (
+    validCasterEligibility(previousInput?.casterEligibility) !==
+    validCasterEligibility(nextInput?.casterEligibility)
+  ) {
+    changed.add('eligibility');
+  }
+  for (const domain of FACT_DOMAINS) {
+    const nextRevision = nextInput?.revisions?.[domain];
+    if (nextRevision !== undefined && nextRevision !== previous.fact.revisions[domain]) {
+      changed.add(domain);
+    }
+  }
+  return changed;
+}
+
+function temporalProducerChanged(previous: RenderableSnapshot, next: RenderableSnapshot): boolean {
+  return (
+    !sameValue(previous.skin?.jointMatrices, next.skin?.jointMatrices) ||
+    !sameFloatArray(previous.morphWeights, next.morphWeights)
+  );
+}
+
+/**
+ * Renderer-owned persistent CPU scene projection.
+ *
+ * Operations are coalesced per `(worldId, entityKey)` before stable slots are
+ * touched. Slots carry generations so downstream GPU residency can reject
+ * stale work after removal and reuse. Each slot also owns the Scene Fact used
+ * by later spatial, visibility, batch, and upload owners.
+ */
+export class RenderSceneProjection {
+  private readonly slots: Array<ProjectionSlot | undefined> = [];
+  private readonly lastSubmittedSlots: Array<ProjectionSlot | undefined> = [];
+  private readonly generations: number[] = [];
+  private readonly freeSlots: number[] = [];
+  private readonly slotsByWorld = new Map<number, Map<number, number>>();
+  private readonly slotsByMaterial = new Map<number, Set<number>>();
+  private materialized: readonly RenderableSnapshot[] | undefined;
+  private slotSnapshot: readonly RenderSceneProjectionSlot[] | undefined;
+  private factDiagnostics: readonly SceneFactDiagnostic[] = [];
+  private readonly spatialIndex = new RenderSceneSpatialIndex();
+  private readonly dirtySinceSubmitted = new Set<number>();
+  private lastSubmittedVisible = new Set<string>();
+  private revision = 0;
+  private submittedEpoch = 0;
+
+  apply(operations: readonly RenderSceneOperation[]): RenderSceneApplyResult {
+    const pendingByWorld = new Map<number, Map<number, PendingIdentity>>();
+    const pendingOrder: PendingIdentity[] = [];
+    const diagnostics: SceneFactDiagnostic[] = [];
+    let ignoredLateUpdates = 0;
+
+    const pendingFor = (worldId: number, entityKey: number): PendingIdentity => {
+      let entities = pendingByWorld.get(worldId);
+      if (entities === undefined) {
+        entities = new Map<number, PendingIdentity>();
+        pendingByWorld.set(worldId, entities);
+      }
+      let pending = entities.get(entityKey);
+      if (pending !== undefined) return pending;
+      const initial = this.lookup(worldId, entityKey);
+      pending = {
+        worldId,
+        entityKey,
+        initial,
+        current: initial?.snapshot,
+        removed: false,
+        touched: false,
+      };
+      entities.set(entityKey, pending);
+      pendingOrder.push(pending);
+      return pending;
+    };
+
+    const acceptsGeneration = (
+      operation: RenderSceneOperation,
+      pending: PendingIdentity,
+    ): boolean => {
+      if (operation.expectedGeneration === undefined) return true;
+      const actualGeneration = pending.initial?.generation;
+      if (actualGeneration === operation.expectedGeneration) return true;
+      const diagnostic = {
+        code: 'stale-generation',
+        worldId: operation.kind === 'create' ? operation.snapshot.worldId : operation.worldId,
+        entityKey: operation.kind === 'create' ? operation.snapshot.entityKey : operation.entityKey,
+        expectedGeneration: operation.expectedGeneration,
+        reason: 'operation-generation-does-not-match-live-slot',
+        ...(actualGeneration === undefined ? {} : { actualGeneration }),
+        ...(pending.initial === undefined
+          ? {}
+          : { slot: pending.initial.slot, generation: pending.initial.generation }),
+      } satisfies SceneFactDiagnostic;
+      diagnostics.push(diagnostic);
+      return false;
+    };
+
+    for (const operation of operations) {
+      if (operation.kind === 'create') {
+        const { worldId, entityKey } = operation.snapshot;
+        const pending = pendingFor(worldId, entityKey);
+        if (!acceptsGeneration(operation, pending)) continue;
+        pending.current = ownSnapshot(operation.snapshot);
+        pending.touched = true;
+        continue;
+      }
+      const pending = pendingFor(operation.worldId, operation.entityKey);
+      if (!acceptsGeneration(operation, pending)) {
+        if (operation.kind === 'update-transform') ignoredLateUpdates += 1;
+        continue;
+      }
+      if (operation.kind === 'remove') {
+        pending.current = undefined;
+        pending.removed = true;
+        pending.touched = true;
+        continue;
+      }
+      if (pending.current === undefined) {
+        ignoredLateUpdates += 1;
+        continue;
+      }
+      pending.touched = true;
+      pending.current = withWorld(pending.current, operation.world);
+    }
+
+    let created = 0;
+    let updated = 0;
+    let removed = 0;
+    let recreated = 0;
+    const createdSlots: RenderSceneProjectionSlot[] = [];
+    const updatedSlots: RenderSceneProjectionSlot[] = [];
+    const removedSlots: RenderSceneProjectionRecord[] = [];
+    const recreatedSlots: RenderSceneProjectionSlot[] = [];
+    const factDeltas: RenderSceneFactDelta[] = [];
+    for (const pending of pendingOrder) {
+      if (!pending.touched) continue;
+      if (pending.initial === undefined) {
+        if (pending.current === undefined) continue;
+        const createdSlot = this.allocate(pending.current, diagnostics);
+        createdSlots.push(createdSlot);
+        factDeltas.push({
+          slot: createdSlot.slot,
+          generation: createdSlot.generation,
+          changedDomains: FACT_DOMAINS,
+          previous: undefined,
+          current: createdSlot.fact,
+        });
+        this.dirtySinceSubmitted.add(createdSlot.slot);
+        created += 1;
+        continue;
+      }
+      if (pending.current === undefined) {
+        this.release(pending.initial);
+        this.dirtySinceSubmitted.add(pending.initial.slot);
+        removedSlots.push(pending.initial);
+        removed += 1;
+        continue;
+      }
+      if (pending.removed) {
+        this.release(pending.initial);
+        const recreatedSlot = this.allocate(pending.current, diagnostics);
+        recreatedSlots.push(recreatedSlot);
+        factDeltas.push({
+          slot: recreatedSlot.slot,
+          generation: recreatedSlot.generation,
+          changedDomains: FACT_DOMAINS,
+          previous: pending.initial.fact,
+          current: recreatedSlot.fact,
+        });
+        this.dirtySinceSubmitted.add(recreatedSlot.slot);
+        recreated += 1;
+        continue;
+      }
+      const domains = changedFactDomains(pending.initial, pending.current);
+      const currentFact = factFor(
+        pending.current,
+        pending.initial.slot,
+        pending.initial.generation,
+        pending.initial.fact,
+        domains,
+        diagnostics,
+        domains.size > 0,
+      );
+      const updatedSlot: ProjectionSlot = {
+        ...pending.initial,
+        snapshot: pending.current,
+        fact: currentFact,
+      };
+      this.unindexMaterials(pending.initial);
+      this.slots[pending.initial.slot] = updatedSlot;
+      this.indexMaterials(updatedSlot);
+      updatedSlots.push(updatedSlot);
+      if (domains.size > 0) {
+        factDeltas.push({
+          slot: updatedSlot.slot,
+          generation: updatedSlot.generation,
+          changedDomains: FACT_DOMAINS.filter((domain) => domains.has(domain)),
+          previous: pending.initial.fact,
+          current: currentFact,
+        });
+      }
+      if (domains.size > 0 || temporalProducerChanged(pending.initial.snapshot, pending.current)) {
+        this.dirtySinceSubmitted.add(updatedSlot.slot);
+      }
+      updated += 1;
+    }
+
+    this.factDiagnostics = diagnostics;
+    const changed = created + updated + removed + recreated > 0;
+    const result: RenderSceneApplyResult = {
+      created,
+      updated,
+      removed,
+      recreated,
+      ignoredLateUpdates,
+      createdSlots,
+      updatedSlots,
+      removedSlots,
+      recreatedSlots,
+      factDeltas,
+      diagnostics,
+    };
+    if (!changed) return result;
+    this.revision += 1;
+    this.invalidateSnapshots();
+    return {
+      ...result,
+      spatialIndex: this.spatialIndex.patch(
+        [...createdSlots, ...updatedSlots, ...recreatedSlots],
+        removedSlots,
+      ),
+    };
+  }
+
+  materialize(): readonly RenderableSnapshot[] {
+    if (this.materialized !== undefined) return this.materialized;
+    const snapshots: RenderableSnapshot[] = [];
+    for (const slot of this.slots) {
+      if (slot !== undefined) snapshots.push(slot.snapshot);
+    }
+    this.materialized = Object.freeze(snapshots);
+    return this.materialized;
+  }
+
+  slotsSnapshot(): readonly RenderSceneProjectionSlot[] {
+    if (this.slotSnapshot !== undefined) return this.slotSnapshot;
+    const records: RenderSceneProjectionSlot[] = [];
+    for (const slot of this.slots) {
+      if (slot !== undefined) records.push(slot);
+    }
+    this.slotSnapshot = Object.freeze(records);
+    return this.slotSnapshot;
+  }
+
+  lastSubmittedSlotByIndex(slot: number): RenderSceneProjectionSlot | undefined {
+    return this.lastSubmittedSlots[slot];
+  }
+
+  temporalSnapshotBySlot(slot: number): RenderableTemporalSnapshot | undefined {
+    const current = this.slots[slot];
+    return current === undefined ? undefined : this.temporalSnapshot(current);
+  }
+
+  withTemporal(snapshot: RenderableSnapshot): RenderableSnapshot {
+    const slot = this.lookup(snapshot.worldId, snapshot.entityKey);
+    return slot === undefined ? snapshot : { ...snapshot, temporal: this.temporalSnapshot(slot) };
+  }
+
+  wasLastSubmittedVisible(slot: number, generation: number): boolean {
+    return this.lastSubmittedVisible.has(submittedIdentity(slot, generation));
+  }
+
+  captureSubmission(
+    visible: readonly Pick<RenderableSnapshot, 'worldId' | 'entityKey'>[],
+  ): RenderSceneSubmissionCapture {
+    const visibleSlots = new Set<string>();
+    for (const snapshot of visible) {
+      const slot = this.lookup(snapshot.worldId, snapshot.entityKey);
+      if (slot !== undefined) visibleSlots.add(submittedIdentity(slot.slot, slot.generation));
+    }
+    return {
+      revision: this.revision,
+      slots: [...this.dirtySinceSubmitted].map((slot) => ({ slot, current: this.slots[slot] })),
+      visible: visibleSlots,
+    };
+  }
+
+  commitSubmission(capture: RenderSceneSubmissionCapture): RenderSceneSubmissionDelta {
+    if (capture.revision !== this.revision) {
+      throw new RangeError('render scene changed while its temporal submission was active');
+    }
+    for (const update of capture.slots) {
+      this.lastSubmittedSlots[update.slot] = update.current;
+      this.dirtySinceSubmitted.delete(update.slot);
+    }
+    this.lastSubmittedVisible = new Set(capture.visible);
+    this.submittedEpoch += 1;
+    this.invalidateSnapshots();
+    return {
+      epoch: this.submittedEpoch,
+      slots: capture.slots.map((update) => update.slot),
+    };
+  }
+
+  /** O(1) stable-slot lookup for delta owners; avoids rescanning slotsSnapshot. */
+  slotByIndex(slot: number): RenderSceneProjectionSlot | undefined {
+    return this.slots[slot];
+  }
+
+  has(worldId: number, entityKey: number): boolean {
+    return this.lookup(worldId, entityKey) !== undefined;
+  }
+
+  record(worldId: number, entityKey: number): RenderSceneProjectionRecord | undefined {
+    const slot = this.lookup(worldId, entityKey);
+    if (slot === undefined) return undefined;
+    return { slot: slot.slot, generation: slot.generation, worldId, entityKey };
+  }
+
+  snapshot(worldId: number, entityKey: number): RenderableSnapshot | undefined {
+    return this.lookup(worldId, entityKey)?.snapshot;
+  }
+
+  slotsForMaterial(materialHandle: number): readonly RenderSceneProjectionSlot[] {
+    const slots = this.slotsByMaterial.get(materialHandle);
+    if (slots === undefined) return [];
+    const records: RenderSceneProjectionSlot[] = [];
+    for (const slot of slots) {
+      const record = this.slots[slot];
+      if (record !== undefined) records.push(record);
+    }
+    return records;
+  }
+
+  querySpatialIndex(
+    worldAabb: Float32Array,
+    options: { readonly verifyAgainstBruteForce?: boolean } = {},
+  ): SpatialQueryResult {
+    return this.spatialIndex.query(worldAabb, options.verifyAgainstBruteForce === true);
+  }
+
+  replaceCurrent(snapshots: readonly RenderableSnapshot[]): RenderSceneApplyResult {
+    const incoming = new Set(
+      snapshots.map((snapshot) => `${snapshot.worldId}:${snapshot.entityKey}`),
+    );
+    const operations: RenderSceneOperation[] = [];
+    for (const slot of this.slots) {
+      if (slot === undefined || incoming.has(`${slot.worldId}:${slot.entityKey}`)) continue;
+      operations.push({
+        kind: 'remove',
+        worldId: slot.worldId,
+        entityKey: slot.entityKey,
+        expectedGeneration: slot.generation,
+      });
+    }
+    for (const snapshot of snapshots) {
+      const live = this.lookup(snapshot.worldId, snapshot.entityKey);
+      operations.push({
+        kind: 'create',
+        snapshot,
+        ...(live === undefined ? {} : { expectedGeneration: live.generation }),
+      });
+    }
+    return this.apply(operations);
+  }
+
+  reset(snapshots: readonly RenderableSnapshot[]): void {
+    this.slots.length = 0;
+    this.generations.length = 0;
+    this.freeSlots.length = 0;
+    this.slotsByWorld.clear();
+    this.slotsByMaterial.clear();
+    this.lastSubmittedSlots.length = 0;
+    this.lastSubmittedVisible.clear();
+    this.dirtySinceSubmitted.clear();
+    this.submittedEpoch = 0;
+    const diagnostics: SceneFactDiagnostic[] = [];
+    for (const snapshot of snapshots) this.allocate(ownSnapshot(snapshot), diagnostics);
+    for (const slot of this.slots) {
+      if (slot !== undefined) this.dirtySinceSubmitted.add(slot.slot);
+    }
+    this.factDiagnostics = diagnostics;
+    this.invalidateSnapshots();
+    this.spatialIndex.replace(this.slotsSnapshot());
+    this.revision += 1;
+  }
+
+  inspect(): RenderSceneProjectionInspection {
+    const current: RenderSceneProjectionRecord[] = [];
+    const lastSubmitted: RenderSceneProjectionRecord[] = [];
+    for (const slot of this.slots) {
+      if (slot === undefined) continue;
+      current.push({
+        slot: slot.slot,
+        generation: slot.generation,
+        worldId: slot.worldId,
+        entityKey: slot.entityKey,
+      });
+    }
+    for (const slot of this.lastSubmittedSlots) {
+      if (slot === undefined) continue;
+      lastSubmitted.push({
+        slot: slot.slot,
+        generation: slot.generation,
+        worldId: slot.worldId,
+        entityKey: slot.entityKey,
+      });
+    }
+    return {
+      current,
+      lastSubmitted: { epoch: this.submittedEpoch, records: lastSubmitted },
+      slotCapacity: this.slots.length,
+      freeSlots: this.freeSlots.length,
+      factDiagnostics: this.factDiagnostics,
+      spatialIndex: this.spatialIndex.inspect(),
+    };
+  }
+
+  private lookup(worldId: number, entityKey: number): ProjectionSlot | undefined {
+    const slot = this.slotsByWorld.get(worldId)?.get(entityKey);
+    return slot === undefined ? undefined : this.slots[slot];
+  }
+
+  private temporalSnapshot(slot: ProjectionSlot): RenderableTemporalSnapshot {
+    const submitted = this.lastSubmittedSlots[slot.slot];
+    const sameGeneration = submitted?.generation === slot.generation;
+    const wasVisible =
+      sameGeneration &&
+      this.lastSubmittedVisible.has(submittedIdentity(slot.slot, slot.generation));
+    const changed =
+      sameGeneration && submitted !== undefined
+        ? changedFactDomains(submitted, slot.snapshot)
+        : new Set<SceneFactRevisionDomain>();
+    const reasons: RenderableReactiveReason[] = [];
+    if (!sameGeneration) {
+      reasons.push(submitted === undefined ? 'new-slot' : 'generation-reuse');
+    } else if (!wasVisible) {
+      reasons.push('reentered');
+    }
+    if (changed.has('geometry')) reasons.push('geometry-revision');
+    if (changed.has('material') || changed.has('resource')) reasons.push('material-revision');
+    const exactSkin =
+      slot.snapshot.skin === undefined ||
+      (sameGeneration &&
+        submitted?.snapshot.skin !== undefined &&
+        submitted.snapshot.skin.jointCount === slot.snapshot.skin.jointCount &&
+        submitted.snapshot.skin.jointMatrices.length === slot.snapshot.skin.jointMatrices.length);
+    const exactMorph =
+      slot.snapshot.morphWeights === undefined ||
+      (sameGeneration &&
+        submitted?.snapshot.morphWeights !== undefined &&
+        submitted.snapshot.morphWeights.length === slot.snapshot.morphWeights.length);
+    if (!exactSkin) reasons.push('skinning-deformation');
+    if (!exactMorph) reasons.push('morph-deformation');
+    const seedCurrent =
+      !sameGeneration ||
+      !wasVisible ||
+      changed.has('geometry') ||
+      changed.has('material') ||
+      changed.has('resource') ||
+      !exactSkin ||
+      !exactMorph;
+    const previous = seedCurrent || submitted === undefined ? slot.snapshot : submitted.snapshot;
+    return {
+      previousEpoch: seedCurrent ? undefined : this.submittedEpoch,
+      previousSource: seedCurrent ? 'current-seed' : 'last-submitted',
+      reactive: reasons.length > 0,
+      reactiveReasons: reasons,
+      previousTransform: previous.transform,
+      previousInstances: previous.instances,
+      previousSkin: previous.skin,
+      previousMorphWeights: previous.morphWeights,
+    };
+  }
+
+  private allocate(
+    snapshot: RenderableSnapshot,
+    diagnostics: SceneFactDiagnostic[],
+  ): ProjectionSlot {
+    const reused = this.freeSlots.pop();
+    const slot = reused ?? this.slots.length;
+    const generation = reused === undefined ? 0 : (this.generations[slot] ?? -1) + 1;
+    const fact = factFor(snapshot, slot, generation, undefined, new Set(), diagnostics, true);
+    const record: ProjectionSlot = {
+      slot,
+      generation,
+      worldId: snapshot.worldId,
+      entityKey: snapshot.entityKey,
+      snapshot,
+      fact,
+    };
+    this.generations[slot] = generation;
+    this.slots[slot] = record;
+    let entities = this.slotsByWorld.get(snapshot.worldId);
+    if (entities === undefined) {
+      entities = new Map<number, number>();
+      this.slotsByWorld.set(snapshot.worldId, entities);
+    }
+    entities.set(snapshot.entityKey, slot);
+    this.indexMaterials(record);
+    return record;
+  }
+
+  private release(record: ProjectionSlot): void {
+    this.slots[record.slot] = undefined;
+    this.unindexMaterials(record);
+    const entities = this.slotsByWorld.get(record.worldId);
+    entities?.delete(record.entityKey);
+    if (entities?.size === 0) this.slotsByWorld.delete(record.worldId);
+    this.freeSlots.push(record.slot);
+  }
+
+  private indexMaterials(record: ProjectionSlot): void {
+    for (const material of record.snapshot.materials) {
+      const handle = material.materialHandle ?? 0;
+      let slots = this.slotsByMaterial.get(handle);
+      if (slots === undefined) {
+        slots = new Set();
+        this.slotsByMaterial.set(handle, slots);
+      }
+      slots.add(record.slot);
+    }
+  }
+
+  private unindexMaterials(record: ProjectionSlot): void {
+    for (const material of record.snapshot.materials) {
+      const handle = material.materialHandle ?? 0;
+      const slots = this.slotsByMaterial.get(handle);
+      slots?.delete(record.slot);
+      if (slots?.size === 0) this.slotsByMaterial.delete(handle);
+    }
+  }
+
+  private invalidateSnapshots(): void {
+    this.materialized = undefined;
+    this.slotSnapshot = undefined;
+  }
+}