bruce-cesium 6.6.4 → 6.6.6

package/dist/bruce-cesium.umd.js

@@ -2576,609 +2576,845 @@
         CesiumEntityStyler.Unhighlight = Unhighlight;
     })(exports.CesiumEntityStyler || (exports.CesiumEntityStyler = {}));
 
+    function isTurfAvailable() {
+        return window && window.turf != null;
+    }
     /**
-     * Utility for rendering parabolas between two points on the map.
+     * Util for simplifying geometry on the fly.
      */
-    class CesiumParabola {
-        get Disposed() {
-            return this.disposed;
-        }
-        set Hidden(value) {
-            this.hidden = value;
-        }
-        get curPos1() {
-            return this.pos1 instanceof Function ? this.pos1() : this.pos1;
+    var SimplifyGeometry;
+    (function (SimplifyGeometry) {
+        /**
+         * Returns the total number of points in the geometry.
+         * @param geometry
+         * @param limit number to count up to before returning.
+         * @returns
+         */
+        function CountPoints(geometry, limit) {
+            let count = 0;
+            const traverse = (geometry) => {
+                if (geometry.MultiGeometry) {
+                    for (let i = 0; i < geometry.MultiGeometry.length; i++) {
+                        traverse(geometry.MultiGeometry[i]);
+                        // Reached the limit, return.
+                        if (limit && count >= limit) {
+                            return;
+                        }
+                    }
+                }
+                else if (geometry.Polygon) {
+                    for (let i = 0; i < geometry.Polygon.length; i++) {
+                        const polygon = geometry.Polygon[i];
+                        count += BModels.Geometry.ParsePoints(polygon.LinearRing).length;
+                    }
+                }
+                else if (geometry.LineString) {
+                    count += BModels.Geometry.ParsePoints(geometry.LineString).length;
+                }
+                else if (geometry.Point) {
+                    count += 1;
+                }
+            };
+            traverse(geometry);
+            return count;
         }
-        get curPos2() {
-            return this.pos2 instanceof Function ? this.pos2() : this.pos2;
+        SimplifyGeometry.CountPoints = CountPoints;
+        /**
+         * Simplifies input geometry.
+         * This will turn it into GeoJSON, run it through turf, then back to Bruce geometry.
+         * @param geometry
+         */
+        function Simplify(entityId, geometry, tolerance) {
+            var _a;
+            if (!geometry || !isTurfAvailable() || !turf.simplify) {
+                return geometry;
+            }
+            // Convert to geojson so that we can interact with turf.
+            const gFeature = BModels.Geometry.ToGeoJsonFeature({
+                geometry: geometry
+            });
+            // Unkink the geometry.
+            // This removes overlapping polygons before we start merging and simplifying.
+            // Commented out because it has crashes and doesn't handle holes.
+            untangleFeature(gFeature);
+            // Union the geometry.
+            // This merges overlapping polygons.
+            unionFeature(gFeature);
+            // Simplify the geometry.
+            if (tolerance > 0) {
+                gFeature.geometry = turf.simplify(gFeature.geometry, {
+                    tolerance: tolerance,
+                    highQuality: true,
+                    mutate: true
+                });
+            }
+            // Converting back to Bruce geometry.
+            geometry = (_a = BModels.Geometry.FromGeoJson({
+                geoJson: gFeature
+            })) === null || _a === void 0 ? void 0 : _a.geometry;
+            return geometry;
         }
-        constructor(params) {
-            this.disposed = false;
-            this.color = "white";
-            this.width = 2;
-            this.duration = 10;
-            this.heightDistanceRatio = 0.25;
-            this.curPoints = [];
-            this.animateInterval = null;
-            this.retryTimeout = null;
-            this.hidden = false;
-            this.viewer = params.viewer;
-            this.pos1 = params.pos1;
-            this.pos2 = params.pos2;
-            if (params.color) {
-                this.color = params.color;
+        SimplifyGeometry.Simplify = Simplify;
+    })(SimplifyGeometry || (SimplifyGeometry = {}));
+    /**
+     * Runs through all found polygons and runs unkink through turf on them.
+     * @param feature
+     */
+    function untangleFeature(feature) {
+        // Collection to add to because the result might be multiple from an unkink.
+        const collection = {
+            geometries: [],
+            type: "GeometryCollection"
+        };
+        // Runs a dedupe and unkink on the coordinates.
+        // Returns if the coordinates were added to the collection.
+        const processCoordinates = (coords) => {
+            try {
+                // Dedupe the coordinates to avoid issues with unkink.
+                coords = dedupeCoordinates(coords);
+                const outer = [];
+                let inner = [];
+                // We'll unkink each ring separately as this is killing the holes when it is done as a whole.
+                // So we'll do it separate then recombine.
+                for (let i = 0; i < coords.length; i++) {
+                    const ring = coords[i];
+                    const unkink = turf.unkinkPolygon({
+                        type: "Polygon",
+                        coordinates: [ring]
+                    });
+                    if (unkink.type == "FeatureCollection") {
+                        let target = i == 0 ? outer : inner;
+                        for (let j = 0; j < unkink.features.length; j++) {
+                            const unkinked = unkink.features[j].geometry.coordinates;
+                            if (unkinked.length > 0) {
+                                target.push(unkinked[0]);
+                            }
+                        }
+                    }
+                    else {
+                        console.error("Unexpected unkink result.", unkink);
+                    }
+                }
+                // Recreate the rings and reapply to the collection.
+                if (outer.length > 0) {
+                    const combinedCoords = [outer[0]];
+                    for (let i = 0; i < inner.length; i++) {
+                        combinedCoords.push(inner[i]);
+                    }
+                    // Add the combined coordinates to the collection
+                    const polygon = {
+                        type: "Polygon",
+                        coordinates: combinedCoords
+                    };
+                    // Ensure right-hand rule is followed.
+                    ensureRightHandRule(polygon);
+                    // Add to the collection.
+                    collection.geometries.push(polygon);
+                    return true;
+                }
             }
-            if (!isNaN(params.width)) {
-                this.width = params.width;
+            catch (e) {
+                // console.error("Failed to unkink polygon.", e);
             }
-            if (!isNaN(params.duration)) {
-                this.duration = params.duration;
+            return false;
+        };
+        const processGeometry = (geometry) => {
+            let added = false;
+            if (geometry.type == "Polygon") {
+                added = processCoordinates(geometry.coordinates);
             }
-            if (!isNaN(params.heightDistanceRatio)) {
-                this.heightDistanceRatio = params.heightDistanceRatio;
+            else if (geometry.type == "MultiPolygon") {
+                for (let i = 0; i < geometry.coordinates.length; i++) {
+                    added = processCoordinates(geometry.coordinates[i]) || added;
+                }
             }
-            this.prepareEntities();
+            if (!added) {
+                // Adding original since we can't unkink it.
+                collection.geometries.push(geometry);
+            }
+        };
+        if (feature.geometry.type == "GeometryCollection") {
+            feature.geometry.geometries.forEach((geometry) => {
+                processGeometry(geometry);
+            });
         }
-        prepareEntities() {
-            const parabola = new Cesium.Entity({
-                polyline: {
-                    positions: new Cesium.CallbackProperty(() => {
-                        return this.curPoints;
-                    }, false),
-                    width: this.width,
-                    material: Cesium.Color.fromCssColorString(this.color),
-                    show: new Cesium.CallbackProperty(() => {
-                        return !this.hidden;
-                    }, false)
+        else {
+            processGeometry(feature.geometry);
+        }
+        // Re-assign the geometry.
+        if (collection.geometries.length == 1) {
+            feature.geometry = collection.geometries[0];
+        }
+        else {
+            feature.geometry = collection;
+        }
+    }
+    /**
+     * Runs through all found polygons and unions them using turf.
+     * Failed unions are ignored and the original is kept.
+     * @param feature
+     */
+    function unionFeature(feature) {
+        // Collection to add to because the result might be multiple from an unkink.
+        const collection = {
+            geometries: [],
+            type: "GeometryCollection"
+        };
+        // We'll turn each geometry into a feature and union them.
+        const tmpCollection = {
+            features: [],
+            type: "FeatureCollection"
+        };
+        if (feature.geometry.type == "GeometryCollection") {
+            feature.geometry.geometries.forEach((geometry) => {
+                if (geometry.type == "Polygon") {
+                    tmpCollection.features.push({
+                        type: "Feature",
+                        geometry: geometry,
+                        properties: {}
+                    });
                 }
-            });
-            const p1Entity = new Cesium.Entity({
-                position: new Cesium.CallbackProperty(() => {
-                    return this.curPoints.length ? this.curPoints[0] : new Cesium.Cartesian3();
-                }, false),
-                point: {
-                    heightReference: Cesium.HeightReference.NONE,
-                    pixelSize: this.width * 1.3,
-                    color: Cesium.Color.fromCssColorString(this.color),
-                    outlineColor: Cesium.Color.WHITE,
-                    outlineWidth: 2,
-                    show: new Cesium.CallbackProperty(() => {
-                        return !this.hidden;
-                    }, false)
+                else if (geometry.type == "MultiPolygon") {
+                    for (let i = 0; i < geometry.coordinates.length; i++) {
+                        tmpCollection.features.push({
+                            type: "Feature",
+                            geometry: {
+                                type: "Polygon",
+                                coordinates: geometry.coordinates[i]
+                            },
+                            properties: {}
+                        });
+                    }
                 }
-            });
-            const p2Entity = new Cesium.Entity({
-                position: new Cesium.CallbackProperty(() => {
-                    return this.curPoints.length ? this.curPoints[this.curPoints.length - 1] : new Cesium.Cartesian3();
-                }, false),
-                point: {
-                    heightReference: Cesium.HeightReference.NONE,
-                    pixelSize: this.width * 1.8,
-                    color: Cesium.Color.fromCssColorString(this.color),
-                    outlineColor: Cesium.Color.WHITE,
-                    outlineWidth: 2,
-                    show: new Cesium.CallbackProperty(() => {
-                        return !this.hidden;
-                    }, false)
+                // Only focusing on polygons.
+                else {
+                    collection.geometries.push(geometry);
                 }
             });
-            p1Entity.parent = parabola;
-            p2Entity.parent = parabola;
-            const siblings = [p1Entity, p2Entity];
-            this.parabola = parabola;
-            this.siblings = siblings;
-            // The parabola is hidden while this entity is not added.
-            // If we avoid adding it now, then the parent can control if the parabola is visible at first or not.
-            // this.viewer.entities.add(this.parabola);
-            this.viewer.entities.add(p1Entity);
-            this.viewer.entities.add(p2Entity);
         }
-        Animate() {
-            if (this.disposed) {
-                return null;
+        else if (feature.geometry.type == "Polygon") {
+            tmpCollection.features.push({
+                type: "Feature",
+                geometry: feature.geometry,
+                properties: {}
+            });
+        }
+        else if (feature.geometry.type == "MultiPolygon") {
+            for (let i = 0; i < feature.geometry.coordinates.length; i++) {
+                tmpCollection.features.push({
+                    type: "Feature",
+                    geometry: {
+                        type: "Polygon",
+                        coordinates: feature.geometry.coordinates[i]
+                    },
+                    properties: {}
+                });
             }
-            let retry = false;
-            if (!this.curPos1 || !this.curPos2 || !BModels.Cartes.ValidateCartes3(this.curPos1) || !BModels.Cartes.ValidateCartes3(this.curPos2)) {
-                retry = true;
+        }
+        // No polygons to union.
+        // Need at least 2 to union.
+        if (tmpCollection.features.length < 2) {
+            return;
+        }
+        // Now we'll union them.
+        try {
+            const union = turf.union(tmpCollection);
+            if (union.geometry.type == "Polygon") {
+                collection.geometries.push(union.geometry);
             }
-            let TOTAL_LENGTH = retry ? 0 : Cesium.Cartesian3.distance(this.curPos1, this.curPos2);
-            if (TOTAL_LENGTH <= 0) {
-                retry = true;
+            else if (union.geometry.type == "MultiPolygon") {
+                for (let i = 0; i < union.geometry.coordinates.length; i++) {
+                    collection.geometries.push({
+                        type: "Polygon",
+                        coordinates: union.geometry.coordinates[i]
+                    });
+                }
             }
-            if (retry) {
-                this.retryTimeout = setTimeout(() => {
-                    this.Animate();
-                }, 2000);
-                return {
-                    parabola: this.parabola,
-                    siblings: this.siblings
-                };
+            else {
+                // Returning early because the result is unexpected.
+                return;
             }
-            const RATE_PER_SECOND = 1000 / 40;
-            const SEC_DURATION = this.duration;
-            const HEIGHT_DISTANCE_RATIO = this.heightDistanceRatio;
-            let TOTAL_POINTS = null;
-            let POINT_LENGTH = null;
-            let TICK_LENGTH_INC = null;
-            // Updates TOTAL_POINTS, POINT_LENGTH, and TICK_LENGTH_INC based on current TOTAL_LENGTH and camera position.
-            // We want less points the further away the camera is.
-            const updateParams = () => {
-                var _a, _b;
-                // TODO: Do distance to parabola line instead.
-                const MIN_POINTS = 30;
-                let totalPoints = 80;
-                let cameraHeight = (_b = (_a = this.viewer.camera) === null || _a === void 0 ? void 0 : _a.positionCartographic) === null || _b === void 0 ? void 0 : _b.height;
-                if (isNaN(cameraHeight) || cameraHeight >= 100000) {
-                    totalPoints = MIN_POINTS;
-                }
-                else if (cameraHeight >= 10000) {
-                    totalPoints = 50;
-                }
-                else if (cameraHeight >= 1000) {
-                    totalPoints = 80;
-                }
-                else if (cameraHeight >= 100) {
-                    totalPoints = 100;
-                }
-                TOTAL_POINTS = Math.max(MIN_POINTS, Math.min(totalPoints, TOTAL_LENGTH * 0.1));
-                POINT_LENGTH = TOTAL_LENGTH / TOTAL_POINTS;
-                TICK_LENGTH_INC = SEC_DURATION == 0 ? TOTAL_LENGTH : TOTAL_POINTS / (RATE_PER_SECOND * SEC_DURATION);
-            };
-            updateParams();
-            let curPoint = 0;
-            let quadraticKey = null;
-            let quadratic = null;
-            let quadraticPreparing = false;
-            const prepareQuadratic = async () => {
-                if (quadraticPreparing) {
-                    return;
-                }
-                quadraticPreparing = true;
-                try {
-                    const p1 = this.curPos1;
-                    const p2 = this.curPos2;
-                    if (!p1 || !p2 || !BModels.Cartes.ValidateCartes3(p1) || !BModels.Cartes.ValidateCartes3(p2)) {
-                        return;
-                    }
-                    const height1 = Cesium.Cartographic.fromCartesian(p1).height;
-                    const height2 = Cesium.Cartographic.fromCartesian(p2).height;
-                    if (isNaN(height1) || isNaN(height2)) {
-                        return;
-                    }
-                    const totalHeight = height2 + height1;
-                    const curQuadraticKey = `${height1}-${height2}-${TOTAL_LENGTH}`;
-                    if (quadraticKey == curQuadraticKey) {
-                        return;
-                    }
-                    const points2d = [
-                        new Cesium.Cartesian2(0, height1),
-                        new Cesium.Cartesian2(TOTAL_LENGTH, height2)
-                    ];
-                    let vertexHeight = 0;
-                    // Flat line.
-                    if (HEIGHT_DISTANCE_RATIO == 0) {
-                        vertexHeight = totalHeight * 0.5;
-                    }
-                    else {
-                        const largestHeight = Math.max(height1, height2);
-                        vertexHeight = largestHeight + (TOTAL_LENGTH * HEIGHT_DISTANCE_RATIO);
-                    }
-                    points2d.push(new Cesium.Cartesian2(TOTAL_LENGTH * 0.5, vertexHeight));
-                    const calcQuadratic = (points) => {
-                        // Swaps position of two rows in matrix.
-                        function swapRows(matrix, rowAIndex, rowBIndex) {
-                            const rowAVal = matrix[rowAIndex];
-                            matrix[rowAIndex] = matrix[rowBIndex];
-                            matrix[rowBIndex] = rowAVal;
-                            return matrix;
-                        }
-                        // Zeros rowA at colIndex by subtracting a multiplied rowB from it.
-                        function reduceMatrixRowByRow(matrix, zeroingIndex, parentIndex, colIndex) {
-                            const zeroRow = matrix[zeroingIndex];
-                            const parentRow = matrix[parentIndex];
-                            if (zeroRow[colIndex] == 0) {
-                                return matrix;
-                            }
-                            else if (parentRow[colIndex] == 0) {
-                                matrix = swapRows(matrix, parentIndex, zeroingIndex);
-                                return divideMatrixRow(matrix, parentIndex, colIndex);
-                            }
-                            // rowAIndex colIndex / rowBIndex colIndex = factor;
-                            let factor = zeroRow[colIndex] / parentRow[colIndex];
-                            for (let i = 0; i < zeroRow.length; i++) {
-                                if (i >= colIndex) {
-                                    zeroRow[i] -= parentRow[i] * factor;
-                                }
-                            }
-                            return matrix;
-                        }
-                        // Makes a given row column equal 1 by diving while row by that column.
-                        function divideMatrixRow(matrix, rowIndex, colIndex) {
-                            const row = matrix[rowIndex];
-                            const colValue = row[colIndex];
-                            for (let i = 0; i < row.length; i++) {
-                                if (i >= colIndex) {
-                                    row[i] /= colValue;
-                                }
-                            }
-                            return matrix;
-                        }
-                        // Returns initial matrix for calculating a, b and c for quadratic formula from given points.
-                        function matrixFromPoints(points) {
-                            const rows = [];
-                            const constructRow = (point) => {
-                                rows.push([
-                                    -Math.pow(point.x, 2),
-                                    point.x,
-                                    1,
-                                    point.y
-                                ]);
-                            };
-                            for (let i = 0; i < points.length; i++) {
-                                constructRow(points[i]);
-                            }
-                            return rows;
-                        }
-                        const initialMatrix = matrixFromPoints(points);
-                        const step1Matrix = reduceMatrixRowByRow(initialMatrix, 1, 0, 0);
-                        const step2Matrix = reduceMatrixRowByRow(step1Matrix, 2, 0, 0);
-                        const step3Matrix = reduceMatrixRowByRow(step2Matrix, 2, 1, 1);
-                        const step4Matrix = reduceMatrixRowByRow(step3Matrix, 0, 1, 1);
-                        const step5Matrix = reduceMatrixRowByRow(step4Matrix, 0, 2, 2);
-                        const step6Matrix = reduceMatrixRowByRow(step5Matrix, 1, 2, 2);
-                        const a = step6Matrix[0][3];
-                        const b = step6Matrix[1][3];
-                        const c = step6Matrix[2][3];
-                        return { a: a, b: b, c: c };
-                    };
-                    quadratic = calcQuadratic(points2d);
+        }
+        catch (e) {
+            // console.error("Failed to union polygons.", e);
+            return;
+        }
+        // Re-assign the geometry.
+        if (collection.geometries.length == 1) {
+            feature.geometry = collection.geometries[0];
+        }
+        else {
+            feature.geometry = collection;
+        }
+    }
+    function dedupeCoordinates(inputCoords) {
+        return inputCoords.map(ring => {
+            if (ring.length < 2) {
+                return ring;
+            }
+            const dedupeCoords = [];
+            const uniqueCoords = new Set();
+            // Dedupe the points.
+            ring.forEach(coord => {
+                const key = coord.join(',');
+                if (!uniqueCoords.has(key)) {
+                    uniqueCoords.add(key);
+                    dedupeCoords.push(coord);
                 }
-                catch (e) {
-                    console.error(e);
+            });
+            // Make sure the last point matches the first.
+            if (dedupeCoords.length > 1) {
+                if (dedupeCoords[0][0] != dedupeCoords[dedupeCoords.length - 1][0] ||
+                    dedupeCoords[0][1] != dedupeCoords[dedupeCoords.length - 1][1]) {
+                    dedupeCoords.push(dedupeCoords[0]);
                 }
-                finally {
-                    quadraticPreparing = false;
-                }
-            };
-            const getPosition = (increment) => {
-                if (!quadratic) {
-                    return null;
-                }
-                let lengthAcross = POINT_LENGTH * increment;
-                if (lengthAcross > TOTAL_LENGTH) {
-                    lengthAcross = TOTAL_LENGTH;
-                }
-                const getParabolaYFromX = (x, quadLetters) => {
-                    let a = quadLetters.a;
-                    let b = quadLetters.b;
-                    let c = quadLetters.c;
-                    return (-a * Math.pow(x, 2)) + (b * x) + c;
-                };
-                const { point: pos3d } = exports.DrawingUtils.PointAcrossPolyline({
-                    viewer: this.viewer,
-                    distance: lengthAcross,
-                    posses: [this.curPos1, this.curPos2]
-                });
-                const point = Cesium.Cartographic.fromCartesian(pos3d);
-                const posHeight = getParabolaYFromX(lengthAcross, quadratic);
-                return Cesium.Cartesian3.fromRadians(point.longitude, point.latitude, posHeight);
-            };
-            const updatePoints = () => {
-                if (!quadratic) {
-                    return;
-                }
-                const increment = Math.floor(curPoint);
-                const chips = curPoint - Math.floor(curPoint);
-                const posses = [];
-                posses.push(getPosition(0));
-                const addLast = increment >= TOTAL_POINTS;
-                const totalCycles = addLast ? increment + 1 : increment;
-                for (let i = 0; i < totalCycles; i++) {
-                    posses.push(getPosition(i));
-                }
-                if (chips) {
-                    posses.push(getPosition(increment + chips));
-                }
-                if (posses.find(x => !x || !BModels.Cartes.ValidateCartes3(x))) {
-                    return;
-                }
-                this.curPoints = posses;
-            };
-            let lastTickDate = new Date();
-            let finished = false;
-            const doTick = () => {
-                const curDate = new Date();
-                const seconds = (curDate.getTime() - lastTickDate.getTime()) / 1000;
-                const ticks = seconds * RATE_PER_SECOND;
-                if (!isNaN(ticks) && ticks >= 1) {
-                    lastTickDate = curDate;
-                    const p1 = this.curPos1;
-                    const p2 = this.curPos2;
-                    const newLength = p1 && p2 ? Cesium.Cartesian3.distance(p1, p2) : -1;
-                    if (newLength > 0 && newLength != TOTAL_LENGTH) {
-                        TOTAL_LENGTH = newLength;
-                        updateParams();
-                    }
-                    prepareQuadratic();
-                    if (quadratic) {
-                        if (curPoint < TOTAL_POINTS) {
-                            curPoint += (TICK_LENGTH_INC * ticks);
-                        }
-                        updatePoints();
-                    }
-                    this.viewer.scene.requestRender();
-                    if (curPoint >= TOTAL_POINTS && !finished) {
-                        finished = true;
-                        // We can make the interval update super slow now.
-                        // We keep it updating in case the positions move.
-                        clearInterval(this.animateInterval);
-                        this.animateInterval = setInterval(doTick, 3000);
-                    }
-                }
-            };
-            this.animateInterval = setInterval(doTick, RATE_PER_SECOND);
-            return {
-                parabola: this.parabola,
-                siblings: this.siblings
-            };
+            }
+            return dedupeCoords;
+        });
+    }
+    function ensureRightHandRule(polygon) {
+        // Ensure the outer ring follows the right-hand rule
+        if (polygon.coordinates.length > 0) {
+            const outerRing = polygon.coordinates[0];
+            if (isClockwise(outerRing)) {
+                polygon.coordinates[0] = outerRing.reverse();
+            }
         }
-        Dispose() {
-            this.disposed = true;
-            clearTimeout(this.retryTimeout);
-            clearInterval(this.animateInterval);
-            const cEntities = [
-                this.parabola
-            ].concat(this.siblings);
-            cEntities.forEach(e => {
-                if (e && this.viewer.entities.contains(e)) {
-                    this.viewer.entities.remove(e);
-                }
-            });
+        // Ensure any inner rings (holes) follow the right-hand rule
+        for (let i = 1; i < polygon.coordinates.length; i++) {
+            const innerRing = polygon.coordinates[i];
+            if (!isClockwise(innerRing)) {
+                polygon.coordinates[i] = innerRing.reverse();
+            }
+        }
+    }
+    function isClockwise(ring) {
+        let sum = 0;
+        for (let i = 0; i < ring.length - 1; i++) {
+            const p1 = ring[i];
+            const p2 = ring[i + 1];
+            sum += (p2[0] - p1[0]) * (p2[1] + p1[1]);
         }
+        return sum > 0;
     }
 
-    function colorToCColor(color) {
-        return new Cesium.Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
+    function OnNextCRender(viewer, callback) {
+        const removal = viewer.scene.postRender.addEventListener(() => {
+            removal();
+            callback();
+        });
     }
-    async function getStyle(api, typeId, styleId) {
-        let style = null;
-        if (styleId && styleId != -1) {
-            try {
-                style = (await BModels.Style.Get({
-                    api,
-                    styleId
-                })).style;
-            }
-            // Probably deleted.
-            catch (e) {
-                console.error(e);
+    function GetCValue(viewer, obj) {
+        if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
+            let date = viewer.scene.lastRenderTime;
+            if (!date) {
+                date = viewer.clock.currentTime;
             }
+            return obj.getValue(date);
         }
-        if (!style && typeId) {
-            const { entityType: type } = await BModels.EntityType.Get({
-                api,
-                entityTypeId: typeId
-            });
-            if (type["DisplaySetting.ID"]) {
-                try {
-                    style = (await BModels.Style.Get({
-                        api,
-                        styleId: type["DisplaySetting.ID"]
-                    })).style;
-                }
-                catch (e) {
-                    let hideError = false;
-                    // TODO: we need a util for extracting code + message rather than writing all this every time.
-                    if (e && typeof e == "object" && e.ERROR) {
-                        const error = e.ERROR;
-                        const code = error && typeof error == "object" ? error.Code : "";
-                        // Avoiding logging a common error.
-                        // This happens when rendering entities that don't have records.
-                        hideError = String(code).toLowerCase() == "notfound";
-                    }
-                    if (!hideError) {
-                        console.error(e);
-                    }
-                }
+        return obj;
+    }
+    function ColorToCColor(color) {
+        return new Cesium.Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
+    }
+    /**
+     * Removes duplicate points in a row and returns a new array.
+     * Passed array is not mutated.
+     * @param posses
+     */
+    function CullDuplicateCPosses(posses) {
+        const newPosses = [];
+        let lastPos = null;
+        for (let i = 0; i < posses.length; i++) {
+            const pos = posses[i];
+            // Avoiding 'Cesium.Cartesian3.equals' because passed data might be just a json blob in certain cases.
+            if (pos && (!lastPos || (pos.x != lastPos.x || pos.y != lastPos.y || pos.z != lastPos.z))) {
+                newPosses.push(pos);
+                lastPos = pos;
             }
         }
-        return style;
+        return newPosses;
     }
-    var RelationRenderEngine;
-    (function (RelationRenderEngine) {
-        function GetRenderGroupId(relation) {
-            return `${relation["Related.Entity.ID"]}-${relation["Principal.Entity.ID"]}-${relation["Relation.Type.ID"]}`;
+    /**
+     * Returns if the given positions are equal.
+     * @param a
+     * @param b
+     */
+    function CompareCPosses(a, b) {
+        // Same reference.
+        if (a == b) {
+            return true;
         }
-        RelationRenderEngine.GetRenderGroupId = GetRenderGroupId;
-        async function Render(params) {
-            const { apiGetter, viewer, visualRegister, menuItemId, relations } = params;
-            const api = apiGetter.getApi(apiGetter.accountId);
-            const rendered = {};
-            let neededEntityIdsIds = [];
-            for (let i = 0; i < relations.length; i++) {
-                const relation = relations[i];
-                if (relation["Principal.Entity.ID"]) {
-                    neededEntityIdsIds.push(relation["Principal.Entity.ID"]);
-                }
-                if (relation["Related.Entity.ID"]) {
-                    neededEntityIdsIds.push(relation["Related.Entity.ID"]);
-                }
-                if (relation["Data.Entity.ID"]) {
-                    neededEntityIdsIds.push(relation["Data.Entity.ID"]);
-                }
+        // Different lengths or one is null.
+        if ((!a || !b) || (a.length != b.length)) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            const posA = a[i];
+            const posB = b[i];
+            // Null detected.
+            if (!posA || !posB) {
+                return false;
             }
-            // Turn the set unique.
-            neededEntityIdsIds = neededEntityIdsIds.filter((v, i, a) => a.indexOf(v) === i);
-            // Get all entities in one go.
-            let entities = (await BModels.Entity.GetListByIds({
-                entityIds: neededEntityIdsIds,
-                api: apiGetter.getApi(),
-                migrated: true,
-                maxSearchTimeSec: 60 * 2
-            })).entities;
-            // Create a map for quick reference.
-            const entitiesMap = {};
-            for (let i = 0; i < entities.length; i++) {
-                const entity = entities[i];
-                entitiesMap[entity.Bruce.ID] = entity;
+            // Position values don't match.
+            if (!BModels.Cartes.IsEqualCartes3(posA, posB)) {
+                return false;
             }
-            entities = null;
-            // Gather needed relationship types.
-            // Right now this means just getting the full list.
-            const relationTypes = (await BModels.EntityRelationType.GetList({
-                api
-            })).relationTypes;
-            const relationTypesMap = {};
-            for (let i = 0; i < relationTypes.length; i++) {
-                const relationType = relationTypes[i];
-                relationTypesMap[relationType.ID] = relationType;
+        }
+        return true;
+    }
+    /**
+     * Returns if the given polygon hierarchies are equal.
+     * @param a
+     * @param b
+     */
+    function CompareCPolygonHierarchies(a, b) {
+        // Same reference.
+        if (a == b) {
+            return true;
+        }
+        // Different lengths or one is null.
+        if ((!a || !b) || (a.positions.length != b.positions.length)) {
+            return false;
+        }
+        // Positions don't match.
+        if (!CompareCPosses(a.positions, b.positions)) {
+            return false;
+        }
+        const holes = a.holes;
+        const bHoles = b.holes;
+        // Number of holes don't match.
+        if (holes.length != bHoles.length) {
+            return false;
+        }
+        for (let i = 0; i < holes.length; i++) {
+            // Hole positions don't match.
+            if (!CompareCPosses(holes[i].positions, bHoles[i].positions)) {
+                return false;
             }
-            for (let i = 0; i < relations.length; i++) {
-                try {
-                    const relation = relations[i];
-                    const fromEntity = entitiesMap[relation["Principal.Entity.ID"]];
-                    const toEntity = entitiesMap[relation["Related.Entity.ID"]];
-                    const dataEntity = relation["Data.Entity.ID"] ? entitiesMap[relation["Data.Entity.ID"]] : null;
-                    const relationType = relationTypesMap[relation["Relation.Type.ID"]];
-                    const style = await getStyle(api, relationType === null || relationType === void 0 ? void 0 : relationType["Relation.EntityType.ID"], Number(relationType === null || relationType === void 0 ? void 0 : relationType.EntityDisplaySettingID));
-                    const cEntity = await Parabola.Render({
-                        dataEntity,
-                        fromEntity,
-                        relation,
-                        style,
-                        toEntity,
-                        viewer,
-                        visualRegister,
-                        apiGetter
+        }
+        return true;
+    }
+
+    const CESIUM_INSPECTOR_KEY = "_nextspace_inspector";
+    const CESIUM_TIMELINE_KEY = "_nextspace_timeline";
+    const CESIUM_TIMELINE_LIVE_KEY = "_nextspace_timeline_live";
+    const CESIUM_TIMELINE_LIVE_PADDING_KEY = "_nextspace_timeline_live_padding";
+    const CESIUM_TIMELINE_INTERVAL_KEY = "_nextspace_timeline_interval";
+    const CESIUM_MODEL_SPACE_KEY = "_nextspace_model_space";
+    const DEFAULT_LIVE_PADDING_SECONDS = 30 * 60;
+    (function (ViewUtils) {
+        function GatherLegacyMapTiles(params) {
+            const viewer = params.viewer;
+            const collection = viewer.imageryLayers;
+            const tiles = [];
+            for (let i = 0; i < collection.length; i++) {
+                const layer = collection.get(i);
+                if (layer._bName) {
+                    tiles.push({
+                        alpha: layer.alpha,
+                        brightness: layer.brightness,
+                        contrast: layer.contrast,
+                        hue: layer.hue,
+                        saturation: layer.saturation,
+                        gamma: layer.gamma,
+                        title: layer._bName,
                     });
-                    cEntity._renderGroup = GetRenderGroupId(relation);
-                    rendered[GetRenderGroupId(relation)] = cEntity;
-                }
-                catch (e) {
-                    console.error(e);
                 }
             }
-            return rendered;
+            return {
+                imagery: tiles.reverse()
+            };
         }
-        RelationRenderEngine.Render = Render;
-        let Parabola;
-        (function (Parabola) {
-            async function Render(params) {
-                var _a;
-                const style = (_a = params.style) === null || _a === void 0 ? void 0 : _a.Settings;
-                const entity = params.dataEntity;
-                const bColor = (style === null || style === void 0 ? void 0 : style.lineColor) ? BModels.Calculator.GetColor(style === null || style === void 0 ? void 0 : style.lineColor, entity, []) : null;
-                const cColor = bColor ? colorToCColor(bColor) : Cesium.Color.WHITE;
-                let width = EnsureNumber((style === null || style === void 0 ? void 0 : style.lineWidth) ? BModels.Calculator.GetNumber(style === null || style === void 0 ? void 0 : style.lineWidth, entity, []) : 4, 4);
-                if (width < 1) {
-                    width = 1;
-                }
-                const duration = EnsureNumber((style === null || style === void 0 ? void 0 : style.duration) ? BModels.Calculator.GetNumber(style === null || style === void 0 ? void 0 : style.duration, entity, []) : 2, 2);
-                const hDistanceRatio = EnsureNumber((style === null || style === void 0 ? void 0 : style.heightDistanceRatio) ? BModels.Calculator.GetNumber(style === null || style === void 0 ? void 0 : style.heightDistanceRatio, entity, []) : 0.25, 0.25);
-                let fromPos = null;
-                let toPos = null;
-                let updatingPosses = false;
-                const updatePosses = async () => {
-                    if (updatingPosses) {
-                        return;
-                    }
-                    updatingPosses = true;
-                    try {
-                        const fromData = await exports.EntityUtils.GetLocation({
-                            samples: [{
-                                    entity: params.fromEntity,
-                                    entityId: params.fromEntity.Bruce.ID,
-                                    heightRef: Cesium.HeightReference.CLAMP_TO_GROUND,
-                                    returnHeightRef: Cesium.HeightReference.NONE
-                                }],
-                            viewer: params.viewer,
-                            visualRegister: params.visualRegister,
-                            api: params.apiGetter.getApi()
-                        });
-                        fromPos = fromData.pos3d;
-                        const toData = await exports.EntityUtils.GetLocation({
-                            samples: [{
-                                    entity: params.toEntity,
-                                    entityId: params.toEntity.Bruce.ID,
-                                    heightRef: Cesium.HeightReference.CLAMP_TO_GROUND,
-                                    returnHeightRef: Cesium.HeightReference.NONE
-                                }],
-                            viewer: params.viewer,
-                            visualRegister: params.visualRegister,
-                            api: params.apiGetter.getApi()
+        ViewUtils.GatherLegacyMapTiles = GatherLegacyMapTiles;
+        function GatherLegacyTerrainTile(params) {
+            const viewer = params.viewer;
+            const enabled = viewer.terrainProvider;
+            if (enabled === null || enabled === void 0 ? void 0 : enabled._bName) {
+                return {
+                    terrain: enabled._bName
+                };
+            }
+            return {
+                terrain: "flatterrain"
+            };
+        }
+        ViewUtils.GatherLegacyTerrainTile = GatherLegacyTerrainTile;
+        function GatherMapTiles(params) {
+            const viewer = params.viewer;
+            const imagery = viewer.imageryLayers;
+            const tiles = [];
+            for (let i = 0; i < imagery.length; i++) {
+                const provider = imagery.get(i);
+                if (provider._bMeta) {
+                    const idCombo = provider._bMeta.accountId + provider._bMeta.tilesetId;
+                    if (!tiles.find(x => x.accountId + x.tilesetId === idCombo)) {
+                        tiles.push({
+                            accountId: provider._bMeta.accountId,
+                            tilesetId: provider._bMeta.tilesetId,
+                            alpha: provider.alpha,
+                            brightness: provider.brightness,
+                            contrast: provider.contrast,
+                            hue: provider.hue,
+                            saturation: provider.saturation,
+                            gamma: provider.gamma
                         });
-                        toPos = toData.pos3d;
-                    }
-                    catch (e) {
-                        console.error(e);
                     }
-                    updatingPosses = false;
-                };
-                updatePosses();
-                const parabola = new CesiumParabola({
-                    viewer: params.viewer,
-                    pos1: () => fromPos,
-                    pos2: () => toPos,
-                    color: cColor.toCssColorString(),
-                    width: width,
-                    duration: duration,
-                    heightDistanceRatio: hDistanceRatio
-                });
-                parabola.Hidden = true;
-                const cEntities = parabola.Animate();
-                const cEntity = cEntities.parabola;
-                cEntity._siblingGraphics = [];
-                for (let i = 0; i < cEntities.siblings.length; i++) {
-                    const sibling = cEntities.siblings[i];
-                    cEntity._siblingGraphics.push(sibling);
                 }
-                let updateInterval = setInterval(() => {
-                    var _a;
-                    if (!((_a = params.viewer) === null || _a === void 0 ? void 0 : _a.scene) ||
-                        params.viewer.isDestroyed() ||
-                        (!parabola || parabola.Disposed)) {
-                        clearInterval(updateInterval);
-                        parabola.Dispose();
-                        return;
-                    }
-                    if (parabola) {
-                        const visible = cEntity && cEntity.show != false && params.viewer.entities.contains(cEntity);
-                        parabola.Hidden = !visible;
-                    }
-                    updatePosses();
-                    params.viewer.scene.requestRender();
-                }, 1000);
-                let disposed = false;
-                cEntity._dispose = () => {
-                    if (disposed) {
-                        return;
-                    }
-                    disposed = true;
-                    clearInterval(updateInterval);
-                    if (parabola) {
-                        parabola.Dispose();
+            }
+            return {
+                imagery: tiles
+            };
+        }
+        ViewUtils.GatherMapTiles = GatherMapTiles;
+        function GatherTerrainTile(params) {
+            const viewer = params.viewer;
+            const provider = viewer.terrainProvider;
+            if (provider === null || provider === void 0 ? void 0 : provider._bMeta) {
+                return {
+                    terrain: {
+                        accountId: provider._bMeta.accountId,
+                        tilesetId: provider._bMeta.tilesetId,
                     }
                 };
-                return cEntity;
             }
-            Parabola.Render = Render;
-        })(Parabola = RelationRenderEngine.Parabola || (RelationRenderEngine.Parabola = {}));
-    })(RelationRenderEngine || (RelationRenderEngine = {}));
-
-    /**
-     * Returns cesium property's value.
-     * This will check if it's one that changes over time, or just a fixed value.
-     * Eg: const pos3d = getValue<Cesium.Cartesian3>(cViewer, cEntity.point.position);
-     * @param viewer
-     * @param obj
-    */
-    function getValue(viewer, obj) {
-        if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
-            let date = viewer.scene.lastRenderTime;
-            if (!date) {
-                date = viewer.clock.currentTime;
+            else if (provider instanceof Cesium.EllipsoidTerrainProvider) {
+                return {
+                    terrain: {
+                        tilesetId: BModels.ProjectViewTile.EDefaultTerrain.FlatTerrain,
+                        accountId: null
+                    }
+                };
             }
-            return obj.getValue(date);
+            return null;
+        }
+        ViewUtils.GatherTerrainTile = GatherTerrainTile;
+        function SetTerrainWireframeStatus(params) {
+            if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
+                const InspectorClass = Cesium.CesiumInspector;
+                if (InspectorClass) {
+                    const inspector = new InspectorClass(document.createElement("div"), params.viewer.scene);
+                    inspector.container.style.display = "none";
+                    params.viewer[CESIUM_INSPECTOR_KEY] = inspector;
+                    params.viewer.scene.requestRender();
+                }
+            }
+            if (params.viewer[CESIUM_INSPECTOR_KEY]) {
+                params.viewer[CESIUM_INSPECTOR_KEY].viewModel.wireframe = params.status;
+            }
+        }
+        ViewUtils.SetTerrainWireframeStatus = SetTerrainWireframeStatus;
+        function GetTerrainWireframeStatus(params) {
+            var _a, _b;
+            if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
+                return false;
+            }
+            return (_b = (_a = params.viewer[CESIUM_INSPECTOR_KEY]) === null || _a === void 0 ? void 0 : _a.viewModel) === null || _b === void 0 ? void 0 : _b.wireframe;
+        }
+        ViewUtils.GetTerrainWireframeStatus = GetTerrainWireframeStatus;
+        /**
+         * Changes between perspective and orthographic view.
+         * When Cesium stops being bad at picking positions in 2d mode we'll use the flat earth mode instead.
+         * @param params
+         */
+        function Set2dStatus(params) {
+            const { viewer, status: is2d, moveCamera } = params;
+            const curLens2d = viewer.camera.frustum instanceof Cesium.OrthographicFrustum;
+            if (curLens2d && !is2d) {
+                OnNextCRender(viewer, () => {
+                    viewer.camera.switchToPerspectiveFrustum();
+                    viewer.scene.screenSpaceCameraController.enableTilt = true;
+                });
+                viewer.scene.requestRender();
+            }
+            else if (!curLens2d && is2d) {
+                OnNextCRender(viewer, () => {
+                    viewer.camera.switchToOrthographicFrustum();
+                    viewer.scene.screenSpaceCameraController.enableTilt = false;
+                });
+                if (moveCamera != false) {
+                    try {
+                        // Face camera downwards to make it look 2d.
+                        // We want to try make it look at the center-point of the current view.
+                        // If center cannot be calculated then we'll simply raise the camera and face it downwards.
+                        const scene = viewer.scene;
+                        const windowPosition = new Cesium.Cartesian2(scene.canvas.clientWidth / 2, scene.canvas.clientHeight / 2);
+                        const ray = viewer.camera.getPickRay(windowPosition);
+                        const intersection = scene.globe.pick(ray, scene);
+                        let center;
+                        if (Cesium.defined(intersection)) {
+                            center = Cesium.Cartographic.fromCartesian(intersection);
+                        }
+                        // Use current camera position if we can't calculate the center.
+                        else {
+                            center = Cesium.Cartographic.fromCartesian(viewer.camera.position);
+                            center.height = 0;
+                        }
+                        center.height = viewer.camera.positionCartographic.height + 100;
+                        viewer.camera.setView({
+                            destination: Cesium.Cartographic.toCartesian(center),
+                            orientation: {
+                                heading: 0.0,
+                                pitch: Cesium.Math.toRadians(-90.0),
+                                roll: 0.0
+                            }
+                        });
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+                viewer.scene.requestRender();
+            }
+        }
+        ViewUtils.Set2dStatus = Set2dStatus;
+        function Get2dStatus(params) {
+            const { viewer } = params;
+            return viewer.camera.frustum instanceof Cesium.OrthographicFrustum;
+        }
+        ViewUtils.Get2dStatus = Get2dStatus;
+        function SetLockedCameraStatus(params) {
+            const { viewer, status } = params;
+            const scene = viewer === null || viewer === void 0 ? void 0 : viewer.scene;
+            if (!scene) {
+                return;
+            }
+            if (status) {
+                scene.screenSpaceCameraController.enableInputs = false;
+                scene.screenSpaceCameraController.enableTranslate = false;
+                scene.screenSpaceCameraController.enableZoom = false;
+                scene.screenSpaceCameraController.enableRotate = false;
+                scene.screenSpaceCameraController.enableTilt = false;
+            }
+            else {
+                scene.screenSpaceCameraController.enableInputs = true;
+                scene.screenSpaceCameraController.enableTranslate = true;
+                scene.screenSpaceCameraController.enableZoom = true;
+                scene.screenSpaceCameraController.enableRotate = true;
+                if (!ViewUtils.Get2dStatus({ viewer })) {
+                    scene.screenSpaceCameraController.enableTilt = true;
+                }
+            }
+            viewer.scene.requestRender();
+        }
+        ViewUtils.SetLockedCameraStatus = SetLockedCameraStatus;
+        function GetLockedCameraStatus(params) {
+            var _a;
+            const scene = (_a = params.viewer) === null || _a === void 0 ? void 0 : _a.scene;
+            if (!scene) {
+                return false;
+            }
+            return !scene.screenSpaceCameraController.enableTranslate;
+        }
+        ViewUtils.GetLockedCameraStatus = GetLockedCameraStatus;
+        /**
+         * Returns the current camera time and related settings.
+         * @param params
+         * @returns
+         */
+        function GetTimeDetails(params) {
+            const { viewer } = params;
+            const clock = viewer.clock;
+            return {
+                animationSpeed: clock.multiplier,
+                isAnimating: clock.shouldAnimate,
+                startTime: clock.startTime,
+                startTimeIso: clock.startTime.toString(),
+                currentTime: clock.currentTime,
+                currentTimeIso: clock.currentTime.toString(),
+                stopTime: clock.stopTime,
+                stopTimeIso: clock.stopTime.toString(),
+                areCesiumValues: clock[CESIUM_TIMELINE_KEY] != true,
+                isLive: clock[CESIUM_TIMELINE_LIVE_KEY] == true,
+                livePaddingSeconds: clock[CESIUM_TIMELINE_LIVE_PADDING_KEY] || DEFAULT_LIVE_PADDING_SECONDS
+            };
+        }
+        ViewUtils.GetTimeDetails = GetTimeDetails;
+        /**
+         * Sets the Cesium clock values.
+         * If a value is not provided, then 'areCesiumValues' checked to see if the values are Cesium values.
+         * If they're currently Cesium set values then our defaults are used.
+         * @param params
+         */
+        function SetTimeDetails(params) {
+            let { viewer, animationSpeed, isAnimating, startTime, currentTime, stopTime, startTimeIso, stopTimeIso, currentTimeIso, isLive, livePaddingSeconds } = params;
+            const clock = viewer.clock;
+            if (startTime) {
+                clock.startTime = startTime;
+            }
+            else if (startTimeIso) {
+                const startDate = Cesium.JulianDate.fromIso8601(startTimeIso);
+                if (startDate) {
+                    clock.startTime = startDate;
+                }
+            }
+            if (currentTime) {
+                clock.currentTime = currentTime;
+            }
+            else if (currentTimeIso) {
+                const currentDate = Cesium.JulianDate.fromIso8601(currentTimeIso);
+                if (currentDate) {
+                    clock.currentTime = currentDate;
+                }
+            }
+            if (stopTime) {
+                clock.stopTime = stopTime;
+            }
+            else if (stopTimeIso) {
+                const stopDate = Cesium.JulianDate.fromIso8601(stopTimeIso);
+                if (stopDate) {
+                    clock.stopTime = stopDate;
+                }
+            }
+            clock.clockRange = Cesium.ClockRange.LOOP_STOP;
+            const areCesiumValues = clock[CESIUM_TIMELINE_KEY] != true;
+            if (areCesiumValues) {
+                if (isNaN(animationSpeed) || animationSpeed == null) {
+                    animationSpeed = 1;
+                }
+                if (isAnimating == null) {
+                    isAnimating = false;
+                }
+                if (isLive == null) {
+                    isLive = false;
+                }
+                if (livePaddingSeconds == null) {
+                    livePaddingSeconds = DEFAULT_LIVE_PADDING_SECONDS;
+                }
+            }
+            if (!isNaN(animationSpeed) && animationSpeed != null) {
+                clock.multiplier = animationSpeed;
+            }
+            if (isAnimating != null) {
+                clock.shouldAnimate = isAnimating;
+            }
+            viewer.scene.requestRender();
+            clock[CESIUM_TIMELINE_KEY] = true;
+            if (livePaddingSeconds != null) {
+                clock[CESIUM_TIMELINE_LIVE_PADDING_KEY] = livePaddingSeconds || DEFAULT_LIVE_PADDING_SECONDS;
+            }
+            if (isLive != null) {
+                clock[CESIUM_TIMELINE_LIVE_KEY] = params.isLive == true;
+            }
+            if (clock[CESIUM_TIMELINE_LIVE_KEY]) {
+                startLive(viewer);
+            }
+            else {
+                stopLive(viewer);
+            }
+        }
+        ViewUtils.SetTimeDetails = SetTimeDetails;
+        function startLive(viewer) {
+            const doUpdate = () => {
+                if (!viewer || viewer.isDestroyed() || !viewer.scene) {
+                    stopLive(viewer);
+                    return;
+                }
+                // Get the current settings.
+                const tDetails = GetTimeDetails({ viewer });
+                const clock = viewer.clock;
+                if (clock) {
+                    clock.shouldAnimate = true;
+                    clock.multiplier = 1;
+                    clock.currentTime = Cesium.JulianDate.now();
+                    clock.startTime = Cesium.JulianDate.addSeconds(clock.currentTime, -tDetails.livePaddingSeconds, new Cesium.JulianDate());
+                    clock.stopTime = Cesium.JulianDate.addSeconds(clock.currentTime, tDetails.livePaddingSeconds, new Cesium.JulianDate());
+                    clock.clockRange = Cesium.ClockRange.UNBOUNDED;
+                }
+            };
+            if (viewer[CESIUM_TIMELINE_INTERVAL_KEY]) {
+                doUpdate();
+                return;
+            }
+            // We'll start an interval that occasionally updates the Cesium clock to stay in the desired settings.
+            // Since it moves live (1 second per second), we don't have to worry about the ranges being out of date quickly.
+            viewer[CESIUM_TIMELINE_INTERVAL_KEY] = setInterval(() => {
+                doUpdate();
+            }, 800);
+            viewer[CESIUM_TIMELINE_LIVE_KEY] = true;
+            // Initial update.
+            doUpdate();
+        }
+        function stopLive(viewer) {
+            if (!viewer) {
+                return;
+            }
+            let interval = viewer[CESIUM_TIMELINE_INTERVAL_KEY];
+            if (interval) {
+                clearInterval(interval);
+                viewer[CESIUM_TIMELINE_INTERVAL_KEY] = null;
+            }
+            viewer[CESIUM_TIMELINE_LIVE_KEY] = false;
+        }
+        function SetGlobeDetails(params) {
+            let { viewer, hidden, baseColor } = params;
+            const scene = viewer === null || viewer === void 0 ? void 0 : viewer.scene;
+            if (!(scene === null || scene === void 0 ? void 0 : scene.globe)) {
+                return;
+            }
+            if (hidden == null) {
+                hidden = !scene.globe.show;
+            }
+            else {
+                scene.globe.show = !hidden;
+            }
+            if (baseColor == null) {
+                baseColor = scene.globe.baseColor;
+            }
+            // When globe is off, we'll also hide the stars/moon.
+            // We also grab the globe color and apply it to the sky.
+            if (hidden && GetModelSpace(viewer)) {
+                scene.skyBox.show = false;
+                scene.skyAtmosphere.show = false;
+                scene.sun.show = false;
+                scene.moon.show = false;
+                scene.backgroundColor = baseColor.clone();
+            }
+            else {
+                scene.skyBox.show = true;
+                scene.skyAtmosphere.show = true;
+                scene.sun.show = true;
+                scene.moon.show = true;
+                scene.backgroundColor = Cesium.Color.BLACK;
+            }
+            scene.globe.baseColor = baseColor;
+        }
+        ViewUtils.SetGlobeDetails = SetGlobeDetails;
+        function SetModelSpace(viewer, modelSpace) {
+            if (!viewer) {
+                return;
+            }
+            if (viewer[CESIUM_MODEL_SPACE_KEY] === modelSpace) {
+                return;
+            }
+            viewer[CESIUM_MODEL_SPACE_KEY] = modelSpace;
+            // Reload globe since we display it differently between the two modes.
+            SetGlobeDetails({ viewer });
+        }
+        ViewUtils.SetModelSpace = SetModelSpace;
+        function GetModelSpace(viewer) {
+            if (!viewer) {
+                return false;
+            }
+            return Boolean(viewer[CESIUM_MODEL_SPACE_KEY]);
+        }
+        ViewUtils.GetModelSpace = GetModelSpace;
+    })(exports.ViewUtils || (exports.ViewUtils = {}));
+
+    /**
+     * Returns cesium property's value.
+     * This will check if it's one that changes over time, or just a fixed value.
+     * Eg: const pos3d = getValue<Cesium.Cartesian3>(cViewer, cEntity.point.position);
+     * @param viewer
+     * @param obj
+    */
+    function getValue(viewer, obj) {
+        if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
+            let date = viewer.scene.lastRenderTime;
+            if (!date) {
+                date = viewer.clock.currentTime;
+            }
+            return obj.getValue(date);
         }
         return obj;
     }
@@ -3862,508 +4098,594 @@
         EntityLabel.GetLabel = GetLabel;
     })(exports.EntityLabel || (exports.EntityLabel = {}));
 
-    function OnNextCRender(viewer, callback) {
-        const removal = viewer.scene.postRender.addEventListener(() => {
-            removal();
-            callback();
-        });
-    }
-    function GetCValue(viewer, obj) {
-        if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
-            let date = viewer.scene.lastRenderTime;
-            if (!date) {
-                date = viewer.clock.currentTime;
-            }
-            return obj.getValue(date);
-        }
-        return obj;
-    }
-    function ColorToCColor(color) {
-        return new Cesium.Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
-    }
     /**
-     * Removes duplicate points in a row and returns a new array.
-     * Passed array is not mutated.
-     * @param posses
+     * Utility for rendering parabolas between two points on the map.
      */
-    function CullDuplicateCPosses(posses) {
-        const newPosses = [];
-        let lastPos = null;
-        for (let i = 0; i < posses.length; i++) {
-            const pos = posses[i];
-            // Avoiding 'Cesium.Cartesian3.equals' because passed data might be just a json blob in certain cases.
-            if (pos && (!lastPos || (pos.x != lastPos.x || pos.y != lastPos.y || pos.z != lastPos.z))) {
-                newPosses.push(pos);
-                lastPos = pos;
-            }
+    class CesiumParabola {
+        get Disposed() {
+            return this.disposed;
         }
-        return newPosses;
-    }
-    /**
-     * Returns if the given positions are equal.
-     * @param a
-     * @param b
-     */
-    function CompareCPosses(a, b) {
-        // Same reference.
-        if (a == b) {
-            return true;
+        set Hidden(value) {
+            this.hidden = value;
         }
-        // Different lengths or one is null.
-        if ((!a || !b) || (a.length != b.length)) {
-            return false;
+        get curPos1() {
+            return this.pos1 instanceof Function ? this.pos1() : this.pos1;
         }
-        for (let i = 0; i < a.length; i++) {
-            const posA = a[i];
-            const posB = b[i];
-            // Null detected.
-            if (!posA || !posB) {
-                return false;
+        get curPos2() {
+            return this.pos2 instanceof Function ? this.pos2() : this.pos2;
+        }
+        constructor(params) {
+            this.disposed = false;
+            this.color = "white";
+            this.width = 2;
+            this.duration = 10;
+            this.heightDistanceRatio = 0.25;
+            this.curPoints = [];
+            this.animateInterval = null;
+            this.retryTimeout = null;
+            this.hidden = false;
+            this.viewer = params.viewer;
+            this.pos1 = params.pos1;
+            this.pos2 = params.pos2;
+            if (params.color) {
+                this.color = params.color;
             }
-            // Position values don't match.
-            if (!BModels.Cartes.IsEqualCartes3(posA, posB)) {
-                return false;
+            if (!isNaN(params.width)) {
+                this.width = params.width;
             }
-        }
-        return true;
-    }
-    /**
-     * Returns if the given polygon hierarchies are equal.
-     * @param a
-     * @param b
-     */
-    function CompareCPolygonHierarchies(a, b) {
-        // Same reference.
-        if (a == b) {
-            return true;
-        }
-        // Different lengths or one is null.
-        if ((!a || !b) || (a.positions.length != b.positions.length)) {
-            return false;
-        }
-        // Positions don't match.
-        if (!CompareCPosses(a.positions, b.positions)) {
-            return false;
-        }
-        const holes = a.holes;
-        const bHoles = b.holes;
-        // Number of holes don't match.
-        if (holes.length != bHoles.length) {
-            return false;
-        }
-        for (let i = 0; i < holes.length; i++) {
-            // Hole positions don't match.
-            if (!CompareCPosses(holes[i].positions, bHoles[i].positions)) {
-                return false;
+            if (!isNaN(params.duration)) {
+                this.duration = params.duration;
+            }
+            if (!isNaN(params.heightDistanceRatio)) {
+                this.heightDistanceRatio = params.heightDistanceRatio;
             }
+            this.prepareEntities();
         }
-        return true;
-    }
-
-    const CESIUM_INSPECTOR_KEY = "_nextspace_inspector";
-    const CESIUM_TIMELINE_KEY = "_nextspace_timeline";
-    const CESIUM_TIMELINE_LIVE_KEY = "_nextspace_timeline_live";
-    const CESIUM_TIMELINE_LIVE_PADDING_KEY = "_nextspace_timeline_live_padding";
-    const CESIUM_TIMELINE_INTERVAL_KEY = "_nextspace_timeline_interval";
-    const CESIUM_MODEL_SPACE_KEY = "_nextspace_model_space";
-    const DEFAULT_LIVE_PADDING_SECONDS = 30 * 60;
-    (function (ViewUtils) {
-        function GatherLegacyMapTiles(params) {
-            const viewer = params.viewer;
-            const collection = viewer.imageryLayers;
-            const tiles = [];
-            for (let i = 0; i < collection.length; i++) {
-                const layer = collection.get(i);
-                if (layer._bName) {
-                    tiles.push({
-                        alpha: layer.alpha,
-                        brightness: layer.brightness,
-                        contrast: layer.contrast,
-                        hue: layer.hue,
-                        saturation: layer.saturation,
-                        gamma: layer.gamma,
-                        title: layer._bName,
-                    });
+        prepareEntities() {
+            const parabola = new Cesium.Entity({
+                polyline: {
+                    positions: new Cesium.CallbackProperty(() => {
+                        return this.curPoints;
+                    }, false),
+                    width: this.width,
+                    material: Cesium.Color.fromCssColorString(this.color),
+                    show: new Cesium.CallbackProperty(() => {
+                        return !this.hidden;
+                    }, false)
                 }
-            }
-            return {
-                imagery: tiles.reverse()
-            };
+            });
+            const p1Entity = new Cesium.Entity({
+                position: new Cesium.CallbackProperty(() => {
+                    return this.curPoints.length ? this.curPoints[0] : new Cesium.Cartesian3();
+                }, false),
+                point: {
+                    heightReference: Cesium.HeightReference.NONE,
+                    pixelSize: this.width * 1.3,
+                    color: Cesium.Color.fromCssColorString(this.color),
+                    outlineColor: Cesium.Color.WHITE,
+                    outlineWidth: 2,
+                    show: new Cesium.CallbackProperty(() => {
+                        return !this.hidden;
+                    }, false)
+                }
+            });
+            const p2Entity = new Cesium.Entity({
+                position: new Cesium.CallbackProperty(() => {
+                    return this.curPoints.length ? this.curPoints[this.curPoints.length - 1] : new Cesium.Cartesian3();
+                }, false),
+                point: {
+                    heightReference: Cesium.HeightReference.NONE,
+                    pixelSize: this.width * 1.8,
+                    color: Cesium.Color.fromCssColorString(this.color),
+                    outlineColor: Cesium.Color.WHITE,
+                    outlineWidth: 2,
+                    show: new Cesium.CallbackProperty(() => {
+                        return !this.hidden;
+                    }, false)
+                }
+            });
+            p1Entity.parent = parabola;
+            p2Entity.parent = parabola;
+            const siblings = [p1Entity, p2Entity];
+            this.parabola = parabola;
+            this.siblings = siblings;
+            // The parabola is hidden while this entity is not added.
+            // If we avoid adding it now, then the parent can control if the parabola is visible at first or not.
+            // this.viewer.entities.add(this.parabola);
+            this.viewer.entities.add(p1Entity);
+            this.viewer.entities.add(p2Entity);
         }
-        ViewUtils.GatherLegacyMapTiles = GatherLegacyMapTiles;
-        function GatherLegacyTerrainTile(params) {
-            const viewer = params.viewer;
-            const enabled = viewer.terrainProvider;
-            if (enabled === null || enabled === void 0 ? void 0 : enabled._bName) {
-                return {
-                    terrain: enabled._bName
-                };
+        Animate() {
+            if (this.disposed) {
+                return null;
             }
-            return {
-                terrain: "flatterrain"
-            };
-        }
-        ViewUtils.GatherLegacyTerrainTile = GatherLegacyTerrainTile;
-        function GatherMapTiles(params) {
-            const viewer = params.viewer;
-            const imagery = viewer.imageryLayers;
-            const tiles = [];
-            for (let i = 0; i < imagery.length; i++) {
-                const provider = imagery.get(i);
-                if (provider._bMeta) {
-                    const idCombo = provider._bMeta.accountId + provider._bMeta.tilesetId;
-                    if (!tiles.find(x => x.accountId + x.tilesetId === idCombo)) {
-                        tiles.push({
-                            accountId: provider._bMeta.accountId,
-                            tilesetId: provider._bMeta.tilesetId,
-                            alpha: provider.alpha,
-                            brightness: provider.brightness,
-                            contrast: provider.contrast,
-                            hue: provider.hue,
-                            saturation: provider.saturation,
-                            gamma: provider.gamma
-                        });
-                    }
-                }
+            let retry = false;
+            if (!this.curPos1 || !this.curPos2 || !BModels.Cartes.ValidateCartes3(this.curPos1) || !BModels.Cartes.ValidateCartes3(this.curPos2)) {
+                retry = true;
             }
-            return {
-                imagery: tiles
-            };
-        }
-        ViewUtils.GatherMapTiles = GatherMapTiles;
-        function GatherTerrainTile(params) {
-            const viewer = params.viewer;
-            const provider = viewer.terrainProvider;
-            if (provider === null || provider === void 0 ? void 0 : provider._bMeta) {
-                return {
-                    terrain: {
-                        accountId: provider._bMeta.accountId,
-                        tilesetId: provider._bMeta.tilesetId,
-                    }
-                };
+            let TOTAL_LENGTH = retry ? 0 : Cesium.Cartesian3.distance(this.curPos1, this.curPos2);
+            if (TOTAL_LENGTH <= 0) {
+                retry = true;
             }
-            else if (provider instanceof Cesium.EllipsoidTerrainProvider) {
+            if (retry) {
+                this.retryTimeout = setTimeout(() => {
+                    this.Animate();
+                }, 2000);
                 return {
-                    terrain: {
-                        tilesetId: BModels.ProjectViewTile.EDefaultTerrain.FlatTerrain,
-                        accountId: null
-                    }
+                    parabola: this.parabola,
+                    siblings: this.siblings
                 };
             }
-            return null;
-        }
-        ViewUtils.GatherTerrainTile = GatherTerrainTile;
-        function SetTerrainWireframeStatus(params) {
-            if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
-                const InspectorClass = Cesium.CesiumInspector;
-                if (InspectorClass) {
-                    const inspector = new InspectorClass(document.createElement("div"), params.viewer.scene);
-                    inspector.container.style.display = "none";
-                    params.viewer[CESIUM_INSPECTOR_KEY] = inspector;
-                    params.viewer.scene.requestRender();
+            const RATE_PER_SECOND = 1000 / 40;
+            const SEC_DURATION = this.duration;
+            const HEIGHT_DISTANCE_RATIO = this.heightDistanceRatio;
+            let TOTAL_POINTS = null;
+            let POINT_LENGTH = null;
+            let TICK_LENGTH_INC = null;
+            // Updates TOTAL_POINTS, POINT_LENGTH, and TICK_LENGTH_INC based on current TOTAL_LENGTH and camera position.
+            // We want less points the further away the camera is.
+            const updateParams = () => {
+                var _a, _b;
+                // TODO: Do distance to parabola line instead.
+                const MIN_POINTS = 30;
+                let totalPoints = 80;
+                let cameraHeight = (_b = (_a = this.viewer.camera) === null || _a === void 0 ? void 0 : _a.positionCartographic) === null || _b === void 0 ? void 0 : _b.height;
+                if (isNaN(cameraHeight) || cameraHeight >= 100000) {
+                    totalPoints = MIN_POINTS;
                 }
-            }
-            if (params.viewer[CESIUM_INSPECTOR_KEY]) {
-                params.viewer[CESIUM_INSPECTOR_KEY].viewModel.wireframe = params.status;
-            }
-        }
-        ViewUtils.SetTerrainWireframeStatus = SetTerrainWireframeStatus;
-        function GetTerrainWireframeStatus(params) {
-            var _a, _b;
-            if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
-                return false;
-            }
-            return (_b = (_a = params.viewer[CESIUM_INSPECTOR_KEY]) === null || _a === void 0 ? void 0 : _a.viewModel) === null || _b === void 0 ? void 0 : _b.wireframe;
-        }
-        ViewUtils.GetTerrainWireframeStatus = GetTerrainWireframeStatus;
-        /**
-         * Changes between perspective and orthographic view.
-         * When Cesium stops being bad at picking positions in 2d mode we'll use the flat earth mode instead.
-         * @param params
-         */
-        function Set2dStatus(params) {
-            const { viewer, status: is2d, moveCamera } = params;
-            const curLens2d = viewer.camera.frustum instanceof Cesium.OrthographicFrustum;
-            if (curLens2d && !is2d) {
-                OnNextCRender(viewer, () => {
-                    viewer.camera.switchToPerspectiveFrustum();
-                    viewer.scene.screenSpaceCameraController.enableTilt = true;
-                });
-                viewer.scene.requestRender();
-            }
-            else if (!curLens2d && is2d) {
-                OnNextCRender(viewer, () => {
-                    viewer.camera.switchToOrthographicFrustum();
-                    viewer.scene.screenSpaceCameraController.enableTilt = false;
-                });
-                if (moveCamera != false) {
-                    try {
-                        // Face camera downwards to make it look 2d.
-                        // We want to try make it look at the center-point of the current view.
-                        // If center cannot be calculated then we'll simply raise the camera and face it downwards.
-                        const scene = viewer.scene;
-                        const windowPosition = new Cesium.Cartesian2(scene.canvas.clientWidth / 2, scene.canvas.clientHeight / 2);
-                        const ray = viewer.camera.getPickRay(windowPosition);
-                        const intersection = scene.globe.pick(ray, scene);
-                        let center;
-                        if (Cesium.defined(intersection)) {
-                            center = Cesium.Cartographic.fromCartesian(intersection);
+                else if (cameraHeight >= 10000) {
+                    totalPoints = 50;
+                }
+                else if (cameraHeight >= 1000) {
+                    totalPoints = 80;
+                }
+                else if (cameraHeight >= 100) {
+                    totalPoints = 100;
+                }
+                TOTAL_POINTS = Math.max(MIN_POINTS, Math.min(totalPoints, TOTAL_LENGTH * 0.1));
+                POINT_LENGTH = TOTAL_LENGTH / TOTAL_POINTS;
+                TICK_LENGTH_INC = SEC_DURATION == 0 ? TOTAL_LENGTH : TOTAL_POINTS / (RATE_PER_SECOND * SEC_DURATION);
+            };
+            updateParams();
+            let curPoint = 0;
+            let quadraticKey = null;
+            let quadratic = null;
+            let quadraticPreparing = false;
+            const prepareQuadratic = async () => {
+                if (quadraticPreparing) {
+                    return;
+                }
+                quadraticPreparing = true;
+                try {
+                    const p1 = this.curPos1;
+                    const p2 = this.curPos2;
+                    if (!p1 || !p2 || !BModels.Cartes.ValidateCartes3(p1) || !BModels.Cartes.ValidateCartes3(p2)) {
+                        return;
+                    }
+                    const height1 = Cesium.Cartographic.fromCartesian(p1).height;
+                    const height2 = Cesium.Cartographic.fromCartesian(p2).height;
+                    if (isNaN(height1) || isNaN(height2)) {
+                        return;
+                    }
+                    const totalHeight = height2 + height1;
+                    const curQuadraticKey = `${height1}-${height2}-${TOTAL_LENGTH}`;
+                    if (quadraticKey == curQuadraticKey) {
+                        return;
+                    }
+                    const points2d = [
+                        new Cesium.Cartesian2(0, height1),
+                        new Cesium.Cartesian2(TOTAL_LENGTH, height2)
+                    ];
+                    let vertexHeight = 0;
+                    // Flat line.
+                    if (HEIGHT_DISTANCE_RATIO == 0) {
+                        vertexHeight = totalHeight * 0.5;
+                    }
+                    else {
+                        const largestHeight = Math.max(height1, height2);
+                        vertexHeight = largestHeight + (TOTAL_LENGTH * HEIGHT_DISTANCE_RATIO);
+                    }
+                    points2d.push(new Cesium.Cartesian2(TOTAL_LENGTH * 0.5, vertexHeight));
+                    const calcQuadratic = (points) => {
+                        // Swaps position of two rows in matrix.
+                        function swapRows(matrix, rowAIndex, rowBIndex) {
+                            const rowAVal = matrix[rowAIndex];
+                            matrix[rowAIndex] = matrix[rowBIndex];
+                            matrix[rowBIndex] = rowAVal;
+                            return matrix;
                         }
-                        // Use current camera position if we can't calculate the center.
-                        else {
-                            center = Cesium.Cartographic.fromCartesian(viewer.camera.position);
-                            center.height = 0;
+                        // Zeros rowA at colIndex by subtracting a multiplied rowB from it.
+                        function reduceMatrixRowByRow(matrix, zeroingIndex, parentIndex, colIndex) {
+                            const zeroRow = matrix[zeroingIndex];
+                            const parentRow = matrix[parentIndex];
+                            if (zeroRow[colIndex] == 0) {
+                                return matrix;
+                            }
+                            else if (parentRow[colIndex] == 0) {
+                                matrix = swapRows(matrix, parentIndex, zeroingIndex);
+                                return divideMatrixRow(matrix, parentIndex, colIndex);
+                            }
+                            // rowAIndex colIndex / rowBIndex colIndex = factor;
+                            let factor = zeroRow[colIndex] / parentRow[colIndex];
+                            for (let i = 0; i < zeroRow.length; i++) {
+                                if (i >= colIndex) {
+                                    zeroRow[i] -= parentRow[i] * factor;
+                                }
+                            }
+                            return matrix;
                         }
-                        center.height = viewer.camera.positionCartographic.height + 100;
-                        viewer.camera.setView({
-                            destination: Cesium.Cartographic.toCartesian(center),
-                            orientation: {
-                                heading: 0.0,
-                                pitch: Cesium.Math.toRadians(-90.0),
-                                roll: 0.0
+                        // Makes a given row column equal 1 by diving while row by that column.
+                        function divideMatrixRow(matrix, rowIndex, colIndex) {
+                            const row = matrix[rowIndex];
+                            const colValue = row[colIndex];
+                            for (let i = 0; i < row.length; i++) {
+                                if (i >= colIndex) {
+                                    row[i] /= colValue;
+                                }
                             }
-                        });
-                    }
-                    catch (e) {
-                        console.error(e);
-                    }
+                            return matrix;
+                        }
+                        // Returns initial matrix for calculating a, b and c for quadratic formula from given points.
+                        function matrixFromPoints(points) {
+                            const rows = [];
+                            const constructRow = (point) => {
+                                rows.push([
+                                    -Math.pow(point.x, 2),
+                                    point.x,
+                                    1,
+                                    point.y
+                                ]);
+                            };
+                            for (let i = 0; i < points.length; i++) {
+                                constructRow(points[i]);
+                            }
+                            return rows;
+                        }
+                        const initialMatrix = matrixFromPoints(points);
+                        const step1Matrix = reduceMatrixRowByRow(initialMatrix, 1, 0, 0);
+                        const step2Matrix = reduceMatrixRowByRow(step1Matrix, 2, 0, 0);
+                        const step3Matrix = reduceMatrixRowByRow(step2Matrix, 2, 1, 1);
+                        const step4Matrix = reduceMatrixRowByRow(step3Matrix, 0, 1, 1);
+                        const step5Matrix = reduceMatrixRowByRow(step4Matrix, 0, 2, 2);
+                        const step6Matrix = reduceMatrixRowByRow(step5Matrix, 1, 2, 2);
+                        const a = step6Matrix[0][3];
+                        const b = step6Matrix[1][3];
+                        const c = step6Matrix[2][3];
+                        return { a: a, b: b, c: c };
+                    };
+                    quadratic = calcQuadratic(points2d);
                 }
-                viewer.scene.requestRender();
-            }
-        }
-        ViewUtils.Set2dStatus = Set2dStatus;
-        function Get2dStatus(params) {
-            const { viewer } = params;
-            return viewer.camera.frustum instanceof Cesium.OrthographicFrustum;
-        }
-        ViewUtils.Get2dStatus = Get2dStatus;
-        function SetLockedCameraStatus(params) {
-            const { viewer, status } = params;
-            const scene = viewer === null || viewer === void 0 ? void 0 : viewer.scene;
-            if (!scene) {
-                return;
-            }
-            if (status) {
-                scene.screenSpaceCameraController.enableInputs = false;
-                scene.screenSpaceCameraController.enableTranslate = false;
-                scene.screenSpaceCameraController.enableZoom = false;
-                scene.screenSpaceCameraController.enableRotate = false;
-                scene.screenSpaceCameraController.enableTilt = false;
-            }
-            else {
-                scene.screenSpaceCameraController.enableInputs = true;
-                scene.screenSpaceCameraController.enableTranslate = true;
-                scene.screenSpaceCameraController.enableZoom = true;
-                scene.screenSpaceCameraController.enableRotate = true;
-                if (!ViewUtils.Get2dStatus({ viewer })) {
-                    scene.screenSpaceCameraController.enableTilt = true;
+                catch (e) {
+                    console.error(e);
                 }
-            }
-            viewer.scene.requestRender();
-        }
-        ViewUtils.SetLockedCameraStatus = SetLockedCameraStatus;
-        function GetLockedCameraStatus(params) {
-            var _a;
-            const scene = (_a = params.viewer) === null || _a === void 0 ? void 0 : _a.scene;
-            if (!scene) {
-                return false;
-            }
-            return !scene.screenSpaceCameraController.enableTranslate;
-        }
-        ViewUtils.GetLockedCameraStatus = GetLockedCameraStatus;
-        /**
-         * Returns the current camera time and related settings.
-         * @param params
-         * @returns
-         */
-        function GetTimeDetails(params) {
-            const { viewer } = params;
-            const clock = viewer.clock;
+                finally {
+                    quadraticPreparing = false;
+                }
+            };
+            const getPosition = (increment) => {
+                if (!quadratic) {
+                    return null;
+                }
+                let lengthAcross = POINT_LENGTH * increment;
+                if (lengthAcross > TOTAL_LENGTH) {
+                    lengthAcross = TOTAL_LENGTH;
+                }
+                const getParabolaYFromX = (x, quadLetters) => {
+                    let a = quadLetters.a;
+                    let b = quadLetters.b;
+                    let c = quadLetters.c;
+                    return (-a * Math.pow(x, 2)) + (b * x) + c;
+                };
+                const { point: pos3d } = exports.DrawingUtils.PointAcrossPolyline({
+                    viewer: this.viewer,
+                    distance: lengthAcross,
+                    posses: [this.curPos1, this.curPos2]
+                });
+                const point = Cesium.Cartographic.fromCartesian(pos3d);
+                const posHeight = getParabolaYFromX(lengthAcross, quadratic);
+                return Cesium.Cartesian3.fromRadians(point.longitude, point.latitude, posHeight);
+            };
+            const updatePoints = () => {
+                if (!quadratic) {
+                    return;
+                }
+                const increment = Math.floor(curPoint);
+                const chips = curPoint - Math.floor(curPoint);
+                const posses = [];
+                posses.push(getPosition(0));
+                const addLast = increment >= TOTAL_POINTS;
+                const totalCycles = addLast ? increment + 1 : increment;
+                for (let i = 0; i < totalCycles; i++) {
+                    posses.push(getPosition(i));
+                }
+                if (chips) {
+                    posses.push(getPosition(increment + chips));
+                }
+                if (posses.find(x => !x || !BModels.Cartes.ValidateCartes3(x))) {
+                    return;
+                }
+                this.curPoints = posses;
+            };
+            let lastTickDate = new Date();
+            let finished = false;
+            const doTick = () => {
+                const curDate = new Date();
+                const seconds = (curDate.getTime() - lastTickDate.getTime()) / 1000;
+                const ticks = seconds * RATE_PER_SECOND;
+                if (!isNaN(ticks) && ticks >= 1) {
+                    lastTickDate = curDate;
+                    const p1 = this.curPos1;
+                    const p2 = this.curPos2;
+                    const newLength = p1 && p2 ? Cesium.Cartesian3.distance(p1, p2) : -1;
+                    if (newLength > 0 && newLength != TOTAL_LENGTH) {
+                        TOTAL_LENGTH = newLength;
+                        updateParams();
+                    }
+                    prepareQuadratic();
+                    if (quadratic) {
+                        if (curPoint < TOTAL_POINTS) {
+                            curPoint += (TICK_LENGTH_INC * ticks);
+                        }
+                        updatePoints();
+                    }
+                    this.viewer.scene.requestRender();
+                    if (curPoint >= TOTAL_POINTS && !finished) {
+                        finished = true;
+                        // We can make the interval update super slow now.
+                        // We keep it updating in case the positions move.
+                        clearInterval(this.animateInterval);
+                        this.animateInterval = setInterval(doTick, 3000);
+                    }
+                }
+            };
+            this.animateInterval = setInterval(doTick, RATE_PER_SECOND);
             return {
-                animationSpeed: clock.multiplier,
-                isAnimating: clock.shouldAnimate,
-                startTime: clock.startTime,
-                startTimeIso: clock.startTime.toString(),
-                currentTime: clock.currentTime,
-                currentTimeIso: clock.currentTime.toString(),
-                stopTime: clock.stopTime,
-                stopTimeIso: clock.stopTime.toString(),
-                areCesiumValues: clock[CESIUM_TIMELINE_KEY] != true,
-                isLive: clock[CESIUM_TIMELINE_LIVE_KEY] == true,
-                livePaddingSeconds: clock[CESIUM_TIMELINE_LIVE_PADDING_KEY] || DEFAULT_LIVE_PADDING_SECONDS
+                parabola: this.parabola,
+                siblings: this.siblings
             };
         }
-        ViewUtils.GetTimeDetails = GetTimeDetails;
-        /**
-         * Sets the Cesium clock values.
-         * If a value is not provided, then 'areCesiumValues' checked to see if the values are Cesium values.
-         * If they're currently Cesium set values then our defaults are used.
-         * @param params
-         */
-        function SetTimeDetails(params) {
-            let { viewer, animationSpeed, isAnimating, startTime, currentTime, stopTime, startTimeIso, stopTimeIso, currentTimeIso, isLive, livePaddingSeconds } = params;
-            const clock = viewer.clock;
-            if (startTime) {
-                clock.startTime = startTime;
-            }
-            else if (startTimeIso) {
-                const startDate = Cesium.JulianDate.fromIso8601(startTimeIso);
-                if (startDate) {
-                    clock.startTime = startDate;
+        Dispose() {
+            this.disposed = true;
+            clearTimeout(this.retryTimeout);
+            clearInterval(this.animateInterval);
+            const cEntities = [
+                this.parabola
+            ].concat(this.siblings);
+            cEntities.forEach(e => {
+                if (e && this.viewer.entities.contains(e)) {
+                    this.viewer.entities.remove(e);
                 }
+            });
+        }
+    }
+
+    function colorToCColor(color) {
+        return new Cesium.Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
+    }
+    async function getStyle(api, typeId, styleId) {
+        let style = null;
+        if (styleId && styleId != -1) {
+            try {
+                style = (await BModels.Style.Get({
+                    api,
+                    styleId
+                })).style;
             }
-            if (currentTime) {
-                clock.currentTime = currentTime;
+            // Probably deleted.
+            catch (e) {
+                console.error(e);
             }
-            else if (currentTimeIso) {
-                const currentDate = Cesium.JulianDate.fromIso8601(currentTimeIso);
-                if (currentDate) {
-                    clock.currentTime = currentDate;
+        }
+        if (!style && typeId) {
+            const { entityType: type } = await BModels.EntityType.Get({
+                api,
+                entityTypeId: typeId
+            });
+            if (type["DisplaySetting.ID"]) {
+                try {
+                    style = (await BModels.Style.Get({
+                        api,
+                        styleId: type["DisplaySetting.ID"]
+                    })).style;
                 }
-            }
-            if (stopTime) {
-                clock.stopTime = stopTime;
-            }
-            else if (stopTimeIso) {
-                const stopDate = Cesium.JulianDate.fromIso8601(stopTimeIso);
-                if (stopDate) {
-                    clock.stopTime = stopDate;
+                catch (e) {
+                    let hideError = false;
+                    // TODO: we need a util for extracting code + message rather than writing all this every time.
+                    if (e && typeof e == "object" && e.ERROR) {
+                        const error = e.ERROR;
+                        const code = error && typeof error == "object" ? error.Code : "";
+                        // Avoiding logging a common error.
+                        // This happens when rendering entities that don't have records.
+                        hideError = String(code).toLowerCase() == "notfound";
+                    }
+                    if (!hideError) {
+                        console.error(e);
+                    }
                 }
             }
-            clock.clockRange = Cesium.ClockRange.LOOP_STOP;
-            const areCesiumValues = clock[CESIUM_TIMELINE_KEY] != true;
-            if (areCesiumValues) {
-                if (isNaN(animationSpeed) || animationSpeed == null) {
-                    animationSpeed = 1;
-                }
-                if (isAnimating == null) {
-                    isAnimating = false;
+        }
+        return style;
+    }
+    var RelationRenderEngine;
+    (function (RelationRenderEngine) {
+        function GetRenderGroupId(relation) {
+            return `${relation["Related.Entity.ID"]}-${relation["Principal.Entity.ID"]}-${relation["Relation.Type.ID"]}`;
+        }
+        RelationRenderEngine.GetRenderGroupId = GetRenderGroupId;
+        async function Render(params) {
+            const { apiGetter, viewer, visualRegister, menuItemId, relations } = params;
+            const api = apiGetter.getApi(apiGetter.accountId);
+            const rendered = {};
+            let neededEntityIdsIds = [];
+            for (let i = 0; i < relations.length; i++) {
+                const relation = relations[i];
+                if (relation["Principal.Entity.ID"]) {
+                    neededEntityIdsIds.push(relation["Principal.Entity.ID"]);
                 }
-                if (isLive == null) {
-                    isLive = false;
+                if (relation["Related.Entity.ID"]) {
+                    neededEntityIdsIds.push(relation["Related.Entity.ID"]);
                 }
-                if (livePaddingSeconds == null) {
-                    livePaddingSeconds = DEFAULT_LIVE_PADDING_SECONDS;
+                if (relation["Data.Entity.ID"]) {
+                    neededEntityIdsIds.push(relation["Data.Entity.ID"]);
                 }
             }
-            if (!isNaN(animationSpeed) && animationSpeed != null) {
-                clock.multiplier = animationSpeed;
-            }
-            if (isAnimating != null) {
-                clock.shouldAnimate = isAnimating;
-            }
-            viewer.scene.requestRender();
-            clock[CESIUM_TIMELINE_KEY] = true;
-            if (livePaddingSeconds != null) {
-                clock[CESIUM_TIMELINE_LIVE_PADDING_KEY] = livePaddingSeconds || DEFAULT_LIVE_PADDING_SECONDS;
-            }
-            if (isLive != null) {
-                clock[CESIUM_TIMELINE_LIVE_KEY] = params.isLive == true;
-            }
-            if (clock[CESIUM_TIMELINE_LIVE_KEY]) {
-                startLive(viewer);
+            // Turn the set unique.
+            neededEntityIdsIds = neededEntityIdsIds.filter((v, i, a) => a.indexOf(v) === i);
+            // Get all entities in one go.
+            let entities = (await BModels.Entity.GetListByIds({
+                entityIds: neededEntityIdsIds,
+                api: apiGetter.getApi(),
+                migrated: true,
+                maxSearchTimeSec: 60 * 2
+            })).entities;
+            // Create a map for quick reference.
+            const entitiesMap = {};
+            for (let i = 0; i < entities.length; i++) {
+                const entity = entities[i];
+                entitiesMap[entity.Bruce.ID] = entity;
             }
-            else {
-                stopLive(viewer);
+            entities = null;
+            // Gather needed relationship types.
+            // Right now this means just getting the full list.
+            const relationTypes = (await BModels.EntityRelationType.GetList({
+                api
+            })).relationTypes;
+            const relationTypesMap = {};
+            for (let i = 0; i < relationTypes.length; i++) {
+                const relationType = relationTypes[i];
+                relationTypesMap[relationType.ID] = relationType;
             }
-        }
-        ViewUtils.SetTimeDetails = SetTimeDetails;
-        function startLive(viewer) {
-            const doUpdate = () => {
-                if (!viewer || viewer.isDestroyed() || !viewer.scene) {
-                    stopLive(viewer);
-                    return;
+            for (let i = 0; i < relations.length; i++) {
+                try {
+                    const relation = relations[i];
+                    const fromEntity = entitiesMap[relation["Principal.Entity.ID"]];
+                    const toEntity = entitiesMap[relation["Related.Entity.ID"]];
+                    const dataEntity = relation["Data.Entity.ID"] ? entitiesMap[relation["Data.Entity.ID"]] : null;
+                    const relationType = relationTypesMap[relation["Relation.Type.ID"]];
+                    const style = await getStyle(api, relationType === null || relationType === void 0 ? void 0 : relationType["Relation.EntityType.ID"], Number(relationType === null || relationType === void 0 ? void 0 : relationType.EntityDisplaySettingID));
+                    const cEntity = await Parabola.Render({
+                        dataEntity,
+                        fromEntity,
+                        relation,
+                        style,
+                        toEntity,
+                        viewer,
+                        visualRegister,
+                        apiGetter
+                    });
+                    cEntity._renderGroup = GetRenderGroupId(relation);
+                    rendered[GetRenderGroupId(relation)] = cEntity;
                 }
-                // Get the current settings.
-                const tDetails = GetTimeDetails({ viewer });
-                const clock = viewer.clock;
-                if (clock) {
-                    clock.shouldAnimate = true;
-                    clock.multiplier = 1;
-                    clock.currentTime = Cesium.JulianDate.now();
-                    clock.startTime = Cesium.JulianDate.addSeconds(clock.currentTime, -tDetails.livePaddingSeconds, new Cesium.JulianDate());
-                    clock.stopTime = Cesium.JulianDate.addSeconds(clock.currentTime, tDetails.livePaddingSeconds, new Cesium.JulianDate());
-                    clock.clockRange = Cesium.ClockRange.UNBOUNDED;
+                catch (e) {
+                    console.error(e);
                 }
-            };
-            if (viewer[CESIUM_TIMELINE_INTERVAL_KEY]) {
-                doUpdate();
-                return;
-            }
-            // We'll start an interval that occasionally updates the Cesium clock to stay in the desired settings.
-            // Since it moves live (1 second per second), we don't have to worry about the ranges being out of date quickly.
-            viewer[CESIUM_TIMELINE_INTERVAL_KEY] = setInterval(() => {
-                doUpdate();
-            }, 800);
-            viewer[CESIUM_TIMELINE_LIVE_KEY] = true;
-            // Initial update.
-            doUpdate();
-        }
-        function stopLive(viewer) {
-            if (!viewer) {
-                return;
-            }
-            let interval = viewer[CESIUM_TIMELINE_INTERVAL_KEY];
-            if (interval) {
-                clearInterval(interval);
-                viewer[CESIUM_TIMELINE_INTERVAL_KEY] = null;
-            }
-            viewer[CESIUM_TIMELINE_LIVE_KEY] = false;
-        }
-        function SetGlobeDetails(params) {
-            let { viewer, hidden, baseColor } = params;
-            const scene = viewer === null || viewer === void 0 ? void 0 : viewer.scene;
-            if (!(scene === null || scene === void 0 ? void 0 : scene.globe)) {
-                return;
-            }
-            if (hidden == null) {
-                hidden = !scene.globe.show;
-            }
-            else {
-                scene.globe.show = !hidden;
-            }
-            if (baseColor == null) {
-                baseColor = scene.globe.baseColor;
-            }
-            // When globe is off, we'll also hide the stars/moon.
-            // We also grab the globe color and apply it to the sky.
-            if (hidden && GetModelSpace(viewer)) {
-                scene.skyBox.show = false;
-                scene.skyAtmosphere.show = false;
-                scene.sun.show = false;
-                scene.moon.show = false;
-                scene.backgroundColor = baseColor.clone();
-            }
-            else {
-                scene.skyBox.show = true;
-                scene.skyAtmosphere.show = true;
-                scene.sun.show = true;
-                scene.moon.show = true;
-                scene.backgroundColor = Cesium.Color.BLACK;
-            }
-            scene.globe.baseColor = baseColor;
-        }
-        ViewUtils.SetGlobeDetails = SetGlobeDetails;
-        function SetModelSpace(viewer, modelSpace) {
-            if (!viewer) {
-                return;
             }
-            if (viewer[CESIUM_MODEL_SPACE_KEY] === modelSpace) {
-                return;
-            }
-            viewer[CESIUM_MODEL_SPACE_KEY] = modelSpace;
-            // Reload globe since we display it differently between the two modes.
-            SetGlobeDetails({ viewer });
+            return rendered;
         }
-        ViewUtils.SetModelSpace = SetModelSpace;
-        function GetModelSpace(viewer) {
-            if (!viewer) {
-                return false;
+        RelationRenderEngine.Render = Render;
+        let Parabola;
+        (function (Parabola) {
+            async function Render(params) {
+                var _a;
+                const style = (_a = params.style) === null || _a === void 0 ? void 0 : _a.Settings;
+                const entity = params.dataEntity;
+                const bColor = (style === null || style === void 0 ? void 0 : style.lineColor) ? BModels.Calculator.GetColor(style === null || style === void 0 ? void 0 : style.lineColor, entity, []) : null;
+                const cColor = bColor ? colorToCColor(bColor) : Cesium.Color.WHITE;
+                let width = EnsureNumber((style === null || style === void 0 ? void 0 : style.lineWidth) ? BModels.Calculator.GetNumber(style === null || style === void 0 ? void 0 : style.lineWidth, entity, []) : 4, 4);
+                if (width < 1) {
+                    width = 1;
+                }
+                const duration = EnsureNumber((style === null || style === void 0 ? void 0 : style.duration) ? BModels.Calculator.GetNumber(style === null || style === void 0 ? void 0 : style.duration, entity, []) : 2, 2);
+                const hDistanceRatio = EnsureNumber((style === null || style === void 0 ? void 0 : style.heightDistanceRatio) ? BModels.Calculator.GetNumber(style === null || style === void 0 ? void 0 : style.heightDistanceRatio, entity, []) : 0.25, 0.25);
+                let fromPos = null;
+                let toPos = null;
+                let updatingPosses = false;
+                const updatePosses = async () => {
+                    if (updatingPosses) {
+                        return;
+                    }
+                    updatingPosses = true;
+                    try {
+                        const fromData = await exports.EntityUtils.GetLocation({
+                            samples: [{
+                                    entity: params.fromEntity,
+                                    entityId: params.fromEntity.Bruce.ID,
+                                    heightRef: Cesium.HeightReference.CLAMP_TO_GROUND,
+                                    returnHeightRef: Cesium.HeightReference.NONE
+                                }],
+                            viewer: params.viewer,
+                            visualRegister: params.visualRegister,
+                            api: params.apiGetter.getApi()
+                        });
+                        fromPos = fromData.pos3d;
+                        const toData = await exports.EntityUtils.GetLocation({
+                            samples: [{
+                                    entity: params.toEntity,
+                                    entityId: params.toEntity.Bruce.ID,
+                                    heightRef: Cesium.HeightReference.CLAMP_TO_GROUND,
+                                    returnHeightRef: Cesium.HeightReference.NONE
+                                }],
+                            viewer: params.viewer,
+                            visualRegister: params.visualRegister,
+                            api: params.apiGetter.getApi()
+                        });
+                        toPos = toData.pos3d;
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                    updatingPosses = false;
+                };
+                updatePosses();
+                const parabola = new CesiumParabola({
+                    viewer: params.viewer,
+                    pos1: () => fromPos,
+                    pos2: () => toPos,
+                    color: cColor.toCssColorString(),
+                    width: width,
+                    duration: duration,
+                    heightDistanceRatio: hDistanceRatio
+                });
+                parabola.Hidden = true;
+                const cEntities = parabola.Animate();
+                const cEntity = cEntities.parabola;
+                cEntity._siblingGraphics = [];
+                for (let i = 0; i < cEntities.siblings.length; i++) {
+                    const sibling = cEntities.siblings[i];
+                    cEntity._siblingGraphics.push(sibling);
+                }
+                let updateInterval = setInterval(() => {
+                    var _a;
+                    if (!((_a = params.viewer) === null || _a === void 0 ? void 0 : _a.scene) ||
+                        params.viewer.isDestroyed() ||
+                        (!parabola || parabola.Disposed)) {
+                        clearInterval(updateInterval);
+                        parabola.Dispose();
+                        return;
+                    }
+                    if (parabola) {
+                        const visible = cEntity && cEntity.show != false && params.viewer.entities.contains(cEntity);
+                        parabola.Hidden = !visible;
+                    }
+                    updatePosses();
+                    params.viewer.scene.requestRender();
+                }, 1000);
+                let disposed = false;
+                cEntity._dispose = () => {
+                    if (disposed) {
+                        return;
+                    }
+                    disposed = true;
+                    clearInterval(updateInterval);
+                    if (parabola) {
+                        parabola.Dispose();
+                    }
+                };
+                return cEntity;
             }
-            return Boolean(viewer[CESIUM_MODEL_SPACE_KEY]);
-        }
-        ViewUtils.GetModelSpace = GetModelSpace;
-    })(exports.ViewUtils || (exports.ViewUtils = {}));
+            Parabola.Render = Render;
+        })(Parabola = RelationRenderEngine.Parabola || (RelationRenderEngine.Parabola = {}));
+    })(RelationRenderEngine || (RelationRenderEngine = {}));
 
     const MODEL_MIN_RADIUS = 10;
     const POINT_MIN_RADIUS = 15;
@@ -7023,6 +7345,116 @@
         VisualsRegister.Register = Register;
     })(exports.VisualsRegister || (exports.VisualsRegister = {}));
 
+    /**
+     * Tracks per-entity rerender state for unsaved blob maintenance and stale API response suppression.
+     */
+    class EntityReRenderMaintainState {
+        constructor() {
+            this.maintainedEntitiesById = {};
+            this.apiRevisionByEntityId = {};
+            this.skipApiRunByEntityId = {};
+            this.checkRunId = 0;
+        }
+        setMaintainedEntities(entities) {
+            var _a;
+            for (let i = 0; i < entities.length; i++) {
+                const entity = entities[i];
+                const id = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
+                if (!id) {
+                    continue;
+                }
+                this.maintainedEntitiesById[id] = entity;
+            }
+        }
+        clearMaintainedEntities(entityIds) {
+            for (let i = 0; i < entityIds.length; i++) {
+                const id = entityIds[i];
+                if (!id) {
+                    continue;
+                }
+                delete this.maintainedEntitiesById[id];
+            }
+        }
+        getMaintainedEntities(entityIds) {
+            const entities = [];
+            for (let i = 0; i < entityIds.length; i++) {
+                const id = entityIds[i];
+                if (!id) {
+                    continue;
+                }
+                const entity = this.maintainedEntitiesById[id];
+                if (entity) {
+                    entities.push(entity);
+                }
+            }
+            return entities;
+        }
+        bumpApiRevisions(entityIds) {
+            var _a;
+            for (let i = 0; i < entityIds.length; i++) {
+                const id = entityIds[i];
+                if (!id) {
+                    continue;
+                }
+                this.apiRevisionByEntityId[id] = ((_a = this.apiRevisionByEntityId[id]) !== null && _a !== void 0 ? _a : 0) + 1;
+            }
+        }
+        captureApiRevisions(entityIds) {
+            var _a;
+            const revisions = {};
+            for (let i = 0; i < entityIds.length; i++) {
+                const id = entityIds[i];
+                if (!id) {
+                    continue;
+                }
+                revisions[id] = (_a = this.apiRevisionByEntityId[id]) !== null && _a !== void 0 ? _a : 0;
+            }
+            return revisions;
+        }
+        startCheckRun() {
+            this.checkRunId += 1;
+            return this.checkRunId;
+        }
+        getCurrentCheckRun() {
+            return this.checkRunId;
+        }
+        markSkipForCurrentRun(entityIds, isRunningCheck) {
+            if (!isRunningCheck) {
+                return;
+            }
+            const runId = this.checkRunId;
+            for (let i = 0; i < entityIds.length; i++) {
+                const id = entityIds[i];
+                if (!id) {
+                    continue;
+                }
+                this.skipApiRunByEntityId[id] = runId;
+            }
+        }
+        shouldSkipInRun(entityId, runId) {
+            return this.skipApiRunByEntityId[entityId] === runId;
+        }
+        filterNonSkippedIds(entityIds, runId) {
+            return entityIds.filter((id) => {
+                return id && !this.shouldSkipInRun(id, runId);
+            });
+        }
+        filterCurrentApiEntities(params) {
+            const { entities, revisions, runId } = params;
+            return entities.filter((entity) => {
+                var _a, _b, _c;
+                const id = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
+                if (!id) {
+                    return false;
+                }
+                if (runId != null && this.shouldSkipInRun(id, runId)) {
+                    return false;
+                }
+                return ((_b = this.apiRevisionByEntityId[id]) !== null && _b !== void 0 ? _b : 0) === ((_c = revisions[id]) !== null && _c !== void 0 ? _c : 0);
+            });
+        }
+    }
+
     function GetValue(viewer, obj) {
         if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
             let date = viewer.scene.lastRenderTime;
@@ -7842,438 +8274,6 @@
         }
     }
 
-    /**
-     * Tracks per-entity rerender state for unsaved blob maintenance and stale API response suppression.
-     */
-    class EntityReRenderMaintainState {
-        constructor() {
-            this.maintainedEntitiesById = {};
-            this.apiRevisionByEntityId = {};
-            this.skipApiRunByEntityId = {};
-            this.checkRunId = 0;
-        }
-        setMaintainedEntities(entities) {
-            var _a;
-            for (let i = 0; i < entities.length; i++) {
-                const entity = entities[i];
-                const id = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
-                if (!id) {
-                    continue;
-                }
-                this.maintainedEntitiesById[id] = entity;
-            }
-        }
-        clearMaintainedEntities(entityIds) {
-            for (let i = 0; i < entityIds.length; i++) {
-                const id = entityIds[i];
-                if (!id) {
-                    continue;
-                }
-                delete this.maintainedEntitiesById[id];
-            }
-        }
-        getMaintainedEntities(entityIds) {
-            const entities = [];
-            for (let i = 0; i < entityIds.length; i++) {
-                const id = entityIds[i];
-                if (!id) {
-                    continue;
-                }
-                const entity = this.maintainedEntitiesById[id];
-                if (entity) {
-                    entities.push(entity);
-                }
-            }
-            return entities;
-        }
-        bumpApiRevisions(entityIds) {
-            var _a;
-            for (let i = 0; i < entityIds.length; i++) {
-                const id = entityIds[i];
-                if (!id) {
-                    continue;
-                }
-                this.apiRevisionByEntityId[id] = ((_a = this.apiRevisionByEntityId[id]) !== null && _a !== void 0 ? _a : 0) + 1;
-            }
-        }
-        captureApiRevisions(entityIds) {
-            var _a;
-            const revisions = {};
-            for (let i = 0; i < entityIds.length; i++) {
-                const id = entityIds[i];
-                if (!id) {
-                    continue;
-                }
-                revisions[id] = (_a = this.apiRevisionByEntityId[id]) !== null && _a !== void 0 ? _a : 0;
-            }
-            return revisions;
-        }
-        startCheckRun() {
-            this.checkRunId += 1;
-            return this.checkRunId;
-        }
-        getCurrentCheckRun() {
-            return this.checkRunId;
-        }
-        markSkipForCurrentRun(entityIds, isRunningCheck) {
-            if (!isRunningCheck) {
-                return;
-            }
-            const runId = this.checkRunId;
-            for (let i = 0; i < entityIds.length; i++) {
-                const id = entityIds[i];
-                if (!id) {
-                    continue;
-                }
-                this.skipApiRunByEntityId[id] = runId;
-            }
-        }
-        shouldSkipInRun(entityId, runId) {
-            return this.skipApiRunByEntityId[entityId] === runId;
-        }
-        filterNonSkippedIds(entityIds, runId) {
-            return entityIds.filter((id) => {
-                return id && !this.shouldSkipInRun(id, runId);
-            });
-        }
-        filterCurrentApiEntities(params) {
-            const { entities, revisions, runId } = params;
-            return entities.filter((entity) => {
-                var _a, _b, _c;
-                const id = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
-                if (!id) {
-                    return false;
-                }
-                if (runId != null && this.shouldSkipInRun(id, runId)) {
-                    return false;
-                }
-                return ((_b = this.apiRevisionByEntityId[id]) !== null && _b !== void 0 ? _b : 0) === ((_c = revisions[id]) !== null && _c !== void 0 ? _c : 0);
-            });
-        }
-    }
-
-    function isTurfAvailable() {
-        return window && window.turf != null;
-    }
-    /**
-     * Util for simplifying geometry on the fly.
-     */
-    var SimplifyGeometry;
-    (function (SimplifyGeometry) {
-        /**
-         * Returns the total number of points in the geometry.
-         * @param geometry
-         * @param limit number to count up to before returning.
-         * @returns
-         */
-        function CountPoints(geometry, limit) {
-            let count = 0;
-            const traverse = (geometry) => {
-                if (geometry.MultiGeometry) {
-                    for (let i = 0; i < geometry.MultiGeometry.length; i++) {
-                        traverse(geometry.MultiGeometry[i]);
-                        // Reached the limit, return.
-                        if (limit && count >= limit) {
-                            return;
-                        }
-                    }
-                }
-                else if (geometry.Polygon) {
-                    for (let i = 0; i < geometry.Polygon.length; i++) {
-                        const polygon = geometry.Polygon[i];
-                        count += BModels.Geometry.ParsePoints(polygon.LinearRing).length;
-                    }
-                }
-                else if (geometry.LineString) {
-                    count += BModels.Geometry.ParsePoints(geometry.LineString).length;
-                }
-                else if (geometry.Point) {
-                    count += 1;
-                }
-            };
-            traverse(geometry);
-            return count;
-        }
-        SimplifyGeometry.CountPoints = CountPoints;
-        /**
-         * Simplifies input geometry.
-         * This will turn it into GeoJSON, run it through turf, then back to Bruce geometry.
-         * @param geometry
-         */
-        function Simplify(entityId, geometry, tolerance) {
-            var _a;
-            if (!geometry || !isTurfAvailable() || !turf.simplify) {
-                return geometry;
-            }
-            // Convert to geojson so that we can interact with turf.
-            const gFeature = BModels.Geometry.ToGeoJsonFeature({
-                geometry: geometry
-            });
-            // Unkink the geometry.
-            // This removes overlapping polygons before we start merging and simplifying.
-            // Commented out because it has crashes and doesn't handle holes.
-            untangleFeature(gFeature);
-            // Union the geometry.
-            // This merges overlapping polygons.
-            unionFeature(gFeature);
-            // Simplify the geometry.
-            if (tolerance > 0) {
-                gFeature.geometry = turf.simplify(gFeature.geometry, {
-                    tolerance: tolerance,
-                    highQuality: true,
-                    mutate: true
-                });
-            }
-            // Converting back to Bruce geometry.
-            geometry = (_a = BModels.Geometry.FromGeoJson({
-                geoJson: gFeature
-            })) === null || _a === void 0 ? void 0 : _a.geometry;
-            return geometry;
-        }
-        SimplifyGeometry.Simplify = Simplify;
-    })(SimplifyGeometry || (SimplifyGeometry = {}));
-    /**
-     * Runs through all found polygons and runs unkink through turf on them.
-     * @param feature
-     */
-    function untangleFeature(feature) {
-        // Collection to add to because the result might be multiple from an unkink.
-        const collection = {
-            geometries: [],
-            type: "GeometryCollection"
-        };
-        // Runs a dedupe and unkink on the coordinates.
-        // Returns if the coordinates were added to the collection.
-        const processCoordinates = (coords) => {
-            try {
-                // Dedupe the coordinates to avoid issues with unkink.
-                coords = dedupeCoordinates(coords);
-                const outer = [];
-                let inner = [];
-                // We'll unkink each ring separately as this is killing the holes when it is done as a whole.
-                // So we'll do it separate then recombine.
-                for (let i = 0; i < coords.length; i++) {
-                    const ring = coords[i];
-                    const unkink = turf.unkinkPolygon({
-                        type: "Polygon",
-                        coordinates: [ring]
-                    });
-                    if (unkink.type == "FeatureCollection") {
-                        let target = i == 0 ? outer : inner;
-                        for (let j = 0; j < unkink.features.length; j++) {
-                            const unkinked = unkink.features[j].geometry.coordinates;
-                            if (unkinked.length > 0) {
-                                target.push(unkinked[0]);
-                            }
-                        }
-                    }
-                    else {
-                        console.error("Unexpected unkink result.", unkink);
-                    }
-                }
-                // Recreate the rings and reapply to the collection.
-                if (outer.length > 0) {
-                    const combinedCoords = [outer[0]];
-                    for (let i = 0; i < inner.length; i++) {
-                        combinedCoords.push(inner[i]);
-                    }
-                    // Add the combined coordinates to the collection
-                    const polygon = {
-                        type: "Polygon",
-                        coordinates: combinedCoords
-                    };
-                    // Ensure right-hand rule is followed.
-                    ensureRightHandRule(polygon);
-                    // Add to the collection.
-                    collection.geometries.push(polygon);
-                    return true;
-                }
-            }
-            catch (e) {
-                // console.error("Failed to unkink polygon.", e);
-            }
-            return false;
-        };
-        const processGeometry = (geometry) => {
-            let added = false;
-            if (geometry.type == "Polygon") {
-                added = processCoordinates(geometry.coordinates);
-            }
-            else if (geometry.type == "MultiPolygon") {
-                for (let i = 0; i < geometry.coordinates.length; i++) {
-                    added = processCoordinates(geometry.coordinates[i]) || added;
-                }
-            }
-            if (!added) {
-                // Adding original since we can't unkink it.
-                collection.geometries.push(geometry);
-            }
-        };
-        if (feature.geometry.type == "GeometryCollection") {
-            feature.geometry.geometries.forEach((geometry) => {
-                processGeometry(geometry);
-            });
-        }
-        else {
-            processGeometry(feature.geometry);
-        }
-        // Re-assign the geometry.
-        if (collection.geometries.length == 1) {
-            feature.geometry = collection.geometries[0];
-        }
-        else {
-            feature.geometry = collection;
-        }
-    }
-    /**
-     * Runs through all found polygons and unions them using turf.
-     * Failed unions are ignored and the original is kept.
-     * @param feature
-     */
-    function unionFeature(feature) {
-        // Collection to add to because the result might be multiple from an unkink.
-        const collection = {
-            geometries: [],
-            type: "GeometryCollection"
-        };
-        // We'll turn each geometry into a feature and union them.
-        const tmpCollection = {
-            features: [],
-            type: "FeatureCollection"
-        };
-        if (feature.geometry.type == "GeometryCollection") {
-            feature.geometry.geometries.forEach((geometry) => {
-                if (geometry.type == "Polygon") {
-                    tmpCollection.features.push({
-                        type: "Feature",
-                        geometry: geometry,
-                        properties: {}
-                    });
-                }
-                else if (geometry.type == "MultiPolygon") {
-                    for (let i = 0; i < geometry.coordinates.length; i++) {
-                        tmpCollection.features.push({
-                            type: "Feature",
-                            geometry: {
-                                type: "Polygon",
-                                coordinates: geometry.coordinates[i]
-                            },
-                            properties: {}
-                        });
-                    }
-                }
-                // Only focusing on polygons.
-                else {
-                    collection.geometries.push(geometry);
-                }
-            });
-        }
-        else if (feature.geometry.type == "Polygon") {
-            tmpCollection.features.push({
-                type: "Feature",
-                geometry: feature.geometry,
-                properties: {}
-            });
-        }
-        else if (feature.geometry.type == "MultiPolygon") {
-            for (let i = 0; i < feature.geometry.coordinates.length; i++) {
-                tmpCollection.features.push({
-                    type: "Feature",
-                    geometry: {
-                        type: "Polygon",
-                        coordinates: feature.geometry.coordinates[i]
-                    },
-                    properties: {}
-                });
-            }
-        }
-        // No polygons to union.
-        // Need at least 2 to union.
-        if (tmpCollection.features.length < 2) {
-            return;
-        }
-        // Now we'll union them.
-        try {
-            const union = turf.union(tmpCollection);
-            if (union.geometry.type == "Polygon") {
-                collection.geometries.push(union.geometry);
-            }
-            else if (union.geometry.type == "MultiPolygon") {
-                for (let i = 0; i < union.geometry.coordinates.length; i++) {
-                    collection.geometries.push({
-                        type: "Polygon",
-                        coordinates: union.geometry.coordinates[i]
-                    });
-                }
-            }
-            else {
-                // Returning early because the result is unexpected.
-                return;
-            }
-        }
-        catch (e) {
-            // console.error("Failed to union polygons.", e);
-            return;
-        }
-        // Re-assign the geometry.
-        if (collection.geometries.length == 1) {
-            feature.geometry = collection.geometries[0];
-        }
-        else {
-            feature.geometry = collection;
-        }
-    }
-    function dedupeCoordinates(inputCoords) {
-        return inputCoords.map(ring => {
-            if (ring.length < 2) {
-                return ring;
-            }
-            const dedupeCoords = [];
-            const uniqueCoords = new Set();
-            // Dedupe the points.
-            ring.forEach(coord => {
-                const key = coord.join(',');
-                if (!uniqueCoords.has(key)) {
-                    uniqueCoords.add(key);
-                    dedupeCoords.push(coord);
-                }
-            });
-            // Make sure the last point matches the first.
-            if (dedupeCoords.length > 1) {
-                if (dedupeCoords[0][0] != dedupeCoords[dedupeCoords.length - 1][0] ||
-                    dedupeCoords[0][1] != dedupeCoords[dedupeCoords.length - 1][1]) {
-                    dedupeCoords.push(dedupeCoords[0]);
-                }
-            }
-            return dedupeCoords;
-        });
-    }
-    function ensureRightHandRule(polygon) {
-        // Ensure the outer ring follows the right-hand rule
-        if (polygon.coordinates.length > 0) {
-            const outerRing = polygon.coordinates[0];
-            if (isClockwise(outerRing)) {
-                polygon.coordinates[0] = outerRing.reverse();
-            }
-        }
-        // Ensure any inner rings (holes) follow the right-hand rule
-        for (let i = 1; i < polygon.coordinates.length; i++) {
-            const innerRing = polygon.coordinates[i];
-            if (!isClockwise(innerRing)) {
-                polygon.coordinates[i] = innerRing.reverse();
-            }
-        }
-    }
-    function isClockwise(ring) {
-        let sum = 0;
-        for (let i = 0; i < ring.length - 1; i++) {
-            const p1 = ring[i];
-            const p2 = ring[i + 1];
-            sum += (p2[0] - p1[0]) * (p2[1] + p1[1]);
-        }
-        return sum > 0;
-    }
-
     const BATCH_SIZE = 500;
     const CHECK_BATCH_SIZE = 250;
     function getValue$2(viewer, obj) {
@@ -8313,6 +8313,16 @@
                 this.getterSub = null;
                 this.disposed = false;
                 this.renderedEntities = {};
+                // InternalID to public Entity ID, populated when Entity blob is available.
+                // Used to match WS entity-change events (which carry internal ID ranges) to rendered Entities.
+                this.renderedByInternalId = new Map();
+                // Entity ID to internal ID, reverse lookup for cleanup.
+                this.internalByEntityId = new Map();
+                // Cleanup function for the RecordChangeFeed subscription.
+                this.feedSub = null;
+                // Entity IDs waiting for a throttled re-render pass (1s rate limit).
+                this.feedPendingUpdateIds = new Set();
+                this.feedUpdateThrottleTimer = null;
                 this.entityCheckQueue = null;
                 this.entityCheckQueueIds = [];
                 this.entityCheckRemoval = null;
@@ -8477,7 +8487,7 @@
                 }
             }
             setGetter() {
-                var _a, _b, _c, _d;
+                var _a, _b, _c, _d, _e;
                 this.unsetGetter();
                 const isTagItem = Boolean(this.item.BruceEntity.ExpandLayers);
                 let tagsToRender = isTagItem ? this.item.BruceEntity.SelectedExpandLayers : null;
@@ -8535,15 +8545,90 @@
                 this.entityCheckQueue = new BModels.DelayQueue(() => {
                     this.doEntityCheck(Object.keys(this.renderedEntities));
                 }, shouldCheck ? 3000 : 30000);
+                const feed = (_e = this.apiGetter.getApi()) === null || _e === void 0 ? void 0 : _e.RecordChangeFeed;
+                if (feed) {
+                    this.feedSub = feed.Subscribe({
+                        concepts: [BModels.AccountConcept.EConcept.ENTITY],
+                        actions: ["U", "D"]
+                    }, (event) => {
+                        var _a;
+                        if (!this.renderedByInternalId.size) {
+                            return;
+                        }
+                        const rangeStr = typeof event.data === "string" ? event.data : "";
+                        if (!rangeStr) {
+                            return;
+                        }
+                        const affectedIds = [];
+                        for (const [internalId, entityId] of this.renderedByInternalId) {
+                            if (BModels.RecordChangeFeed.isEntityInternalIdInRangeString(rangeStr, internalId)) {
+                                affectedIds.push(entityId);
+                            }
+                        }
+                        if (!affectedIds.length) {
+                            return;
+                        }
+                        // Remove regos directly.
+                        if (event.action === "D") {
+                            for (const entityId of affectedIds) {
+                                this.visualsManager.RemoveRegos({
+                                    entityId,
+                                    menuItemId: this.item.id,
+                                    requestRender: false
+                                });
+                                delete this.renderedEntities[entityId];
+                                (_a = this.clustering) === null || _a === void 0 ? void 0 : _a.RemoveEntity(entityId, false);
+                                const knownId = this.internalByEntityId.get(entityId);
+                                if (knownId != null) {
+                                    this.renderedByInternalId.delete(knownId);
+                                    this.internalByEntityId.delete(entityId);
+                                }
+                            }
+                            if (this.clustering) {
+                                this.clustering.Update();
+                            }
+                            this.viewer.scene.requestRender();
+                        }
+                        // Accumulate IDs and flush at most once per second.
+                        else {
+                            for (const entityId of affectedIds) {
+                                this.feedPendingUpdateIds.add(entityId);
+                            }
+                            if (!this.feedUpdateThrottleTimer) {
+                                this.feedUpdateThrottleTimer = setTimeout(() => {
+                                    this.feedUpdateThrottleTimer = null;
+                                    if (this.disposed || !this.feedPendingUpdateIds.size) {
+                                        return;
+                                    }
+                                    const ids = [...this.feedPendingUpdateIds];
+                                    this.feedPendingUpdateIds.clear();
+                                    this.ReRender({
+                                        entityIds: ids,
+                                        force: true
+                                    });
+                                }, 1000);
+                            }
+                        }
+                    });
+                }
             }
             unsetGetter() {
-                var _a, _b, _c;
+                var _a, _b, _c, _d;
                 (_a = this.getter) === null || _a === void 0 ? void 0 : _a.ExcludeMenuItem(this.item.id);
                 this.getter = null;
                 (_b = this.getterSub) === null || _b === void 0 ? void 0 : _b.call(this);
                 this.getterSub = null;
                 (_c = this.entityCheckQueue) === null || _c === void 0 ? void 0 : _c.Dispose();
                 this.entityCheckQueue = null;
+                (_d = this.feedSub) === null || _d === void 0 ? void 0 : _d.call(this);
+                this.feedSub = null;
+                if (this.feedUpdateThrottleTimer) {
+                    clearTimeout(this.feedUpdateThrottleTimer);
+                    this.feedUpdateThrottleTimer = null;
+                }
+                this.feedPendingUpdateIds.clear();
+                this.renderedByInternalId.clear();
+                this.internalByEntityId.clear();
             }
             preventCurrentCheckApiRefresh(entityIds) {
                 var _a;
@@ -9096,7 +9181,7 @@
                  * @returns
                  */
                 const register = (thing) => {
-                    var _a, _b, _c, _d, _e, _f;
+                    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
                     // See if the cesium entity already exists in a group.
                     let group = groups.find((x) => { var _a; return ((_a = x.visual) === null || _a === void 0 ? void 0 : _a.id) == thing.id || x.siblings.find(x => (x === null || x === void 0 ? void 0 : x.id) == thing.id); });
                     if (group) {
@@ -9140,8 +9225,14 @@
                             cdn: this.item.cdnEnabled,
                             collection: source.entities,
                             outline: (_f = (_e = group.data) === null || _e === void 0 ? void 0 : _e.Bruce) === null || _f === void 0 ? void 0 : _f.Outline,
+                            internalId: (_j = (_h = (_g = group.data) === null || _g === void 0 ? void 0 : _g.Bruce) === null || _h === void 0 ? void 0 : _h.InternalID) !== null && _j !== void 0 ? _j : undefined,
                         };
                         group.rego = rego;
+                        const groupInternalId = (_l = (_k = group.data) === null || _k === void 0 ? void 0 : _k.Bruce) === null || _l === void 0 ? void 0 : _l.InternalID;
+                        if (groupInternalId != null) {
+                            this.renderedByInternalId.set(groupInternalId, entityId);
+                            this.internalByEntityId.set(entityId, groupInternalId);
+                        }
                         this.visualsManager.AddRego({
                             rego,
                             requestRender: false
@@ -9185,7 +9276,7 @@
              * @returns
              */
             async renderAsIndividuals(entities, force = false) {
-                var _a, _b, _c, _d, _e, _f;
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
                 // When live we just want to show the latest pos.
                 // When not live, the user might scroll the timeline and want to see it a fluid animation between points in time.
                 const isLive = exports.ViewUtils.GetTimeDetails({
@@ -9239,13 +9330,25 @@
                     const id = entity.Bruce.ID;
                     const cEntity = cEntities.get(id);
                     this.renderedEntities[id] = !!cEntity;
+                    const internalId = (_c = entity.Bruce) === null || _c === void 0 ? void 0 : _c.InternalID;
+                    if (cEntity && internalId != null) {
+                        this.renderedByInternalId.set(internalId, id);
+                        this.internalByEntityId.set(id, internalId);
+                    }
+                    else if (!cEntity) {
+                        const knownInternalId = this.internalByEntityId.get(id);
+                        if (knownInternalId != null) {
+                            this.renderedByInternalId.delete(knownInternalId);
+                            this.internalByEntityId.delete(id);
+                        }
+                    }
                     if (cEntity) {
                         const rego = this.visualsManager.GetRego({
                             entityId: id,
                             menuItemId: this.item.id
                         });
                         // The baseline data source must be editable.
-                        const canEdit = !((_c = entity.Bruce.Outline) === null || _c === void 0 ? void 0 : _c.find(x => x.Baseline && !x.Editable));
+                        const canEdit = !((_d = entity.Bruce.Outline) === null || _d === void 0 ? void 0 : _d.find(x => x.Baseline && !x.Editable));
                         const visual = rego === null || rego === void 0 ? void 0 : rego.visual;
                         if (!visual || visual != cEntity) {
                             const wasClustered = this.clustering ? this.clustering.AddEntity(id, cEntity, false) : false;
@@ -9264,7 +9367,8 @@
                                 overrideShow: wasClustered ? false : null,
                                 name: cEntity.name,
                                 cdn: this.item.cdnEnabled,
-                                outline: entity.Bruce.Outline
+                                outline: entity.Bruce.Outline,
+                                internalId: (_f = (_e = entity.Bruce) === null || _e === void 0 ? void 0 : _e.InternalID) !== null && _f !== void 0 ? _f : undefined,
                             };
                             this.visualsManager.AddRego({
                                 rego,
@@ -9276,10 +9380,11 @@
                             rego.visual = cEntity;
                             rego.entityTypeId = entity.Bruce["EntityType.ID"];
                             rego.tagIds = entity.Bruce["Layer.ID"] ? [].concat(entity.Bruce["Layer.ID"]) : [];
-                            rego.outline = (_d = entity.Bruce) === null || _d === void 0 ? void 0 : _d.Outline;
+                            rego.outline = (_g = entity.Bruce) === null || _g === void 0 ? void 0 : _g.Outline;
                             rego.cdn = this.item.cdnEnabled;
-                            rego.schema = (_e = entity.Bruce) === null || _e === void 0 ? void 0 : _e.Schema;
+                            rego.schema = (_h = entity.Bruce) === null || _h === void 0 ? void 0 : _h.Schema;
                             rego.canEdit = canEdit;
+                            rego.internalId = (_k = (_j = entity.Bruce) === null || _j === void 0 ? void 0 : _j.InternalID) !== null && _k !== void 0 ? _k : rego.internalId;
                             // Marked as stale meaning some change was performed that requires a refresh.
                             // This usually means a new sibling was added that we need to update.
                             if (rego.stale) {
@@ -9309,7 +9414,7 @@
                             menuItemId: this.item.id,
                             requestRender: false
                         });
-                        (_f = this.clustering) === null || _f === void 0 ? void 0 : _f.RemoveEntity(id, false);
+                        (_l = this.clustering) === null || _l === void 0 ? void 0 : _l.RemoveEntity(id, false);
                     }
                 }
                 this.viewer.scene.requestRender();
@@ -11347,6 +11452,14 @@
             // Entity ID -> styled status.
             // Helps us emit progress events.
             this.styledEntityIds = new Map();
+            // InternalID to Entity ID for Styled Tileset Entities.
+            // Populated when Entity data is available in styleTilesetFeatureFullData.
+            this.styledByInternalId = new Map();
+            // Cleanup function for the RecordChangeFeed subscription.
+            this.feedSub = null;
+            // Entity IDs waiting for a throttled re-style pass (1s rate limit).
+            this.feedPendingRestyleIds = new Set();
+            this.feedRestyleThrottleTimer = null;
             // % progress for how many Entities have been styled so far.
             // This can change as Tiles load in and more queue.
             this._styleProgress = 0;
@@ -11366,7 +11479,7 @@
             return this._styleProgress;
         }
         Init(params) {
-            var _a;
+            var _a, _b;
             let { viewer, api, cTileset, fallbackStyleId, styleMapping, expandSources, menuItemId, register, scenario, historic } = params;
             this.viewer = viewer;
             this.api = api;
@@ -11422,6 +11535,37 @@
             });
             this.loaded = true;
             this.loadStyles();
+            const feed = (_b = this.api) === null || _b === void 0 ? void 0 : _b.RecordChangeFeed;
+            if (feed) {
+                this.feedSub = feed.Subscribe({
+                    concepts: [BModels.AccountConcept.EConcept.ENTITY],
+                    actions: ["U"]
+                }, (event) => {
+                    if (!this.styledByInternalId.size || !this.entityGatherer) {
+                        return;
+                    }
+                    const rangeStr = typeof event.data === "string" ? event.data : "";
+                    if (!rangeStr) {
+                        return;
+                    }
+                    for (const [internalId, entityId] of this.styledByInternalId) {
+                        if (BModels.RecordChangeFeed.isEntityInternalIdInRangeString(rangeStr, internalId)) {
+                            this.feedPendingRestyleIds.add(entityId);
+                        }
+                    }
+                    if (this.feedPendingRestyleIds.size && !this.feedRestyleThrottleTimer) {
+                        this.feedRestyleThrottleTimer = setTimeout(() => {
+                            this.feedRestyleThrottleTimer = null;
+                            if (this.disposed || !this.feedPendingRestyleIds.size || !this.entityGatherer) {
+                                return;
+                            }
+                            const ids = [...this.feedPendingRestyleIds];
+                            this.feedPendingRestyleIds.clear();
+                            this.entityGatherer.Queue(ids, true);
+                        }, 1000);
+                    }
+                });
+            }
         }
         /**
          * Updates style mapping and fallback style.
@@ -11574,11 +11718,19 @@
             });
         }
         Dispose() {
+            var _a;
             if (this.disposed) {
                 return;
             }
             this.disposed = true;
             this._styleProgressQueue.Dispose();
+            (_a = this.feedSub) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.feedSub = null;
+            if (this.feedRestyleThrottleTimer) {
+                clearTimeout(this.feedRestyleThrottleTimer);
+                this.feedRestyleThrottleTimer = null;
+            }
+            this.feedPendingRestyleIds.clear();
             this.disposeGatherer();
         }
         async loadStyles() {
@@ -11754,6 +11906,12 @@
             }
         }
         disposeGatherer() {
+            if (this.feedRestyleThrottleTimer) {
+                clearTimeout(this.feedRestyleThrottleTimer);
+                this.feedRestyleThrottleTimer = null;
+            }
+            this.feedPendingRestyleIds.clear();
+            this.styledByInternalId.clear();
             if (this.entityGatherer) {
                 this.entityGatherer.Dispose();
                 this.entityGatherer = null;
@@ -11816,7 +11974,7 @@
             this.styleTilesetFeatureFullData(rego, null, []);
         }
         styleTilesetFeatureFullData(rego, data, tags) {
-            var _a, _b;
+            var _a, _b, _c;
             const visual = rego.visual;
             if (!visual || !(visual instanceof Cesium.Cesium3DTileFeature)) {
                 return;
@@ -11838,6 +11996,10 @@
                 override: override
             });
             this.overrideFeatureColor.set(rego.entityId, true);
+            if (((_b = data === null || data === void 0 ? void 0 : data.Bruce) === null || _b === void 0 ? void 0 : _b.InternalID) != null) {
+                rego.internalId = data.Bruce.InternalID;
+                this.styledByInternalId.set(data.Bruce.InternalID, rego.entityId);
+            }
             this.styledEntityIds.set(rego.entityId, true);
             this._styleProgressQueue.Call();
             // Since we only need to update it for scenarios right now.
@@ -11846,7 +12008,7 @@
                 // Update the Entity's rego state.
                 let changed = false;
                 if (isOutlineChanged(rego, data)) {
-                    rego.outline = (_b = data === null || data === void 0 ? void 0 : data.Bruce) === null || _b === void 0 ? void 0 : _b.Outline;
+                    rego.outline = (_c = data === null || data === void 0 ? void 0 : data.Bruce) === null || _c === void 0 ? void 0 : _c.Outline;
                     changed = true;
                 }
                 // Something changed, trigger a rego update.
@@ -12877,6 +13039,10 @@
                             viaCdn: false
                         });
                     }
+                    // Should not occur.
+                    if (!tileset.loadUrl && loadUrl) {
+                        tileset.loadUrl = loadUrl;
+                    }
                     // TODO: we shouldn't just assume we'll need it, huge assemblies are 100+ MB.
                     // TODO: this is a problem as we need to know what nodes are collapsed...
                     // In >v1 the model-tree sits in its own file.
@@ -13155,6 +13321,9 @@
                     else if (lowered === "brucepath") {
                         this.featurePropCache.set("brucePath", prop);
                     }
+                    else if (lowered === "internalid") {
+                        this.featurePropCache.set("internalId", prop);
+                    }
                 }
             }
             /**
@@ -13283,6 +13452,14 @@
                         }
                     }
                 }
+                const internalIdProp = this.featurePropCache.get("internalId");
+                if (internalIdProp) {
+                    const raw = feature.getProperty(internalIdProp);
+                    const parsed = raw != null ? +raw : NaN;
+                    if (Number.isInteger(parsed)) {
+                        rego.internalId = parsed;
+                    }
+                }
                 this.loadedCesiumEntities[rego.entityId] = rego;
                 this.visualsManager.AddRego({
                     rego,
@@ -16485,6 +16662,9 @@
                     else if (lowered === "building_id" || lowered === "buildingid") {
                         this.featurePropCache.set("BuildingID", prop);
                     }
+                    else if (lowered === "internalid") {
+                        this.featurePropCache.set("internalId", prop);
+                    }
                 }
             }
             Dispose() {
@@ -16595,6 +16775,14 @@
                         }
                     }
                 }
+                const internalIdProp = this.featurePropCache.get("internalId");
+                if (internalIdProp) {
+                    const raw = feature.getProperty(internalIdProp);
+                    const parsed = raw != null ? +raw : NaN;
+                    if (Number.isInteger(parsed)) {
+                        rego.internalId = parsed;
+                    }
+                }
                 this.loadedCesiumEntities[rego.entityId] = rego;
                 this.visualsManager.AddRego({
                     rego,
@@ -36071,7 +36259,7 @@
         }
     }
 
-    const VERSION = "6.6.4";
+    const VERSION = "6.6.6";
     /**
      * 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.