@ifc-lite/renderer 3.2.0 → 5.0.0

package/dist/scene.js

@@ -4,6 +4,7 @@
 import { materializeInstances } from './scene-instance-materialization.js';
 import { InstanceSuppression } from './scene-instance-suppression.js';
 import { createSceneBatch } from './scene-batch-upload.js';
+import { createStaticGpuBuffer } from './gpu-static-upload.js';
 import { createSceneAppearancePreview, rebindSceneAppearanceAccess } from './scene-appearance-preview.js';
 import { AppearanceBuckets } from './scene-appearance-buckets.js';
 import { AuthoredPreparationRegistry, prepareSceneAuthoredOwner } from './scene-authored-owner.js';
@@ -27,10 +28,13 @@ import { selectEvictions } from './residency.js';
 import { OPAQUE_ALPHA_CUTOFF } from './overlay-routing.js';
 import { translateSceneModel, rotateSceneModelInstances, releaseInstanceVertices, refreshTexturedBounds } from './scene-model-translation.js';
 import { ModelTranslations } from './model-translation.js';
+import { unionInstancedWorldAabb as unionInstanceBounds } from './scene-instance-bounds.js';
 import { DerivedMeshProvenance } from './scene-derived-mesh-provenance.js';
 import { rebuildSceneBatches } from './scene-batch-rebuild.js';
+import { regroupStreamedBuckets } from './scene-finalize-regroup.js';
 import { dropAllPartialCaches as dropAllPartialCachesIn, dropPartialCacheForBatch as dropPartialCacheForBatchIn, retireUnusedAlphaSlots as retireUnusedAlphaSlotsIn, } from './partial-batch-cache.js';
 import { prepareInstancedRender, foldOccurrenceWorldBox, INSTANCE_STRIDE_BYTES, INSTANCE_COLOR_OFFSET, INSTANCE_FLAGS_OFFSET, INSTANCE_FLAG_SELECTED, INSTANCE_FLAG_HIDDEN, } from './instanced-render.js';
+import { translateInstanceRecord } from './scene-instance-translation.js';
 import { discardSceneGpuResourcesForRecovery, prepareSceneDeviceRecovery, repartitionHydratedRecoveryBucket, restoreSceneGpuResourcesAfterRecovery } from './scene-device-recovery.js';
 const EMPTY_INSTANCED_TEMPLATES = [];
 /**
@@ -300,6 +304,9 @@ export class Scene {
     // Temporary fragment batches created during streaming for immediate rendering.
     // Destroyed and replaced by proper merged batches in finalizeStreaming().
     streamingFragments = [];
+    // Buckets that received streamed meshes since the last finalize — the only
+    // ones a finalize re-groups and rebuilds (#5358).
+    streamedBucketKeys = new Set();
     // ─── Mesh command queue ────────────────────────────────────────────
     // Decouples React state updates from GPU work.  Callers push meshes
     // via queueMeshes() (instant, no GPU), and the animation loop drains
@@ -1084,7 +1091,7 @@ export class Scene {
      * STREAMING OPTIMIZATION: During streaming, creates lightweight "fragment"
      * batches from ONLY the new meshes instead of re-merging all accumulated
      * data. This reduces streaming from O(N²) to O(N). Call finalizeStreaming()
-     * when streaming completes to do one O(N) full merge.
+     * when streaming completes to merge the streamed buckets (only those, #5358).
      */
     appendToBatches(meshDataArray, device, pipeline, isStreaming = false) {
         meshDataArray = meshDataArray.map((mesh) => this.modelTranslations.placeMesh(mesh));
@@ -1146,16 +1153,17 @@ export class Scene {
                 this.meshDataBucket.set(meshData, bucket);
                 // Also store individual mesh data for visibility filtering
                 this.addMeshData(meshData);
-                // Track pending keys for non-streaming rebuild only
-                if (!isStreaming) {
+                // Non-streaming rebuilds now; streamed buckets wait for finalize.
+                if (isStreaming)
+                    this.streamedBucketKeys.add(bucketKey);
+                else
                     this.pendingBatchKeys.add(bucketKey);
-                }
             }
         }
         if (isStreaming) {
             // STREAMING: Create small fragment batches from ONLY the new meshes.
             // Avoids the O(N²) cost of re-merging all accumulated data every batch.
-            // finalizeStreaming() destroys fragments and does one O(N) full merge.
+            // finalizeStreaming() destroys fragments and merges the streamed buckets.
             // `renderable` excludes textured meshes (drawn via the textured pipeline).
             this.createStreamingFragments(renderable, device, pipeline);
             return;
@@ -1504,22 +1512,17 @@ export class Scene {
             const cpu = this.instancedTemplateCpu[occ.templateIndex];
             if (!cpu)
                 continue;
-            // Column-major mat4: the translation column is floats 12,13,14, i.e. bytes
-            // +48/+52/+56 of the occurrence's record (matches unionInstancedWorldAabb).
-            const dv = new DataView(cpu.instanceData);
             const b = occ.byteOffset;
-            const tx = dv.getFloat32(b + 48, true) + dx;
-            const ty = dv.getFloat32(b + 52, true) + dy;
-            const tz = dv.getFloat32(b + 56, true) + dz;
-            dv.setFloat32(b + 48, tx, true);
-            dv.setFloat32(b + 52, ty, true);
-            dv.setFloat32(b + 56, tz, true);
+            const translated = translateInstanceRecord(cpu, b, [dx, dy, dz]);
             // Push only the 12 translation bytes to the GPU buffer (in place). Guarded
             // on the cached device so CPU-only tests still exercise the matrix math.
             if (device) {
                 const gpu = this.instancedTemplates[occ.templateIndex]?.instanceBuffer;
-                if (gpu)
-                    device.queue.writeBuffer(gpu, b + 48, new Float32Array([tx, ty, tz]));
+                if (gpu) {
+                    device.queue.writeBuffer(gpu, b + 48, translated.translation);
+                    if (translated.legacyAnchors)
+                        device.queue.writeBuffer(gpu, b + 88, translated.legacyAnchors);
+                }
             }
             moved = true;
         }
@@ -1773,7 +1776,7 @@ export class Scene {
         // yielding the frame back at the TOP of the loop. The mesh-count-only chunker
         // could merge a 512-mesh chunk of high-poly meshes (e.g. 899 Velux roof
         // windows at 7624 tris each → ~3.9M tris) in ONE indivisible mergeGeometry +
-        // mappedAtCreation buffer copy — hundreds of ms that parked the main thread
+        // GPU buffer upload copy — hundreds of ms that parked the main thread
         // past the 16s stream watchdog. Capping each appendToBatches by index volume
         // keeps every synchronous slice ≈ one bounded fragment merge (~12-15ms).
         const MAX_MESHES_PER_FLUSH = 4096;
@@ -1863,15 +1866,14 @@ export class Scene {
         return splitMeshForStreaming(meshData, Scene.STREAMING_FRAGMENT_MAX_INDICES, Scene.STREAMING_FRAGMENT_MAX_VERTEX_BYTES);
     }
     /**
-     * Finalize streaming: destroy temporary fragment batches and do one full
-     * O(N) merge of all accumulated mesh data into proper batches.
+     * Finalize streaming: destroy the temporary fragment batches and merge the
+     * meshes streamed since the last finalize into proper batches.
      * Call this when streaming completes instead of rebuildPendingBatches().
      *
-     * IMPORTANT: During streaming, external code (applyColorUpdatesToMeshes)
-     * may mutate meshData.color in-place for deferred style/material colors.
-     * This means the bucket keys (computed at insertion time from the ORIGINAL
-     * color) no longer match the meshes' current colors. We must re-group all
-     * meshData by their CURRENT color to produce correct batches.
+     * Only the buckets that received streamed meshes are re-grouped and rebuilt
+     * (plus any key already pending); every other model's batches stay as they
+     * are (#5358). See `regroupStreamedBuckets` for why the streamed meshes are
+     * re-grouped by their CURRENT colour.
      */
     finalizeStreaming(device, pipeline) {
         if (this.streamingFragments.length === 0)
@@ -1884,6 +1886,27 @@ export class Scene {
             this.finalizeInProgress = false;
         }
     }
+    regroupStreamed() {
+        return regroupStreamedBuckets({
+            buckets: this.buckets,
+            meshDataBucket: this.meshDataBucket,
+            activeBucketKey: this.activeBucketKey,
+            coldBuckets: this.coldBuckets,
+            pendingBatchKeys: this.pendingBatchKeys,
+            streamedBucketKeys: this.streamedBucketKeys,
+            bucketBaseKey: (md) => this.bucketBaseKey(md),
+            resolveActiveBucket: (base, md) => this.resolveActiveBucket(base, md),
+            createBucket: (key) => ({ key, meshData: [], batchedMesh: null, vertexBytes: 0 }),
+        });
+    }
+    /** Free batches the finalize swap replaced, with their per-batch caches. */
+    retireFinalizedBatches(batches) {
+        for (const batch of batches) {
+            this.dropPartialCacheForBatch(batch);
+            this.lastDrawnFrame.delete(batch.id);
+            destroyGpuResources(batch);
+        }
+    }
     finalizeStreamingInner(device, pipeline) {
         // Save references to old fragments/batches — keep them rendering
         // until the new proper batches are fully built (no visual gap).
@@ -1891,103 +1914,47 @@ export class Scene {
         const oldBatches = this.batchedMeshes;
         const fragmentSet = new Set(oldFragments);
         const oldBatchSet = new Set(oldBatches);
-        // Steps 1-4 detach the old drawables (streamingFragments = [],
-        // batchedMeshes = []) BEFORE the replacement GPU buffers exist. If a
-        // createBuffer fails part-way through, callers that CONTAIN the throw to
-        // keep the canvas alive would otherwise be left rendering a half-built —
-        // often empty — scene, turning a crash into a silently blank model.
+        // The re-group detaches the streamed buckets BEFORE the replacement GPU
+        // buffers exist. If a createBuffer fails part-way through, callers that
+        // CONTAIN the throw to keep the canvas alive would otherwise be left
+        // rendering a half-built scene, turning a crash into a silently blank model.
+        let regroup = null;
         let rebuilt = false;
         try {
             this.streamingFragments = [];
-            // 1. Collect ALL accumulated meshData before clearing state.
-            //    Cold buckets (issue #1682 phase 3b) hold NO meshData — their
-            //    geometry lives on disk — so they are carried through the rebuild as
-            //    sealed shells instead of being re-grouped (re-grouping would
-            //    silently drop them).
-            const allMeshData = [];
-            const carriedCold = [];
-            for (const [key, bucket] of this.buckets) {
-                if (this.coldBuckets.has(key) && bucket.meshData.length === 0 && bucket.batchedMesh) {
-                    carriedCold.push([key, bucket]);
-                    continue;
-                }
-                for (const md of bucket.meshData)
-                    allMeshData.push(md);
-            }
-            // 2. Clear all bucket/batch state for a clean rebuild
-            // NOTE: batchedMeshes keeps the OLD array reference — the renderer
-            // continues to draw from it until we swap in the new array below.
-            this.buckets.clear();
-            this.meshDataBucket = new Map();
-            this.activeBucketKey.clear();
-            this.lastDrawnFrame.clear();
-            this.residencyRestoreQueue.clear();
-            this.pendingBatchKeys.clear();
-            // Re-seat the carried cold shells in the fresh bucket map (their GPU
-            // shells re-enter the flat array via rebuildPendingBatches below).
-            for (const [key, bucket] of carriedCold)
-                this.buckets.set(key, bucket);
-            // 3. Re-group ALL meshData by their CURRENT color (and grid cell).
-            //    meshData.color may have been mutated in-place since the mesh was
-            //    first bucketed, so the original bucket key is stale. Re-grouping
-            //    by current color ensures batches render with correct colors.
-            for (const meshData of allMeshData) {
-                const baseKey = this.bucketBaseKey(meshData);
-                const bucketKey = this.resolveActiveBucket(baseKey, meshData);
-                let bucket = this.buckets.get(bucketKey);
-                if (!bucket) {
-                    bucket = { key: bucketKey, meshData: [], batchedMesh: null, vertexBytes: 0 };
-                    this.buckets.set(bucketKey, bucket);
-                }
-                bucket.meshData.push(meshData);
-                this.meshDataBucket.set(meshData, bucket);
-                this.pendingBatchKeys.add(bucketKey);
-            }
-            // 4. Build new proper batches into a fresh array
+            regroup = this.regroupStreamed();
+            // Build into a fresh array; rebuildPendingBatches republishes every
+            // bucket's batch, untouched ones included.
             this.batchedMeshes = [];
             this.rebuildPendingBatches(device, pipeline);
             rebuilt = true;
-            // Cached partial (filtered-visibility) batches are keyed by their SOURCE
-            // batch, so they only go stale once the replacement batches are live.
-            // Dropping them up in step 2 destroyed their GPU resources BEFORE the
-            // rebuild could fail, and the rollback cannot bring them back — an active
-            // hide/isolate view lost its visible subset and had to recreate it
-            // against the very device that just failed. On the failure path they now
-            // survive, still matching the restored batches.
-            this.dropAllPartialCaches();
         }
         finally {
             if (!rebuilt) {
-                // Free ONLY what this attempt created. Carried cold shells are aliased
-                // into BOTH the old and the new array, so anything that was already
-                // live before the rebuild must be left alone — destroying it would
-                // leave the restored arrays pointing at dead buffers.
+                // Free ONLY what this attempt created: anything live before the
+                // rebuild is what the restored arrays point back at.
                 for (const created of this.batchedMeshes) {
                     if (!oldBatchSet.has(created) && !fragmentSet.has(created)) {
                         destroyGpuResources(created);
                     }
                 }
-                // Step 5 never ran, so every old fragment/batch is still a live GPU
-                // resource: putting the arrays back restores exactly what was on
-                // screen.
+                regroup?.rollback();
                 this.streamingFragments = oldFragments;
                 this.batchedMeshes = oldBatches;
             }
         }
-        // 5. NOW destroy old fragment/batch GPU resources (new batches are live)
-        for (const fragment of oldFragments)
-            destroyGpuResources(fragment);
-        for (const batch of oldBatches) {
-            if (!fragmentSet.has(batch))
-                destroyGpuResources(batch);
-        }
+        // NOW free the fragments and the dissolved buckets' batches (the
+        // replacements are live). Batches of rebuilt surviving buckets were
+        // already retired by rebuildPendingBatches.
+        this.retireFinalizedBatches(oldFragments);
+        this.retireFinalizedBatches(regroup?.retired ?? []);
         this.reapplyColorOverrides(device, pipeline);
     }
     /**
      * Time-sliced version of finalizeStreaming.
-     * Re-groups mesh data and rebuilds GPU batches in small chunks,
-     * yielding to the event loop between chunks so orbit/pan stays responsive.
-     * Streaming fragments continue rendering until each new batch replaces them.
+     * Rebuilds the streamed buckets' batches in small chunks, yielding to the
+     * event loop between chunks so orbit/pan stays responsive. The fragments
+     * keep rendering until the rebuilt batches are swapped in.
      *
      * @param device  GPU device
      * @param pipeline  Render pipeline
@@ -2019,21 +1986,18 @@ export class Scene {
         // spec). Every entry point that can fail — the synchronous preamble AND
         // each chunked continuation — must therefore run under its own try/catch
         // that explicitly calls `reject`, mirroring finalizeStreamingInner's
-        // try/finally contract: restore oldFragments/oldBatches, free only what
-        // this attempt created, defer dropAllPartialCaches() until success, and
-        // always clear finalizeInProgress.
+        // try/finally contract: restore oldFragments/oldBatches and the bucket
+        // map, free only what this attempt created, and always clear
+        // finalizeInProgress.
         return new Promise((resolve, reject) => {
-            const newBatches = [];
             const createdOwned = [];
-            let carriedCold = [];
+            // Pending keys whose bucket ended up empty: deleted (and their batch
+            // retired) at the swap, exactly as rebuildPendingBatches would.
+            const emptied = [];
+            let regroup = null;
             let pendingKeys = [];
             let keyIdx = 0;
             function rollback() {
-                // Free ONLY what this attempt created — carried cold shells and
-                // anything already live before the rebuild must be left alone (they
-                // are what the restored arrays point back at). Iterating the owned
-                // pairs rather than `newBatches` also skips the carried cold shells
-                // appended just before the swap, which this attempt did not create.
                 for (const { bucket, previous, previousFrameOrigin, batch } of createdOwned) {
                     // Repair the owner BEFORE the free, so no bucket is ever observable
                     // holding a destroyed batch; its frame origin (what a later
@@ -2046,7 +2010,8 @@ export class Scene {
                         destroyGpuResources(batch);
                     }
                 }
-                scene.streamingFragments = oldFragments;
+                regroup?.rollback();
+                scene.streamingFragments = [...oldFragments, ...scene.streamingFragments]; // + any streamed in meanwhile
                 scene.batchedMeshes = oldBatches;
                 scene.finalizeInProgress = false;
             }
@@ -2057,7 +2022,7 @@ export class Scene {
                         const key = pendingKeys[keyIdx++];
                         const bucket = scene.buckets.get(key);
                         if (!bucket || bucket.meshData.length === 0) {
-                            scene.buckets.delete(key);
+                            emptied.push(key);
                             continue;
                         }
                         const color = bucket.meshData[0].color;
@@ -2067,35 +2032,31 @@ export class Scene {
                         bucket.batchedMesh = batchedMesh;
                         bucket.frameOrigin = batchedMesh.origin;
                         createdOwned.push({ bucket, previous, previousFrameOrigin, batch: batchedMesh });
-                        newBatches.push(batchedMesh);
                         // Check time budget — yield if exceeded
                         if (performance.now() - chunkStart >= budgetMs) {
                             setTimeout(processChunk, 0);
                             return;
                         }
                     }
-                    // Carried cold shells stay drawable-when-restored: keep them in the
-                    // flat array (their buffers are already destroyed; the draw loop
-                    // skips gpuResident === false and the restore path revives them).
-                    for (const [, bucket] of carriedCold) {
-                        if (bucket.batchedMesh)
-                            newBatches.push(bucket.batchedMesh);
-                    }
-                    // All batches built — atomic swap so renderer never sees an empty array
-                    scene.batchedMeshes = newBatches;
-                    // Cached partial (filtered-visibility) batches are keyed by their
-                    // SOURCE batch, so they only go stale once the replacement batches
-                    // are live — dropping them any earlier destroys GPU resources a
-                    // mid-rebuild failure could never get back (same rationale as
-                    // finalizeStreamingInner).
-                    scene.dropAllPartialCaches();
-                    // Destroy old fragment/batch GPU resources
-                    for (const fragment of oldFragments)
-                        destroyGpuResources(fragment);
-                    for (const batch of oldBatches) {
-                        if (!fragmentSet.has(batch))
-                            destroyGpuResources(batch);
+                    const retired = [...oldFragments, ...(regroup?.retired ?? [])];
+                    for (const { previous } of createdOwned)
+                        if (previous)
+                            retired.push(previous);
+                    for (const key of emptied) {
+                        const batch = scene.buckets.get(key)?.batchedMesh;
+                        if (batch)
+                            retired.push(batch);
+                        scene.buckets.delete(key);
                     }
+                    // Atomic swap so the renderer never sees an empty array: every
+                    // bucket's live batch (untouched models included, evicted shells
+                    // too — the draw loop skips gpuResident === false and the restore
+                    // path revives them) plus any fragment streamed in meanwhile.
+                    scene.batchedMeshes = [
+                        ...[...scene.buckets.values()].flatMap((b) => (b.batchedMesh ? [b.batchedMesh] : [])),
+                        ...scene.streamingFragments,
+                    ];
+                    scene.retireFinalizedBatches(retired);
                     scene.finalizeInProgress = false;
                     scene.reapplyColorOverrides(device, pipeline); // never throws: the swap above is committed
                     resolve();
@@ -2106,45 +2067,9 @@ export class Scene {
                 }
             }
             try {
-                // --- Synchronous preamble (fast O(N) bookkeeping) ---
+                // --- Synchronous preamble: re-group the streamed meshes only ---
                 scene.streamingFragments = [];
-                // 1. Collect ALL accumulated meshData (cold buckets carried as sealed
-                //    shells — see the sync finalize for the rationale)
-                const allMeshData = [];
-                for (const [key, bucket] of scene.buckets) {
-                    if (scene.coldBuckets.has(key) && bucket.meshData.length === 0 && bucket.batchedMesh) {
-                        carriedCold.push([key, bucket]);
-                        continue;
-                    }
-                    for (const md of bucket.meshData)
-                        allMeshData.push(md);
-                }
-                // 2. Clear bucket/batch state. dropAllPartialCaches() is deliberately
-                //    NOT called here — see the success path above.
-                scene.buckets.clear();
-                scene.meshDataBucket = new Map();
-                scene.activeBucketKey.clear();
-                scene.lastDrawnFrame.clear();
-                scene.residencyRestoreQueue.clear();
-                scene.pendingBatchKeys.clear();
-                // Re-seat the carried cold shells in the fresh bucket map.
-                for (const [key, bucket] of carriedCold)
-                    scene.buckets.set(key, bucket);
-                // 3. Re-group meshData by current color (and grid cell) — fast
-                for (const meshData of allMeshData) {
-                    const baseKey = scene.bucketBaseKey(meshData);
-                    const bucketKey = scene.resolveActiveBucket(baseKey, meshData);
-                    let bucket = scene.buckets.get(bucketKey);
-                    if (!bucket) {
-                        bucket = { key: bucketKey, meshData: [], batchedMesh: null, vertexBytes: 0 };
-                        scene.buckets.set(bucketKey, bucket);
-                    }
-                    bucket.meshData.push(meshData);
-                    scene.meshDataBucket.set(meshData, bucket);
-                    scene.pendingBatchKeys.add(bucketKey);
-                }
-                // Build new batches into a temporary array so the old batchedMeshes
-                // (streaming fragments) keep rendering until the swap is complete.
+                regroup = scene.regroupStreamed();
                 pendingKeys = Array.from(scene.pendingBatchKeys);
                 scene.pendingBatchKeys.clear();
             }
@@ -2185,6 +2110,7 @@ export class Scene {
         this.coldBuckets.clear();
         this.dirtyBuckets.clear();
         this.pendingBatchKeys.clear();
+        this.streamedBucketKeys.clear();
         this.dropAllPartialCaches();
         this.geometryReleased = true;
         this.ephemeralStreamingMode = false;
@@ -2887,31 +2813,13 @@ export class Scene {
                 vf[o + 5] = i * 3 + 2 < t.normals.length ? t.normals[i * 3 + 2] : 0;
                 // vf[o + 6] (entityId lane) stays 0.
             }
-            const vertexBuffer = device.createBuffer({
-                size: vtx.byteLength,
-                usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-                mappedAtCreation: true,
-            });
-            new Uint8Array(vertexBuffer.getMappedRange()).set(new Uint8Array(vtx));
-            vertexBuffer.unmap();
-            const indexBuffer = device.createBuffer({
-                size: t.indices.byteLength,
-                usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
-                mappedAtCreation: true,
-            });
-            new Uint32Array(indexBuffer.getMappedRange()).set(t.indices);
-            indexBuffer.unmap();
+            const vertexBuffer = createStaticGpuBuffer(device, vtx, GPUBufferUsage.VERTEX);
+            const indexBuffer = createStaticGpuBuffer(device, t.indices, GPUBufferUsage.INDEX);
             // instanceBuffer is already the interleaved mat4 + entityId + rgba block
             // (INSTANCE_STRIDE_BYTES per occurrence) from prepareInstancedRender.
-            this.modelTranslations.placeInstances(t.instanceBuffer, modelIndex, INSTANCE_STRIDE_BYTES);
+            this.modelTranslations.placeInstances(t.instanceBuffer, modelIndex, INSTANCE_STRIDE_BYTES, t.canonicalAnchors, t.canonicalMatrixTranslations);
             const instSize = t.instanceCount * INSTANCE_STRIDE_BYTES;
-            const instanceBuffer = device.createBuffer({
-                size: instSize,
-                usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-                mappedAtCreation: true,
-            });
-            new Uint8Array(instanceBuffer.getMappedRange()).set(new Uint8Array(t.instanceBuffer, 0, instSize));
-            instanceBuffer.unmap();
+            const instanceBuffer = createStaticGpuBuffer(device, new Uint8Array(t.instanceBuffer, 0, instSize), GPUBufferUsage.VERTEX);
             // Always append: slots are stable identities, never recycled.
             const templateIndex = this.instancedTemplates.length;
             const template = {
@@ -2921,6 +2829,7 @@ export class Scene {
                 indexCount: t.indices.length,
                 instanceBuffer,
                 instanceCount: t.instanceCount,
+                canonicalAnchors: t.canonicalAnchors,
                 bounds: null,
                 maxOccRadius: 0,
                 selectedCount: 0,
@@ -2954,6 +2863,8 @@ export class Scene {
                 normals: t.normals,
                 indices: t.indices,
                 instanceData: t.instanceBuffer,
+                canonicalAnchors: t.canonicalAnchors,
+                canonicalMatrixTranslations: t.canonicalMatrixTranslations,
                 localMin: [lmnx, lmny, lmnz],
                 localMax: [lmxx, lmxy, lmxz],
             };
@@ -3024,51 +2935,10 @@ export class Scene {
         this.instancedVisibilityDirty = true;
         this.instancedGhostDirty = true;
     }
-    /** Transform a template's local AABB by an occurrence's column-major mat4 (read
-     *  from the packed instance record at `matOffset`) and union the world box into
-     *  boundingBoxes[eid]. Returns the occurrence's world box so the caller can also
-     *  fold it into the template's cull metadata. */
     unionInstancedWorldAabb(eid, dv, matOffset, lmnx, lmny, lmnz, lmxx, lmxy, lmxz) {
-        const m0 = dv.getFloat32(matOffset + 0, true), m1 = dv.getFloat32(matOffset + 4, true), m2 = dv.getFloat32(matOffset + 8, true);
-        const m4 = dv.getFloat32(matOffset + 16, true), m5 = dv.getFloat32(matOffset + 20, true), m6 = dv.getFloat32(matOffset + 24, true);
-        const m8 = dv.getFloat32(matOffset + 32, true), m9 = dv.getFloat32(matOffset + 36, true), m10 = dv.getFloat32(matOffset + 40, true);
-        const m12 = dv.getFloat32(matOffset + 48, true), m13 = dv.getFloat32(matOffset + 52, true), m14 = dv.getFloat32(matOffset + 56, true);
-        let minX = Infinity, minY = Infinity, minZ = Infinity, maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
-        for (let c = 0; c < 8; c++) {
-            const x = (c & 1) ? lmxx : lmnx, y = (c & 2) ? lmxy : lmny, z = (c & 4) ? lmxz : lmnz;
-            const wx = m0 * x + m4 * y + m8 * z + m12;
-            const wy = m1 * x + m5 * y + m9 * z + m13;
-            const wz = m2 * x + m6 * y + m10 * z + m14;
-            if (wx < minX)
-                minX = wx;
-            if (wy < minY)
-                minY = wy;
-            if (wz < minZ)
-                minZ = wz;
-            if (wx > maxX)
-                maxX = wx;
-            if (wy > maxY)
-                maxY = wy;
-            if (wz > maxZ)
-                maxZ = wz;
-        }
-        const existing = this.boundingBoxes.get(eid);
-        if (existing) {
-            existing.min.x = Math.min(existing.min.x, minX);
-            existing.min.y = Math.min(existing.min.y, minY);
-            existing.min.z = Math.min(existing.min.z, minZ);
-            existing.max.x = Math.max(existing.max.x, maxX);
-            existing.max.y = Math.max(existing.max.y, maxY);
-            existing.max.z = Math.max(existing.max.z, maxZ);
-        }
-        else {
-            this.boundingBoxes.set(eid, { min: { x: minX, y: minY, z: minZ }, max: { x: maxX, y: maxY, z: maxZ } });
-        }
-        return { minX, minY, minZ, maxX, maxY, maxZ };
+        return unionInstanceBounds(this.boundingBoxes, eid, dv, matOffset, lmnx, lmny, lmnz, lmxx, lmxy, lmxz);
     }
-    /** True if `expressId` is a GPU-instanced occurrence (lives only in the instanced
-     *  shard, not the flat meshDataMap). CPU consumers use this to decide whether to
-     *  fall back to the instanced accessors below. */
+    /** True when `expressId` has a GPU-instanced occurrence. */
     isInstancedEntity(expressId) {
         return this.instancedEntityMap.has(expressId);
     }
@@ -3635,6 +3505,7 @@ export class Scene {
         this.dirtyBuckets.clear();
         this.cachedMaxBufferSize = 0;
         this.pendingBatchKeys.clear();
+        this.streamedBucketKeys.clear();
         this.meshQueue = [];
         this.meshQueueReadIndex = 0;
         this.geometryReleased = false;
@@ -3933,7 +3804,7 @@ export class Scene {
      * covered: their world AABBs are registered in `boundingBoxes` when the
      * instanced shard is built.
      */
-    selectRect(x0, y0, x1, y1, viewportWidth, viewportHeight, viewProj, hiddenIds, isolatedIds, clip) {
+    selectRect(x0, y0, x1, y1, viewportWidth, viewportHeight, viewProj, hiddenIds, isolatedIds, clip, rte) {
         // After release the cache is already the complete set; before it, boxes are
         // computed lazily, so make sure every entity that still has mesh data has
         // one. Same authoritative id set pick() uses, so colour-fused fillers whose
@@ -3951,7 +3822,7 @@ export class Scene {
                 this.getEntityBoundingBox(expressId);
             }
         }
-        return selectBoundingBoxesInRect(this.boundingBoxes, viewProj, { x0, y0, x1, y1 }, viewportWidth, viewportHeight, hiddenIds, isolatedIds, clip);
+        return selectBoundingBoxesInRect(this.boundingBoxes, viewProj, { x0, y0, x1, y1 }, viewportWidth, viewportHeight, hiddenIds, isolatedIds, clip, rte);
     }
 }
 //# sourceMappingURL=scene.js.map