bruce-cesium 7.0.1 → 7.0.3

package/dist/bruce-cesium.umd.js

@@ -21,6 +21,28 @@
         }
         return value;
     }
+    /**
+     * Returns an entity's own name when it is good enough to use as-is, or null when it has to be resolved properly.
+     * @param entity
+     */
+    function GetUsableEntityName(entity) {
+        var _a;
+        return IsUsableEntityName((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.Name) ? String(entity.Bruce.Name).trim() : null;
+    }
+    /**
+     * Returns whether a name is a real one rather than empty or a placeholder.
+     * @param name
+     */
+    function IsUsableEntityName(name) {
+        if (typeof name !== "string") {
+            return false;
+        }
+        const trimmed = name.trim();
+        if (!trimmed) {
+            return false;
+        }
+        return !trimmed.toLowerCase().includes("unnamed");
+    }
 
     (function (MeasureUtils) {
         /**
@@ -1955,7 +1977,11 @@
                 }
             }
             else if (graphic instanceof Cesium.CorridorGraphics) {
-                graphic.material = new Cesium.ColorMaterialProperty(color);
+                // See if it's changed before applying, same flicker/rebuild concern as the polyline above.
+                const currentColor = calculateCurColor(viewer, graphic);
+                if (currentColor == null || !currentColor.equals(color)) {
+                    graphic.material = new Cesium.ColorMaterialProperty(color);
+                }
             }
             else if (graphic instanceof Cesium.PointGraphics) {
                 const animateColor = new exports.CesiumAnimatedProperty.AnimateColor({
@@ -2198,11 +2224,11 @@
          * @returns
          */
         function SetDefaultColor(params) {
-            const { viewer, entity, requestRender, override } = params;
+            const { viewer, entity, requestRender, override, includeSiblings } = params;
             if (!entity) {
                 return;
             }
-            const parts = exports.EntityUtils.GatherEntity({
+            const parts = includeSiblings == false ? [entity] : exports.EntityUtils.GatherEntity({
                 entity: entity,
                 selectable: true
             });
@@ -3835,6 +3861,202 @@
         }
         return obj;
     }
+    /*
+     * Marks an EntityCollection as one this library created and fully controls (a menu item's own data source).
+     */
+    const OWNED_CCOLLECTION_KEY = "_bruceOwnedCollection";
+    function MarkCCollectionOwned(collection) {
+        if (collection) {
+            collection[OWNED_CCOLLECTION_KEY] = true;
+        }
+    }
+    function IsCCollectionOwned(collection) {
+        return Boolean(collection && collection[OWNED_CCOLLECTION_KEY]);
+    }
+    /**
+     * Runs a bulk collection mutation with every given collection's events suspended, so Cesium raises one
+     * collectionChanged per collection for the whole pass instead of one per entity.
+     *
+     * Takes a set of collections rather than assuming `viewer.entities`, because managed visuals live in their menu
+     * item's own data source: suspending the wrong collection silently does nothing.
+     * @param collections Duplicates and empty entries are ignored.
+     * @param run
+     */
+    function WithSuspendedCCollections(collections, run) {
+        const unique = [];
+        for (const collection of collections) {
+            if (collection && unique.indexOf(collection) === -1) {
+                unique.push(collection);
+            }
+        }
+        for (const collection of unique) {
+            collection.suspendEvents();
+        }
+        try {
+            return run();
+        }
+        finally {
+            for (const collection of unique) {
+                try {
+                    collection.resumeEvents();
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+        }
+    }
+    /**
+     * Returns the collection a graphic belongs to, falling back to the viewer's own when it has never been added.
+     * @param viewer
+     * @param entity
+     */
+    function GetCEntityCollection(viewer, entity) {
+        const owner = entity === null || entity === void 0 ? void 0 : entity.entityCollection;
+        return owner ? owner : viewer === null || viewer === void 0 ? void 0 : viewer.entities;
+    }
+    /**
+     * Returns whether a graphic is currently in the scene, looking in whichever collection owns it.
+     * @param viewer
+     * @param entity
+     */
+    function IsCEntityInScene(viewer, entity) {
+        const collection = GetCEntityCollection(viewer, entity);
+        return Boolean(collection && entity && collection.contains(entity));
+    }
+    /**
+     * Removes a graphic from whichever collection owns it. Returns whether it removed anything.
+     * @param viewer
+     * @param entity
+     */
+    function RemoveCEntityFromScene(viewer, entity) {
+        var _a;
+        if (!entity) {
+            return false;
+        }
+        const collection = GetCEntityCollection(viewer, entity);
+        if (collection === null || collection === void 0 ? void 0 : collection.contains(entity)) {
+            return collection.remove(entity);
+        }
+        // A stale owner reference and the graphic ended up in the viewer's collection anyway.
+        if (collection !== (viewer === null || viewer === void 0 ? void 0 : viewer.entities) && ((_a = viewer === null || viewer === void 0 ? void 0 : viewer.entities) === null || _a === void 0 ? void 0 : _a.contains(entity))) {
+            return viewer.entities.remove(entity);
+        }
+        return false;
+    }
+    /**
+     * Adds a graphic back into whichever collection owns it, or the viewer's if it has no owner yet.
+     * @param viewer
+     * @param entity
+     */
+    function AddCEntityToScene(viewer, entity, fallbackCollection) {
+        if (!entity) {
+            return false;
+        }
+        // An existing owner always wins, so a graphic is never migrated out from under whoever holds it.
+        const owner = entity.entityCollection;
+        const collection = owner ? owner : (fallbackCollection ? fallbackCollection : viewer === null || viewer === void 0 ? void 0 : viewer.entities);
+        if (!collection || collection.contains(entity)) {
+            return false;
+        }
+        collection.add(entity);
+        return true;
+    }
+    /**
+     * Returns whether toggling `show` on these graphics is safe, rather than having to add/remove them from the
+     * entity collection to hide them.
+     *
+     * Toggling show is far cheaper than re-adding the graphic to the viewer however a Cesium bug means we can't always use it.
+     * See: https://github.com/CesiumGS/cesium/issues/9370
+     * @param parts The graphic and any sibling graphics, eg. from EntityUtils.GatherEntity.
+     */
+    function CanToggleShowSafely(parts) {
+        if (!(parts === null || parts === void 0 ? void 0 : parts.length)) {
+            return false;
+        }
+        for (const part of parts) {
+            if (!(part instanceof Cesium.Entity)) {
+                // Not an Entity, so not something whose `show` we can drive.
+                return false;
+            }
+            if (part.polyline && isTruthyCValue(part.polyline.clampToGround)) {
+                return false;
+            }
+            const materialGraphics = [part.polygon, part.corridor, part.ellipse, part.rectangle, part.wall, part.polylineVolume];
+            for (const graphic of materialGraphics) {
+                if (graphic && !isPlainColorMaterial(graphic.material)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * Returns whether a material is a plain colour, which is what keeps a graphic out of Cesium's per-material batches.
+     * Anything unrecognised counts as not plain, so callers stay on the conservative side.
+     * @param material
+     */
+    function isPlainColorMaterial(material) {
+        if (material == null) {
+            // Cesium defaults an absent material to white, a plain colour.
+            return true;
+        }
+        return material instanceof Cesium.ColorMaterialProperty || material instanceof Cesium.Color;
+    }
+    /**
+     * Resolves a possibly-property boolean without needing a viewer clock, treating anything undeterminable as true
+     * so callers stay on the conservative side.
+     * @param value
+     */
+    function isTruthyCValue(value) {
+        if (value == null) {
+            return false;
+        }
+        if (typeof value.getValue === "function") {
+            if (value instanceof Cesium.ConstantProperty) {
+                return Boolean(value.valueOf());
+            }
+            // A non-constant property could be true at any moment, so assume it is.
+            return true;
+        }
+        return Boolean(value);
+    }
+    /**
+     * Returns if two resolved Cesium property values are equal, using the value's own equals() when it has one.
+     * @param a
+     * @param b
+     */
+    function AreCValuesEqual(a, b) {
+        if (a === b) {
+            return true;
+        }
+        // One side is null/undefined and the other isn't.
+        if (a == null || b == null) {
+            return false;
+        }
+        if (typeof a.equals === "function") {
+            return a.equals(b) === true;
+        }
+        return false;
+    }
+    /**
+     * Wraps a value in a ConstantProperty and assigns it to a graphic's property, but only when the resolved
+     * value actually differs. Returns whether it assigned.
+     * @param params
+     */
+    function SetCPropIfChanged(params) {
+        const { viewer, graphic, property, value, compare } = params;
+        if (!graphic) {
+            return false;
+        }
+        const oldValue = GetCValue(viewer, graphic[property]);
+        const isEqual = compare ? compare(oldValue, value) : AreCValuesEqual(oldValue, value);
+        if (isEqual) {
+            return false;
+        }
+        graphic[property] = new Cesium.ConstantProperty(value);
+        return true;
+    }
     function ColorToCColor(color) {
         return new Cesium.Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
     }
@@ -4322,6 +4544,85 @@
         ViewUtils.GetModelSpace = GetModelSpace;
     })(exports.ViewUtils || (exports.ViewUtils = {}));
 
+    /*
+     * Lets something decide WHEN a `show` flag is honoured, without owning WHAT it should be.
+     */
+    const SHOW_GATE_KEY = "_bruceShowGate";
+    /**
+     * Installs a show gate on an object, or returns the one already installed.
+     * Returns null when the property cannot be intercepted or restored, in which case the caller must leave `show` alone rather than fall back to writing it directly.
+     * @param target Anything with a plain, configurable `show` property.
+     */
+    function InstallShowGate(target) {
+        if (!target) {
+            return null;
+        }
+        const existing = target[SHOW_GATE_KEY];
+        if (existing) {
+            return existing;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(target, "show");
+        // An accessor already, or something we could not put back, so refuse rather than half-apply.
+        if (descriptor && (!descriptor.configurable || descriptor.get || descriptor.set)) {
+            return null;
+        }
+        let intended = target.show !== false;
+        let suppressed = false;
+        try {
+            Object.defineProperty(target, "show", {
+                configurable: true,
+                enumerable: descriptor ? descriptor.enumerable : true,
+                get: () => intended && !suppressed,
+                set: (value) => {
+                    intended = value !== false;
+                }
+            });
+        }
+        catch (e) {
+            console.error("Failed to install a show gate.", e);
+            return null;
+        }
+        const gate = {
+            get Intended() {
+                return intended;
+            },
+            get Suppressed() {
+                return suppressed;
+            },
+            SetSuppressed(value) {
+                const next = Boolean(value);
+                if (next === suppressed) {
+                    return false;
+                }
+                const before = intended && !suppressed;
+                suppressed = next;
+                return (intended && !suppressed) !== before;
+            },
+            Release() {
+                try {
+                    delete target[SHOW_GATE_KEY];
+                    Object.defineProperty(target, "show", {
+                        configurable: true,
+                        enumerable: descriptor ? descriptor.enumerable : true,
+                        writable: true,
+                        // The intent, not the gated value: releasing must not leave something culled forever.
+                        value: intended
+                    });
+                }
+                catch (e) {
+                    console.error("Failed to release a show gate.", e);
+                }
+            }
+        };
+        Object.defineProperty(target, SHOW_GATE_KEY, {
+            value: gate,
+            configurable: true,
+            enumerable: false,
+            writable: true
+        });
+        return gate;
+    }
+
     /**
      * Returns cesium property's value.
      * This will check if it's one that changes over time, or just a fixed value.
@@ -4395,10 +4696,17 @@
              * Loads the Entity's name and updates the corresponding visual rego.
              */
             async loadName() {
+                var _a;
                 if (this.loadedName) {
                     return;
                 }
                 try {
+                    // A rego that already holds a real name needs no lookup. Placeholders do not count, or a cached
+                    // "Unnamed Entity" would stop the real name ever being resolved.
+                    if (IsUsableEntityName((_a = this.rego) === null || _a === void 0 ? void 0 : _a.name)) {
+                        this.loadedName = true;
+                        return;
+                    }
                     if (this.api) {
                         const rego = this.rego;
                         this.rego.name = await BModels.Entity.CalculateNameAsync({
@@ -5585,7 +5893,7 @@
                         return;
                     }
                     if (parabola) {
-                        const visible = cEntity && cEntity.show != false && params.viewer.entities.contains(cEntity);
+                        const visible = cEntity && cEntity.show != false && IsCEntityInScene(params.viewer, cEntity);
                         parabola.Hidden = !visible;
                     }
                     updatePosses();
@@ -5613,18 +5921,58 @@
     // If a shape has more than this amount of points, we'll avoid checking it because it will take too long.
     // We will put responsibility on the bookmark creator to view shapes they can see.
     const DO_NOT_CULL_AT_LEN_POINTS = 5000;
-    // Returns terrain height at a given position.
-    // This will cache the results based on the terrain provider and position.
-    const _terrainCache = new BModels.LRUCache(1000);
-    // Positions within this tolerance from each-other will be re-used.
-    const TERRAIN_HEIGHT_TOLERANCE = 400;
-    // Tolerance to use when number of entities is lower than x in the scene.
-    const TERRAIN_HEIGHT_TOLERANCE_LOW_COUNT = 30;
-    const TERRAIN_HEIGHT_TOLERANCE_LOW_ENTITY_THRESHOLD = 100;
+    const _terrainCache = new BModels.LRUCache(20000);
+    /*
+     * Past this camera distance the terrain sample is skipped entirely (resolving a long-standing TODO here).
+     * The sphere's radius is padded by TERRAIN_SKIP_RADIUS_PAD instead, which covers any plausible unresolved ground height.
+     */
+    const TERRAIN_SKIP_DISTANCE = 60000;
+    const TERRAIN_SKIP_RADIUS_PAD = 1500;
+    // Edge length of a coarse grid cell, and of the finer cell used where the ground turns out to be varied.
+    const TERRAIN_CELL_SIZE = 400;
+    const TERRAIN_CELL_SIZE_FINE = 50;
+    // A cell spanning more than this much height cannot be answered with a single average.
+    const TERRAIN_CELL_MAX_SPREAD = 25;
+    /**
+     * Builds the grid key for a position at a given cell size.
+     */
+    function terrainCellKey(terrainId, pos3d, cellSize) {
+        const x = Math.floor(pos3d.x / cellSize);
+        const y = Math.floor(pos3d.y / cellSize);
+        const z = Math.floor(pos3d.z / cellSize);
+        return `${terrainId}_${cellSize}_${x}_${y}_${z}`;
+    }
+    /**
+     * Folds a sample into a cell, refining its estimate and noticing when the region is too varied to average.
+     */
+    function recordTerrainSample(key, height) {
+        const existing = _terrainCache.Get(key);
+        if (!existing) {
+            const cell = {
+                offset: height,
+                count: 1,
+                min: height,
+                max: height,
+                needsDetail: false
+            };
+            _terrainCache.Set(key, cell);
+            return cell;
+        }
+        existing.count++;
+        // Running mean, so the estimate keeps improving rather than being whatever landed first.
+        existing.offset += (height - existing.offset) / existing.count;
+        existing.min = Math.min(existing.min, height);
+        existing.max = Math.max(existing.max, height);
+        if (existing.max - existing.min > TERRAIN_CELL_MAX_SPREAD) {
+            existing.needsDetail = true;
+        }
+        _terrainCache.Set(key, existing);
+        return existing;
+    }
     /**
      * Returns the terrain height for a given position.
      * This will not sample most-detailed and instead the current state of the terrain.
-     * TODO: If something is VERY far from the camera, we should just return 0.
+     * Callers past TERRAIN_SKIP_DISTANCE should not be asking at all, see shouldCullEntity.
      * @param viewer
      * @param pos3d
      * @returns
@@ -5641,37 +5989,36 @@
             return 0;
         }
         const terrainId = terrain.tilesetId;
-        // Check for existing values within TOLERANCE distance.
-        const keys = Array.from(_terrainCache.Entries());
-        const tolerance = viewer.entities.values.length > TERRAIN_HEIGHT_TOLERANCE_LOW_ENTITY_THRESHOLD ? TERRAIN_HEIGHT_TOLERANCE : TERRAIN_HEIGHT_TOLERANCE_LOW_COUNT;
-        for (let i = 0; i < keys.length; i++) {
-            const [key, offset] = keys[i];
-            const [terrainId2, x, y, z] = key.split("_");
-            if (terrainId2 != terrainId) {
-                continue;
-            }
-            const pos3d2 = new Cesium.Cartesian3(parseFloat(x), parseFloat(y), parseFloat(z));
-            const distance = Cesium.Cartesian3.distance(pos3d, pos3d2);
-            if (distance < tolerance) {
-                return offset;
-            }
+        // Always start coarse and let the region teach us where that is not good enough, rather than guessing from a scene-wide entity count.
+        // A cell that turns out to span varied ground flags itself and its lookups move to the finer grid.
+        const coarseKey = terrainCellKey(terrainId, pos3d, TERRAIN_CELL_SIZE);
+        const coarseCell = _terrainCache.Get(coarseKey);
+        const useFine = Boolean(coarseCell === null || coarseCell === void 0 ? void 0 : coarseCell.needsDetail);
+        const key = useFine ? terrainCellKey(terrainId, pos3d, TERRAIN_CELL_SIZE_FINE) : coarseKey;
+        const cell = useFine ? _terrainCache.Get(key) : coarseCell;
+        if (cell && !cell.needsDetail) {
+            return cell.offset;
         }
-        const key = terrainId + "_" + pos3d.x + "_" + pos3d.y + "_" + pos3d.z;
-        let offset = _terrainCache.Get(key);
-        if (offset == null) {
-            const carto = Cesium.Cartographic.fromCartesian(pos3d);
-            let height = 0;
-            try {
-                height = viewer.scene.globe.getHeight(carto);
-            }
-            catch (e) {
-                // Likely out of rendered area.
-                // This means it's not our problem since the user isn't looking there :)
-            }
-            offset = height;
-            _terrainCache.Set(key, offset);
+        const carto = Cesium.Cartographic.fromCartesian(pos3d);
+        let height = 0;
+        try {
+            height = viewer.scene.globe.getHeight(carto);
+        }
+        catch (e) {
+            // Likely out of rendered area.
+            // This means it's not our problem since the user isn't looking there :)
+        }
+        if (height == null || isNaN(height)) {
+            // Terrain tile not loaded yet. Don't record it, so a later pass can sample it properly.
+            return coarseCell ? coarseCell.offset : 0;
+        }
+        // Always fold into the coarse cell as well, so its spread keeps being learned even while the finer grid is
+        // answering lookups for this region.
+        const recorded = recordTerrainSample(key, height);
+        if (useFine) {
+            recordTerrainSample(coarseKey, height);
         }
-        return offset;
+        return recorded.offset;
     };
     /**
      * Converts given pos3d into a an absolute position.
@@ -5855,6 +6202,10 @@
                 if (cEntity.model) {
                     const model = cEntity.model;
                     if (model._radius && !isNaN(model._radius)) {
+                        // _radius is already measured from the model's origin rather than its own centre: the model3d
+                        // engine folds the bounding sphere's centre offset into it (plus padding for badly-centred
+                        // models), and measures it at the entity's scale. So it can be used as-is against a sphere
+                        // centred on the entity position.
                         sphere.radius = Math.max(model._radius, MODEL_MIN_RADIUS);
                     }
                     else {
@@ -5868,12 +6219,10 @@
                     let radius = getValue$1(viewer, cEntity.ellipse.semiMajorAxis);
                     const extrusion = getValue$1(viewer, cEntity.ellipse.extrudedHeight);
                     if (extrusion && !isNaN(extrusion)) {
-                        if (!radius) {
-                            radius = extrusion;
-                        }
-                        else if (extrusion > radius / 2) {
-                            radius = extrusion;
-                        }
+                        // Expand rather than replace: measured from the base centre, the top rim of an extruded ellipse
+                        // sits at sqrt(radius^2 + height^2). Taking whichever of the two is larger leaves the rim outside
+                        // the sphere, and for something both wide and tall it would actually shrink it.
+                        radius = radius ? Math.sqrt((radius * radius) + (extrusion * extrusion)) : extrusion;
                     }
                     if (radius && !isNaN(radius)) {
                         sphere.radius = radius;
@@ -5883,12 +6232,11 @@
                 else if (cEntity.polygon) {
                     const extrusion = getValue$1(viewer, cEntity.polygon.extrudedHeight);
                     if (extrusion && !isNaN(extrusion)) {
-                        if (!sphere.radius) {
-                            sphere.radius = extrusion;
-                        }
-                        else if (extrusion > sphere.radius / 2) {
-                            sphere.radius = extrusion;
-                        }
+                        // Same as the ellipse above: the footprint sphere has to grow to reach the extruded top corners,
+                        // at sqrt(footprint^2 + height^2) from the footprint centre.
+                        sphere.radius = sphere.radius
+                            ? Math.sqrt((sphere.radius * sphere.radius) + (extrusion * extrusion))
+                            : extrusion;
                     }
                 }
                 else if (cEntity.point || cEntity.billboard) {
@@ -5910,7 +6258,15 @@
             return false;
         }
         const adjustedSphere = boundingSphere.sphere.clone();
-        adjustedSphere.center = adjustPos3d(viewer, boundingSphere.heightRef, adjustedSphere.center);
+        // Terrain only matters here because it moves the sphere onto the ground.
+        // Far enough away that a plausible ground height is a rounding error against the viewing distance, sampling it is wasted work.
+        const cameraDistance = Cesium.Cartesian3.distance(camera.position, adjustedSphere.center);
+        if (cameraDistance > TERRAIN_SKIP_DISTANCE) {
+            adjustedSphere.radius += TERRAIN_SKIP_RADIUS_PAD;
+        }
+        else {
+            adjustedSphere.center = adjustPos3d(viewer, boundingSphere.heightRef, adjustedSphere.center);
+        }
         const cullingVolume = camera.frustum.computeCullingVolume(camera.position, camera.direction, camera.up);
         const visibility = cullingVolume.computeVisibility(adjustedSphere);
         return visibility !== Cesium.Intersect.INSIDE && visibility !== Cesium.Intersect.INTERSECTING;
@@ -5983,38 +6339,67 @@
             rego.relation != null ||
             // Explicitly being either shown or hidden.
             rego.overrideShow != null ||
-            // Part of an independent collection.
-            // Won't touch in case there is special logic.
-            rego.collection ||
+            // Part of a collection we did not create, eg. a geojson data source, which may have its own rules for
+            // what is in the scene. Our own per-menu-item data sources are fair game.
+            (rego.collection && !IsCCollectionOwned(rego.collection)) ||
             // We won't cull historic records as they may be interpolating their locations.
             Boolean(rego.outline && rego.outline.some(x => !!x.DateTime))) {
             return true;
         }
-        const visual = rego.visual;
-        // We will only cull clamped stuff since it seems that's where we get benefits from.
-        let heightRef;
-        if (visual.polygon) {
-            heightRef = getValue$1(viewer, visual.polygon.heightReference);
-        }
-        else if (visual.polyline) {
-            heightRef = getValue$1(viewer, visual.polyline.clampToGround) == false ? Cesium.HeightReference.NONE : Cesium.HeightReference.CLAMP_TO_GROUND;
-        }
-        else if (visual.corridor) {
-            heightRef = getValue$1(viewer, visual.corridor.heightReference);
-        }
-        else if (visual.ellipse) {
-            heightRef = getValue$1(viewer, visual.ellipse.heightReference);
-        }
-        else if (visual.model) {
-            heightRef = getValue$1(viewer, visual.model.heightReference);
+        return false;
+    }
+    // A tileset's bounds are padded by this fraction before testing, so panning does not immediately evict something
+    // at the edge of view and pay to re-traverse it moments later.
+    const TILESET_CULL_PADDING = 0.25;
+    /**
+     * Suppresses tilesets whose padded bounds are outside the view, and restores ones that come back.
+     *
+     * Worth doing separately from entity culling because Cesium gates a tileset's whole update on its show flag: a
+     * hidden tileset skips traversal, tile selection and request scheduling entirely, where hiding its features still
+     * does all of that and merely draws nothing. There are only ever a handful of tilesets, so this needs no batching.
+     * @param register
+     */
+    function cullTilesets(register) {
+        var _a;
+        const viewer = register.Viewer;
+        const tilesets = register.GetTilesets();
+        if (!tilesets.length || viewer.isDestroyed() || !viewer.scene) {
+            return;
         }
-        else if (visual.point) {
-            heightRef = getValue$1(viewer, visual.point.heightReference);
+        const camera = viewer.scene.camera;
+        const cullingVolume = camera.frustum.computeCullingVolume(camera.position, camera.direction, camera.up);
+        let changed = false;
+        for (const rego of tilesets) {
+            const tileset = rego.tileset;
+            if (!tileset || !rego.gate) {
+                continue;
+            }
+            // A destroyed tileset should not be held onto, let alone culled.
+            if ((_a = tileset.isDestroyed) === null || _a === void 0 ? void 0 : _a.call(tileset)) {
+                register.RemoveTileset(tileset);
+                continue;
+            }
+            let sphere;
+            try {
+                sphere = tileset.boundingSphere;
+            }
+            catch (e) {
+                // Not ready yet. Leave it alone rather than guessing.
+                continue;
+            }
+            if (!sphere || isNaN(sphere.radius) || sphere.radius <= 0) {
+                continue;
+            }
+            const padded = sphere.clone();
+            padded.radius = sphere.radius * (1 + TILESET_CULL_PADDING);
+            const visible = cullingVolume.computeVisibility(padded) !== Cesium.Intersect.OUTSIDE;
+            if (register.SetTilesetCulled(tileset, !visible)) {
+                changed = true;
+            }
         }
-        else if (visual.billboard) {
-            heightRef = getValue$1(viewer, visual.billboard.heightReference);
+        if (changed) {
+            viewer.scene.requestRender();
         }
-        return heightRef != Cesium.HeightReference.CLAMP_TO_GROUND;
     }
     /**
      * Runs through all entities in the register and culls them if they are out of the viewport.
@@ -6030,6 +6415,7 @@
         const entityIds = register.GetEntityIds();
         // We'll use the terrain cache per culler cycle.
         _terrainCache.Clear();
+        cullTilesets(register);
         checkInterval = setInterval(() => {
             var _a;
             if (viewer.isDestroyed() || !viewer.scene) {
@@ -6082,7 +6468,7 @@
                         else {
                             delete part[VisualRegisterCuller.VISUAL_CULL_KEY];
                             if (rego.overrideShow != false &&
-                                !viewer.entities.contains(part) &&
+                                !IsCEntityInScene(viewer, part) &&
                                 !state.hidden &&
                                 (!isIsolatedAny || state.isolated)) {
                                 toAdd.push(part);
@@ -6122,16 +6508,17 @@
         }
         const removal = viewer.scene.postRender.addEventListener(() => {
             removal();
-            for (let i = 0; i < entities.length; i++) {
-                const entity = entities[i];
-                if (entityRemoveAddState.get(entity.id) != false) {
-                    continue;
-                }
-                entityRemoveAddState.delete(entity.id);
-                if (viewer.entities.contains(entity)) {
-                    viewer.entities.remove(entity);
+            // Batched, so Cesium raises one collectionChanged for the whole cull pass instead of one per entity.
+            WithSuspendedCCollections(entities.map(x => GetCEntityCollection(viewer, x)), () => {
+                for (let i = 0; i < entities.length; i++) {
+                    const entity = entities[i];
+                    if (entityRemoveAddState.get(entity.id) != false) {
+                        continue;
+                    }
+                    entityRemoveAddState.delete(entity.id);
+                    RemoveCEntityFromScene(viewer, entity);
                 }
-            }
+            });
         });
     }
     /**
@@ -6146,16 +6533,17 @@
         }
         const removal = viewer.scene.postRender.addEventListener(() => {
             removal();
-            for (let i = 0; i < entities.length; i++) {
-                const entity = entities[i];
-                if (entityRemoveAddState.get(entity.id) != true) {
-                    continue;
-                }
-                entityRemoveAddState.delete(entity.id);
-                if (!viewer.entities.contains(entity)) {
-                    viewer.entities.add(entity);
+            // Batched, so Cesium raises one collectionChanged for the whole cull pass instead of one per entity.
+            WithSuspendedCCollections(entities.map(x => GetCEntityCollection(viewer, x)), () => {
+                for (let i = 0; i < entities.length; i++) {
+                    const entity = entities[i];
+                    if (entityRemoveAddState.get(entity.id) != true) {
+                        continue;
+                    }
+                    entityRemoveAddState.delete(entity.id);
+                    AddCEntityToScene(viewer, entity);
                 }
-            }
+            });
         });
     }
     var VisualRegisterCuller;
@@ -6226,6 +6614,19 @@
             };
         }
         VisualRegisterCuller.Monitor = Monitor;
+        /**
+         * Runs the tileset visibility pass immediately, rather than waiting for the next cull cycle.
+         * Exposed so the behaviour is directly assertable, and for a caller that needs it applied now.
+         * @param register
+         */
+        function CullTilesets(register) {
+            cullTilesets(register);
+        }
+        VisualRegisterCuller.CullTilesets = CullTilesets;
+        function IsCullingIgnored(viewer, rego) {
+            return isCullingIgnored(viewer, rego);
+        }
+        VisualRegisterCuller.IsCullingIgnored = IsCullingIgnored;
         function IsCulled(viewer, rego, visual) {
             if (isCullingIgnored(viewer, rego)) {
                 return false;
@@ -6273,7 +6674,7 @@
             return false;
         }
         if (visual instanceof Cesium.Entity) {
-            return viewer.entities.contains(visual);
+            return IsCEntityInScene(viewer, visual);
         }
         else if (visual instanceof Cesium.Primitive) {
             return viewer.scene.primitives.contains(visual);
@@ -6300,6 +6701,32 @@
             viewer
         });
     }
+    /**
+     * Returns the highest zIndex across a graphic and its siblings, or null when none of them set one.
+     * @param viewer
+     * @param visual
+     */
+    function getHighestZIndex(viewer, visual) {
+        if (!(visual instanceof Cesium.Entity)) {
+            return null;
+        }
+        let highest = null;
+        const parts = exports.EntityUtils.GatherEntity({
+            entity: visual
+        });
+        for (const part of parts) {
+            if (!(part instanceof Cesium.Entity)) {
+                continue;
+            }
+            for (const graphic of [part.polygon, part.polyline, part.corridor, part.ellipse, part.rectangle]) {
+                const zIndex = graphic ? GetCValue(viewer, graphic.zIndex) : null;
+                if (zIndex != null && !isNaN(zIndex) && (highest == null || zIndex > highest)) {
+                    highest = zIndex;
+                }
+            }
+        }
+        return highest;
+    }
     const MAX_SHOW_DEPTH = 10;
     function updateCEntityShow(viewer, visual, rego, show, ignoreParent, depth = 0) {
         if (depth > MAX_SHOW_DEPTH) {
@@ -6318,26 +6745,24 @@
                 updateCEntityShow(viewer, sibling, rego, show, true, depth + 1);
             }
         }
-        /**
-         * Do NOT use ".show" as it causes crashes in Cesium polylines that are clamped to ground.
-         * We could target them specifically here but we may be getting overall performance gain by just removing stuff from the scene.
-         */
-        if (rego.collection) {
-            if (!show && rego.collection.contains(visual)) {
-                rego.collection.remove(visual);
-            }
-            else if (show && !rego.collection.contains(visual)) {
-                rego.collection.add(visual);
+        if (show) {
+            // Always restore membership on the way back in. Something else may have evicted this graphic while it
+            // was hidden (the culler removes outright), and `show` alone would leave it invisible.
+            AddCEntityToScene(viewer, visual, rego.collection);
+            if (visual.show !== true) {
+                visual.show = true;
             }
+            return;
         }
-        else {
-            if (!show && viewer.entities.contains(visual)) {
-                viewer.entities.remove(visual);
-            }
-            else if (show && !viewer.entities.contains(visual)) {
-                viewer.entities.add(visual);
+        // Hiding via `show` only updates a per-instance attribute, where leaving the collection rebuilds the whole
+        // geometry batch. But it is not safe for every graphic, see CanToggleShowSafely for exactly why.
+        if (CanToggleShowSafely([visual])) {
+            if (visual.show !== false) {
+                visual.show = false;
             }
+            return;
         }
+        RemoveCEntityFromScene(viewer, visual);
     }
     function updateEntityShow(viewer, rego, show) {
         const visual = rego.visual;
@@ -6646,12 +7071,128 @@
                 // This lets us modify the update without re-adding the item to the queue if it's already in it.
                 this.updateQueueSettings = {};
                 this.updateQueueInterval = null;
+                // Per menu item collections so we can refresh sets of Entities without affecting others.
+                this.menuItemSources = new Map();
+                // Set when the data source order no longer matches the zIndexes seen, so it is re-applied once.
+                this.sourceOrderDirty = false;
+                /*
+                 * Tilesets in the scene, keyed by the tileset itself.
+                 */
+                this.tilesets = new Map();
                 this.viewer = params.viewer;
                 this.apiGetters = params.apiGetters;
                 this.cameraCullerDispose = VisualRegisterCuller.Monitor({
                     register: this
                 });
             }
+            /**
+             * Returns the collection a menu item's visuals belong in, creating its data source on first use.
+             * Returns null when there is nothing to key off, leaving the caller on the viewer's own collection.
+             * @param menuItemId
+             */
+            ensureMenuItemCollection(menuItemId) {
+                var _a;
+                if (!menuItemId || this.disposed || !((_a = this.viewer) === null || _a === void 0 ? void 0 : _a.dataSources)) {
+                    return null;
+                }
+                const existing = this.menuItemSources.get(menuItemId);
+                if (existing) {
+                    return existing.source.entities;
+                }
+                const source = new Cesium.CustomDataSource(`menu-item-${menuItemId}`);
+                const record = {
+                    source,
+                    maxZIndex: 0,
+                    added: false
+                };
+                MarkCCollectionOwned(source.entities);
+                this.menuItemSources.set(menuItemId, record);
+                // Adding is asynchronous, so ordering has to wait until it is actually in the collection.
+                Promise.resolve(this.viewer.dataSources.add(source))
+                    .then(() => {
+                    record.added = true;
+                    this.applySourceOrder();
+                })
+                    .catch((e) => {
+                    console.error(e);
+                });
+                return source.entities;
+            }
+            /**
+             * Notes the highest zIndex seen for a menu item, since that is what its data source has to sort by.
+             * zIndex orders geometry within a data source but not between them, so a whole layer stacks by the
+             * highest value anything in it asked for.
+             * @param menuItemId
+             * @param visual
+             */
+            trackSourceZIndex(menuItemId, visual) {
+                const record = this.menuItemSources.get(menuItemId);
+                if (!record) {
+                    return;
+                }
+                const zIndex = getHighestZIndex(this.viewer, visual);
+                if (zIndex == null || zIndex <= record.maxZIndex) {
+                    return;
+                }
+                record.maxZIndex = zIndex;
+                this.sourceOrderDirty = true;
+                this.applySourceOrder();
+            }
+            /**
+             * Re-stacks the menu item data sources so a higher zIndex sits above a lower one.
+             */
+            applySourceOrder() {
+                var _a;
+                if (this.disposed || !this.sourceOrderDirty || !((_a = this.viewer) === null || _a === void 0 ? void 0 : _a.dataSources)) {
+                    return;
+                }
+                const records = Array.from(this.menuItemSources.values()).filter(x => x.added);
+                if (records.length < 2) {
+                    // Nothing to order against yet, so leave the flag set for when there is.
+                    return;
+                }
+                this.sourceOrderDirty = false;
+                // Raising each in ascending order leaves the highest on top.
+                records.sort((a, b) => a.maxZIndex - b.maxZIndex);
+                for (const record of records) {
+                    try {
+                        this.viewer.dataSources.raiseToTop(record.source);
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+            }
+            /**
+             * Drops a menu item's data source once nothing is registered under it any more.
+             * @param menuItemId
+             */
+            releaseMenuItemCollection(menuItemId) {
+                var _a, _b, _c;
+                const record = this.menuItemSources.get(menuItemId);
+                if (!record) {
+                    return;
+                }
+                if ((_a = this.entityIdsByMenuItem[menuItemId]) === null || _a === void 0 ? void 0 : _a.size) {
+                    return;
+                }
+                this.menuItemSources.delete(menuItemId);
+                try {
+                    (_c = (_b = this.viewer) === null || _b === void 0 ? void 0 : _b.dataSources) === null || _c === void 0 ? void 0 : _c.remove(record.source, true);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            /** Every collection a bulk pass over this register's visuals could mutate. */
+            allSceneCollections() {
+                var _a;
+                const collections = [(_a = this.viewer) === null || _a === void 0 ? void 0 : _a.entities];
+                for (const record of Array.from(this.menuItemSources.values())) {
+                    collections.push(record.source.entities);
+                }
+                return collections;
+            }
             indexMenuItemEntity(menuItemId, entityId) {
                 if (!menuItemId) {
                     return;
@@ -7241,9 +7782,11 @@
                         return;
                     }
                     const end = Math.min(index + BATCH_SIZE, items.length);
-                    for (; index < end; index++) {
-                        perItem(items[index]);
-                    }
+                    WithSuspendedCCollections(this.allSceneCollections(), () => {
+                        for (; index < end; index++) {
+                            perItem(items[index]);
+                        }
+                    });
                     this.viewer.scene.requestRender();
                     if (index >= items.length) {
                         clearInterval(interval);
@@ -7400,7 +7943,7 @@
                 markEntity(this, rego, rego.visual, false);
             }
             Dispose() {
-                var _a;
+                var _a, _b, _c, _d;
                 (_a = this.cameraCullerDispose) === null || _a === void 0 ? void 0 : _a.call(this, {
                     uncull: false
                 });
@@ -7415,6 +7958,20 @@
                 }
                 this.activeChunkedIntervals.clear();
                 this.disposed = true;
+                for (const record of Array.from(this.menuItemSources.values())) {
+                    try {
+                        (_c = (_b = this.viewer) === null || _b === void 0 ? void 0 : _b.dataSources) === null || _c === void 0 ? void 0 : _c.remove(record.source, true);
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+                this.menuItemSources.clear();
+                // Hand every tileset's show flag back to its owner, holding whatever the owner last asked for.
+                for (const rego of Array.from(this.tilesets.values())) {
+                    (_d = rego.gate) === null || _d === void 0 ? void 0 : _d.Release();
+                }
+                this.tilesets.clear();
             }
             ForceUpdate(params) {
                 var _a;
@@ -8010,6 +8567,14 @@
                     });
                 }
                 const entityId = rego.entityId;
+                // Scope this visual to its menu item's own data source, so a rebuild of it cannot re-tessellate
+                // other layers. A caller that already picked a collection (eg. geojson) keeps its own.
+                if (!rego.collection && rego.menuItemId) {
+                    const collection = this.ensureMenuItemCollection(rego.menuItemId);
+                    if (collection) {
+                        rego.collection = collection;
+                    }
+                }
                 // Add the new visual to the register.
                 const entityRegos = (_a = this.rego[entityId]) !== null && _a !== void 0 ? _a : [];
                 entityRegos.push(rego);
@@ -8017,6 +8582,7 @@
                 this.indexMenuItemEntity(rego.menuItemId, entityId);
                 // Mark the visual as part of this register so selection works.
                 markEntity(this, rego, rego.visual, false);
+                this.trackSourceZIndex(rego.menuItemId, rego.visual);
                 // Run any updates on the visual based on the calculated state.
                 // Eg: visibility, opacity, selection, etc.
                 this.queueUpdate({
@@ -8321,9 +8887,13 @@
                         this.startLazyRemoval(entityIds, removeOne, onComplete);
                         return;
                     }
-                    for (const entityId of entityIds) {
-                        removeOne(entityId);
-                    }
+                    WithSuspendedCCollections(this.allSceneCollections(), () => {
+                        for (const entityId of entityIds) {
+                            removeOne(entityId);
+                        }
+                    });
+                    this.releaseMenuItemCollection(menuItemId);
+                    this.RemoveTilesetsByMenuItem(menuItemId);
                 }
                 else if (entityId) {
                     const entityRegos = this.rego[entityId];
@@ -8506,8 +9076,75 @@
                 };
             }
             /**
-             * Returns all registered entity ids.
+             * Registers a tileset so the register can decide when it is worth drawing.
+             * @param params
+             */
+            AddTileset(params) {
+                const { tileset, menuItemId } = params;
+                if (!tileset || this.disposed) {
+                    return;
+                }
+                const existing = this.tilesets.get(tileset);
+                if (existing) {
+                    existing.menuItemId = menuItemId !== null && menuItemId !== void 0 ? menuItemId : existing.menuItemId;
+                    return;
+                }
+                this.tilesets.set(tileset, {
+                    tileset,
+                    menuItemId,
+                    // Null when the property could not be intercepted, in which case this tileset simply never gets
+                    // culled rather than us fighting its owner over the same field.
+                    gate: InstallShowGate(tileset),
+                    culled: false
+                });
+            }
+            /**
+             * Stops tracking a tileset and hands its show flag back to its owner.
+             * @param tileset
+             */
+            RemoveTileset(tileset) {
+                var _a;
+                const rego = this.tilesets.get(tileset);
+                if (!rego) {
+                    return;
+                }
+                this.tilesets.delete(tileset);
+                (_a = rego.gate) === null || _a === void 0 ? void 0 : _a.Release();
+            }
+            /**
+             * Stops tracking every tileset belonging to a menu item.
+             * @param menuItemId
+             */
+            RemoveTilesetsByMenuItem(menuItemId) {
+                if (!menuItemId) {
+                    return;
+                }
+                for (const rego of Array.from(this.tilesets.values())) {
+                    if (rego.menuItemId === menuItemId) {
+                        this.RemoveTileset(rego.tileset);
+                    }
+                }
+            }
+            /**
+             * Every tileset currently tracked.
+             */
+            GetTilesets() {
+                return Array.from(this.tilesets.values());
+            }
+            /**
+             * Suppresses or restores a tileset.
+             * Returns whether its effective visibility changed, so a caller can skip requesting a render when nothing did.
+             * @param tileset
+             * @param culled
              */
+            SetTilesetCulled(tileset, culled) {
+                const rego = this.tilesets.get(tileset);
+                if (!(rego === null || rego === void 0 ? void 0 : rego.gate)) {
+                    return false;
+                }
+                rego.culled = Boolean(culled);
+                return rego.gate.SetSuppressed(rego.culled);
+            }
             GetEntityIds() {
                 const ids = [];
                 for (const entityId in this.rego) {
@@ -9661,6 +10298,14 @@
                 // Type IDs that we'll allow to be rendered when receiving Entities.
                 // This might be exactly the Menu Item Type ID because of local data sources.
                 this.allowedTypeIDs = [];
+                /**
+                 * Our default path.
+                 * We render each entity individually.
+                 * @param entities
+                 * @param force
+                 * @returns
+                 */
+                this.renderAsIndividualsChain = Promise.resolve();
                 const { viewer, apiGetter, monitor, item, register: visualsManager, sharedGetters, onSeriesDiscovered } = params;
                 this.viewer = viewer;
                 this.sharedGetters = sharedGetters;
@@ -9868,7 +10513,11 @@
                 const displayItems = this.zoomControl ? (_d = this.zoomControl) === null || _d === void 0 ? void 0 : _d.filter(x => x.DisplayType != BModels.ZoomControl.EDisplayType.Hidden) : [];
                 const shouldCheck = displayItems.length > 1;
                 this.entityCheckQueue = new BModels.DelayQueue(() => {
-                    this.doEntityCheck(Object.keys(this.renderedEntities));
+                    // With a single band this pass is not looking for band changes at all, it is the periodic registry cleanup, so it always runs over everything.
+                    const ids = shouldCheck
+                        ? this.filterPossibleBandChanges(Object.keys(this.renderedEntities))
+                        : Object.keys(this.renderedEntities);
+                    this.doEntityCheck(ids);
                 }, shouldCheck ? 3000 : 30000);
                 const feed = (_e = this.apiGetter.getApi()) === null || _e === void 0 ? void 0 : _e.RecordChangeFeed;
                 if (feed) {
@@ -10111,6 +10760,30 @@
                     this.doEntityCheck(entityIds);
                 }
             }
+            /**
+             * Narrows a camera-driven check to the entities whose zoom band could actually have changed.
+             * @param ids
+             */
+            filterPossibleBandChanges(ids) {
+                return ids.filter((id) => {
+                    const rego = this.visualsManager.GetRego({
+                        entityId: id,
+                        menuItemId: this.item.id
+                    });
+                    // Anything without a live graphic to measure against has to be checked.
+                    if (!(rego === null || rego === void 0 ? void 0 : rego.visual) || rego.stale) {
+                        return true;
+                    }
+                    const bandCheck = rego.visual._bandCheck;
+                    if (!bandCheck) {
+                        return true;
+                    }
+                    return exports.RenderManager.CouldBandHaveChanged({
+                        viewer: this.viewer,
+                        bandCheck
+                    });
+                });
+            }
             async doEntityCheck(ids) {
                 var _a, _b;
                 if (this.isRunningCheck) {
@@ -10593,14 +11266,18 @@
                 }
                 this.viewer.scene.requestRender();
             }
-            /**
-             * Our default path.
-             * We render each entity individually.
-             * @param entities
-             * @param force
-             * @returns
-             */
-            async renderAsIndividuals(entities, force = false) {
+            renderAsIndividuals(entities, force = false) {
+                // Waiting for prior call to finish resolving.
+                // This avoids race conditions against two sets of overlapping Entities.
+                const next = this.renderAsIndividualsChain
+                    .then(() => this.doRenderAsIndividuals(entities, force))
+                    .catch((e) => {
+                    console.error("EntitiesRenderManager.renderAsIndividuals failed:", e);
+                });
+                this.renderAsIndividualsChain = next;
+                return next;
+            }
+            async doRenderAsIndividuals(entities, force = false) {
                 var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
                 // When live we just want to show the latest pos.
                 // When not live, the user might scroll the timeline and want to see it a fluid animation between points in time.
@@ -10778,6 +11455,19 @@
                     optimizeTolerance: (_o = item.optimizeTolerance) !== null && _o !== void 0 ? _o : ""
                 });
             }
+            /**
+             * Everything about a menu item that changes how its entities are drawn, as a comparable string.
+             * Two items with the same signature produce identical graphics, so a hand-off between them needs no
+             * re-render (and so no re-fetch of entity data the hand-off just avoided requesting).
+             * A false mismatch only costs the optimization, so key ordering inside an inline Style is not normalized.
+             */
+            static GetRenderSignature(item) {
+                return JSON.stringify({
+                    zoomControl: exports.RenderManager.GetZoomControlSignature(item.CameraZoomSettings),
+                    historicDrawTrack: Boolean(item.historicDrawTrack),
+                    historicInterpolation: Boolean(item.historicInterpolation)
+                });
+            }
             PrepareHandoff() {
                 var _a;
                 if (this.disposed || this.useGeojson || this.item.enableClustering) {
@@ -10789,7 +11479,8 @@
                     internalByEntityId: new Map(this.internalByEntityId),
                     allowedTypeIDs: [...this.allowedTypeIDs],
                     renderQueue: [...this.renderQueue],
-                    sourceMenuItemId: this.item.id
+                    sourceMenuItemId: this.item.id,
+                    renderSignature: Manager.GetRenderSignature(this.item)
                 };
                 this.unsetGetter();
                 (_a = this.viewMonitorRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
@@ -10829,7 +11520,12 @@
                 if ((_a = payload.renderQueue) === null || _a === void 0 ? void 0 : _a.length) {
                     this.distributeForRender(payload.renderQueue);
                 }
-                this.ReRender({ entityIds: Object.keys(this.renderedEntities), force: true });
+                // Adopted graphics are already drawn the way this item wants them, so re-rendering would only
+                // re-request every entity from the API, which is the cost the hand-off exists to avoid.
+                const needsRestyle = payload.renderSignature !== Manager.GetRenderSignature(this.item);
+                if (needsRestyle) {
+                    this.ReRender({ entityIds: Object.keys(this.renderedEntities), force: true });
+                }
                 this.viewer.scene.requestRender();
             }
         }
@@ -10954,6 +11650,14 @@
                 // Many things are not supported when this is enabled.
                 this.useGeojson = false;
                 this.reRenderState = new EntityReRenderMaintainState();
+                /**
+                 * Our default path.
+                 * We render each entity individually.
+                 * @param entities
+                 * @param force
+                 * @returns
+                 */
+                this.renderAsIndividualsChain = Promise.resolve();
                 const { viewer, apiGetter, monitor, item, register: visualsManager } = params;
                 this.viewer = viewer;
                 this.apiGetter = apiGetter;
@@ -11263,7 +11967,7 @@
              * @param force TODO: This should re-render entities that are already rendered.
              */
             async renderAsGeojson(entities, force) {
-                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
                 entities = entities.filter((entity) => {
                     var _a;
                     return !this.renderedEntities[(_a = entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID];
@@ -11314,38 +12018,42 @@
                 if (!entities.length) {
                     return;
                 }
+                // A menu item can declare that nothing about its render may touch the API. Styling then has to come from
+                // the zoom item's inline Style, and names from what the entities already carry.
+                const offline = Boolean((_a = this.item) === null || _a === void 0 ? void 0 : _a.offline);
                 let style = null;
-                if ((zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.StyleID) && zoomItem.StyleID != -1) {
+                if (!offline && (zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.StyleID) && zoomItem.StyleID != -1) {
                     try {
-                        style = (_a = (await BModels.Style.Get({
+                        style = (_b = (await BModels.Style.Get({
                             api: this.apiGetter.getApi(),
                             styleId: zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.StyleID
-                        })).style) === null || _a === void 0 ? void 0 : _a.Settings;
+                        })).style) === null || _b === void 0 ? void 0 : _b.Settings;
                     }
                     // Probably deleted.
                     catch (e) {
                         console.error(e);
                     }
                 }
-                let entityTypeId = (_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b["EntityType.ID"];
+                let entityTypeId = (_c = this.item.BruceEntity) === null || _c === void 0 ? void 0 : _c["EntityType.ID"];
                 if (!entityTypeId) {
-                    entityTypeId = (_d = (_c = entities.find(x => { var _a; return !!((_a = x.Bruce) === null || _a === void 0 ? void 0 : _a["EntityType.ID"]); })) === null || _c === void 0 ? void 0 : _c.Bruce) === null || _d === void 0 ? void 0 : _d["EntityType.ID"];
+                    entityTypeId = (_e = (_d = entities.find(x => { var _a; return !!((_a = x.Bruce) === null || _a === void 0 ? void 0 : _a["EntityType.ID"]); })) === null || _d === void 0 ? void 0 : _d.Bruce) === null || _e === void 0 ? void 0 : _e["EntityType.ID"];
                 }
-                // Getting type regardless cause it's needed for name calculations.
+                // Normally fetched regardless, since name calculation needs it. Offline callers take the names the
+                // entities already carry instead.
                 let entityType;
-                if (entityTypeId) {
+                if (entityTypeId && !offline) {
                     // Try using the Entity Type default if one is specified in the menu item.
                     try {
-                        entityType = (_e = (await BModels.EntityType.Get({
+                        entityType = (_f = (await BModels.EntityType.Get({
                             entityTypeId: entityTypeId,
                             api: this.apiGetter.getApi()
-                        }))) === null || _e === void 0 ? void 0 : _e.entityType;
+                        }))) === null || _f === void 0 ? void 0 : _f.entityType;
                         if (!style && entityType) {
                             if (entityType["DisplaySetting.ID"] && entityType["DisplaySetting.ID"] > 0) {
-                                style = (_f = (await BModels.Style.Get({
+                                style = (_g = (await BModels.Style.Get({
                                     api: this.apiGetter.getApi(),
                                     styleId: entityType["DisplaySetting.ID"]
-                                })).style) === null || _f === void 0 ? void 0 : _f.Settings;
+                                })).style) === null || _g === void 0 ? void 0 : _g.Settings;
                             }
                         }
                     }
@@ -11353,9 +12061,13 @@
                         console.error(e);
                     }
                 }
-                const pStyle = (_g = style === null || style === void 0 ? void 0 : style.polygonStyle) !== null && _g !== void 0 ? _g : {};
-                const lStyle = (_h = style === null || style === void 0 ? void 0 : style.polylineStyle) !== null && _h !== void 0 ? _h : {};
-                const polygonsClamped = ((_j = pStyle === null || pStyle === void 0 ? void 0 : pStyle.altitudeOption) === null || _j === void 0 ? void 0 : _j.id) == null ? true : ((_k = pStyle === null || pStyle === void 0 ? void 0 : pStyle.altitudeOption) === null || _k === void 0 ? void 0 : _k.id) == 0;
+                // Fall back to whatever the zoom item carried inline, which is the only source offline.
+                if (!style) {
+                    style = zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.Style;
+                }
+                const pStyle = (_h = style === null || style === void 0 ? void 0 : style.polygonStyle) !== null && _h !== void 0 ? _h : {};
+                const lStyle = (_j = style === null || style === void 0 ? void 0 : style.polylineStyle) !== null && _j !== void 0 ? _j : {};
+                const polygonsClamped = ((_k = pStyle === null || pStyle === void 0 ? void 0 : pStyle.altitudeOption) === null || _k === void 0 ? void 0 : _k.id) == null ? true : ((_l = pStyle === null || pStyle === void 0 ? void 0 : pStyle.altitudeOption) === null || _l === void 0 ? void 0 : _l.id) == 0;
                 const bFillColor = BModels.Calculator.GetColor(pStyle.fillColor, {}, []);
                 const cFillColor = bFillColor ? colorToCColor$2(bFillColor) : Cesium.Color.fromCssColorString("rgba(139, 195, 74, 0.8)");
                 const bLineColor = BModels.Calculator.GetColor(pStyle.lineColor, {}, []);
@@ -11577,14 +12289,19 @@
                 }
                 this.viewer.scene.requestRender();
             }
-            /**
-             * Our default path.
-             * We render each entity individually.
-             * @param entities
-             * @param force
-             * @returns
-             */
-            async renderAsIndividuals(entities, force = false) {
+            renderAsIndividuals(entities, force = false) {
+                // Waiting for prior call to finish resolving.
+                // This avoids race conditions against two sets of overlapping Entities.
+                const next = this.renderAsIndividualsChain
+                    .then(() => this.doRenderAsIndividuals(entities, force))
+                    .catch((e) => {
+                    console.error("EntitiesLoadedRenderManager.renderAsIndividuals failed:", e);
+                });
+                this.renderAsIndividualsChain = next;
+                return next;
+            }
+            async doRenderAsIndividuals(entities, force = false) {
+                var _a;
                 const { updated, entities: cEntities } = await exports.EntityRenderEngine.Render({
                     viewer: this.viewer,
                     apiGetter: this.apiGetter,
@@ -11592,6 +12309,8 @@
                     menuItemId: this.item.id,
                     visualRegister: this.visualsManager,
                     zoomControl: this.item.CameraZoomSettings,
+                    // Carries the promise through to the engines, which do the rest of the API avoidance.
+                    offline: Boolean((_a = this.item) === null || _a === void 0 ? void 0 : _a.offline),
                     force
                 });
                 if (this.disposed) {
@@ -12220,6 +12939,7 @@
                 this.getterSub = null;
                 this.disposed = false;
                 this.reRenderState = new EntityReRenderMaintainState();
+                this.renderEntityChain = Promise.resolve();
                 const { viewer, apiGetter, monitor, item, register: visualsManager } = params;
                 this.viewer = viewer;
                 this.apiGetter = apiGetter;
@@ -12342,7 +13062,18 @@
                     this.onGetterUpdate(entityId, true);
                 }
             }
-            async renderEntity(entity, force = false) {
+            renderEntity(entity, force = false) {
+                // Waiting for prior call to finish resolving.
+                // This avoids race conditions against two sets of overlapping Entities.
+                const next = this.renderEntityChain
+                    .then(() => this.doRenderEntity(entity, force))
+                    .catch((e) => {
+                    console.error("EntityRenderManager.renderEntity failed:", e);
+                });
+                this.renderEntityChain = next;
+                return next;
+            }
+            async doRenderEntity(entity, force = false) {
                 try {
                     if (this.disposed || this.viewer.isDestroyed()) {
                         return;
@@ -13800,6 +14531,7 @@
         }
         TilesetRenderEngine.ApplySettings = ApplySettings;
         async function Render(params) {
+            var _a, _b, _c;
             const api = params.apiGetter.getApi(params.accountId);
             // Ensure regional url is loaded.
             await api.Loading;
@@ -13863,6 +14595,10 @@
                         console.error(e);
                     }
                 });
+                (_a = params.register) === null || _a === void 0 ? void 0 : _a.AddTileset({
+                    tileset: cTileset,
+                    menuItemId: params.menuItemId
+                });
                 return cTileset;
             }
             else if (params.tileset.type === BModels.Tileset.EType.EntitiesSet) {
@@ -13879,6 +14615,10 @@
                 const cTileset = await createTileset(loadUrl, null, params.noMemoryLimit);
                 params.viewer.scene.primitives.add(cTileset);
                 watchTilesetDateRange(params.viewer, cTileset, params.tileset);
+                (_b = params.register) === null || _b === void 0 ? void 0 : _b.AddTileset({
+                    tileset: cTileset,
+                    menuItemId: params.menuItemId
+                });
                 return cTileset;
             }
             else if (params.tileset.type == BModels.Tileset.EType.PointCloud) {
@@ -13924,6 +14664,10 @@
                         console.error(e);
                     }
                 });
+                (_c = params.register) === null || _c === void 0 ? void 0 : _c.AddTileset({
+                    tileset: cTileset,
+                    menuItemId: params.menuItemId
+                });
                 return cTileset;
             }
             else {
@@ -13932,6 +14676,7 @@
         }
         TilesetRenderEngine.Render = Render;
         async function RenderLegacy(params) {
+            var _a;
             let { apiGetter, viewer, tileset, ionId, loadUrl, viaCdn, accountId, noMemoryLimit, backFaceCulling } = params;
             let settings = tileset === null || tileset === void 0 ? void 0 : tileset.Settings;
             settings = {
@@ -14054,6 +14799,10 @@
                     console.error(e);
                 }
             });
+            (_a = params.register) === null || _a === void 0 ? void 0 : _a.AddTileset({
+                tileset: cTileset,
+                menuItemId: params.menuItemId
+            });
             return cTileset;
         }
         TilesetRenderEngine.RenderLegacy = RenderLegacy;
@@ -14563,6 +15312,8 @@
                     }
                     // Render outside the shared process because we can't control file requests from Cesium.
                     const cTileset = this.cTileset = await exports.TilesetRenderEngine.Render({
+                        register: this.visualsManager,
+                        menuItemId: this.item.id,
                         loadUrl: loadUrl,
                         apiGetter: this.getters.GetBruceGetter(),
                         tileset: tileset,
@@ -16778,6 +17529,7 @@
                 this.reRenderState = new EntityReRenderMaintainState();
                 this.zoomControl = [];
                 this.queryLoadId = 0;
+                this.renderDataLabEntitiesChain = Promise.resolve();
                 const { viewer, item, apiGetter, monitor, visualsRegister } = params;
                 this.viewer = viewer;
                 this.item = item;
@@ -16893,7 +17645,12 @@
                 const displayItems = this.zoomControl ? this.zoomControl.filter(x => x.DisplayType != BModels.ZoomControl.EDisplayType.Hidden) : [];
                 const shouldCheck = displayItems.length > 1;
                 this.entityCheckQueue = new BModels.DelayQueue(() => {
-                    this.doEntityCheck(Object.keys(this.renderedEntities));
+                    // With a single band this pass is not looking for band changes at all, so it always runs over
+                    // everything. With more than one, most entities can be ruled out without asking the server.
+                    const ids = shouldCheck
+                        ? this.filterPossibleBandChanges(Object.keys(this.renderedEntities))
+                        : Object.keys(this.renderedEntities);
+                    this.doEntityCheck(ids);
                 }, shouldCheck ? 3000 : 30000);
                 (_b = this.viewMonitorRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
                 this.viewMonitorRemoval = this.monitor.Updated().Subscribe(() => {
@@ -16901,6 +17658,30 @@
                     (_a = this.entityCheckQueue) === null || _a === void 0 ? void 0 : _a.Call();
                 });
             }
+            /**
+             * Narrows a camera-driven check to the entities whose zoom band could actually have changed, so a pan or
+             * zoom stops re-requesting the whole rendered set. See RenderManager.CouldBandHaveChanged.
+             * @param ids
+             */
+            filterPossibleBandChanges(ids) {
+                return ids.filter((id) => {
+                    const rego = this.visualsManager.GetRego({
+                        entityId: id,
+                        menuItemId: this.item.id
+                    });
+                    if (!(rego === null || rego === void 0 ? void 0 : rego.visual) || rego.stale) {
+                        return true;
+                    }
+                    const bandCheck = rego.visual._bandCheck;
+                    if (!bandCheck) {
+                        return true;
+                    }
+                    return exports.RenderManager.CouldBandHaveChanged({
+                        viewer: this.viewer,
+                        bandCheck
+                    });
+                });
+            }
             preventCurrentCheckApiRefresh(entityIds) {
                 var _a;
                 this.reRenderState.markSkipForCurrentRun(entityIds, this.isRunningCheck);
@@ -17116,7 +17897,18 @@
                 }
                 return Array.from(entityMap.values());
             }
-            async renderDataLabEntities(entities, force = false) {
+            renderDataLabEntities(entities, force = false) {
+                // Waiting for prior call to finish resolving.
+                // This avoids race conditions against two sets of overlapping Entities.
+                const next = this.renderDataLabEntitiesChain
+                    .then(() => this.doRenderDataLabEntities(entities, force))
+                    .catch((e) => {
+                    console.error("EntitiesDatalabRenderManager.renderDataLabEntities failed:", e);
+                });
+                this.renderDataLabEntitiesChain = next;
+                return next;
+            }
+            async doRenderDataLabEntities(entities, force = false) {
                 var _a, _b, _c;
                 if (this.disposed || this.viewer.isDestroyed() || !(entities === null || entities === void 0 ? void 0 : entities.length)) {
                     return;
@@ -17216,6 +18008,15 @@
                 }
                 return `datalab:${queryId}`;
             }
+            /**
+             * Everything about this menu item that changes how its entities are drawn, as a comparable string.
+             * The hand-off key is only the query id, so this is what catches a styling difference between two items sharing that query.
+             */
+            static GetRenderSignature(item) {
+                return JSON.stringify({
+                    zoomControl: exports.RenderManager.GetZoomControlSignature(item.CameraZoomSettings)
+                });
+            }
             PrepareHandoff() {
                 var _a, _b, _c;
                 if (this.disposed || !this.getter) {
@@ -17236,7 +18037,8 @@
                     getter,
                     renderedEntities: this.renderedEntities,
                     renderQueue: [...this.renderQueue],
-                    sourceMenuItemId: this.item.id
+                    sourceMenuItemId: this.item.id,
+                    renderSignature: Manager.GetRenderSignature(this.item)
                 };
                 this.renderQueue = [];
                 this.queryLoadId += 1;
@@ -17259,7 +18061,10 @@
                 if ((_a = payload.renderQueue) === null || _a === void 0 ? void 0 : _a.length) {
                     this.distributeForRender(payload.renderQueue);
                 }
-                this.ReRender({ entityIds: Object.keys(this.renderedEntities), force: true });
+                const needsRestyle = payload.renderSignature !== Manager.GetRenderSignature(this.item);
+                if (needsRestyle) {
+                    this.ReRender({ entityIds: Object.keys(this.renderedEntities), force: true });
+                }
                 this.viewer.scene.requestRender();
             }
         }
@@ -18240,6 +19045,8 @@
                             }
                         }
                         const cTileset = this.cTileset = await exports.TilesetRenderEngine.Render({
+                            register: this.visualsManager,
+                            menuItemId: this.item.id,
                             apiGetter: this.getters.GetBruceGetter(),
                             tileset: tileset,
                             viewer: this.viewer,
@@ -18730,11 +19537,12 @@
             constructor(params) {
                 this.disposed = false;
                 this.cTileset = null;
-                const { viewer, getters: apiGetter, item, initQueue } = params;
+                const { viewer, getters: apiGetter, item, initQueue, register } = params;
                 this.viewer = viewer;
                 this.getters = apiGetter;
                 this.item = item;
                 this.initQueue = initQueue;
+                this.visualsManager = register;
             }
             Init() {
                 var _a;
@@ -18785,6 +19593,8 @@
                         return;
                     }
                     this.cTileset = await exports.TilesetRenderEngine.Render({
+                        register: this.visualsManager,
+                        menuItemId: this.item.id,
                         apiGetter: this.getters.GetBruceGetter(),
                         tileset: tileset,
                         viewer: this.viewer,
@@ -19371,6 +20181,8 @@
                             if (!accountId) {
                                 accountId = this.getters.GetAccountId();
                             }
+                            // Deliberately NOT registered with the visuals register, so it is never whole-tileset culled.
+                            // An arbitrary tileset can be produced outside our system and its declared bounds cannot be trusted.
                             this.cTileset = await exports.TilesetRenderEngine.RenderLegacy({
                                 apiGetter: this.getters.GetBruceGetter(),
                                 tileset: legacyTileset,
@@ -20038,8 +20850,8 @@
                      * @param cEntity
                      */
                     const killCEntity = (cEntity) => {
-                        if (cEntity && !this.viewer.isDestroyed() && this.viewer.entities.contains(cEntity)) {
-                            this.viewer.entities.remove(cEntity);
+                        if (cEntity && !this.viewer.isDestroyed()) {
+                            RemoveCEntityFromScene(this.viewer, cEntity);
                         }
                         if (cEntity === null || cEntity === void 0 ? void 0 : cEntity._dispose) {
                             cEntity._dispose();
@@ -20517,8 +21329,8 @@
                      * @param cEntity
                      */
                     const killCEntity = (cEntity) => {
-                        if (cEntity && !this.viewer.isDestroyed() && this.viewer.entities.contains(cEntity)) {
-                            this.viewer.entities.remove(cEntity);
+                        if (cEntity && !this.viewer.isDestroyed()) {
+                            RemoveCEntityFromScene(this.viewer, cEntity);
                         }
                         if (cEntity === null || cEntity === void 0 ? void 0 : cEntity._dispose) {
                             cEntity._dispose();
@@ -22537,6 +23349,7 @@
                             rItem.renderManager = new exports.TilesetPointcloudRenderManager.Manager({
                                 viewer: this.viewer,
                                 getters: this.getters,
+                                register: this.visualsRegister,
                                 item: params.item,
                                 initQueue: this.tilesetInitQueue
                             });
@@ -22691,6 +23504,8 @@
                     }
                     if (allowHandoff && this.isHandoffCapable(item.renderManager)) {
                         this.pendingHandoffPool.push(item);
+                        // Series segments stay recorded under the pooled id for now. A claimed hand-off
+                        // transfers them to the claiming item, and a flushed one clears them.
                     }
                     else {
                         try {
@@ -22699,9 +23514,9 @@
                         catch (e) {
                             console.error(e);
                         }
+                        this.ClearSeriesSegments(item.id);
                     }
                     this.items = this.items.filter(x => x.id !== id);
-                    this.ClearSeriesSegments(item.id);
                     (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Trigger({ isEnabling: false, itemId: item.id });
                 }
             }
@@ -22749,14 +23564,38 @@
                 if (poolIndex < 0) {
                     return null;
                 }
-                const pooled = this.pendingHandoffPool[poolIndex].renderManager;
+                const pooledItem = this.pendingHandoffPool[poolIndex];
+                const pooled = pooledItem.renderManager;
                 const payload = pooled.PrepareHandoff();
                 if (!payload) {
                     return null;
                 }
                 this.pendingHandoffPool.splice(poolIndex, 1);
+                this.transferSeriesSegments(pooledItem.id, item.id);
                 return payload;
             }
+            /**
+             * Moves any series segments recorded for one menu item over to another, for a claimed hand-off.
+             * The adopting manager may legitimately skip re-rendering (nothing to restyle), and segments are only
+             * ever reported from inside a render, so without this the claiming item would end up with none.
+             */
+            transferSeriesSegments(fromItemId, toItemId) {
+                const segments = this.seriesSegments.get(fromItemId);
+                if (!(segments === null || segments === void 0 ? void 0 : segments.length)) {
+                    this.ClearSeriesSegments(fromItemId);
+                    return;
+                }
+                this.seriesSegments.delete(fromItemId);
+                this.OnSeriesUpdated.Trigger({ itemId: fromItemId, segments: [] });
+                const existing = this.seriesSegments.get(toItemId) || [];
+                for (const segment of segments) {
+                    if (!existing.some((s) => s.key === segment.key)) {
+                        existing.push(segment);
+                    }
+                }
+                this.seriesSegments.set(toItemId, existing);
+                this.OnSeriesUpdated.Trigger({ itemId: toItemId, segments: existing });
+            }
             // Disposes everything left unclaimed in the pending-hand-off pool.
             FlushPendingHandoffs() {
                 var _a;
@@ -22772,6 +23611,7 @@
                     catch (e) {
                         console.error(e);
                     }
+                    this.ClearSeriesSegments(item.id);
                 }
             }
             GetEnabledItemIds() {
@@ -34128,6 +34968,10 @@
         }
         return minDistance;
     }
+    // Slack added when proving a zoom band cannot have changed.
+    // See CouldBandHaveChanged: an entity's measured distance can jump by its altitude spread as the camera crosses over its footprint,
+    // so being this close to a band edge means re-checking rather than trusting the bound.
+    const BAND_EDGE_MARGIN_METERS = 500;
     // Cache for distance calculations.
     // It will keep only the most recent 3000 entries.
     const distanceCache = new BModels.LRUCache(3000);
@@ -34270,7 +35114,7 @@
     }
     (function (RenderManager) {
         function DetermineZoomItem(params) {
-            const { viewer, entity, zoomControl } = params;
+            const { viewer, entity, zoomControl, out } = params;
             const pos = exports.EntityUtils.GetPos({
                 viewer,
                 entity
@@ -34283,11 +35127,16 @@
             if (!cameraPos || !cameraPos.latitude) {
                 return null;
             }
-            const distance = calculateDistance({
+            const cameraCarto = {
                 altitude: cameraPos.height,
                 latitude: Cesium.Math.toDegrees(cameraPos.latitude),
                 longitude: Cesium.Math.toDegrees(cameraPos.longitude)
-            }, entity);
+            };
+            const distance = calculateDistance(cameraCarto, entity);
+            if (out) {
+                out.distance = distance;
+                out.cameraPos = Cesium.Cartesian3.fromDegrees(cameraCarto.longitude, cameraCarto.latitude, cameraCarto.altitude);
+            }
             let zoomItem = (!distance && distance != 0) ? null : GetZoomControlFromDistance({
                 zoomControl,
                 distance
@@ -34300,6 +35149,41 @@
             return zoomItem;
         }
         RenderManager.DetermineZoomItem = DetermineZoomItem;
+        /**
+         * Returns whether an entity could have moved into a different zoom band since its graphic was rendered,
+         * given where the camera is now.
+         *
+         * Answers true whenever it cannot prove otherwise, so a caller may safely skip only on a false.
+         */
+        function CouldBandHaveChanged(params) {
+            var _a;
+            const { viewer, bandCheck } = params;
+            if (!bandCheck || bandCheck.distance == null || !bandCheck.cameraPos) {
+                return true;
+            }
+            // An absent range is not something to reason about. Values that ARE present go through EnsureNumber so
+            // this agrees with how GetZoomControlFromDistance matched the band in the first place.
+            if (bandCheck.min == null || bandCheck.max == null) {
+                return true;
+            }
+            const min = EnsureNumber(bandCheck.min);
+            const max = EnsureNumber(bandCheck.max);
+            if (!(max > min)) {
+                return true;
+            }
+            const cameraPos = (_a = viewer.camera) === null || _a === void 0 ? void 0 : _a.positionCartographic;
+            if (!cameraPos || !cameraPos.latitude) {
+                return true;
+            }
+            const nowPos = Cesium.Cartesian3.fromDegrees(Cesium.Math.toDegrees(cameraPos.longitude), Cesium.Math.toDegrees(cameraPos.latitude), cameraPos.height);
+            const travelled = Cesium.Cartesian3.distance(nowPos, bandCheck.cameraPos);
+            if (isNaN(travelled)) {
+                return true;
+            }
+            const slack = travelled + BAND_EDGE_MARGIN_METERS;
+            return (bandCheck.distance - slack) < min || (bandCheck.distance + slack) > max;
+        }
+        RenderManager.CouldBandHaveChanged = CouldBandHaveChanged;
         function GetZoomControlFromDistance(params) {
             const { zoomControl, distance } = params;
             for (let i = 0; i < zoomControl.length; i++) {
@@ -34311,6 +35195,26 @@
             return null;
         }
         RenderManager.GetZoomControlFromDistance = GetZoomControlFromDistance;
+        /**
+         * Everything in a zoom control that changes how an entity is drawn, as a comparable string.
+         * Used to tell whether two menu items would produce identical graphics (see a manager's GetRenderSignature).
+         * A false mismatch only costs an optimization, so key ordering inside an inline Style is not normalized.
+         */
+        function GetZoomControlSignature(zoomControl) {
+            return JSON.stringify([].concat(zoomControl !== null && zoomControl !== void 0 ? zoomControl : []).map((zoomItem) => {
+                var _a, _b, _c, _d, _e, _f, _g;
+                return ({
+                    MinZoom: (_a = zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.MinZoom) !== null && _a !== void 0 ? _a : null,
+                    MaxZoom: (_b = zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.MaxZoom) !== null && _b !== void 0 ? _b : null,
+                    DisplayType: (_c = zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.DisplayType) !== null && _c !== void 0 ? _c : null,
+                    StyleID: (_d = zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.StyleID) !== null && _d !== void 0 ? _d : null,
+                    Style: (_e = zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.Style) !== null && _e !== void 0 ? _e : null,
+                    LODCategoryID: (_f = zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.LODCategoryID) !== null && _f !== void 0 ? _f : null,
+                    LODLevel: (_g = zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.LODLevel) !== null && _g !== void 0 ? _g : null
+                });
+            }));
+        }
+        RenderManager.GetZoomControlSignature = GetZoomControlSignature;
         function GetZoomMinMax(params) {
             const { zoomControl } = params;
             let min = 0;
@@ -34395,8 +35299,8 @@
                     // We'll remove all that aren't in the allowed (direct) list.
                     for (let i = 0; i < parts.length - 1; i++) {
                         const part = parts[i];
-                        if (part && part instanceof Cesium.Entity && params.viewer.entities.contains(part) && !cEntity._siblingGraphics.includes(part)) {
-                            params.viewer.entities.remove(part);
+                        if (part && part instanceof Cesium.Entity && !cEntity._siblingGraphics.includes(part)) {
+                            RemoveCEntityFromScene(params.viewer, part);
                         }
                     }
                     if (cEntity._parentEntity) {
@@ -34740,7 +35644,6 @@
                         cEntity.ellipse.semiMajorAxis = new Cesium.ConstantProperty(radius);
                         cEntity.ellipse.semiMinorAxis = new Cesium.ConstantProperty(radius);
                     }
-                    cEntity.ellipse.outlineWidth = undefined;
                     {
                         const curHeightRef = GetCValue(params.viewer, cEntity.ellipse.heightReference);
                         if (curHeightRef != heightRef) {
@@ -34761,13 +35664,26 @@
                             cEntity.ellipse.extrudedHeight = new Cesium.ConstantProperty(extrusion.value);
                         }
                     }
-                    cEntity.ellipse.zIndex = new Cesium.ConstantProperty(1);
-                    cEntity.ellipse.distanceDisplayCondition = new Cesium.ConstantProperty(exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
+                    SetCPropIfChanged({
+                        viewer: params.viewer,
+                        graphic: cEntity.ellipse,
+                        property: "zIndex",
+                        value: 1
+                    });
+                    SetCPropIfChanged({
+                        viewer: params.viewer,
+                        graphic: cEntity.ellipse,
+                        property: "distanceDisplayCondition",
+                        value: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance)
+                    });
                     const curClassification = GetCValue(params.viewer, cEntity.ellipse.classificationType);
                     if (curClassification != classification) {
                         cEntity.ellipse.classificationType = new Cesium.ConstantProperty(classification);
                     }
-                    cEntity.position = new Cesium.ConstantPositionProperty(pos3d === null || pos3d === void 0 ? void 0 : pos3d.clone());
+                    const curPos = GetCValue(params.viewer, cEntity.position);
+                    if (!curPos || !pos3d || !Cesium.Cartesian3.equals(curPos, pos3d)) {
+                        cEntity.position = new Cesium.ConstantPositionProperty(pos3d === null || pos3d === void 0 ? void 0 : pos3d.clone());
+                    }
                     // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
                     // WARNING: ellipse does not support animation (yet?).
                     exports.CesiumEntityStyler.SetDefaultColor({
@@ -34775,6 +35691,8 @@
                         entity: cEntity,
                         viewer: params.viewer,
                         override: true,
+                        // Fill colour only. The outline sibling gets its own cOutline baked below.
+                        includeSiblings: false,
                         requestRender: false
                     });
                     cEntity.show = true;
@@ -34813,8 +35731,18 @@
                                 outlineEntity.ellipse.extrudedHeight = new Cesium.ConstantProperty(outlineExtrusion.value);
                             }
                         }
-                        outlineEntity.ellipse.zIndex = new Cesium.ConstantProperty(2);
-                        outlineEntity.ellipse.distanceDisplayCondition = new Cesium.ConstantProperty(exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
+                        SetCPropIfChanged({
+                            viewer: params.viewer,
+                            graphic: outlineEntity.ellipse,
+                            property: "zIndex",
+                            value: 2
+                        });
+                        SetCPropIfChanged({
+                            viewer: params.viewer,
+                            graphic: outlineEntity.ellipse,
+                            property: "distanceDisplayCondition",
+                            value: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance)
+                        });
                         const curClassification = GetCValue(params.viewer, outlineEntity.ellipse.classificationType);
                         if (curClassification != classification) {
                             outlineEntity.ellipse.classificationType = new Cesium.ConstantProperty(classification);
@@ -34826,6 +35754,7 @@
                             entity: outlineEntity,
                             viewer: params.viewer,
                             override: true,
+                            includeSiblings: false,
                             requestRender: false
                         });
                         outlineEntity.show = true;
@@ -35090,7 +36019,7 @@
                 // De-dupe the tag IDs.
                 tagIds = Array.from(new Set(tagIds));
                 // Request if at least one then create a quick lookup map for tags.
-                const tags = tagIds.length > 0 ? (await BModels.EntityTag.GetListByIds({
+                const tags = (!params.offline && tagIds.length > 0) ? (await BModels.EntityTag.GetListByIds({
                     api,
                     tagIds
                 })).tags : [];
@@ -35102,7 +36031,7 @@
             for (let i = 0; i < params.entities.length; i++) {
                 const entity = params.entities[i];
                 const zoomItem = params.zoomItems[entity.Bruce.ID];
-                const style = zoomItem.StyleID != -1 ? (_a = (await getStyle$1(api, entity, zoomItem.StyleID))) === null || _a === void 0 ? void 0 : _a.Settings : zoomItem.Style;
+                const style = (!params.offline && zoomItem.StyleID != -1) ? (_a = (await getStyle$1(api, entity, zoomItem.StyleID))) === null || _a === void 0 ? void 0 : _a.Settings : zoomItem.Style;
                 // Pass through tags that may be needed for styling.
                 const tagIds = entity.Bruce["Layer.ID"];
                 const tags = [];
@@ -35140,7 +36069,7 @@
                     rego: rego
                 });
                 if (cEntity) {
-                    const name = await getName(api, entity);
+                    const name = await getName(api, entity, params.offline);
                     cEntity.name = name;
                     cEntity._renderGroup = exports.EntityRenderEngine.GetRenderGroupId(zoomItem);
                     cEntity.styleId = zoomItem.StyleID == -1 ? -1 : (+zoomItem.StyleID || null);
@@ -35311,7 +36240,16 @@
         }
         return data;
     }
-    async function getName(api, entity) {
+    async function getName(api, entity, offline) {
+        var _a;
+        const ownName = GetUsableEntityName(entity);
+        if (ownName) {
+            return ownName;
+        }
+        if (offline) {
+            // Anything further needs a request, so offline callers take what the entity carries, placeholder or not.
+            return ((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.Name) || "Unnamed Entity";
+        }
         try {
             const typeId = entity.Bruce["EntityType.ID"];
             let type = null;
@@ -35487,8 +36425,8 @@
                     // We'll remove all that aren't in the allowed (direct) list.
                     for (let i = 0; i < parts.length - 1; i++) {
                         const part = parts[i];
-                        if (part && part instanceof Cesium.Entity && params.viewer.entities.contains(part) && !cEntity._siblingGraphics.includes(part)) {
-                            params.viewer.entities.remove(part);
+                        if (part && part instanceof Cesium.Entity && !cEntity._siblingGraphics.includes(part)) {
+                            RemoveCEntityFromScene(params.viewer, part);
                         }
                     }
                     if (cEntity._parentEntity) {
@@ -35981,7 +36919,7 @@
                 // De-dupe the tag IDs.
                 tagIds = Array.from(new Set(tagIds));
                 // Request if at least one then create a quick lookup map for tags.
-                const tags = tagIds.length > 0 ? (await BModels.EntityTag.GetListByIds({
+                const tags = (!params.offline && tagIds.length > 0) ? (await BModels.EntityTag.GetListByIds({
                     api,
                     tagIds
                 })).tags : [];
@@ -35993,7 +36931,7 @@
             for (let i = 0; i < params.entities.length; i++) {
                 const entity = params.entities[i];
                 const zoomItem = params.zoomItems[entity.Bruce.ID];
-                const style = zoomItem.StyleID != -1 ? (_a = (await getStyle$2(api, entity, zoomItem.StyleID))) === null || _a === void 0 ? void 0 : _a.Settings : zoomItem.Style;
+                const style = (!params.offline && zoomItem.StyleID != -1) ? (_a = (await getStyle$2(api, entity, zoomItem.StyleID))) === null || _a === void 0 ? void 0 : _a.Settings : zoomItem.Style;
                 // Pass through tags that may be needed for styling.
                 const tagIds = entity.Bruce["Layer.ID"];
                 const tags = [];
@@ -36032,8 +36970,8 @@
             for (let i = 0; i < params.entities.length; i++) {
                 const entity = params.entities[i];
                 const zoomItem = params.zoomItems[entity.Bruce.ID];
-                const styleRecord = zoomItem.StyleID != -1 ? (await getStyle$2(api, entity, zoomItem.StyleID)) : null;
-                const style = zoomItem.StyleID != -1 ? styleRecord === null || styleRecord === void 0 ? void 0 : styleRecord.Settings : zoomItem.Style;
+                const styleRecord = (!params.offline && zoomItem.StyleID != -1) ? (await getStyle$2(api, entity, zoomItem.StyleID)) : null;
+                const style = (!params.offline && zoomItem.StyleID != -1) ? styleRecord === null || styleRecord === void 0 ? void 0 : styleRecord.Settings : zoomItem.Style;
                 const lod = lodData.find(x => x.entityId == entity.Bruce.ID);
                 if (!(lod === null || lod === void 0 ? void 0 : lod.clientFileId)) {
                     continue;
@@ -36079,7 +37017,7 @@
                     rego: rego
                 });
                 if (cEntity) {
-                    const name = await getName$1(api, entity);
+                    const name = await getName$1(api, entity, params.offline);
                     cEntity.name = name;
                     cEntity._renderGroup = exports.EntityRenderEngine.GetRenderGroupId(zoomItem);
                     cEntity.styleId = zoomItem.StyleID == -1 ? -1 : styleRecord === null || styleRecord === void 0 ? void 0 : styleRecord.ID;
@@ -36105,7 +37043,16 @@
         }
         return heightRef;
     }
-    async function getName$1(api, entity) {
+    async function getName$1(api, entity, offline) {
+        var _a;
+        const ownName = GetUsableEntityName(entity);
+        if (ownName) {
+            return ownName;
+        }
+        if (offline) {
+            // Anything further needs a request, so offline callers take what the entity carries, placeholder or not.
+            return ((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.Name) || "Unnamed Entity";
+        }
         try {
             const typeId = entity.Bruce["EntityType.ID"];
             let type = null;
@@ -36374,8 +37321,8 @@
                     // Kill all expect last part. Last one is the primary entity.
                     for (let i = 0; i < parts.length - 1; i++) {
                         const part = parts[i];
-                        if (part && part instanceof Cesium.Entity && params.viewer.entities.contains(part)) {
-                            params.viewer.entities.remove(part);
+                        if (part && part instanceof Cesium.Entity) {
+                            RemoveCEntityFromScene(params.viewer, part);
                         }
                     }
                     cEntity._siblingGraphics = [];
@@ -36406,7 +37353,12 @@
                     if (oldClampToGround != newClampToGround) {
                         cEntity.polyline.clampToGround = new Cesium.ConstantProperty(newClampToGround);
                     }
-                    cEntity.polyline.distanceDisplayCondition = new Cesium.ConstantProperty(exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
+                    SetCPropIfChanged({
+                        viewer: params.viewer,
+                        graphic: cEntity.polyline,
+                        property: "distanceDisplayCondition",
+                        value: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance)
+                    });
                     cEntity.corridor = undefined;
                 }
                 else {
@@ -36430,7 +37382,12 @@
                     if (oldZIndex != getZIndex(style, entity, params.tags)) {
                         cEntity.corridor.zIndex = new Cesium.ConstantProperty(getZIndex(style, entity, params.tags));
                     }
-                    cEntity.corridor.distanceDisplayCondition = new Cesium.ConstantProperty(exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width));
+                    SetCPropIfChanged({
+                        viewer: params.viewer,
+                        graphic: cEntity.corridor,
+                        property: "distanceDisplayCondition",
+                        value: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width)
+                    });
                     cEntity.polyline = undefined;
                 }
                 // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
@@ -36498,7 +37455,7 @@
                 // De-dupe the tag IDs.
                 tagIds = Array.from(new Set(tagIds));
                 // Request if at least one then create a quick lookup map for tags.
-                const tags = tagIds.length > 0 ? (await BModels.EntityTag.GetListByIds({
+                const tags = (!params.offline && tagIds.length > 0) ? (await BModels.EntityTag.GetListByIds({
                     api,
                     tagIds
                 })).tags : [];
@@ -36510,7 +37467,7 @@
             for (let i = 0; i < params.entities.length; i++) {
                 const entity = params.entities[i];
                 const zoomItem = params.zoomItems[entity.Bruce.ID];
-                const style = zoomItem.StyleID != -1 ? (_a = (await getStyle$3(api, entity, zoomItem.StyleID))) === null || _a === void 0 ? void 0 : _a.Settings : zoomItem.Style;
+                const style = (!params.offline && zoomItem.StyleID != -1) ? (_a = (await getStyle$3(api, entity, zoomItem.StyleID))) === null || _a === void 0 ? void 0 : _a.Settings : zoomItem.Style;
                 // Pass through tags that may be needed for styling.
                 const tagIds = entity.Bruce["Layer.ID"];
                 const tags = [];
@@ -36533,7 +37490,7 @@
                     rendered: (_c = params.rendered) === null || _c === void 0 ? void 0 : _c.get(entity.Bruce.ID)
                 });
                 if (cEntity) {
-                    const name = await getName$2(api, entity);
+                    const name = await getName$2(api, entity, params.offline);
                     cEntity.name = name;
                     cEntity._renderGroup = exports.EntityRenderEngine.GetRenderGroupId(zoomItem);
                     cEntity.styleId = zoomItem.StyleID == -1 ? -1 : (+zoomItem.StyleID || null);
@@ -36544,7 +37501,16 @@
         }
         EntityRenderEnginePolyline.RenderGroup = RenderGroup;
     })(exports.EntityRenderEnginePolyline || (exports.EntityRenderEnginePolyline = {}));
-    async function getName$2(api, entity) {
+    async function getName$2(api, entity, offline) {
+        var _a;
+        const ownName = GetUsableEntityName(entity);
+        if (ownName) {
+            return ownName;
+        }
+        if (offline) {
+            // Anything further needs a request, so offline callers take what the entity carries, placeholder or not.
+            return ((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.Name) || "Unnamed Entity";
+        }
         try {
             const typeId = entity.Bruce["EntityType.ID"];
             let type = null;
@@ -36786,6 +37752,13 @@
             GetArchiveUrl() {
                 return this.archiveUrl;
             }
+            /**
+             * The property this instance presents frames through, for a caller that needs to rebuild the entity's
+             * material (eg: re-tinting for opacity/selection) without detaching the animation.
+             */
+            GetImageProperty() {
+                return this.imageProperty;
+            }
             onClockTick(currentTime) {
                 if (this.disposed) {
                     return;
@@ -36974,8 +37947,9 @@
     const TEXTURE_FRAME_SERIES_ANIMATOR_KEY = "TextureFrameSeriesAnimator.Animator";
     (function (EntityRenderEnginePolygon) {
         async function Render(params) {
-            var _a, _b;
+            var _a, _b, _c;
             const entity = params.entity;
+            const style = params.style;
             const pRings = BModels.Entity.GetValue({
                 entity: entity,
                 path: ["Bruce", "VectorGeometry", "Polygon"]
@@ -36983,7 +37957,6 @@
             if (pRings == null || !Array.isArray(pRings) || pRings.length <= 0) {
                 return null;
             }
-            const style = params.style;
             const fillType = style.fillType || BModels.Style.EPolygonFillType.Color;
             const fillColorTrace = style.fillColor ? BModels.Calculator.TraceGetColor(style.fillColor, entity, params.tags) : { value: null, effective: null };
             const bFillColor = fillColorTrace.value;
@@ -36991,16 +37964,21 @@
             let textureDataUri = null;
             let textureTraceEffective = null;
             let frameArchive = null;
-            if (fillType === BModels.Style.EPolygonFillType.Texture) {
-                const resolved = await resolveTexturedFill({
-                    api: params.api,
-                    style,
-                    entity,
-                    tags: params.tags
-                });
-                textureDataUri = resolved.dataUri;
-                textureTraceEffective = resolved.effective;
-                frameArchive = resolved.frameArchive || null;
+            if (fillType === BModels.Style.EPolygonFillType.Texture && !params.offline) {
+                try {
+                    const resolved = await resolveTexturedFill({
+                        api: params.api,
+                        style,
+                        entity,
+                        tags: params.tags
+                    });
+                    textureDataUri = resolved.dataUri;
+                    textureTraceEffective = resolved.effective;
+                    frameArchive = resolved.frameArchive || null;
+                }
+                catch (e) {
+                    console.error(`Polygon.Render: failed to resolve textured fill for entity ${((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID) || "<NONE>"}:`, e);
+                }
             }
             const hasFill = fillType === BModels.Style.EPolygonFillType.Texture
                 ? Boolean(textureDataUri || frameArchive || cFillColor.alpha > 0)
@@ -37067,8 +38045,8 @@
                     // We'll remove all that aren't in the allowed (direct) list.
                     for (let i = 0; i < parts.length - 1; i++) {
                         const part = parts[i];
-                        if (part && part instanceof Cesium.Entity && params.viewer.entities.contains(part) && !cEntity._siblingGraphics.includes(part)) {
-                            params.viewer.entities.remove(part);
+                        if (part && part instanceof Cesium.Entity && !cEntity._siblingGraphics.includes(part)) {
+                            RemoveCEntityFromScene(params.viewer, part);
                         }
                     }
                     if (cEntity._parentEntity) {
@@ -37078,7 +38056,8 @@
             };
             const hasOutline = width > 0 && cLineColor;
             let cEntity = null;
-            if (!params.rendered || !params.rendered.polygon) {
+            const isExistingGraphic = Boolean(params.rendered && params.rendered.polygon);
+            if (!isExistingGraphic) {
                 cEntity = new Cesium.Entity({
                     id: BModels.ObjectUtils.UId(15),
                     polygon: {
@@ -37091,7 +38070,7 @@
                         classificationType: classification,
                         perPositionHeight: heightRef == Cesium.HeightReference.CLAMP_TO_GROUND ? false : true,
                         zIndex: zIndex,
-                        distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width <= 0 || !cLineColor || units == "m" ? size : null, true)
+                        distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width <= 0 || !cLineColor || units == "m" ? size : null, true, size)
                     },
                     position: exports.EntityUtils.GetPos({
                         viewer: params.viewer,
@@ -37145,9 +38124,38 @@
                 if (oldZIndex != zIndex) {
                     cEntity.polygon.zIndex = new Cesium.ConstantProperty(zIndex);
                 }
-                cEntity.polygon.distanceDisplayCondition = new Cesium.ConstantProperty(exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width <= 0 || !cLineColor || units == "m" ? size : null, true));
-                cEntity.polygon.shadows = new Cesium.ConstantProperty(Cesium.ShadowMode.ENABLED);
-                cEntity.polygon.classificationType = new Cesium.ConstantProperty(classification);
+                SetCPropIfChanged({
+                    viewer: params.viewer,
+                    graphic: cEntity.polygon,
+                    property: "distanceDisplayCondition",
+                    value: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width <= 0 || !cLineColor || units == "m" ? size : null, true, size)
+                });
+                SetCPropIfChanged({
+                    viewer: params.viewer,
+                    graphic: cEntity.polygon,
+                    property: "shadows",
+                    value: Cesium.ShadowMode.ENABLED
+                });
+                SetCPropIfChanged({
+                    viewer: params.viewer,
+                    graphic: cEntity.polygon,
+                    property: "classificationType",
+                    value: classification
+                });
+                cEntity.show = true;
+            }
+            // Must run before any material is baked below: the Animator takes over polygon.material, so a bake
+            // has to know whether it is baking over a live animation or over a disposed one's restored material.
+            const animator = syncTextureFrameArchive(cEntity, frameArchive, params.viewer, style.textureColorMask);
+            if (animator) {
+                exports.CesiumEntityStyler.SetDefaultTextureImage({
+                    entity: cEntity,
+                    image: animator.GetImageProperty(),
+                    viewer: params.viewer,
+                    requestRender: false
+                });
+            }
+            else if (isExistingGraphic) {
                 // TODO: animate the texture!
                 if (textureDataUri) {
                     // Rebaking texture to ensure we don't revert to the wrong one later.
@@ -37174,12 +38182,12 @@
                         entity: cEntity,
                         viewer: params.viewer,
                         override: true,
+                        // Fill colour only. The outline sibling gets its own line colour baked below.
+                        includeSiblings: false,
                         requestRender: false
                     });
                 }
-                cEntity.show = true;
             }
-            syncTextureFrameArchive(cEntity, frameArchive, params.viewer, style.textureColorMask);
             if (frameArchive && params.onSeriesDiscovered) {
                 const segment = frameArchiveToSeriesSegment(frameArchive, params.entity);
                 if (segment) {
@@ -37198,7 +38206,7 @@
                     }
                 }
                 let borderPosses = posses.map(x => x.clone ? x.clone() : { ...x });
-                let cEntityBorder = (_b = (_a = params.rendered) === null || _a === void 0 ? void 0 : _a._siblingGraphics) === null || _b === void 0 ? void 0 : _b[0];
+                let cEntityBorder = (_c = (_b = params.rendered) === null || _b === void 0 ? void 0 : _b._siblingGraphics) === null || _c === void 0 ? void 0 : _c[0];
                 cEntity._siblingGraphics = [];
                 if (!cEntityBorder || ((!cEntityBorder.polyline && units == "px") ||
                     (!cEntityBorder.corridor && units == "m"))) {
@@ -37212,7 +38220,7 @@
                             classificationType: Cesium.ClassificationType.TERRAIN,
                             arcType: Cesium.ArcType.GEODESIC,
                             zIndex: zIndex,
-                            distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance)
+                            distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, null, false, size)
                         }) : null,
                         corridor: units == "m" ? {
                             positions: borderPosses,
@@ -37224,7 +38232,7 @@
                             zIndex: zIndex + 1,
                             cornerType: Cesium.CornerType.MITERED,
                             classificationType: classification,
-                            distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width),
+                            distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width, false, size),
                             shadows: Cesium.ShadowMode.ENABLED
                         } : null,
                         show: true
@@ -37251,11 +38259,21 @@
                         }
                         const oldMaterial = GetCValue(params.viewer, cEntityBorder.polyline.material);
                         const newMaterial = new Cesium.ColorMaterialProperty(cLineColor);
-                        if (compareColorMaterials(params.viewer, oldMaterial, newMaterial)) {
+                        if (!areColorMaterialsEqual(params.viewer, oldMaterial, newMaterial)) {
                             cEntityBorder.polyline.material = newMaterial;
                         }
-                        cEntityBorder.polyline.classificationType = new Cesium.ConstantProperty(Cesium.ClassificationType.TERRAIN);
-                        cEntityBorder.polyline.distanceDisplayCondition = new Cesium.ConstantProperty(exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
+                        SetCPropIfChanged({
+                            viewer: params.viewer,
+                            graphic: cEntityBorder.polyline,
+                            property: "classificationType",
+                            value: Cesium.ClassificationType.TERRAIN
+                        });
+                        SetCPropIfChanged({
+                            viewer: params.viewer,
+                            graphic: cEntityBorder.polyline,
+                            property: "distanceDisplayCondition",
+                            value: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, null, false, size)
+                        });
                         cEntityBorder.corridor = undefined;
                     }
                     else {
@@ -37281,15 +38299,35 @@
                         }
                         const oldMaterial = GetCValue(params.viewer, cEntityBorder.corridor.material);
                         const newMaterial = new Cesium.ColorMaterialProperty(cLineColor);
-                        if (compareColorMaterials(params.viewer, oldMaterial, newMaterial)) {
+                        if (!areColorMaterialsEqual(params.viewer, oldMaterial, newMaterial)) {
                             cEntityBorder.corridor.material = newMaterial;
                         }
-                        cEntityBorder.corridor.fill = new Cesium.ConstantProperty(true);
-                        cEntityBorder.corridor.distanceDisplayCondition = new Cesium.ConstantProperty(exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width));
+                        SetCPropIfChanged({
+                            viewer: params.viewer,
+                            graphic: cEntityBorder.corridor,
+                            property: "fill",
+                            value: true
+                        });
+                        SetCPropIfChanged({
+                            viewer: params.viewer,
+                            graphic: cEntityBorder.corridor,
+                            property: "distanceDisplayCondition",
+                            value: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width, false, size)
+                        });
                         cEntityBorder.polyline = undefined;
                     }
                     cEntityBorder.show = true;
                 }
+                // Bake the outline's own colour as its default, so a deselect/opacity refresh restores the line
+                // colour rather than falling back to the fill's.
+                exports.CesiumEntityStyler.SetDefaultColor({
+                    color: cLineColor,
+                    entity: cEntityBorder,
+                    viewer: params.viewer,
+                    override: true,
+                    includeSiblings: false,
+                    requestRender: false
+                });
                 cEntityBorder._parentEntity = cEntity;
                 cEntity._siblingGraphics.push(cEntityBorder);
                 for (let i = 0; i < holePosses.length; i++) {
@@ -37305,7 +38343,7 @@
                             classificationType: Cesium.ClassificationType.TERRAIN,
                             arcType: Cesium.ArcType.GEODESIC,
                             zIndex: zIndex,
-                            distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance)
+                            distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, null, false, size)
                         }) : null,
                         corridor: units == "m" ? {
                             positions: borderPosses,
@@ -37317,7 +38355,7 @@
                             zIndex: zIndex + 1,
                             cornerType: Cesium.CornerType.MITERED,
                             classificationType: classification,
-                            distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width),
+                            distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width, false, size),
                             shadows: Cesium.ShadowMode.ENABLED,
                         } : null,
                         show: true
@@ -37339,7 +38377,7 @@
         }
         EntityRenderEnginePolygon.Render = Render;
         async function RenderGroup(params) {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             const api = params.apiGetter.getApi();
             const cEntities = new Map();
             // Gathering tags in case styling needs it.
@@ -37358,7 +38396,7 @@
                 // De-dupe the tag IDs.
                 tagIds = Array.from(new Set(tagIds));
                 // Request if at least one then create a quick lookup map for tags.
-                const tags = tagIds.length > 0 ? (await BModels.EntityTag.GetListByIds({
+                const tags = (!params.offline && tagIds.length > 0) ? (await BModels.EntityTag.GetListByIds({
                     api,
                     tagIds
                 })).tags : [];
@@ -37370,7 +38408,7 @@
             for (let i = 0; i < params.entities.length; i++) {
                 const entity = params.entities[i];
                 const zoomItem = params.zoomItems[entity.Bruce.ID];
-                const style = zoomItem.StyleID != -1 ? (_a = (await getStyle$4(api, entity, zoomItem.StyleID))) === null || _a === void 0 ? void 0 : _a.Settings : zoomItem.Style;
+                const style = (!params.offline && zoomItem.StyleID != -1) ? (_a = (await getStyle$4(api, entity, zoomItem.StyleID))) === null || _a === void 0 ? void 0 : _a.Settings : zoomItem.Style;
                 // Pass through tags that may be needed for styling.
                 const tagIds = entity.Bruce["Layer.ID"];
                 const tags = [];
@@ -37383,23 +38421,29 @@
                     }
                 }
                 const pStyle = (_b = style === null || style === void 0 ? void 0 : style.polygonStyle) !== null && _b !== void 0 ? _b : {};
-                const cEntity = await Render({
-                    entity: entity,
-                    style: pStyle,
-                    tags: tags,
-                    viewer: params.viewer,
-                    api,
-                    maxDistance: zoomItem.MaxZoom,
-                    minDistance: zoomItem.MinZoom,
-                    // Temporarily disabling re-using graphics for polygons as they have some bugs, and
-                    // they don't support any animation yet.
-                    // rendered: null
-                    rendered: (_c = params.rendered) === null || _c === void 0 ? void 0 : _c.get(entity.Bruce.ID),
-                    menuItemId: params.menuItemId,
-                    onSeriesDiscovered: params.onSeriesDiscovered
-                });
+                let cEntity = null;
+                try {
+                    cEntity = await Render({
+                        entity: entity,
+                        style: pStyle,
+                        tags: tags,
+                        viewer: params.viewer,
+                        api,
+                        maxDistance: zoomItem.MaxZoom,
+                        minDistance: zoomItem.MinZoom,
+                        // Temporarily disabling re-using graphics for polygons as they have some bugs, and
+                        // they don't support any animation yet.
+                        // rendered: null
+                        rendered: (_c = params.rendered) === null || _c === void 0 ? void 0 : _c.get(entity.Bruce.ID),
+                        menuItemId: params.menuItemId,
+                        onSeriesDiscovered: params.onSeriesDiscovered
+                    });
+                }
+                catch (e) {
+                    console.error(`Polygon.RenderGroup: failed to render entity ${((_d = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _d === void 0 ? void 0 : _d.ID) || "<NONE>"}:`, e);
+                }
                 if (cEntity) {
-                    const name = await getName$3(api, entity);
+                    const name = await getName$3(api, entity, params.offline);
                     cEntity.name = name;
                     cEntity._renderGroup = exports.EntityRenderEngine.GetRenderGroupId(zoomItem);
                     cEntity.styleId = zoomItem.StyleID == -1 ? -1 : (+zoomItem.StyleID || null);
@@ -37421,7 +38465,16 @@
         }
         EntityRenderEnginePolygon.DisposeTextureFrameSeriesAnimator = DisposeTextureFrameSeriesAnimator;
     })(exports.EntityRenderEnginePolygon || (exports.EntityRenderEnginePolygon = {}));
-    async function getName$3(api, entity) {
+    async function getName$3(api, entity, offline) {
+        var _a;
+        const ownName = GetUsableEntityName(entity);
+        if (ownName) {
+            return ownName;
+        }
+        if (offline) {
+            // Anything further needs a request, so offline callers take what the entity carries, placeholder or not.
+            return ((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.Name) || "Unnamed Entity";
+        }
         try {
             const typeId = entity.Bruce["EntityType.ID"];
             let type = null;
@@ -37525,6 +38578,7 @@
     /**
      * Reconciles cEntity's TextureFrameSeriesAnimator.Animator (if any) against this render's resolved texture.
      * Called once cEntity is fully created/updated and definitely has a `polygon` graphics.
+     * Returns the animator now driving the entity, or null if this render has no frame series.
      * @param cEntity
      * @param frameArchive
      * @param viewer
@@ -37533,22 +38587,24 @@
     function syncTextureFrameArchive(cEntity, frameArchive, viewer, textureColorMask) {
         const existing = cEntity[TEXTURE_FRAME_SERIES_ANIMATOR_KEY];
         if (frameArchive && existing && !existing.IsDisposed() && existing.GetArchiveUrl() === frameArchive.url) {
-            return;
+            return existing;
         }
         if (existing && !existing.IsDisposed()) {
             existing.Dispose();
             cEntity[TEXTURE_FRAME_SERIES_ANIMATOR_KEY] = null;
         }
-        if (frameArchive) {
-            const animator = new TextureFrameSeriesAnimator.Animator({
-                viewer,
-                entity: cEntity,
-                archiveUrl: frameArchive.url,
-                frames: frameArchive.metadata.Frames,
-                textureColorMask
-            });
-            cEntity[TEXTURE_FRAME_SERIES_ANIMATOR_KEY] = animator;
+        if (!frameArchive) {
+            return null;
         }
+        const animator = new TextureFrameSeriesAnimator.Animator({
+            viewer,
+            entity: cEntity,
+            archiveUrl: frameArchive.url,
+            frames: frameArchive.metadata.Frames,
+            textureColorMask
+        });
+        cEntity[TEXTURE_FRAME_SERIES_ANIMATOR_KEY] = animator;
+        return animator;
     }
     /**
      * Derives a min/max/label time-range segment from a resolved frame archive's Frames metadata,
@@ -37715,7 +38771,7 @@
      * @param b
      * @returns
      */
-    function compareColorMaterials(viewer, a, b) {
+    function areColorMaterialsEqual(viewer, a, b) {
         // Same reference.
         if (a == b) {
             return true;
@@ -38024,15 +39080,44 @@
         }
     })(exports.StyleEffective || (exports.StyleEffective = {}));
     (function (EntityRenderEngine) {
+        /**
+         * Identifies the zoom band a graphic was last rendered for, covering everything in that band which
+         * changes how the entity is drawn. Used to decide whether a re-render is needed at all.
+         *
+         * Deliberately NOT the reuse key: most of a band's identity is plain graphics properties that can be
+         * patched onto the existing graphic, so see GetGraphicShapeId for that decision.
+         */
         function GetRenderGroupId(zoomItem) {
             if (!zoomItem) {
                 return null;
             }
-            return zoomItem.MinZoom + "-" + zoomItem.MaxZoom;
+            return exports.RenderManager.GetZoomControlSignature([zoomItem]);
         }
         EntityRenderEngine.GetRenderGroupId = GetRenderGroupId;
+        /**
+         * Identifies the kind of Cesium graphic a zoom item + entity resolves to, ignoring anything that is merely a property on it.
+         */
+        function GetGraphicShapeId(zoomItem, entity) {
+            var _a;
+            let displayType = zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.DisplayType;
+            if (!displayType) {
+                displayType = BModels.ZoomControl.EDisplayType.Hidden;
+            }
+            // Backwards compatibility, same mapping the render pass applies.
+            else if (displayType == "polygon") {
+                displayType = BModels.ZoomControl.EDisplayType.Geometry;
+            }
+            // Multi-geometry builds a container graphic holding sibling graphics rather than a flat one.
+            const geometry = BModels.Entity.GetValue({
+                entity: entity,
+                path: ["Bruce", "VectorGeometry"]
+            });
+            const isMulti = ((_a = geometry === null || geometry === void 0 ? void 0 : geometry.MultiGeometry) === null || _a === void 0 ? void 0 : _a.length) > 1;
+            return displayType + "|" + (isMulti ? "multi" : "single");
+        }
+        EntityRenderEngine.GetGraphicShapeId = GetGraphicShapeId;
         async function Render(params) {
-            var _a, _b, _c, _d;
+            var _a, _b, _c;
             const groupRenderParams = {
                 apiGetter: params.apiGetter,
                 viewer: params.viewer,
@@ -38040,10 +39125,15 @@
                 zoomItems: {},
                 menuItemId: params.menuItemId,
                 onSeriesDiscovered: params.onSeriesDiscovered,
-                visualRegister: params.visualRegister
+                visualRegister: params.visualRegister,
+                offline: params.offline
             };
             const updated = new Map();
             const cEntities = new Map();
+            // Entity ID -> the graphic shape resolved for this pass, stamped onto the results at the end.
+            const shapeIds = new Map();
+            // Entity ID -> what its zoom band was resolved from, stamped alongside the shape.
+            const bandChecks = new Map();
             const models = [];
             const multiGeometry = [];
             const polygons = [];
@@ -38093,11 +39183,21 @@
             for (let i = 0; i < params.entities.length; i++) {
                 let entity = params.entities[i];
                 const id = entity.Bruce.ID;
+                const resolution = {};
                 const zoomItem = exports.RenderManager.DetermineZoomItem({
                     viewer: params.viewer,
                     entity,
-                    zoomControl: params.zoomControl
-                });
+                    zoomControl: params.zoomControl,
+                    out: resolution
+                });
+                if (zoomItem && resolution.distance != null && resolution.cameraPos) {
+                    bandChecks.set(id, {
+                        distance: resolution.distance,
+                        cameraPos: resolution.cameraPos,
+                        min: zoomItem.MinZoom,
+                        max: zoomItem.MaxZoom
+                    });
+                }
                 let displayType = zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.DisplayType;
                 if (!displayType) {
                     displayType = BModels.ZoomControl.EDisplayType.Hidden;
@@ -38111,8 +39211,13 @@
                         entityId: id,
                         menuItemId: params.menuItemId
                     });
+                    const existingVisual = existingRego === null || existingRego === void 0 ? void 0 : existingRego.visual;
                     const newRenderId = GetRenderGroupId(zoomItem);
-                    const oldRenderId = (_a = existingRego === null || existingRego === void 0 ? void 0 : existingRego.visual) === null || _a === void 0 ? void 0 : _a._renderGroup;
+                    const oldRenderId = existingVisual === null || existingVisual === void 0 ? void 0 : existingVisual._renderGroup;
+                    // Resolved before prepareGeometry() below, which flattens a single-item MultiGeometry and
+                    // would otherwise make the same entity resolve to a different shape than it was stamped with.
+                    const newShapeId = GetGraphicShapeId(zoomItem, entity);
+                    shapeIds.set(id, newShapeId);
                     if (!params.force &&
                         newRenderId == oldRenderId &&
                         !(existingRego === null || existingRego === void 0 ? void 0 : existingRego.stale) &&
@@ -38122,13 +39227,13 @@
                         cEntities.set(id, existingRego.visual);
                     }
                     else {
-                        // Add so we can re-use the graphic and update it.
-                        if (existingRego && newRenderId == oldRenderId) {
+                        const oldShapeId = existingVisual === null || existingVisual === void 0 ? void 0 : existingVisual._graphicShape;
+                        if (existingRego && newShapeId == oldShapeId) {
                             cEntities.set(id, existingRego.visual);
                             // Flag as no longer stale as we're unlikely to recreate the rego if we're reusing the graphic.
                             existingRego.stale = false;
                             // Update metadata for the same reason.
-                            existingRego.outline = (_b = entity.Bruce) === null || _b === void 0 ? void 0 : _b.Outline;
+                            existingRego.outline = (_a = entity.Bruce) === null || _a === void 0 ? void 0 : _a.Outline;
                             existingRego.entityTypeId = entity.Bruce["EntityType.ID"];
                             updated.set(id, true);
                         }
@@ -38142,7 +39247,7 @@
                                 entity: entity,
                                 path: ["Bruce", "VectorGeometry"]
                             });
-                            if ((_c = geometry === null || geometry === void 0 ? void 0 : geometry.MultiGeometry) === null || _c === void 0 ? void 0 : _c.length) {
+                            if ((_b = geometry === null || geometry === void 0 ? void 0 : geometry.MultiGeometry) === null || _b === void 0 ? void 0 : _b.length) {
                                 multiGeometry.push(entity);
                             }
                             else {
@@ -38185,7 +39290,7 @@
                         entity: entity,
                         path: ["Bruce", "VectorGeometry"]
                     });
-                    if (!((_d = geometry === null || geometry === void 0 ? void 0 : geometry.MultiGeometry) === null || _d === void 0 ? void 0 : _d.length)) {
+                    if (!((_c = geometry === null || geometry === void 0 ? void 0 : geometry.MultiGeometry) === null || _c === void 0 ? void 0 : _c.length)) {
                         polygons.push(entity);
                         continue;
                     }
@@ -38304,6 +39409,21 @@
                     }
                 }
             }
+            // Stamped centrally rather than per-engine so the value always matches what the gate above compared,
+            // regardless of which engine (or fallback engine) ended up producing the graphic.
+            cEntities.forEach((cEntity, id) => {
+                if (!cEntity) {
+                    return;
+                }
+                const shapeId = shapeIds.get(id);
+                if (shapeId) {
+                    cEntity._graphicShape = shapeId;
+                }
+                const bandCheck = bandChecks.get(id);
+                if (bandCheck) {
+                    cEntity._bandCheck = bandCheck;
+                }
+            });
             return {
                 entities: cEntities,
                 updated
@@ -38339,9 +39459,7 @@
                         });
                     }
                 }
-                if (viewer.entities.contains(entity)) {
-                    viewer.entities.remove(entity);
-                }
+                RemoveCEntityFromScene(viewer, entity);
             }
             doRemove({
                 viewer: params.viewer,
@@ -38376,9 +39494,10 @@
          * @param max
          * @param meterSize size of "thing" in meters, eg polyline is 0.5 meters width. If size is provided we can potentially cull it earlier.
          * @param isPolygon
+         * @param fitMeterSize overall extent of the "thing" in meters, eg a parcel's bounding-box diagonal. If provided we keep it visible far enough out to actually fit on screen.
          * @returns
          */
-        function GetDisplayCondition(min, max, meterSize, isPolygon) {
+        function GetDisplayCondition(min, max, meterSize, isPolygon, fitMeterSize) {
             // Max is required.
             if (isNaN(+max)) {
                 return undefined;
@@ -38408,6 +39527,15 @@
                     return undefined;
                 }
             }
+            // The configured max is a guess about viewing distance, and for a large thing that guess is often short:
+            // it vanishes while still overflowing the screen, so you can never see all of it at once.
+            // A thing of size S needs roughly S * 0.87 of camera distance to fit a 60deg vertical fov, so we
+            // floor the max at a margin above that rather than culling something you haven't finished zooming out to.
+            fitMeterSize = +fitMeterSize;
+            if (!isNaN(fitMeterSize) && fitMeterSize > 0) {
+                const FIT_DISTANCE_PER_METER = 1.4;
+                max = Math.max(max, fitMeterSize * FIT_DISTANCE_PER_METER);
+            }
             return new Cesium.DistanceDisplayCondition(min, max);
         }
         EntityRenderEngine.GetDisplayCondition = GetDisplayCondition;
@@ -38430,7 +39558,71 @@
         }
         return value;
     }
+    const pendingRemovalsByViewer = new WeakMap();
+    function scheduleEntityRemoval(viewer, entity) {
+        let pending = pendingRemovalsByViewer.get(viewer);
+        if (!pending) {
+            pending = { entities: new Set(), hook: null };
+            pendingRemovalsByViewer.set(viewer, pending);
+        }
+        pending.entities.add(entity);
+        if (pending.hook) {
+            return;
+        }
+        pending.hook = viewer.scene.postRender.addEventListener(() => {
+            var _a;
+            (_a = pending.hook) === null || _a === void 0 ? void 0 : _a.call(pending);
+            pending.hook = null;
+            const batch = Array.from(pending.entities);
+            pending.entities.clear();
+            if (!batch.length) {
+                return;
+            }
+            WithSuspendedCCollections(batch.map(x => GetCEntityCollection(viewer, x)), () => {
+                for (const item of batch) {
+                    try {
+                        exports.EntityRenderEngine.Remove({
+                            viewer,
+                            entity: item
+                        });
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+            });
+        });
+    }
     (function (CesiumAnimatedInOut) {
+        /**
+         * Runs any removals already queued for this viewer immediately, instead of waiting for the next render.
+         * For teardown paths that need the scene emptied synchronously.
+         */
+        function FlushPendingRemovals(viewer) {
+            var _a;
+            const pending = pendingRemovalsByViewer.get(viewer);
+            if (!(pending === null || pending === void 0 ? void 0 : pending.entities.size)) {
+                return;
+            }
+            const batch = Array.from(pending.entities);
+            pending.entities.clear();
+            (_a = pending.hook) === null || _a === void 0 ? void 0 : _a.call(pending);
+            pending.hook = null;
+            WithSuspendedCCollections(batch.map(x => GetCEntityCollection(viewer, x)), () => {
+                for (const item of batch) {
+                    try {
+                        exports.EntityRenderEngine.Remove({
+                            viewer,
+                            entity: item
+                        });
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+            });
+        }
+        CesiumAnimatedInOut.FlushPendingRemovals = FlushPendingRemovals;
         /**
          * Animates an Entity out of the scene.
          * Removes it from the scene at the end of the animation.
@@ -38449,13 +39641,7 @@
                         return;
                     }
                     removed = true;
-                    const removal = viewer.scene.postRender.addEventListener(() => {
-                        removal();
-                        exports.EntityRenderEngine.Remove({
-                            viewer,
-                            entity
-                        });
-                    });
+                    scheduleEntityRemoval(viewer, entity);
                 };
                 for (let i = 0; i < pieces.length; i++) {
                     const piece = pieces[i];
@@ -39003,7 +40189,7 @@
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.0.1";
+    const VERSION = "7.0.3";
     /**
      * 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.