bruce-cesium 6.7.9 → 6.8.0

package/dist/bruce-cesium.umd.js

@@ -6516,6 +6516,18 @@
                 this.id = BModels.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.
@@ -6523,6 +6535,8 @@
                 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 = {};
@@ -6533,6 +6547,42 @@
                     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;
@@ -6565,7 +6615,8 @@
                 }
                 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();
                 }
@@ -6586,6 +6637,7 @@
                         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;
@@ -6698,6 +6750,8 @@
             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;
@@ -6730,8 +6784,9 @@
                 };
                 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;
                     }
@@ -6766,7 +6821,7 @@
                         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
@@ -6796,12 +6851,18 @@
              * 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;
@@ -6972,18 +7033,68 @@
                 }
                 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) => {
@@ -6994,76 +7105,16 @@
                         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({
@@ -7073,6 +7124,77 @@
                 }
                 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.
@@ -7088,9 +7210,8 @@
                     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];
@@ -7156,6 +7277,9 @@
                 this.cameraCullerDispose = null;
                 clearInterval(this.updateQueueInterval);
                 this.updateQueueInterval = null;
+                clearInterval(this.lazyOverrideInterval);
+                this.lazyOverrideInterval = null;
+                this.lazyOverrideActive = false;
                 this.disposed = true;
             }
             ForceUpdate(params) {
@@ -7225,12 +7349,15 @@
              */
             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);
                     }
                 });
@@ -7358,11 +7485,12 @@
             }
             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,
@@ -7370,13 +7498,13 @@
                     });
                     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)) {
                             exports.CesiumEntityStyler.Deselect({
                                 entity: rego.visual,
                                 viewer: this.viewer,
                                 requestRender: false
                             });
-                            cleared.push(rego);
+                            cleared.add(rego);
                         }
                     }
                 });
@@ -7489,10 +7617,13 @@
                 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);
                         }
                     }
@@ -7581,7 +7712,10 @@
                 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().
@@ -7602,10 +7736,15 @@
                 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
@@ -7656,10 +7795,11 @@
                 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
@@ -7695,6 +7835,7 @@
                 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.
@@ -7718,6 +7859,74 @@
                     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.
@@ -7828,7 +8037,10 @@
                 // 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);
@@ -7850,6 +8062,7 @@
                             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,
@@ -7902,6 +8115,7 @@
                             (_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,
@@ -7924,7 +8138,11 @@
                             });
                             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,
@@ -7936,7 +8154,7 @@
                             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
@@ -7953,68 +8171,68 @@
              * @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)) {
-                                exports.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.
+                        exports.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)
                 };
             }
             /**
@@ -8170,16 +8388,17 @@
                 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;
                 });
@@ -13786,6 +14005,14 @@
                 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 exports.TilesetRenderEngine.Styler();
                 this.modelTreeUpdate = new BModels.BruceEvent();
                 // Quick look-up of the model tree nodes by entity/geomId.
@@ -13892,6 +14119,7 @@
                     if (!tileset || this.disposed) {
                         return;
                     }
+                    this.tileset = tileset;
                     if (!api) {
                         api = this.getters.GetBruceApi({
                             accountId: accountId
@@ -14058,7 +14286,7 @@
                             console.error(e);
                         }
                     });
-                    cTileset.tileLoad.addEventListener((tile) => {
+                    this.tileLoadRemoval = cTileset.tileLoad.addEventListener((tile) => {
                         try {
                             this.queueTile(tile, true);
                         }
@@ -14066,7 +14294,7 @@
                             console.error(e);
                         }
                     });
-                    cTileset.tileUnload.addEventListener((tile) => {
+                    this.tileUnloadRemoval = cTileset.tileUnload.addEventListener((tile) => {
                         try {
                             this.queueTile(tile, false);
                         }
@@ -14086,6 +14314,137 @@
                     this.viewer.zoomTo(this.cTileset, new Cesium.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.
@@ -14098,7 +14457,7 @@
                 }
                 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);
@@ -14635,6 +14994,10 @@
                     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)) {
@@ -17282,6 +17645,14 @@
                 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 exports.TilesetRenderEngine.Styler();
                 // Entity ID -> rego.
                 // We retain this information as a quick look-up on what has been registered.
@@ -17369,6 +17740,7 @@
                         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()) {
@@ -17417,7 +17789,7 @@
                                 console.error(e);
                             }
                         });
-                        cTileset.tileLoad.addEventListener((tile) => {
+                        this.tileLoadRemoval = cTileset.tileLoad.addEventListener((tile) => {
                             try {
                                 this.queueTile(tile, true);
                             }
@@ -17425,7 +17797,7 @@
                                 console.error(e);
                             }
                         });
-                        cTileset.tileUnload.addEventListener((tile) => {
+                        this.tileUnloadRemoval = cTileset.tileUnload.addEventListener((tile) => {
                             try {
                                 this.queueTile(tile, false);
                             }
@@ -17466,7 +17838,7 @@
                 }
                 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);
@@ -17585,6 +17957,10 @@
                     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)) {
@@ -17605,6 +17981,141 @@
                     this.viewer.zoomTo(this.cTileset, new Cesium.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;
+                }
+                exports.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);
@@ -18439,7 +18950,7 @@
                 }
                 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);
@@ -21153,6 +21664,7 @@
             }
             constructor(params) {
                 this.items = [];
+                this.pendingHandoffPool = [];
                 this.onUpdate = null;
                 let { viewer, visualsRegister, getters } = params;
                 this.viewer = viewer;
@@ -21176,7 +21688,7 @@
              * 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];
@@ -21188,7 +21700,9 @@
                     }
                 }
                 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();
                 }
@@ -21537,8 +22051,14 @@
                             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);
@@ -21569,7 +22089,7 @@
              */
             RemoveItemById(params) {
                 var _a, _b;
-                let { menuItemId: id, recursive } = params;
+                let { menuItemId: id, recursive, allowHandoff } = params;
                 if (this.viewer.isDestroyed()) {
                     return;
                 }
@@ -21583,19 +22103,79 @@
                             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 === BModels.MenuItem.EType.CadTileset) {
+                    return exports.TilesetCadRenderManager.Manager.GetHandoffKey(item);
+                }
+                if (item.Type === BModels.MenuItem.EType.EntityTileset) {
+                    return exports.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() {
@@ -24605,7 +25185,8 @@
             if (newItemIds.indexOf(id) === -1 ||
                 id == RELATION_MENU_ITEM_ID) {
                 params.manager.RemoveItemById({
-                    menuItemId: id
+                    menuItemId: id,
+                    allowHandoff: true
                 });
             }
         }
@@ -24620,6 +25201,8 @@
             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 = {
@@ -25144,7 +25727,8 @@
             }
             if (shouldRemove) {
                 params.manager.RemoveItemById({
-                    menuItemId: id
+                    menuItemId: id,
+                    allowHandoff: true
                 });
             }
         }
@@ -25158,6 +25742,8 @@
             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) {
@@ -36474,7 +37060,7 @@
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "6.7.9";
+    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.