bruce-cesium 6.6.5 → 6.6.6

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
-import { Cartes, Entity as Entity$1, Calculator, EntityRelationType, EntityType, Style, ENVIRONMENT, ProjectViewTile, DelayQueue, LRUCache, BruceEvent, ObjectUtils, Geometry, EntityHistoricData, EntityLod, ZoomControl, EntityTag, Tileset, EntityCoords, Api, DataLab, EntitySource, ClientFile, MenuItem, EntityRelation, ProgramKey, Bounds, Carto, ProjectView, ProjectViewBookmark, ProjectViewLegacyTile, Camera, AbstractApi, Session, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils } from 'bruce-models';
+import { Cartes, Entity as Entity$1, Geometry, ProjectViewTile, ENVIRONMENT, EntityRelationType, EntityType, Calculator, Style, DelayQueue, LRUCache, BruceEvent, ObjectUtils, AccountConcept, EntityHistoricData, EntityLod, RecordChangeFeed, ZoomControl, EntityTag, Tileset, EntityCoords, Api, DataLab, EntitySource, ClientFile, MenuItem, EntityRelation, ProgramKey, Bounds, Carto, ProjectView, ProjectViewBookmark, ProjectViewLegacyTile, Camera, AbstractApi, Session, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils } from 'bruce-models';
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, Matrix4, DistanceDisplayCondition, HeightReference, ColorBlendMode, ShadowMode, ClassificationType, Model, HorizontalOrigin, VerticalOrigin, ConstantPositionProperty, PolygonHierarchy, PolylineGraphics, ArcType, CornerType, Cartesian2, SceneTransforms, NearFarScalar, Matrix3, Rectangle, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Ion, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, IonResource, Cesium3DTileset, OrthographicFrustum, EasingFunction, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, PolygonPipeline, CesiumInspector, ClockRange, BoundingSphere, GeometryInstance, ScreenSpaceEventHandler, ScreenSpaceEventType, Intersect, CzmlDataSource, Fullscreen } from 'cesium';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, DistanceDisplayCondition, Cartesian3, HeightReference, ClassificationType, PolygonHierarchy, ShadowMode, ConstantPositionProperty, PolylineGraphics, ArcType, CornerType, HorizontalOrigin, VerticalOrigin, Math as Math$1, JulianDate, Quaternion, Transforms, HeadingPitchRoll, Matrix4, ColorBlendMode, Model, Cartesian2, SceneTransforms, NearFarScalar, Matrix3, Rectangle, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Ion, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, IonResource, OrthographicFrustum, EasingFunction, Cesium3DTileset, BoundingSphere, GeometryInstance, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, PolygonPipeline, CesiumInspector, ClockRange, ScreenSpaceEventHandler, ScreenSpaceEventType, Intersect, CzmlDataSource, Fullscreen } from 'cesium';
 
 /**
  * Ensures a number is returned from a given value.
@@ -2582,609 +2582,846 @@ var CesiumEntityStyler;
     CesiumEntityStyler.Unhighlight = Unhighlight;
 })(CesiumEntityStyler || (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 += Geometry.ParsePoints(polygon.LinearRing).length;
+                }
+            }
+            else if (geometry.LineString) {
+                count += 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 = 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 = 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 Entity({
-            polyline: {
-                positions: new CallbackProperty(() => {
-                    return this.curPoints;
-                }, false),
-                width: this.width,
-                material: Color.fromCssColorString(this.color),
-                show: new 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 Entity({
-            position: new CallbackProperty(() => {
-                return this.curPoints.length ? this.curPoints[0] : new Cartesian3();
-            }, false),
-            point: {
-                heightReference: HeightReference.NONE,
-                pixelSize: this.width * 1.3,
-                color: Color.fromCssColorString(this.color),
-                outlineColor: Color.WHITE,
-                outlineWidth: 2,
-                show: new 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 Entity({
-            position: new CallbackProperty(() => {
-                return this.curPoints.length ? this.curPoints[this.curPoints.length - 1] : new Cartesian3();
-            }, false),
-            point: {
-                heightReference: HeightReference.NONE,
-                pixelSize: this.width * 1.8,
-                color: Color.fromCssColorString(this.color),
-                outlineColor: Color.WHITE,
-                outlineWidth: 2,
-                show: new 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 || !Cartes.ValidateCartes3(this.curPos1) || !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 : 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 || !Cartes.ValidateCartes3(p1) || !Cartes.ValidateCartes3(p2)) {
-                    return;
-                }
-                const height1 = Cartographic.fromCartesian(p1).height;
-                const height2 = 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 Cartesian2(0, height1),
-                    new 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 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 } = DrawingUtils.PointAcrossPolyline({
-                viewer: this.viewer,
-                distance: lengthAcross,
-                posses: [this.curPos1, this.curPos2]
-            });
-            const point = Cartographic.fromCartesian(pos3d);
-            const posHeight = getParabolaYFromX(lengthAcross, quadratic);
-            return 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 || !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 ? 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 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 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 EntityType.Get({
-            api,
-            entityTypeId: typeId
-        });
-        if (type["DisplaySetting.ID"]) {
-            try {
-                style = (await 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 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 Entity$1.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 (!Cartes.IsEqualCartes3(posA, posB)) {
+            return false;
         }
-        entities = null;
-        // Gather needed relationship types.
-        // Right now this means just getting the full list.
-        const relationTypes = (await 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;
+var ViewUtils;
+(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) ? Calculator.GetColor(style === null || style === void 0 ? void 0 : style.lineColor, entity, []) : null;
-            const cColor = bColor ? colorToCColor(bColor) : Color.WHITE;
-            let width = EnsureNumber((style === null || style === void 0 ? void 0 : style.lineWidth) ? 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) ? 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) ? 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 EntityUtils.GetLocation({
-                        samples: [{
-                                entity: params.fromEntity,
-                                entityId: params.fromEntity.Bruce.ID,
-                                heightRef: HeightReference.CLAMP_TO_GROUND,
-                                returnHeightRef: HeightReference.NONE
-                            }],
-                        viewer: params.viewer,
-                        visualRegister: params.visualRegister,
-                        api: params.apiGetter.getApi()
-                    });
-                    fromPos = fromData.pos3d;
-                    const toData = await EntityUtils.GetLocation({
-                        samples: [{
-                                entity: params.toEntity,
-                                entityId: params.toEntity.Bruce.ID,
-                                heightRef: HeightReference.CLAMP_TO_GROUND,
-                                returnHeightRef: 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 EllipsoidTerrainProvider) {
+            return {
+                terrain: {
+                    tilesetId: 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 = 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 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 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 (defined(intersection)) {
+                        center = Cartographic.fromCartesian(intersection);
+                    }
+                    // Use current camera position if we can't calculate the center.
+                    else {
+                        center = Cartographic.fromCartesian(viewer.camera.position);
+                        center.height = 0;
+                    }
+                    center.height = viewer.camera.positionCartographic.height + 100;
+                    viewer.camera.setView({
+                        destination: Cartographic.toCartesian(center),
+                        orientation: {
+                            heading: 0.0,
+                            pitch: Math$1.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 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 = JulianDate.fromIso8601(startTimeIso);
+            if (startDate) {
+                clock.startTime = startDate;
+            }
+        }
+        if (currentTime) {
+            clock.currentTime = currentTime;
+        }
+        else if (currentTimeIso) {
+            const currentDate = JulianDate.fromIso8601(currentTimeIso);
+            if (currentDate) {
+                clock.currentTime = currentDate;
+            }
+        }
+        if (stopTime) {
+            clock.stopTime = stopTime;
+        }
+        else if (stopTimeIso) {
+            const stopDate = JulianDate.fromIso8601(stopTimeIso);
+            if (stopDate) {
+                clock.stopTime = stopDate;
+            }
+        }
+        clock.clockRange = 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 = JulianDate.now();
+                clock.startTime = JulianDate.addSeconds(clock.currentTime, -tDetails.livePaddingSeconds, new JulianDate());
+                clock.stopTime = JulianDate.addSeconds(clock.currentTime, tDetails.livePaddingSeconds, new JulianDate());
+                clock.clockRange = 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 = 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;
+})(ViewUtils || (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;
 }
@@ -3872,509 +4109,594 @@ var EntityLabel;
     EntityLabel.GetLabel = GetLabel;
 })(EntityLabel || (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 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 (!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;
-var ViewUtils;
-(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 Entity({
+            polyline: {
+                positions: new CallbackProperty(() => {
+                    return this.curPoints;
+                }, false),
+                width: this.width,
+                material: Color.fromCssColorString(this.color),
+                show: new CallbackProperty(() => {
+                    return !this.hidden;
+                }, false)
             }
-        }
-        return {
-            imagery: tiles.reverse()
-        };
+        });
+        const p1Entity = new Entity({
+            position: new CallbackProperty(() => {
+                return this.curPoints.length ? this.curPoints[0] : new Cartesian3();
+            }, false),
+            point: {
+                heightReference: HeightReference.NONE,
+                pixelSize: this.width * 1.3,
+                color: Color.fromCssColorString(this.color),
+                outlineColor: Color.WHITE,
+                outlineWidth: 2,
+                show: new CallbackProperty(() => {
+                    return !this.hidden;
+                }, false)
+            }
+        });
+        const p2Entity = new Entity({
+            position: new CallbackProperty(() => {
+                return this.curPoints.length ? this.curPoints[this.curPoints.length - 1] : new Cartesian3();
+            }, false),
+            point: {
+                heightReference: HeightReference.NONE,
+                pixelSize: this.width * 1.8,
+                color: Color.fromCssColorString(this.color),
+                outlineColor: Color.WHITE,
+                outlineWidth: 2,
+                show: new 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 || !Cartes.ValidateCartes3(this.curPos1) || !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 : Cartesian3.distance(this.curPos1, this.curPos2);
+        if (TOTAL_LENGTH <= 0) {
+            retry = true;
         }
-        else if (provider instanceof EllipsoidTerrainProvider) {
+        if (retry) {
+            this.retryTimeout = setTimeout(() => {
+                this.Animate();
+            }, 2000);
             return {
-                terrain: {
-                    tilesetId: 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 = 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 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 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 (defined(intersection)) {
-                        center = 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 || !Cartes.ValidateCartes3(p1) || !Cartes.ValidateCartes3(p2)) {
+                    return;
+                }
+                const height1 = Cartographic.fromCartesian(p1).height;
+                const height2 = 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 Cartesian2(0, height1),
+                    new 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 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 = 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: Cartographic.toCartesian(center),
-                        orientation: {
-                            heading: 0.0,
-                            pitch: Math$1.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 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 } = DrawingUtils.PointAcrossPolyline({
+                viewer: this.viewer,
+                distance: lengthAcross,
+                posses: [this.curPos1, this.curPos2]
+            });
+            const point = Cartographic.fromCartesian(pos3d);
+            const posHeight = getParabolaYFromX(lengthAcross, quadratic);
+            return 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 || !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 ? 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 = 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 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 Style.Get({
+                api,
+                styleId
+            })).style;
         }
-        if (currentTime) {
-            clock.currentTime = currentTime;
+        // Probably deleted.
+        catch (e) {
+            console.error(e);
         }
-        else if (currentTimeIso) {
-            const currentDate = JulianDate.fromIso8601(currentTimeIso);
-            if (currentDate) {
-                clock.currentTime = currentDate;
+    }
+    if (!style && typeId) {
+        const { entityType: type } = await EntityType.Get({
+            api,
+            entityTypeId: typeId
+        });
+        if (type["DisplaySetting.ID"]) {
+            try {
+                style = (await Style.Get({
+                    api,
+                    styleId: type["DisplaySetting.ID"]
+                })).style;
             }
-        }
-        if (stopTime) {
-            clock.stopTime = stopTime;
-        }
-        else if (stopTimeIso) {
-            const stopDate = 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 = 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 Entity$1.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 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 = JulianDate.now();
-                clock.startTime = JulianDate.addSeconds(clock.currentTime, -tDetails.livePaddingSeconds, new JulianDate());
-                clock.stopTime = JulianDate.addSeconds(clock.currentTime, tDetails.livePaddingSeconds, new JulianDate());
-                clock.clockRange = 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 = 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) ? Calculator.GetColor(style === null || style === void 0 ? void 0 : style.lineColor, entity, []) : null;
+            const cColor = bColor ? colorToCColor(bColor) : Color.WHITE;
+            let width = EnsureNumber((style === null || style === void 0 ? void 0 : style.lineWidth) ? 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) ? 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) ? 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 EntityUtils.GetLocation({
+                        samples: [{
+                                entity: params.fromEntity,
+                                entityId: params.fromEntity.Bruce.ID,
+                                heightRef: HeightReference.CLAMP_TO_GROUND,
+                                returnHeightRef: HeightReference.NONE
+                            }],
+                        viewer: params.viewer,
+                        visualRegister: params.visualRegister,
+                        api: params.apiGetter.getApi()
+                    });
+                    fromPos = fromData.pos3d;
+                    const toData = await EntityUtils.GetLocation({
+                        samples: [{
+                                entity: params.toEntity,
+                                entityId: params.toEntity.Bruce.ID,
+                                heightRef: HeightReference.CLAMP_TO_GROUND,
+                                returnHeightRef: 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;
-})(ViewUtils || (ViewUtils = {}));
+        Parabola.Render = Render;
+    })(Parabola = RelationRenderEngine.Parabola || (RelationRenderEngine.Parabola = {}));
+})(RelationRenderEngine || (RelationRenderEngine = {}));
 
 const MODEL_MIN_RADIUS = 10;
 const POINT_MIN_RADIUS = 15;
@@ -7038,6 +7360,116 @@ var VisualsRegister;
     VisualsRegister.Register = Register;
 })(VisualsRegister || (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;
@@ -7857,438 +8289,6 @@ class PointClustering {
     }
 }
 
-/**
- * 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 += Geometry.ParsePoints(polygon.LinearRing).length;
-                }
-            }
-            else if (geometry.LineString) {
-                count += 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 = 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 = 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) {
@@ -8333,6 +8333,16 @@ var EntitiesRenderManager;
             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;
@@ -8497,7 +8507,7 @@ var EntitiesRenderManager;
             }
         }
         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;
@@ -8555,15 +8565,90 @@ var EntitiesRenderManager;
             this.entityCheckQueue = new 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: [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 (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;
@@ -9116,7 +9201,7 @@ var EntitiesRenderManager;
              * @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) {
@@ -9160,8 +9245,14 @@ var EntitiesRenderManager;
                         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
@@ -9205,7 +9296,7 @@ var EntitiesRenderManager;
          * @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 = ViewUtils.GetTimeDetails({
@@ -9259,13 +9350,25 @@ var EntitiesRenderManager;
                 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;
@@ -9284,7 +9387,8 @@ var EntitiesRenderManager;
                             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,
@@ -9296,10 +9400,11 @@ var EntitiesRenderManager;
                         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) {
@@ -9329,7 +9434,7 @@ var EntitiesRenderManager;
                         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();
@@ -11382,6 +11487,14 @@ class TilesetStyler {
         // 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;
@@ -11401,7 +11514,7 @@ class TilesetStyler {
         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;
@@ -11457,6 +11570,37 @@ class TilesetStyler {
         });
         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: [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 (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.
@@ -11609,11 +11753,19 @@ class TilesetStyler {
         });
     }
     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() {
@@ -11789,6 +11941,12 @@ class TilesetStyler {
         }
     }
     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;
@@ -11851,7 +12009,7 @@ class TilesetStyler {
         this.styleTilesetFeatureFullData(rego, null, []);
     }
     styleTilesetFeatureFullData(rego, data, tags) {
-        var _a, _b;
+        var _a, _b, _c;
         const visual = rego.visual;
         if (!visual || !(visual instanceof Cesium3DTileFeature)) {
             return;
@@ -11873,6 +12031,10 @@ class TilesetStyler {
             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.
@@ -11881,7 +12043,7 @@ class TilesetStyler {
             // 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.
@@ -13200,6 +13362,9 @@ var TilesetCadRenderManager;
                 else if (lowered === "brucepath") {
                     this.featurePropCache.set("brucePath", prop);
                 }
+                else if (lowered === "internalid") {
+                    this.featurePropCache.set("internalId", prop);
+                }
             }
         }
         /**
@@ -13328,6 +13493,14 @@ var TilesetCadRenderManager;
                     }
                 }
             }
+            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,
@@ -16536,6 +16709,9 @@ var TilesetEntitiesRenderManager;
                 else if (lowered === "building_id" || lowered === "buildingid") {
                     this.featurePropCache.set("BuildingID", prop);
                 }
+                else if (lowered === "internalid") {
+                    this.featurePropCache.set("internalId", prop);
+                }
             }
         }
         Dispose() {
@@ -16646,6 +16822,14 @@ var TilesetEntitiesRenderManager;
                     }
                 }
             }
+            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,
@@ -36186,7 +36370,7 @@ class WidgetViewBar extends Widget.AWidget {
     }
 }
 
-const VERSION = "6.6.5";
+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.