@forgeax/engine-render 0.1.4 → 0.1.6

package/src/render-scene-projection.ts

@@ -1,1738 +0,0 @@
-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;
-  }
-}