bruce-cesium 6.7.8 → 6.8.0

package/dist/bruce-cesium.es5.js

@@ -6536,6 +6536,18 @@ var VisualsRegister;
             this.id = ObjectUtils.UId();
             this.disposed = false;
             this.rego = {};
+            // Menu Item ID -> Set of Entity IDs registered under that menu item, for O(1) lookup.
+            this.entityIdsByMenuItem = {};
+            // Caches GetIsIsolatedAny(). `null` means "unknown, recompute".
+            // Invalidated on any write that could affect isolation.
+            this.isolatedAnyCache = null;
+            // Lazy OverrideStates() bookkeeping. See cancelLazyOverride()/startLazyOverride().
+            this.lazyOverrideToken = 0;
+            this.lazyOverrideActive = false;
+            // Entity ids a direct (non-lazy) write touched while a lazy apply was in-flight-
+            // skipped by the applier so a live user action always wins.
+            this.lazyOverrideExclusions = new Set();
+            this.lazyOverrideInterval = null;
             this.onUpdate = null;
             // Entity ID -> Menu Item ID -> State.
             // When no Menu Item ID is set, then the second key is a blank string.
@@ -6543,6 +6555,8 @@ var VisualsRegister;
             this.states = {};
             // Queue of Entity updates to process in batches to avoid overloading the render loop.
             this.updateQueue = [];
+            // Mirrors updateQueue for O(1) "already queued" checks.
+            this.updateQueueIds = new Set();
             // Settings related to those Entities in the queue.
             // This lets us modify the update without re-adding the item to the queue if it's already in it.
             this.updateQueueSettings = {};
@@ -6553,6 +6567,42 @@ var VisualsRegister;
                 register: this
             });
         }
+        indexMenuItemEntity(menuItemId, entityId) {
+            if (!menuItemId) {
+                return;
+            }
+            let set = this.entityIdsByMenuItem[menuItemId];
+            if (!set) {
+                set = this.entityIdsByMenuItem[menuItemId] = new Set();
+            }
+            set.add(entityId);
+        }
+        // Removes entityId from the menu item index only if it no longer has any rego
+        // registered under that menu item. Safe to call speculatively.
+        unindexMenuItemEntityIfAbsent(menuItemId, entityId) {
+            var _a;
+            if (!menuItemId) {
+                return;
+            }
+            const set = this.entityIdsByMenuItem[menuItemId];
+            if (!set) {
+                return;
+            }
+            const stillPresent = (_a = this.rego[entityId]) === null || _a === void 0 ? void 0 : _a.some(r => r.menuItemId === menuItemId);
+            if (!stillPresent) {
+                set.delete(entityId);
+                if (!set.size) {
+                    delete this.entityIdsByMenuItem[menuItemId];
+                }
+            }
+        }
+        // Records that `entityId` was just written to directly, outside of any lazy
+        // OverrideStates() apply. No-op unless a lazy apply is currently in-flight.
+        markLazyExclusion(entityId) {
+            if (this.lazyOverrideActive) {
+                this.lazyOverrideExclusions.add(entityId);
+            }
+        }
         queueUpdate(update) {
             if (this.Disposed) {
                 return;
@@ -6585,7 +6635,8 @@ var VisualsRegister;
             }
             this.updateQueueSettings[update.entityId] = settings;
             // Queue ID if it's not already in the queue.
-            if (!this.updateQueue.includes(update.entityId)) {
+            if (!this.updateQueueIds.has(update.entityId)) {
+                this.updateQueueIds.add(update.entityId);
                 this.updateQueue.push(update.entityId);
                 this.pingUpdateQueue();
             }
@@ -6606,6 +6657,7 @@ var VisualsRegister;
                     const cache = {};
                     for (let i = 0; i < batch.length; i++) {
                         const entityId = batch[i];
+                        this.updateQueueIds.delete(entityId);
                         // Check if still registered.
                         if (entityId && (!this.rego[entityId] || !this.rego[entityId].length)) {
                             continue;
@@ -6718,6 +6770,8 @@ var VisualsRegister;
         SetStates(states, source) {
             // Array of changed Entity IDs so we know what to refresh/notify at the end.
             const entityIds = [];
+            // Mirrors entityIds for O(1) "already recorded" checks.
+            const entityIdsSeen = new Set();
             // If we need to update all Entities.
             // This is usually for isolation changes.
             let updateAll = false;
@@ -6750,8 +6804,9 @@ var VisualsRegister;
             };
             const doUpdate = (state) => {
                 const eChanged = this.SetState(state, false, source);
-                if (eChanged && !entityIds.includes(state.entityId)) {
+                if (eChanged && !entityIdsSeen.has(state.entityId)) {
                     updateRefreshMarkers(state);
+                    entityIdsSeen.add(state.entityId);
                     entityIds.push(state.entityId);
                     changed = true;
                 }
@@ -6786,7 +6841,7 @@ var VisualsRegister;
                     for (let i = 0; i < keys.length; i++) {
                         const key = keys[i];
                         const state = states[key];
-                        if (entityIds.includes(state.entityId)) {
+                        if (entityIdsSeen.has(state.entityId)) {
                             const update = {
                                 type: EVisualUpdateType.Update,
                                 entityId: state.entityId
@@ -6816,12 +6871,18 @@ var VisualsRegister;
          * Sets the provided settings for a given Entity's state.
          * @param params
          */
-        setStateValues(values) {
+        setStateValues(values, fromLazyApplier = false) {
             const { entityId, menuItemId } = values;
             const keys = Object.keys(values).filter(k => k !== "entityId" && k !== "menuItemId");
             if (!keys.length) {
                 return false;
             }
+            if (!fromLazyApplier) {
+                this.markLazyExclusion(entityId);
+            }
+            if (keys.includes("isolated")) {
+                this.isolatedAnyCache = null;
+            }
             let changed = false;
             const eStates = this.states[entityId] || {};
             this.states[entityId] = eStates;
@@ -6992,18 +7053,68 @@ var VisualsRegister;
             }
             return false;
         }
+        buildClearDiffItem(state) {
+            const clearState = {
+                entityId: state.entityId,
+                menuItemId: state.menuItemId
+            };
+            const refresh = {};
+            // For each property that exists, set it to null to clear it.
+            // This will cause setStateValues to delete the property.
+            if (state.highlighted != null) {
+                clearState.highlighted = null;
+                refresh.highlighted = true;
+            }
+            if (state.selected != null) {
+                clearState.selected = null;
+                refresh.selected = true;
+            }
+            if (state.opacity != null) {
+                clearState.opacity = null;
+                refresh.opacity = true;
+            }
+            if (state.labelled != null) {
+                clearState.labelled = null;
+            }
+            if (state.hidden != null) {
+                clearState.hidden = null;
+            }
+            if (state.isolated != null) {
+                clearState.isolated = null;
+            }
+            return { clearState, refresh };
+        }
+        /**
+         * Refresh flags needed for an "add"/"update" state - the new value is applied as-is,
+         * this just says which visual properties changed.
+         */
+        buildSetDiffRefresh(state) {
+            const refresh = {};
+            if (state.hasOwnProperty("highlighted")) {
+                refresh.highlighted = true;
+            }
+            if (state.hasOwnProperty("selected")) {
+                refresh.selected = true;
+            }
+            if (state.hasOwnProperty("opacity")) {
+                refresh.opacity = true;
+            }
+            return refresh;
+        }
         /**
          * Applies a set of new states to override the existing ones using differential updates.
-         * This is more efficient than clearing and re-applying all states.
-         * @param states
          */
-        OverrideStates(states) {
-            // Calculate what needs to change.
+        OverrideStates(states, options) {
+            this.cancelLazyOverride();
             const diff = this.calculateStateDifference(states);
             // If nothing changed, exit early.
             if (diff.toAdd.length === 0 && diff.toRemove.length === 0 && diff.toUpdate.length === 0) {
                 return;
             }
+            if (options === null || options === void 0 ? void 0 : options.lazy) {
+                this.startLazyOverride(diff);
+                return;
+            }
             // Track which visual properties need refreshing per entity.
             const refreshMap = new Map();
             const updateRefreshForEntity = (entityId, props) => {
@@ -7014,76 +7125,16 @@ var VisualsRegister;
                     opacity: existing.opacity || props.opacity || false
                 });
             };
-            // Process removals.
             for (const state of diff.toRemove) {
-                // Create a state with inverted/cleared values.
-                const clearState = {
-                    entityId: state.entityId,
-                    menuItemId: state.menuItemId
-                };
-                // For each property that exists, set it to null to clear it.
-                // This will cause setStateValues to delete the property.
-                if (state.highlighted != null) {
-                    clearState.highlighted = null;
-                    updateRefreshForEntity(state.entityId, {
-                        highlighted: true
-                    });
-                }
-                if (state.selected != null) {
-                    clearState.selected = null;
-                    updateRefreshForEntity(state.entityId, {
-                        selected: true
-                    });
-                }
-                if (state.opacity != null) {
-                    clearState.opacity = null;
-                    updateRefreshForEntity(state.entityId, {
-                        opacity: true
-                    });
-                }
-                if (state.labelled != null) {
-                    clearState.labelled = null;
-                    updateRefreshForEntity(state.entityId, {});
-                }
-                if (state.hidden != null) {
-                    clearState.hidden = null;
-                    updateRefreshForEntity(state.entityId, {});
-                }
-                if (state.isolated != null) {
-                    clearState.isolated = null;
-                    updateRefreshForEntity(state.entityId, {});
-                }
+                const { clearState, refresh } = this.buildClearDiffItem(state);
+                updateRefreshForEntity(state.entityId, refresh);
                 this.setStateValues(clearState);
             }
-            // Process additions and updates.
             const statesToSet = [...diff.toAdd, ...diff.toUpdate];
             for (const state of statesToSet) {
-                // Determine what needs visual refresh based on what's changing.
-                if (state.hasOwnProperty("highlighted")) {
-                    updateRefreshForEntity(state.entityId, {
-                        highlighted: true
-                    });
-                }
-                if (state.hasOwnProperty("selected")) {
-                    updateRefreshForEntity(state.entityId, {
-                        selected: true
-                    });
-                }
-                if (state.hasOwnProperty("opacity")) {
-                    updateRefreshForEntity(state.entityId, {
-                        opacity: true
-                    });
-                }
-                if (state.hasOwnProperty("labelled")) {
-                    updateRefreshForEntity(state.entityId, {});
-                }
-                if (state.hasOwnProperty("hidden") || state.hasOwnProperty("isolated")) {
-                    updateRefreshForEntity(state.entityId, {});
-                }
+                updateRefreshForEntity(state.entityId, this.buildSetDiffRefresh(state));
                 this.setStateValues(state);
             }
-            // Queue updates for all affected entities.
-            // TODO: if a massive list we should async batch this.
             for (const entityId of diff.affectedEntityIds) {
                 const refresh = refreshMap.get(entityId);
                 this.queueUpdate({
@@ -7093,6 +7144,77 @@ var VisualsRegister;
             }
             this.viewer.scene.requestRender();
         }
+        /**
+         * Cancels any in-flight lazy OverrideStates() apply.
+         */
+        cancelLazyOverride() {
+            if (!this.lazyOverrideActive) {
+                return;
+            }
+            this.lazyOverrideToken++;
+            this.lazyOverrideActive = false;
+            this.lazyOverrideExclusions.clear();
+            if (this.lazyOverrideInterval) {
+                clearInterval(this.lazyOverrideInterval);
+                this.lazyOverrideInterval = null;
+            }
+        }
+        /**
+         * Starts (or restarts) a chunked, cancellable apply of a previously-computed diff.
+         * See OverrideStates() for the cancellation/priority semantics.
+         */
+        startLazyOverride(diff) {
+            const BATCH_SIZE = 2000;
+            const queue = [];
+            for (const state of diff.toRemove) {
+                queue.push({ state, isRemoval: true });
+            }
+            for (const state of diff.toAdd) {
+                queue.push({ state, isRemoval: false });
+            }
+            for (const state of diff.toUpdate) {
+                queue.push({ state, isRemoval: false });
+            }
+            this.lazyOverrideToken++;
+            const token = this.lazyOverrideToken;
+            this.lazyOverrideActive = true;
+            this.lazyOverrideExclusions.clear();
+            let index = 0;
+            this.lazyOverrideInterval = setInterval(() => {
+                // A newer lazy call (or a sync OverrideStates()) superseded this run.
+                if (token !== this.lazyOverrideToken || this.Disposed) {
+                    clearInterval(this.lazyOverrideInterval);
+                    this.lazyOverrideInterval = null;
+                    return;
+                }
+                const end = Math.min(index + BATCH_SIZE, queue.length);
+                for (; index < end; index++) {
+                    const { state, isRemoval } = queue[index];
+                    // A direct write already claimed this entity, the bookmark's still-pending
+                    // value for it is dropped for the rest of this run.
+                    if (this.lazyOverrideExclusions.has(state.entityId)) {
+                        continue;
+                    }
+                    if (isRemoval) {
+                        const { clearState, refresh } = this.buildClearDiffItem(state);
+                        this.setStateValues(clearState, true);
+                        this.queueUpdate({ entityId: state.entityId, refresh });
+                    }
+                    else {
+                        const refresh = this.buildSetDiffRefresh(state);
+                        this.setStateValues(state, true);
+                        this.queueUpdate({ entityId: state.entityId, refresh });
+                    }
+                }
+                this.viewer.scene.requestRender();
+                if (index >= queue.length) {
+                    clearInterval(this.lazyOverrideInterval);
+                    this.lazyOverrideInterval = null;
+                    this.lazyOverrideActive = false;
+                    this.lazyOverrideExclusions.clear();
+                }
+            }, 10);
+        }
         /**
          * Returns all states with the first detected Menu Item ID settings included.
          * This is a utility function for returning settings for apps that don't support the newer state settings.
@@ -7108,9 +7230,8 @@ var VisualsRegister;
                 if (!eStates) {
                     continue;
                 }
-                if (!entityIds.includes(entityId)) {
-                    entityIds.push(entityId);
-                }
+                // Keys of this.states are already unique, no dedupe check needed.
+                entityIds.push(entityId);
                 const mKeys = Object.keys(eStates);
                 for (let i = 0; i < mKeys.length; i++) {
                     const menuItemId = mKeys[i];
@@ -7176,6 +7297,9 @@ var VisualsRegister;
             this.cameraCullerDispose = null;
             clearInterval(this.updateQueueInterval);
             this.updateQueueInterval = null;
+            clearInterval(this.lazyOverrideInterval);
+            this.lazyOverrideInterval = null;
+            this.lazyOverrideActive = false;
             this.disposed = true;
         }
         ForceUpdate(params) {
@@ -7245,12 +7369,15 @@ var VisualsRegister;
          */
         ClearLabelled(params) {
             const toUpdateIds = [];
+            const toUpdateIdsSeen = new Set();
             this.ForEachState((state) => {
                 if (state.labelled == null || state.labelled === undefined) {
                     return;
                 }
+                this.markLazyExclusion(state.entityId);
                 delete state.labelled;
-                if (!toUpdateIds.includes(state.entityId)) {
+                if (!toUpdateIdsSeen.has(state.entityId)) {
+                    toUpdateIdsSeen.add(state.entityId);
                     toUpdateIds.push(state.entityId);
                 }
             });
@@ -7378,11 +7505,12 @@ var VisualsRegister;
         }
         ClearSelected(params) {
             var _a;
-            const cleared = [];
+            const cleared = new Set();
             this.ForEachState((state) => {
                 if (state.selected == null || state.selected === undefined) {
                     return;
                 }
+                this.markLazyExclusion(state.entityId);
                 delete state.selected;
                 const regos = this.GetRegos({
                     entityId: state.entityId,
@@ -7390,13 +7518,13 @@ var VisualsRegister;
                 });
                 for (let i = 0; i < regos.length; i++) {
                     const rego = regos[i];
-                    if ((rego === null || rego === void 0 ? void 0 : rego.visual) && !cleared.includes(rego)) {
+                    if ((rego === null || rego === void 0 ? void 0 : rego.visual) && !cleared.has(rego)) {
                         CesiumEntityStyler.Deselect({
                             entity: rego.visual,
                             viewer: this.viewer,
                             requestRender: false
                         });
-                        cleared.push(rego);
+                        cleared.add(rego);
                     }
                 }
             });
@@ -7509,10 +7637,13 @@ var VisualsRegister;
             var _a;
             // Null all states.
             let entityIds = [];
+            const entityIdsSeen = new Set();
             this.ForEachState((state) => {
                 if (state.highlighted) {
+                    this.markLazyExclusion(state.entityId);
                     delete state.highlighted;
-                    if (!entityIds.includes(state.entityId)) {
+                    if (!entityIdsSeen.has(state.entityId)) {
+                        entityIdsSeen.add(state.entityId);
                         entityIds.push(state.entityId);
                     }
                 }
@@ -7601,7 +7732,10 @@ var VisualsRegister;
             return state.isolated === true;
         }
         GetIsIsolatedAny() {
-            return Object.values(this.states).some(state => state && Object.values(state).some(item => item.isolated));
+            if (this.isolatedAnyCache == null) {
+                this.isolatedAnyCache = Object.values(this.states).some(state => state && Object.values(state).some(item => item.isolated));
+            }
+            return this.isolatedAnyCache;
         }
         /**
          * @deprecated Use GetStates() or GetState().
@@ -7622,10 +7756,15 @@ var VisualsRegister;
             this.ForEachState((state) => {
                 if (state.isolated) {
                     changed = true;
+                    this.markLazyExclusion(state.entityId);
                 }
                 delete state.isolated;
             });
-            if (changed && params.doUpdate !== false) {
+            if (changed) {
+                // Mutated `isolated` directly rather than through setStateValues().
+                this.isolatedAnyCache = false;
+            }
+            if (changed && (params === null || params === void 0 ? void 0 : params.doUpdate) !== false) {
                 this.updateAllEntities({
                     requestRender: params === null || params === void 0 ? void 0 : params.requestRender,
                     refresh: true
@@ -7676,10 +7815,11 @@ var VisualsRegister;
             this.ForEachState((state) => {
                 if (state.hidden) {
                     changed = true;
+                    this.markLazyExclusion(state.entityId);
                 }
                 delete state.hidden;
             });
-            if (changed && params.doUpdate !== false) {
+            if (changed && (params === null || params === void 0 ? void 0 : params.doUpdate) !== false) {
                 this.updateAllEntities({
                     requestRender: params === null || params === void 0 ? void 0 : params.requestRender,
                     refresh: true
@@ -7715,6 +7855,7 @@ var VisualsRegister;
             const entityRegos = (_a = this.rego[entityId]) !== null && _a !== void 0 ? _a : [];
             entityRegos.push(rego);
             this.rego[entityId] = entityRegos;
+            this.indexMenuItemEntity(rego.menuItemId, entityId);
             // Mark the visual as part of this register so selection works.
             markEntity(this, rego, rego.visual, false);
             // Run any updates on the visual based on the calculated state.
@@ -7738,6 +7879,74 @@ var VisualsRegister;
                 this.viewer.scene.requestRender();
             }
         }
+        /**
+         * Re-parents every rego registered under one menu item id to a different menu item id.
+         */
+        ReassignMenuItem(params) {
+            var _a, _b;
+            const { fromMenuItemId, toMenuItemId, toMenuItemType, toPriority, requestRender, source } = params;
+            if (!fromMenuItemId || !toMenuItemId || fromMenuItemId === toMenuItemId) {
+                return;
+            }
+            const entityIds = this.entityIdsByMenuItem[fromMenuItemId];
+            if (!entityIds) {
+                return;
+            }
+            // Snapshot: unindexMenuItemEntityIfAbsent() below mutates this same set.
+            for (const entityId of Array.from(entityIds)) {
+                const regos = this.rego[entityId];
+                if (!regos) {
+                    continue;
+                }
+                for (const rego of regos) {
+                    if (rego.menuItemId !== fromMenuItemId) {
+                        continue;
+                    }
+                    if (source !== EUpdateSource.TREE_CASCADE) {
+                        (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger({
+                            type: EVisualUpdateType.Remove,
+                            entityId,
+                            rego: { ...rego, menuItemId: fromMenuItemId },
+                            source
+                        });
+                    }
+                    rego.menuItemId = toMenuItemId;
+                    rego.menuItemType = toMenuItemType;
+                    if (toPriority != null) {
+                        rego.priority = toPriority;
+                    }
+                    if (source !== EUpdateSource.TREE_CASCADE) {
+                        (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Trigger({
+                            type: EVisualUpdateType.Add,
+                            entityId,
+                            rego,
+                            source
+                        });
+                    }
+                }
+                const eStates = this.states[entityId];
+                const movingState = eStates === null || eStates === void 0 ? void 0 : eStates[fromMenuItemId];
+                if (movingState) {
+                    delete eStates[fromMenuItemId];
+                    const existingTargetState = eStates[toMenuItemId];
+                    eStates[toMenuItemId] = {
+                        ...existingTargetState,
+                        ...movingState,
+                        entityId,
+                        menuItemId: toMenuItemId
+                    };
+                }
+                this.unindexMenuItemEntityIfAbsent(fromMenuItemId, entityId);
+                this.indexMenuItemEntity(toMenuItemId, entityId);
+                this.queueUpdate({
+                    entityId,
+                    refresh: true
+                });
+            }
+            if (requestRender != false) {
+                this.viewer.scene.requestRender();
+            }
+        }
         /**
          * Locates a visual corresponding to a given entity id.
          * If no menu item id is provided, then it will pick the "best" one.
@@ -7848,7 +8057,10 @@ var VisualsRegister;
             // TODO: refactor.
             // Currently this was made by merging two functions.
             if (menuItemId && !entityId) {
-                for (const entityId in this.rego) {
+                // Entities registered under this menu item, keyed via entityIdsByMenuItem.
+                // Snapshot to an array since removals below mutate the backing set.
+                const entityIds = this.entityIdsByMenuItem[menuItemId] ? Array.from(this.entityIdsByMenuItem[menuItemId]) : [];
+                for (const entityId of entityIds) {
                     const entityRegos = this.rego[entityId];
                     if (entityRegos) {
                         const rego = entityRegos.find(r => r.menuItemId === menuItemId);
@@ -7870,6 +8082,7 @@ var VisualsRegister;
                         const doesInclude = this.rego[entityId].find(r => r.menuItemId === menuItemId);
                         if (doesInclude) {
                             this.rego[entityId] = entityRegos.filter(r => r.menuItemId !== menuItemId);
+                            this.unindexMenuItemEntityIfAbsent(menuItemId, entityId);
                         }
                         const update = {
                             type: EVisualUpdateType.Remove,
@@ -7922,6 +8135,7 @@ var VisualsRegister;
                         (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Trigger(update);
                     }
                     this.rego[entityId] = entityRegos.filter(r => r.menuItemId !== menuItemId);
+                    this.unindexMenuItemEntityIfAbsent(menuItemId, entityId);
                     if (doUpdate && menuItemId) {
                         this.queueUpdate({
                             entityId: entityId,
@@ -7944,7 +8158,11 @@ var VisualsRegister;
                         });
                         removeEntity(this.viewer, rego.visual);
                         rego.visual = null;
-                        this.rego[entityId] = entityRegos.filter(r => r.menuItemId !== menuItemId);
+                        this.rego[entityId] = entityRegos.filter(r => r !== rego);
+                        if (!this.rego[entityId].length) {
+                            delete this.rego[entityId];
+                        }
+                        this.unindexMenuItemEntityIfAbsent(rego.menuItemId, entityId);
                         const update = {
                             type: EVisualUpdateType.Remove,
                             entityId: rego.entityId,
@@ -7956,7 +8174,7 @@ var VisualsRegister;
                         if (source !== EUpdateSource.TREE_CASCADE) {
                             (_c = this.onUpdate) === null || _c === void 0 ? void 0 : _c.Trigger(update);
                         }
-                        if (doUpdate && menuItemId) {
+                        if (doUpdate) {
                             this.queueUpdate({
                                 entityId: entityId,
                                 refresh: false
@@ -7973,68 +8191,68 @@ var VisualsRegister;
          * @param params
          */
         RemoveRegosByVisuals(params) {
-            var _a, _b, _c;
+            var _a, _b;
             const { doRemove = true, requestRender = true, source, doUpdate, menuItemId } = params;
-            const entityIds = Object.keys(this.rego);
-            const removedEntityIds = [];
-            for (const entityId of entityIds) {
-                const regos = this.rego[entityId];
-                if (regos && regos.length) {
-                    for (const rego of regos) {
-                        if (params.visuals.includes(rego.visual)) {
-                            EntityLabel.Detatch({
-                                rego
-                            });
-                            if (doRemove != false) {
-                                removeEntity(this.viewer, rego.visual);
-                            }
-                            rego.visual = null;
-                            this.rego[entityId] = regos.filter(r => r.visual !== rego.visual);
-                            const update = {
-                                type: EVisualUpdateType.Remove,
-                                entityId: rego.entityId,
-                                rego: rego
-                            };
-                            if (source) {
-                                update.source = source;
-                            }
-                            if (source !== EUpdateSource.TREE_CASCADE) {
-                                (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(update);
-                            }
-                            if (doUpdate && menuItemId) {
-                                this.queueUpdate({
-                                    entityId: entityId,
-                                    refresh: false
-                                });
-                            }
-                            if (!removedEntityIds.includes(rego.entityId)) {
-                                removedEntityIds.push(rego.entityId);
-                            }
-                        }
-                        // Check siblings.
-                        else if ((_b = rego.visual) === null || _b === void 0 ? void 0 : _b["_siblingGraphics"]) {
-                            let siblings = rego.visual["_siblingGraphics"];
-                            if (doRemove != false) {
-                                for (const sibling of siblings) {
-                                    if (params.visuals.includes(sibling)) {
-                                        removeEntity(this.viewer, sibling);
-                                    }
-                                }
-                            }
-                            siblings = siblings.filter(s => !params.visuals.includes(s));
-                            rego.visual["_siblingGraphics"] = siblings;
-                        }
+            const removedEntityIds = new Set();
+            for (const visual of params.visuals) {
+                const visExt = visual;
+                const rego = (visExt === null || visExt === void 0 ? void 0 : visExt._register) === this ? visExt._rego : null;
+                if (!rego || !rego.visual) {
+                    continue;
+                }
+                const entityId = rego.entityId;
+                const entityRegos = this.rego[entityId];
+                if (!entityRegos) {
+                    continue;
+                }
+                if (rego.visual === visual) {
+                    // The primary graphic for this rego - remove the rego entirely.
+                    EntityLabel.Detatch({
+                        rego
+                    });
+                    if (doRemove != false) {
+                        removeEntity(this.viewer, rego.visual);
+                    }
+                    rego.visual = null;
+                    this.rego[entityId] = entityRegos.filter(r => r !== rego);
+                    if (!this.rego[entityId].length) {
+                        delete this.rego[entityId];
+                    }
+                    this.unindexMenuItemEntityIfAbsent(rego.menuItemId, entityId);
+                    const update = {
+                        type: EVisualUpdateType.Remove,
+                        entityId: rego.entityId,
+                        rego: rego
+                    };
+                    if (source) {
+                        update.source = source;
                     }
+                    if (source !== EUpdateSource.TREE_CASCADE) {
+                        (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(update);
+                    }
+                    if (doUpdate && menuItemId) {
+                        this.queueUpdate({
+                            entityId: entityId,
+                            refresh: false
+                        });
+                    }
+                    removedEntityIds.add(entityId);
                 }
-                if (!((_c = this.rego[entityId]) === null || _c === void 0 ? void 0 : _c.length)) {
-                    delete this.rego[entityId];
+                else {
+                    const siblings = (_b = rego.visual) === null || _b === void 0 ? void 0 : _b["_siblingGraphics"];
+                    if (siblings === null || siblings === void 0 ? void 0 : siblings.length) {
+                        if (doRemove != false && siblings.includes(visual)) {
+                            removeEntity(this.viewer, visual);
+                        }
+                        rego.visual["_siblingGraphics"] = siblings.filter(s => s !== visual);
+                    }
                 }
             }
             if (requestRender) {
                 this.viewer.scene.requestRender();
             }
             return {
-                removedEntityIds
+                removedEntityIds: Array.from(removedEntityIds)
             };
         }
         /**
@@ -8190,16 +8408,17 @@ var VisualsRegister;
             return (totalOpacity && totalTicks) ? (totalOpacity / totalTicks) : totalOpacity != null && typeof totalOpacity == "number" ? totalOpacity : 1;
         }
         ClearOpacity(params) {
-            const clearedIds = [];
+            const clearedIds = new Set();
             this.ForEachState((state) => {
-                if (!clearedIds.includes(state.entityId) && state.opacity != null) {
+                if (!clearedIds.has(state.entityId) && state.opacity != null) {
+                    this.markLazyExclusion(state.entityId);
                     this.queueUpdate({
                         entityId: state.entityId,
                         refresh: {
                             opacity: true
                         }
                     });
-                    clearedIds.push(state.entityId);
+                    clearedIds.add(state.entityId);
                 }
                 delete state.opacity;
             });
@@ -13832,6 +14051,14 @@ var TilesetCadRenderManager;
             this.disposed = false;
             this.modelSpace = false;
             this.cTileset = null;
+            // Kept around so a hand-off (see PrepareHandoff/AdoptHandoff) can pass it on without a re-fetch.
+            this.tileset = null;
+            // Removal callbacks for this instance's own tile stream listeners.
+            this.tileLoadRemoval = null;
+            this.tileUnloadRemoval = null;
+            // Chunks AdoptHandoff()'s restyle of handed-off content across ticks instead of one
+            // synchronous pass over potentially millions of regos.
+            this.handoffRestyleInterval = null;
             this.styler = new TilesetRenderEngine.Styler();
             this.modelTreeUpdate = new BruceEvent();
             // Quick look-up of the model tree nodes by entity/geomId.
@@ -13938,6 +14165,7 @@ var TilesetCadRenderManager;
                 if (!tileset || this.disposed) {
                     return;
                 }
+                this.tileset = tileset;
                 if (!api) {
                     api = this.getters.GetBruceApi({
                         accountId: accountId
@@ -14104,7 +14332,7 @@ var TilesetCadRenderManager;
                         console.error(e);
                     }
                 });
-                cTileset.tileLoad.addEventListener((tile) => {
+                this.tileLoadRemoval = cTileset.tileLoad.addEventListener((tile) => {
                     try {
                         this.queueTile(tile, true);
                     }
@@ -14112,7 +14340,7 @@ var TilesetCadRenderManager;
                         console.error(e);
                     }
                 });
-                cTileset.tileUnload.addEventListener((tile) => {
+                this.tileUnloadRemoval = cTileset.tileUnload.addEventListener((tile) => {
                     try {
                         this.queueTile(tile, false);
                     }
@@ -14132,6 +14360,137 @@ var TilesetCadRenderManager;
                 this.viewer.zoomTo(this.cTileset, new HeadingPitchRange(0.0, -0.5, this.cTileset.boundingSphere.radius / 4.0));
             }
         }
+        // Two items resolving to the same key are eligible to hand off, regardless of styling.
+        get HandoffKey() {
+            return Manager.GetHandoffKey(this.item);
+        }
+        static GetHandoffKey(item) {
+            var _a, _b;
+            const tilesetId = (_a = item === null || item === void 0 ? void 0 : item.tileset) === null || _a === void 0 ? void 0 : _a.TilesetID;
+            if (!tilesetId) {
+                return null;
+            }
+            const accountId = ((_b = item.tileset) === null || _b === void 0 ? void 0 : _b.ClientAccountID) || "";
+            return `${accountId}:${tilesetId}`;
+        }
+        // Returns null (fall back to a normal Dispose()) if the tileset hasn't finished loading yet.
+        PrepareHandoff() {
+            var _a, _b;
+            if (this.disposed || !this.cTileset || this.cTileset.isDestroyed()) {
+                return null;
+            }
+            // Drain anything mid-flight, once handed off, this instance no longer owns the tile events.
+            while (this.featureQueue.length) {
+                this.processFeatureQueueBatch();
+            }
+            if (this.featureQueueInterval) {
+                clearInterval(this.featureQueueInterval);
+                this.featureQueueInterval = null;
+            }
+            if (this.handoffRestyleInterval) {
+                clearInterval(this.handoffRestyleInterval);
+                this.handoffRestyleInterval = null;
+            }
+            // Not transferred, the receiving manager sets up its own fresh copy if needed.
+            this.viewerDateTimeDispose();
+            (_a = this.tileLoadRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_b = this.tileUnloadRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+            this.tileLoadRemoval = null;
+            this.tileUnloadRemoval = null;
+            const payload = {
+                cTileset: this.cTileset,
+                tileset: this.tileset,
+                rootId: this.rootId,
+                modelTree: this.modelTree,
+                treeNodeByGeomId: this.treeNodeByGeomId,
+                treeNodeByEntityId: this.treeNodeByEntityId,
+                loadedCesiumEntities: this.loadedCesiumEntities,
+                sourceMenuItemId: this.item.id
+            };
+            // Not routed through Dispose(), that would remove the tileset/regos just handed off.
+            this.cTileset = null;
+            this.disposed = true;
+            return payload;
+        }
+        // Takes ownership of a PrepareHandoff() payload instead of loading via Init().
+        // Then re-parents every already-registered rego to this menu item and re-runs styling.
+        AdoptHandoff(payload) {
+            var _a, _b, _c, _d;
+            this.cTileset = payload.cTileset;
+            this.tileset = payload.tileset;
+            this.rootId = payload.rootId;
+            this.modelTree = payload.modelTree;
+            this.treeNodeByGeomId = payload.treeNodeByGeomId;
+            this.treeNodeByEntityId = payload.treeNodeByEntityId;
+            this.loadedCesiumEntities = payload.loadedCesiumEntities;
+            this.renderPriority = this.item.renderPriority;
+            if (this.renderPriority == null) {
+                this.renderPriority = 0;
+            }
+            // Same visuals, same registrations - just re-keyed onto this menu item.
+            this.visualsManager.ReassignMenuItem({
+                fromMenuItemId: payload.sourceMenuItemId,
+                toMenuItemId: this.item.id,
+                toMenuItemType: this.item.Type,
+                toPriority: this.renderPriority,
+                requestRender: false
+            });
+            this.tileLoadRemoval = this.cTileset.tileLoad.addEventListener((tile) => {
+                try {
+                    this.queueTile(tile, true);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            });
+            this.tileUnloadRemoval = this.cTileset.tileUnload.addEventListener((tile) => {
+                try {
+                    this.queueTile(tile, false);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            });
+            this.onCTilesetLoad();
+            this.styler.Init({
+                viewer: this.viewer,
+                api: this.getters.GetBruceApi(),
+                cTileset: this.cTileset,
+                fallbackStyleId: this.item.styleId,
+                styleMapping: this.item.StyleMapping,
+                expandSources: (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.ExpandSources,
+                menuItemId: this.item.id,
+                register: this.visualsManager,
+                scenario: (_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b.Scenario,
+                historic: (_c = this.item.BruceEntity) === null || _c === void 0 ? void 0 : _c.historic,
+            });
+            this.queueHandoffRestyle(this.visualsManager.GetRegos({ menuItemId: this.item.id }));
+            this.viewer.scene.requestRender();
+            if (((_d = this.item.BruceEntity) === null || _d === void 0 ? void 0 : _d.historic) && this.tileset) {
+                this.viewerDateTimeSub(this.tileset);
+            }
+        }
+        queueHandoffRestyle(regos) {
+            if (!regos.length) {
+                return;
+            }
+            const BATCH_SIZE = 5000;
+            let index = 0;
+            this.handoffRestyleInterval = setInterval(() => {
+                if (this.disposed) {
+                    clearInterval(this.handoffRestyleInterval);
+                    this.handoffRestyleInterval = null;
+                    return;
+                }
+                const end = Math.min(index + BATCH_SIZE, regos.length);
+                this.styler.QueueEntities(regos.slice(index, end), true);
+                index = end;
+                if (index >= regos.length) {
+                    clearInterval(this.handoffRestyleInterval);
+                    this.handoffRestyleInterval = null;
+                }
+            }, 10);
+        }
         /**
          * @param tile
          * @param load indicates if we are loading or unloading the tile.
@@ -14144,7 +14503,7 @@ var TilesetCadRenderManager;
             }
             for (let i = 0; i < content.featuresLength; i++) {
                 const feature = content.getFeature(i);
-                if (!this.featureQueue.includes(feature)) {
+                if (!this.featureQueueStates.has(feature)) {
                     this.featureQueue.push(feature);
                 }
                 this.featureQueueStates.set(feature, load);
@@ -14681,6 +15040,10 @@ var TilesetCadRenderManager;
                 this.featureQueueInterval = null;
                 this.featureQueue = [];
             }
+            if (this.handoffRestyleInterval) {
+                clearInterval(this.handoffRestyleInterval);
+                this.handoffRestyleInterval = null;
+            }
             if (this.cTileset) {
                 const viewer = this.viewer;
                 if (!(viewer === null || viewer === void 0 ? void 0 : viewer.isDestroyed()) && this.viewer.scene.primitives.contains(this.cTileset)) {
@@ -17334,6 +17697,14 @@ var TilesetEntitiesRenderManager;
             this.initCounter = 0;
             this.disposed = false;
             this.cTileset = null;
+            // Kept around so a hand-off (see PrepareHandoff/AdoptHandoff) can pass it on without a re-fetch.
+            this.tileset = null;
+            // Removal callbacks for this instance's own tile stream listeners.
+            this.tileLoadRemoval = null;
+            this.tileUnloadRemoval = null;
+            // Chunks AdoptHandoff()'s restyle of handed-off content across ticks instead of one
+            // synchronous pass over potentially millions of regos.
+            this.handoffRestyleInterval = null;
             this.styler = new TilesetRenderEngine.Styler();
             // Entity ID -> rego.
             // We retain this information as a quick look-up on what has been registered.
@@ -17421,6 +17792,7 @@ var TilesetEntitiesRenderManager;
                     if (!tileset || this.disposed || counter !== this.initCounter) {
                         return;
                     }
+                    this.tileset = tileset;
                     this.typeId = tileset.settings.entityTypeId;
                     // Other account so we'll prefer the fallback entity-type ID if it's set.
                     if (accountId != this.getters.GetAccountId()) {
@@ -17469,7 +17841,7 @@ var TilesetEntitiesRenderManager;
                             console.error(e);
                         }
                     });
-                    cTileset.tileLoad.addEventListener((tile) => {
+                    this.tileLoadRemoval = cTileset.tileLoad.addEventListener((tile) => {
                         try {
                             this.queueTile(tile, true);
                         }
@@ -17477,7 +17849,7 @@ var TilesetEntitiesRenderManager;
                             console.error(e);
                         }
                     });
-                    cTileset.tileUnload.addEventListener((tile) => {
+                    this.tileUnloadRemoval = cTileset.tileUnload.addEventListener((tile) => {
                         try {
                             this.queueTile(tile, false);
                         }
@@ -17518,7 +17890,7 @@ var TilesetEntitiesRenderManager;
             }
             for (let i = 0; i < content.featuresLength; i++) {
                 const feature = content.getFeature(i);
-                if (!this.featureQueue.includes(feature)) {
+                if (!this.featureQueueStates.has(feature)) {
                     this.featureQueue.push(feature);
                 }
                 this.featureQueueStates.set(feature, load);
@@ -17637,6 +18009,10 @@ var TilesetEntitiesRenderManager;
                 this.featureQueueInterval = null;
                 this.featureQueue = [];
             }
+            if (this.handoffRestyleInterval) {
+                clearInterval(this.handoffRestyleInterval);
+                this.handoffRestyleInterval = null;
+            }
             if (this.cTileset) {
                 const viewer = this.viewer;
                 if (!(viewer === null || viewer === void 0 ? void 0 : viewer.isDestroyed()) && this.viewer.scene.primitives.contains(this.cTileset)) {
@@ -17657,6 +18033,141 @@ var TilesetEntitiesRenderManager;
                 this.viewer.zoomTo(this.cTileset, new HeadingPitchRange(0.0, -0.5, this.cTileset.boundingSphere.radius / 4.0));
             }
         }
+        // Two items resolving to the same key are eligible to hand off, regardless of styling.
+        get HandoffKey() {
+            return Manager.GetHandoffKey(this.item);
+        }
+        static GetHandoffKey(item) {
+            var _a, _b;
+            const tilesetId = (_a = item === null || item === void 0 ? void 0 : item.tileset) === null || _a === void 0 ? void 0 : _a.TilesetID;
+            if (!tilesetId) {
+                return null;
+            }
+            const accountId = ((_b = item.tileset) === null || _b === void 0 ? void 0 : _b.ClientAccountID) || "";
+            return `${accountId}:${tilesetId}`;
+        }
+        // Returns null (fall back to a normal Dispose()) if the tileset hasn't finished loading yet.
+        PrepareHandoff() {
+            var _a, _b;
+            if (this.disposed || !this.cTileset || this.cTileset.isDestroyed()) {
+                return null;
+            }
+            // Drain anything mid-flight - once handed off, this instance no longer owns the tile events.
+            while (this.featureQueue.length) {
+                this.processFeatureQueueBatch();
+            }
+            if (this.featureQueueInterval) {
+                clearInterval(this.featureQueueInterval);
+                this.featureQueueInterval = null;
+            }
+            if (this.handoffRestyleInterval) {
+                clearInterval(this.handoffRestyleInterval);
+                this.handoffRestyleInterval = null;
+            }
+            (_a = this.tileLoadRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_b = this.tileUnloadRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+            this.tileLoadRemoval = null;
+            this.tileUnloadRemoval = null;
+            const payload = {
+                cTileset: this.cTileset,
+                tileset: this.tileset,
+                typeId: this.typeId,
+                loadedCesiumEntities: this.loadedCesiumEntities,
+                sourceMenuItemId: this.item.id
+            };
+            // Not routed through Dispose() - that would remove the tileset/regos just handed off.
+            this.cTileset = null;
+            this.disposed = true;
+            return payload;
+        }
+        // Takes ownership of a PrepareHandoff() payload instead of loading via Init().
+        // Then re-parents every already-registered rego to this menu item and re-runs styling.
+        AdoptHandoff(payload) {
+            var _a;
+            this.cTileset = payload.cTileset;
+            this.tileset = payload.tileset;
+            this.typeId = payload.typeId;
+            this.loadedCesiumEntities = payload.loadedCesiumEntities;
+            this.renderPriority = this.item.renderPriority;
+            if (this.renderPriority == null) {
+                this.renderPriority = 0;
+            }
+            this.visualsManager.ReassignMenuItem({
+                fromMenuItemId: payload.sourceMenuItemId,
+                toMenuItemId: this.item.id,
+                toMenuItemType: this.item.Type,
+                toPriority: this.renderPriority,
+                requestRender: false
+            });
+            this.tileLoadRemoval = this.cTileset.tileLoad.addEventListener((tile) => {
+                try {
+                    this.queueTile(tile, true);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            });
+            this.tileUnloadRemoval = this.cTileset.tileUnload.addEventListener((tile) => {
+                try {
+                    this.queueTile(tile, false);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            });
+            if (this.item.ApplyStyles) {
+                this.styler.Init({
+                    viewer: this.viewer,
+                    api: this.getters.GetBruceApi(),
+                    cTileset: this.cTileset,
+                    fallbackStyleId: this.item.styleId,
+                    styleMapping: [],
+                    expandSources: false,
+                    menuItemId: this.item.id,
+                    register: this.visualsManager,
+                    historic: (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic
+                });
+                this.queueHandoffRestyle(this.visualsManager.GetRegos({ menuItemId: this.item.id }));
+            }
+            this.onCTilesetLoad();
+            let attenuation = this.item.attenuation;
+            if (!attenuation && attenuation != false) {
+                attenuation = true;
+            }
+            let attenuationMax = this.item.attenuationMax;
+            if (isNaN(attenuationMax)) {
+                attenuationMax = 20;
+            }
+            TilesetRenderEngine.ApplySettings({
+                cTileset: this.cTileset,
+                settings: {
+                    attenuation: attenuation,
+                    maximumAttenuation: attenuationMax
+                }
+            });
+            this.viewer.scene.requestRender();
+        }
+        queueHandoffRestyle(regos) {
+            if (!regos.length) {
+                return;
+            }
+            const BATCH_SIZE = 5000;
+            let index = 0;
+            this.handoffRestyleInterval = setInterval(() => {
+                if (this.disposed) {
+                    clearInterval(this.handoffRestyleInterval);
+                    this.handoffRestyleInterval = null;
+                    return;
+                }
+                const end = Math.min(index + BATCH_SIZE, regos.length);
+                this.styler.QueueEntities(regos.slice(index, end), true);
+                index = end;
+                if (index >= regos.length) {
+                    clearInterval(this.handoffRestyleInterval);
+                    this.handoffRestyleInterval = null;
+                }
+            }, 10);
+        }
         mapTilesetFeature(feature) {
             var _a, _b, _c;
             this.evaluateFeatureProps(feature);
@@ -18498,7 +19009,7 @@ var TilesetArbRenderManager;
             }
             for (let i = 0; i < content.featuresLength; i++) {
                 const feature = content.getFeature(i);
-                if (!this.featureQueue.includes(feature)) {
+                if (!this.featureQueueStates.has(feature)) {
                     this.featureQueue.push(feature);
                 }
                 this.featureQueueStates.set(feature, load);
@@ -21226,6 +21737,7 @@ var MenuItemManager;
         }
         constructor(params) {
             this.items = [];
+            this.pendingHandoffPool = [];
             this.onUpdate = null;
             let { viewer, visualsRegister, getters } = params;
             this.viewer = viewer;
@@ -21249,7 +21761,7 @@ var MenuItemManager;
          * This will dispose all render managers and unregister all menu items.
          */
         Dispose(params) {
-            var _a;
+            var _a, _b;
             const { disposeRegister } = params !== null && params !== void 0 ? params : {};
             for (let i = 0; i < this.items.length; i++) {
                 const item = this.items[i];
@@ -21261,7 +21773,9 @@ var MenuItemManager;
                 }
             }
             this.items = [];
+            this.FlushPendingHandoffs();
             this.tilesetInitQueue.Dispose();
+            (_b = this.sharedMonitor) === null || _b === void 0 ? void 0 : _b.Dispose();
             if (this.visualsRegister && disposeRegister != false) {
                 this.visualsRegister.Dispose();
             }
@@ -21610,8 +22124,14 @@ var MenuItemManager;
                         console.error("Menu item type is not implemented.", params.item.Type);
                 }
                 if (rItem.renderManager && !rItem.renderManager.Disposed) {
+                    const handoffPayload = this.tryClaimHandoffPayload(params.item, rItem.renderManager);
                     try {
-                        rItem.renderManager.Init();
+                        if (handoffPayload) {
+                            rItem.renderManager.AdoptHandoff(handoffPayload);
+                        }
+                        else {
+                            rItem.renderManager.Init();
+                        }
                     }
                     catch (e) {
                         rItem.errors.push(e);
@@ -21642,7 +22162,7 @@ var MenuItemManager;
          */
         RemoveItemById(params) {
             var _a, _b;
-            let { menuItemId: id, recursive } = params;
+            let { menuItemId: id, recursive, allowHandoff } = params;
             if (this.viewer.isDestroyed()) {
                 return;
             }
@@ -21656,19 +22176,79 @@ var MenuItemManager;
                         const child = this.items.find(x => x.id === item.childIds[i]);
                         if (child) {
                             this.RemoveItemById({
-                                menuItemId: child.id
+                                menuItemId: child.id,
+                                allowHandoff
                             });
                         }
                     }
                 }
+                if (allowHandoff && this.isHandoffCapable(item.renderManager)) {
+                    this.pendingHandoffPool.push(item);
+                }
+                else {
+                    try {
+                        (_a = item.renderManager) === null || _a === void 0 ? void 0 : _a.Dispose();
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+                this.items = this.items.filter(x => x.id !== id);
+                (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Trigger({ isEnabling: false, itemId: item.id });
+            }
+        }
+        isHandoffCapable(renderManager) {
+            return Boolean(renderManager) && typeof renderManager.PrepareHandoff === "function";
+        }
+        // Resolves the hand-off key a menu item's data would have.
+        computeHandoffKey(item) {
+            if (item.Type === MenuItem.EType.CadTileset) {
+                return TilesetCadRenderManager.Manager.GetHandoffKey(item);
+            }
+            if (item.Type === MenuItem.EType.EntityTileset) {
+                return TilesetEntitiesRenderManager.Manager.GetHandoffKey(item);
+            }
+            return null;
+        }
+        // Claims a pooled manager for the same resource, if one exists and both sides opt in.
+        // Returns null (meaning: construct normally via Init()) otherwise.
+        tryClaimHandoffPayload(item, newManager) {
+            if (typeof newManager.AdoptHandoff !== "function") {
+                return null;
+            }
+            const key = this.computeHandoffKey(item);
+            if (!key) {
+                return null;
+            }
+            const poolIndex = this.pendingHandoffPool.findIndex(pooled => pooled.type === item.Type &&
+                this.isHandoffCapable(pooled.renderManager) &&
+                pooled.renderManager.HandoffKey === key);
+            if (poolIndex < 0) {
+                return null;
+            }
+            const pooled = this.pendingHandoffPool[poolIndex].renderManager;
+            const payload = pooled.PrepareHandoff();
+            if (!payload) {
+                return null;
+            }
+            this.pendingHandoffPool.splice(poolIndex, 1);
+            return payload;
+        }
+        // Disposes everything left unclaimed in the pending-hand-off pool.
+        FlushPendingHandoffs() {
+            var _a;
+            if (!this.pendingHandoffPool.length) {
+                return;
+            }
+            const pool = this.pendingHandoffPool;
+            this.pendingHandoffPool = [];
+            for (const item of pool) {
                 try {
                     (_a = item.renderManager) === null || _a === void 0 ? void 0 : _a.Dispose();
                 }
                 catch (e) {
                     console.error(e);
                 }
-                this.items = this.items.filter(x => x.id !== id);
-                (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Trigger({ isEnabling: false, itemId: item.id });
             }
         }
         GetEnabledItemIds() {
@@ -24689,7 +25269,8 @@ async function renderLegacyNavigator(iteration, params, bookmark, view) {
         if (newItemIds.indexOf(id) === -1 ||
             id == RELATION_MENU_ITEM_ID) {
             params.manager.RemoveItemById({
-                menuItemId: id
+                menuItemId: id,
+                allowHandoff: true
             });
         }
     }
@@ -24704,6 +25285,8 @@ async function renderLegacyNavigator(iteration, params, bookmark, view) {
         if (!assertIteration$1(params.viewer, iteration)) {
             return;
         }
+        // Deferred removals not claimed via a hand-off can now be disposed for real.
+        manager.FlushPendingHandoffs();
     }
     if ((_e = bSettings === null || bSettings === void 0 ? void 0 : bSettings.drawnRelationEntityIDs) === null || _e === void 0 ? void 0 : _e.length) {
         const menuItem = {
@@ -25228,7 +25811,8 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
         }
         if (shouldRemove) {
             params.manager.RemoveItemById({
-                menuItemId: id
+                menuItemId: id,
+                allowHandoff: true
             });
         }
     }
@@ -25242,6 +25826,8 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
         if (!assertIteration$1(params.viewer, iteration)) {
             return;
         }
+        // Deferred removals not claimed via a hand-off can now be disposed for real.
+        params.manager.FlushPendingHandoffs();
     }
     if (legacyRelationIds.length || relations.length) {
         if (relations.length) {
@@ -30661,25 +31247,27 @@ const getLocationFromFeature = (feature) => {
     var _a;
     const prepareLatitude = (propName, value) => {
         value = +value;
-        // Check to see if the lat is in valid degrees, if not, try convert from radians.
+        // Check to see if the lat is in valid degrees, if not, convert from radians.
         if (value < -90 || value > 90) {
-            value = Math$1.toDegrees(value);
+            return Math$1.toDegrees(value);
         }
         // If the value is really small we'll assume it's in radians.
         // "cesium#blah" properties are always in degrees. No need to check.
-        if (value < 0.9 && !propName.startsWith("cesium#")) {
+        // (Only reached when the value wasn't already converted above, to avoid double-converting.)
+        if (value < 0.9 && value > -0.9 && !propName.startsWith("cesium#")) {
             value = Math$1.toDegrees(value);
         }
         return value;
     };
     const prepareLongitude = (propName, value) => {
         value = +value;
-        // Check to see if the lon is in valid degrees, if not, try convert from radians.
+        // Check to see if the lon is in valid degrees, if not, convert from radians.
         if (value < -180 || value > 180) {
-            value = Math$1.toDegrees(value);
+            return Math$1.toDegrees(value);
         }
         // If the value is really small we'll assume it's in radians.
         // "cesium#blah" properties are always in degrees. No need to check.
+        // (Only reached when the value wasn't already converted above, to avoid double-converting.)
         if (value < 0.9 && value > -0.9 && !propName.startsWith("cesium#")) {
             value = Math$1.toDegrees(value);
         }
@@ -31361,6 +31949,84 @@ var EntityUtils;
         catch (e) {
             console.error(e);
         }
+        // Some records may still not be expanded.
+        // We have to detect whatever is an Assembly Entity and expand it.
+        try {
+            const needsExpansion = recordSamples.filter(x => {
+                const assemblyPos = Entity$1.GetValue({
+                    entity: x.entity,
+                    path: ["Bruce", "AssemblyPosition"]
+                });
+                if (!assemblyPos) {
+                    return false;
+                }
+                const rootPos = Entity$1.GetValue({
+                    entity: x.entity,
+                    path: ["Bruce", "AssemblyRootPosition"]
+                });
+                return !rootPos;
+            });
+            if (needsExpansion.length) {
+                const EXPAND_BATCH_SIZE = 30;
+                const EXPAND_MAX_IDS = 200;
+                // Figure out if any are in the scene.
+                // Helps us sort leaf-nodes away from category nodes thta don't have geometry.
+                const isInScene = (sample) => {
+                    var _a;
+                    return !!(visualRegister && visualRegister.GetRego({
+                        entityId: (_a = sample.entityId) !== null && _a !== void 0 ? _a : sample.entity.Bruce.ID,
+                        menuItemId: sample.menuItemId
+                    }));
+                };
+                // Trim to max 200 with a preference to those in the scene.
+                const sceneSamples = needsExpansion.filter(isInScene);
+                const offSceneSamples = sceneSamples.length ? needsExpansion.filter(x => !isInScene(x)) : [];
+                if (offSceneSamples.length) {
+                    const offSceneIds = new Set(offSceneSamples.map(x => x.entity.Bruce.ID));
+                    recordSamples = recordSamples.filter(x => !offSceneIds.has(x.entity.Bruce.ID));
+                }
+                const effectiveSamples = sceneSamples.length ? sceneSamples : needsExpansion;
+                const uniqueIds = Array.from(new Set(effectiveSamples.map(x => x.entity.Bruce.ID)));
+                const expandIds = uniqueIds.slice(0, EXPAND_MAX_IDS);
+                // Anything we didn't expand will taint the overall result so we have to filter them out.
+                const droppedIds = new Set(uniqueIds.slice(EXPAND_MAX_IDS));
+                if (droppedIds.size) {
+                    recordSamples = recordSamples.filter(x => !droppedIds.has(x.entity.Bruce.ID));
+                }
+                const expandedMap = new Map();
+                const batches = [];
+                for (let i = 0; i < expandIds.length; i += EXPAND_BATCH_SIZE) {
+                    batches.push(expandIds.slice(i, i + EXPAND_BATCH_SIZE));
+                }
+                const batchResults = await Promise.all(batches.map(batchIds => Entity$1.GetListByIds({
+                    entityIds: batchIds,
+                    historicPoint: latestDate,
+                    expandLocation: true,
+                    expandSources: true,
+                    migrated: true,
+                    maxSearchTimeSec: 60 * 2,
+                    api
+                }).catch(e => {
+                    console.error(e);
+                    return { entities: [] };
+                })));
+                for (const { entities } of batchResults) {
+                    for (let i = 0; i < entities.length; i++) {
+                        expandedMap.set(entities[i].Bruce.ID, entities[i]);
+                    }
+                }
+                for (let i = 0; i < effectiveSamples.length; i++) {
+                    const sample = effectiveSamples[i];
+                    const expanded = expandedMap.get(sample.entity.Bruce.ID);
+                    if (expanded) {
+                        sample.entity = expanded;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
         for (let i = 0; i < recordSamples.length; i++) {
             const sample = recordSamples[i];
             const samplePosses = await getRecordEntityPositions(sample);
@@ -36516,7 +37182,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "6.7.8";
+const VERSION = "6.8.0";
 /**
  * Updates the environment instance used by bruce-cesium to one specified.
  * This can be used to ensure that the instance a parent is referencing is shared between bruce-cesium, bruce-models, and the parent app.