bruce-cesium 7.0.2 → 7.0.3

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, DistanceDisplayCondition, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, Matrix4, HeightReference, ColorBlendMode, ShadowMode, ClassificationType, Model, ArcType, CornerType, ConstantPositionProperty, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, HorizontalOrigin, VerticalOrigin, Cartesian2, SceneTransforms, NearFarScalar, Matrix3, Rectangle, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileColorBlendMode, Cesium3DTileset, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, OrthographicFrustum, EasingFunction, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, PolygonPipeline, CesiumInspector, ClockRange, BoundingSphere, GeometryInstance, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, Intersect, CzmlDataSource } from 'cesium';
-import { Cartes, Entity as Entity$1, ENVIRONMENT, Calculator, ClientFile, EntityLod, EntityTag, EntityType, LRUCache, ObjectUtils, Style, Carto, Geometry, Bounds, Color as Color$1, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, Api, BruceEvent, EntityCoords, DataLab, DelayQueue, EntityHistoricData, BruceApi, EntityRelation, ProgramKey, EntitySource, AccountConcept, RecordChangeFeed, ProjectViewLegacyTile, ProjectViewTile, Camera, Session, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, EntityRelationType } from 'bruce-models';
+import { Cartographic, Entity, DistanceDisplayCondition, ColorMaterialProperty, Color, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, Matrix4, ClassificationType, ArcType, HeightReference, CornerType, ShadowMode, ConstantProperty, ConstantPositionProperty, CallbackProperty, HorizontalOrigin, VerticalOrigin, Primitive, Cesium3DTileFeature, ColorBlendMode, Model, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Cartesian2, SceneTransforms, NearFarScalar, Matrix3, Rectangle, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, OrthographicFrustum, EasingFunction, Cesium3DTileColorBlendMode, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Cesium3DTileset, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, PolygonPipeline, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, CesiumInspector, ClockRange, BoundingSphere, GeometryInstance, ScreenSpaceEventHandler, ScreenSpaceEventType, CustomDataSource, Fullscreen, Intersect, CzmlDataSource } from 'cesium';
+import { Cartes, Entity as Entity$1, ENVIRONMENT, Calculator, Carto, EntityTag, EntityType, Geometry, ObjectUtils, Style, Api, ClientFile, LRUCache, EntityLod, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, Bounds, Color as Color$1, DataLab, DelayQueue, EntityHistoricData, EntityRelation, AccountConcept, RecordChangeFeed, BruceApi, ProgramKey, EntitySource, Camera, ProjectViewTile, ProjectViewLegacyTile, Session, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, EntityRelationType } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -19,6 +19,28 @@ function EnsureNumber(value, defaultNum) {
     }
     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");
+}
 
 var MeasureUtils;
 (function (MeasureUtils) {
@@ -1956,7 +1978,11 @@ function refreshColor(viewer, graphic, opacity) {
             }
         }
         else if (graphic instanceof CorridorGraphics) {
-            graphic.material = new 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 ColorMaterialProperty(color);
+            }
         }
         else if (graphic instanceof PointGraphics) {
             const animateColor = new CesiumAnimatedProperty.AnimateColor({
@@ -2204,11 +2230,11 @@ var CesiumEntityStyler;
      * @returns
      */
     function SetDefaultColor(params) {
-        const { viewer, entity, requestRender, override } = params;
+        const { viewer, entity, requestRender, override, includeSiblings } = params;
         if (!entity) {
             return;
         }
-        const parts = EntityUtils.GatherEntity({
+        const parts = includeSiblings == false ? [entity] : EntityUtils.GatherEntity({
             entity: entity,
             selectable: true
         });
@@ -3846,6 +3872,202 @@ function GetCValue(viewer, obj) {
     }
     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 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 ColorMaterialProperty || material instanceof 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 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 ConstantProperty(value);
+    return true;
+}
 function ColorToCColor(color) {
     return new Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
 }
@@ -4334,6 +4556,85 @@ var ViewUtils;
     ViewUtils.GetModelSpace = GetModelSpace;
 })(ViewUtils || (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.
@@ -4411,10 +4712,17 @@ var EntityLabel;
          * 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 Entity$1.CalculateNameAsync({
@@ -5601,7 +5909,7 @@ var RelationRenderEngine;
                     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();
@@ -5629,18 +5937,58 @@ const POINT_MIN_RADIUS = 15;
 // 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 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 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
@@ -5657,37 +6005,36 @@ const getTerrainOffset = (viewer, pos3d) => {
         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 Cartesian3(parseFloat(x), parseFloat(y), parseFloat(z));
-        const distance = 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 = 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 = Cartographic.fromCartesian(pos3d);
+    let height = 0;
+    try {
+        height = viewer.scene.globe.getHeight(carto);
     }
-    return offset;
+    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 recorded.offset;
 };
 /**
  * Converts given pos3d into a an absolute position.
@@ -5871,6 +6218,10 @@ function shouldCullEntity(viewer, cEntity) {
             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 {
@@ -5884,12 +6235,10 @@ function shouldCullEntity(viewer, cEntity) {
                 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;
@@ -5899,12 +6248,11 @@ function shouldCullEntity(viewer, cEntity) {
             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) {
@@ -5926,7 +6274,15 @@ function shouldCullEntity(viewer, cEntity) {
         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 = 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 !== Intersect.INSIDE && visibility !== Intersect.INTERSECTING;
@@ -5999,38 +6355,67 @@ function isCullingIgnored(viewer, rego) {
         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 ? HeightReference.NONE : 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) !== 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 != HeightReference.CLAMP_TO_GROUND;
 }
 /**
  * Runs through all entities in the register and culls them if they are out of the viewport.
@@ -6046,6 +6431,7 @@ function runCullChecker(register) {
     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) {
@@ -6098,7 +6484,7 @@ function runCullChecker(register) {
                     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);
@@ -6138,16 +6524,17 @@ function removeEntities(viewer, entities) {
     }
     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);
             }
-        }
+        });
     });
 }
 /**
@@ -6162,16 +6549,17 @@ function addEntities(viewer, entities) {
     }
     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;
@@ -6242,6 +6630,19 @@ var VisualRegisterCuller;
         };
     }
     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;
@@ -6289,7 +6690,7 @@ function isAlive$1(viewer, visual) {
         return false;
     }
     if (visual instanceof Entity) {
-        return viewer.entities.contains(visual);
+        return IsCEntityInScene(viewer, visual);
     }
     else if (visual instanceof Primitive) {
         return viewer.scene.primitives.contains(visual);
@@ -6316,6 +6717,32 @@ function removeEntity(viewer, visual) {
         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 Entity)) {
+        return null;
+    }
+    let highest = null;
+    const parts = EntityUtils.GatherEntity({
+        entity: visual
+    });
+    for (const part of parts) {
+        if (!(part instanceof 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) {
@@ -6334,26 +6761,24 @@ function updateCEntityShow(viewer, visual, rego, show, ignoreParent, depth = 0)
             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;
@@ -6666,12 +7091,128 @@ var VisualsRegister;
             // 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 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;
@@ -7261,9 +7802,11 @@ var VisualsRegister;
                     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);
@@ -7420,7 +7963,7 @@ var VisualsRegister;
             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
             });
@@ -7435,6 +7978,20 @@ var VisualsRegister;
             }
             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;
@@ -8030,6 +8587,14 @@ var VisualsRegister;
                 });
             }
             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);
@@ -8037,6 +8602,7 @@ var VisualsRegister;
             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({
@@ -8341,9 +8907,13 @@ var VisualsRegister;
                     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];
@@ -8526,8 +9096,75 @@ var VisualsRegister;
             };
         }
         /**
-         * 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) {
@@ -9901,7 +10538,11 @@ var EntitiesRenderManager;
             const displayItems = this.zoomControl ? (_d = this.zoomControl) === null || _d === void 0 ? void 0 : _d.filter(x => x.DisplayType != ZoomControl.EDisplayType.Hidden) : [];
             const shouldCheck = displayItems.length > 1;
             this.entityCheckQueue = new 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) {
@@ -10144,6 +10785,30 @@ var EntitiesRenderManager;
                 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 RenderManager.CouldBandHaveChanged({
+                    viewer: this.viewer,
+                    bandCheck
+                });
+            });
+        }
         async doEntityCheck(ids) {
             var _a, _b;
             if (this.isRunningCheck) {
@@ -10815,6 +11480,19 @@ var EntitiesRenderManager;
                 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: RenderManager.GetZoomControlSignature(item.CameraZoomSettings),
+                historicDrawTrack: Boolean(item.historicDrawTrack),
+                historicInterpolation: Boolean(item.historicInterpolation)
+            });
+        }
         PrepareHandoff() {
             var _a;
             if (this.disposed || this.useGeojson || this.item.enableClustering) {
@@ -10826,7 +11504,8 @@ var EntitiesRenderManager;
                 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);
@@ -10866,7 +11545,12 @@ var EntitiesRenderManager;
             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();
         }
     }
@@ -11314,7 +11998,7 @@ var EntitiesLoadedRenderManager;
          * @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];
@@ -11365,38 +12049,42 @@ var EntitiesLoadedRenderManager;
             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 Style.Get({
+                    style = (_b = (await 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 EntityType.Get({
+                    entityType = (_f = (await 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 Style.Get({
+                            style = (_g = (await 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;
                         }
                     }
                 }
@@ -11404,9 +12092,13 @@ var EntitiesLoadedRenderManager;
                     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 = Calculator.GetColor(pStyle.fillColor, {}, []);
             const cFillColor = bFillColor ? colorToCColor$2(bFillColor) : Color.fromCssColorString("rgba(139, 195, 74, 0.8)");
             const bLineColor = Calculator.GetColor(pStyle.lineColor, {}, []);
@@ -11640,6 +12332,7 @@ var EntitiesLoadedRenderManager;
             return next;
         }
         async doRenderAsIndividuals(entities, force = false) {
+            var _a;
             const { updated, entities: cEntities } = await EntityRenderEngine.Render({
                 viewer: this.viewer,
                 apiGetter: this.apiGetter,
@@ -11647,6 +12340,8 @@ var EntitiesLoadedRenderManager;
                 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) {
@@ -13877,6 +14572,7 @@ var TilesetRenderEngine;
     }
     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;
@@ -13940,6 +14636,10 @@ var TilesetRenderEngine;
                     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 === Tileset.EType.EntitiesSet) {
@@ -13956,6 +14656,10 @@ var TilesetRenderEngine;
             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 == Tileset.EType.PointCloud) {
@@ -14001,6 +14705,10 @@ var TilesetRenderEngine;
                     console.error(e);
                 }
             });
+            (_c = params.register) === null || _c === void 0 ? void 0 : _c.AddTileset({
+                tileset: cTileset,
+                menuItemId: params.menuItemId
+            });
             return cTileset;
         }
         else {
@@ -14009,6 +14717,7 @@ var TilesetRenderEngine;
     }
     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 = {
@@ -14131,6 +14840,10 @@ var TilesetRenderEngine;
                 console.error(e);
             }
         });
+        (_a = params.register) === null || _a === void 0 ? void 0 : _a.AddTileset({
+            tileset: cTileset,
+            menuItemId: params.menuItemId
+        });
         return cTileset;
     }
     TilesetRenderEngine.RenderLegacy = RenderLegacy;
@@ -14645,6 +15358,8 @@ var TilesetCadRenderManager;
                 }
                 // Render outside the shared process because we can't control file requests from Cesium.
                 const cTileset = this.cTileset = await TilesetRenderEngine.Render({
+                    register: this.visualsManager,
+                    menuItemId: this.item.id,
                     loadUrl: loadUrl,
                     apiGetter: this.getters.GetBruceGetter(),
                     tileset: tileset,
@@ -16978,7 +17693,12 @@ var DataLabRenderManager;
             const displayItems = this.zoomControl ? this.zoomControl.filter(x => x.DisplayType != ZoomControl.EDisplayType.Hidden) : [];
             const shouldCheck = displayItems.length > 1;
             this.entityCheckQueue = new 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(() => {
@@ -16986,6 +17706,30 @@ var DataLabRenderManager;
                 (_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 RenderManager.CouldBandHaveChanged({
+                    viewer: this.viewer,
+                    bandCheck
+                });
+            });
+        }
         preventCurrentCheckApiRefresh(entityIds) {
             var _a;
             this.reRenderState.markSkipForCurrentRun(entityIds, this.isRunningCheck);
@@ -17312,6 +18056,15 @@ var DataLabRenderManager;
             }
             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: RenderManager.GetZoomControlSignature(item.CameraZoomSettings)
+            });
+        }
         PrepareHandoff() {
             var _a, _b, _c;
             if (this.disposed || !this.getter) {
@@ -17332,7 +18085,8 @@ var DataLabRenderManager;
                 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;
@@ -17355,7 +18109,10 @@ var DataLabRenderManager;
             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();
         }
     }
@@ -18340,6 +19097,8 @@ var TilesetEntitiesRenderManager;
                         }
                     }
                     const cTileset = this.cTileset = await TilesetRenderEngine.Render({
+                        register: this.visualsManager,
+                        menuItemId: this.item.id,
                         apiGetter: this.getters.GetBruceGetter(),
                         tileset: tileset,
                         viewer: this.viewer,
@@ -18831,11 +19590,12 @@ var TilesetPointcloudRenderManager;
         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;
@@ -18886,6 +19646,8 @@ var TilesetPointcloudRenderManager;
                     return;
                 }
                 this.cTileset = await TilesetRenderEngine.Render({
+                    register: this.visualsManager,
+                    menuItemId: this.item.id,
                     apiGetter: this.getters.GetBruceGetter(),
                     tileset: tileset,
                     viewer: this.viewer,
@@ -19478,6 +20240,8 @@ var TilesetArbRenderManager;
                         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 TilesetRenderEngine.RenderLegacy({
                             apiGetter: this.getters.GetBruceGetter(),
                             tileset: legacyTileset,
@@ -20146,8 +20910,8 @@ var RelationsRenderManager;
                  * @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();
@@ -20626,8 +21390,8 @@ var LegacyRelationsRenderManager;
                  * @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();
@@ -22658,6 +23422,7 @@ var MenuItemManager;
                         rItem.renderManager = new TilesetPointcloudRenderManager.Manager({
                             viewer: this.viewer,
                             getters: this.getters,
+                            register: this.visualsRegister,
                             item: params.item,
                             initQueue: this.tilesetInitQueue
                         });
@@ -22812,6 +23577,8 @@ var MenuItemManager;
                 }
                 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 {
@@ -22820,9 +23587,9 @@ var MenuItemManager;
                     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 });
             }
         }
@@ -22870,14 +23637,38 @@ var MenuItemManager;
             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;
@@ -22893,6 +23684,7 @@ var MenuItemManager;
                 catch (e) {
                     console.error(e);
                 }
+                this.ClearSeriesSegments(item.id);
             }
         }
         GetEnabledItemIds() {
@@ -34269,6 +35061,10 @@ function distanceToPolygon(point, polygon) {
     }
     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 LRUCache(3000);
@@ -34412,7 +35208,7 @@ function calculateDistance(point, entity) {
 var RenderManager;
 (function (RenderManager) {
     function DetermineZoomItem(params) {
-        const { viewer, entity, zoomControl } = params;
+        const { viewer, entity, zoomControl, out } = params;
         const pos = EntityUtils.GetPos({
             viewer,
             entity
@@ -34425,11 +35221,16 @@ var RenderManager;
         if (!cameraPos || !cameraPos.latitude) {
             return null;
         }
-        const distance = calculateDistance({
+        const cameraCarto = {
             altitude: cameraPos.height,
             latitude: Math$1.toDegrees(cameraPos.latitude),
             longitude: Math$1.toDegrees(cameraPos.longitude)
-        }, entity);
+        };
+        const distance = calculateDistance(cameraCarto, entity);
+        if (out) {
+            out.distance = distance;
+            out.cameraPos = Cartesian3.fromDegrees(cameraCarto.longitude, cameraCarto.latitude, cameraCarto.altitude);
+        }
         let zoomItem = (!distance && distance != 0) ? null : GetZoomControlFromDistance({
             zoomControl,
             distance
@@ -34442,6 +35243,41 @@ var RenderManager;
         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 = Cartesian3.fromDegrees(Math$1.toDegrees(cameraPos.longitude), Math$1.toDegrees(cameraPos.latitude), cameraPos.height);
+        const travelled = 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++) {
@@ -34453,6 +35289,26 @@ var RenderManager;
         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;
@@ -34541,8 +35397,8 @@ var EntityRenderEnginePoint;
                 // 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 Entity && params.viewer.entities.contains(part) && !cEntity._siblingGraphics.includes(part)) {
-                        params.viewer.entities.remove(part);
+                    if (part && part instanceof Entity && !cEntity._siblingGraphics.includes(part)) {
+                        RemoveCEntityFromScene(params.viewer, part);
                     }
                 }
                 if (cEntity._parentEntity) {
@@ -34886,7 +35742,6 @@ var EntityRenderEnginePoint;
                     cEntity.ellipse.semiMajorAxis = new ConstantProperty(radius);
                     cEntity.ellipse.semiMinorAxis = new ConstantProperty(radius);
                 }
-                cEntity.ellipse.outlineWidth = undefined;
                 {
                     const curHeightRef = GetCValue(params.viewer, cEntity.ellipse.heightReference);
                     if (curHeightRef != heightRef) {
@@ -34907,13 +35762,26 @@ var EntityRenderEnginePoint;
                         cEntity.ellipse.extrudedHeight = new ConstantProperty(extrusion.value);
                     }
                 }
-                cEntity.ellipse.zIndex = new ConstantProperty(1);
-                cEntity.ellipse.distanceDisplayCondition = new ConstantProperty(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: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance)
+                });
                 const curClassification = GetCValue(params.viewer, cEntity.ellipse.classificationType);
                 if (curClassification != classification) {
                     cEntity.ellipse.classificationType = new ConstantProperty(classification);
                 }
-                cEntity.position = new ConstantPositionProperty(pos3d === null || pos3d === void 0 ? void 0 : pos3d.clone());
+                const curPos = GetCValue(params.viewer, cEntity.position);
+                if (!curPos || !pos3d || !Cartesian3.equals(curPos, pos3d)) {
+                    cEntity.position = new 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?).
                 CesiumEntityStyler.SetDefaultColor({
@@ -34921,6 +35789,8 @@ var EntityRenderEnginePoint;
                     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;
@@ -34959,8 +35829,18 @@ var EntityRenderEnginePoint;
                             outlineEntity.ellipse.extrudedHeight = new ConstantProperty(outlineExtrusion.value);
                         }
                     }
-                    outlineEntity.ellipse.zIndex = new ConstantProperty(2);
-                    outlineEntity.ellipse.distanceDisplayCondition = new ConstantProperty(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: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance)
+                    });
                     const curClassification = GetCValue(params.viewer, outlineEntity.ellipse.classificationType);
                     if (curClassification != classification) {
                         outlineEntity.ellipse.classificationType = new ConstantProperty(classification);
@@ -34972,6 +35852,7 @@ var EntityRenderEnginePoint;
                         entity: outlineEntity,
                         viewer: params.viewer,
                         override: true,
+                        includeSiblings: false,
                         requestRender: false
                     });
                     outlineEntity.show = true;
@@ -35236,7 +36117,7 @@ var EntityRenderEnginePoint;
             // 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 EntityTag.GetListByIds({
+            const tags = (!params.offline && tagIds.length > 0) ? (await EntityTag.GetListByIds({
                 api,
                 tagIds
             })).tags : [];
@@ -35248,7 +36129,7 @@ var EntityRenderEnginePoint;
         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 = [];
@@ -35286,7 +36167,7 @@ var EntityRenderEnginePoint;
                 rego: rego
             });
             if (cEntity) {
-                const name = await getName(api, entity);
+                const name = await getName(api, entity, params.offline);
                 cEntity.name = name;
                 cEntity._renderGroup = EntityRenderEngine.GetRenderGroupId(zoomItem);
                 cEntity.styleId = zoomItem.StyleID == -1 ? -1 : (+zoomItem.StyleID || null);
@@ -35457,7 +36338,16 @@ function getCylinderExtrusion(entity, tags, heightRef, style) {
     }
     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;
@@ -35637,8 +36527,8 @@ var EntityRenderEngineModel3d;
                 // 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 Entity && params.viewer.entities.contains(part) && !cEntity._siblingGraphics.includes(part)) {
-                        params.viewer.entities.remove(part);
+                    if (part && part instanceof Entity && !cEntity._siblingGraphics.includes(part)) {
+                        RemoveCEntityFromScene(params.viewer, part);
                     }
                 }
                 if (cEntity._parentEntity) {
@@ -36131,7 +37021,7 @@ var EntityRenderEngineModel3d;
             // 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 EntityTag.GetListByIds({
+            const tags = (!params.offline && tagIds.length > 0) ? (await EntityTag.GetListByIds({
                 api,
                 tagIds
             })).tags : [];
@@ -36143,7 +37033,7 @@ var EntityRenderEngineModel3d;
         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 = [];
@@ -36182,8 +37072,8 @@ var EntityRenderEngineModel3d;
         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;
@@ -36229,7 +37119,7 @@ var EntityRenderEngineModel3d;
                 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 = EntityRenderEngine.GetRenderGroupId(zoomItem);
                 cEntity.styleId = zoomItem.StyleID == -1 ? -1 : styleRecord === null || styleRecord === void 0 ? void 0 : styleRecord.ID;
@@ -36255,7 +37145,16 @@ function getHeightRef$1(style, defaultStyle) {
     }
     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;
@@ -36528,8 +37427,8 @@ var EntityRenderEnginePolyline;
                 // 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 Entity && params.viewer.entities.contains(part)) {
-                        params.viewer.entities.remove(part);
+                    if (part && part instanceof Entity) {
+                        RemoveCEntityFromScene(params.viewer, part);
                     }
                 }
                 cEntity._siblingGraphics = [];
@@ -36560,7 +37459,12 @@ var EntityRenderEnginePolyline;
                 if (oldClampToGround != newClampToGround) {
                     cEntity.polyline.clampToGround = new ConstantProperty(newClampToGround);
                 }
-                cEntity.polyline.distanceDisplayCondition = new ConstantProperty(EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
+                SetCPropIfChanged({
+                    viewer: params.viewer,
+                    graphic: cEntity.polyline,
+                    property: "distanceDisplayCondition",
+                    value: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance)
+                });
                 cEntity.corridor = undefined;
             }
             else {
@@ -36584,7 +37488,12 @@ var EntityRenderEnginePolyline;
                 if (oldZIndex != getZIndex(style, entity, params.tags)) {
                     cEntity.corridor.zIndex = new ConstantProperty(getZIndex(style, entity, params.tags));
                 }
-                cEntity.corridor.distanceDisplayCondition = new ConstantProperty(EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width));
+                SetCPropIfChanged({
+                    viewer: params.viewer,
+                    graphic: cEntity.corridor,
+                    property: "distanceDisplayCondition",
+                    value: 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.
@@ -36652,7 +37561,7 @@ var EntityRenderEnginePolyline;
             // 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 EntityTag.GetListByIds({
+            const tags = (!params.offline && tagIds.length > 0) ? (await EntityTag.GetListByIds({
                 api,
                 tagIds
             })).tags : [];
@@ -36664,7 +37573,7 @@ var EntityRenderEnginePolyline;
         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 = [];
@@ -36687,7 +37596,7 @@ var EntityRenderEnginePolyline;
                 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 = EntityRenderEngine.GetRenderGroupId(zoomItem);
                 cEntity.styleId = zoomItem.StyleID == -1 ? -1 : (+zoomItem.StyleID || null);
@@ -36698,7 +37607,16 @@ var EntityRenderEnginePolyline;
     }
     EntityRenderEnginePolyline.RenderGroup = RenderGroup;
 })(EntityRenderEnginePolyline || (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;
@@ -36940,6 +37858,13 @@ var TextureFrameSeriesAnimator;
         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;
@@ -37146,7 +38071,7 @@ var EntityRenderEnginePolygon;
         let textureDataUri = null;
         let textureTraceEffective = null;
         let frameArchive = null;
-        if (fillType === Style.EPolygonFillType.Texture) {
+        if (fillType === Style.EPolygonFillType.Texture && !params.offline) {
             try {
                 const resolved = await resolveTexturedFill({
                     api: params.api,
@@ -37227,8 +38152,8 @@ var EntityRenderEnginePolygon;
                 // 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 Entity && params.viewer.entities.contains(part) && !cEntity._siblingGraphics.includes(part)) {
-                        params.viewer.entities.remove(part);
+                    if (part && part instanceof Entity && !cEntity._siblingGraphics.includes(part)) {
+                        RemoveCEntityFromScene(params.viewer, part);
                     }
                 }
                 if (cEntity._parentEntity) {
@@ -37238,7 +38163,8 @@ var EntityRenderEnginePolygon;
         };
         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 Entity({
                 id: ObjectUtils.UId(15),
                 polygon: {
@@ -37251,7 +38177,7 @@ var EntityRenderEnginePolygon;
                     classificationType: classification,
                     perPositionHeight: heightRef == HeightReference.CLAMP_TO_GROUND ? false : true,
                     zIndex: zIndex,
-                    distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width <= 0 || !cLineColor || units == "m" ? size : null, true)
+                    distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width <= 0 || !cLineColor || units == "m" ? size : null, true, size)
                 },
                 position: EntityUtils.GetPos({
                     viewer: params.viewer,
@@ -37305,9 +38231,38 @@ var EntityRenderEnginePolygon;
             if (oldZIndex != zIndex) {
                 cEntity.polygon.zIndex = new ConstantProperty(zIndex);
             }
-            cEntity.polygon.distanceDisplayCondition = new ConstantProperty(EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width <= 0 || !cLineColor || units == "m" ? size : null, true));
-            cEntity.polygon.shadows = new ConstantProperty(ShadowMode.ENABLED);
-            cEntity.polygon.classificationType = new ConstantProperty(classification);
+            SetCPropIfChanged({
+                viewer: params.viewer,
+                graphic: cEntity.polygon,
+                property: "distanceDisplayCondition",
+                value: 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: 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) {
+            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.
@@ -37334,12 +38289,12 @@ var EntityRenderEnginePolygon;
                     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) {
@@ -37372,7 +38327,7 @@ var EntityRenderEnginePolygon;
                         classificationType: ClassificationType.TERRAIN,
                         arcType: ArcType.GEODESIC,
                         zIndex: zIndex,
-                        distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance)
+                        distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, null, false, size)
                     }) : null,
                     corridor: units == "m" ? {
                         positions: borderPosses,
@@ -37384,7 +38339,7 @@ var EntityRenderEnginePolygon;
                         zIndex: zIndex + 1,
                         cornerType: CornerType.MITERED,
                         classificationType: classification,
-                        distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width),
+                        distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width, false, size),
                         shadows: ShadowMode.ENABLED
                     } : null,
                     show: true
@@ -37411,11 +38366,21 @@ var EntityRenderEnginePolygon;
                     }
                     const oldMaterial = GetCValue(params.viewer, cEntityBorder.polyline.material);
                     const newMaterial = new ColorMaterialProperty(cLineColor);
-                    if (compareColorMaterials(params.viewer, oldMaterial, newMaterial)) {
+                    if (!areColorMaterialsEqual(params.viewer, oldMaterial, newMaterial)) {
                         cEntityBorder.polyline.material = newMaterial;
                     }
-                    cEntityBorder.polyline.classificationType = new ConstantProperty(ClassificationType.TERRAIN);
-                    cEntityBorder.polyline.distanceDisplayCondition = new ConstantProperty(EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
+                    SetCPropIfChanged({
+                        viewer: params.viewer,
+                        graphic: cEntityBorder.polyline,
+                        property: "classificationType",
+                        value: ClassificationType.TERRAIN
+                    });
+                    SetCPropIfChanged({
+                        viewer: params.viewer,
+                        graphic: cEntityBorder.polyline,
+                        property: "distanceDisplayCondition",
+                        value: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, null, false, size)
+                    });
                     cEntityBorder.corridor = undefined;
                 }
                 else {
@@ -37441,15 +38406,35 @@ var EntityRenderEnginePolygon;
                     }
                     const oldMaterial = GetCValue(params.viewer, cEntityBorder.corridor.material);
                     const newMaterial = new ColorMaterialProperty(cLineColor);
-                    if (compareColorMaterials(params.viewer, oldMaterial, newMaterial)) {
+                    if (!areColorMaterialsEqual(params.viewer, oldMaterial, newMaterial)) {
                         cEntityBorder.corridor.material = newMaterial;
                     }
-                    cEntityBorder.corridor.fill = new ConstantProperty(true);
-                    cEntityBorder.corridor.distanceDisplayCondition = new ConstantProperty(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: 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.
+            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++) {
@@ -37465,7 +38450,7 @@ var EntityRenderEnginePolygon;
                         classificationType: ClassificationType.TERRAIN,
                         arcType: ArcType.GEODESIC,
                         zIndex: zIndex,
-                        distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance)
+                        distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, null, false, size)
                     }) : null,
                     corridor: units == "m" ? {
                         positions: borderPosses,
@@ -37477,7 +38462,7 @@ var EntityRenderEnginePolygon;
                         zIndex: zIndex + 1,
                         cornerType: CornerType.MITERED,
                         classificationType: classification,
-                        distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width),
+                        distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width, false, size),
                         shadows: ShadowMode.ENABLED,
                     } : null,
                     show: true
@@ -37518,7 +38503,7 @@ var EntityRenderEnginePolygon;
             // 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 EntityTag.GetListByIds({
+            const tags = (!params.offline && tagIds.length > 0) ? (await EntityTag.GetListByIds({
                 api,
                 tagIds
             })).tags : [];
@@ -37530,7 +38515,7 @@ var EntityRenderEnginePolygon;
         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 = [];
@@ -37565,7 +38550,7 @@ var EntityRenderEnginePolygon;
                 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 = EntityRenderEngine.GetRenderGroupId(zoomItem);
                 cEntity.styleId = zoomItem.StyleID == -1 ? -1 : (+zoomItem.StyleID || null);
@@ -37587,7 +38572,16 @@ var EntityRenderEnginePolygon;
     }
     EntityRenderEnginePolygon.DisposeTextureFrameSeriesAnimator = DisposeTextureFrameSeriesAnimator;
 })(EntityRenderEnginePolygon || (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;
@@ -37691,6 +38685,7 @@ const _textureCache = new LRUCache(50);
 /**
  * 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
@@ -37699,22 +38694,24 @@ const _textureCache = new LRUCache(50);
 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,
@@ -37881,7 +38878,7 @@ async function buildTintedTextureDataUri(url, mask) {
  * @param b
  * @returns
  */
-function compareColorMaterials(viewer, a, b) {
+function areColorMaterialsEqual(viewer, a, b) {
     // Same reference.
     if (a == b) {
         return true;
@@ -38202,15 +39199,44 @@ var StyleEffective;
 })(StyleEffective || (StyleEffective = {}));
 var EntityRenderEngine;
 (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 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 = ZoomControl.EDisplayType.Hidden;
+        }
+        // Backwards compatibility, same mapping the render pass applies.
+        else if (displayType == "polygon") {
+            displayType = ZoomControl.EDisplayType.Geometry;
+        }
+        // Multi-geometry builds a container graphic holding sibling graphics rather than a flat one.
+        const geometry = Entity$1.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,
@@ -38218,10 +39244,15 @@ var EntityRenderEngine;
             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 = [];
@@ -38271,11 +39302,21 @@ var EntityRenderEngine;
         for (let i = 0; i < params.entities.length; i++) {
             let entity = params.entities[i];
             const id = entity.Bruce.ID;
+            const resolution = {};
             const zoomItem = 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 = ZoomControl.EDisplayType.Hidden;
@@ -38289,8 +39330,13 @@ var EntityRenderEngine;
                     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) &&
@@ -38300,13 +39346,13 @@ var EntityRenderEngine;
                     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);
                     }
@@ -38320,7 +39366,7 @@ var EntityRenderEngine;
                             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 {
@@ -38363,7 +39409,7 @@ var EntityRenderEngine;
                     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;
                 }
@@ -38482,6 +39528,21 @@ var EntityRenderEngine;
                 }
             }
         }
+        // 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
@@ -38517,9 +39578,7 @@ var EntityRenderEngine;
                     });
                 }
             }
-            if (viewer.entities.contains(entity)) {
-                viewer.entities.remove(entity);
-            }
+            RemoveCEntityFromScene(viewer, entity);
         }
         doRemove({
             viewer: params.viewer,
@@ -38554,9 +39613,10 @@ var EntityRenderEngine;
      * @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;
@@ -38586,6 +39646,15 @@ var EntityRenderEngine;
                 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 DistanceDisplayCondition(min, max);
     }
     EntityRenderEngine.GetDisplayCondition = GetDisplayCondition;
@@ -38608,8 +39677,72 @@ function getColor$3(viewer, obj) {
     }
     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 {
+                    EntityRenderEngine.Remove({
+                        viewer,
+                        entity: item
+                    });
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+        });
+    });
+}
 var CesiumAnimatedInOut;
 (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 {
+                    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.
@@ -38628,13 +39761,7 @@ var CesiumAnimatedInOut;
                     return;
                 }
                 removed = true;
-                const removal = viewer.scene.postRender.addEventListener(() => {
-                    removal();
-                    EntityRenderEngine.Remove({
-                        viewer,
-                        entity
-                    });
-                });
+                scheduleEntityRemoval(viewer, entity);
             };
             for (let i = 0; i < pieces.length; i++) {
                 const piece = pieces[i];
@@ -39184,7 +40311,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.0.2";
+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.