bruce-cesium 7.3.8 → 7.4.0

package/dist/bruce-cesium.umd.js

@@ -5283,6 +5283,86 @@
         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.
@@ -5301,10 +5381,564 @@
         return obj;
     }
     (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 = Cesium.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 = Cesium.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;
             }
@@ -5317,10 +5951,18 @@
             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.
@@ -5340,15 +5982,24 @@
                 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 && !BModels.ENVIRONMENT.IS_SELF_MANAGED) {
+                if (!params.api && !BModels.ENVIRONMENT.IS_SELF_MANAGED && this.options.text == null) {
                     this.api = BModels.ENVIRONMENT.Api().GetBruceApi();
                 }
             }
@@ -5398,12 +6049,24 @@
                 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;
@@ -5612,7 +6275,7 @@
                         }
                         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;
                             }
@@ -5620,10 +6283,10 @@
                             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 BModels.EntityType.Get({
+                                        const data = this.options.attributes ? null : await BModels.EntityType.Get({
                                             api: this.api,
                                             entityTypeId: this.rego.entityTypeId
                                         });
@@ -5638,14 +6301,14 @@
                                     }
                                     // 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 BModels.Entity.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
                                                 });
@@ -5654,7 +6317,7 @@
                                                         entity: entity,
                                                         path: attributes[i]
                                                     });
-                                                    if (value) {
+                                                    if (value != null) {
                                                         additionalTexts.push(value);
                                                     }
                                                 }
@@ -5683,12 +6346,166 @@
                 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 = Cesium.Color.fromCssColorString(iconColor || "white") || Cesium.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 Cesium.Color()) :
+                            color.brighten(ICON_BACKGROUND_BLEND, new Cesium.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) {
@@ -5696,11 +6513,22 @@
                 }
                 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;
@@ -5709,9 +6537,10 @@
                     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;
@@ -5728,7 +6557,10 @@
                     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;
@@ -5741,35 +6573,20 @@
                     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 = Cesium.Cartesian3.distance(cameraPos, this._pos3d);
-                    _lastDistance = distance;
-                    _lastCameraPos = cameraPos.clone();
-                    return distance;
-                };
                 let MAX_DISTANCE = Math.max(15000, sizeInM * 35);
                 if (visual && visual instanceof Cesium.Entity) {
                     // Consistent sized things.
@@ -5777,123 +6594,399 @@
                         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 Cesium.Entity && visual.position) {
+                        const position = getValue(this.viewer, visual.position);
+                        if (position)
+                            this._pos3d = exports.DrawingUtils.EnsurePosHeight({
+                                desiredHeightRef: Cesium.HeightReference.NONE, heightRef, pos3d: position, viewer: this.viewer
+                            });
                     }
-                    const CESIUM = Cesium;
-                    const _3dTo2D = Cesium.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 = Cesium.Cartesian3.subtract(this._pos3d, cameraPosition, new Cesium.Cartesian3());
+                    const depth = Cesium.Cartesian3.dot(relative, camera.directionWC || camera.direction);
+                    const distance = Cesium.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 = Cesium.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 = Cesium.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 = Cesium.Cartographic.toCartesian(lineEndPoint);
-                        const CESIUM = Cesium;
-                        const _3dTo2D = Cesium.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 = Cesium.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, Cesium.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 Cesium.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 Cesium.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(() => {
@@ -5913,6 +7006,9 @@
              * 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);
@@ -5938,16 +7034,44 @@
          * 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];
         }
@@ -5962,12 +7086,19 @@
             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;
         }
@@ -5987,6 +7118,481 @@
         EntityLabel.GetLabel = GetLabel;
     })(exports.EntityLabel || (exports.EntityLabel = {}));
 
+    (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 = Cesium.Cartographic.fromCartesian(Cesium.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 ? Cesium.Math.toDegrees(cartographic.longitude) : location === null || location === void 0 ? void 0 : location.longitude,
+                latitude: cartographic ? Cesium.Math.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 BModels.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: BModels.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 BModels.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 BModels.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 = BModels.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 = BModels.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 => BModels.Entity.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 Cesium.Entity({
+                    position: Cesium.Cartesian3.fromDegrees(item.longitude, item.latitude, item.altitude || 0),
+                    point: { heightReference: Cesium.HeightReference.NONE, pixelSize: 0 }
+                });
+                this.standalone.set(entityId, new exports.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;
+    })(exports.EntityLabelGroup || (exports.EntityLabelGroup = {}));
+
     /**
      * Utility for rendering parabolas between two points on the map.
      */
@@ -7480,7 +9086,7 @@
         }
     }
     function updateEntity(viewer, entityId, register, refresh, cache = {}) {
-        var _a;
+        var _a, _b, _c;
         if (!entityId) {
             // What are we doing?
             return;
@@ -7593,20 +9199,25 @@
                     }
                 }
             }
-            if (state.labelled && visible) {
+            const labelGroup = register.GetLabelGroupFor(rego.entityId, rego.menuItemId);
+            if ((state.labelled || labelGroup) && visible) {
                 exports.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 = exports.EntityLabel.GetLabel({ rego })) === null || _c === void 0 ? void 0 : _c.Persistent)) {
                 exports.EntityLabel.Detatch({
-                    rego
+                    rego, force: true
                 });
             }
         }
+        register.RefreshLabelGroupEntity(entityId);
     }
     function markEntity(register, rego, visual, ignoreParent) {
         const vis = visual;
@@ -7717,6 +9328,7 @@
                 }
                 return this.onUpdate;
             }
+            get OnLabelGroupsChanged() { return this.labelGroupsChanged; }
             constructor(params) {
                 this.id = BModels.ObjectUtils.UId();
                 this.disposed = false;
@@ -7755,10 +9367,35 @@
                 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 BModels.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 = exports.VisualRegisterCuller.Monitor({
@@ -7954,6 +9591,7 @@
                 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;
@@ -7966,6 +9604,8 @@
                             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);
@@ -8623,8 +10263,23 @@
                 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);
+                    exports.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)
+                        exports.EntityLabel.Detatch({ rego, force: true });
+                }
+                exports.EntityLabel.SetContainer(this.viewer);
+                (_b = this.cameraCullerDispose) === null || _b === void 0 ? void 0 : _b.call(this, {
                     uncull: false
                 });
                 this.cameraCullerDispose = null;
@@ -8640,7 +10295,7 @@
                 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);
@@ -8649,7 +10304,7 @@
                 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();
             }
@@ -9601,7 +11256,7 @@
              * @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;
@@ -9622,7 +11277,7 @@
                         }
                     }
                     const removeOne = (entityId) => {
-                        var _a, _b;
+                        var _a, _b, _c;
                         const entityRegos = this.rego[entityId];
                         if (!entityRegos) {
                             return;
@@ -9637,7 +11292,7 @@
                             return;
                         }
                         exports.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.
@@ -9662,15 +11317,14 @@
                             (_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);
@@ -9701,7 +11355,7 @@
                             return;
                         }
                         exports.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.
@@ -9720,7 +11374,7 @@
                         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({
@@ -9729,6 +11383,7 @@
                             });
                         }
                     }
+                    (_c = this.labelGroups) === null || _c === void 0 ? void 0 : _c.RefreshEntity(entityId);
                 }
                 else if (relation) {
                     const relationKey = RelationRenderEngine.GetRenderGroupId(relation);
@@ -9740,7 +11395,7 @@
                                 continue;
                             }
                             exports.EntityLabel.Detatch({
-                                rego
+                                rego, force: true
                             });
                             removeEntity(this.viewer, rego.visual);
                             rego.visual = null;
@@ -9749,6 +11404,7 @@
                                 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,
@@ -9758,7 +11414,7 @@
                                 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({
@@ -9777,7 +11433,7 @@
              * @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) {
@@ -9792,9 +11448,8 @@
                         continue;
                     }
                     if (rego.visual === visual) {
-                        // The primary graphic for this rego - remove the rego entirely.
                         exports.EntityLabel.Detatch({
-                            rego
+                            rego, force: true
                         });
                         if (doRemove != false) {
                             removeEntity(this.viewer, rego.visual);
@@ -9823,9 +11478,10 @@
                             });
                         }
                         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);
@@ -10092,6 +11748,204 @@
                 }
                 return map;
             }
+            ReleaseHoverLabel(immediate = false) {
+                const label = this.hoverLabel;
+                this.hoverLabel = undefined;
+                if (!label || label.Disposed || label.Persistent) {
+                    return;
+                }
+                if (immediate) {
+                    exports.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);
+                    exports.EntityLabel.Detatch({ label: previous.label });
+                }
+                // Retain briefly beyond the fade to bridge debounced same-target hover updates.
+                const timer = setTimeout(() => {
+                    this.retiringHoverLabels.delete(key);
+                    exports.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 && exports.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 Cesium.Entity({
+                            position: Cesium.Cartesian3.fromDegrees(group.item.longitude, group.item.latitude, group.item.altitude || 0),
+                            point: {
+                                pixelSize: 0,
+                                heightReference: Cesium.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 exports.EntityLabel.Label(params) : exports.EntityLabel.Attach(params);
+            }
+            SetLabelContainer(container) {
+                if (this.disposed) {
+                    return;
+                }
+                exports.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 exports.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;
     })(exports.VisualsRegister || (exports.VisualsRegister = {}));
@@ -10218,6 +12072,8 @@
     }
     class Point {
         constructor(lon, lat, id) {
+            this.radius = 0;
+            this.minDistance = 0;
             this.lon = lon;
             this.lat = lat;
             this.id = id;
@@ -10235,8 +12091,8 @@
             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;
             }
@@ -10250,8 +12106,7 @@
         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 {
@@ -10288,13 +12143,13 @@
             let y = this.boundary.y;
             let w = this.boundary.w / 2;
             let h = this.boundary.h / 2;
-            let ne = new Rectangle(x + w / 2, y - h / 2, w, h);
+            let ne = new Rectangle(x + w, y - h, w, h);
             this.northeast = new Quad(ne, this.capacity);
-            let nw = new Rectangle(x - w / 2, y - h / 2, w, h);
+            let nw = new Rectangle(x - w, y - h, w, h);
             this.northwest = new Quad(nw, this.capacity);
-            let se = new Rectangle(x + w / 2, y + h / 2, w, h);
+            let se = new Rectangle(x + w, y + h, w, h);
             this.southeast = new Quad(se, this.capacity);
-            let sw = new Rectangle(x - w / 2, y + h / 2, w, h);
+            let sw = new Rectangle(x - w, y + h, w, h);
             this.southwest = new Quad(sw, this.capacity);
             this.divided = true;
         }
@@ -10302,7 +12157,8 @@
             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;
             }
@@ -10532,505 +12388,640 @@
         }
         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(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 BModels.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 Cesium.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 = Cesium.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 = Cesium.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 == exports.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(0, 0, 360, 180), 30);
+            this.updateQueue = new BModels.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 === exports.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 == exports.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)
+                    exports.CesiumEntityStyler.Select({ viewer: this.viewer, entity: view.entity, requestRender: false });
+                else
+                    exports.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) && Cesium.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 : Cesium.HeightReference.NONE;
+            if (visual.polyline) {
+                heightRef = value(visual.polyline.clampToGround) ? Cesium.HeightReference.CLAMP_TO_GROUND : Cesium.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 = Cesium.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 = [Cesium.Rectangle.northwest(rectangle), Cesium.Rectangle.northeast(rectangle),
+                        Cesium.Rectangle.southwest(rectangle), Cesium.Rectangle.southeast(rectangle)].map(c => Cesium.Cartographic.toCartesian(c));
+                }
+                height = value(visual.rectangle.height);
+                if (height == null && value(visual.rectangle.extrudedHeight) == null) {
+                    heightRef = Cesium.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 = Cesium.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 => Cesium.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 = Cesium.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 = Cesium.Cartographic.fromCartesian(position);
+                    if (!carto)
+                        continue;
+                    source = Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, height);
+                }
+                const actual = exports.DrawingUtils.EnsurePosHeight({
+                    viewer: this.viewer,
+                    pos3d: source,
+                    desiredHeightRef: Cesium.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 : Cesium.HeightReference.NONE;
+                for (const position of positions || []) {
+                    if (!valid(position)) {
+                        continue;
+                    }
+                    const carto = Cesium.Cartographic.fromCartesian(position);
+                    if (!carto) {
+                        continue;
+                    }
+                    const actual = exports.DrawingUtils.EnsurePosHeight({
+                        viewer: this.viewer,
+                        pos3d: Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, extrudedHeight),
+                        desiredHeightRef: Cesium.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 = Cesium.BoundingSphere.fromPoints(resolved);
+                // A chord midpoint can lie underground. Preserve the average rendered vertex altitude.
+                const center = Cesium.Cartographic.fromCartesian(sphere.center);
+                if (center) {
+                    const altitude = resolved.reduce((sum, p) => sum + Cesium.Cartographic.fromCartesian(p).height, 0) / resolved.length;
+                    const position = Cesium.Cartesian3.fromRadians(center.longitude, center.latitude, altitude);
+                    sphere.radius += Cesium.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, Cesium.Cartesian3.magnitude(value(visual.box.dimensions) || Cesium.Cartesian3.ZERO) / 2);
                 }
-                if (count >= 1000) {
-                    return 120;
+                if (visual.ellipsoid) {
+                    sphere.radius = Math.max(sphere.radius, Cesium.Cartesian3.maximumComponent(value(visual.ellipsoid.radii) || Cesium.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 Cesium.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] : Cesium.BoundingSphere.fromBoundingSpheres(spheres);
+            if (!valid(sphere.center) || !Number.isFinite(sphere.radius)) {
+                return null;
+            }
+            if (spheres.length > 1) {
+                const carto = Cesium.Cartographic.fromCartesian(sphere.center);
+                if (!carto) {
+                    return null;
+                }
+                const height = anchors.reduce((sum, p) => sum + Cesium.Cartographic.fromCartesian(p).height, 0) / anchors.length;
+                const position = Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, height);
+                sphere.radius += Cesium.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) ? BModels.Calculator.GetNumber(this.settings.iconPriority, data) : this.settings.iconPriority;
+                status = Array.isArray(this.settings.iconStatus) ? BModels.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 ? exports.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 = Cesium.Cartesian3.distanceSquared(point.position, this.viewer.camera.positionWC || this.viewer.camera.position);
+                        const representativeDistance = Cesium.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 Cesium.Cartesian3();
+                for (const point of cluster.points) {
+                    Cesium.Cartesian3.add(position, point.position, position);
+                }
+                Cesium.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 Cesium.ConstantPositionProperty(Cesium.Cartesian3.fromDegrees(centroid.lon, centroid.lat, 150));
-                    clusterEntity.billboard.image = new Cesium.CallbackProperty(() => {
-                        return getCanvas(count);
-                    }, false),
-                        clusterEntity.billboard.width = new Cesium.ConstantProperty(getScale(cluster.points.length));
-                    clusterEntity.billboard.height = new Cesium.ConstantProperty(getScale(cluster.points.length));
-                }
-                else {
-                    clusterEntity = this.viewer.entities.add({
-                        position: Cesium.Cartesian3.fromDegrees(centroid.lon, centroid.lat, 150),
+                const image = new Cesium.CallbackProperty(() => getClusterImage(params), false);
+                let entity = this.clusterEntities.get(clusterId);
+                if (!entity) {
+                    entity = this.viewer.entities.add({
+                        position,
                         billboard: {
+                            image,
+                            color: Cesium.Color.WHITE,
+                            width: params.size,
+                            height: params.size,
                             heightReference: Cesium.HeightReference.NONE,
-                            image: new Cesium.CallbackProperty(() => {
-                                return getCanvas(count);
-                            }, false),
-                            width: getScale(count),
-                            height: getScale(count),
                             verticalOrigin: Cesium.VerticalOrigin.CENTER,
                             horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
-                            disableDepthTestDistance: Number.POSITIVE_INFINITY,
-                            scaleByDistance: new Cesium.NearFarScalar(1.5e2, 0.5, 3.0e7, 0.1),
+                            disableDepthTestDistance: Infinity,
+                            scaleByDistance: new Cesium.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 Cesium.ConstantPositionProperty(position);
+                    entity.billboard.image = image;
+                    entity.billboard.width = new Cesium.ConstantProperty(params.size);
+                    entity.billboard.height = new Cesium.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 = Cesium.Cartesian3.fromDegrees(point.lon, point.lat);
-                            const distanceFromCluster = Cesium.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(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 = Cesium.Cartographic.fromCartesian(position);
+                if (!carto) {
+                    continue;
+                }
+                const point = new Point(Cesium.Math.toDegrees(carto.longitude), Cesium.Math.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, Cesium.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 = Cesium.Cartographic.fromCartesian(cartesian3);
-            const lon = Cesium.Math.toDegrees(carto.longitude);
-            const lat = Cesium.Math.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 Cesium.Color(pointColorBg.red, pointColorBg.green, pointColorBg.blue, pointColorBg.alpha);
-                    }
-                    else if (typeof pointColorBg === "string") {
-                        cColor = Cesium.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) {
@@ -11075,6 +13066,13 @@
         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.
          */
@@ -11155,6 +13153,55 @@
             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(Cesium.Math.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(Cesium.Math.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.
          */
@@ -11163,17 +13210,22 @@
             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.
          */
@@ -11664,7 +13716,7 @@
                 });
                 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) {
@@ -12700,8 +14752,8 @@
                         // 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,
@@ -14136,8 +16188,8 @@
                             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,
@@ -14559,6 +16611,19 @@
             // 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;
@@ -14609,6 +16674,16 @@
             }
             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.
@@ -14660,6 +16735,8 @@
             this.lastOrderFocus = null;
             this.allEIds.clear();
             this.lastFoundDateTimes.clear();
+            this.everFound.clear();
+            this.clearIndex();
             this.lastDateTime = null;
         }
         ReQueueAll() {
@@ -14670,22 +16747,193 @@
             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.
@@ -14698,8 +16946,6 @@
             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) &&
                 Cesium.Cartesian3.distance(this.lastOrderFocus.origin, focus.origin) < EntityGatherer.REORDER_MOVE_METRES) {
                 return;
@@ -14746,26 +16992,47 @@
             });
             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;
                     }
@@ -14801,7 +17068,7 @@
             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;
                     }
@@ -14816,19 +17083,22 @@
             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) {
@@ -14852,6 +17122,7 @@
             this.lastDateTime = rTime;
             (async () => {
                 this.runningTick = true;
+                this.placeStragglers();
                 let rerun = false;
                 try {
                     const handleResponse = async (requestedBatch, entities) => {
@@ -14864,6 +17135,13 @@
                                 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) {
@@ -14992,15 +17270,16 @@
                             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) {
@@ -15039,6 +17318,11 @@
     }
     // 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;
@@ -47784,7 +50068,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.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.
@@ -47804,6 +50088,9 @@ void main() {
     exports.VERSION = VERSION;
     exports.setENVIRONMENT = setENVIRONMENT;
     exports.getENVIRONMENT = getENVIRONMENT;
+    exports.ClusterItems = ClusterItems;
+    exports.PointClustering = PointClustering;
+    exports.PointClusterSize = PointClusterSize;
     exports.isStyleChanged = isStyleChanged;
     exports.isOutlineChanged = isOutlineChanged$1;
     exports.CesiumParabola = CesiumParabola;