bruce-cesium 7.3.8 → 7.4.0

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, HeightReference, DistanceDisplayCondition, ShaderSource, Cartesian3, Math as Math$1, Ellipsoid, Transforms, Matrix4, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, JulianDate, Quaternion, HeadingPitchRoll, ClassificationType, ArcType, CornerType, ShadowMode, ConstantPositionProperty, HorizontalOrigin, VerticalOrigin, ColorBlendMode, Model, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, SceneTransforms, NearFarScalar, Matrix3, 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, Intersect, OrthographicFrustum, EasingFunction, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, PolygonPipeline, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, CustomDataSource, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, ScreenSpaceEventHandler, ScreenSpaceEventType, GeometryInstance, Fullscreen, CzmlDataSource } from 'cesium';
-import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Calculator, Carto, Entity as Entity$1, EntityTag, EntityType, Geometry as Geometry$1, ObjectUtils, Style, Api, ClientFile, EntityLod, Bounds, ClientFileValueMap, Color as Color$1, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, RecordChangeFeed, EntityRelation, BruceApi, EntitySource, ProgramKey, ProjectViewLegacyTile, Camera, Account, AccountLimits, Session, UrlUtils, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType, EntityHistoricData } from 'bruce-models';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, HeightReference, Matrix4, ShaderSource, Ellipsoid, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, DistanceDisplayCondition, ColorBlendMode, ShadowMode, ClassificationType, Model, HorizontalOrigin, VerticalOrigin, ConstantPositionProperty, ArcType, CornerType, ImageMaterialProperty, SceneTransforms, PolygonHierarchy, PolylineGraphics, Rectangle, FeatureDetection, NearFarScalar, Matrix3, 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, Intersect, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, PolygonPipeline, CustomDataSource, GeometryInstance, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
+import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Calculator, ClientFile, Entity as Entity$1, EntityLod, EntityTag, EntityType, ObjectUtils, Style, Api, Carto, Geometry as Geometry$1, ClientFileValueMap, Color as Color$1, Bounds, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, BruceApi, RecordChangeFeed, EntityRelation, EntitySource, ProgramKey, ProjectViewLegacyTile, Camera, Account, AccountLimits, Session, UrlUtils, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType, EntityHistoricData } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -5295,6 +5295,86 @@ function InstallShowGate(target) {
     return gate;
 }
 
+/*
+ * Status semantics are shared by label and scene-entity clusters; opaque image pixels are not inferred.
+ * A bit jank but helps keep current 'important' labels higher than others.
+ */
+function GetClusterIconPriority(options) {
+    if (Number.isFinite(options === null || options === void 0 ? void 0 : options.iconPriority)) {
+        return options.iconPriority;
+    }
+    const statusPriority = (value) => {
+        const tokens = value.toLowerCase().split(/[^a-z0-9]+/);
+        if (tokens.some(token => ["critical", "fatal", "error", "fault", "failed", "alarm", "danger", "red"].includes(token))) {
+            return 3;
+        }
+        if (tokens.some(token => ["warning", "warn", "degraded", "amber", "orange", "yellow"].includes(token))) {
+            return 2;
+        }
+        if (tokens.some(token => ["unknown", "offline"].includes(token))) {
+            return 1;
+        }
+        return 0;
+    };
+    if ((options === null || options === void 0 ? void 0 : options.iconStatus) != null) {
+        return statusPriority(options.iconStatus);
+    }
+    const glyph = (options === null || options === void 0 ? void 0 : options.icon) || "";
+    if (/[🔴🟥❌🚨]/u.test(glyph)) {
+        return 3;
+    }
+    if (/[🟠🟡⚠]/u.test(glyph)) {
+        return 2;
+    }
+    let filename = "";
+    if ((options === null || options === void 0 ? void 0 : options.iconUrl) && !/^(data|blob):/i.test(options.iconUrl)) {
+        try {
+            filename = decodeURIComponent(new URL(options.iconUrl, "https://label.invalid").pathname.split("/").pop());
+        }
+        catch {
+            // Ignore malformed URLs when inferring status.
+        }
+    }
+    return Math.max(statusPriority(glyph), statusPriority(filename));
+}
+/*
+ * Groups eligible neighbours around stable representatives without coupling membership to its renderer.
+ */
+function ClusterItems(params) {
+    const eligible = new Map();
+    for (const item of params.items) {
+        if (!params.eligible || params.eligible(item)) {
+            eligible.set(params.id(item), item);
+        }
+    }
+    const assigned = new Set();
+    const result = [];
+    const minimum = Math.max(2, params.minSize || 2);
+    for (const [id, item] of eligible) {
+        if (assigned.has(id)) {
+            continue;
+        }
+        const members = new Map([[id, item]]);
+        for (const neighbour of params.neighbours(item)) {
+            const key = params.id(neighbour);
+            if (eligible.has(key) && !assigned.has(key)) {
+                members.set(key, eligible.get(key));
+            }
+        }
+        if (members.size < minimum) {
+            continue;
+        }
+        for (const key of members.keys()) {
+            assigned.add(key);
+        }
+        result.push({
+            representative: item,
+            members: Array.from(members.values())
+        });
+    }
+    return result;
+}
+
 /**
  * Returns cesium property's value.
  * This will check if it's one that changes over time, or just a fixed value.
@@ -5317,10 +5397,564 @@ function getValue(viewer, obj) {
 */
 var EntityLabel;
 (function (EntityLabel) {
+    const ICON_BACKGROUND_BLEND = 0.8;
+    const ICON_BACKGROUND_ALPHA = 0.45;
+    const TEXT_MAX_WIDTH = 200;
     // Key where the label instance is stored within the cesium entity.
     // Eg: rego[ATTACH_KEY] = new EntityLabel(...);
     EntityLabel.ATTACH_KEY = "nextspace-navigator-entity-label";
+    /*
+     * Indexes screen rectangles so sparse scenes do not compare every label with every other label.
+     */
+    class ScreenIndex {
+        constructor() {
+            this.cells = new Map();
+            this.large = [];
+            this.all = [];
+        }
+        keys(frame, padding = 0) {
+            const x0 = Math.floor((frame.x - padding) / 64);
+            const y0 = Math.floor((frame.y - padding) / 64);
+            const x1 = Math.floor((frame.x + frame.width + padding) / 64);
+            const y1 = Math.floor((frame.y + frame.height + padding) / 64);
+            if ((x1 - x0 + 1) * (y1 - y0 + 1) > 4096) {
+                return null;
+            }
+            const keys = [];
+            for (let x = x0; x <= x1; x++) {
+                for (let y = y0; y <= y1; y++) {
+                    keys.push(`${x},${y}`);
+                }
+            }
+            return keys;
+        }
+        Add(frame) {
+            this.all.push(frame);
+            const keys = this.keys(frame);
+            if (!keys) {
+                this.large.push(frame);
+                return;
+            }
+            for (const key of keys) {
+                if (!this.cells.has(key)) {
+                    this.cells.set(key, []);
+                }
+                this.cells.get(key).push(frame);
+            }
+        }
+        Query(frame, padding = 0) {
+            const keys = this.keys(frame, padding);
+            const found = new Set(keys ? this.large : this.all);
+            for (const key of keys || []) {
+                for (const item of this.cells.get(key) || []) {
+                    found.add(item);
+                }
+            }
+            return (Array.from(found).filter(other => frame.x <= other.x + other.width + padding && frame.x + frame.width + padding >= other.x &&
+                frame.y <= other.y + other.height + padding && frame.y + frame.height + padding >= other.y));
+        }
+        HasOverlap(frame) {
+            var _a;
+            const intersects = (other) => (frame.x <= other.x + other.width && frame.x + frame.width >= other.x &&
+                frame.y <= other.y + other.height && frame.y + frame.height >= other.y);
+            const keys = this.keys(frame);
+            if ((keys ? this.large : this.all).some(intersects)) {
+                return true;
+            }
+            for (const key of keys || []) {
+                if ((_a = this.cells.get(key)) === null || _a === void 0 ? void 0 : _a.some(intersects)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+    /*
+     * Includes the stem in collision checks without treating two crossing stems as text occlusion.
+     */
+    function leaderBounds(frame) {
+        if (!frame.hasLeader || !Number.isFinite(frame.anchorX) || !Number.isFinite(frame.anchorY)) {
+            return undefined;
+        }
+        const endX = Math.max(frame.x, Math.min(frame.anchorX, frame.x + frame.width));
+        const endY = Math.max(frame.y, Math.min(frame.anchorY, frame.y + frame.height));
+        if (Math.hypot(frame.anchorX - endX, frame.anchorY - endY) < .01) {
+            return undefined;
+        }
+        return {
+            ...frame,
+            x: Math.min(frame.anchorX, endX) - 1,
+            y: Math.min(frame.anchorY, endY) + .01,
+            width: Math.abs(frame.anchorX - endX) + 2,
+            height: Math.max(0, Math.abs(frame.anchorY - endY) - .02)
+        };
+    }
+    /*
+     * Remembers sides, never rendered positions: its own output cannot trigger another layout pass.
+     */
+    class PlacementMemory {
+        constructor() {
+            this.previous = new Map();
+            this.nextOrder = 0;
+        }
+        Resolve(frames) {
+            var _a, _b;
+            const live = new Set(frames.map(frame => frame.id));
+            const moved = (frame) => {
+                var _a;
+                const old = (_a = this.previous.get(frame.id)) === null || _a === void 0 ? void 0 : _a.frame;
+                return (!old ||
+                    old.transient !== frame.transient || old.canFlip !== frame.canFlip ||
+                    Math.hypot(frame.x - old.x, frame.y - old.y) >= 24 ||
+                    Math.abs(frame.width - old.width) >= 8 || Math.abs(frame.height - old.height) >= 8);
+            };
+            const persistent = frames.filter(frame => !frame.transient);
+            const changes = (persistent.filter(moved).length +
+                Array.from(this.previous.values()).filter(old => !old.frame.transient && !live.has(old.frame.id)).length);
+            // A hover or one arrival cannot rearrange incumbents; a substantial batch/camera change can.
+            const restructure = this.previous.size > 0 && changes >= Math.max(2, Math.ceil(persistent.length * 0.3));
+            const fixed = (frame) => !restructure && !frame.transient && this.previous.has(frame.id) && !moved(frame);
+            const ordered = ([...frames].sort((a, b) => {
+                var _a, _b, _c, _d;
+                return Number(fixed(b)) - Number(fixed(a)) ||
+                    Number(Boolean(a.transient)) - Number(Boolean(b.transient)) ||
+                    ((_b = (_a = this.previous.get(a.id)) === null || _a === void 0 ? void 0 : _a.order) !== null && _b !== void 0 ? _b : Infinity) - ((_d = (_c = this.previous.get(b.id)) === null || _c === void 0 ? void 0 : _c.order) !== null && _d !== void 0 ? _d : Infinity) ||
+                    a.depth - b.depth || a.id.localeCompare(b.id);
+            }));
+            const text = new ScreenIndex(), leaders = new ScreenIndex();
+            const placed = new Map();
+            const next = new Map();
+            const candidate = (frame, side) => {
+                var _a;
+                return (side === "left" && frame.canFlip ?
+                    { ...frame, x: Math.max(0, Math.min(frame.anchorX - frame.width, ((_a = frame.viewportWidth) !== null && _a !== void 0 ? _a : Infinity) - frame.width)) } :
+                    frame);
+            };
+            const score = (frame, padding = 0) => {
+                const box = {
+                    ...frame,
+                    x: frame.x - padding + .01,
+                    y: frame.y - padding + .01,
+                    width: Math.max(0, frame.width + padding * 2 - .02),
+                    height: Math.max(0, frame.height + padding * 2 - .02)
+                };
+                const stem = leaderBounds(frame);
+                return (Number(text.HasOverlap(box)) * 4 + Number(leaders.HasOverlap(box)) +
+                    Number(Boolean(stem && text.HasOverlap(stem))));
+            };
+            for (const frame of ordered) {
+                const old = this.previous.get(frame.id);
+                let side = frame.canFlip ? (_a = old === null || old === void 0 ? void 0 : old.side) !== null && _a !== void 0 ? _a : "right" : "right";
+                let chosen = candidate(frame, side);
+                if (!fixed(frame) && frame.canFlip) {
+                    const otherSide = side === "left" ? "right" : "left";
+                    const other = candidate(frame, otherSide);
+                    // An established side only changes when the alternative has a little breathing room.
+                    if (score(other, old ? 4 : 0) < score(chosen)) {
+                        side = otherSide;
+                        chosen = other;
+                    }
+                }
+                placed.set(frame.id, { frame: chosen, side });
+                next.set(frame.id, { frame: fixed(frame) ? old.frame : { ...frame }, side, order: (_b = old === null || old === void 0 ? void 0 : old.order) !== null && _b !== void 0 ? _b : this.nextOrder++ });
+                text.Add(chosen);
+                const stem = leaderBounds(chosen);
+                if (stem) {
+                    leaders.Add(stem);
+                }
+            }
+            this.previous = next;
+            return placed;
+        }
+    }
+    EntityLabel.PlacementMemory = PlacementMemory;
+    /*
+     * Prefer declared semantics; only infers from recognisable glyphs and filename tokens, never image pixels.
+     */
+    EntityLabel.IconPriority = GetClusterIconPriority;
+    /*
+     * Resolves clustering and stable text placement before depth fading; highlighted labels receive priority.
+     */
+    function Layout(input, memory = new PlacementMemory()) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const frames = input.filter(frame => [frame.x, frame.y, frame.width, frame.height, frame.depth].every(Number.isFinite))
+            .sort((a, b) => (b.priority || 0) - (a.priority || 0) || a.depth - b.depth || a.id.localeCompare(b.id));
+        const result = new Map();
+        const entityKeys = new Set();
+        const groups = new Map();
+        for (const frame of frames) {
+            const duplicate = frame.entityKey && entityKeys.has(frame.entityKey);
+            result.set(frame.id, { frame, visible: !duplicate, opacity: frame.opacity, zIndex: 0, members: [], entityIds: frame.entityId ? [frame.entityId] : [] });
+            if (duplicate) {
+                continue;
+            }
+            if (frame.entityKey)
+                entityKeys.add(frame.entityKey);
+            if (!((_b = (_a = frame.options) === null || _a === void 0 ? void 0 : _a.cluster) === null || _b === void 0 ? void 0 : _b.enabled) || frame.priority > 0) {
+                continue;
+            }
+            const key = JSON.stringify([frame.group || "", frame.options.presentation || "text"]);
+            if (!groups.has(key)) {
+                groups.set(key, []);
+            }
+            groups.get(key).push(frame);
+        }
+        for (const group of groups.values()) {
+            // Summary and badge dimensions are output, never the next frame's membership input.
+            const candidates = group.map(frame => frame.extendedGeometry && frame.canFlip &&
+                frame.options.cluster.pixelRange == null ? { ...frame, x: frame.anchorX, y: frame.anchorY, width: 1, height: 1 } :
+                frame.clusterBounds ? { ...frame, ...frame.clusterBounds } : frame);
+            const index = new ScreenIndex();
+            for (const frame of candidates) {
+                index.Add(frame);
+            }
+            const clusters = ClusterItems({
+                items: candidates,
+                id: frame => frame.id,
+                minSize: group[0].options.cluster.minSize,
+                neighbours: frame => {
+                    var _a;
+                    return (index.Query(frame, (_a = frame.options.cluster.pixelRange) !== null && _a !== void 0 ? _a : (frame.options.presentation === "icon" ? 24 : 8)));
+                }
+            });
+            for (const cluster of clusters) {
+                let chosen = cluster.representative;
+                if ((chosen.options.presentation || "text") !== "text" && chosen.options.cluster.representative !== "nearest") {
+                    let priority = EntityLabel.IconPriority(chosen.options);
+                    for (const member of cluster.members) {
+                        const candidate = EntityLabel.IconPriority(member.options);
+                        if (candidate > priority) {
+                            chosen = member;
+                            priority = candidate;
+                        }
+                    }
+                }
+                const representative = result.get(chosen.id);
+                representative.members = cluster.members.map(frame => frame.id);
+                representative.entityIds = Array.from(new Set(cluster.members.map(frame => frame.entityId).filter(Boolean)));
+                if (chosen.options.presentation !== "icon") {
+                    const values = new Set();
+                    const stableMembers = [...cluster.members].sort((a, b) => (a.entityKey || a.entityId || a.id).localeCompare(b.entityKey || b.entityId || b.id));
+                    for (const member of stableMembers) {
+                        const value = ((_e = (_c = member.text) !== null && _c !== void 0 ? _c : (_d = member.options) === null || _d === void 0 ? void 0 : _d.text) !== null && _e !== void 0 ? _e : "").replace(/\s+/g, " ").trim();
+                        if (value) {
+                            values.add(value);
+                        }
+                    }
+                    if (values.size > 1) {
+                        const description = stableMembers.find(member => { var _a, _b; return member.textWrapped && ((_b = (member.text || ((_a = member.options) === null || _a === void 0 ? void 0 : _a.text))) === null || _b === void 0 ? void 0 : _b.trim()); });
+                        if (description) {
+                            representative.text = ((_f = description.text) !== null && _f !== void 0 ? _f : description.options.text).trim();
+                            representative.summaryMore = true;
+                        }
+                        else {
+                            const rows = Array.from(values).slice(0, 2);
+                            if (values.size > 2)
+                                rows.push(`+${values.size - 2} more…`);
+                            representative.text = rows.join("\n");
+                        }
+                    }
+                }
+                for (const frame of cluster.members) {
+                    if (frame !== chosen)
+                        result.get(frame.id).visible = false;
+                }
+            }
+        }
+        const placed = memory.Resolve(frames.filter(frame => result.get(frame.id).visible));
+        const foreground = new ScreenIndex(), foregroundLeaders = new ScreenIndex();
+        let zIndex = frames.length + 1;
+        for (const original of frames) {
+            const placement = result.get(original.id);
+            if (!placement.visible) {
+                continue;
+            }
+            const chosen = placed.get(original.id);
+            const frame = placement.frame = chosen.frame;
+            placement.textSide = chosen.side;
+            const stem = leaderBounds(frame);
+            const box = { ...frame, x: frame.x + .01, y: frame.y + .01, width: Math.max(0, frame.width - .02), height: Math.max(0, frame.height - .02) };
+            const overlap = foreground.HasOverlap(box) || foregroundLeaders.HasOverlap(box) || Boolean(stem && foreground.HasOverlap(stem));
+            if (overlap) {
+                placement.opacity *= Math.max(0, Math.min(1, (_h = (_g = frame.options) === null || _g === void 0 ? void 0 : _g.overlapOpacity) !== null && _h !== void 0 ? _h : 0.25));
+            }
+            placement.zIndex = zIndex--;
+            foreground.Add(frame);
+            if (stem) {
+                foregroundLeaders.Add(stem);
+            }
+        }
+        return Array.from(result.values());
+    }
+    EntityLabel.Layout = Layout;
+    const layers = new WeakMap();
+    const containers = new WeakMap();
+    /*
+     * Moves the shared overlay without recreating labels or resolving their sources.
+     */
+    function SetContainer(viewer, container) {
+        const layer = layers.get(viewer);
+        if (container && (container === (layer === null || layer === void 0 ? void 0 : layer.element) || (layer === null || layer === void 0 ? void 0 : layer.element.contains(container)))) {
+            throw new Error("Label container cannot be inside the label overlay");
+        }
+        if (container) {
+            containers.set(viewer, container);
+        }
+        else
+            containers.delete(viewer);
+        layer === null || layer === void 0 ? void 0 : layer.Move();
+    }
+    EntityLabel.SetContainer = SetContainer;
+    /*
+     * Owns one scene callback per viewer and separates projection/measurement from DOM writes.
+     */
+    class Layer {
+        constructor(viewer) {
+            this.viewer = viewer;
+            this.element = document.createElement("div");
+            this.coordinates = { x: 0, y: 0, scaleX: 1, scaleY: 1 };
+            this.participants = new Set();
+            this.placementMemory = new PlacementMemory();
+            this.forwardingWheel = false;
+            this.pendingDrag = null;
+            this.TrackPointer = (event) => {
+                var _a, _b;
+                if (event.pointerType && event.pointerType !== "mouse" && event.pointerType !== "pen")
+                    return;
+                const rect = (_b = (_a = this.viewer.canvas).getBoundingClientRect) === null || _b === void 0 ? void 0 : _b.call(_a);
+                if (!rect || event.clientX < rect.left || event.clientX >= rect.right || event.clientY < rect.top || event.clientY >= rect.bottom) {
+                    if (this.pointerClient)
+                        this.ClearPointer();
+                    return;
+                }
+                this.pointerClient = { x: event.clientX, y: event.clientY };
+                this.viewer.scene.requestRender();
+            };
+            this.PointerOut = (event) => { if (!event.relatedTarget)
+                this.ClearPointer(); };
+            this.ClearPointer = () => {
+                this.pointerClient = undefined;
+                this.pointer = undefined;
+                if (!this.viewer.isDestroyed()) {
+                    this.viewer.scene.requestRender();
+                }
+            };
+            this.PreventNativeDrag = (event) => {
+                event.preventDefault();
+            };
+            this.BeginDrag = (event) => {
+                var _a, _b, _c;
+                this.EndPendingDrag();
+                const detection = FeatureDetection;
+                const target = (_b = (_a = event.target) === null || _a === void 0 ? void 0 : _a.closest) === null || _b === void 0 ? void 0 : _b.call(_a, '.entity-label [role="button"]');
+                const canvas = this.viewer.canvas;
+                if (event.defaultPrevented || event.button !== 0 || event.pointerType !== "mouse" ||
+                    ((_c = detection.supportsPointerEvents) === null || _c === void 0 ? void 0 : _c.call(detection)) === false || !canvas.setPointerCapture || this.viewer.isDestroyed() ||
+                    !target || !this.element.contains(target) ||
+                    this.element.ownerDocument.defaultView.getComputedStyle(target).visibility !== "visible") {
+                    return;
+                }
+                const bounds = canvas.getBoundingClientRect();
+                if (event.clientX < bounds.left || event.clientX >= bounds.right || event.clientY < bounds.top || event.clientY >= bounds.bottom) {
+                    return;
+                }
+                this.pendingDrag = event;
+                const doc = this.element.ownerDocument;
+                doc.addEventListener("pointermove", this.ContinueDrag, true);
+                doc.addEventListener("pointerup", this.FinishPendingDrag, true);
+                doc.addEventListener("pointercancel", this.FinishPendingDrag, true);
+                doc.defaultView.addEventListener("blur", this.EndPendingDrag);
+            };
+            this.FinishPendingDrag = (event) => {
+                var _a;
+                if (event.pointerId === ((_a = this.pendingDrag) === null || _a === void 0 ? void 0 : _a.pointerId)) {
+                    this.EndPendingDrag();
+                }
+            };
+            this.EndPendingDrag = () => {
+                this.pendingDrag = null;
+                const doc = this.element.ownerDocument;
+                doc.removeEventListener("pointermove", this.ContinueDrag, true);
+                doc.removeEventListener("pointerup", this.FinishPendingDrag, true);
+                doc.removeEventListener("pointercancel", this.FinishPendingDrag, true);
+                doc.defaultView.removeEventListener("blur", this.EndPendingDrag);
+            };
+            this.ContinueDrag = (event) => {
+                const start = this.pendingDrag;
+                if (!start || event.pointerId !== start.pointerId) {
+                    return;
+                }
+                if (!(event.buttons & 1) || this.viewer.isDestroyed() || !this.element.contains(start.target)) {
+                    this.EndPendingDrag();
+                    return;
+                }
+                // Keep ordinary clicks local; only a deliberate drag starts Cesium's camera gesture.
+                if (Math.hypot(event.clientX - start.clientX, event.clientY - start.clientY) < 6) {
+                    return;
+                }
+                this.EndPendingDrag();
+                const canvas = this.viewer.canvas;
+                try {
+                    canvas.setPointerCapture(start.pointerId);
+                }
+                catch {
+                    // A cancelled pointer or unsupported capture still cannot start native image dragging.
+                    return;
+                }
+                const win = this.element.ownerDocument.defaultView;
+                const copy = (source) => ({
+                    bubbles: true, cancelable: true, pointerId: source.pointerId, pointerType: source.pointerType,
+                    isPrimary: source.isPrimary, button: source.button, buttons: source.buttons,
+                    clientX: source.clientX, clientY: source.clientY, screenX: source.screenX, screenY: source.screenY,
+                    ctrlKey: source.ctrlKey, shiftKey: source.shiftKey, altKey: source.altKey, metaKey: source.metaKey
+                });
+                // Capture routes subsequent real move/up events to Cesium, including releases outside the label.
+                canvas.dispatchEvent(new win.PointerEvent("pointerdown", copy(start)));
+                canvas.dispatchEvent(new win.PointerEvent("pointermove", copy(event)));
+                event.preventDefault();
+                event.stopPropagation();
+                this.viewer.scene.requestRender();
+            };
+            this.ForwardWheel = (event) => {
+                var _a, _b, _c;
+                if (this.forwardingWheel || event.defaultPrevented || this.viewer.isDestroyed()) {
+                    return;
+                }
+                const target = (_b = (_a = event.target) === null || _a === void 0 ? void 0 : _a.closest) === null || _b === void 0 ? void 0 : _b.call(_a, '.entity-label [role="button"]');
+                const canvas = this.viewer.canvas;
+                const win = this.element.ownerDocument.defaultView;
+                if (!target || !this.element.contains(target) || win.getComputedStyle(target).visibility !== "visible") {
+                    return;
+                }
+                const bounds = canvas.getBoundingClientRect();
+                if (event.clientX < bounds.left || event.clientX >= bounds.right || event.clientY < bounds.top || event.clientY >= bounds.bottom) {
+                    return;
+                }
+                const position = {
+                    bubbles: true, cancelable: true, clientX: event.clientX, clientY: event.clientY,
+                    screenX: event.screenX, screenY: event.screenY, buttons: event.buttons,
+                    ctrlKey: event.ctrlKey, shiftKey: event.shiftKey, altKey: event.altKey, metaKey: event.metaKey,
+                    pointerId: 1, pointerType: "mouse", isPrimary: true
+                };
+                this.forwardingWheel = true;
+                try {
+                    // Cesium's wheel zoom uses its last mouse position, not the wheel event's coordinates.
+                    const detection = FeatureDetection;
+                    // Older Cesium versions opt Firefox out even when the browser exposes PointerEvent.
+                    canvas.dispatchEvent(((_c = detection.supportsPointerEvents) === null || _c === void 0 ? void 0 : _c.call(detection)) !== false && typeof win.PointerEvent === "function" ?
+                        new win.PointerEvent("pointermove", position) : new win.MouseEvent("mousemove", position));
+                    canvas.dispatchEvent(new win.WheelEvent("wheel", {
+                        ...position, deltaX: event.deltaX, deltaY: event.deltaY, deltaZ: event.deltaZ, deltaMode: event.deltaMode
+                    }));
+                    this.viewer.scene.requestRender();
+                    event.preventDefault();
+                    event.stopPropagation();
+                }
+                finally {
+                    this.forwardingWheel = false;
+                }
+            };
+            this.element.className = "entity-label-layer";
+            // Depth ordering belongs inside the map overlay, never in the application's UI stack.
+            this.element.style.cssText = "position:absolute;inset:0;z-index:0;isolation:isolate;pointer-events:none;";
+            this.Move();
+            this.element.addEventListener("wheel", this.ForwardWheel, { passive: false });
+            this.element.addEventListener("pointerdown", this.BeginDrag, true);
+            this.element.addEventListener("dragstart", this.PreventNativeDrag);
+            this.element.ownerDocument.addEventListener("pointermove", this.TrackPointer, true);
+            this.element.ownerDocument.addEventListener("pointerout", this.PointerOut, true);
+            this.element.ownerDocument.defaultView.addEventListener("blur", this.ClearPointer);
+            this.remove = viewer.scene.postUpdate.addEventListener(() => this.Update());
+        }
+        Move() {
+            (containers.get(this.viewer) || this.viewer.container).appendChild(this.element);
+            this.Update();
+            this.viewer.scene.requestRender();
+        }
+        MeasureCoordinates() {
+            var _a;
+            const canvas = this.viewer.canvas;
+            const canvasRect = (_a = canvas.getBoundingClientRect) === null || _a === void 0 ? void 0 : _a.call(canvas);
+            const rect = this.element.getBoundingClientRect();
+            const scaleX = rect.width / this.element.offsetWidth || 1;
+            const scaleY = rect.height / this.element.offsetHeight || 1;
+            return {
+                x: (((canvasRect === null || canvasRect === void 0 ? void 0 : canvasRect.left) || 0) - rect.left) / scaleX,
+                y: (((canvasRect === null || canvasRect === void 0 ? void 0 : canvasRect.top) || 0) - rect.top) / scaleY,
+                scaleX: ((canvasRect === null || canvasRect === void 0 ? void 0 : canvasRect.width) / canvas.clientWidth || 1) / scaleX,
+                scaleY: ((canvasRect === null || canvasRect === void 0 ? void 0 : canvasRect.height) / canvas.clientHeight || 1) / scaleY
+            };
+        }
+        Add(participant) {
+            this.participants.add(participant);
+            this.viewer.scene.requestRender();
+            return () => {
+                this.participants.delete(participant);
+                if (!this.participants.size) {
+                    this.remove();
+                    this.element.removeEventListener("wheel", this.ForwardWheel);
+                    this.element.removeEventListener("pointerdown", this.BeginDrag, true);
+                    this.element.removeEventListener("dragstart", this.PreventNativeDrag);
+                    this.element.ownerDocument.removeEventListener("pointermove", this.TrackPointer, true);
+                    this.element.ownerDocument.removeEventListener("pointerout", this.PointerOut, true);
+                    this.element.ownerDocument.defaultView.removeEventListener("blur", this.ClearPointer);
+                    this.EndPendingDrag();
+                    this.element.remove();
+                    layers.delete(this.viewer);
+                }
+            };
+        }
+        Update() {
+            var _a, _b;
+            this.coordinates = this.MeasureCoordinates();
+            const rect = (_b = (_a = this.viewer.canvas).getBoundingClientRect) === null || _b === void 0 ? void 0 : _b.call(_a);
+            const pointer = this.pointerClient;
+            this.pointer = pointer && (rect === null || rect === void 0 ? void 0 : rect.width) && (rect === null || rect === void 0 ? void 0 : rect.height) && pointer.x >= rect.left && pointer.x < rect.right && pointer.y >= rect.top && pointer.y < rect.bottom ?
+                {
+                    x: (pointer.x - rect.left) * this.viewer.canvas.clientWidth / rect.width,
+                    y: (pointer.y - rect.top) * this.viewer.canvas.clientHeight / rect.height
+                } : undefined;
+            const projected = new Map();
+            for (const participant of this.participants) {
+                projected.set(participant, participant.project());
+            }
+            const placements = new Map(Layout(Array.from(projected.values()).filter(Boolean), this.placementMemory).map(item => [item.frame.id, item]));
+            for (const [participant, frame] of projected) {
+                participant.apply(frame ? placements.get(frame.id) : undefined);
+            }
+        }
+    }
+    let nextLabelId = 0;
     class Label {
+        get HasText() { return this.options.presentation !== "icon"; }
+        SetHoverVisible(visible) {
+            var _a, _b, _c;
+            if (!this.Transient || this.Persistent) {
+                return;
+            }
+            if (!visible) {
+                this.retainedHoverPosition = (_a = this.visualRegister) === null || _a === void 0 ? void 0 : _a.GetLabelHoverPosition((_b = this.rego) === null || _b === void 0 ? void 0 : _b.entityId, (_c = this.rego) === null || _c === void 0 ? void 0 : _c.menuItemId);
+                // Retiring labels must not change the ring now owned by the next hover target.
+                if (this.ringAnimation) {
+                    this.ringAnimation = { ...this.ringAnimation };
+                }
+            }
+            if (this.hoverFade.to === Number(visible)) {
+                return;
+            }
+            this.hoverFade = { from: this.HoverOpacity(), to: Number(visible), start: Date.now() };
+            this.viewer.scene.requestRender();
+        }
+        HoverOpacity() {
+            if (!this.Transient || this.Persistent) {
+                return 1;
+            }
+            const progress = Math.min(1, Math.max(0, (Date.now() - this.hoverFade.start) / 120));
+            if (progress < 1) {
+                this.viewer.scene.requestRender();
+            }
+            return this.hoverFade.from + (this.hoverFade.to - this.hoverFade.from) * progress * progress * (3 - 2 * progress);
+        }
         get Rego() {
             return this.rego;
         }
@@ -5333,10 +5967,18 @@ var EntityLabel;
         set pos3d(val) {
             this._pos3d = val;
             this.prePositioned = !isNaN(val === null || val === void 0 ? void 0 : val.x);
-            this.createLabel(val);
+            if (this.label && this.prePositioned)
+                this.viewer.scene.requestRender();
+            else
+                this.createLabel(val);
         }
         constructor(params) {
-            var _a;
+            var _a, _b, _c, _d;
+            this.id = `label-${++nextLabelId}`;
+            this.Persistent = false;
+            this.Transient = false;
+            this.hoverFade = { from: 0, to: 1, start: Date.now() };
+            this.cursorMotion = { amount: 0, from: 0, target: 0, start: 0, position: undefined };
             // Counter to help differentiate between createLabel calls.
             this.counter = 0;
             // The label element itself.
@@ -5356,15 +5998,24 @@ var EntityLabel;
             this.loadTimeout = null;
             this.loadedName = false;
             this.line = null;
+            this.anchor = null;
             // Null = not attempted to load.
             this.additionalTexts = null;
             this.rego = params.rego;
             this.viewer = params.viewer;
             this.api = params.api;
             this.visualRegister = params.visualRegister;
-            this.prePositioned = !isNaN((_a = params.pos3d) === null || _a === void 0 ? void 0 : _a.x);
+            this.options = params.options || {};
+            this.groupId = params.groupId;
+            this.Persistent = (_a = params.persistent) !== null && _a !== void 0 ? _a : Boolean(params.groupId);
+            this.Transient = (_b = params.transient) !== null && _b !== void 0 ? _b : false;
+            this.hoverRingState = params.hoverRingState;
+            this.visible = params.visible;
+            if (((_c = params.options) === null || _c === void 0 ? void 0 : _c.text) != null)
+                this.additionalTexts = [];
+            this.prePositioned = !isNaN((_d = params.pos3d) === null || _d === void 0 ? void 0 : _d.x);
             this.createLabel(params.pos3d);
-            if (!params.api && !ENVIRONMENT.IS_SELF_MANAGED) {
+            if (!params.api && !ENVIRONMENT.IS_SELF_MANAGED && this.options.text == null) {
                 this.api = ENVIRONMENT.Api().GetBruceApi();
             }
         }
@@ -5414,12 +6065,24 @@ var EntityLabel;
             clearTimeout(this.loadTimeout);
             this.loadTimeout = null;
         }
+        /*
+         * Rebuilds only when configuration changes; state refreshes must not recreate DOM every frame.
+         */
+        Configure(options, groupId) {
+            if (this.groupId === groupId && JSON.stringify(this.options) === JSON.stringify(options || {})) {
+                return;
+            }
+            this.options = options || {};
+            this.groupId = groupId;
+            this.additionalTexts = this.options.text != null ? [] : null;
+            this.createLabel();
+        }
         /**
          * Creates cesium entity for the label if one does not exist.
          * @param starterPos3d optional position to create label at. Ignored for billboard labels.
          */
         async createLabel(starterPos3d) {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
             this.removeLabel();
             let pos3d = starterPos3d ? starterPos3d.clone() : null;
             const counter = ++this.counter;
@@ -5628,7 +6291,7 @@ var EntityLabel;
                     }
                     clearTimeout(this.loadTimeout);
                     this.loadTimeout = setTimeout(async () => {
-                        var _a, _b, _c, _d;
+                        var _a, _b, _c, _d, _e;
                         if (this.disposed || this.counter != counter) {
                             return;
                         }
@@ -5636,10 +6299,10 @@ var EntityLabel;
                         if (this.additionalTexts == null) {
                             const additionalTexts = [];
                             // Rego might not have a known or default Entity Type. Eg: OSM building.
-                            if (this.rego.entityTypeId) {
+                            if (this.rego.entityTypeId || this.options.attributes) {
                                 let entityType = null;
                                 try {
-                                    const data = await EntityType.Get({
+                                    const data = this.options.attributes ? null : await EntityType.Get({
                                         api: this.api,
                                         entityTypeId: this.rego.entityTypeId
                                     });
@@ -5654,14 +6317,14 @@ var EntityLabel;
                                 }
                                 // Type could be deleted, however we'll just catch that to show a label instead of nothing.
                                 // This is not unusual for Tilesets where the Type that is baked might be outdated.
-                                if (entityType) {
-                                    const attributes = (_b = (_a = entityType.VisualSettings) === null || _a === void 0 ? void 0 : _a.label) === null || _b === void 0 ? void 0 : _b.attributes;
+                                if (entityType || this.options.attributes) {
+                                    const attributes = (_a = this.options.attributes) !== null && _a !== void 0 ? _a : (_c = (_b = entityType.VisualSettings) === null || _b === void 0 ? void 0 : _b.label) === null || _c === void 0 ? void 0 : _c.attributes;
                                     if (attributes) {
                                         try {
                                             const { entity } = await Entity$1.Get({
                                                 api: this.api,
                                                 entityId: this.rego.entityId,
-                                                scenario: ((_c = this.rego.outline) === null || _c === void 0 ? void 0 : _c.length) ? (_d = this.rego.outline.find(x => !!x.Scenario)) === null || _d === void 0 ? void 0 : _d.Scenario : null,
+                                                scenario: ((_d = this.rego.outline) === null || _d === void 0 ? void 0 : _d.length) ? (_e = this.rego.outline.find(x => !!x.Scenario)) === null || _e === void 0 ? void 0 : _e.Scenario : null,
                                                 schemaId: this.rego.schema,
                                                 migrated: true
                                             });
@@ -5670,7 +6333,7 @@ var EntityLabel;
                                                     entity: entity,
                                                     path: attributes[i]
                                                 });
-                                                if (value) {
+                                                if (value != null) {
                                                     additionalTexts.push(value);
                                                 }
                                             }
@@ -5699,12 +6362,166 @@ var EntityLabel;
             if (this.disposed || this.counter != counter) {
                 return;
             }
-            const labelContent = `
-                <div>
-                    <div style="margin-bottom:4px">${text}</div>
-                    ${additionalTexts.map(attr => `<div>${attr}</div>`).join('')}
-                </div>
-            `;
+            const presentation = this.options.presentation || "text";
+            let clickEntityIds = [];
+            const selectOnClick = (_j = this.options.selectOnClick) !== null && _j !== void 0 ? _j : Boolean(this.groupId);
+            const select = (event) => {
+                event.preventDefault();
+                event.stopPropagation();
+                if (!selectOnClick || this.disposed || this.counter !== counter || !clickEntityIds.length || !this.visualRegister) {
+                    return;
+                }
+                this.visualRegister.ClearSelected({ requestRender: false });
+                this.visualRegister.SetSelected({ entityIds: clickEntityIds, selected: true });
+            };
+            const makeClickable = (target) => {
+                if (!selectOnClick || !this.visualRegister) {
+                    return;
+                }
+                target.style.pointerEvents = "auto";
+                target.style.cursor = "pointer";
+                target.style.userSelect = "none";
+                target.setAttribute("role", "button");
+                target.tabIndex = 0;
+                target.addEventListener("click", select);
+                target.addEventListener("keydown", event => {
+                    if (event.key === "Enter" || event.key === " ")
+                        select(event);
+                });
+                // Prevent viewer picking and camera gestures from interpreting label interactions.
+                for (const type of ["pointerdown", "pointerup", "mousedown", "mouseup", "dblclick"]) {
+                    target.addEventListener(type, event => event.stopPropagation());
+                }
+            };
+            const normalLeader = (_k = this.options.leader) !== null && _k !== void 0 ? _k : presentation === "text";
+            let leader = normalLeader;
+            const content = document.createElement("span");
+            const originalText = (_l = this.options.text) !== null && _l !== void 0 ? _l : [text, ...additionalTexts].join("\n");
+            let textElement;
+            let sourceText;
+            let sourceNaturalText;
+            let iconElement;
+            let iconContainer;
+            content.className = "entity-label-content";
+            content.style.cssText = "display:flex;align-items:center;gap:6px;";
+            if (presentation === "icon-text-above") {
+                content.style.flexDirection = "column-reverse";
+            }
+            if (presentation !== "text") {
+                const icon = document.createElement("span");
+                iconElement = icon;
+                icon.className = "entity-label-icon";
+                icon.style.cssText = `font-size:${(this.options.iconSize || 24) * ((_m = this.options.iconScale) !== null && _m !== void 0 ? _m : 1)}px;line-height:1;`;
+                icon.style.textShadow = "0 1px 2px rgba(0, 0, 0, 0.25)";
+                const iconColor = typeof this.options.iconColor === "string" ? this.options.iconColor : undefined;
+                const iconBackground = this.options.iconBackground && this.options.iconScale !== 0;
+                if (iconColor) {
+                    icon.style.color = iconColor;
+                }
+                if (this.options.iconUrl) {
+                    const image = document.createElement("img");
+                    image.draggable = false;
+                    image.alt = this.options.icon || "";
+                    const scale = (_o = this.options.iconScale) !== null && _o !== void 0 ? _o : 1;
+                    const size = this.options.iconSize;
+                    const mask = iconColor && iconBackground ? document.createElement("span") : icon;
+                    if (mask !== icon) {
+                        icon.appendChild(mask);
+                    }
+                    const target = iconColor ? mask : image;
+                    if (iconColor) {
+                        mask.style.display = "inline-block";
+                        mask.style.backgroundColor = iconColor;
+                        for (const prefix of ["", "-webkit-"]) {
+                            mask.style.setProperty(`${prefix}mask-image`, `url(${JSON.stringify(this.options.iconUrl)})`);
+                            mask.style.setProperty(`${prefix}mask-size`, "contain");
+                            mask.style.setProperty(`${prefix}mask-repeat`, "no-repeat");
+                            mask.style.setProperty(`${prefix}mask-position`, "center");
+                        }
+                    }
+                    const resize = () => {
+                        if (this.disposed || this.counter !== counter) {
+                            return;
+                        }
+                        const intrinsic = this.options.iconScale != null && size == null;
+                        target.style.width = `${(intrinsic ? image.naturalWidth || 24 : size || 24) * scale}px`;
+                        target.style.height = `${(intrinsic ? image.naturalHeight || 24 : size || 24) * scale}px`;
+                        this.viewer.scene.requestRender();
+                    };
+                    image.onload = resize;
+                    resize();
+                    image.src = this.options.iconUrl;
+                    if (!iconColor) {
+                        icon.appendChild(image);
+                    }
+                }
+                else if (typeof this.options.iconClass === "string" && this.options.iconClass) {
+                    icon.className = `entity-label-icon ${this.options.iconClass}`;
+                }
+                else {
+                    icon.textContent = this.options.icon || "●";
+                }
+                if (iconBackground) {
+                    const color = Color.fromCssColorString(iconColor || "white") || Color.WHITE;
+                    const luminance = 0.2126 * color.red + 0.7152 * color.green + 0.0722 * color.blue;
+                    const background = (luminance > 0.5 ? color.darken(ICON_BACKGROUND_BLEND, new Color()) :
+                        color.brighten(ICON_BACKGROUND_BLEND, new Color()));
+                    const size = (this.options.iconSize || 24) * ((_p = this.options.iconScale) !== null && _p !== void 0 ? _p : 1);
+                    icon.style.backgroundColor = background.withAlpha(ICON_BACKGROUND_ALPHA).toCssColorString();
+                    icon.style.borderRadius = "50%";
+                    icon.style.padding = `${size / 3}px`;
+                    icon.style.display = "inline-flex";
+                    icon.style.alignItems = "center";
+                    icon.style.justifyContent = "center";
+                    icon.style.minWidth = `${size}px`;
+                    icon.style.minHeight = `${size}px`;
+                    icon.style.boxSizing = "content-box";
+                }
+                if (this.options.iconScale === 0) {
+                    icon.style.display = "none";
+                }
+                makeClickable(icon);
+                // Keep badges outside the glyph so font classes and image masks cannot affect them.
+                iconContainer = document.createElement("span");
+                iconContainer.style.cssText = "position:relative;display:inline-flex;flex:none;";
+                iconContainer.appendChild(icon);
+                content.appendChild(iconContainer);
+            }
+            if (presentation !== "icon") {
+                textElement = document.createElement("span");
+                textElement.className = "entity-label-text";
+                const textStyle = `white-space:pre-wrap;overflow-wrap:anywhere;max-width:${TEXT_MAX_WIDTH}px;width:max-content;flex-shrink:0;`;
+                textElement.style.cssText = textStyle;
+                textElement.textContent = originalText;
+                if (presentation === "text")
+                    makeClickable(textElement);
+                content.appendChild(textElement);
+                if ((_q = this.options.cluster) === null || _q === void 0 ? void 0 : _q.enabled) {
+                    sourceText = document.createElement("span");
+                    sourceText.className = "entity-label-source-text";
+                    sourceText.setAttribute("aria-hidden", "true");
+                    sourceText.style.cssText = textStyle + "position:absolute;visibility:hidden;pointer-events:none;";
+                    sourceText.textContent = originalText;
+                    content.appendChild(sourceText);
+                    // Measure the original unwrapped text, never a rendered cluster summary.
+                    sourceNaturalText = document.createElement("span");
+                    sourceNaturalText.setAttribute("aria-hidden", "true");
+                    sourceNaturalText.style.cssText = "position:absolute;visibility:hidden;pointer-events:none;white-space:pre;width:max-content;";
+                    sourceNaturalText.textContent = originalText;
+                    content.appendChild(sourceNaturalText);
+                }
+            }
+            const countElement = document.createElement("span");
+            countElement.className = "entity-label-count";
+            countElement.style.cssText = "flex:none;align-self:center;white-space:nowrap;background:#fff;color:#000;text-shadow:none;border-radius:8px;padding:0 3px;display:none;";
+            if (iconContainer) {
+                countElement.style.cssText += "position:absolute;left:100%;top:0;transform:translate(-50%,-50%);";
+                iconContainer.appendChild(countElement);
+            }
+            if (!layers.has(this.viewer)) {
+                layers.set(this.viewer, new Layer(this.viewer));
+            }
+            const layer = layers.get(this.viewer);
             let ele = null;
             let lineEle = null;
             if (this.label) {
@@ -5712,11 +6529,22 @@ var EntityLabel;
             }
             else {
                 ele = document.createElement("div");
-                ele.innerHTML = labelContent;
+                ele.appendChild(content);
+                if (!iconContainer) {
+                    ele.appendChild(countElement);
+                }
+                ele.className = "entity-label";
+                ele.dataset.entityId = ((_r = this.rego) === null || _r === void 0 ? void 0 : _r.entityId) || "";
+                ele.dataset.presentation = presentation;
+                if (this.groupId) {
+                    ele.dataset.groupId = this.groupId;
+                }
                 ele.setAttribute("style", `
                     position: absolute;
                     z-index: 0;
                     display: none;
+                    align-items: center;
+                    gap: 6px;
                     pointer-events: none;
                     padding: 6px 8px;
                     border-radius: 6px;
@@ -5725,9 +6553,10 @@ var EntityLabel;
                     border-radius: 9px;
                     color: #ffffff;
                     text-shadow: 0 0 5px rgba(0, 0, 0, 0.8);
-                }`);
+                `);
                 this.label = ele;
-                this.viewer.container.appendChild(ele);
+                ele.style.width = "max-content";
+                layer.element.appendChild(ele);
             }
             if (this.line) {
                 lineEle = this.line;
@@ -5744,7 +6573,10 @@ var EntityLabel;
                     box-shadow: 0 0 5px rgba(0, 0, 0, 0.3);
                 `);
                 this.line = lineEle;
-                // We'll draw a ball at the bottom of the line to make it look like it's connecting to the entity.
+                lineEle.className = "entity-label-leader";
+                if (this.options.leaderColor)
+                    lineEle.style.background = this.options.leaderColor;
+                // A separate anchor keeps the stem out of the hollow centre when proximity opens the ring.
                 const lineEleNode = document.createElement("div");
                 lineEleNode.setAttribute("style", `
                     position: absolute;
@@ -5757,35 +6589,20 @@ var EntityLabel;
                     top: -2px;
                     left: -2px;
                 `);
-                lineEle.appendChild(lineEleNode);
-                this.viewer.container.appendChild(lineEle);
+                lineEleNode.className = "entity-label-anchor";
+                // SVG preserves fractional strokes in scaled containers where CSS borders round to pixels.
+                const ringSvg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+                ringSvg.style.cssText = "position:absolute;inset:0;width:100%;height:100%;overflow:visible;";
+                ringSvg.setAttribute("aria-hidden", "true");
+                ringSvg.setAttribute("preserveAspectRatio", "none");
+                const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");
+                circle.setAttribute("fill", "none");
+                ringSvg.appendChild(circle);
+                lineEleNode.appendChild(ringSvg);
+                this.anchor = lineEleNode;
+                layer.element.appendChild(lineEleNode);
+                layer.element.appendChild(lineEle);
             }
-            let _lastDistance = null;
-            let _lastCameraPos = null;
-            const getDistance = () => {
-                var _a;
-                if (this.disposed) {
-                    return null;
-                }
-                const cameraPos = (_a = this.viewer.camera) === null || _a === void 0 ? void 0 : _a.position;
-                if (isNaN(cameraPos === null || cameraPos === void 0 ? void 0 : cameraPos.x)) {
-                    return null;
-                }
-                // If camera hasn't moved much then we can use the last distance.
-                const TOLERANCE = 0.1;
-                if (_lastCameraPos) {
-                    const totalMovement = Math.abs(_lastCameraPos.x - cameraPos.x) +
-                        Math.abs(_lastCameraPos.y - cameraPos.y) +
-                        Math.abs(_lastCameraPos.z - cameraPos.z);
-                    if (totalMovement < TOLERANCE) {
-                        return _lastDistance;
-                    }
-                }
-                const distance = Cartesian3.distance(cameraPos, this._pos3d);
-                _lastDistance = distance;
-                _lastCameraPos = cameraPos.clone();
-                return distance;
-            };
             let MAX_DISTANCE = Math.max(15000, sizeInM * 35);
             if (visual && visual instanceof Entity) {
                 // Consistent sized things.
@@ -5793,123 +6610,399 @@ var EntityLabel;
                     MAX_DISTANCE = Infinity;
                 }
             }
-            const updateLabel = () => {
-                var _a;
-                if (this.disposed || isNaN((_a = this._pos3d) === null || _a === void 0 ? void 0 : _a.x)) {
-                    return;
+            const fitLeader = (anchorX, anchorY, desired, width, height, radius = 0) => {
+                const above = Math.max(0, anchorY - height);
+                const below = Math.max(0, this.viewer.canvas.clientHeight - anchorY - height);
+                // Keep a short visible stem before switching sides; never aim it at the cursor or a box corner.
+                const upwards = above >= Math.max(radius ? radius + 4 : 0, Math.min(8, desired)) || above >= below;
+                const length = Math.min(desired, upwards ? above : below);
+                const endY = anchorY + (upwards ? -length : length);
+                return {
+                    x: Math.max(0, Math.min(anchorX, this.viewer.canvas.clientWidth - width)),
+                    y: upwards ? endY - height : endY, endY
+                };
+            };
+            let cursorMotion = this.cursorMotion;
+            const project = () => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+                if (this.disposed || !this.viewer || this.viewer.isDestroyed() || ((_a = this.visible) === null || _a === void 0 ? void 0 : _a.call(this)) === false ||
+                    (presentation === "icon" && this.options.iconScale === 0)) {
+                    return null;
                 }
-                if (!this.viewer || this.viewer.isDestroyed()) {
-                    this.Dispose();
-                    return;
+                if (this.Transient && !this.Persistent && this.hoverFade.to === 0 &&
+                    (this.hoverFade.from === 0 || Date.now() - this.hoverFade.start >= 120)) {
+                    return null;
                 }
-                const distance = getDistance();
-                if (isNaN(distance) || (!this.prePositioned && distance >= MAX_DISTANCE)) {
-                    ele.style.display = "none";
-                    lineEle.style.display = "none";
-                    return;
+                // Moving point/model positions must be sampled at the current clock time.
+                if (!this.prePositioned && visual instanceof Entity && visual.position) {
+                    const position = getValue(this.viewer, visual.position);
+                    if (position)
+                        this._pos3d = DrawingUtils.EnsurePosHeight({
+                            desiredHeightRef: HeightReference.NONE, heightRef, pos3d: position, viewer: this.viewer
+                        });
                 }
-                const CESIUM = Cesium;
-                const _3dTo2D = SceneTransforms.hasOwnProperty("wgs84ToWindowCoordinates") ? CESIUM.SceneTransforms.wgs84ToWindowCoordinates : CESIUM.SceneTransforms.worldToWindowCoordinates;
-                const lineStartPos2d = _3dTo2D(this.viewer.scene, this._pos3d);
-                // Invalid point.
-                if (isNaN(lineStartPos2d === null || lineStartPos2d === void 0 ? void 0 : lineStartPos2d.x)) {
-                    ele.style.transform = "";
-                    ele.style.opacity = "0";
-                    lineEle.style.display = "none";
-                    return;
+                if (!Number.isFinite((_b = this._pos3d) === null || _b === void 0 ? void 0 : _b.x)) {
+                    return null;
+                }
+                const camera = this.viewer.camera;
+                const cameraPosition = camera.positionWC || camera.position;
+                const relative = Cartesian3.subtract(this._pos3d, cameraPosition, new Cartesian3());
+                const depth = Cartesian3.dot(relative, camera.directionWC || camera.direction);
+                const distance = Cartesian3.magnitude(relative);
+                if (!Number.isFinite(distance) || depth <= 0 || distance < ((_c = this.options.near) !== null && _c !== void 0 ? _c : 0) ||
+                    distance > ((_d = this.options.far) !== null && _d !== void 0 ? _d : Infinity) || (!this.prePositioned && distance >= MAX_DISTANCE)) {
+                    return null;
                 }
-                // Offset start by the pixel offset.
-                lineStartPos2d.x += pixelOffset.x;
-                lineStartPos2d.y += pixelOffset.y;
-                ele.style.display = "block";
-                lineEle.style.display = "block";
-                // Calculate opacity to apply based on distance between camera and pos3d.
-                // We'll make the label less transparent when further away.
-                const opacity = this.prePositioned || MAX_DISTANCE == Infinity ? 1 : 1 - (distance / MAX_DISTANCE);
-                if (opacity && opacity > 0.15) {
-                    this.label.style.opacity = `${opacity}`;
-                    // Calc where the line should end.
-                    // We get the pos3d and add 'n' to it, then turn it back into 2d.
-                    let lineEndPos3d = this._pos3d.clone();
-                    const lineEndPoint = Cartographic.fromCartesian(lineEndPos3d);
-                    let addHeight = null;
-                    // If we're pre-positioned that means the user is hovering over the entity.
-                    // We will keep the height low to avoid looking goofy.
-                    if (this.prePositioned) {
-                        addHeight = distance / 24;
+                const transforms = SceneTransforms;
+                const projectPosition = transforms.wgs84ToWindowCoordinates || transforms.worldToWindowCoordinates;
+                const anchor = projectPosition(this.viewer.scene, this._pos3d);
+                if (!Number.isFinite(anchor === null || anchor === void 0 ? void 0 : anchor.x) || !Number.isFinite(anchor === null || anchor === void 0 ? void 0 : anchor.y)) {
+                    return null;
+                }
+                if (leader && (anchor.x < 0 || anchor.y < 0 || anchor.x >= this.viewer.canvas.clientWidth || anchor.y >= this.viewer.canvas.clientHeight))
+                    return null;
+                const transientPivot = (this.Transient && !this.Persistent ?
+                    (this.hoverFade.to === 0 ? this.retainedHoverPosition : (_e = this.visualRegister) === null || _e === void 0 ? void 0 : _e.GetLabelHoverPosition((_f = this.rego) === null || _f === void 0 ? void 0 : _f.entityId, (_g = this.rego) === null || _g === void 0 ? void 0 : _g.menuItemId)) : undefined);
+                const hover = (presentation !== "icon" ?
+                    (this.Transient && !this.Persistent && this.hoverFade.to === 0 ? this.retainedHoverPosition :
+                        (_h = this.visualRegister) === null || _h === void 0 ? void 0 : _h.GetLabelHoverPosition((_j = this.rego) === null || _j === void 0 ? void 0 : _j.entityId, (_k = this.rego) === null || _k === void 0 ? void 0 : _k.menuItemId)) : undefined);
+                const reused = !this.Transient || this.Persistent;
+                const now = Date.now();
+                const animateCursor = () => {
+                    const progress = Math.min(1, Math.max(0, (now - cursorMotion.start) / 200));
+                    const eased = progress * progress * (3 - 2 * progress);
+                    cursorMotion.amount = cursorMotion.from + (cursorMotion.target - cursorMotion.from) * eased;
+                    return progress;
+                };
+                animateCursor();
+                const cursorTarget = reused && hover ? 1 : 0;
+                if (cursorMotion.target !== cursorTarget) {
+                    cursorMotion = { ...cursorMotion, from: cursorMotion.amount, target: cursorTarget, start: now };
+                }
+                if (hover) {
+                    cursorMotion.position = { x: hover.x, y: hover.y };
+                }
+                if (animateCursor() < 1 && cursorMotion.from !== cursorMotion.target) {
+                    this.viewer.scene.requestRender();
+                }
+                this.cursorMotion = cursorMotion;
+                const cursorAmount = cursorMotion.amount;
+                leader = normalLeader || cursorAmount > 0;
+                let x = ((_l = transientPivot === null || transientPivot === void 0 ? void 0 : transientPivot.x) !== null && _l !== void 0 ? _l : anchor.x) + pixelOffset.x;
+                let y = ((_m = transientPivot === null || transientPivot === void 0 ? void 0 : transientPivot.y) !== null && _m !== void 0 ? _m : anchor.y) + pixelOffset.y;
+                if (cursorAmount > 0) {
+                    // A leader-less label starts centred on its anchor; preserve that box as it lifts away.
+                    if (!normalLeader) {
+                        x -= ele.offsetWidth / layer.coordinates.scaleX / 2;
+                        y += ele.offsetHeight / layer.coordinates.scaleY / 2;
+                    }
+                    x += (cursorMotion.position.x + pixelOffset.x - x) * cursorAmount;
+                    y += (cursorMotion.position.y + pixelOffset.y - y) * cursorAmount;
+                }
+                const anchorX = x;
+                const anchorY = y;
+                let leaderLength;
+                if (leader) {
+                    if (!normalLeader) {
+                        leaderLength = 0;
+                    }
+                    else if (this.options.leaderLength != null) {
+                        leaderLength = Math.max(0, this.options.leaderLength);
+                    }
+                    else if (transientPivot) {
+                        // Cursor callouts must not jump when the next hover target has a different extent.
+                        leaderLength = 96;
                     }
                     else {
-                        // If known then calculate based on size.
-                        // If we're close then we'll favour the distance over the size.
-                        if (sizeInM && sizeInM > 0) {
-                            addHeight = Math.min(distance / 5, sizeInM * 1.2);
-                        }
-                        // If unknown then calculate based on camera height or distance.
-                        // Radius is unknown for Tileset things. We could bake the radius in possibly as a feature property.
-                        // We have to make it work for both labels against tall skyscrapers, and up-close assembly models.
-                        else {
-                            addHeight = Math.min(distance, this.viewer.camera.positionCartographic.height) / 7;
-                        }
-                    }
-                    // The ratio is roughly 1m = 11px on the screen.
-                    // So if we want to add additional labels then we'll need to adjust the height.
-                    if (additionalTexts === null || additionalTexts === void 0 ? void 0 : additionalTexts.length) {
-                        // Each additional text is about 16px tall.
-                        // So we get the total px height and divide by 11 to get the meters.
-                        addHeight += ((additionalTexts.length * 16) / 11);
-                    }
-                    // Safety check.
-                    if (!addHeight || addHeight <= 0) {
-                        addHeight = 0.001;
-                    }
-                    lineEndPoint.height += addHeight;
-                    lineEndPos3d = Cartographic.toCartesian(lineEndPoint);
-                    const CESIUM = Cesium;
-                    const _3dTo2D = SceneTransforms.hasOwnProperty("wgs84ToWindowCoordinates") ? CESIUM.SceneTransforms.wgs84ToWindowCoordinates : CESIUM.SceneTransforms.worldToWindowCoordinates;
-                    let lineEndPos2d = _3dTo2D(this.viewer.scene, lineEndPos3d);
-                    // Invalid point.
-                    if (isNaN(lineEndPos2d === null || lineEndPos2d === void 0 ? void 0 : lineEndPos2d.x)) {
-                        ele.style.transform = "";
-                        ele.style.opacity = "0";
-                        lineEle.style.display = "none";
-                        return;
+                        const point = Cartographic.fromCartesian(this._pos3d);
+                        const height = (this.prePositioned ? distance / 24 : sizeInM > 0 ?
+                            Math.min(distance / 5, sizeInM * 1.2) : Math.min(distance, camera.positionCartographic.height) / 7);
+                        point.height += Math.max(0.001, height);
+                        const end = projectPosition(this.viewer.scene, Cartographic.toCartesian(point));
+                        // A tall world-space leader can cross the camera plane while its anchor remains visible.
+                        leaderLength = Number.isFinite(end === null || end === void 0 ? void 0 : end.x) && Number.isFinite(end === null || end === void 0 ? void 0 : end.y) ? Math.hypot(end.x - anchor.x, end.y - anchor.y) : 24;
+                        // Scale after projection so large areas and routes get shorter leaders at every zoom.
+                        if (visual instanceof Entity && (visual.polygon || visual.polyline))
+                            leaderLength /= 3;
+                    }
+                    if (cursorAmount > 0) {
+                        leaderLength += (96 - leaderLength) * cursorAmount;
+                    }
+                    y = anchorY - leaderLength;
+                }
+                else if (hover && !reused) {
+                    x = hover.x + pixelOffset.x;
+                    y = hover.y + pixelOffset.y - 24;
+                }
+                // Hidden participants remain measurable; visibility never removes their layout boxes.
+                const coordinates = layer.coordinates;
+                const width = ele.offsetWidth / coordinates.scaleX;
+                const height = ele.offsetHeight / coordinates.scaleY;
+                let clusterBounds;
+                if ((_o = this.options.cluster) === null || _o === void 0 ? void 0 : _o.enabled) {
+                    const textWidth = (sourceText === null || sourceText === void 0 ? void 0 : sourceText.offsetWidth) || 0;
+                    const textHeight = (sourceText === null || sourceText === void 0 ? void 0 : sourceText.offsetHeight) || 0;
+                    const iconWidth = (iconElement === null || iconElement === void 0 ? void 0 : iconElement.offsetWidth) || 0;
+                    const iconHeight = (iconElement === null || iconElement === void 0 ? void 0 : iconElement.offsetHeight) || 0;
+                    const gap = sourceText && iconWidth ? 6 : 0;
+                    const above = presentation === "icon-text-above";
+                    // Match the fixed content gap and label padding, excluding the count badge.
+                    const baseWidth = ((above ? Math.max(textWidth, iconWidth) : textWidth + iconWidth + gap) + 16) / coordinates.scaleX;
+                    const baseHeight = ((above ? textHeight + iconHeight + gap : Math.max(textHeight, iconHeight)) + 12) / coordinates.scaleY;
+                    clusterBounds = {
+                        x: leader ? x : x - baseWidth / 2,
+                        y: leader ? y - baseHeight : y - baseHeight / 2, width: baseWidth, height: baseHeight
+                    };
+                }
+                if (!leader) {
+                    x -= width / 2;
+                    y -= height / 2;
+                }
+                // Membership uses the unclamped source footprint, never the summary's changing dimensions.
+                if (leader)
+                    ({ x, y } = fitLeader(anchorX, anchorY, leaderLength, width, height));
+                const bounds = clusterBounds || { x, y, width, height };
+                if (!leader && (bounds.x + bounds.width < 0 || bounds.y + bounds.height < 0 || bounds.x > this.viewer.canvas.clientWidth || bounds.y > this.viewer.canvas.clientHeight)) {
+                    return null;
+                }
+                const state = (_p = this.visualRegister) === null || _p === void 0 ? void 0 : _p.GetState({ entityId: (_q = this.rego) === null || _q === void 0 ? void 0 : _q.entityId, menuItemId: (_r = this.rego) === null || _r === void 0 ? void 0 : _r.menuItemId });
+                const opacity = this.prePositioned || MAX_DISTANCE === Infinity ? 1 : 1 - distance / MAX_DISTANCE;
+                return {
+                    canFlip: leader && presentation !== "icon", hasLeader: leader,
+                    textWrapped: ((sourceNaturalText === null || sourceNaturalText === void 0 ? void 0 : sourceNaturalText.offsetWidth) || 0) > TEXT_MAX_WIDTH,
+                    transient: this.Transient || Boolean(hover) || cursorAmount > 0,
+                    extendedGeometry: visual instanceof Entity && Boolean(visual.polygon || visual.polyline || visual.corridor),
+                    viewportWidth: this.viewer.canvas.clientWidth,
+                    id: this.id, entityKey: ((_s = this.rego) === null || _s === void 0 ? void 0 : _s.entityId) ? JSON.stringify([this.rego.entityId, this.rego.menuItemId || "", this.Transient && !this.Persistent ? "hover" : ""]) : undefined,
+                    entityId: (_t = this.rego) === null || _t === void 0 ? void 0 : _t.entityId, group: this.groupId, x, y, width, height, anchorX, anchorY, depth, leaderLength, distance,
+                    // Priority shows the hovered member individually without dragging its cluster along.
+                    opacity, priority: hover || cursorAmount > 0 || (state === null || state === void 0 ? void 0 : state.highlighted) ? 1 : 0, options: this.options, text: originalText, clusterBounds
+                };
+            };
+            let displacement = { x: 0, y: 0 };
+            let displayedSummaryMore = false;
+            let nudge = { x: 0, y: 0, fromX: 0, fromY: 0, targetX: 0, targetY: 0, start: 0 };
+            const apply = (placement) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
+                const show = (placement === null || placement === void 0 ? void 0 : placement.visible) && placement.opacity > 0;
+                clickEntityIds = show ? placement.entityIds : [];
+                ele.style.visibility = show ? "visible" : "hidden";
+                lineEle.style.display = show && leader ? "block" : "none";
+                this.anchor.style.display = show && leader ? "block" : "none";
+                if (!show) {
+                    displacement = { x: 0, y: 0 };
+                    nudge = { x: 0, y: 0, fromX: 0, fromY: 0, targetX: 0, targetY: 0, start: 0 };
+                    if (!this.Transient) {
+                        this.ringAnimation = undefined;
                     }
-                    // Offset end by the pixel offset.
-                    lineEndPos2d.x += pixelOffset.x;
-                    lineEndPos2d.y += pixelOffset.y;
-                    // If out of the screen then we can hide it.
-                    const startOutOfScreen = (lineStartPos2d.x < 0 || lineStartPos2d.x > this.viewer.canvas.clientWidth ||
-                        lineStartPos2d.y < 0 || lineStartPos2d.y > this.viewer.canvas.clientHeight);
-                    const endOutOfScreen = (lineEndPos2d.x < 0 || lineEndPos2d.x > this.viewer.canvas.clientWidth ||
-                        lineEndPos2d.y < 0 || lineEndPos2d.y > this.viewer.canvas.clientHeight);
-                    if (startOutOfScreen && endOutOfScreen) {
-                        ele.style.transform = "";
-                        ele.style.opacity = "0";
-                        lineEle.style.display = "none";
-                        return;
+                    return;
+                }
+                const displayText = (_a = placement.text) !== null && _a !== void 0 ? _a : originalText;
+                const summaryMore = Boolean(placement.summaryMore);
+                if (textElement && (textElement.textContent !== displayText + (summaryMore ? "\n…" : "") || displayedSummaryMore !== summaryMore)) {
+                    textElement.textContent = displayText;
+                    if (summaryMore) {
+                        const more = document.createElement("span");
+                        more.className = "entity-label-more";
+                        more.style.opacity = "0.65";
+                        more.textContent = "\n…";
+                        textElement.appendChild(more);
+                    }
+                    displayedSummaryMore = summaryMore;
+                    // Measure the summary's footprint next frame without replacing each member's source text.
+                    this.viewer.scene.requestRender();
+                }
+                const frame = placement.frame;
+                const coordinates = layer.coordinates;
+                const opacity = placement.opacity * this.HoverOpacity();
+                ele.style.opacity = String(opacity);
+                ele.style.zIndex = String(placement.zIndex);
+                ele.dataset.clusterCount = String(placement.members.length || 1);
+                countElement.style.display = placement.members.length ? "block" : "none";
+                countElement.style.order = placement.textSide === "left" ? "-1" : "0";
+                const count = placement.members.length ? String(placement.members.length) : "";
+                if (countElement.textContent !== count) {
+                    countElement.textContent = count;
+                    // The badge participates in layout, so its new width needs another measurement.
+                    this.viewer.scene.requestRender();
+                }
+                if (iconContainer) {
+                    const badgeWidth = countElement.offsetWidth;
+                    const iconWidth = iconElement.offsetWidth;
+                    const narrow = iconWidth < iconElement.offsetHeight * 0.6;
+                    const clearance = badgeWidth ? (narrow ? badgeWidth / 2 + 2 : Math.max(0, badgeWidth / 2 - iconWidth / 4)) : 0;
+                    countElement.style.left = `calc(100% + ${clearance}px)`;
+                    // Reserve the badge overhang so adjacent text and viewport edges remain clear.
+                    iconContainer.style.marginTop = `${countElement.offsetHeight / 2}px`;
+                    iconContainer.style.marginRight = `${badgeWidth / 2 + clearance}px`;
+                }
+                // Summary and badge changes must fit on their first visible frame, including after resize.
+                const ring = this.options.anchorRing;
+                const pointer = (layer.pointer || (cursorMotion.target ? cursorMotion.position : undefined) || (this.Transient && !this.Persistent ?
+                    (this.hoverFade.to === 0 ? this.retainedHoverPosition : (_b = this.visualRegister) === null || _b === void 0 ? void 0 : _b.GetLabelHoverPosition((_c = this.rego) === null || _c === void 0 ? void 0 : _c.entityId, (_d = this.rego) === null || _d === void 0 ? void 0 : _d.menuItemId)) : undefined));
+                const hovered = pointer && Math.hypot(pointer.x - frame.anchorX, pointer.y - frame.anchorY) <= ((_e = ring === null || ring === void 0 ? void 0 : ring.hoverDistance) !== null && _e !== void 0 ? _e : 24);
+                const normalRadius = (!leader || (ring === null || ring === void 0 ? void 0 : ring.enabled) === false ? 0 : Math.max(frame.distance <= ((_f = ring === null || ring === void 0 ? void 0 : ring.nearDistance) !== null && _f !== void 0 ? _f : 100) ? ((_g = ring === null || ring === void 0 ? void 0 : ring.nearRadius) !== null && _g !== void 0 ? _g : 10) : 0, hovered ? ((_h = ring === null || ring === void 0 ? void 0 : ring.hoverRadius) !== null && _h !== void 0 ? _h : (this.Transient && !this.Persistent ? 15.4 : 22)) : 0));
+                const targetRadius = normalRadius + (15.4 - normalRadius) * cursorMotion.amount;
+                const now = Date.now();
+                const duration = (_j = ring === null || ring === void 0 ? void 0 : ring.transitionDuration) !== null && _j !== void 0 ? _j : 200;
+                const sharedRing = this.Transient && !this.Persistent && this.hoverFade.to === 1 ? this.hoverRingState : undefined;
+                let ringAnimation = sharedRing ? sharedRing.animation : this.ringAnimation;
+                if (!ringAnimation) {
+                    ringAnimation = { target: 0, start: now, outer: 2.5, inner: 0, fromOuter: 2.5, fromInner: 0 };
+                }
+                const animateRing = () => {
+                    const progress = duration > 0 ? Math.min(1, Math.max(0, (now - ringAnimation.start) / duration)) : 1;
+                    const eased = progress * progress * (3 - 2 * progress);
+                    ringAnimation.outer = ringAnimation.fromOuter + ((ringAnimation.target || 2.5) - ringAnimation.fromOuter) * eased;
+                    ringAnimation.inner = ringAnimation.fromInner + (Math.max(0, ringAnimation.target - 2) - ringAnimation.fromInner) * eased;
+                    return progress;
+                };
+                animateRing();
+                if (ringAnimation.target !== targetRadius) {
+                    ringAnimation = {
+                        ...ringAnimation,
+                        target: targetRadius,
+                        start: now,
+                        fromOuter: ringAnimation.outer,
+                        fromInner: ringAnimation.inner
+                    };
+                }
+                // Animate the hole and stem together; no CSS transition may lag behind a moving world anchor.
+                if (animateRing() < 1 && (ringAnimation.fromOuter !== (targetRadius || 2.5) || ringAnimation.fromInner !== Math.max(0, targetRadius - 2))) {
+                    this.viewer.scene.requestRender();
+                }
+                this.ringAnimation = ringAnimation;
+                if (sharedRing) {
+                    sharedRing.animation = ringAnimation;
+                }
+                const radius = ringAnimation.inner > 0 ? ringAnimation.outer : 0;
+                const stem = (leader ? fitLeader(frame.anchorX, frame.anchorY, Math.max(frame.leaderLength, radius ? radius + 4 : 0), ele.offsetWidth / coordinates.scaleX, ele.offsetHeight / coordinates.scaleY, radius) : undefined);
+                const position = { x: (stem || frame).x, y: (stem || frame).y };
+                const width = ele.offsetWidth / coordinates.scaleX;
+                const height = ele.offsetHeight / coordinates.scaleY;
+                if (leader && placement.textSide === "left") {
+                    position.x = Math.max(0, Math.min(frame.anchorX - width, this.viewer.canvas.clientWidth - width));
+                }
+                const gap = (_l = (_k = this.options.pointerAvoidance) === null || _k === void 0 ? void 0 : _k.gap) !== null && _l !== void 0 ? _l : 12;
+                const containsPointer = (x, y, margin) => {
+                    return pointer && pointer.x >= x - margin && pointer.x <= x + width + margin && pointer.y >= y - margin && pointer.y <= y + height + margin;
+                };
+                const passive = !selectOnClick || !this.visualRegister;
+                if (passive && ((_m = this.options.pointerAvoidance) === null || _m === void 0 ? void 0 : _m.enabled) !== false && pointer &&
+                    (containsPointer(position.x, position.y, gap) || containsPointer(position.x + displacement.x, position.y + displacement.y, gap))) {
+                    if (containsPointer(position.x + displacement.x, position.y + displacement.y, 0)) {
+                        // Choose against the original box and retain the offset until the pointer leaves both boxes.
+                        const candidates = [
+                            { x: 0, y: pointer.y - gap - height - position.y },
+                            { x: 0, y: pointer.y + gap - position.y },
+                            { x: pointer.x - gap - width - position.x, y: 0 },
+                            { x: pointer.x + gap - position.x, y: 0 }
+                        ].filter(offset => position.x + offset.x >= 0 && position.y + offset.y >= 0 &&
+                            position.x + offset.x + width <= this.viewer.canvas.clientWidth && position.y + offset.y + height <= this.viewer.canvas.clientHeight)
+                            .sort((a, b) => Math.hypot(a.x, a.y) - Math.hypot(b.x, b.y));
+                        displacement = candidates[0] || { x: 0, y: 0 };
                     }
-                    // Position the label above the line end point.
-                    this.label.style.left = `${lineEndPos2d.x}px`;
-                    this.label.style.top = `${lineEndPos2d.y}px`;
-                    // Update line position and size.
-                    const dx = lineEndPos2d.x - lineStartPos2d.x;
-                    const dy = lineEndPos2d.y - lineStartPos2d.y;
-                    const length = Math.sqrt(dx * dx + dy * dy);
-                    const angle = Math.atan2(dy, dx) - Math.PI / 2;
-                    this.line.style.left = `${lineStartPos2d.x}px`;
-                    this.line.style.top = `${lineStartPos2d.y}px`;
-                    this.line.style.height = `${length}px`;
-                    this.line.style.transform = `rotate(${angle}rad)`;
-                    this.line.style.transformOrigin = 'top center';
                 }
                 else {
-                    ele.style.transform = "";
-                    ele.style.opacity = "0";
-                    lineEle.style.display = "none";
+                    displacement = { x: 0, y: 0 };
+                }
+                const nudgeDuration = (_p = (_o = this.options.pointerAvoidance) === null || _o === void 0 ? void 0 : _o.transitionDuration) !== null && _p !== void 0 ? _p : 200;
+                const animateNudge = () => {
+                    const progress = now < nudge.start ? 0 : nudgeDuration > 0 ? Math.min(1, (now - nudge.start) / nudgeDuration) : 1;
+                    const eased = progress * progress * (3 - 2 * progress);
+                    nudge.x = nudge.fromX + (nudge.targetX - nudge.fromX) * eased;
+                    nudge.y = nudge.fromY + (nudge.targetY - nudge.fromY) * eased;
+                    return progress;
+                };
+                animateNudge();
+                if (nudge.targetX !== displacement.x || nudge.targetY !== displacement.y) {
+                    nudge = {
+                        ...nudge,
+                        fromX: nudge.x,
+                        fromY: nudge.y,
+                        targetX: displacement.x,
+                        targetY: displacement.y,
+                        start: now + ((_r = (_q = this.options.pointerAvoidance) === null || _q === void 0 ? void 0 : _q.delay) !== null && _r !== void 0 ? _r : 180)
+                    };
+                }
+                if (animateNudge() < 1 && (nudge.fromX !== nudge.targetX || nudge.fromY !== nudge.targetY)) {
+                    this.viewer.scene.requestRender();
+                }
+                position.x += nudge.x;
+                position.y += nudge.y;
+                ele.style.left = `${coordinates.x + position.x * coordinates.scaleX}px`;
+                ele.style.top = `${coordinates.y + position.y * coordinates.scaleY}px`;
+                const clickTarget = content.querySelector('[role="button"]');
+                if (clickTarget) {
+                    clickTarget.setAttribute("aria-label", placement.members.length ? `Select ${placement.entityIds.length} entities` : `Select ${(_t = (_s = this.options.text) !== null && _s !== void 0 ? _s : text) !== null && _t !== void 0 ? _t : (_u = this.rego) === null || _u === void 0 ? void 0 : _u.entityId}`);
+                }
+                if (leader) {
+                    const nodeRadius = ringAnimation.outer;
+                    const anchor = this.anchor;
+                    anchor.style.left = `${coordinates.x + (frame.anchorX - nodeRadius) * coordinates.scaleX}px`;
+                    anchor.style.top = `${coordinates.y + (frame.anchorY - nodeRadius) * coordinates.scaleY}px`;
+                    anchor.style.width = `${nodeRadius * 2 * coordinates.scaleX}px`;
+                    anchor.style.height = `${nodeRadius * 2 * coordinates.scaleY}px`;
+                    anchor.style.boxSizing = "border-box";
+                    anchor.style.background = "transparent";
+                    const svg = anchor.firstElementChild;
+                    svg.setAttribute("viewBox", `0 0 ${nodeRadius * 2} ${nodeRadius * 2}`);
+                    const circle = svg.firstElementChild;
+                    circle.setAttribute("cx", String(nodeRadius));
+                    circle.setAttribute("cy", String(nodeRadius));
+                    circle.setAttribute("r", String((nodeRadius + ringAnimation.inner) / 2));
+                    circle.setAttribute("stroke", this.options.leaderColor || "rgba(255, 255, 255, 0.8)");
+                    circle.setAttribute("stroke-width", String(nodeRadius - ringAnimation.inner));
+                    anchor.style.boxShadow = radius ? "none" : "0 0 5px rgba(0, 0, 0, 0.3)";
+                    anchor.style.opacity = String(opacity * (normalLeader ? 1 : cursorMotion.amount));
+                    anchor.style.zIndex = String(placement.zIndex);
+                    // The stem starts at the rim, never across the transparent centre, even after passive displacement.
+                    const endX = Math.max(position.x, Math.min(frame.anchorX, position.x + width));
+                    const endY = frame.anchorY < position.y ? position.y : frame.anchorY > position.y + height ? position.y + height : frame.anchorY;
+                    const dx = endX - frame.anchorX, dy = endY - frame.anchorY;
+                    const length = Math.hypot(dx, dy);
+                    const leaderAngle = Math.atan2(dy, dx);
+                    const pointerDx = pointer ? pointer.x - frame.anchorX : 0;
+                    const pointerDy = pointer ? pointer.y - frame.anchorY : 0;
+                    const desiredAngle = Math.hypot(pointerDx, pointerDy) > 0.5 ? Math.atan2(pointerDy, pointerDx) + Math.PI - leaderAngle : 0;
+                    const wrappedAngle = Math.atan2(Math.sin(desiredAngle), Math.cos(desiredAngle));
+                    // Keep the stem inside the 126-degree arc, away from antialiased endpoints.
+                    const arcFraction = 0.35;
+                    const rotationLimit = Math.PI * arcFraction - Math.PI / 30;
+                    const targetOffset = hovered ? Math.max(-rotationLimit, Math.min(rotationLimit, wrappedAngle)) : ((_v = ringAnimation.arcOffset) !== null && _v !== void 0 ? _v : 0);
+                    const targetOpen = cursorMotion.target || (hovered && (ring === null || ring === void 0 ? void 0 : ring.enabled) !== false && targetRadius > 0) ? 1 : 0;
+                    const elapsed = Math.min(32, Math.max(0, now - ((_w = ringAnimation.arcTime) !== null && _w !== void 0 ? _w : now)));
+                    const blend = duration > 0 ? 1 - Math.exp(-elapsed / (duration / 3)) : 1;
+                    const approach = (value, target) => Math.abs(value - target) < 0.001 ? target : value + (target - value) * blend;
+                    ringAnimation.arcOffset = approach((_x = ringAnimation.arcOffset) !== null && _x !== void 0 ? _x : 0, targetOffset);
+                    ringAnimation.arcOpen = approach((_y = ringAnimation.arcOpen) !== null && _y !== void 0 ? _y : 0, targetOpen);
+                    ringAnimation.arcTime = now;
+                    if (ringAnimation.arcOffset !== targetOffset || ringAnimation.arcOpen !== targetOpen) {
+                        this.viewer.scene.requestRender();
+                    }
+                    const circumference = Math.PI * (nodeRadius + ringAnimation.inner);
+                    const filledFraction = 1 - ringAnimation.arcOpen * (1 - arcFraction);
+                    circle.setAttribute("stroke-dasharray", `${circumference * filledFraction} ${circumference * (1 - filledFraction)}`);
+                    circle.setAttribute("transform", `rotate(${(leaderAngle + ringAnimation.arcOffset - Math.PI * filledFraction) * 180 / Math.PI} ${nodeRadius} ${nodeRadius})`);
+                    const cut = Math.min(radius, length);
+                    const startX = frame.anchorX + (length ? dx / length * cut : 0);
+                    const startY = frame.anchorY + (length ? dy / length * cut : 0);
+                    const screenDx = (endX - startX) * coordinates.scaleX;
+                    const screenDy = (endY - startY) * coordinates.scaleY;
+                    lineEle.style.width = `${2 * coordinates.scaleX}px`;
+                    lineEle.style.left = `${coordinates.x + (startX - 1) * coordinates.scaleX}px`;
+                    lineEle.style.top = `${coordinates.y + startY * coordinates.scaleY}px`;
+                    lineEle.style.height = `${Math.hypot(screenDx, screenDy)}px`;
+                    lineEle.style.transform = `rotate(${Math.atan2(screenDy, screenDx) - Math.PI / 2}rad)`;
+                    lineEle.style.boxShadow = radius ? "none" : "0 0 5px rgba(0, 0, 0, 0.3)";
+                    lineEle.style.transformOrigin = "top center";
+                    lineEle.style.opacity = String(opacity * (normalLeader ? 1 : cursorMotion.amount));
+                    lineEle.style.zIndex = String(placement.zIndex);
                 }
             };
-            this.renderRemoval = this.viewer.scene.postUpdate.addEventListener(updateLabel);
-            updateLabel();
+            ele.style.display = "flex";
+            ele.style.visibility = "hidden";
+            this.renderRemoval = layer.Add({ project, apply });
             // If terrain changes then we'll re-call createLabel as the position may have changed.
             let terrTimeout = null;
             this.terrChangedRemoval = this.viewer.scene.terrainProviderChanged.addEventListener(() => {
@@ -5929,6 +7022,9 @@ var EntityLabel;
          * Removes label from the viewer and unsubscribes from events.
          */
         removeLabel() {
+            var _a;
+            (_a = this.anchor) === null || _a === void 0 ? void 0 : _a.remove();
+            this.anchor = null;
             if (this.label &&
                 this.label.parentElement) {
                 this.label.parentElement.removeChild(this.label);
@@ -5954,16 +7050,44 @@ var EntityLabel;
      * If one exists then the action is ignored.
      */
     function Attach(params) {
-        const { rego, viewer, pos3d, visualRegister, api } = params;
-        if (!rego || !viewer || rego[EntityLabel.ATTACH_KEY]) {
+        var _a, _b, _c;
+        const { rego, viewer, pos3d, visualRegister, api, options, groupId } = params;
+        if (!rego || !viewer) {
             return;
         }
+        if (params.persistent == null && visualRegister) {
+            const group = visualRegister.GetLabelGroupFor(rego.entityId, rego.menuItemId);
+            if (group || visualRegister.GetIsLabelled({ entityId: rego.entityId, menuItemId: rego.menuItemId })) {
+                return Attach({
+                    ...params,
+                    pos3d: undefined,
+                    options: (_a = group === null || group === void 0 ? void 0 : group.options) !== null && _a !== void 0 ? _a : options,
+                    groupId: (_b = group === null || group === void 0 ? void 0 : group.groupId) !== null && _b !== void 0 ? _b : groupId,
+                    persistent: true
+                });
+            }
+        }
+        if (rego[EntityLabel.ATTACH_KEY]) {
+            // Legacy hover callers omit ownership/options and must not reconfigure a register-owned label.
+            if (rego[EntityLabel.ATTACH_KEY].Persistent && params.persistent !== true && !groupId) {
+                return rego[EntityLabel.ATTACH_KEY];
+            }
+            rego[EntityLabel.ATTACH_KEY].Persistent = (_c = params.persistent) !== null && _c !== void 0 ? _c : Boolean(groupId);
+            rego[EntityLabel.ATTACH_KEY].Configure(options, groupId);
+            return rego[EntityLabel.ATTACH_KEY];
+        }
         rego[EntityLabel.ATTACH_KEY] = new Label({
             rego,
             viewer,
             pos3d,
             visualRegister,
-            api
+            api,
+            options,
+            groupId,
+            persistent: params.persistent,
+            transient: params.transient,
+            hoverRingState: params.hoverRingState,
+            visible: params.visible
         });
         return rego[EntityLabel.ATTACH_KEY];
     }
@@ -5978,12 +7102,19 @@ var EntityLabel;
         if (!rego && label) {
             rego = label.Rego;
         }
+        if (label && label !== (rego === null || rego === void 0 ? void 0 : rego[EntityLabel.ATTACH_KEY])) {
+            if (!label.Persistent || params.force)
+                label.Dispose();
+            return;
+        }
         if (!rego || !rego[EntityLabel.ATTACH_KEY]) {
             if (label) {
                 (_a = label.Dispose) === null || _a === void 0 ? void 0 : _a.call(label);
             }
             return;
         }
+        if (rego[EntityLabel.ATTACH_KEY].Persistent && !params.force)
+            return;
         (_c = (_b = rego[EntityLabel.ATTACH_KEY]).Dispose) === null || _c === void 0 ? void 0 : _c.call(_b);
         rego[EntityLabel.ATTACH_KEY] = null;
     }
@@ -6003,6 +7134,482 @@ var EntityLabel;
     EntityLabel.GetLabel = GetLabel;
 })(EntityLabel || (EntityLabel = {}));
 
+var EntityLabelGroup;
+(function (EntityLabelGroup) {
+    /*
+     * Keeps the query response useful even when the Entity has no loaded visual yet.
+     */
+    function FromEntity(entity) {
+        var _a, _b, _c, _d;
+        const location = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.Location;
+        const pivot = (_b = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _b === void 0 ? void 0 : _b.GeometryWorldPivot;
+        let cartographic;
+        if ((pivot === null || pivot === void 0 ? void 0 : pivot.length) >= 3 && pivot.every(Number.isFinite)) {
+            cartographic = Cartographic.fromCartesian(Cartesian3.fromArray(pivot));
+        }
+        return {
+            entityId: (_c = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _c === void 0 ? void 0 : _c.ID,
+            text: (_d = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _d === void 0 ? void 0 : _d.Name,
+            longitude: cartographic ? Math$1.toDegrees(cartographic.longitude) : location === null || location === void 0 ? void 0 : location.longitude,
+            latitude: cartographic ? Math$1.toDegrees(cartographic.latitude) : location === null || location === void 0 ? void 0 : location.latitude,
+            altitude: cartographic ? cartographic.height : location === null || location === void 0 ? void 0 : location.altitude,
+            entity
+        };
+    }
+    EntityLabelGroup.FromEntity = FromEntity;
+    /*
+     * Uses the existing DataLab grammar, discarding actions and projections that cannot return Entities.
+     */
+    async function Loader(source, api, signal) {
+        var _a;
+        var _b;
+        if (source.type === "provider") {
+            return (offset, limit, signal) => source.loadPage({ offset, limit, signal });
+        }
+        if (source.type === "entityIds" || source.type === "json") {
+            const items = (source.type === "entityIds" ? source.entityIds.map(entityId => ({ entityId })) :
+                typeof source.items === "string" ? JSON.parse(source.items) : source.items);
+            if (!Array.isArray(items)) {
+                throw new Error("Label JSON must be an array of label items");
+            }
+            return async (offset, limit) => ({ items: items.slice(offset, offset + limit), hasMore: offset + limit < items.length });
+        }
+        if (!api) {
+            throw new Error("DataLab label sources require API getters on the visual register");
+        }
+        let query;
+        if (source.type === "queryId") {
+            const saved = (await DataLab.Get({ api, queryId: source.queryId, req: { noCache: true, abortSignal: signal } })).query;
+            const selection = (_a = saved === null || saved === void 0 ? void 0 : saved.PrimarySelectionCriteria) !== null && _a !== void 0 ? _a : saved === null || saved === void 0 ? void 0 : saved.PrimarySelection;
+            if (!selection) {
+                throw new Error("Saved label query has no selection criteria");
+            }
+            query = { PrimarySelection: selection };
+        }
+        else {
+            query = typeof source.query === "string" ? JSON.parse(source.query) : source.query;
+        }
+        if (!(query === null || query === void 0 ? void 0 : query.PrimarySelection)) {
+            throw new Error("Label query requires PrimarySelection");
+        }
+        query = JSON.parse(JSON.stringify(query));
+        delete query.Action;
+        query.PrimarySelection.Select = { Type: DataLab.ESelectType.Entity };
+        (_b = query.PrimarySelection).OrderBy || (_b.OrderBy = "Bruce/ID");
+        query.Expand = query.Expand ? `${query.Expand},location` : "location";
+        return async (offset, limit, signal) => {
+            const response = await DataLab.Run({ api, query, skip: offset, load: limit, migrated: true, req: { noCache: true, abortSignal: signal } });
+            const entities = response.entities || response.items || [];
+            return {
+                items: entities.map(FromEntity),
+                hasMore: response.totalCount != null ? offset + entities.length < response.totalCount : entities.length === limit
+            };
+        };
+    }
+    EntityLabelGroup.Loader = Loader;
+    /*
+     * Snapshot settings without dropping Calculator's optional runtime function values.
+     */
+    function copyOptions(value) {
+        if (Array.isArray(value)) {
+            return value.map(copyOptions);
+        }
+        if (value && typeof value === "object") {
+            return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, copyOptions(item)]));
+        }
+        return value;
+    }
+    /*
+     * Evaluate source attributes during register refresh, never in the camera-frame layout loop.
+     */
+    function resolveIcon(value, entity) {
+        if (!Array.isArray(value))
+            return value;
+        try {
+            return Calculator.GetString(value, entity || {});
+        }
+        catch {
+            // An invalid expression on one item must not prevent the remaining labels from rendering.
+            return null;
+        }
+    }
+    /*
+     * Owns membership independently of manual labelled states, with atomic replacement and stale-load cancellation.
+     */
+    class Manager {
+        constructor(register, changed = () => { }) {
+            this.register = register;
+            this.changed = changed;
+            this.active = new Map();
+            this.pending = new Map();
+            this.standalone = new Map();
+            this.standaloneItems = new Map();
+            this.members = new Map();
+            this.definitions = new Map();
+            this.visibility = new Map();
+            this.errors = new Map();
+        }
+        notify() {
+            try {
+                this.changed();
+            }
+            catch (error) {
+                console.error("Label group observer failed", error);
+            }
+        }
+        Refresh(id) {
+            const definition = this.definitions.get(id);
+            if (!definition)
+                return Promise.reject(new Error(`Unknown label group: ${id}`));
+            return this.Set({ ...definition, visible: this.visibility.get(id) });
+        }
+        SetVisible(id, visible) {
+            var _a;
+            if (!this.definitions.has(id))
+                return false;
+            if (this.visibility.get(id) === visible)
+                return true;
+            this.visibility.set(id, visible);
+            this.refresh(new Set(((_a = this.active.get(id)) === null || _a === void 0 ? void 0 : _a.items.keys()) || []));
+            this.notify();
+            return true;
+        }
+        async Set(definition) {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            if (!(definition === null || definition === void 0 ? void 0 : definition.id) || !definition.source) {
+                throw new Error("Label group requires id and source");
+            }
+            definition = { ...definition, options: copyOptions(definition.options) };
+            const pageSize = (_a = definition.pageSize) !== null && _a !== void 0 ? _a : 500;
+            const maximum = (_b = definition.maxItems) !== null && _b !== void 0 ? _b : 50000;
+            if (!Number.isInteger(pageSize) || pageSize < 1 || !Number.isInteger(maximum) || maximum < 1) {
+                throw new Error("Label pageSize and maxItems must be positive integers");
+            }
+            ValidateOptions(definition.options);
+            (_c = this.pending.get(definition.id)) === null || _c === void 0 ? void 0 : _c.abort();
+            const controller = new AbortController();
+            this.pending.set(definition.id, controller);
+            this.definitions.set(definition.id, definition);
+            const wasVisible = this.visibility.get(definition.id);
+            this.visibility.set(definition.id, (_e = (_d = definition.visible) !== null && _d !== void 0 ? _d : this.visibility.get(definition.id)) !== null && _e !== void 0 ? _e : true);
+            if (wasVisible != null && wasVisible !== this.visibility.get(definition.id)) {
+                this.refresh(new Set(((_f = this.active.get(definition.id)) === null || _f === void 0 ? void 0 : _f.items.keys()) || []));
+            }
+            this.errors.delete(definition.id);
+            this.notify();
+            const cancelled = () => ({ id: definition.id, entityIds: [], truncated: false, cancelled: true });
+            const items = new Map();
+            let truncated = false;
+            try {
+                const load = await Loader(definition.source, (_g = this.register.ApiGetters) === null || _g === void 0 ? void 0 : _g.GetBruceApi(), controller.signal);
+                let offset = 0;
+                for (let pageNumber = 0;; pageNumber++) {
+                    if (controller.signal.aborted || this.register.Disposed) {
+                        return cancelled();
+                    }
+                    if (pageNumber >= 10000) {
+                        throw new Error("Label source exceeded 10000 pages");
+                    }
+                    const page = await load(offset, Math.min(pageSize, maximum - items.size), controller.signal);
+                    if (controller.signal.aborted || this.register.Disposed)
+                        return cancelled();
+                    if (!Array.isArray(page === null || page === void 0 ? void 0 : page.items)) {
+                        throw new Error("Label source returned an invalid page");
+                    }
+                    for (const item of page.items) {
+                        if (!item || typeof item.entityId !== "string" || !item.entityId) {
+                            throw new Error("Label item requires entityId");
+                        }
+                        if (!items.has(item.entityId) && items.size >= maximum) {
+                            truncated = true;
+                            break;
+                        }
+                        items.set(item.entityId, item);
+                    }
+                    if (!page.hasMore) {
+                        break;
+                    }
+                    if (items.size >= maximum) {
+                        truncated = true;
+                        break;
+                    }
+                    const next = (_h = page.nextOffset) !== null && _h !== void 0 ? _h : offset + page.items.length;
+                    if (!Number.isSafeInteger(next) || next <= offset) {
+                        throw new Error("Label source pagination did not advance");
+                    }
+                    offset = next;
+                }
+                const previous = this.active.get(definition.id);
+                const affected = new Set([...((previous === null || previous === void 0 ? void 0 : previous.items.keys()) || []), ...items.keys()]);
+                this.unindex(definition.id);
+                // Reinsertion makes the most recently committed matching group the presentation owner.
+                this.active.delete(definition.id);
+                this.active.set(definition.id, { definition, items, truncated });
+                for (const id of items.keys()) {
+                    if (!this.members.has(id)) {
+                        this.members.set(id, new Set());
+                    }
+                    this.members.get(id).add(definition.id);
+                }
+                this.refresh(affected);
+                return { id: definition.id, entityIds: Array.from(items.keys()), truncated, cancelled: false };
+            }
+            catch (error) {
+                if (controller.signal.aborted || this.register.Disposed) {
+                    return cancelled();
+                }
+                this.errors.set(definition.id, error instanceof Error ? error.message : String(error));
+                throw error;
+            }
+            finally {
+                if (this.pending.get(definition.id) === controller) {
+                    this.pending.delete(definition.id);
+                    this.notify();
+                }
+            }
+        }
+        Get() {
+            return Array.from(this.definitions.keys(), id => {
+                var _a;
+                const group = this.active.get(id);
+                return {
+                    id,
+                    entityIds: Array.from((group === null || group === void 0 ? void 0 : group.items.keys()) || []),
+                    truncated: (_a = group === null || group === void 0 ? void 0 : group.truncated) !== null && _a !== void 0 ? _a : false,
+                    cancelled: false,
+                    visible: this.visibility.get(id) !== false,
+                    loading: this.pending.has(id),
+                    error: this.errors.get(id)
+                };
+            });
+        }
+        Has(entityId, menuItemId) {
+            for (const id of this.members.get(entityId) || []) {
+                const group = this.active.get(id);
+                if (group && this.visibility.get(id) !== false && (!group.definition.menuItemId || group.definition.menuItemId === menuItemId)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        Resolve(entityId, menuItemId) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+            const ids = Array.from(this.members.get(entityId) || []).reverse();
+            for (const id of ids) {
+                const group = this.active.get(id);
+                if (this.visibility.get(id) === false) {
+                    continue;
+                }
+                if (group.definition.menuItemId && group.definition.menuItemId !== menuItemId) {
+                    continue;
+                }
+                const item = group.items.get(entityId);
+                const entity = (_a = item.entity) !== null && _a !== void 0 ? _a : { Bruce: { ID: entityId, Name: item.text } };
+                let iconPriority = (_b = group.definition.options) === null || _b === void 0 ? void 0 : _b.iconPriority;
+                if (Array.isArray(iconPriority)) {
+                    try {
+                        iconPriority = Calculator.GetNumber(iconPriority, entity);
+                    }
+                    catch {
+                        iconPriority = null;
+                    }
+                }
+                let iconScale = (_c = group.definition.options) === null || _c === void 0 ? void 0 : _c.iconScale;
+                if (Array.isArray(iconScale)) {
+                    try {
+                        iconScale = Calculator.GetNumber(iconScale, entity);
+                    }
+                    catch {
+                        iconScale = null;
+                    }
+                    if (!Number.isFinite(iconScale)) {
+                        iconScale = 1;
+                    }
+                }
+                if (iconScale != null) {
+                    iconScale = Math.max(0, iconScale);
+                }
+                const textSetting = (_d = group.definition.options) === null || _d === void 0 ? void 0 : _d.text;
+                let resolvedText = resolveIcon(textSetting, entity);
+                const expression = Array.isArray(textSetting);
+                if (expression && !(resolvedText === null || resolvedText === void 0 ? void 0 : resolvedText.trim())) {
+                    resolvedText = undefined;
+                }
+                const fallbackText = [item.text, (_e = entity.Bruce) === null || _e === void 0 ? void 0 : _e.Name, (_f = this.register.GetRego({ entityId, menuItemId })) === null || _f === void 0 ? void 0 : _f.name, entityId]
+                    .find(text => typeof text === "string" && text.trim().length > 0);
+                const options = {
+                    ...group.definition.options,
+                    text: resolvedText !== null && resolvedText !== void 0 ? resolvedText : fallbackText,
+                    iconScale: iconScale,
+                    icon: resolveIcon((_g = group.definition.options) === null || _g === void 0 ? void 0 : _g.icon, entity),
+                    iconUrl: resolveIcon((_h = group.definition.options) === null || _h === void 0 ? void 0 : _h.iconUrl, entity),
+                    iconClass: resolveIcon((_j = group.definition.options) === null || _j === void 0 ? void 0 : _j.iconClass, entity),
+                    iconColor: resolveIcon((_k = group.definition.options) === null || _k === void 0 ? void 0 : _k.iconColor, entity),
+                    iconBackground: (_l = group.definition.options) === null || _l === void 0 ? void 0 : _l.iconBackground,
+                    iconPriority: Number.isFinite(iconPriority) ? iconPriority : item.iconPriority,
+                    iconStatus: (_o = resolveIcon((_m = group.definition.options) === null || _m === void 0 ? void 0 : _m.iconStatus, entity)) !== null && _o !== void 0 ? _o : item.iconStatus
+                };
+                if (options.attributes && item.entity && !(expression && resolvedText != null)) {
+                    options.text = [
+                        (_r = (_p = options.text) !== null && _p !== void 0 ? _p : (_q = item.entity.Bruce) === null || _q === void 0 ? void 0 : _q.Name) !== null && _r !== void 0 ? _r : entityId,
+                        ...options.attributes.map(path => Entity$1.GetValue({ entity: item.entity, path })).filter(value => value != null).map(String)
+                    ].join("\n");
+                }
+                return { groupId: id, options, item };
+            }
+            return null;
+        }
+        RefreshEntity(entityId) {
+            var _a, _b, _c, _d, _e, _f, _g;
+            const match = this.Resolve(entityId);
+            const registered = this.register.GetRego({ entityId });
+            if (!registered && match && this.standalone.has(entityId) && this.standaloneItems.get(entityId) === match.item) {
+                this.standalone.get(entityId).Configure({ ...match.options, text: (_b = (_a = match.options.text) !== null && _a !== void 0 ? _a : match.item.text) !== null && _b !== void 0 ? _b : entityId }, match.groupId);
+                return;
+            }
+            (_c = this.standalone.get(entityId)) === null || _c === void 0 ? void 0 : _c.Dispose();
+            this.standalone.delete(entityId);
+            this.standaloneItems.delete(entityId);
+            if (this.register.Disposed || registered) {
+                return;
+            }
+            if (!match) {
+                return;
+            }
+            const item = match.item;
+            if (![item.longitude, item.latitude, (_d = item.altitude) !== null && _d !== void 0 ? _d : 0].every(Number.isFinite) || Math.abs(item.latitude) > 90) {
+                return;
+            }
+            const visual = new Entity({
+                position: Cartesian3.fromDegrees(item.longitude, item.latitude, item.altitude || 0),
+                point: { heightReference: HeightReference.NONE, pixelSize: 0 }
+            });
+            this.standalone.set(entityId, new EntityLabel.Label({
+                viewer: this.register.Viewer,
+                visualRegister: this.register,
+                api: (_e = this.register.ApiGetters) === null || _e === void 0 ? void 0 : _e.GetBruceApi(),
+                rego: { entityId, visual, name: item.text || entityId, priority: 0 },
+                options: { ...match.options, text: (_g = (_f = match.options.text) !== null && _f !== void 0 ? _f : item.text) !== null && _g !== void 0 ? _g : entityId },
+                groupId: match.groupId,
+                visible: () => {
+                    const state = this.register.GetState({ entityId });
+                    return !state.hidden && (!this.register.GetIsIsolatedAny() || state.isolated || this.register.GetIsolationOpacity() != null);
+                }
+            }));
+            this.standaloneItems.set(entityId, item);
+        }
+        Remove(id) {
+            var _a;
+            const known = this.definitions.delete(id);
+            this.visibility.delete(id);
+            this.errors.delete(id);
+            (_a = this.pending.get(id)) === null || _a === void 0 ? void 0 : _a.abort();
+            this.pending.delete(id);
+            const group = this.active.get(id);
+            if (!group) {
+                if (known) {
+                    this.notify();
+                    return;
+                }
+            }
+            this.unindex(id);
+            this.active.delete(id);
+            this.refresh(new Set(group.items.keys()));
+            this.notify();
+        }
+        Clear() {
+            for (const controller of this.pending.values()) {
+                controller.abort();
+            }
+            this.pending.clear();
+            const affected = new Set(this.members.keys());
+            this.active.clear();
+            this.members.clear();
+            this.definitions.clear();
+            this.visibility.clear();
+            this.errors.clear();
+            this.refresh(affected);
+            this.notify();
+        }
+        Dispose() {
+            for (const controller of this.pending.values()) {
+                controller.abort();
+            }
+            for (const label of this.standalone.values()) {
+                label.Dispose();
+            }
+            this.pending.clear();
+            this.standalone.clear();
+            this.standaloneItems.clear();
+            this.active.clear();
+            this.members.clear();
+            this.definitions.clear();
+            this.visibility.clear();
+            this.errors.clear();
+        }
+        unindex(groupId) {
+            var _a;
+            for (const id of ((_a = this.active.get(groupId)) === null || _a === void 0 ? void 0 : _a.items.keys()) || []) {
+                const groups = this.members.get(id);
+                groups === null || groups === void 0 ? void 0 : groups.delete(groupId);
+                if (!(groups === null || groups === void 0 ? void 0 : groups.size)) {
+                    this.members.delete(id);
+                }
+            }
+        }
+        refresh(ids) {
+            var _a;
+            // Creation drains through the register's bounded update queue, including source-only labels.
+            for (const id of ids) {
+                (_a = this.standalone.get(id)) === null || _a === void 0 ? void 0 : _a.Dispose();
+                this.standalone.delete(id);
+                this.standaloneItems.delete(id);
+            }
+            this.register.ForceUpdate({ entityIds: Array.from(ids) });
+            this.register.Viewer.scene.requestRender();
+        }
+    }
+    EntityLabelGroup.Manager = Manager;
+    /*
+     * Rejects invalid geometry settings before they can create unbounded spatial-index work.
+     */
+    function ValidateOptions(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        if (!options) {
+            return;
+        }
+        if (options.iconBackground != null && typeof options.iconBackground !== "boolean") {
+            throw new Error("Label iconBackground must be a boolean");
+        }
+        for (const value of [options.icon, options.iconUrl, options.iconClass, options.iconColor, options.text]) {
+            if (value != null && typeof value !== "string" && !Array.isArray(value)) {
+                throw new Error("Label icons must be strings or Calculator field arrays");
+            }
+        }
+        if (options.iconScale != null && !Array.isArray(options.iconScale) && !Number.isFinite(options.iconScale)) {
+            throw new Error("Label iconScale must be finite or a Calculator field array");
+        }
+        if (options.iconPriority != null && !Array.isArray(options.iconPriority) && !Number.isFinite(options.iconPriority)) {
+            throw new Error("Label iconPriority must be finite or a Calculator field array");
+        }
+        for (const value of [options.iconSize, options.leaderLength, options.near, options.far, (_a = options.cluster) === null || _a === void 0 ? void 0 : _a.pixelRange, (_b = options.pointerAvoidance) === null || _b === void 0 ? void 0 : _b.gap, (_c = options.pointerAvoidance) === null || _c === void 0 ? void 0 : _c.delay, (_d = options.pointerAvoidance) === null || _d === void 0 ? void 0 : _d.transitionDuration, (_e = options.anchorRing) === null || _e === void 0 ? void 0 : _e.nearDistance, (_f = options.anchorRing) === null || _f === void 0 ? void 0 : _f.nearRadius, (_g = options.anchorRing) === null || _g === void 0 ? void 0 : _g.hoverDistance, (_h = options.anchorRing) === null || _h === void 0 ? void 0 : _h.hoverRadius, (_j = options.anchorRing) === null || _j === void 0 ? void 0 : _j.transitionDuration]) {
+            if (value != null && (!Number.isFinite(value) || value < 0)) {
+                throw new Error("Label dimensions and distances must be finite and nonnegative");
+            }
+        }
+        if (((_k = options.near) !== null && _k !== void 0 ? _k : 0) > ((_l = options.far) !== null && _l !== void 0 ? _l : Infinity)) {
+            throw new Error("Label near must not exceed far");
+        }
+        if (options.overlapOpacity != null && (!Number.isFinite(options.overlapOpacity) || options.overlapOpacity < 0 || options.overlapOpacity > 1)) {
+            throw new Error("Label overlapOpacity must be between zero and one");
+        }
+        if (((_m = options.cluster) === null || _m === void 0 ? void 0 : _m.minSize) != null && (!Number.isInteger(options.cluster.minSize) || options.cluster.minSize < 2)) {
+            throw new Error("Label cluster minSize must be an integer of at least two");
+        }
+    }
+    EntityLabelGroup.ValidateOptions = ValidateOptions;
+})(EntityLabelGroup || (EntityLabelGroup = {}));
+
 /**
  * Utility for rendering parabolas between two points on the map.
  */
@@ -7497,7 +9104,7 @@ function updateEntityShow(viewer, rego, show) {
     }
 }
 function updateEntity(viewer, entityId, register, refresh, cache = {}) {
-    var _a;
+    var _a, _b, _c;
     if (!entityId) {
         // What are we doing?
         return;
@@ -7610,20 +9217,25 @@ function updateEntity(viewer, entityId, register, refresh, cache = {}) {
                 }
             }
         }
-        if (state.labelled && visible) {
+        const labelGroup = register.GetLabelGroupFor(rego.entityId, rego.menuItemId);
+        if ((state.labelled || labelGroup) && visible) {
             EntityLabel.Attach({
                 rego,
                 viewer,
-                api: register.ApiGetters.GetBruceApi(),
-                visualRegister: register
+                api: (_b = register.ApiGetters) === null || _b === void 0 ? void 0 : _b.GetBruceApi(),
+                visualRegister: register,
+                options: labelGroup === null || labelGroup === void 0 ? void 0 : labelGroup.options,
+                groupId: labelGroup === null || labelGroup === void 0 ? void 0 : labelGroup.groupId,
+                persistent: true
             });
         }
-        else {
+        else if (!visible || ((_c = EntityLabel.GetLabel({ rego })) === null || _c === void 0 ? void 0 : _c.Persistent)) {
             EntityLabel.Detatch({
-                rego
+                rego, force: true
             });
         }
     }
+    register.RefreshLabelGroupEntity(entityId);
 }
 function markEntity(register, rego, visual, ignoreParent) {
     const vis = visual;
@@ -7738,6 +9350,7 @@ var VisualsRegister;
             }
             return this.onUpdate;
         }
+        get OnLabelGroupsChanged() { return this.labelGroupsChanged; }
         constructor(params) {
             this.id = ObjectUtils.UId();
             this.disposed = false;
@@ -7776,10 +9389,35 @@ var VisualsRegister;
             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;
+            this.labelGroupsChanged = new BruceEvent();
+            this.hoverRingState = {};
+            this.retiringHoverLabels = new Map();
             /*
              * Tilesets in the scene, keyed by the tileset itself.
              */
             this.tilesets = new Map();
+            this.ClearLabelHover = () => {
+                if (!this.labelHover && !this.hoverLabel) {
+                    return;
+                }
+                this.ReleaseHoverLabel();
+                this.labelHover = undefined;
+                clearTimeout(this.hoverRingReset);
+                this.hoverRingReset = setTimeout(() => { this.hoverRingState = {}; }, 400);
+                const doc = this.viewer.container.ownerDocument;
+                doc.removeEventListener("pointermove", this.CheckLabelHoverBounds, true);
+                this.viewer.container.removeEventListener("pointerleave", this.CheckLabelHoverBounds);
+                doc.defaultView.removeEventListener("blur", this.ClearLabelHover);
+                if (!this.viewer.isDestroyed()) {
+                    this.viewer.scene.requestRender();
+                }
+            };
+            this.CheckLabelHoverBounds = (event) => {
+                const bounds = this.viewer.canvas.getBoundingClientRect();
+                if (event.clientX < bounds.left || event.clientX >= bounds.right || event.clientY < bounds.top || event.clientY >= bounds.bottom) {
+                    this.ClearLabelHover();
+                }
+            };
             this.viewer = params.viewer;
             this.apiGetters = params.apiGetters;
             this.cameraCullerDispose = VisualRegisterCuller.Monitor({
@@ -7975,6 +9613,7 @@ var VisualsRegister;
             const BATCH_SIZE = 300;
             if (this.updateQueue.length) {
                 this.updateQueueInterval = setInterval(() => {
+                    var _a;
                     if (this.Disposed || (!this.viewer || !this.viewer.scene || this.viewer.isDestroyed())) {
                         clearInterval(this.updateQueueInterval);
                         this.updateQueueInterval = null;
@@ -7987,6 +9626,8 @@ var VisualsRegister;
                         this.updateQueueIds.delete(entityId);
                         // Check if still registered.
                         if (entityId && (!this.rego[entityId] || !this.rego[entityId].length)) {
+                            (_a = this.labelGroups) === null || _a === void 0 ? void 0 : _a.RefreshEntity(entityId);
+                            delete this.updateQueueSettings[entityId];
                             continue;
                         }
                         updateEntity(this.viewer, entityId, this, this.updateQueueSettings[entityId] == null ? false : this.updateQueueSettings[entityId], cache);
@@ -8644,8 +10285,23 @@ var VisualsRegister;
             markEntity(this, rego, rego.visual, false);
         }
         Dispose() {
-            var _a, _b, _c, _d;
-            (_a = this.cameraCullerDispose) === null || _a === void 0 ? void 0 : _a.call(this, {
+            var _a, _b, _c, _d, _e;
+            this.ClearLabelHover();
+            clearTimeout(this.hoverRingReset);
+            this.hoverRingState = {};
+            for (const { label, timer } of this.retiringHoverLabels.values()) {
+                clearTimeout(timer);
+                EntityLabel.Detatch({ label });
+            }
+            this.retiringHoverLabels.clear();
+            (_a = this.labelGroups) === null || _a === void 0 ? void 0 : _a.Dispose();
+            this.labelGroupsChanged.Clear();
+            for (const regos of Object.values(this.rego)) {
+                for (const rego of regos)
+                    EntityLabel.Detatch({ rego, force: true });
+            }
+            EntityLabel.SetContainer(this.viewer);
+            (_b = this.cameraCullerDispose) === null || _b === void 0 ? void 0 : _b.call(this, {
                 uncull: false
             });
             this.cameraCullerDispose = null;
@@ -8661,7 +10317,7 @@ var VisualsRegister;
             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);
+                    (_d = (_c = this.viewer) === null || _c === void 0 ? void 0 : _c.dataSources) === null || _d === void 0 ? void 0 : _d.remove(record.source, true);
                 }
                 catch (e) {
                     console.error(e);
@@ -8670,7 +10326,7 @@ var VisualsRegister;
             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();
+                (_e = rego.gate) === null || _e === void 0 ? void 0 : _e.Release();
             }
             this.tilesets.clear();
         }
@@ -9622,7 +11278,7 @@ var VisualsRegister;
          * @returns
          */
         RemoveRegos(params) {
-            var _a, _b, _c;
+            var _a, _b, _c, _d, _e;
             let { entityId, menuItemId, doUpdate, relation, retainTagIds, requestRender, doRemove, source, lazy, onComplete } = params;
             if (doUpdate == null || doUpdate === undefined) {
                 doUpdate = true;
@@ -9643,7 +11299,7 @@ var VisualsRegister;
                     }
                 }
                 const removeOne = (entityId) => {
-                    var _a, _b;
+                    var _a, _b, _c;
                     const entityRegos = this.rego[entityId];
                     if (!entityRegos) {
                         return;
@@ -9658,7 +11314,7 @@ var VisualsRegister;
                         return;
                     }
                     EntityLabel.Detatch({
-                        rego
+                        rego, force: true
                     });
                     // Never tear down the graphic the caller is registering: the renderers hand back
                     // the same object when they reuse it, so removing it here destroys what replaces it.
@@ -9683,15 +11339,14 @@ var VisualsRegister;
                         (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(update);
                     }
                     // Only worth refreshing while the Entity is still drawn by something else, since
-                    // losing this rego can change which of the survivors wins. With none left there is
-                    // nothing to restyle, and queueing one per removed Entity is what turns disabling a
-                    // large menu item into minutes of scheduled work.
+                    // losing this rego can change which of the survivors wins.
                     if (doesInclude && ((_b = this.rego[entityId]) === null || _b === void 0 ? void 0 : _b.length)) {
                         this.queueUpdate({
                             entityId: entityId,
                             refresh: false
                         });
                     }
+                    (_c = this.labelGroups) === null || _c === void 0 ? void 0 : _c.RefreshEntity(entityId);
                 };
                 const finish = () => {
                     this.releaseMenuItemCollection(menuItemId);
@@ -9722,7 +11377,7 @@ var VisualsRegister;
                         return;
                     }
                     EntityLabel.Detatch({
-                        rego
+                        rego, force: true
                     });
                     // Never tear down the graphic the caller is registering: the renderers hand back
                     // the same object when they reuse it, so removing it here destroys what replaces it.
@@ -9741,7 +11396,7 @@ var VisualsRegister;
                     if (source !== EUpdateSource.TREE_CASCADE) {
                         (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Trigger(update);
                     }
-                    this.rego[entityId] = entityRegos.filter(r => r.menuItemId !== menuItemId);
+                    this.rego[entityId] = this.rego[entityId].filter(r => r.menuItemId !== menuItemId);
                     this.unindexMenuItemEntityIfAbsent(menuItemId, entityId);
                     if (doUpdate && menuItemId) {
                         this.queueUpdate({
@@ -9750,6 +11405,7 @@ var VisualsRegister;
                         });
                     }
                 }
+                (_c = this.labelGroups) === null || _c === void 0 ? void 0 : _c.RefreshEntity(entityId);
             }
             else if (relation) {
                 const relationKey = RelationRenderEngine.GetRenderGroupId(relation);
@@ -9761,7 +11417,7 @@ var VisualsRegister;
                             continue;
                         }
                         EntityLabel.Detatch({
-                            rego
+                            rego, force: true
                         });
                         removeEntity(this.viewer, rego.visual);
                         rego.visual = null;
@@ -9770,6 +11426,7 @@ var VisualsRegister;
                             delete this.rego[entityId];
                         }
                         this.unindexMenuItemEntityIfAbsent(rego.menuItemId, entityId);
+                        (_d = this.labelGroups) === null || _d === void 0 ? void 0 : _d.RefreshEntity(entityId);
                         const update = {
                             type: EVisualUpdateType.Remove,
                             entityId: rego.entityId,
@@ -9779,7 +11436,7 @@ var VisualsRegister;
                             update.source = source;
                         }
                         if (source !== EUpdateSource.TREE_CASCADE) {
-                            (_c = this.onUpdate) === null || _c === void 0 ? void 0 : _c.Trigger(update);
+                            (_e = this.onUpdate) === null || _e === void 0 ? void 0 : _e.Trigger(update);
                         }
                         if (doUpdate) {
                             this.queueUpdate({
@@ -9798,7 +11455,7 @@ var VisualsRegister;
          * @param params
          */
         RemoveRegosByVisuals(params) {
-            var _a, _b;
+            var _a, _b, _c;
             const { doRemove = true, requestRender = true, source, doUpdate, menuItemId } = params;
             const removedEntityIds = new Set();
             for (const visual of params.visuals) {
@@ -9813,9 +11470,8 @@ var VisualsRegister;
                     continue;
                 }
                 if (rego.visual === visual) {
-                    // The primary graphic for this rego - remove the rego entirely.
                     EntityLabel.Detatch({
-                        rego
+                        rego, force: true
                     });
                     if (doRemove != false) {
                         removeEntity(this.viewer, rego.visual);
@@ -9844,9 +11500,10 @@ var VisualsRegister;
                         });
                     }
                     removedEntityIds.add(entityId);
+                    (_b = this.labelGroups) === null || _b === void 0 ? void 0 : _b.RefreshEntity(entityId);
                 }
                 else {
-                    const siblings = (_b = rego.visual) === null || _b === void 0 ? void 0 : _b["_siblingGraphics"];
+                    const siblings = (_c = rego.visual) === null || _c === void 0 ? void 0 : _c["_siblingGraphics"];
                     if (siblings === null || siblings === void 0 ? void 0 : siblings.length) {
                         if (doRemove != false && siblings.includes(visual)) {
                             removeEntity(this.viewer, visual);
@@ -10113,6 +11770,204 @@ var VisualsRegister;
             }
             return map;
         }
+        ReleaseHoverLabel(immediate = false) {
+            const label = this.hoverLabel;
+            this.hoverLabel = undefined;
+            if (!label || label.Disposed || label.Persistent) {
+                return;
+            }
+            if (immediate) {
+                EntityLabel.Detatch({ label });
+                return;
+            }
+            label.SetHoverVisible(false);
+            const key = JSON.stringify([label.Rego.entityId, label.Rego.menuItemId || ""]);
+            const previous = this.retiringHoverLabels.get(key);
+            if (previous) {
+                clearTimeout(previous.timer);
+                EntityLabel.Detatch({ label: previous.label });
+            }
+            // Retain briefly beyond the fade to bridge debounced same-target hover updates.
+            const timer = setTimeout(() => {
+                this.retiringHoverLabels.delete(key);
+                EntityLabel.Detatch({ label });
+            }, 240);
+            this.retiringHoverLabels.set(key, { label, timer });
+        }
+        /*
+         * Owns temporary positioning separately from persistent label membership and world anchors.
+         */
+        SetLabelHover(params) {
+            var _a, _b;
+            if (this.disposed) {
+                return;
+            }
+            if (!(params === null || params === void 0 ? void 0 : params.entityId)) {
+                this.ClearLabelHover();
+                return;
+            }
+            if (params.position && (!Number.isFinite(params.position.x) || !Number.isFinite(params.position.y) ||
+                params.position.x < 0 || params.position.y < 0 ||
+                params.position.x >= this.viewer.canvas.clientWidth || params.position.y >= this.viewer.canvas.clientHeight)) {
+                this.ClearLabelHover();
+                return;
+            }
+            const changed = ((_a = this.labelHover) === null || _a === void 0 ? void 0 : _a.entityId) !== params.entityId || ((_b = this.labelHover) === null || _b === void 0 ? void 0 : _b.menuItemId) !== params.menuItemId;
+            if (changed) {
+                this.ClearLabelHover();
+            }
+            clearTimeout(this.hoverRingReset);
+            this.labelHover = {
+                entityId: params.entityId,
+                menuItemId: params.menuItemId,
+                position: params.position ? { ...params.position } : undefined,
+                createIfMissing: params.createIfMissing !== false
+            };
+            const doc = this.viewer.container.ownerDocument;
+            doc.addEventListener("pointermove", this.CheckLabelHoverBounds, true);
+            this.viewer.container.addEventListener("pointerleave", this.CheckLabelHoverBounds);
+            doc.defaultView.addEventListener("blur", this.ClearLabelHover);
+            this.SyncLabelHover();
+            this.viewer.scene.requestRender();
+        }
+        GetLabelHoverPosition(entityId, menuItemId) {
+            const hover = this.labelHover;
+            return (hover === null || hover === void 0 ? void 0 : hover.entityId) === entityId && (hover.menuItemId == null || hover.menuItemId === menuItemId) ? hover.position : undefined;
+        }
+        SyncLabelHover() {
+            var _a, _b, _c, _d;
+            const hover = this.labelHover;
+            if (!hover || this.disposed) {
+                return;
+            }
+            if ((_a = this.hoverLabel) === null || _a === void 0 ? void 0 : _a.Disposed) {
+                this.hoverLabel = undefined;
+            }
+            if (!hover.createIfMissing) {
+                this.ReleaseHoverLabel(true);
+                return;
+            }
+            const group = this.GetLabelGroupFor(hover.entityId, hover.menuItemId);
+            let rego = this.GetRego(hover);
+            const key = JSON.stringify([hover.entityId, hover.menuItemId || ""]);
+            const retiring = this.retiringHoverLabels.get(key);
+            if (retiring) {
+                clearTimeout(retiring.timer);
+                this.retiringHoverLabels.delete(key);
+                if (!retiring.label.Disposed) {
+                    this.hoverLabel = retiring.label;
+                }
+            }
+            const existing = rego && EntityLabel.GetLabel({ rego });
+            const state = this.GetState(hover);
+            if ((!rego && !group) || state.hidden || ((_b = rego === null || rego === void 0 ? void 0 : rego.visual) === null || _b === void 0 ? void 0 : _b.show) === false ||
+                (this.GetIsIsolatedAny() && !state.isolated && this.GetIsolationOpacity() == null) ||
+                (existing && existing !== this.hoverLabel && existing.HasText) ||
+                (group && group.options.presentation !== "icon")) {
+                this.ReleaseHoverLabel(true);
+                return;
+            }
+            if (this.hoverLabel && !this.hoverLabel.Disposed) {
+                this.hoverLabel.SetHoverVisible(true);
+                return;
+            }
+            // Query-only icon groups have coordinates but no registered scene visual to attach to.
+            if (!rego && group && [group.item.longitude, group.item.latitude, (_c = group.item.altitude) !== null && _c !== void 0 ? _c : 0].every(Number.isFinite)) {
+                rego = {
+                    entityId: hover.entityId,
+                    menuItemId: hover.menuItemId,
+                    name: group.options.text,
+                    priority: 0,
+                    visual: new Entity({
+                        position: Cartesian3.fromDegrees(group.item.longitude, group.item.latitude, group.item.altitude || 0),
+                        point: {
+                            pixelSize: 0,
+                            heightReference: HeightReference.NONE
+                        }
+                    })
+                };
+            }
+            if (!rego) {
+                return;
+            }
+            const params = {
+                rego,
+                viewer: this.viewer,
+                visualRegister: this,
+                api: (_d = this.ApiGetters) === null || _d === void 0 ? void 0 : _d.GetBruceApi(),
+                persistent: false,
+                transient: true,
+                hoverRingState: this.hoverRingState,
+                options: {
+                    presentation: "text",
+                    text: group === null || group === void 0 ? void 0 : group.options.text,
+                    selectOnClick: false
+                },
+                visible: () => {
+                    var _a, _b;
+                    const current = this.GetState(hover);
+                    return (!this.disposed && !current.hidden && ((_a = rego.visual) === null || _a === void 0 ? void 0 : _a.show) !== false &&
+                        Boolean(this.GetRego(hover) || ((_b = this.labelGroups) === null || _b === void 0 ? void 0 : _b.Has(hover.entityId, hover.menuItemId))) &&
+                        (!this.GetIsIsolatedAny() || current.isolated || this.GetIsolationOpacity() != null));
+                }
+            };
+            this.hoverLabel = existing || group ? new EntityLabel.Label(params) : EntityLabel.Attach(params);
+        }
+        SetLabelContainer(container) {
+            if (this.disposed) {
+                return;
+            }
+            EntityLabel.SetContainer(this.viewer, container);
+        }
+        ClearLabelContainer() {
+            this.SetLabelContainer();
+        }
+        /*
+         * Adds source-driven membership without changing manual labelled state or legacy bookmark snapshots.
+         */
+        SetLabelGroup(group) {
+            if (this.disposed) {
+                return Promise.reject(new Error("Visual register is disposed"));
+            }
+            if (!this.labelGroups) {
+                this.labelGroups = new EntityLabelGroup.Manager(this, () => this.labelGroupsChanged.Trigger(undefined));
+            }
+            return this.labelGroups.Set(group);
+        }
+        RemoveLabelGroup(id) {
+            var _a;
+            (_a = this.labelGroups) === null || _a === void 0 ? void 0 : _a.Remove(id);
+        }
+        RefreshLabelGroup(id) {
+            var _a, _b;
+            if (this.disposed) {
+                return Promise.reject(new Error("Visual register is disposed"));
+            }
+            return (_b = (_a = this.labelGroups) === null || _a === void 0 ? void 0 : _a.Refresh(id)) !== null && _b !== void 0 ? _b : Promise.reject(new Error(`Unknown label group: ${id}`));
+        }
+        SetLabelGroupVisible(id, visible) {
+            var _a, _b;
+            return (_b = (_a = this.labelGroups) === null || _a === void 0 ? void 0 : _a.SetVisible(id, visible)) !== null && _b !== void 0 ? _b : false;
+        }
+        ClearLabelGroups() {
+            var _a;
+            (_a = this.labelGroups) === null || _a === void 0 ? void 0 : _a.Clear();
+        }
+        GetLabelGroups() {
+            var _a;
+            return ((_a = this.labelGroups) === null || _a === void 0 ? void 0 : _a.Get()) || [];
+        }
+        GetLabelGroupFor(entityId, menuItemId) {
+            var _a;
+            return (_a = this.labelGroups) === null || _a === void 0 ? void 0 : _a.Resolve(entityId, menuItemId);
+        }
+        RefreshLabelGroupEntity(entityId) {
+            var _a, _b;
+            (_a = this.labelGroups) === null || _a === void 0 ? void 0 : _a.RefreshEntity(entityId);
+            if (((_b = this.labelHover) === null || _b === void 0 ? void 0 : _b.entityId) === entityId) {
+                this.SyncLabelHover();
+            }
+        }
     }
     VisualsRegister.Register = Register;
 })(VisualsRegister || (VisualsRegister = {}));
@@ -10239,6 +12094,8 @@ function GetValue(viewer, obj) {
 }
 class Point {
     constructor(lon, lat, id) {
+        this.radius = 0;
+        this.minDistance = 0;
         this.lon = lon;
         this.lat = lat;
         this.id = id;
@@ -10256,8 +12113,8 @@ class Circle {
         let xDist = Math.abs(range.x - this.x);
         let yDist = Math.abs(range.y - this.y);
         let r = this.radius;
-        let w = range.width;
-        let h = range.height;
+        let w = range.width / 2;
+        let h = range.height / 2;
         if (xDist > (w + r) || yDist > (h + r)) {
             return false;
         }
@@ -10271,8 +12128,7 @@ class Circle {
     Contains(point) {
         const dx = this.x - point.lon;
         const dy = this.y - point.lat;
-        const distance = Math.sqrt(dx * dx + dy * dy);
-        return distance <= this.radius;
+        return dx * dx + dy * dy <= this.radius * this.radius;
     }
 }
 class Rectangle$1 {
@@ -10309,13 +12165,13 @@ class Quad {
         let y = this.boundary.y;
         let w = this.boundary.w / 2;
         let h = this.boundary.h / 2;
-        let ne = new Rectangle$1(x + w / 2, y - h / 2, w, h);
+        let ne = new Rectangle$1(x + w, y - h, w, h);
         this.northeast = new Quad(ne, this.capacity);
-        let nw = new Rectangle$1(x - w / 2, y - h / 2, w, h);
+        let nw = new Rectangle$1(x - w, y - h, w, h);
         this.northwest = new Quad(nw, this.capacity);
-        let se = new Rectangle$1(x + w / 2, y + h / 2, w, h);
+        let se = new Rectangle$1(x + w, y + h, w, h);
         this.southeast = new Quad(se, this.capacity);
-        let sw = new Rectangle$1(x - w / 2, y + h / 2, w, h);
+        let sw = new Rectangle$1(x - w, y + h, w, h);
         this.southwest = new Quad(sw, this.capacity);
         this.divided = true;
     }
@@ -10323,7 +12179,8 @@ class Quad {
         if (!this.boundary.Contains(point)) {
             return false;
         }
-        if (this.points.length < this.capacity) {
+        // Coincident points must terminate in a bucket rather than subdividing indefinitely.
+        if (this.points.length < this.capacity || this.boundary.w < 1e-10) {
             this.points.push(point);
             return true;
         }
@@ -10553,505 +12410,640 @@ function getClusterImage(params) {
     }
     return null;
 }
-const FORCE_UPDATE_BATCH_SIZE = 1000;
-const FORCE_UPDATE_BATCH_DELAY = 100;
-class PointClustering {
-    constructor(register, menuItemId, settings) {
-        this.minDistance = 5000;
-        this.minTotalCount = 0;
-        this.disposed = false;
-        this.registeredEntityIds = new Set();
-        // Queue to force update entities.
-        this.updateEntityQueue = [];
-        this.register = register;
-        this.viewer = register.Viewer;
-        this.menuItemId = menuItemId;
-        let boundary = new Rectangle$1(0, 0, 360, 180);
-        this.quadTree = new Quad(boundary, 30);
-        this.prevClusteredEntities = new Set();
-        this.currClusteredEntities = new Set();
-        this.clusterEntities = new Map();
-        this.updateQueue = new DelayQueue(() => {
-            this.doUpdate();
-        }, 1000);
-        this.listenCamera();
-        this.listenSelection();
-        if (settings) {
-            if (!isNaN(+settings.minDistance)) {
-                this.minDistance = +settings.minDistance;
-            }
-            if (!isNaN(+settings.minTotalCount)) {
-                this.minTotalCount = +settings.minTotalCount;
-            }
-        }
-    }
-    Update() {
-        this.updateQueue.Call();
+const clusterPickers = new WeakMap();
+/*
+ * One capture listener set per viewer prevents host canvas picking from undoing cluster selection.
+ */
+function getClusterPicker(viewer) {
+    let picker = clusterPickers.get(viewer);
+    if (picker) {
+        return picker;
     }
-    queueForceUpdate(entityIds) {
-        for (let i = 0; i < entityIds.length; i++) {
-            if (this.updateEntityQueue.includes(entityIds[i])) {
-                continue;
+    const canvas = viewer.canvas;
+    picker = {
+        owners: new Set(),
+        targets: new Map(),
+        remove: () => { }
+    };
+    let gesture;
+    let released;
+    const handler = (event) => {
+        if (viewer.isDestroyed())
+            return;
+        const stop = () => { event.preventDefault(); event.stopImmediatePropagation(); };
+        if (event.type === "pointermove") {
+            if (gesture && Math.hypot(event.clientX - gesture.x, event.clientY - gesture.y) > 6) {
+                gesture.moved = true;
             }
-            this.updateEntityQueue.push(entityIds[i]);
+            return;
         }
-        this.runForceUpdateQueue();
-    }
-    runForceUpdateQueue() {
-        if (!this.updateEntityQueue.length) {
+        if (event.type === "pointercancel") {
+            if (gesture) {
+                released = { ...gesture, moved: true };
+                gesture = null;
+                if (released.target) {
+                    stop();
+                }
+            }
             return;
         }
-        if (this.queueInterval) {
+        if (event.button !== 0) {
             return;
         }
-        this.queueInterval = setInterval(() => {
-            if (this.disposed) {
-                clearInterval(this.queueInterval);
-                this.queueInterval = null;
+        if (event.type === "pointerup" || event.type === "mouseup") {
+            // Only consume releases whose press we owned, even if the cursor left the billboard.
+            if (!gesture) {
                 return;
             }
-            const ids = this.updateEntityQueue.splice(0, FORCE_UPDATE_BATCH_SIZE);
-            this.register.ForceUpdate({
-                entityIds: ids
-            });
-            if (!this.updateEntityQueue.length) {
-                clearInterval(this.queueInterval);
-                this.queueInterval = null;
+            gesture.moved || (gesture.moved = Math.hypot(event.clientX - gesture.x, event.clientY - gesture.y) > 6);
+            released = gesture;
+            gesture = null;
+            if (released.target) {
+                stop();
             }
-        }, FORCE_UPDATE_BATCH_DELAY);
-    }
-    /**
-     * Starts listening to camera changes.
-     * This will trigger the clustering update whenever camera is moved.
-     */
-    listenCamera() {
-        const viewer = this.viewer;
-        let lastPos3d;
-        const hasMoved = () => {
-            var _a;
-            const cameraPos = (_a = viewer === null || viewer === void 0 ? void 0 : viewer.camera) === null || _a === void 0 ? void 0 : _a.positionCartographic;
-            if (!cameraPos) {
-                return false;
+            return;
+        }
+        const rect = canvas.getBoundingClientRect();
+        const picked = viewer.scene.pick(new Cartesian2(event.clientX - rect.left, event.clientY - rect.top));
+        const select = picker.targets.get(picked === null || picked === void 0 ? void 0 : picked.id);
+        if (event.type === "pointerdown" || event.type === "mousedown") {
+            released = null;
+            gesture = { target: select ? picked.id : null, x: event.clientX, y: event.clientY, moved: false };
+            if (gesture.target) {
+                stop();
             }
-            const pos3d = Cartographic.toCartesian(cameraPos);
-            if (!lastPos3d) {
-                lastPos3d = pos3d;
-                return false;
+            return;
+        }
+        if (released) {
+            const owned = !!released.target;
+            const invalid = released.moved || released.target !== (picked === null || picked === void 0 ? void 0 : picked.id);
+            released = null;
+            if (!owned) {
+                return;
             }
-            const distance = Cartesian3.distance(pos3d, lastPos3d);
-            lastPos3d = pos3d;
-            // 50 meter movement at least.
-            return distance > 50;
-        };
-        this.listenCameraRemoval = viewer.scene.camera.changed.addEventListener(() => {
-            if (hasMoved()) {
-                this.updateQueue.Call();
+            if (invalid) {
+                stop();
+                return;
             }
-        });
-    }
-    /**
-     * Stops listening to camera changes.
-     */
-    unlistenCamera() {
-        if (this.listenCameraRemoval) {
-            this.listenCameraRemoval();
-            this.listenCameraRemoval = null;
         }
+        if (!select) {
+            return;
+        }
+        stop();
+        if (event.type === "click") {
+            select();
+        }
+    };
+    const types = ["pointerdown", "pointermove", "pointerup", "pointercancel", "mousedown", "mouseup", "click", "dblclick"];
+    if (canvas === null || canvas === void 0 ? void 0 : canvas.addEventListener) {
+        for (const type of types) {
+            canvas.addEventListener(type, handler, true);
+        }
+        picker.remove = () => {
+            for (const type of types) {
+                canvas.removeEventListener(type, handler, true);
+            }
+        };
     }
-    /**
-     * Starts listening to entity selection changes.
-     * Selected entities are not clustered.
-     */
-    listenSelection() {
-        this.listenUpdateRemoval = this.register.OnUpdate.Subscribe((data) => {
-            if (data.type == VisualsRegister.EVisualUpdateType.DeselectAll) {
-                this.updateQueue.Call();
+    clusterPickers.set(viewer, picker);
+    return picker;
+}
+/*
+ * Count tiers are bounded so large clusters do not cover the scene with enormous billboards.
+ */
+function PointClusterSize(count) {
+    return count >= 10000 ? 140 : count >= 1000 ? 120 : count >= 100 ? 90 : count >= 10 ? 80 : 70;
+}
+class PointClustering {
+    constructor(register, menuItemId, settings = {}) {
+        this.register = register;
+        this.menuItemId = menuItemId;
+        this.settings = settings;
+        this.minDistance = 5000;
+        this.minTotalCount = 0;
+        this.currClusteredEntities = new Set();
+        this.clusterEntities = new Map();
+        this.clusterViews = new Map();
+        this.registeredEntityIds = new Set();
+        this.records = new Map();
+        this.disposed = false;
+        this.removals = [];
+        this.selectionQueued = false;
+        this.viewer = register.Viewer;
+        this.settings = settings = settings || {};
+        if (Number.isFinite(+settings.minDistance)) {
+            this.minDistance = Math.max(0, +settings.minDistance);
+        }
+        if (Number.isFinite(+settings.minTotalCount)) {
+            this.minTotalCount = Math.max(0, +settings.minTotalCount);
+        }
+        this.quadTree = new Quad(new Rectangle$1(0, 0, 360, 180), 30);
+        this.updateQueue = new DelayQueue(() => this.doUpdate(), 1000);
+        this.picker = getClusterPicker(this.viewer);
+        this.picker.owners.add(this);
+        this.removals.push(this.viewer.scene.camera.changed.addEventListener(() => this.Update()));
+        this.removals.push(this.viewer.scene.terrainProviderChanged.addEventListener(() => this.Update()));
+        this.removals.push(register.OnUpdate.Subscribe(data => {
+            if (data.type === VisualsRegister.EVisualUpdateType.DeselectAll ||
+                (data.entityId && this.registeredEntityIds.has(data.entityId) && data.selected != null)) {
+                if (!this.selectionQueued) {
+                    this.selectionQueued = true;
+                    Promise.resolve().then(() => {
+                        this.selectionQueued = false;
+                        if (!this.disposed)
+                            this.refreshSelection();
+                    });
+                }
             }
-            else if (data.entityId &&
-                data.selected != null &&
-                data.type == VisualsRegister.EVisualUpdateType.Update &&
-                this.registeredEntityIds.has(data.entityId)) {
-                this.updateQueue.Call();
+            if ("isolated" in data || (data.entityId && this.registeredEntityIds.has(data.entityId) && "hidden" in data)) {
+                this.Update();
             }
-        });
+        }));
     }
-    unlistenSelection() {
-        if (this.listenUpdateRemoval) {
-            this.listenUpdateRemoval();
-            this.listenUpdateRemoval = null;
+    Update() {
+        if (!this.disposed) {
+            this.updateQueue.Call();
         }
     }
-    /**
-     * Removes all clusters and updates entities to no longer be suppressed.
-     * @returns
-     */
+    GetClusters() {
+        return Array.from(this.clusterViews.values(), view => ({ ...view, entityIds: [...view.entityIds] }));
+    }
     Dispose() {
         if (this.disposed) {
             return;
         }
-        for (let [, entity] of Array.from(this.clusterEntities)) {
-            this.viewer.entities.remove(entity);
-        }
-        this.clusterEntities.clear();
-        this.unlistenCamera();
-        this.unlistenSelection();
         this.disposed = true;
-        this.updateEntityQueue = [];
-        // Restore entities.
-        const toUpdateIds = [];
-        for (let id of Array.from(this.registeredEntityIds)) {
-            const rego = this.register.GetRego({
-                entityId: id,
-                menuItemId: this.menuItemId
-            });
-            if (rego && rego.overrideShow) {
+        this.updateQueue.Dispose();
+        for (const remove of this.removals) {
+            remove();
+        }
+        for (const id of this.clusterEntities.keys()) {
+            this.removeClusterEntity(id);
+        }
+        this.picker.owners.delete(this);
+        if (!this.picker.owners.size) {
+            this.picker.remove();
+            clusterPickers.delete(this.viewer);
+        }
+        const restore = [];
+        for (const id of this.registeredEntityIds) {
+            const rego = this.register.GetRego({ entityId: id, menuItemId: this.menuItemId });
+            if ((rego === null || rego === void 0 ? void 0 : rego.overrideShow) === false) {
                 rego.overrideShow = null;
-                toUpdateIds.push(id);
+                restore.push(id);
             }
         }
-        if (toUpdateIds.length) {
-            this.register.ForceUpdate({
-                entityIds: toUpdateIds,
-            });
+        this.records.clear();
+        this.registeredEntityIds.clear();
+        this.currClusteredEntities.clear();
+        if (restore.length) {
+            this.register.ForceUpdate({ entityIds: restore });
         }
     }
-    /**
-     * Calculates center of given points.
-     * @param points
-     * @returns
-     */
-    calculateCentroid(points) {
-        let lonSum = 0;
-        let latSum = 0;
-        for (let point of points) {
-            lonSum += point.lon;
-            latSum += point.lat;
+    refreshSelection() {
+        for (const view of this.clusterViews.values()) {
+            const selected = view.entityIds.length > 0 && view.entityIds.every(entityId => this.register.GetIsSelected({ entityId, menuItemId: this.menuItemId }));
+            if (selected === view.selected)
+                continue;
+            view.selected = selected;
+            if (selected)
+                CesiumEntityStyler.Select({ viewer: this.viewer, entity: view.entity, requestRender: false });
+            else
+                CesiumEntityStyler.Deselect({ viewer: this.viewer, entity: view.entity, requestRender: false });
         }
-        const lonAvg = lonSum / points.length;
-        const latAvg = latSum / points.length;
-        return new Point(lonAvg, latAvg, "");
+        this.viewer.scene.requestRender();
     }
-    /**
-     * Gathers current clusters and renders them.
-     * @returns
-     */
-    doUpdate() {
-        if (this.disposed) {
+    selectCluster(clusterId) {
+        const view = this.clusterViews.get(clusterId);
+        if (this.disposed || !view)
             return;
+        this.register.ClearSelected({ requestRender: false });
+        this.register.SetSelected({ entityIds: view.entityIds, selected: true });
+        this.refreshSelection();
+    }
+    resolveGeometry(visual, seen = new Set()) {
+        var _a, _b, _c;
+        if (!visual || seen.has(visual)) {
+            return null;
         }
-        // 1: Update precision.
-        // This defines how far apart these clusters can be.
-        const cameraHeight = this.viewer.camera.positionCartographic.height;
-        this.getClusterSpacing(cameraHeight);
-        // 2: Get clusters.
-        const { clusters, noLongerClustered } = this.getClusters();
-        const entitiesToUpdate = [];
-        // 3: Remove all cesium cluster entities that are no longer clustered.
-        for (let id of Array.from(noLongerClustered)) {
-            this.removeClusterEntity(id);
+        seen.add(visual);
+        const value = (property) => GetValue(this.viewer, property);
+        const valid = (p) => p && [p.x, p.y, p.z].every(Number.isFinite) && Cartesian3.magnitudeSquared(p) > 0;
+        const kind = visual.model || visual.box || visual.cylinder || visual.ellipsoid ? "model" :
+            visual.polygon || visual.rectangle || visual.ellipse ? "polygon" :
+                visual.polyline || visual.corridor || visual.wall || visual.polylineVolume ? "polyline" :
+                    visual.point || visual.billboard || visual.label ? "point" : "other";
+        const configured = (_a = this.settings.minDistanceByType) === null || _a === void 0 ? void 0 : _a[kind];
+        let minDistance = Number.isFinite(configured) ? Math.max(0, configured) : this.minDistance * (kind === "point" || kind === "other" ? 1 : 2);
+        const graphic = (visual.model || visual.polygon || visual.rectangle || visual.ellipse || visual.polyline ||
+            visual.corridor || visual.wall || visual.polylineVolume || visual.billboard || visual.point || visual.label || visual.box || visual.cylinder || visual.ellipsoid);
+        let heightRef = (_b = value(graphic === null || graphic === void 0 ? void 0 : graphic.heightReference)) !== null && _b !== void 0 ? _b : HeightReference.NONE;
+        if (visual.polyline) {
+            heightRef = value(visual.polyline.clampToGround) ? HeightReference.CLAMP_TO_GROUND : HeightReference.NONE;
+        }
+        let positions;
+        let height;
+        if (visual.polygon) {
+            const hierarchy = value(visual.polygon.hierarchy);
+            positions = hierarchy === null || hierarchy === void 0 ? void 0 : hierarchy.positions;
+            if (!value(visual.polygon.perPositionHeight)) {
+                height = value(visual.polygon.height);
+                if (height == null && value(visual.polygon.extrudedHeight) == null) {
+                    heightRef = HeightReference.CLAMP_TO_GROUND;
+                }
+                height !== null && height !== void 0 ? height : (height = 0);
+            }
+        }
+        else if (visual.rectangle) {
+            const rectangle = value(visual.rectangle.coordinates);
+            if (rectangle) {
+                positions = [Rectangle.northwest(rectangle), Rectangle.northeast(rectangle),
+                    Rectangle.southwest(rectangle), Rectangle.southeast(rectangle)].map(c => Cartographic.toCartesian(c));
+            }
+            height = value(visual.rectangle.height);
+            if (height == null && value(visual.rectangle.extrudedHeight) == null) {
+                heightRef = HeightReference.CLAMP_TO_GROUND;
+            }
+            height !== null && height !== void 0 ? height : (height = 0);
+        }
+        else if (visual.polyline || visual.corridor || visual.wall || visual.polylineVolume) {
+            positions = value(graphic.positions);
+            if (visual.wall && positions) {
+                const minimum = value(visual.wall.minimumHeights);
+                const maximum = value(visual.wall.maximumHeights);
+                positions = positions.flatMap((position, index) => {
+                    var _a, _b;
+                    if (!valid(position)) {
+                        return [];
+                    }
+                    const carto = Cartographic.fromCartesian(position);
+                    if (!carto) {
+                        return [];
+                    }
+                    return ([(_a = minimum === null || minimum === void 0 ? void 0 : minimum[index]) !== null && _a !== void 0 ? _a : 0, (_b = maximum === null || maximum === void 0 ? void 0 : maximum[index]) !== null && _b !== void 0 ? _b : carto.height]
+                        .filter(Number.isFinite).map(height => Cartesian3.fromRadians(carto.longitude, carto.latitude, height)));
+                });
+            }
         }
-        // 4: Stop hiding entities that are no longer clustered.
-        const previousEntityIds = new Set(this.registeredEntityIds);
-        for (let id of Array.from(previousEntityIds)) {
-            if (!this.currClusteredEntities.has(id)) {
-                const rego = this.register.GetRego({
-                    entityId: id,
-                    menuItemId: this.menuItemId
+        if (visual.corridor || visual.ellipse) {
+            height = value(graphic.height);
+            if (height == null && value(graphic.extrudedHeight) == null)
+                heightRef = HeightReference.CLAMP_TO_GROUND;
+            height !== null && height !== void 0 ? height : (height = 0);
+        }
+        if (!(positions === null || positions === void 0 ? void 0 : positions.length)) {
+            const position = value(visual.position);
+            if (valid(position)) {
+                positions = [position];
+            }
+        }
+        const children = visual._siblingGraphics || [];
+        // Container entities often copy their first child's position; don't count that anchor twice.
+        if (!graphic && children.length) {
+            positions = [];
+            minDistance = 0;
+        }
+        const resolved = [];
+        for (const position of positions || []) {
+            if (!valid(position))
+                continue;
+            let source = position;
+            if (height != null) {
+                const carto = Cartographic.fromCartesian(position);
+                if (!carto)
+                    continue;
+                source = Cartesian3.fromRadians(carto.longitude, carto.latitude, height);
+            }
+            const actual = DrawingUtils.EnsurePosHeight({
+                viewer: this.viewer,
+                pos3d: source,
+                desiredHeightRef: HeightReference.NONE,
+                heightRef
+            });
+            if (valid(actual)) {
+                resolved.push(actual);
+            }
+        }
+        const extrudedHeight = value(graphic === null || graphic === void 0 ? void 0 : graphic.extrudedHeight);
+        if (Number.isFinite(extrudedHeight)) {
+            const reference = (_c = value(graphic.extrudedHeightReference)) !== null && _c !== void 0 ? _c : HeightReference.NONE;
+            for (const position of positions || []) {
+                if (!valid(position)) {
+                    continue;
+                }
+                const carto = Cartographic.fromCartesian(position);
+                if (!carto) {
+                    continue;
+                }
+                const actual = DrawingUtils.EnsurePosHeight({
+                    viewer: this.viewer,
+                    pos3d: Cartesian3.fromRadians(carto.longitude, carto.latitude, extrudedHeight),
+                    desiredHeightRef: HeightReference.NONE, heightRef: reference
                 });
-                if (rego && rego.overrideShow != null) {
-                    rego.overrideShow = null;
-                    entitiesToUpdate.push(id);
+                if (valid(actual)) {
+                    resolved.push(actual);
                 }
             }
         }
-        const getScale = (count) => {
-            // const MIN_SCALE = 15;
-            // const MAX_SCALE = 80;
-            // const SCALE_PER_POINT = 1.01;
-            // let scale = MIN_SCALE + (count * SCALE_PER_POINT);
-            // scale = Math.min(scale, MAX_SCALE);
-            // return scale;
-            if (count >= 10000) {
-                return 140;
+        const spheres = [];
+        const anchors = [];
+        if (resolved.length) {
+            const sphere = BoundingSphere.fromPoints(resolved);
+            // A chord midpoint can lie underground. Preserve the average rendered vertex altitude.
+            const center = Cartographic.fromCartesian(sphere.center);
+            if (center) {
+                const altitude = resolved.reduce((sum, p) => sum + Cartographic.fromCartesian(p).height, 0) / resolved.length;
+                const position = Cartesian3.fromRadians(center.longitude, center.latitude, altitude);
+                sphere.radius += Cartesian3.distance(position, sphere.center);
+                sphere.center = position;
+            }
+            if (visual.ellipse) {
+                sphere.radius = Math.max(sphere.radius, value(visual.ellipse.semiMajorAxis) || 0, value(visual.ellipse.semiMinorAxis) || 0);
+            }
+            if (visual.box) {
+                sphere.radius = Math.max(sphere.radius, Cartesian3.magnitude(value(visual.box.dimensions) || Cartesian3.ZERO) / 2);
             }
-            if (count >= 1000) {
-                return 120;
+            if (visual.ellipsoid) {
+                sphere.radius = Math.max(sphere.radius, Cartesian3.maximumComponent(value(visual.ellipsoid.radii) || Cartesian3.ZERO));
             }
-            if (count >= 100) {
-                return 90;
+            if (visual.cylinder) {
+                sphere.radius = Math.max(sphere.radius, Math.hypot((value(visual.cylinder.length) || 0) / 2, Math.max(value(visual.cylinder.topRadius) || 0, value(visual.cylinder.bottomRadius) || 0)));
             }
-            if (count >= 10) {
-                return 80;
+            if (visual.corridor) {
+                sphere.radius += (value(visual.corridor.width) || 0) / 2;
             }
-            return 70;
+            if (visual.polylineVolume) {
+                const shape = value(visual.polylineVolume.shape) || [];
+                sphere.radius += shape.reduce((radius, p) => Math.max(radius, Math.hypot(p.x, p.y)), 0);
+            }
+            spheres.push(sphere);
+            anchors.push(sphere.center);
+        }
+        for (const child of children) {
+            const result = this.resolveGeometry(child, seen);
+            if (!result) {
+                continue;
+            }
+            spheres.push(new BoundingSphere(result.position, result.radius));
+            anchors.push(result.position);
+            minDistance = Math.max(minDistance, result.minDistance);
+        }
+        if (!spheres.length) {
+            return null;
+        }
+        const sphere = spheres.length === 1 ? spheres[0] : BoundingSphere.fromBoundingSpheres(spheres);
+        if (!valid(sphere.center) || !Number.isFinite(sphere.radius)) {
+            return null;
+        }
+        if (spheres.length > 1) {
+            const carto = Cartographic.fromCartesian(sphere.center);
+            if (!carto) {
+                return null;
+            }
+            const height = anchors.reduce((sum, p) => sum + Cartographic.fromCartesian(p).height, 0) / anchors.length;
+            const position = Cartesian3.fromRadians(carto.longitude, carto.latitude, height);
+            sphere.radius += Cartesian3.distance(position, sphere.center);
+            sphere.center = position;
+        }
+        return { position: sphere.center, radius: sphere.radius, minDistance };
+    }
+    appearance(id) {
+        var _a, _b, _c, _d, _e, _f;
+        const { visual, metadata } = this.records.get(id);
+        const data = metadata.entity || { Bruce: { ID: id } };
+        let priority;
+        let status;
+        try {
+            priority = Array.isArray(this.settings.iconPriority) ? Calculator.GetNumber(this.settings.iconPriority, data) : this.settings.iconPriority;
+            status = Array.isArray(this.settings.iconStatus) ? Calculator.GetString(this.settings.iconStatus, data) : this.settings.iconStatus;
+        }
+        catch {
+            priority = undefined;
+            status = undefined;
+        }
+        const rawImage = GetValue(this.viewer, (_a = visual.billboard) === null || _a === void 0 ? void 0 : _a.image);
+        const imageKey = (_b = visual.billboard) === null || _b === void 0 ? void 0 : _b._billboardImgKey;
+        const iconUrl = (_c = metadata.iconUrl) !== null && _c !== void 0 ? _c : (typeof rawImage === "string" ? rawImage : undefined);
+        // Original URLs retain status tokens after the point renderer converts an image into a data URI.
+        const inferenceUrl = (_e = (_d = metadata.iconUrl) !== null && _d !== void 0 ? _d : imageKey) !== null && _e !== void 0 ? _e : iconUrl;
+        const colorGraphic = visual.point || visual.polygon || visual.polyline || visual.corridor || visual.ellipse || visual.model;
+        const color = colorGraphic ? CesiumEntityStyler.GetDefaultColor(this.viewer, colorGraphic) : null;
+        let colorStatus;
+        if (color && color.alpha > 0 && color.red > 0.5 && color.blue < 0.4) {
+            colorStatus = color.green > 0.4 ? "warning" : "red";
+        }
+        const bgColor = color === null || color === void 0 ? void 0 : color.toCssColorString();
+        return {
+            priority: GetClusterIconPriority({
+                iconPriority: Number.isFinite(priority) ? priority : metadata.iconPriority,
+                iconStatus: (_f = status !== null && status !== void 0 ? status : metadata.iconStatus) !== null && _f !== void 0 ? _f : colorStatus, icon: metadata.icon, iconUrl: inferenceUrl
+            }),
+            iconUrl, bgColor,
+            txtColor: color && color.red * 0.299 + color.green * 0.587 + color.blue * 0.114 > 0.5 ? "black" : "white"
         };
-        /**
-         * Generate circle with label in center.
-         * @param count
-         * @returns
-         */
-        const getCanvas = (count) => {
+    }
+    doUpdate() {
+        var _a;
+        if (this.disposed) {
+            return;
+        }
+        const previous = new Set(this.currClusteredEntities);
+        const { clusters } = this.getClusters();
+        const live = new Set(clusters.map(cluster => cluster.center.id));
+        for (const id of this.clusterEntities.keys()) {
+            if (!live.has(id)) {
+                this.removeClusterEntity(id);
+            }
+        }
+        const changed = new Set();
+        for (const id of new Set([...previous, ...this.registeredEntityIds])) {
+            if (this.currClusteredEntities.has(id)) {
+                continue;
+            }
+            const rego = this.register.GetRego({ entityId: id, menuItemId: this.menuItemId });
+            if ((rego === null || rego === void 0 ? void 0 : rego.overrideShow) === false) {
+                rego.overrideShow = null;
+                changed.add(id);
+            }
+        }
+        for (const cluster of clusters) {
+            const clusterId = cluster.center.id;
+            let representative = cluster.center;
+            let appearance = this.appearance(representative.id);
+            if (this.settings.representative !== "nearest") {
+                for (const point of cluster.points) {
+                    const candidate = this.appearance(point.id);
+                    const distance = Cartesian3.distanceSquared(point.position, this.viewer.camera.positionWC || this.viewer.camera.position);
+                    const representativeDistance = Cartesian3.distanceSquared(representative.position, this.viewer.camera.positionWC || this.viewer.camera.position);
+                    if (candidate.priority > appearance.priority || (candidate.priority === appearance.priority &&
+                        (distance < representativeDistance || (distance === representativeDistance &&
+                            point.id.localeCompare(representative.id) < 0)))) {
+                        representative = point;
+                        appearance = candidate;
+                    }
+                }
+            }
+            const position = new Cartesian3();
+            for (const point of cluster.points) {
+                Cartesian3.add(position, point.position, position);
+            }
+            Cartesian3.divideByScalar(position, cluster.points.length, position);
+            const count = cluster.points.length;
             const params = {
-                size: getScale(count),
-                txtColor: this.pointColorTxt,
-                bgColor: this.pointColorBg,
+                size: PointClusterSize(count),
                 text: String(count),
-                iconUrl: this.iconUrl
+                iconUrl: appearance.iconUrl,
+                bgColor: appearance.bgColor,
+                txtColor: appearance.txtColor
             };
-            return getClusterImage(params);
-        };
-        // 5: iterate over clusters and add/update them as Cesium entities.
-        for (let cluster of clusters) {
-            const clusterId = cluster.center.id;
-            let clusterEntity = this.clusterEntities.get(clusterId);
-            const centroid = this.calculateCentroid(cluster.points);
-            const count = cluster.points.length;
-            if (clusterEntity) {
-                clusterEntity.position = new ConstantPositionProperty(Cartesian3.fromDegrees(centroid.lon, centroid.lat, 150));
-                clusterEntity.billboard.image = new CallbackProperty(() => {
-                    return getCanvas(count);
-                }, false),
-                    clusterEntity.billboard.width = new ConstantProperty(getScale(cluster.points.length));
-                clusterEntity.billboard.height = new ConstantProperty(getScale(cluster.points.length));
-            }
-            else {
-                clusterEntity = this.viewer.entities.add({
-                    position: Cartesian3.fromDegrees(centroid.lon, centroid.lat, 150),
+            const image = new CallbackProperty(() => getClusterImage(params), false);
+            let entity = this.clusterEntities.get(clusterId);
+            if (!entity) {
+                entity = this.viewer.entities.add({
+                    position,
                     billboard: {
+                        image,
+                        color: Color.WHITE,
+                        width: params.size,
+                        height: params.size,
                         heightReference: HeightReference.NONE,
-                        image: new CallbackProperty(() => {
-                            return getCanvas(count);
-                        }, false),
-                        width: getScale(count),
-                        height: getScale(count),
                         verticalOrigin: VerticalOrigin.CENTER,
                         horizontalOrigin: HorizontalOrigin.CENTER,
-                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
-                        scaleByDistance: new NearFarScalar(1.5e2, 0.5, 3.0e7, 0.1),
+                        disableDepthTestDistance: Infinity,
+                        scaleByDistance: new NearFarScalar(1.5e2, 0.5, 3.0e7, 0.1)
                     }
                 });
-                this.clusterEntities.set(clusterId, clusterEntity);
+                this.clusterEntities.set(clusterId, entity);
+                if (this.settings.selectOnClick !== false)
+                    this.picker.targets.set(entity, () => this.selectCluster(clusterId));
             }
-            for (let i = 0; i < cluster.points.length; i++) {
-                const entityId = cluster.points[i].id;
+            else {
+                entity.position = new ConstantPositionProperty(position);
+                entity.billboard.image = image;
+                entity.billboard.width = new ConstantProperty(params.size);
+                entity.billboard.height = new ConstantProperty(params.size);
+            }
+            const old = this.clusterViews.get(clusterId);
+            this.clusterViews.set(clusterId, {
+                entity,
+                entityIds: cluster.points.map(point => point.id),
+                representativeId: representative.id,
+                selected: (_a = old === null || old === void 0 ? void 0 : old.selected) !== null && _a !== void 0 ? _a : false
+            });
+            _loadClusterImage(params).then(() => {
+                if (!this.disposed && !this.viewer.isDestroyed()) {
+                    this.viewer.scene.requestRender();
+                }
+            });
+            for (const point of cluster.points) {
                 const rego = this.register.GetRego({
-                    entityId: entityId,
+                    entityId: point.id,
                     menuItemId: this.menuItemId
                 });
-                if (rego && rego.overrideShow != false) {
+                if (rego && rego.overrideShow !== false) {
                     rego.overrideShow = false;
-                    entitiesToUpdate.push(entityId);
+                    changed.add(point.id);
                 }
             }
         }
-        this.queueForceUpdate(entitiesToUpdate);
-        // 6: Iterate over existing cluster entities and remove those that are no longer clustered.
-        for (let [clusterId, clusterEntity] of Array.from(this.clusterEntities)) {
-            if (!clusters.find(x => x.center.id == clusterId)) {
-                this.viewer.entities.remove(clusterEntity);
-                this.clusterEntities.delete(clusterId);
-            }
+        if (changed.size) {
+            this.register.ForceUpdate({ entityIds: Array.from(changed) });
         }
-        this.viewer.scene.requestRender();
+        this.refreshSelection();
     }
-    getClusterSpacing(distanceFromCluster) {
-        // Distance thresholds in meters from the cluster.
-        const distanceThresholds = [3000, 4000, 5300, 6000, 7000];
-        // Distance increments in degrees.
-        const distanceIncrements = [0.001, 0.002, 0.01, 0.03, 0.09];
-        let index = 0;
-        if (distanceFromCluster) {
-            for (let i = 0; i < distanceThresholds.length; i++) {
-                if (distanceFromCluster > distanceThresholds[i]) {
-                    index = i;
-                }
-            }
-        }
-        return distanceIncrements[index];
+    getClusterSpacing(distance) {
+        return distance > 7000 ? 0.09 : distance > 6000 ? 0.03 : distance > 5300 ? 0.01 : distance > 4000 ? 0.002 : 0.001;
     }
     getClusters() {
+        const previous = new Set(this.currClusteredEntities);
         this.currClusteredEntities.clear();
-        let clusters = [];
-        let processedPoints = new Set();
-        const cameraPosition = this.viewer.camera.position;
-        // We won't cluster selected entities.
-        const selectedIds = this.register.GetSelected();
-        // Only cluster if total registered points exceeds minTotalCount.
-        let validClusters = [];
-        if (this.registeredEntityIds.size >= this.minTotalCount) {
-            const MIN_CAMERA_DISTANCE = this.minDistance;
-            const processQuad = (quad) => {
-                // Distance to quad.
-                // TODO: Needs improvement.
-                const distanceToQuad = quad.GetDistanceToQuad(cameraPosition);
-                // Skip quads that are too close.
-                if (distanceToQuad >= MIN_CAMERA_DISTANCE) {
-                    for (let point of quad.points) {
-                        // Skip points already processed in previous clusters.
-                        if (selectedIds.includes(point.id) || processedPoints.has(point.id)) {
-                            continue;
-                        }
-                        // Skip points closer than MIN_CAMERA_DISTANCE meters to the camera.
-                        const cartesian3 = Cartesian3.fromDegrees(point.lon, point.lat);
-                        const distanceFromCluster = Cartesian3.distance(cartesian3, cameraPosition);
-                        if (distanceFromCluster <= MIN_CAMERA_DISTANCE) {
-                            continue;
-                        }
-                        let found = [];
-                        let nearbyPoints = quad.Query(new Circle(point.lon, point.lat, this.getClusterSpacing(distanceFromCluster)), found);
-                        nearbyPoints = nearbyPoints.filter(x => !processedPoints.has(x.id) && !selectedIds.includes(x.id));
-                        if (nearbyPoints.length > 1) {
-                            let cluster = { center: point, points: [] };
-                            for (let nearby of nearbyPoints) {
-                                if (!cluster.points.includes(nearby)) {
-                                    cluster.points.push(nearby);
-                                    processedPoints.add(nearby.id);
-                                    this.currClusteredEntities.add(nearby.id);
-                                }
-                            }
-                            clusters.push(cluster);
-                        }
-                    }
-                }
-                if (quad.divided) {
-                    processQuad(quad.northwest);
-                    processQuad(quad.northeast);
-                    processQuad(quad.southwest);
-                    processQuad(quad.southeast);
-                }
-            };
-            processQuad(this.quadTree);
-            // Filter out clusters with only one point.
-            validClusters = clusters.filter((cluster) => cluster.points.length > 1);
+        this.quadTree = new Quad(new Rectangle$1(0, 0, 360, 180), 30);
+        const points = [];
+        const distances = new Map();
+        const camera = this.viewer.camera.positionWC || this.viewer.camera.position;
+        const isolated = this.register.GetIsIsolatedAny();
+        for (const [id, record] of this.records) {
+            const state = this.register.GetState({ entityId: id, menuItemId: this.menuItemId });
+            if (state.hidden || (isolated && !state.isolated)) {
+                continue;
+            }
+            const geometry = this.resolveGeometry(record.visual);
+            if (!geometry) {
+                continue;
+            }
+            const { position, radius, minDistance } = geometry;
+            const carto = Cartographic.fromCartesian(position);
+            if (!carto) {
+                continue;
+            }
+            const point = new Point(Math$1.toDegrees(carto.longitude), Math$1.toDegrees(carto.latitude), id);
+            point.position = position;
+            point.radius = radius;
+            point.minDistance = minDistance;
+            if (!this.quadTree.Insert(point)) {
+                continue;
+            }
+            points.push(point);
+            distances.set(id, Cartesian3.distance(position, camera));
         }
-        // Get the entity IDs that are no longer clustered
-        const noLongerClustered = new Set(Array.from(this.prevClusteredEntities).filter((id) => !this.currClusteredEntities.has(id)));
-        // Update the previous clustered entities ref.
-        this.prevClusteredEntities = new Set(this.currClusteredEntities);
-        return { clusters: validClusters, noLongerClustered };
-    }
-    /**
-     * Removes Cesium cluster entity.
-     * @param clusterId
-     */
-    removeClusterEntity(clusterId) {
-        const clusterEntity = this.clusterEntities.get(clusterId);
-        if (clusterEntity) {
-            this.viewer.entities.remove(clusterEntity);
-            this.clusterEntities.delete(clusterId);
+        const clusters = points.length < this.minTotalCount ? [] :
+            ClusterItems({
+                items: points.sort((a, b) => distances.get(a.id) - distances.get(b.id) || a.id.localeCompare(b.id)),
+                id: point => point.id,
+                eligible: point => Math.max(0, distances.get(point.id) - point.radius) > point.minDistance,
+                neighbours: point => this.quadTree.Query(new Circle(point.lon, point.lat, this.getClusterSpacing(distances.get(point.id))), [])
+            }).map(cluster => ({ center: cluster.representative, points: cluster.members }));
+        for (const cluster of clusters) {
+            for (const point of cluster.points) {
+                this.currClusteredEntities.add(point.id);
+            }
         }
+        return {
+            clusters,
+            noLongerClustered: new Set(Array.from(previous).filter(id => !this.currClusteredEntities.has(id)))
+        };
     }
-    convertCartesianToCartographic(cartesian3) {
-        const carto = Cartographic.fromCartesian(cartesian3);
-        const lon = Math$1.toDegrees(carto.longitude);
-        const lat = Math$1.toDegrees(carto.latitude);
-        const id = lon + ',' + lat;
-        return new Point(lon, lat, id);
-    }
-    /**
-     * Adds new entity to the clustering logic.
-     * @param id Bruce entity ID.
-     * @param cartesian3 entity's position.
-     */
-    addPoint(id, cartesian3) {
-        let point = this.convertCartesianToCartographic(cartesian3);
-        point.id = id;
-        return this.quadTree.Insert(point);
+    removeClusterEntity(id) {
+        const entity = this.clusterEntities.get(id);
+        if (!entity)
+            return;
+        this.picker.targets.delete(entity);
+        this.viewer.entities.remove(entity);
+        this.clusterEntities.delete(id);
+        this.clusterViews.delete(id);
     }
-    /**
-     * Adds entity to clustering logic.
-     * Will return false if entity could not be clustered and therefor should not be hidden.
-     * @param id
-     * @param entity
-     * @param queueUpdate
-     * @returns
+    /*
+     * Metadata is additive; existing three-argument calls keep their original signature.
      */
-    AddEntity(id, entity, queueUpdate = true) {
-        if (this.disposed) {
-            return false;
-        }
-        if (!entity) {
-            return false;
-        }
-        if (entity.polygon || entity.polyline) {
+    AddEntity(id, visual, queueUpdate = true, metadata = {}) {
+        if (this.disposed || !visual) {
             return false;
         }
-        const pos3d = GetValue(this.viewer, entity.position);
-        if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-            return false;
-        }
-        if (!this.pointColorBg && entity.point) {
-            const pointColorBg = GetValue(this.viewer, entity.point.color);
-            if (pointColorBg) {
-                let cColor = null;
-                if (pointColorBg instanceof Object) {
-                    cColor = new Color(pointColorBg.red, pointColorBg.green, pointColorBg.blue, pointColorBg.alpha);
-                }
-                else if (typeof pointColorBg === "string") {
-                    cColor = Color.fromCssColorString(pointColorBg);
-                }
-                // Determine if text color should instead be black based on background.
-                // cColor contains r,g,b,a values where r,g,b are in the range [0,1].
-                if (cColor) {
-                    const brightness = (cColor.red * 299 + cColor.green * 587 + cColor.blue * 114) / 1000;
-                    if (brightness > 0.5) {
-                        this.pointColorTxt = "black";
-                    }
-                    else {
-                        this.pointColorTxt = "white";
-                    }
-                    this.pointColorBg = cColor.toCssColorString();
-                }
-            }
-        }
-        if (!this.iconUrl && entity.billboard) {
-            const iconUrl = GetValue(this.viewer, entity.billboard.image);
-            if (typeof iconUrl == "string") {
-                this.iconUrl = iconUrl;
-            }
-        }
-        if (this.registeredEntityIds.has(id)) {
-            this.RemoveEntity(id, false);
-        }
-        const added = this.addPoint(id, pos3d);
-        if (!added) {
+        if (!this.resolveGeometry(visual)) {
+            this.RemoveEntity(id, queueUpdate);
             return false;
         }
+        this.records.set(id, { visual, metadata });
         this.registeredEntityIds.add(id);
         if (queueUpdate) {
-            this.updateQueue.Call();
+            this.Update();
         }
         return true;
     }
-    /**
-     * Removes entity from clustering logic.
-     * Warning: This will not reveal the entity, suppressShow will remain true.
-     * This is made with the assumption that the entity is being removed from viewer.
-     * @param id
-     * @param queueUpdate
-     * @returns
-     */
     RemoveEntity(id, queueUpdate = false) {
         if (this.disposed) {
             return;
         }
-        let pointToRemove = this.quadTree.Find(id);
-        if (pointToRemove) {
-            this.quadTree.Remove(pointToRemove);
-            if (queueUpdate) {
-                this.updateQueue.Call();
-            }
-        }
+        this.records.delete(id);
         this.registeredEntityIds.delete(id);
+        if (queueUpdate) {
+            this.Update();
+        }
     }
 }
 
 /**
  * How often a historic refresh is worth running, and which Entities it should ask about first.
- *
- * A handful of tracked vehicles can afford to re-read on almost every clock tick. Thousands of
- * parcels cannot, and refreshing them that often was never buying anything since the answer barely
- * changes between ticks.
  */
 var HistoricFetchOrder;
 (function (HistoricFetchOrder) {
@@ -11096,6 +13088,13 @@ var HistoricFetchOrder;
     HistoricFetchOrder.IntervalForClock = IntervalForClock;
     // Upper bounds in metres for the distance bands, nearest first.
     HistoricFetchOrder.DEFAULT_BANDS = [500, 2000, 10000, 50000];
+    // How far outside the visible rectangle something still counts as worth re-reading, share of the view itself.
+    HistoricFetchOrder.REFRESH_MARGIN_FRACTION = 0.5;
+    // A close view still gets a usable buffer, and a distant one does not reach half the account.
+    HistoricFetchOrder.MIN_REFRESH_MARGIN_METRES = 250;
+    HistoricFetchOrder.MAX_REFRESH_MARGIN_METRES = 2000;
+    const METRES_PER_DEGREE_LAT = 111320;
+    const MIN_LAT_COSINE = 0.01;
     /**
      * Resolves what to order by from the view monitor, falling back to the camera itself.
      */
@@ -11176,6 +13175,55 @@ var HistoricFetchOrder;
         return grouped.filter(group => group.length > 0);
     }
     HistoricFetchOrder.ByCameraDistanceOf = ByCameraDistanceOf;
+    /**
+     * Returns how far past a visible rectangle a refresh should still reach, in metres.
+     */
+    function RefreshMarginFor(bounds) {
+        if (!bounds) {
+            return HistoricFetchOrder.MIN_REFRESH_MARGIN_METRES;
+        }
+        const latSpan = Math.abs(bounds.north - bounds.south) * METRES_PER_DEGREE_LAT;
+        const cosine = Math.max(MIN_LAT_COSINE, Math.cos(Math$1.toRadians((bounds.north + bounds.south) / 2)));
+        const lonDegrees = bounds.west > bounds.east
+            ? (bounds.east + 360) - bounds.west
+            : bounds.east - bounds.west;
+        const lonSpan = Math.abs(lonDegrees) * METRES_PER_DEGREE_LAT * cosine;
+        const span = Math.min(latSpan, lonSpan);
+        if (!(span > 0)) {
+            return HistoricFetchOrder.MIN_REFRESH_MARGIN_METRES;
+        }
+        return Math.min(HistoricFetchOrder.MAX_REFRESH_MARGIN_METRES, Math.max(HistoricFetchOrder.MIN_REFRESH_MARGIN_METRES, span * HistoricFetchOrder.REFRESH_MARGIN_FRACTION));
+    }
+    HistoricFetchOrder.RefreshMarginFor = RefreshMarginFor;
+    /**
+     * Returns the rectangle grown outwards by a margin in metres.
+     */
+    function GrowBounds(bounds, metres) {
+        if (!bounds || !(metres > 0)) {
+            return bounds;
+        }
+        const dLat = metres / METRES_PER_DEGREE_LAT;
+        const north = Math.min(90, bounds.north + dLat);
+        const south = Math.max(-90, bounds.south - dLat);
+        const cosine = Math.cos(Math$1.toRadians((bounds.north + bounds.south) / 2));
+        if (cosine < MIN_LAT_COSINE) {
+            return { north, south, west: -180, east: 180 };
+        }
+        const dLon = metres / (METRES_PER_DEGREE_LAT * cosine);
+        const straddles = bounds.west > bounds.east;
+        const gap = straddles ? bounds.west - bounds.east : 360 - (bounds.east - bounds.west);
+        if (gap <= dLon * 2) {
+            return { north, south, west: -180, east: 180 };
+        }
+        return { north, south, west: wrapLongitude(bounds.west - dLon), east: wrapLongitude(bounds.east + dLon) };
+    }
+    HistoricFetchOrder.GrowBounds = GrowBounds;
+    /*
+     * Returns a longitude folded back into the range the bounds are expressed in.
+     */
+    function wrapLongitude(lon) {
+        return (((lon + 180) % 360) + 360) % 360 - 180;
+    }
     /*
      * Returns whether a world position sits inside a ground rectangle given in degrees.
      */
@@ -11184,17 +13232,22 @@ var HistoricFetchOrder;
         if (!degrees) {
             return false;
         }
-        const { lat, lon } = degrees;
+        return InDegreeBounds(degrees.lat, degrees.lon, bounds);
+    }
+    HistoricFetchOrder.InBounds = InBounds;
+    /*
+     * The same test for a caller that already holds the degrees and should not pay to resolve them from a world position again.
+     */
+    function InDegreeBounds(lat, lon, bounds) {
         if (lat < bounds.south || lat > bounds.north) {
             return false;
         }
-        // A view straddling the antimeridian reports west east of east, so the span is the outside.
         if (bounds.west > bounds.east) {
             return lon >= bounds.west || lon <= bounds.east;
         }
         return lon >= bounds.west && lon <= bounds.east;
     }
-    HistoricFetchOrder.InBounds = InBounds;
+    HistoricFetchOrder.InDegreeBounds = InDegreeBounds;
     /*
      * Returns an Entity's world position, or null when it has none to place it by.
      */
@@ -11690,7 +13743,7 @@ var EntitiesRenderManager;
             });
             this.useGeojson = item.renderAsGeojson == true;
             if (item.enableClustering) {
-                this.clustering = new PointClustering(this.visualsManager, this.item.id);
+                this.clustering = new PointClustering(this.visualsManager, this.item.id, this.item.clustering);
             }
         }
         Init(params) {
@@ -12726,8 +14779,8 @@ var EntitiesRenderManager;
                     // The baseline data source must be editable.
                     const canEdit = !((_b = entity.Bruce.Outline) === null || _b === void 0 ? void 0 : _b.find(x => x.Baseline && !x.Editable));
                     const visual = rego === null || rego === void 0 ? void 0 : rego.visual;
+                    const wasClustered = this.clustering ? this.clustering.AddEntity(id, cEntity, false, { entity }) : false;
                     if (!visual || visual != cEntity) {
-                        const wasClustered = this.clustering ? this.clustering.AddEntity(id, cEntity, false) : false;
                         const tagIds = entity.Bruce["Layer.ID"];
                         const rego = {
                             canEdit: canEdit,
@@ -14173,8 +16226,8 @@ var EntitiesIdsRenderManager;
                         menuItemId: this.item.id
                     });
                     const visual = rego === null || rego === void 0 ? void 0 : rego.visual;
+                    const clustered = this.clustering ? this.clustering.AddEntity(id, cEntity, false, { entity }) : false;
                     if (!visual || visual != cEntity) {
-                        const clustered = this.clustering ? this.clustering.AddEntity(id, cEntity, false) : false;
                         this.visualsManager.AddRego({
                             rego: {
                                 canEdit: true,
@@ -14600,6 +16653,19 @@ class EntityGatherer {
         // All IDs that have ever been queued.
         // When nothing is in queue, we'll re-request the existing IDs based on timeline changes.
         this.allEIds = new Set();
+        // IDs a historic read has actually answered with a record, rather than falling back to a stub.
+        // A refresh serves these before the ones that have never produced anything.
+        this.everFound = new Set();
+        // Every known Entity bucketed by the ground cell its position falls in, so a refresh can ask
+        // what the view reaches instead of walking the whole set. Built as IDs arrive.
+        this.cells = new Map();
+        // IDs the position source could not place yet. They are always refreshed.
+        this.unplaced = new Set();
+        // The IDs the last decision found inside the view, so a camera move can queue the difference
+        // rather than re-requesting everything it already asked about.
+        this.lastInView = new Set();
+        // Unsubscribes the view monitor listener that queues what the camera has moved onto.
+        this.monitorRemoval = null;
         // Indicates a tick is active.
         // When true, we won't bother calling onTick again.
         this.runningTick = false;
@@ -14650,6 +16716,16 @@ class EntityGatherer {
         }
         this.historic = historic;
         this.expandSources = expandSources;
+        if (this.historic) {
+            // Anything already known was taken in before the index was being built, so it is filed
+            // a bounded number at a time from here rather than in one pass now.
+            for (const entityId of this.allEIds) {
+                this.unplaced.add(entityId);
+            }
+        }
+        else {
+            this.clearIndex();
+        }
         if (this.historic) {
             // 4 ticks per second.
             // The fastest data we are working with is 5 times per second.
@@ -14701,6 +16777,8 @@ class EntityGatherer {
         this.lastOrderFocus = null;
         this.allEIds.clear();
         this.lastFoundDateTimes.clear();
+        this.everFound.clear();
+        this.clearIndex();
         this.lastDateTime = null;
     }
     ReQueueAll() {
@@ -14711,22 +16789,193 @@ class EntityGatherer {
         this.eIdQueued = new Set(this.eIdQueue);
         this.priorityCount = 0;
         this.lastOrderFocus = null;
+        this.clearIndex();
     }
     /**
-     * Supplies a lookup from Entity ID to world position, letting the queue resolve what the camera
-     * is nearest first. Sources that cannot answer should not call this, and are served in order.
+     * Supplies a lookup from Entity ID to world position, letting the queue resolve what the camera is nearest first.
+     * Sources that cannot answer should not call this, and are served in order.
      */
     SetPositionSource(positionOf) {
         this.positionOf = positionOf;
         this.lastOrderFocus = null;
+        this.cells.clear();
+        this.lastInView.clear();
+        for (const entityId of this.allEIds) {
+            this.unplaced.add(entityId);
+        }
     }
     /**
-     * Supplies the view monitor, so the order follows the ground the camera is aimed at and prefers
-     * what is on screen. Without one the ordering falls back to distance from the camera itself.
+     * Supplies the view monitor, so the order follows the ground the camera is aimed at and prefers what is on screen.
+     * Without one the ordering falls back to distance from the camera itself.
      */
     SetViewMonitor(monitor) {
+        var _a;
+        (_a = this.monitorRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.monitorRemoval = null;
         this.monitor = monitor;
         this.lastOrderFocus = null;
+        if (!monitor) {
+            return;
+        }
+        this.monitorRemoval = monitor.Updated().Subscribe(() => {
+            this.admitNewlyInView();
+        });
+    }
+    /*
+     * Queues whatever the camera has moved onto since the last decision.
+     */
+    admitNewlyInView() {
+        if (this.disposed || !this.historic) {
+            return;
+        }
+        const inView = this.decideInView();
+        if (!inView) {
+            return;
+        }
+        const admit = [];
+        for (const entityId of inView) {
+            if (!this.lastInView.has(entityId)) {
+                admit.push(entityId);
+            }
+        }
+        this.lastInView = new Set(inView);
+        if (admit.length) {
+            this.Queue(admit);
+        }
+    }
+    /*
+     * Returns the IDs a refresh should ask about, or null when the view cannot say and the answer has to be everything.
+     */
+    decideInView() {
+        if (!this.historic || !this.positionOf || !this.monitor) {
+            return null;
+        }
+        const area = this.refreshArea();
+        if (!area) {
+            return null;
+        }
+        const inView = [];
+        for (const key of this.candidateCellKeys(area)) {
+            const cell = this.cells.get(key);
+            if (!cell) {
+                continue;
+            }
+            for (let i = 0; i < cell.ids.length; i++) {
+                if (HistoricFetchOrder.InDegreeBounds(cell.lats[i], cell.lons[i], area)) {
+                    inView.push(cell.ids[i]);
+                }
+            }
+        }
+        // Anything the source cannot place yet is asked about rather than quietly dropped.
+        for (const entityId of this.unplaced) {
+            inView.push(entityId);
+        }
+        return inView;
+    }
+    /*
+     * Returns the cell keys a rectangle can reach.
+     */
+    candidateCellKeys(area) {
+        const size = EntityGatherer.CELL_DEGREES;
+        const southCell = Math.floor(area.south / size);
+        const northCell = Math.floor(area.north / size);
+        const spans = (area.west > area.east ? [
+            {
+                from: Math.floor(area.west / size),
+                to: Math.floor(180 / size)
+            },
+            {
+                from: Math.floor(-180 / size),
+                to: Math.floor(area.east / size)
+            }
+        ] :
+            [{
+                    from: Math.floor(area.west / size),
+                    to: Math.floor(area.east / size)
+                }]);
+        let width = 0;
+        for (const span of spans) {
+            width += (span.to - span.from) + 1;
+        }
+        const wanted = ((northCell - southCell) + 1) * width;
+        if (!(wanted > 0) || wanted > this.cells.size) {
+            return Array.from(this.cells.keys());
+        }
+        const keys = [];
+        for (let lat = southCell; lat <= northCell; lat++) {
+            for (const span of spans) {
+                for (let lon = span.from; lon <= span.to; lon++) {
+                    keys.push(lat + ":" + lon);
+                }
+            }
+        }
+        return keys;
+    }
+    /*
+     * Files an Entity in the cell its position falls in.
+     */
+    place(entityId) {
+        const degrees = this.degreesOf(entityId);
+        if (!degrees) {
+            this.unplaced.add(entityId);
+            return;
+        }
+        const size = EntityGatherer.CELL_DEGREES;
+        const key = Math.floor(degrees.lat / size) + ":" + Math.floor(degrees.lon / size);
+        let cell = this.cells.get(key);
+        if (!cell) {
+            cell = { ids: [], lats: [], lons: [] };
+            this.cells.set(key, cell);
+        }
+        cell.ids.push(entityId);
+        cell.lats.push(degrees.lat);
+        cell.lons.push(degrees.lon);
+        this.unplaced.delete(entityId);
+    }
+    /*
+     * Retries a bounded number of the Entities the source could not place before, so a late baked
+     * position joins the index without any one tick paying for all of them.
+     */
+    placeStragglers() {
+        if (!this.unplaced.size || !this.positionOf) {
+            return;
+        }
+        let budget = EntityGatherer.PLACE_BATCH;
+        for (const entityId of this.unplaced) {
+            if (budget-- <= 0) {
+                return;
+            }
+            this.place(entityId);
+        }
+    }
+    clearIndex() {
+        this.cells.clear();
+        this.unplaced.clear();
+        this.lastInView.clear();
+    }
+    /*
+     * Returns where an Entity sits in degrees, or null when the source cannot place it.
+     */
+    degreesOf(entityId) {
+        let pos = null;
+        try {
+            pos = this.positionOf ? this.positionOf(entityId) : null;
+        }
+        catch {
+            pos = null;
+        }
+        return pos ? CartesianToDegrees(pos) : null;
+    }
+    /*
+     * Returns the visible rectangle plus the margin a refresh still reaches into,
+     * or null when the view cannot say, which is what leaves every Entity in.
+     */
+    refreshArea() {
+        const focus = HistoricFetchOrder.FocusFrom({ viewer: this.viewer, monitor: this.monitor });
+        if (!(focus === null || focus === void 0 ? void 0 : focus.bounds)) {
+            return null;
+        }
+        return HistoricFetchOrder.GrowBounds(focus.bounds, HistoricFetchOrder.RefreshMarginFor(focus.bounds));
     }
     /**
      * Re-bands the pending queue so the nearest Entities are requested first.
@@ -14739,8 +16988,6 @@ class EntityGatherer {
         if (!focus) {
             return;
         }
-        // Re-banding on every batch would cost a full pass per request for no change in the answer.
-        // Measured on the focus, so panning across the ground counts even when the eye barely moves.
         if (this.lastOrderFocus && !EntityGatherer.boundsChanged(this.lastOrderFocus, focus) &&
             Cartesian3.distance(this.lastOrderFocus.origin, focus.origin) < EntityGatherer.REORDER_MOVE_METRES) {
             return;
@@ -14787,26 +17034,47 @@ class EntityGatherer {
         });
         const ordered = [];
         for (const band of banded) {
+            // Within a band, the ones a read has answered for go first.
+            // A building that has never produced a record is the one least likely to start now, so it waits.
+            const withData = [];
+            const withoutData = [];
             for (const entityId of band) {
+                (this.everFound.has(entityId) ? withData : withoutData).push(entityId);
+            }
+            for (const entityId of withData) {
+                ordered.push(entityId);
+            }
+            for (const entityId of withoutData) {
                 ordered.push(entityId);
             }
         }
         return ordered;
     }
+    /*
+     * Takes an ID into the known set, filing it in the index the first time it is seen.
+     */
+    remember(entityId) {
+        if (this.allEIds.has(entityId)) {
+            return;
+        }
+        this.allEIds.add(entityId);
+        // Only a historic refresh reads the index, so nothing else pays to build it.
+        if (this.historic) {
+            this.place(entityId);
+        }
+    }
     Queue(entityIds, topOfQueue = false) {
         if (this.disposed || !(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
             return;
         }
         let changes = 0;
         if (topOfQueue) {
-            // Walked back to front so a repeated ID keeps the position of its last occurrence, then
-            // laid down in that order, which is where inserting one at a time leaves them.
             const toFront = [];
             const promoting = new Set();
             let anyAlreadyQueued = false;
             for (let i = entityIds.length - 1; i >= 0; i--) {
                 const eId = entityIds[i];
-                this.allEIds.add(eId);
+                this.remember(eId);
                 if (promoting.has(eId)) {
                     continue;
                 }
@@ -14842,7 +17110,7 @@ class EntityGatherer {
         else {
             for (let i = 0; i < entityIds.length; i++) {
                 const eId = entityIds[i];
-                this.allEIds.add(eId);
+                this.remember(eId);
                 if (this.eIdQueued.has(eId)) {
                     continue;
                 }
@@ -14857,19 +17125,22 @@ class EntityGatherer {
         this.onTick(false);
     }
     Dispose() {
+        var _a;
         if (this.disposed) {
             return;
         }
         this.disposed = true;
+        (_a = this.monitorRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.monitorRemoval = null;
         this.hDisposals.forEach((d) => d());
         this.hDisposals = [];
-        // A tick still awaiting a response resumes after this, and anything left here would have it
-        // ask for the whole set again on the way out.
         this.eIdQueue = [];
         this.eIdQueued.clear();
         this.priorityCount = 0;
         this.allEIds.clear();
         this.lastFoundDateTimes.clear();
+        this.everFound.clear();
+        this.clearIndex();
         this.entityDataOverrides.clear();
     }
     checkRange(force) {
@@ -14893,6 +17164,7 @@ class EntityGatherer {
         this.lastDateTime = rTime;
         (async () => {
             this.runningTick = true;
+            this.placeStragglers();
             let rerun = false;
             try {
                 const handleResponse = async (requestedBatch, entities) => {
@@ -14905,6 +17177,13 @@ class EntityGatherer {
                             foundById.set(entityId, entity);
                         }
                     }
+                    if (this.historic) {
+                        for (const entityId of requestedBatch || []) {
+                            if (foundById.has(entityId)) {
+                                this.everFound.add(entityId);
+                            }
+                        }
+                    }
                     for (const entityId of requestedBatch || []) {
                         const override = this.entityDataOverrides.get(entityId);
                         if (override) {
@@ -15033,15 +17312,16 @@ class EntityGatherer {
                         this._onQueueProgress.Trigger(100);
                     }
                 }
-                // Now run through all IDs that we've seen and request them.
+                // Now run through the IDs we've seen that the view still reaches, and request them.
                 // We'll skip those that we just requested.
-                let allEIds = Array.from(this.allEIds);
+                const inView = this.decideInView();
+                this.lastInView = inView ? new Set(inView) : new Set();
+                let allEIds = inView || Array.from(this.allEIds);
                 if (requestedIds.size) {
                     allEIds = allEIds.filter((eId) => !requestedIds.has(eId));
                 }
                 if (allEIds.length) {
-                    // A historic tick re-reads the whole set, so the near ones are worth resolving
-                    // first here even more than in the queue above.
+                    // The near ones are resolved first out of whatever the view still reaches.
                     allEIds = this.bandIds(allEIds);
                     while (allEIds.length && !this.disposed && !this.eIdQueue.length) {
                         if (this.historic && this.lastDateTime !== rTime) {
@@ -15080,6 +17360,11 @@ class EntityGatherer {
 }
 // Below this the whole queue clears in one or two requests, so ordering it buys nothing.
 EntityGatherer.MIN_ORDER_QUEUE = 500;
+// Side of the ground cells Entities are bucketed into, in degrees.
+// About a kilometre, so a view covers a handful of them rather than hundreds.
+EntityGatherer.CELL_DEGREES = 0.01;
+// How many Entities one tick will try to place in the index.
+EntityGatherer.PLACE_BATCH = 20000;
 // How far the point being looked at has to move before the queue is worth re-banding, in metres.
 // Under the nearest band's width, so a move that could change what is nearest still triggers one.
 EntityGatherer.REORDER_MOVE_METRES = 250;
@@ -47923,7 +50208,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.3.8";
+const VERSION = "7.4.0";
 /**
  * Updates the environment instance used by bruce-cesium to one specified.
  * This can be used to ensure that the instance a parent is referencing is shared between bruce-cesium, bruce-models, and the parent app.
@@ -47940,5 +50225,5 @@ const getENVIRONMENT = () => {
     return ENVIRONMENT;
 };
 
-export { VERSION, setENVIRONMENT, getENVIRONMENT, CesiumAnimatedInOut, DisplacedSurfacePrimitive, CesiumAnimatedProperty, isStyleChanged, isOutlineChanged$1 as isOutlineChanged, StyleEffective, EntityRenderEngine, EntityRenderEngineModel3d, EntityRenderEnginePoint, EntityRenderEnginePolygon, EntityRenderEnginePolyline, TextureFrameSeriesAnimator, TextureValueLabels, MenuItemCreator, MenuItemManager, CesiumParabola, EntityLabel, LiveCursor, SharedGetters, DataSourceStaticKmlManager, DataLabRenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, AssemblyRenderManager, GoogleSearchRenderManager, RelationsRenderManager, RenderManager, TilesetArbRenderManager, TilesetCadRenderManager, TilesetEntitiesRenderManager, TilesetGooglePhotosRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TileRenderEngine, createTileset, TilesetRenderEngine, ViewRenderEngine, VisualRegisterCuller, VisualsRegister, XGridsRenderEngine, CesiumEntityStyler, DrawingUtils, EntityUtils, MeasureUtils, StyleUtils, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_KEY, CESIUM_TIMELINE_INTERVAL_KEY, CESIUM_MODEL_SPACE_KEY, DEFAULT_LIVE_PADDING_SECONDS, DEFAULT_BRIGHTNESS_SHIFT, DEFAULT_LIGHT_INTENSITY, LIGHTING_SETTINGS_VERSION, LIGHT_INTENSITY_COMPENSATION, MAX_COMPENSATED_LIGHT_INTENSITY, ViewUtils, CesiumViewMonitor, ViewGroundArea, ViewerEventTracker, ViewerUtils, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, WidgetControlViewBar, WidgetControlViewBarSearch, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks, WidgetLeftPanelTabDashboard, EMenuItemState, WidgetLeftPanelTabMenuItems, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, ECursor, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, WidgetLeftPanel, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar };
+export { VERSION, setENVIRONMENT, getENVIRONMENT, ClusterItems, PointClustering, PointClusterSize, CesiumAnimatedInOut, DisplacedSurfacePrimitive, CesiumAnimatedProperty, isStyleChanged, isOutlineChanged$1 as isOutlineChanged, StyleEffective, EntityRenderEngine, EntityRenderEngineModel3d, EntityRenderEnginePoint, EntityRenderEnginePolygon, EntityRenderEnginePolyline, TextureFrameSeriesAnimator, TextureValueLabels, MenuItemCreator, MenuItemManager, CesiumParabola, EntityLabel, EntityLabelGroup, LiveCursor, SharedGetters, DataSourceStaticKmlManager, DataLabRenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, AssemblyRenderManager, GoogleSearchRenderManager, RelationsRenderManager, RenderManager, TilesetArbRenderManager, TilesetCadRenderManager, TilesetEntitiesRenderManager, TilesetGooglePhotosRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TileRenderEngine, createTileset, TilesetRenderEngine, ViewRenderEngine, VisualRegisterCuller, VisualsRegister, XGridsRenderEngine, CesiumEntityStyler, DrawingUtils, EntityUtils, MeasureUtils, StyleUtils, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_KEY, CESIUM_TIMELINE_INTERVAL_KEY, CESIUM_MODEL_SPACE_KEY, DEFAULT_LIVE_PADDING_SECONDS, DEFAULT_BRIGHTNESS_SHIFT, DEFAULT_LIGHT_INTENSITY, LIGHTING_SETTINGS_VERSION, LIGHT_INTENSITY_COMPENSATION, MAX_COMPENSATED_LIGHT_INTENSITY, ViewUtils, CesiumViewMonitor, ViewGroundArea, ViewerEventTracker, ViewerUtils, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, WidgetControlViewBar, WidgetControlViewBarSearch, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks, WidgetLeftPanelTabDashboard, EMenuItemState, WidgetLeftPanelTabMenuItems, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, ECursor, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, WidgetLeftPanel, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar };
 //# sourceMappingURL=bruce-cesium.es5.js.map