bruce-cesium 7.6.1 → 7.6.2

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, ConstantPositionProperty, HeightReference, DistanceDisplayCondition, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, Matrix4, ShaderSource, Ellipsoid, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, PixelDatatype, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, ColorBlendMode, ShadowMode, ClassificationType, Model, HorizontalOrigin, VerticalOrigin, ArcType, CornerType, SceneMode, IntersectionTests, Ray, SceneTransforms, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, FeatureDetection, Matrix3, NearFarScalar, KmlDataSource, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Ion, IonResource, Cesium3DTileset, OrthographicFrustum, EasingFunction, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Intersect, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, PolygonPipeline, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, GeometryInstance, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, CustomDataSource, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
-import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Calculator, ClientFile, Entity as Entity$1, EntityLod, EntityTag, EntityType, ObjectUtils, Style, UrlUtils, Api, Carto, Geometry as Geometry$1, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, Bounds, ClientFileValueMap, Color as Color$1, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, BruceApi, EntityRelation, RecordChangeFeed, EntitySource, Camera, ProgramKey, ProjectViewLegacyTile, Account, AccountLimits, Session, ProjectViewBookmarkGroup, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, EntityRelationType, EntityHistoricData } from 'bruce-models';
+import { Cartographic, Entity, ConstantPositionProperty, HeightReference, Color, DistanceDisplayCondition, ColorMaterialProperty, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, ColorBlendMode, HeadingPitchRoll, Math as Math$1, Transforms, ShadowMode, Cartesian3, ClassificationType, Model, JulianDate, Quaternion, Matrix4, HorizontalOrigin, VerticalOrigin, ShaderSource, Ellipsoid, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, PixelDatatype, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, ArcType, CornerType, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, SceneMode, IntersectionTests, Ray, SceneTransforms, FeatureDetection, Matrix3, NearFarScalar, KmlDataSource, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileColorBlendMode, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Cesium3DTileset, OrthographicFrustum, EasingFunction, Intersect, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, PolygonPipeline, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, CustomDataSource, GeometryInstance, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
+import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Calculator, ClientFile, Entity as Entity$1, EntityLod, EntityTag, EntityType, ObjectUtils, Style, UrlUtils, Api, Carto, Geometry as Geometry$1, Bounds, ClientFileValueMap, Color as Color$1, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, BruceApi, EntityRelation, RecordChangeFeed, EntitySource, ProgramKey, ProjectViewLegacyTile, Camera, Account, AccountLimits, Session, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType, EntityHistoricData } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -2623,13 +2623,13 @@ var CesiumAnimatedProperty;
     class AnimateTPositionSeries {
         constructor(params) {
             this.lastCalcAttitude = null;
-            // Cache for calculated values.
+            // Cache for calculated values: the scene time and set of positions they were worked out for.
             this.lastCalcTime = null;
+            this.lastCalcRevision = -1;
             this.lastCalcPos3d = null;
-            this.lastCalcPosApplyOverTime = false;
-            this.lastCalcPos3dApplyOverTimeTarget = null;
-            this.lastCalcPos3dApplyOverTimeTimeStart = null;
             this.lastCalcHeading = null;
+            // Bumped whenever the positions change, so a still clock re-applies a changed series.
+            this.revision = 0;
             this.removal = null;
             // Track the timeline range for which we have data.
             this.minDate = null;
@@ -2659,6 +2659,7 @@ var CesiumAnimatedProperty;
             if (!newPositions || newPositions.length === 0) {
                 return;
             }
+            this.revision++;
             // Add new positions to our map, overwriting any existing positions with the same timestamp
             for (const pos of newPositions) {
                 const key = pos.dateTime.toISOString();
@@ -2682,6 +2683,17 @@ var CesiumAnimatedProperty;
                 }
             }
         }
+        /**
+         * Replaces every position with these, eg. once some that were simulated have been cleared.
+         * @param positions Positions to animate through from now on.
+         */
+        replacePositions(positions) {
+            this.positionsMap.clear();
+            this.positions = [];
+            this.minDate = null;
+            this.maxDate = null;
+            this.addPositions(positions);
+        }
         /**
          * Get the current date range covered by our positions.
          */
@@ -2729,106 +2741,47 @@ var CesiumAnimatedProperty;
         /*
          * Returns the attitude of the record at an index, or nothing recorded when it names none.
          */
-        attitudeAt(index) {
-            var _a, _b, _c;
-            const pos = index >= 0 ? (_a = this.positions) === null || _a === void 0 ? void 0 : _a[index] : null;
-            return { pitch: (_b = pos === null || pos === void 0 ? void 0 : pos.pitch) !== null && _b !== void 0 ? _b : null, roll: (_c = pos === null || pos === void 0 ? void 0 : pos.roll) !== null && _c !== void 0 ? _c : null };
+        /*
+         * Pitch and roll between two positions the short way round; an angle only one names is held.
+         */
+        attitudeBetween(indexLast, indexNext, timeMs) {
+            var _a, _b, _c, _d, _e, _f;
+            const a = indexLast >= 0 ? (_a = this.positions) === null || _a === void 0 ? void 0 : _a[indexLast] : null;
+            const b = indexNext >= 0 ? (_b = this.positions) === null || _b === void 0 ? void 0 : _b[indexNext] : null;
+            const span = a && b ? b.dateTime.getTime() - a.dateTime.getTime() : 0;
+            const t = span > 0 ? (timeMs - a.dateTime.getTime()) / span : 0;
+            const turn = (x, y) => {
+                if (x == null || y == null) {
+                    return x !== null && x !== void 0 ? x : null;
+                }
+                return x + (Math$1.negativePiToPi(Math$1.toRadians(y - x)) * 180 / Math.PI) * t;
+            };
+            return { pitch: turn((_c = a === null || a === void 0 ? void 0 : a.pitch) !== null && _c !== void 0 ? _c : null, (_d = b === null || b === void 0 ? void 0 : b.pitch) !== null && _d !== void 0 ? _d : null), roll: turn((_e = a === null || a === void 0 ? void 0 : a.roll) !== null && _e !== void 0 ? _e : null, (_f = b === null || b === void 0 ? void 0 : b.roll) !== null && _f !== void 0 ? _f : null) };
         }
+        /*
+         * Places the series at the scene's time, exactly rather than eased, so what moves with it never lags the clock.
+         */
         update() {
+            var _a;
             if (!this.positions || this.positions.length === 0) {
                 return;
             }
-            // Get current time.
-            let now = this.viewer.scene.lastRenderTime || this.viewer.clock.currentTime;
-            const nowTime = JulianDate.toDate(now);
-            const nowTimeMs = nowTime.getTime();
-            const currentRealTimeMs = Date.now();
-            // Calculate the ideal position based on current time.
-            const targetPosition = this.calculatePosition(nowTimeMs);
-            // Initialize if this is the first update.
-            if (!this.lastCalcPos3d) {
-                this.lastCalcPos3d = targetPosition.pos3d;
-                this.lastCalcAttitude = this.attitudeAt(targetPosition.indexLast);
-                this.onUpdate(targetPosition.pos3d, this.lastCalcHeading, this.lastCalcAttitude);
-                return;
-            }
-            // Check if target has changed.
-            if (!this.lastCalcPos3dApplyOverTimeTarget ||
-                !Cartesian3.equals(this.lastCalcPos3dApplyOverTimeTarget, targetPosition.pos3d)) {
-                // If we were already interpolating, get the current interpolated position as our new starting point.
-                if (this.lastCalcPosApplyOverTime && this.lastCalcPos3dApplyOverTimeTimeStart) {
-                    // Calculate where we are in the current interpolation.
-                    const currentInterpolatedPos = this.interpolatePos3dOverTime(this.lastCalcPos3dApplyOverTimeTimeStart, currentRealTimeMs);
-                    // Use this as our new starting position.
-                    this.lastCalcPos3d = currentInterpolatedPos;
-                }
-                // Set new target and start time.
-                this.lastCalcPos3dApplyOverTimeTarget = targetPosition.pos3d;
-                this.lastCalcPos3dApplyOverTimeTimeStart = currentRealTimeMs;
-                this.lastCalcPosApplyOverTime = true;
-            }
-            // Calculate the interpolated position.
-            let pos3d;
-            if (this.lastCalcPosApplyOverTime) {
-                pos3d = this.interpolatePos3dOverTime(this.lastCalcPos3dApplyOverTimeTimeStart, currentRealTimeMs);
-                // If we've reached the target, update our base position.
-                if (Cartesian3.distance(pos3d, this.lastCalcPos3dApplyOverTimeTarget) < 0.01) {
-                    this.lastCalcPos3d = this.lastCalcPos3dApplyOverTimeTarget;
-                    this.lastCalcPosApplyOverTime = false;
-                }
+            // The clock's time is the frame being drawn; the last render time is the frame before it.
+            const nowTimeMs = JulianDate.toDate(this.viewer.clock.currentTime).getTime();
+            if (nowTimeMs === this.lastCalcTime && this.revision === this.lastCalcRevision) {
+                return;
             }
-            else {
-                pos3d = this.lastCalcPos3d;
-            }
-            // Calculate heading.
-            if (this.lastCalcPos3dApplyOverTimeTarget) {
-                if (this.lastCalcPos3d) {
-                    const minDistanceThreshold = 0.05;
-                    const currentToTargetDistance = Cartesian3.distance(this.lastCalcPos3d, this.lastCalcPos3dApplyOverTimeTarget);
-                    if (currentToTargetDistance >= minDistanceThreshold) {
-                        const lastPos = {
-                            pos3d: this.lastCalcPos3d,
-                            dateTime: this.lastCalcPos3dApplyOverTimeTimeStart ? new Date(this.lastCalcPos3dApplyOverTimeTimeStart) : null,
-                            heading: null
-                        };
-                        const nextPos = {
-                            pos3d: this.lastCalcPos3dApplyOverTimeTarget,
-                            dateTime: null,
-                            heading: null
-                        };
-                        if (lastPos && nextPos) {
-                            this.lastCalcHeading = this.calculateHeading(nowTimeMs, lastPos, nextPos);
-                        }
-                    }
-                }
+            this.lastCalcTime = nowTimeMs;
+            this.lastCalcRevision = this.revision;
+            const target = this.calculatePosition(nowTimeMs);
+            const lastPos = this.positions[target.indexLast];
+            const nextPos = this.positions[target.indexNext];
+            if (lastPos && nextPos) {
+                this.lastCalcHeading = (_a = this.calculateHeading(nowTimeMs, lastPos, nextPos)) !== null && _a !== void 0 ? _a : this.lastCalcHeading;
             }
-            else {
-                const posses = this.positions;
-                const lastPos = posses[targetPosition.indexLast];
-                const nextPos = posses[targetPosition.indexNext];
-                if (lastPos && nextPos) {
-                    this.lastCalcHeading = this.calculateHeading(nowTimeMs, lastPos, nextPos);
-                }
-            }
-            // Provide the calculated values to the caller.
-            this.lastCalcAttitude = this.attitudeAt(targetPosition.indexLast);
-            this.onUpdate(pos3d, this.lastCalcHeading, this.lastCalcAttitude);
-        }
-        interpolatePos3dOverTime(startTimeMs, currentTimeMs) {
-            const lastPos = this.lastCalcPos3d;
-            const targetPos = this.lastCalcPos3dApplyOverTimeTarget;
-            if (!lastPos || !targetPos) {
-                return lastPos ? lastPos : targetPos;
-            }
-            const interpolationDuration = 200;
-            const elapsedTime = currentTimeMs - startTimeMs;
-            let progress = Math.min(elapsedTime / interpolationDuration, 1.0);
-            // Optional step to make it smoother.
-            progress = this.easeInOutQuad(progress);
-            return Cartesian3.lerp(lastPos, targetPos, progress, new Cartesian3());
-        }
-        easeInOutQuad(t) {
-            return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+            this.lastCalcPos3d = target.pos3d;
+            this.lastCalcAttitude = this.attitudeBetween(target.indexLast, target.indexNext, nowTimeMs);
+            this.onUpdate(target.pos3d, this.lastCalcHeading, this.lastCalcAttitude);
         }
         /**
          * Pre-process headings in the series.
@@ -2854,14 +2807,14 @@ var CesiumAnimatedProperty;
          * Calculate the position at the given time.
          */
         calculatePosition(currentTimeMs) {
+            var _a, _b;
             const posses = this.positions;
             // No positions to interpolate
             if (!posses || posses.length === 0) {
                 return {
                     pos3d: new Cartesian3(),
                     indexLast: -1,
-                    indexNext: -1,
-                    applyOverTime: false
+                    indexNext: -1
                 };
             }
             // See if we're before the first position.
@@ -2869,8 +2822,7 @@ var CesiumAnimatedProperty;
                 return {
                     pos3d: posses[0].pos3d,
                     indexLast: 0,
-                    indexNext: 0,
-                    applyOverTime: true
+                    indexNext: 0
                 };
             }
             // See if we're after the last position.
@@ -2879,8 +2831,7 @@ var CesiumAnimatedProperty;
                 return {
                     pos3d: posses[lastIndex].pos3d,
                     indexLast: lastIndex,
-                    indexNext: lastIndex,
-                    applyOverTime: true
+                    indexNext: lastIndex
                 };
             }
             // Binary search to find the closest position.
@@ -2906,20 +2857,25 @@ var CesiumAnimatedProperty;
                 return {
                     pos3d: last.pos3d,
                     indexLast: lastIndex,
-                    indexNext: lastIndex,
-                    applyOverTime: true
+                    indexNext: lastIndex
                 };
             }
             // Interpolate between the two closest positions.
             const lastTime = last.dateTime.getTime();
             const nextTime = next.dateTime.getTime();
             const progress = (currentTimeMs - lastTime) / (nextTime - lastTime);
-            const interpolatedPos = Cartesian3.lerp(last.pos3d, next.pos3d, progress, new Cartesian3());
+            // A straight line between two points on a curved path cuts inside it, so it is lifted back out.
+            const chord = Cartesian3.lerp(last.pos3d, next.pos3d, progress, new Cartesian3());
+            const chordCarto = Cartographic.fromCartesian(chord);
+            const lastHeight = (_a = Cartographic.fromCartesian(last.pos3d)) === null || _a === void 0 ? void 0 : _a.height;
+            const nextHeight = (_b = Cartographic.fromCartesian(next.pos3d)) === null || _b === void 0 ? void 0 : _b.height;
+            const interpolatedPos = chordCarto && lastHeight != null && nextHeight != null
+                ? Cartesian3.fromRadians(chordCarto.longitude, chordCarto.latitude, Math$1.lerp(lastHeight, nextHeight, progress))
+                : chord;
             return {
                 pos3d: interpolatedPos,
                 indexLast: lastIndex,
-                indexNext: nextIndex,
-                applyOverTime: false
+                indexNext: nextIndex
             };
         }
         /**
@@ -5493,6 +5449,485 @@ function ClusterItems(params) {
     return result;
 }
 
+/**
+ * Entity data a caller asserts instead of what the API says, held for every menu item until it is cleared.
+ */
+var EntitySimulation;
+(function (EntitySimulation) {
+    const VIEWER_KEY = "_nextspaceSimulation";
+    /**
+     * The set used when a caller does not name one.
+     */
+    EntitySimulation.DEFAULT_SET = "default";
+    // Record parts replaced whole rather than merged field by field, eg. a matrix or a geometry.
+    const WHOLE_RECORD_PARTS = new Set(["geometry", "boundaries", "assemblyPosition"]);
+    // Record parts that carry Entity data, in the order they are laid over an Entity.
+    const RECORD_PARTS = ["location", "transform", "geometry", "boundaries", "assemblyPosition", "data"];
+    /**
+     * The store for a viewer, made on first use and shared by everything drawing into that scene.
+     */
+    function Get(viewer) {
+        if (!viewer) {
+            return null;
+        }
+        if (!viewer[VIEWER_KEY]) {
+            viewer[VIEWER_KEY] = new Store();
+        }
+        return viewer[VIEWER_KEY];
+    }
+    EntitySimulation.Get = Get;
+    function isPlainObject(value) {
+        return value != null && typeof value === "object" && !Array.isArray(value);
+    }
+    // Entity values replaced whole by a patch, since half of one geometry over another describes neither.
+    const WHOLE_ENTITY_PARTS = new Set(["VectorGeometry", "Boundaries", "AssemblyPosition"]);
+    /**
+     * Returns base with patch laid over it: objects merge key by key, anything else replaces.
+     * @param whole names keys at the top level, or under Bruce, whose value is replaced rather than merged.
+     */
+    function Overlay(base, patch, whole = WHOLE_ENTITY_PARTS) {
+        const lay = (into, over, depth, underBruce) => {
+            if (over === undefined) {
+                return into;
+            }
+            if (!isPlainObject(over) || !isPlainObject(into)) {
+                return over;
+            }
+            const merged = { ...into };
+            for (const key of Object.keys(over)) {
+                const replace = (depth === 0 || underBruce) && whole.has(key);
+                merged[key] = replace ? over[key] : lay(merged[key], over[key], depth + 1, depth === 0 && key === "Bruce");
+            }
+            return merged;
+        };
+        return lay(base, patch, 0, false);
+    }
+    EntitySimulation.Overlay = Overlay;
+    /*
+     * Lays one record's parts over another's, each part replaced whole where a part is one value.
+     */
+    function overlayRecord(base, over) {
+        return Overlay(base, over, WHOLE_RECORD_PARTS);
+    }
+    /**
+     * Each value a record names, as a path into the record. A part replaced whole is one value.
+     */
+    function recordPaths(record) {
+        const paths = [];
+        const walk = (value, path) => {
+            if (isPlainObject(value) && !(path.length === 1 && WHOLE_RECORD_PARTS.has(path[0]))) {
+                for (const key of Object.keys(value)) {
+                    walk(value[key], [...path, key]);
+                }
+                return;
+            }
+            if (value !== undefined) {
+                paths.push(path);
+            }
+        };
+        for (const part of RECORD_PARTS) {
+            if ((record === null || record === void 0 ? void 0 : record[part]) != null) {
+                walk(record[part], [part]);
+            }
+        }
+        return paths;
+    }
+    /*
+     * A copy of the record without the values at these paths, dropping objects left empty.
+     */
+    function withoutPaths(record, paths) {
+        const strip = (value, path) => {
+            if (!isPlainObject(value) || !(path[0] in value)) {
+                return value;
+            }
+            const copy = { ...value };
+            if (path.length === 1) {
+                delete copy[path[0]];
+            }
+            else {
+                const inner = strip(copy[path[0]], path.slice(1));
+                if (isPlainObject(inner) && !Object.keys(inner).length) {
+                    delete copy[path[0]];
+                }
+                else {
+                    copy[path[0]] = inner;
+                }
+            }
+            return copy;
+        };
+        let stripped = record;
+        for (const path of paths) {
+            stripped = strip(stripped, path);
+        }
+        return stripped;
+    }
+    /*
+     * Whether a record still says anything about its Entity.
+     */
+    function hasContent(record) {
+        return RECORD_PARTS.some(part => {
+            const value = record === null || record === void 0 ? void 0 : record[part];
+            return value != null && !(isPlainObject(value) && !Object.keys(value).length);
+        });
+    }
+    function timeOf(record) {
+        return (record === null || record === void 0 ? void 0 : record.dateTime) ? new Date(record.dateTime).getTime() : NaN;
+    }
+    class Store {
+        constructor() {
+            // Insertion order is precedence: a later set wins.
+            this.sets = new Map();
+            this.onChanged = new BruceEvent();
+        }
+        /**
+         * Triggered after anything is simulated or cleared, naming the Entities affected.
+         */
+        get OnChanged() {
+            return this.onChanged;
+        }
+        /**
+         * Whether anything at all is simulated, so a caller can skip the work when nothing is.
+         */
+        get IsEmpty() {
+            for (const set of this.sets.values()) {
+                if (set.entities.size || set.patches.size || set.records.size) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        /**
+         * The names of the sets holding anything, oldest first.
+         */
+        GetSets() {
+            return Array.from(this.sets.keys());
+        }
+        /**
+         * The time each set's records span, oldest set first, for sets holding any records.
+         */
+        GetSetRanges() {
+            const ranges = [];
+            for (const [name, set] of this.sets) {
+                let startMs = Infinity;
+                let endMs = -Infinity;
+                for (const byTime of set.records.values()) {
+                    for (const ms of byTime.keys()) {
+                        startMs = Math.min(startMs, ms);
+                        endMs = Math.max(endMs, ms);
+                    }
+                }
+                if (set.records.size) {
+                    ranges.push({ set: name, startMs, endMs, entityIds: Array.from(set.records.keys()) });
+                }
+            }
+            return ranges;
+        }
+        setFor(name) {
+            const key = name || EntitySimulation.DEFAULT_SET;
+            let set = this.sets.get(key);
+            if (!set) {
+                set = { entities: new Map(), patches: new Map(), records: new Map() };
+                this.sets.set(key, set);
+            }
+            return set;
+        }
+        /**
+         * Replaces the stand-in for each Entity given, within a set.
+         */
+        SetEntities(entities, set) {
+            this.setBlobs(entities, set, false);
+        }
+        /**
+         * Replaces the patch for each Entity given, within a set. A patch names only the data it changes.
+         */
+        SetPatches(patches, set) {
+            this.setBlobs(patches, set, true);
+        }
+        setBlobs(blobs, set, patch) {
+            var _a;
+            const ids = [];
+            for (const blob of blobs || []) {
+                const id = (_a = blob === null || blob === void 0 ? void 0 : blob.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
+                if (!id) {
+                    continue;
+                }
+                const held = this.setFor(set);
+                (patch ? held.patches : held.entities).set(id, blob);
+                ids.push(id);
+            }
+            if (ids.length) {
+                this.onChanged.Trigger({ entityIds: ids, entities: true, records: false, set: set || EntitySimulation.DEFAULT_SET });
+            }
+        }
+        /**
+         * Adds records to each Entity's simulated history within a set, replacing any at the same instant.
+         */
+        SetRecords(records, set) {
+            const ids = new Set();
+            for (const record of records || []) {
+                const id = record === null || record === void 0 ? void 0 : record.entityId;
+                const timeMs = timeOf(record);
+                if (!id || isNaN(timeMs)) {
+                    continue;
+                }
+                const held = this.setFor(set);
+                let byTime = held.records.get(id);
+                if (!byTime) {
+                    byTime = new Map();
+                    held.records.set(id, byTime);
+                }
+                byTime.set(timeMs, record);
+                ids.add(id);
+            }
+            if (ids.size) {
+                this.onChanged.Trigger({ entityIds: Array.from(ids), entities: false, records: true, set: set || EntitySimulation.DEFAULT_SET });
+            }
+        }
+        /**
+         * Forgets what is simulated for these Entities, or for every Entity when none are named.
+         * @param params.set the set to clear. By default every set.
+         * @param params.entities clear the stand-ins and patches. Default true.
+         * @param params.records clear the historic records. Default true.
+         */
+        Clear(params) {
+            var _a, _b;
+            const entities = (params === null || params === void 0 ? void 0 : params.entities) !== false;
+            const records = (params === null || params === void 0 ? void 0 : params.records) !== false;
+            const names = (params === null || params === void 0 ? void 0 : params.set) ? [params.set] : Array.from(this.sets.keys());
+            const cleared = new Set();
+            for (const name of names) {
+                const set = this.sets.get(name);
+                if (!set) {
+                    continue;
+                }
+                const ids = (_a = params === null || params === void 0 ? void 0 : params.entityIds) !== null && _a !== void 0 ? _a : [...set.entities.keys(), ...set.patches.keys(), ...set.records.keys()];
+                for (const id of ids) {
+                    const hadEntity = entities && set.entities.delete(id);
+                    const hadPatch = entities && set.patches.delete(id);
+                    const hadRecords = records && set.records.delete(id);
+                    if (hadEntity || hadPatch || hadRecords) {
+                        cleared.add(id);
+                    }
+                }
+                if (!set.entities.size && !set.patches.size && !set.records.size) {
+                    this.sets.delete(name);
+                }
+            }
+            if (cleared.size) {
+                this.onChanged.Trigger({ entityIds: Array.from(cleared), entities, records, set: (_b = params === null || params === void 0 ? void 0 : params.set) !== null && _b !== void 0 ? _b : null });
+            }
+        }
+        /**
+         * The Entity's stand-in, with any patches laid over it, or null when nothing stands in for it.
+         */
+        GetEntity(entityId) {
+            var _a;
+            let standIn = null;
+            for (const set of this.sets.values()) {
+                standIn = (_a = set.entities.get(entityId)) !== null && _a !== void 0 ? _a : standIn;
+            }
+            return standIn ? this.Overlay(standIn) : null;
+        }
+        /**
+         * Whether a stand-in replaces this Entity, so the API need not be asked for it.
+         */
+        HasEntity(entityId) {
+            for (const set of this.sets.values()) {
+                if (set.entities.has(entityId)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        /**
+         * Whether a stand-in or a patch changes this Entity.
+         */
+        HasBlob(entityId) {
+            for (const set of this.sets.values()) {
+                if (set.entities.has(entityId) || set.patches.has(entityId)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        /**
+         * Returns an Entity with its simulated patches laid over it. The input is never changed.
+         */
+        Overlay(entity) {
+            var _a;
+            const id = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
+            if (!id) {
+                return entity;
+            }
+            let result = entity;
+            for (const set of this.sets.values()) {
+                const patch = set.patches.get(id);
+                if (patch) {
+                    result = Overlay(result, patch);
+                }
+            }
+            return result;
+        }
+        /**
+         * The Entity as simulated: its stand-in if there is one, otherwise what was read with patches laid over it.
+         * @param entityId the Entity.
+         * @param read what the API gave for it, if it was asked.
+         */
+        Resolve(entityId, read) {
+            var _a;
+            return (_a = this.GetEntity(entityId)) !== null && _a !== void 0 ? _a : (read ? this.Overlay(read) : null);
+        }
+        /**
+         * Every Entity with a simulated stand-in or patch.
+         */
+        GetEntityIds() {
+            const ids = new Set();
+            for (const set of this.sets.values()) {
+                set.entities.forEach((_, id) => ids.add(id));
+                set.patches.forEach((_, id) => ids.add(id));
+            }
+            return Array.from(ids);
+        }
+        /**
+         * Every Entity with simulated history.
+         */
+        GetRecordEntityIds() {
+            const ids = new Set();
+            for (const set of this.sets.values()) {
+                set.records.forEach((_, id) => ids.add(id));
+            }
+            return Array.from(ids);
+        }
+        /**
+         * An Entity's simulated history for a historic key, oldest first, every set's record at an instant merged.
+         */
+        GetRecords(entityId, attrKey) {
+            const byTime = new Map();
+            for (const set of this.sets.values()) {
+                for (const [ms, record] of set.records.get(entityId) || []) {
+                    if (attrKey && record.attrKey && record.attrKey !== attrKey) {
+                        continue;
+                    }
+                    const held = byTime.get(ms);
+                    byTime.set(ms, held ? overlayRecord(held, record) : record);
+                }
+            }
+            return Array.from(byTime.entries()).sort(([a], [b]) => a - b).map(([, record]) => record);
+        }
+        /**
+         * Each value an Entity's simulated history names, with the instant from which it is the simulation's.
+         */
+        ownedFrom(records) {
+            const owned = new Map();
+            for (const record of records) {
+                const ms = timeOf(record);
+                for (const path of recordPaths(record)) {
+                    const key = path.join("\u0000");
+                    if (!owned.has(key)) {
+                        owned.set(key, { path, fromMs: ms });
+                    }
+                }
+            }
+            return Array.from(owned.values());
+        }
+        /**
+         * An Entity as it stands at an instant, with each value its simulated records have named by then laid over it.
+         * @param entity the Entity as read for that instant, from the API or a simulated stand-in.
+         * @param timeMs the instant in milliseconds.
+         * @param attrKey the historic attribute key being followed, or null for any.
+         */
+        ApplyAt(entity, timeMs, attrKey) {
+            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 || timeMs == null || isNaN(timeMs)) {
+                return entity;
+            }
+            // Laid oldest first, each record replacing only what it names, which leaves every value at its newest.
+            let state = null;
+            let stateMs = -Infinity;
+            for (const record of this.GetRecords(id, attrKey)) {
+                const ms = timeOf(record);
+                if (ms > timeMs) {
+                    break;
+                }
+                const parts = {};
+                for (const part of RECORD_PARTS) {
+                    if (record[part] != null) {
+                        parts[part] = record[part];
+                    }
+                }
+                state = state ? overlayRecord(state, parts) : parts;
+                stateMs = ms;
+            }
+            if (!state) {
+                return entity;
+            }
+            const bruce = { ...entity.Bruce };
+            if (state.location) {
+                bruce.Location = Overlay(bruce.Location, state.location);
+            }
+            if (state.transform) {
+                bruce.Transform = Overlay(bruce.Transform, state.transform);
+            }
+            if (state.geometry) {
+                bruce.VectorGeometry = state.geometry;
+            }
+            if (state.boundaries) {
+                bruce.Boundaries = state.boundaries;
+            }
+            if (state.assemblyPosition) {
+                bruce.AssemblyPosition = state.assemblyPosition;
+            }
+            // Says the newest record the Entity now reflects, the way a read at a point does.
+            const outline = entity.Bruce.Outline || [];
+            const readAt = outline.find(x => !!x.DateTime);
+            const readMs = readAt ? new Date(readAt.DateTime).getTime() : -Infinity;
+            const dated = {
+                ...(readAt || { "Source.Name": "Simulation", Editable: false, Kind: Entity$1.EOutlineKind.Attribute }),
+                DateTime: new Date(Math.max(readMs, stateMs)).toISOString(),
+                ForeignKey: (_b = readAt === null || readAt === void 0 ? void 0 : readAt.ForeignKey) !== null && _b !== void 0 ? _b : attrKey
+            };
+            bruce.Outline = [dated, ...outline.filter(x => x !== readAt)];
+            const data = state.data ? Overlay({ ...entity, Bruce: undefined }, state.data) : entity;
+            return { ...data, Bruce: Overlay(bruce, (_c = state.data) === null || _c === void 0 ? void 0 : _c.Bruce) };
+        }
+        /**
+         * API records with the simulated ones joined in, for the named Entities or every simulated one.
+         */
+        MergeRecords(recordsByIds, attrKey, entityIds) {
+            if (this.IsEmpty) {
+                return recordsByIds;
+            }
+            const ids = entityIds !== null && entityIds !== void 0 ? entityIds : this.GetRecordEntityIds();
+            let merged = null;
+            for (const id of ids) {
+                const simulated = this.GetRecords(id, attrKey);
+                if (!simulated.length) {
+                    continue;
+                }
+                const owned = this.ownedFrom(simulated);
+                const byTime = new Map();
+                for (const record of (recordsByIds === null || recordsByIds === void 0 ? void 0 : recordsByIds[id]) || []) {
+                    const ms = timeOf(record);
+                    const kept = withoutPaths(record, owned.filter(x => x.fromMs <= ms).map(x => x.path));
+                    if (hasContent(kept)) {
+                        byTime.set(ms, kept);
+                    }
+                }
+                for (const record of simulated) {
+                    const ms = timeOf(record);
+                    const held = byTime.get(ms);
+                    byTime.set(ms, held ? overlayRecord(held, record) : record);
+                }
+                merged = merged !== null && merged !== void 0 ? merged : { ...(recordsByIds || {}) };
+                merged[id] = Array.from(byTime.entries()).sort(([a], [b]) => a - b).map(([, record]) => record);
+            }
+            return merged !== null && merged !== void 0 ? merged : recordsByIds;
+        }
+    }
+    EntitySimulation.Store = Store;
+})(EntitySimulation || (EntitySimulation = {}));
+
 /**
  * Returns cesium property's value.
  * This will check if it's one that changes over time, or just a fixed value.
@@ -5548,6 +5983,8 @@ var EntityLabel;
     const PHOTO_CACHE_KEY = "_nextspaceLabelPhotos";
     // Clearance around a model's box, as a share of its half-extent on each axis.
     const MODEL_BOX_PADDING = 0.02;
+    // How far a moving model's box may drift before it is moved, in metres.
+    const MODEL_BOX_FOLLOW_TOLERANCE = 0.001;
     // Share of each edge drawn out from its corners while the box is idle. Hovering draws the edges whole.
     const MODEL_BOX_BRACKET = 0.2;
     // Under this many pixels across, a box reads as a smudge and the ring takes over.
@@ -6764,6 +7201,7 @@ var EntityLabel;
         constructor() {
             // Whether a box competes for space comes only from inputs (camera distance, hover, the pointer), never from
             // how its label was laid out, so an animation moving a label cannot feed back into which boxes show.
+            // corners is where the box is drawn this frame: stored, moved by the entry's motion.
             this.entries = new Map();
             this.groups = null;
             // The hovered Entity. Its box is drawn on its own and whole, ahead of every other box.
@@ -6781,7 +7219,7 @@ var EntityLabel;
         Set(id, corners, entityId, inputs) {
             const current = this.entries.get(id);
             // A label rebuilt over the same box keeps its place and how far it has animated.
-            if (corners && (current === null || current === void 0 ? void 0 : current.corners) === corners && current.entityId === entityId) {
+            if (corners && (current === null || current === void 0 ? void 0 : current.stored) === corners && current.entityId === entityId) {
                 Object.assign(current, inputs);
                 return;
             }
@@ -6789,17 +7227,41 @@ var EntityLabel;
                 return;
             }
             if (corners) {
-                this.entries.set(id, { ...inputs, corners, entityId, active: false, wanted: false });
+                this.entries.set(id, { ...inputs, corners, stored: corners, entityId, active: false, wanted: false });
             }
             else
                 this.entries.delete(id);
             this.since.delete(id);
+            this.forget(id);
+        }
+        /*
+         * Drops the groups and outlines a box was in, so they are worked out again from where it is now.
+         */
+        forget(id) {
             this.groups = null;
             for (const [key, group] of this.outlines) {
                 if (group.members.includes(id))
                     this.outlines.delete(key);
             }
         }
+        /*
+         * Moves each box whose model moved since the last frame, keeping where it has got to in showing.
+         */
+        follow() {
+            var _a;
+            for (const [id, entry] of this.entries) {
+                const motion = (_a = entry.motion) === null || _a === void 0 ? void 0 : _a.call(entry);
+                if (!motion) {
+                    continue;
+                }
+                const moved = entry.stored.map(corner => Matrix4.multiplyByPoint(motion, corner, new Cartesian3()));
+                if (moved.every((corner, i) => Cartesian3.equalsEpsilon(corner, entry.corners[i], 0, MODEL_BOX_FOLLOW_TOLERANCE))) {
+                    continue;
+                }
+                entry.corners = moved;
+                this.forget(id);
+            }
+        }
         /*
          * The box drawn for a label this frame, or undefined when it has none or lost its place.
          */
@@ -6867,6 +7329,7 @@ var EntityLabel;
          */
         Resolve(viewer, pointer) {
             var _a, _b, _c, _d;
+            this.follow();
             this.frames.clear();
             this.hulls.clear();
             this.drawn = [];
@@ -7289,9 +7752,16 @@ var EntityLabel;
                 }
                 if (this.api) {
                     const rego = this.rego;
+                    const simulation = EntitySimulation.Get(this.viewer);
+                    let simulated = null;
+                    if (simulation === null || simulation === void 0 ? void 0 : simulation.HasBlob(rego.entityId)) {
+                        // A stand-in is named as is; a patch is laid over the API's record first.
+                        const read = simulation.HasEntity(rego.entityId) ? null : (await Entity$1.Get({ api: this.api, entityId: rego.entityId, migrated: true })).entity;
+                        simulated = simulation.Resolve(rego.entityId, read);
+                    }
                     this.rego.name = await Entity$1.CalculateNameAsync({
                         api: this.api,
-                        entity: null,
+                        entity: simulated,
                         entityId: rego.entityId,
                         defaultToId: false
                     });
@@ -7320,6 +7790,21 @@ var EntityLabel;
             clearTimeout(this.loadTimeout);
             this.loadTimeout = null;
         }
+        /*
+         * Reads the label's Entity again and redraws it, eg. after what is simulated for it changed.
+         */
+        Reload() {
+            if (this.disposed) {
+                return;
+            }
+            this.additionalTexts = this.options.text != null ? [] : null;
+            this.loadedName = false;
+            // The name came from whatever record the visual was drawn from, so it is worked out again too.
+            if (this.rego) {
+                this.rego.name = null;
+            }
+            this.createLabel();
+        }
         /*
          * Rebuilds only when configuration changes; state refreshes must not recreate DOM every frame.
          */
@@ -7550,7 +8035,7 @@ var EntityLabel;
                     }
                     clearTimeout(this.loadTimeout);
                     this.loadTimeout = setTimeout(async () => {
-                        var _a, _b, _c, _d, _e;
+                        var _a, _b, _c, _d, _e, _f;
                         if (this.disposed || this.counter != counter) {
                             return;
                         }
@@ -7577,16 +8062,19 @@ var EntityLabel;
                                 const attributes = (_a = this.options.attributes) !== null && _a !== void 0 ? _a : (_c = (_b = entityType === null || entityType === void 0 ? void 0 : entityType.VisualSettings) === null || _b === void 0 ? void 0 : _b.label) === null || _c === void 0 ? void 0 : _c.attributes;
                                 // Read for its attributes, and for a photo when the label has no icon of its own.
                                 if (attributes || !HasIcon(this.options)) {
-                                    let entity = null;
+                                    // A simulated stand-in is labelled as is, and a patch is laid over the API's.
+                                    const simulation = EntitySimulation.Get(this.viewer);
+                                    let entity = (_d = simulation === null || simulation === void 0 ? void 0 : simulation.GetEntity(this.rego.entityId)) !== null && _d !== void 0 ? _d : null;
                                     try {
-                                        entity = (await Entity$1.Get({
+                                        entity = entity !== null && entity !== void 0 ? entity : (await Entity$1.Get({
                                             api: this.api,
                                             entityId: this.rego.entityId,
-                                            scenario: ((_d = this.rego.outline) === null || _d === void 0 ? void 0 : _d.length) ? (_e = this.rego.outline.find(x => !!x.Scenario)) === null || _e === void 0 ? void 0 : _e.Scenario : null,
+                                            scenario: ((_e = this.rego.outline) === null || _e === void 0 ? void 0 : _e.length) ? (_f = this.rego.outline.find(x => !!x.Scenario)) === null || _f === void 0 ? void 0 : _f.Scenario : null,
                                             schemaId: this.rego.schema,
                                             migrated: true,
                                             expandAttachments: !HasIcon(this.options)
                                         })).entity;
+                                        entity = entity && simulation ? simulation.Resolve(this.rego.entityId, entity) : entity;
                                     }
                                     // Entity doesn't exist.
                                     // Likely a graphic with an ID that points to no record.
@@ -7970,11 +8458,17 @@ var EntityLabel;
                 // Past the wait a slow record no longer holds the label back; a box that comes later eases in.
                 setTimeout(settle, MODEL_BOX_WAIT);
                 this.modelBox.load.then(corners => {
+                    var _a, _b;
                     if (!corners || this.disposed || this.counter !== counter) {
                         return;
                     }
                     // A record that disagrees with where the model was found describes another placement, such as a moved tileset.
+                    // A part known to have moved from its record, eg. a joint turning, is judged where it has moved to.
+                    const motion = (_b = (_a = this.rego) === null || _a === void 0 ? void 0 : _a.motion) === null || _b === void 0 ? void 0 : _b.call(_a, this.viewer.clock.currentTime);
                     const centre = Cartesian3.midpoint(corners[0], corners[7], new Cartesian3());
+                    if (motion) {
+                        Matrix4.multiplyByPoint(motion, centre, centre);
+                    }
                     if (Cartesian3.distance(centre, found) > Cartesian3.distance(corners[0], corners[7]) * 0.75 + 2) {
                         return;
                     }
@@ -7982,6 +8476,7 @@ var EntityLabel;
                     // Let go a little further out than it is taken, so a camera resting at the limit does not flip it.
                     let near = false;
                     layer.modelBoxes.Set(this.id, corners, rego.entityId, {
+                        motion: rego.motion ? () => rego.motion(this.viewer.clock.currentTime) : undefined,
                         selected: () => { var _a, _b; return Boolean((_b = (_a = this.visualRegister) === null || _a === void 0 ? void 0 : _a.GetState({ entityId: rego.entityId, menuItemId: rego.menuItemId })) === null || _b === void 0 ? void 0 : _b.selected); },
                         hovered: () => { var _a, _b; return Boolean((_b = (_a = this.visualRegister) === null || _a === void 0 ? void 0 : _a.IsLabelHovered) === null || _b === void 0 ? void 0 : _b.call(_a, rego.entityId, rego.menuItemId)); },
                         near: () => {
@@ -8963,9 +9458,9 @@ var EntityLabelGroup;
      * Reads the entities behind items that name one without carrying it, attachments included,
      * so a label's default image needs no second request.
      */
-    async function Hydrate(items, api, signal) {
+    async function Hydrate(items, api, signal, simulation) {
         var _a, _b;
-        if (!api) {
+        if (!api && !simulation) {
             return items;
         }
         const hydrated = items.slice();
@@ -8976,12 +9471,15 @@ var EntityLabelGroup;
             }
             const chunk = missing.slice(start, start + HYDRATE_AT_ONCE);
             try {
-                const { entities } = await Entity$1.GetListByIds({
-                    api, entityIds: chunk.map(at => hydrated[at].entityId), expandAttachments: true, migrated: true
-                });
+                // A simulated stand-in is labelled as is, never from the API, and a patch is laid over the API's.
+                const asked = chunk.filter(at => !(simulation === null || simulation === void 0 ? void 0 : simulation.HasEntity(hydrated[at].entityId)));
+                const { entities } = api && asked.length ? await Entity$1.GetListByIds({
+                    api, entityIds: asked.map(at => hydrated[at].entityId), expandAttachments: true, migrated: true
+                }) : { entities: [] };
                 const found = new Map((entities !== null && entities !== void 0 ? entities : []).map(entity => { var _a; return [(_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID, entity]; }));
                 for (const at of chunk) {
-                    const entity = found.get(hydrated[at].entityId);
+                    const id = hydrated[at].entityId;
+                    const entity = simulation ? simulation.Resolve(id, found.get(id)) : found.get(id);
                     if (entity) {
                         // The API leaves Attachment out when there are none; an empty list records that they were read.
                         hydrated[at] = { ...hydrated[at], entity: { ...entity, Bruce: { ...entity.Bruce, Attachment: (_b = (_a = entity.Bruce) === null || _a === void 0 ? void 0 : _a.Attachment) !== null && _b !== void 0 ? _b : [] } } };
@@ -8998,7 +9496,7 @@ var EntityLabelGroup;
     /*
      * Uses the existing DataLab grammar, discarding actions and projections that cannot return Entities.
      */
-    async function Loader(source, api, signal, hydrate) {
+    async function Loader(source, api, signal, hydrate, simulation) {
         var _a;
         var _b;
         if (source.type === "provider") {
@@ -9013,7 +9511,7 @@ var EntityLabelGroup;
             return async (offset, limit, signal) => {
                 const page = items.slice(offset, offset + limit);
                 return {
-                    items: hydrate ? await Hydrate(page, api, signal) : page,
+                    items: hydrate ? await Hydrate(page, api, signal, simulation) : page,
                     hasMore: offset + limit < items.length
                 };
             };
@@ -9155,7 +9653,7 @@ var EntityLabelGroup;
             const items = new Map();
             let truncated = false;
             try {
-                const load = await Loader(definition.source, (_g = this.register.ApiGetters) === null || _g === void 0 ? void 0 : _g.GetBruceApi(), controller.signal, NeedsEntityData(definition.options));
+                const load = await Loader(definition.source, (_g = this.register.ApiGetters) === null || _g === void 0 ? void 0 : _g.GetBruceApi(), controller.signal, NeedsEntityData(definition.options), EntitySimulation.Get(this.register.Viewer));
                 let offset = 0;
                 for (let pageNumber = 0;; pageNumber++) {
                     if (controller.signal.aborted || this.register.Disposed) {
@@ -9977,8 +10475,25 @@ var RelationRenderEngine;
         return `${relation["Related.Entity.ID"]}-${relation["Principal.Entity.ID"]}-${relation["Relation.Type.ID"]}`;
     }
     RelationRenderEngine.GetRenderGroupId = GetRenderGroupId;
+    /**
+     * Removes and returns a menu item's drawn relations that end at, or carry data from, any of these Entities.
+     */
+    function TakeRelationsTouching(params) {
+        const { visualRegister, menuItemId } = params;
+        const ids = new Set(params.entityIds);
+        const touched = visualRegister.GetRegos({ menuItemId }).filter((rego) => {
+            const relation = rego.relation;
+            return relation && [relation["Principal.Entity.ID"], relation["Related.Entity.ID"], relation["Data.Entity.ID"]]
+                .some(id => id && ids.has(id));
+        });
+        for (const rego of touched) {
+            visualRegister.RemoveRegos({ relation: rego.relation, entityId: rego.entityId, menuItemId, requestRender: false });
+        }
+        return touched.map(rego => rego.relation);
+    }
+    RelationRenderEngine.TakeRelationsTouching = TakeRelationsTouching;
     async function Render(params) {
-        const { apiGetter, viewer, visualRegister, menuItemId, relations } = params;
+        const { apiGetter, viewer, visualRegister, menuItemId, relations, simulation } = params;
         const api = apiGetter.getApi(apiGetter.accountId);
         const rendered = {};
         let neededEntityIdsIds = [];
@@ -9996,13 +10511,15 @@ var RelationRenderEngine;
         }
         // 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,
+        // Get all entities in one go, other than the simulated ones.
+        const simulated = neededEntityIdsIds.map(id => simulation === null || simulation === void 0 ? void 0 : simulation.GetEntity(id)).filter(x => !!x);
+        const apiIds = neededEntityIdsIds.filter(id => !(simulation === null || simulation === void 0 ? void 0 : simulation.HasEntity(id)));
+        let entities = (apiIds.length ? (await Entity$1.GetListByIds({
+            entityIds: apiIds,
             api: apiGetter.getApi(),
             migrated: true,
             maxSearchTimeSec: 60 * 2
-        })).entities;
+        })).entities.map(entity => simulation ? simulation.Overlay(entity) : entity) : []).concat(simulated);
         // Create a map for quick reference.
         const entitiesMap = {};
         for (let i = 0; i < entities.length; i++) {
@@ -10496,6 +11013,8 @@ function isCullingIgnored(viewer, rego) {
         rego.overrideShow != null ||
         // Being dragged around right now, so its extent is changing faster than we could measure it.
         rego.editing == true ||
+        // Placed by the clock every frame, so no measurement of where it is stays true.
+        rego.moving == true ||
         // Part of a collection we did not create, eg. a geojson data source, which may have its own rules for
         // what is in the scene. Our own per-menu-item data sources are fair game.
         VisualsRegister.IsForeignCollection(rego) ||
@@ -11335,6 +11854,7 @@ var VisualsRegister;
         }
         get OnLabelGroupsChanged() { return this.labelGroupsChanged; }
         constructor(params) {
+            var _a, _b;
             this.id = ObjectUtils.UId();
             this.disposed = false;
             this.rego = {};
@@ -11374,6 +11894,8 @@ var VisualsRegister;
             this.menuItemSources = new Map();
             // Set when the data source order no longer matches the zIndexes seen, so it is re-applied once.
             this.sourceOrderDirty = false;
+            // Stops following what is simulated, so labels can read it again when it changes.
+            this.simulationRemoval = null;
             this.labelGroupsChanged = new BruceEvent();
             this.hoverRingState = {};
             this.retiringHoverLabels = new Map();
@@ -11408,6 +11930,33 @@ var VisualsRegister;
             this.cameraCullerDispose = VisualRegisterCuller.Monitor({
                 register: this
             });
+            this.simulationRemoval = (_b = (_a = EntitySimulation.Get(this.viewer)) === null || _a === void 0 ? void 0 : _a.OnChanged.Subscribe((change) => this.reloadLabels(change.entityIds))) !== null && _b !== void 0 ? _b : null;
+        }
+        /*
+         * Tells labels to read their Entity again, since they keep what they read when drawn.
+         */
+        reloadLabels(entityIds) {
+            var _a, _b, _c, _d;
+            if (this.disposed) {
+                return;
+            }
+            const groupIds = new Set();
+            for (const entityId of entityIds) {
+                for (const rego of this.GetRegos({ entityId })) {
+                    (_a = EntityLabel.GetLabel({ rego })) === null || _a === void 0 ? void 0 : _a.Reload();
+                }
+                if (((_b = this.labelHover) === null || _b === void 0 ? void 0 : _b.entityId) === entityId) {
+                    (_c = this.hoverLabel) === null || _c === void 0 ? void 0 : _c.Reload();
+                }
+                const groupId = (_d = this.GetLabelGroupFor(entityId)) === null || _d === void 0 ? void 0 : _d.groupId;
+                if (groupId) {
+                    groupIds.add(groupId);
+                }
+            }
+            // A group may have read the Entity in with its items, so the group is read again as a whole.
+            for (const groupId of groupIds) {
+                this.RefreshLabelGroup(groupId).catch((e) => console.error(e));
+            }
         }
         /**
          * Returns the collection a menu item's visuals belong in, creating its data source on first use.
@@ -12310,7 +12859,9 @@ var VisualsRegister;
             (_b = this.viewer.scene) === null || _b === void 0 ? void 0 : _b.requestRender();
         }
         Dispose() {
-            var _a, _b, _c, _d, _e;
+            var _a, _b, _c, _d, _e, _f;
+            (_a = this.simulationRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.simulationRemoval = null;
             CesiumEntityStyler.SetDimming(this.viewer, this.id, false);
             this.ClearLabelHover();
             clearTimeout(this.hoverRingReset);
@@ -12320,14 +12871,14 @@ var VisualsRegister;
                 EntityLabel.Detatch({ label });
             }
             this.retiringHoverLabels.clear();
-            (_a = this.labelGroups) === null || _a === void 0 ? void 0 : _a.Dispose();
+            (_b = this.labelGroups) === null || _b === void 0 ? void 0 : _b.Dispose();
             this.labelGroupsChanged.Clear();
             for (const regos of Object.values(this.rego)) {
                 for (const rego of regos)
                     EntityLabel.Detatch({ rego, force: true });
             }
             EntityLabel.SetContainer(this.viewer);
-            (_b = this.cameraCullerDispose) === null || _b === void 0 ? void 0 : _b.call(this, {
+            (_c = this.cameraCullerDispose) === null || _c === void 0 ? void 0 : _c.call(this, {
                 uncull: false
             });
             this.cameraCullerDispose = null;
@@ -12343,7 +12894,7 @@ var VisualsRegister;
             this.disposed = true;
             for (const record of Array.from(this.menuItemSources.values())) {
                 try {
-                    (_d = (_c = this.viewer) === null || _c === void 0 ? void 0 : _c.dataSources) === null || _d === void 0 ? void 0 : _d.remove(record.source, true);
+                    (_e = (_d = this.viewer) === null || _d === void 0 ? void 0 : _d.dataSources) === null || _e === void 0 ? void 0 : _e.remove(record.source, true);
                 }
                 catch (e) {
                     console.error(e);
@@ -12352,7 +12903,7 @@ var VisualsRegister;
             this.menuItemSources.clear();
             // Hand every tileset's show flag back to its owner, holding whatever the owner last asked for.
             for (const rego of Array.from(this.tilesets.values())) {
-                (_e = rego.gate) === null || _e === void 0 ? void 0 : _e.Release();
+                (_f = rego.gate) === null || _f === void 0 ? void 0 : _f.Release();
             }
             this.tilesets.clear();
         }
@@ -12526,21 +13077,7 @@ var VisualsRegister;
                         changed = true;
                     }
                     if (editing) {
-                        const parts = EntityUtils.GatherEntity({
-                            entity: rego.visual
-                        });
-                        for (let k = 0; k < parts.length; k++) {
-                            const part = parts[k];
-                            if (!(part instanceof Entity)) {
-                                continue;
-                            }
-                            const removalPending = VisualRegisterCuller.CancelQueuedSceneChange(part);
-                            const wasCulled = part[VisualRegisterCuller.VISUAL_CULL_KEY] == true || removalPending;
-                            delete part[VisualRegisterCuller.VISUAL_CULL_KEY];
-                            if (wasCulled && !IsCEntityInScene(this.viewer, part)) {
-                                AddCEntityToScene(this.viewer, part, rego.collection);
-                            }
-                        }
+                        this.restoreCulled(rego);
                     }
                     else {
                         VisualRegisterCuller.InvalidateBounds(rego.visual);
@@ -12552,6 +13089,56 @@ var VisualsRegister;
                 (_b = (_a = this.viewer) === null || _a === void 0 ? void 0 : _a.scene) === null || _b === void 0 ? void 0 : _b.requestRender();
             }
         }
+        /**
+         * Marks visuals as placed by the clock, exempting them from culling until it is turned back off.
+         */
+        SetMoving(params) {
+            const { entityIds, moving, menuItemId } = params;
+            if (!(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
+                return;
+            }
+            for (let i = 0; i < entityIds.length; i++) {
+                const regos = this.rego[entityIds[i]];
+                if (!regos) {
+                    continue;
+                }
+                for (let j = 0; j < regos.length; j++) {
+                    const rego = regos[j];
+                    if ((menuItemId && rego.menuItemId !== menuItemId) || Boolean(rego.moving) == Boolean(moving)) {
+                        continue;
+                    }
+                    // Null rather than false, so the rego does not carry a key for every visual that ever moved.
+                    rego.moving = moving ? true : null;
+                    if (moving) {
+                        this.restoreCulled(rego);
+                    }
+                    else {
+                        VisualRegisterCuller.InvalidateBounds(rego.visual);
+                        VisualRegisterCuller.MarkShouldRecheck(this.viewer);
+                    }
+                }
+            }
+        }
+        /*
+         * Puts back whatever the culler took out of a visual that is now exempt from it.
+         */
+        restoreCulled(rego) {
+            const parts = EntityUtils.GatherEntity({
+                entity: rego.visual
+            });
+            for (let k = 0; k < parts.length; k++) {
+                const part = parts[k];
+                if (!(part instanceof Entity)) {
+                    continue;
+                }
+                const removalPending = VisualRegisterCuller.CancelQueuedSceneChange(part);
+                const wasCulled = part[VisualRegisterCuller.VISUAL_CULL_KEY] == true || removalPending;
+                delete part[VisualRegisterCuller.VISUAL_CULL_KEY];
+                if (wasCulled && !IsCEntityInScene(this.viewer, part)) {
+                    AddCEntityToScene(this.viewer, part, rego.collection);
+                }
+            }
+        }
         SetSelected(params) {
             var _a;
             let { entityIds, selected, refreshIfSelected, requestRender, menuItemId, source } = params;
@@ -14044,12 +14631,41 @@ var VisualsRegister;
  * Tracks per-entity rerender state for unsaved blob maintenance and stale API response suppression.
  */
 class EntityReRenderMaintainState {
-    constructor() {
+    constructor(simulation, pointInTime) {
+        this.simulation = simulation;
+        this.pointInTime = pointInTime;
         this.maintainedEntitiesById = {};
         this.apiRevisionByEntityId = {};
         this.skipApiRunByEntityId = {};
         this.checkRunId = 0;
     }
+    /*
+     * Lays each Entity's simulated record for the current point over it, when the manager reads at one.
+     */
+    atPoint(entities) {
+        var _a;
+        const point = (_a = this.pointInTime) === null || _a === void 0 ? void 0 : _a.call(this);
+        if (!point || !this.simulation || this.simulation.IsEmpty || !(entities === null || entities === void 0 ? void 0 : entities.length)) {
+            return entities;
+        }
+        return entities.map((entity) => this.simulation.ApplyAt(entity, point.timeMs, point.attrKey));
+    }
+    /**
+     * Whether a simulated stand-in replaces this Entity, so nothing from the API may replace what is drawn.
+     */
+    isSimulated(entityId) {
+        var _a;
+        return Boolean(entityId && ((_a = this.simulation) === null || _a === void 0 ? void 0 : _a.HasEntity(entityId)));
+    }
+    /**
+     * Swaps any simulated Entity in a set the API returned for its stand-in, or lays its patch over it.
+     */
+    withSimulated(entities) {
+        if (!this.simulation || this.simulation.IsEmpty || !(entities === null || entities === void 0 ? void 0 : entities.length)) {
+            return entities;
+        }
+        return this.atPoint(entities.map((entity) => { var _a, _b; return (_b = this.simulation.Resolve((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID, entity)) !== null && _b !== void 0 ? _b : entity; }));
+    }
     setMaintainedEntities(entities) {
         var _a;
         for (let i = 0; i < entities.length; i++) {
@@ -14071,15 +14687,21 @@ class EntityReRenderMaintainState {
         }
     }
     getMaintainedEntities(entityIds) {
+        var _a;
         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);
+            // A maintained blob is this manager's own unsaved edit, newer than a simulation, so it is drawn as is.
+            const maintained = this.maintainedEntitiesById[id];
+            const simulated = maintained ? null : (_a = this.simulation) === null || _a === void 0 ? void 0 : _a.GetEntity(id);
+            if (maintained) {
+                entities.push(maintained);
+            }
+            else if (simulated) {
+                entities.push(this.atPoint([simulated])[0]);
             }
         }
         return entities;
@@ -14136,7 +14758,7 @@ class EntityReRenderMaintainState {
     }
     filterCurrentApiEntities(params) {
         const { entities, revisions, runId } = params;
-        return entities.filter((entity) => {
+        const current = 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) {
@@ -14145,8 +14767,12 @@ class EntityReRenderMaintainState {
             if (runId != null && this.shouldSkipInRun(id, runId)) {
                 return false;
             }
+            if (this.isSimulated(id)) {
+                return false;
+            }
             return ((_b = this.apiRevisionByEntityId[id]) !== null && _b !== void 0 ? _b : 0) === ((_c = revisions[id]) !== null && _c !== void 0 ? _c : 0);
         });
+        return this.atPoint(this.simulation && !this.simulation.IsEmpty ? current.map((entity) => this.simulation.Overlay(entity)) : current);
     }
 }
 
@@ -15582,7 +16208,7 @@ class HistoricGatherer {
         this.cache = new HistoricRangeCache();
     }
     get Records() {
-        return this.cache.GetRecords();
+        return this.withSimulated(this.cache.GetRecords());
     }
     Clear() {
         this.cache.Clear();
@@ -15606,8 +16232,9 @@ class HistoricGatherer {
      */
     async Gather(entities) {
         var _a;
-        if (this.disposed || !(entities === null || entities === void 0 ? void 0 : entities.length)) {
-            return { fetched: false, recordsByIds: this.cache.GetRecords() };
+        const entityIds = entities === null || entities === void 0 ? void 0 : entities.map(x => { var _a; return (_a = x.Bruce) === null || _a === void 0 ? void 0 : _a.ID; }).filter(x => !!x);
+        if (this.disposed || !(entities === null || entities === void 0 ? void 0 : entities.length) || this.params.simulatedOnly) {
+            return { fetched: false, recordsByIds: this.withSimulated(this.cache.GetRecords(), entityIds) };
         }
         const { viewer } = this.params;
         const windowStart = new Date(viewer.clock.startTime.toString()).getTime();
@@ -15627,7 +16254,7 @@ class HistoricGatherer {
         if (plan.coarse && !this.cache.CoversCoarse(plan.coarse.start, plan.coarse.stop)) {
             const records = await this.request(plan.coarse.start, plan.coarse.stop, entities, plan.coarse.sample);
             if (this.disposed) {
-                return { fetched, recordsByIds: this.cache.GetRecords() };
+                return { fetched, recordsByIds: this.withSimulated(this.cache.GetRecords(), entityIds) };
             }
             this.cache.Absorb(plan.coarse.start, this.holdTo(plan.coarse.stop, liveEdge, liveTail), records, true);
             fetched = true;
@@ -15662,7 +16289,17 @@ class HistoricGatherer {
                 }
             }
         }
-        return { fetched, recordsByIds: this.cache.GetRecords() };
+        return { fetched, recordsByIds: this.withSimulated(this.cache.GetRecords(), entityIds) };
+    }
+    /*
+     * Joins the simulated records for these Entities, or every simulated Entity, into an answer.
+     */
+    withSimulated(recordsByIds, entityIds) {
+        const simulation = this.params.simulation;
+        if (!simulation || simulation.IsEmpty) {
+            return recordsByIds;
+        }
+        return simulation.MergeRecords(recordsByIds, this.params.getAttrKey(), entityIds);
     }
     /*
      * Returns how much of a range that was just read may be marked as held.
@@ -15697,7 +16334,7 @@ class HistoricGatherer {
         }).then((res) => {
             const records = res.recordsByIds || {};
             if (!this.disposed && this.params.onRecords) {
-                this.params.onRecords(records);
+                this.params.onRecords(this.withSimulated(records, entityIds));
             }
             return records;
         }).finally(() => {
@@ -15774,7 +16411,6 @@ var EntitiesRenderManager;
             this.renderQueue = [];
             this.renderQueueInterval = null;
             this.sources = [];
-            this.reRenderState = new EntityReRenderMaintainState();
             // Highly experimental flag to try improve rendering large sets of polygons and polylines.
             // Many things are not supported when this is enabled.
             this.useGeojson = false;
@@ -15794,6 +16430,14 @@ var EntitiesRenderManager;
              */
             this.renderAsIndividualsChain = Promise.resolve();
             const { viewer, apiGetter, monitor, item, register: visualsManager, sharedGetters, onSeriesDiscovered } = params;
+            this.reRenderState = new EntityReRenderMaintainState(params.simulation, () => {
+                // Read at the scene's time only when the item follows history, the same choice its reads make.
+                const bruceEntity = this.item.BruceEntity;
+                if (!(bruceEntity === null || bruceEntity === void 0 ? void 0 : bruceEntity.historic) && !(bruceEntity === null || bruceEntity === void 0 ? void 0 : bruceEntity.historicAttrKey)) {
+                    return null;
+                }
+                return { timeMs: JulianDate.toDate(this.viewer.clock.currentTime).getTime(), attrKey: bruceEntity.historicAttrKey };
+            });
             this.viewer = viewer;
             this.sharedGetters = sharedGetters;
             this.monitor = monitor;
@@ -15807,7 +16451,8 @@ var EntitiesRenderManager;
                 getApi: () => this.apiGetter.getApi(),
                 getAttrKey: () => { var _a; return (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historicAttrKey; },
                 // A second either side, to take in records sitting exactly on the boundary.
-                paddingMs: 1000
+                paddingMs: 1000,
+                simulation: params.simulation
             });
             this.useGeojson = item.renderAsGeojson == true;
             if (item.enableClustering) {
@@ -15988,8 +16633,9 @@ var EntitiesRenderManager;
                     return;
                 }
                 this.updateAllowedTypeIDs(data.entityTypeSources, data.entities);
+                // The getter answers from the API, so a simulated Entity in its answer is swapped for its blob.
                 if (isTagItem) {
-                    this.distributeForRender(data.entities.filter((entity) => {
+                    this.distributeForRender(this.reRenderState.withSimulated(data.entities.filter((entity) => {
                         let entityTags = entity.Bruce["Layer.ID"];
                         if (!entityTags) {
                             entityTags = [];
@@ -15997,10 +16643,10 @@ var EntitiesRenderManager;
                         return entityTags.some((tag) => {
                             return tagsToRender.indexOf(tag) !== -1;
                         });
-                    }));
+                    })));
                 }
                 else {
-                    this.distributeForRender(data.entities);
+                    this.distributeForRender(this.reRenderState.withSimulated(data.entities));
                 }
             });
             // Cesium itself handles single-visibility ranges very well.
@@ -16040,6 +16686,10 @@ var EntitiesRenderManager;
                     // Remove regos directly.
                     if (event.action === "D") {
                         for (const entityId of affectedIds) {
+                            // Deleted in the API, but drawn from its simulation until that is cleared.
+                            if (this.reRenderState.isSimulated(entityId)) {
+                                continue;
+                            }
                             this.visualsManager.RemoveRegos({
                                 entityId,
                                 menuItemId: this.item.id,
@@ -17169,7 +17819,6 @@ var EntitiesLoadedRenderManager;
             // Highly experimental flag to try improve rendering large sets of polygons and polylines.
             // Many things are not supported when this is enabled.
             this.useGeojson = false;
-            this.reRenderState = new EntityReRenderMaintainState();
             /**
              * Our default path.
              * We render each entity individually.
@@ -17179,6 +17828,7 @@ var EntitiesLoadedRenderManager;
              */
             this.renderAsIndividualsChain = Promise.resolve();
             const { viewer, apiGetter, monitor, item, register: visualsManager } = params;
+            this.reRenderState = new EntityReRenderMaintainState(params.simulation);
             this.viewer = viewer;
             this.apiGetter = apiGetter;
             this.monitor = monitor;
@@ -17301,7 +17951,8 @@ var EntitiesLoadedRenderManager;
                         continue;
                     }
                 }
-                this.onGetterUpdate(entities);
+                // The item carries its own Entities, so a simulated one among them is swapped for its blob.
+                this.onGetterUpdate(this.reRenderState.withSimulated(entities));
             });
             this.getter.Start();
         }
@@ -17948,8 +18599,15 @@ var EntitiesIdsRenderManager;
             this.renderQueueActive = false;
             this.renderQueue = [];
             this.renderQueueForceFlags = [];
-            this.reRenderState = new EntityReRenderMaintainState();
             const { viewer, apiGetter, monitor, item, register: visualsManager } = params;
+            this.reRenderState = new EntityReRenderMaintainState(params.simulation, () => {
+                // Read at the scene's time only when the item follows history, the same choice its reads make.
+                const bruceEntity = this.item.BruceEntity;
+                if (!(bruceEntity === null || bruceEntity === void 0 ? void 0 : bruceEntity.historic) && !(bruceEntity === null || bruceEntity === void 0 ? void 0 : bruceEntity.historicAttrKey)) {
+                    return null;
+                }
+                return { timeMs: JulianDate.toDate(this.viewer.clock.currentTime).getTime(), attrKey: bruceEntity.historicAttrKey };
+            });
             this.sharedHistoric = params.sharedHistoric;
             this.viewer = viewer;
             this.apiGetter = apiGetter;
@@ -17962,7 +18620,8 @@ var EntitiesIdsRenderManager;
                 getApi: () => this.apiGetter.getApi(),
                 getAttrKey: () => { var _a; return (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historicAttrKey; },
                 // Padding either side of a requested range, for clock desync between us and the server.
-                paddingMs: 15000
+                paddingMs: 15000,
+                simulation: params.simulation
             });
             if (this.item.enableClustering) {
                 this.clustering = new PointClustering(visualsManager, this.item.id, (_a = this.item) === null || _a === void 0 ? void 0 : _a.clustering);
@@ -18424,9 +19083,9 @@ var EntityRenderManager;
             this.getter = null;
             this.getterSub = null;
             this.disposed = false;
-            this.reRenderState = new EntityReRenderMaintainState();
             this.renderEntityChain = Promise.resolve();
             const { viewer, apiGetter, monitor, item, register: visualsManager } = params;
+            this.reRenderState = new EntityReRenderMaintainState(params.simulation);
             this.viewer = viewer;
             this.apiGetter = apiGetter;
             this.monitor = monitor;
@@ -18700,6 +19359,122 @@ var CodeLogicExceptions;
     ];
 })(CodeLogicExceptions || (CodeLogicExceptions = {}));
 
+/**
+ * The line drawn through where a moving thing has been, from its history, as a whole path or a fading trail.
+ */
+var HistoricTrail;
+(function (HistoricTrail) {
+    const BANDS = 12;
+    const SAMPLES = 96;
+    const WIDTH_FAR = 1;
+    const ALPHA_FAR = 0.05;
+    // Above 1, so width and alpha hold near the head and give way further back.
+    const WIDTH_CURVE = 1.4;
+    const ALPHA_CURVE = 1.25;
+    // How strongly a line is drawn where it passes behind the globe, against its own alpha.
+    const BEHIND_ALPHA = 0.35;
+    /**
+     * The trail length a menu item asks for in its historicTrackSeconds, or null for the whole path.
+     */
+    function GetTrailSeconds(item) {
+        const seconds = Number(item === null || item === void 0 ? void 0 : item.historicTrackSeconds);
+        return seconds > 0 ? seconds : null;
+    }
+    HistoricTrail.GetTrailSeconds = GetTrailSeconds;
+    class Trail {
+        constructor(params) {
+            this.entities = [];
+            this.memoTime = null;
+            this.memo = [];
+            this.viewer = params.viewer;
+            const trailing = params.trailSeconds > 0 && Boolean(params.positionAt);
+            if (!trailing) {
+                this.add(params, params.color, params.width, () => { var _a; return (_a = params.getSeries()) !== null && _a !== void 0 ? _a : []; });
+                return;
+            }
+            for (let band = 0; band < BANDS; band++) {
+                // 0 at the head, 1 at the far end.
+                const age = band / (BANDS - 1);
+                const width = params.width - (params.width - WIDTH_FAR) * Math.pow(age, WIDTH_CURVE);
+                const alpha = params.color.alpha - (params.color.alpha - ALPHA_FAR) * Math.pow(age, ALPHA_CURVE);
+                this.add(params, params.color.withAlpha(alpha), Math.max(WIDTH_FAR, width), (time) => {
+                    return this.slice(this.sample(params, time), band);
+                });
+            }
+        }
+        /*
+         * One polyline of the trail, its positions read from the scene's time.
+         */
+        add(params, color, width, positions) {
+            const entity = this.viewer.entities.add({
+                id: ObjectUtils.UId(15),
+                polyline: {
+                    positions: new CallbackProperty((time) => positions(time), false),
+                    width: width,
+                    material: color,
+                    clampToGround: params.clampToGround,
+                    // A path through the air follows no ellipsoid, so it is drawn as the straight runs it holds.
+                    arcType: params.clampToGround ? ArcType.GEODESIC : ArcType.NONE,
+                    // Drawn dimmer behind the globe rather than winking in and out against the terrain along the limb.
+                    depthFailMaterial: params.clampToGround ? undefined : color.withAlpha(color.alpha * BEHIND_ALPHA),
+                    zIndex: 0,
+                    classificationType: params.clampToGround ? ClassificationType.BOTH : undefined
+                }
+            });
+            entity._noEdit = true;
+            entity._noSelect = true;
+            CesiumEntityStyler.SetDefaultColor({
+                color: color,
+                entity: entity,
+                viewer: this.viewer,
+                override: true,
+                requestRender: false
+            });
+            this.entities.push(entity);
+        }
+        /*
+         * The trail's positions at a time, newest last, kept for that time so every band reads the same set.
+         */
+        sample(params, time) {
+            var _a;
+            if (this.memoTime && JulianDate.equals(this.memoTime, time)) {
+                return this.memo;
+            }
+            this.memoTime = JulianDate.clone(time, (_a = this.memoTime) !== null && _a !== void 0 ? _a : new JulianDate());
+            const nowMs = JulianDate.toDate(time).getTime();
+            const spanMs = params.trailSeconds * 1000;
+            const points = [];
+            for (let i = 0; i <= SAMPLES; i++) {
+                const pos3d = params.positionAt(nowMs - spanMs + spanMs * i / SAMPLES);
+                if (pos3d) {
+                    points.push(pos3d);
+                }
+            }
+            this.memo = points;
+            return points;
+        }
+        /*
+         * A band's run of the samples, counted back from the head, sharing its end point with the next band.
+         */
+        slice(points, band) {
+            if (points.length < 2) {
+                return [];
+            }
+            const per = (points.length - 1) / BANDS;
+            const end = points.length - 1 - Math.round(band * per);
+            const start = points.length - 1 - Math.round((band + 1) * per);
+            return start < end ? points.slice(Math.max(0, start), end + 1) : [];
+        }
+        Dispose() {
+            for (const entity of this.entities) {
+                RemoveCEntityFromScene(this.viewer, entity);
+            }
+            this.entities = [];
+        }
+    }
+    HistoricTrail.Trail = Trail;
+})(HistoricTrail || (HistoricTrail = {}));
+
 class EntityGatherer {
     get OnQueueProgress() {
         if (!this._onQueueProgress) {
@@ -18707,7 +19482,11 @@ class EntityGatherer {
         }
         return this._onQueueProgress;
     }
-    constructor(api, viewer, emitEntities) {
+    /**
+     * @param simulation what callers simulate in place of API data, used where this gatherer has no override.
+     */
+    constructor(api, viewer, emitEntities, simulation) {
+        this.simulation = simulation;
         this.disposed = false;
         this.expandSources = false;
         this.historic = null;
@@ -19284,15 +20063,19 @@ class EntityGatherer {
                             }
                         }
                     }
+                    // A historic read is as at the scene's time, and so is any simulated record laid over it.
+                    const rTimeMs = new Date(rTime).getTime();
+                    const atPoint = (entity) => this.historic && this.simulation ? this.simulation.ApplyAt(entity, rTimeMs) : entity;
                     for (const entityId of requestedBatch || []) {
+                        // A caller's own override is an unsaved edit, newer than any simulation, so it is used as is.
                         const override = this.entityDataOverrides.get(entityId);
                         if (override) {
                             resolvedEntities.push(override);
                             continue;
                         }
-                        const found = foundById.get(entityId);
+                        const found = this.simulation ? this.simulation.Resolve(entityId, foundById.get(entityId)) : foundById.get(entityId);
                         if (found) {
-                            resolvedEntities.push(found);
+                            resolvedEntities.push(atPoint(found));
                             continue;
                         }
                         resolvedEntities.push(this.createFallbackEntity(entityId));
@@ -19656,7 +20439,7 @@ class TilesetStyler {
                     this.styleTilesetFeatureFullData(feature, entity, eTags);
                 }
             }
-        });
+        }, params.simulation);
         // Only Entities Sets bake coordinates into their features, so for any other source this
         // resolves nothing and the gather stays in insertion order.
         this.entityGatherer.SetViewMonitor(this.monitor);
@@ -21186,6 +21969,9 @@ var TilesetCadRenderManager;
             return this.modelTreeUpdate;
         }
         constructor(params) {
+            this.simulationRemoval = null;
+            // Where the tileset stands by its own record, so a cleared simulation puts it back without a refetch.
+            this.restCoords = null;
             this.disposed = false;
             this.modelSpace = false;
             this.cTileset = null;
@@ -21223,7 +22009,7 @@ var TilesetCadRenderManager;
             this.historicAnimation = null;
             this.historicGatherer = null;
             // The trail through the root's own movement, which describes the whole assembly.
-            this.trackEntity = null;
+            this.trail = null;
             this.historicPossesLoadingProm = null;
             // Queue of loaded in features that we haven't processed yet.
             this.featureQueue = [];
@@ -21237,6 +22023,7 @@ var TilesetCadRenderManager;
             this.featurePropCache = new Map();
             this.featurePropsChecked = 0;
             const { viewer, register: visualsManager, getters, item, modelSpace, initQueue } = params;
+            this.simulation = params.simulation;
             this.viewer = viewer;
             this.getters = getters;
             this.item = item;
@@ -21401,7 +22188,7 @@ var TilesetCadRenderManager;
                             historicPoint: this.viewer.clock.currentTime.toString(),
                             api: api
                         });
-                        coords = coordsFromHistoricEntity(root);
+                        coords = coordsFromHistoricEntity(this.atClock(root));
                     }
                     catch (e) {
                         console.error(e);
@@ -21442,6 +22229,10 @@ var TilesetCadRenderManager;
                     this.doDispose();
                     return;
                 }
+                this.restCoords = coords;
+                if (this.simulatedRootCoords()) {
+                    this.applyCoords(tileset, this.simulatedRootCoords());
+                }
                 this.viewer.scene.requestRender();
                 TilesetRenderEngine.OnTilesetReady(this.cTileset).then(() => {
                     var _a, _b, _c;
@@ -21461,6 +22252,7 @@ var TilesetCadRenderManager;
                         }
                         this.onCTilesetLoad();
                         this.styler.Init({
+                            simulation: this.simulation,
                             viewer: this.viewer,
                             // Default API instead of the account one.
                             // Records are driven by the account loading it instead of the source account.
@@ -21476,6 +22268,7 @@ var TilesetCadRenderManager;
                         });
                         this.viewer.scene.requestRender();
                         // Monitor scene time changes and update the root Entity.
+                        this.followSimulation(tileset);
                         this.viewerDateTimeSub(tileset);
                     }
                     catch (e) {
@@ -21531,7 +22324,7 @@ var TilesetCadRenderManager;
          */
         applyRootTrack() {
             var _a;
-            if (!this.item.historicDrawTrack || !this.historicAnimation || this.trackEntity) {
+            if (!this.item.historicDrawTrack || !this.historicAnimation || this.trail) {
                 return;
             }
             const trackStyle = EntityRenderEngine.GetTrackStyle({
@@ -21541,26 +22334,14 @@ var TilesetCadRenderManager;
             if (!trackStyle) {
                 return;
             }
-            this.trackEntity = this.viewer.entities.add({
-                id: ObjectUtils.UId(15),
-                polyline: {
-                    positions: new CallbackProperty(() => { var _a, _b; return (_b = (_a = this.historicAnimation) === null || _a === void 0 ? void 0 : _a.GetSeries()) !== null && _b !== void 0 ? _b : []; }, false),
-                    width: trackStyle.width,
-                    material: trackStyle.color,
-                    clampToGround: EntityRenderEngine.GetHeightRefPolyline(Manager.GetRecordHeightRef(this.item))
-                        == HeightReference.CLAMP_TO_GROUND,
-                    zIndex: 0,
-                    classificationType: ClassificationType.BOTH
-                }
-            });
-            this.trackEntity._noEdit = true;
-            this.trackEntity._noSelect = true;
-            CesiumEntityStyler.SetDefaultColor({
-                color: trackStyle.color,
-                entity: this.trackEntity,
+            // The series has no position at an arbitrary time, so this draws the whole path rather than a trail.
+            this.trail = new HistoricTrail.Trail({
                 viewer: this.viewer,
-                override: true,
-                requestRender: false
+                color: trackStyle.color,
+                width: trackStyle.width,
+                clampToGround: EntityRenderEngine.GetHeightRefPolyline(Manager.GetRecordHeightRef(this.item))
+                    == HeightReference.CLAMP_TO_GROUND,
+                getSeries: () => { var _a, _b; return (_b = (_a = this.historicAnimation) === null || _a === void 0 ? void 0 : _a.GetSeries()) !== null && _b !== void 0 ? _b : []; }
             });
         }
         /**
@@ -21613,7 +22394,7 @@ var TilesetCadRenderManager;
         }
         // Returns null (fall back to a normal Dispose()) if the tileset hasn't finished loading yet.
         PrepareHandoff() {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             if (this.disposed || !this.cTileset || this.cTileset.isDestroyed()) {
                 return null;
             }
@@ -21631,9 +22412,11 @@ var TilesetCadRenderManager;
             this.handoffSourceMenuItemId = null;
             // Not transferred, the receiving manager sets up its own fresh copy if needed.
             this.viewerDateTimeDispose();
-            (_b = this.styler) === null || _b === void 0 ? void 0 : _b.Dispose();
-            (_c = this.tileLoadRemoval) === null || _c === void 0 ? void 0 : _c.call(this);
-            (_d = this.tileUnloadRemoval) === null || _d === void 0 ? void 0 : _d.call(this);
+            (_b = this.simulationRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+            this.simulationRemoval = null;
+            (_c = this.styler) === null || _c === void 0 ? void 0 : _c.Dispose();
+            (_d = this.tileLoadRemoval) === null || _d === void 0 ? void 0 : _d.call(this);
+            (_e = this.tileUnloadRemoval) === null || _e === void 0 ? void 0 : _e.call(this);
             this.tileLoadRemoval = null;
             this.tileUnloadRemoval = null;
             const payload = {
@@ -21654,7 +22437,7 @@ var TilesetCadRenderManager;
         // Takes ownership of a PrepareHandoff() payload instead of loading via Init().
         // Then re-parents every already-registered rego to this menu item and re-runs styling.
         AdoptHandoff(payload) {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             this.cTileset = payload.cTileset;
             this.tileset = payload.tileset;
             this.rootId = payload.rootId;
@@ -21685,6 +22468,7 @@ var TilesetCadRenderManager;
             // Same visuals, same registrations so just re-keyed onto this menu item.
             this.onCTilesetLoad();
             this.styler.Init({
+                simulation: this.simulation,
                 viewer: this.viewer,
                 api: this.getters.GetBruceApi(),
                 cTileset: this.cTileset,
@@ -21718,7 +22502,9 @@ var TilesetCadRenderManager;
                 }
             });
             this.viewer.scene.requestRender();
-            if (((_d = this.item.BruceEntity) === null || _d === void 0 ? void 0 : _d.historic) && this.tileset) {
+            if (this.tileset) {
+                this.restCoords = (_d = this.restCoords) !== null && _d !== void 0 ? _d : (_e = this.cTileset) === null || _e === void 0 ? void 0 : _e._bruceCoords;
+                this.followSimulation(this.tileset);
                 this.viewerDateTimeSub(this.tileset);
             }
         }
@@ -22306,7 +23092,7 @@ var TilesetCadRenderManager;
             this.doDispose();
         }
         doDispose() {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             if (this.featureQueueInterval) {
                 clearInterval(this.featureQueueInterval);
                 this.featureQueueInterval = null;
@@ -22341,6 +23127,8 @@ var TilesetCadRenderManager;
                 this.handoffSourceMenuItemId = null;
             }
             this.viewerDateTimeDispose();
+            (_d = this.simulationRemoval) === null || _d === void 0 ? void 0 : _d.call(this);
+            this.simulationRemoval = null;
         }
         async ReRender(params) {
             let { entityIds, force, entities, maintain } = params;
@@ -22366,8 +23154,11 @@ var TilesetCadRenderManager;
          * @param tileset
          */
         viewerDateTimeSub(tileset) {
-            var _a;
-            if (!((_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic) || this.viewerDateTimeChangeRemoval) {
+            var _a, _b;
+            // An item that is not historic still follows the root's simulated records, once there are some.
+            const historic = Boolean((_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic);
+            const simulated = Boolean(this.rootId && ((_b = this.simulation) === null || _b === void 0 ? void 0 : _b.GetRecords(this.rootId).length));
+            if ((!historic && !simulated) || this.historicGatherer || this.viewerDateTimeChangeRemoval) {
                 return;
             }
             const accountId = this.accountIdForRecords();
@@ -22396,6 +23187,8 @@ var TilesetCadRenderManager;
                 // Time padding in milliseconds (15 seconds).
                 // Helps account for desync between client and server.
                 paddingMs: 15000,
+                simulation: this.simulation,
+                simulatedOnly: !historic,
                 onRecords: (recordsByIds) => {
                     var _a;
                     const records = recordsByIds[this.rootId];
@@ -22423,6 +23216,7 @@ var TilesetCadRenderManager;
              */
             const getInitialPosses = async () => {
                 this.historicPossesLoadingProm = new Promise(async (res) => {
+                    var _a;
                     try {
                         if (this.disposed) {
                             res(false);
@@ -22435,11 +23229,16 @@ var TilesetCadRenderManager;
                             return;
                         }
                         // Also request the current position in case its not in the range.
-                        const { entity } = await Entity$1.Get({
+                        // A simulated root, or an item that is not historic, has no current record to ask the API for.
+                        if (!historic || ((_a = this.simulation) === null || _a === void 0 ? void 0 : _a.HasEntity(this.rootId))) {
+                            res(positions);
+                            return;
+                        }
+                        const entity = this.atClock((await Entity$1.Get({
                             entityId: this.rootId,
                             historicPoint: this.viewer.clock.currentTime.toString(),
                             api: api
-                        });
+                        })).entity);
                         if (this.disposed || !entity) {
                             res(false);
                             return;
@@ -22519,14 +23318,15 @@ var TilesetCadRenderManager;
                     }
                 });
                 this.viewerDateTimeChangeRemoval = () => {
+                    var _a, _b;
                     if (this.historicAnimation) {
                         this.historicAnimation.stop();
                         this.historicAnimation = null;
                     }
-                    if (this.trackEntity) {
-                        RemoveCEntityFromScene(this.viewer, this.trackEntity);
-                        this.trackEntity = null;
-                    }
+                    (_a = this.historicGatherer) === null || _a === void 0 ? void 0 : _a.Dispose();
+                    this.historicGatherer = null;
+                    (_b = this.trail) === null || _b === void 0 ? void 0 : _b.Dispose();
+                    this.trail = null;
                     if (clockTickRemoval) {
                         clockTickRemoval();
                         clockTickRemoval = null;
@@ -22534,10 +23334,84 @@ var TilesetCadRenderManager;
                 };
             });
         }
-        viewerDateTimeDispose() {
+        /*
+         * Keeps the tileset in line with what is simulated for its root Entity.
+         */
+        followSimulation(tileset) {
+            if (this.simulationRemoval || !this.simulation) {
+                return;
+            }
+            this.simulationRemoval = this.simulation.OnChanged.Subscribe((change) => {
+                var _a;
+                if (this.disposed || !this.rootId || !change.entityIds.includes(this.rootId)) {
+                    return;
+                }
+                if (change.records) {
+                    this.regatherRoot(tileset);
+                }
+                // A simulated root is where the tileset stands outside its history; recorded positions still win.
+                if (change.entities && !((_a = this.historicAnimation) === null || _a === void 0 ? void 0 : _a.getDateRange().minDate)) {
+                    this.applyRootRest(tileset);
+                }
+            });
+        }
+        /*
+         * Re-reads the root's history after its simulated records changed, following the clock if it was not.
+         */
+        async regatherRoot(tileset) {
+            var _a;
+            if (!this.historicGatherer) {
+                this.viewerDateTimeSub(tileset);
+                return;
+            }
+            await this.historicPossesLoadingProm;
+            const { recordsByIds } = await this.historicGatherer.Gather([{ Bruce: { ID: this.rootId } }]);
+            if (this.disposed) {
+                return;
+            }
+            const posses = Manager.HistoricPossesFor({ viewer: this.viewer, item: this.item, records: recordsByIds[this.rootId] || [] });
+            (_a = this.historicAnimation) === null || _a === void 0 ? void 0 : _a.replacePositions(posses);
+            if (!posses.length) {
+                this.applyRootRest(tileset);
+            }
+        }
+        /*
+         * The root as read at the scene's time, with any simulated record at that time laid over it.
+         */
+        atClock(root) {
+            return this.simulation && root
+                ? this.simulation.ApplyAt(root, JulianDate.toDate(this.viewer.clock.currentTime).getTime())
+                : root;
+        }
+        /*
+         * Stands the tileset where its root is outside history: the simulated root, else the root's own record.
+         */
+        applyRootRest(tileset) {
             var _a;
+            this.applyCoords(tileset, (_a = this.simulatedRootCoords()) !== null && _a !== void 0 ? _a : this.restCoords);
+        }
+        /*
+         * Where a simulated root puts the tileset, or null; a patch only places it when it names a whole location.
+         */
+        simulatedRootCoords() {
+            var _a, _b;
+            const simulation = this.rootId ? this.simulation : null;
+            const root = (_a = simulation === null || simulation === void 0 ? void 0 : simulation.GetEntity(this.rootId)) !== null && _a !== void 0 ? _a : ((simulation === null || simulation === void 0 ? void 0 : simulation.HasBlob(this.rootId)) ? simulation.Overlay({ Bruce: { ID: this.rootId } }) : null);
+            const location = (_b = root === null || root === void 0 ? void 0 : root.Bruce) === null || _b === void 0 ? void 0 : _b.Location;
+            if ((location === null || location === void 0 ? void 0 : location.latitude) == null || (location === null || location === void 0 ? void 0 : location.longitude) == null) {
+                return null;
+            }
+            const pos3d = Cartesian3.fromDegrees(+location.longitude, +location.latitude, EnsureNumber(location.altitude, 0));
+            const transform = root.Bruce.Transform;
+            return coordsFromHistoricPos3d(this.cTileset, this.rootId, pos3d, EnsureNumber(transform === null || transform === void 0 ? void 0 : transform.heading, 0), transform === null || transform === void 0 ? void 0 : transform.pitch, transform === null || transform === void 0 ? void 0 : transform.roll);
+        }
+        viewerDateTimeDispose() {
+            var _a, _b;
             (_a = this.viewerDateTimeChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
             this.viewerDateTimeChangeRemoval = null;
+            // Made before the first positions land, so it can outlive a removal that was never set.
+            (_b = this.historicGatherer) === null || _b === void 0 ? void 0 : _b.Dispose();
+            this.historicGatherer = null;
         }
         /**
          * Updates the Tileset with latest coordinates.
@@ -23680,11 +24554,11 @@ var DataLabRenderManager;
             this.viewMonitorRemoval = null;
             this.renderQueue = [];
             this.renderQueueInterval = null;
-            this.reRenderState = new EntityReRenderMaintainState();
             this.zoomControl = [];
             this.queryLoadId = 0;
             this.renderDataLabEntitiesChain = Promise.resolve();
             const { viewer, item, apiGetter, monitor, visualsRegister } = params;
+            this.reRenderState = new EntityReRenderMaintainState(params.simulation);
             this.viewer = viewer;
             this.item = item;
             this.apiGetter = apiGetter;
@@ -23781,7 +24655,8 @@ var DataLabRenderManager;
                 if (!((_a = data === null || data === void 0 ? void 0 : data.entities) === null || _a === void 0 ? void 0 : _a.length)) {
                     return;
                 }
-                this.distributeForRender(data.entities);
+                // The getter answers from the API, so a simulated Entity in its answer is swapped for its blob.
+                this.distributeForRender(this.reRenderState.withSimulated(data.entities));
             });
         }
         unsetGetter() {
@@ -25532,6 +26407,7 @@ var TilesetEntitiesRenderManager;
             this.featurePropCache = new Map();
             this.featurePropsChecked = 0;
             const { viewer, register: visualsManager, getters: apiGetter, item, initQueue, monitor } = params;
+            this.simulation = params.simulation;
             this.monitor = monitor;
             this.viewer = viewer;
             this.getters = apiGetter;
@@ -25632,6 +26508,7 @@ var TilesetEntitiesRenderManager;
                             if (Manager.NeedsStyler(this.item)) {
                                 const api = this.getters.GetBruceApi();
                                 this.styler.Init({
+                                    simulation: this.simulation,
                                     viewer: this.viewer,
                                     api: api,
                                     cTileset: this.cTileset,
@@ -25989,6 +26866,7 @@ var TilesetEntitiesRenderManager;
             const needsStyler = Manager.NeedsStyler(this.item);
             if (needsStyler) {
                 this.styler.Init({
+                    simulation: this.simulation,
                     viewer: this.viewer,
                     api: this.getters.GetBruceApi(),
                     cTileset: this.cTileset,
@@ -26680,6 +27558,7 @@ var TilesetArbRenderManager;
             // LCC object if we're using XGrids to render LCC data.
             this.lccObject = null;
             this.viewer = params.viewer;
+            this.simulation = params.simulation;
             this.getters = params.getters;
             this.visualsManager = params.register;
             // We modify the object due to a lot of backwards compatibility.
@@ -26914,6 +27793,7 @@ var TilesetArbRenderManager;
                                 this.item.Type == MenuItem.EType.IonTileset) {
                                 const api = this.getters.GetBruceApi();
                                 this.styler.Init({
+                                    simulation: this.simulation,
                                     viewer: this.viewer,
                                     api: api,
                                     cTileset: this.cTileset,
@@ -27255,14 +28135,32 @@ var RelationsRenderManager;
         }
         ;
         constructor(params) {
+            var _a, _b;
             // If true, this menu item is disposed and should not be used.
             // Any rendering will be ignored.
             this.disposed = false;
+            this.simulationRemoval = null;
+            this.FollowsSimulation = true;
             const { apiGetter, item, register, viewer } = params;
             this.apiGetter = apiGetter;
             this.item = item;
             this.register = register;
             this.viewer = viewer;
+            this.simulation = params.simulation;
+            // Ends are not this item's own Entities, so it watches the store itself rather than wait to be asked.
+            this.simulationRemoval = (_b = (_a = this.simulation) === null || _a === void 0 ? void 0 : _a.OnChanged.Subscribe((change) => {
+                if (this.disposed) {
+                    return;
+                }
+                const relations = RelationRenderEngine.TakeRelationsTouching({
+                    visualRegister: this.register,
+                    menuItemId: this.item.id,
+                    entityIds: change.entityIds
+                });
+                if (relations.length) {
+                    this.onGetterUpdate(relations);
+                }
+            })) !== null && _b !== void 0 ? _b : null;
         }
         /**
          * Starts rendering the menu item.
@@ -27331,10 +28229,13 @@ var RelationsRenderManager;
             return items;
         }
         Dispose() {
+            var _a;
             if (this.disposed) {
                 return;
             }
             this.disposed = true;
+            (_a = this.simulationRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.simulationRemoval = null;
             this.register.RemoveRegos({
                 menuItemId: this.item.id
             });
@@ -27573,7 +28474,8 @@ var RelationsRenderManager;
                     menuItemId: this.item.id,
                     relations: relations,
                     viewer: this.viewer,
-                    visualRegister: this.register
+                    visualRegister: this.register,
+                    simulation: this.simulation
                 });
                 if (this.disposed) {
                     this.register.RemoveRegos({
@@ -27856,9 +28758,12 @@ var LegacyRelationsRenderManager;
         }
         ;
         constructor(params) {
+            var _a, _b;
             // If true, this menu item is disposed and should not be used.
             // Any rendering will be ignored.
             this.disposed = false;
+            this.simulationRemoval = null;
+            this.FollowsSimulation = true;
             // Record of the currently drawn entity IDs.
             // This is to avoid re-queueing already drawn entities when Init is called multiple times.
             this.drawnIds = [];
@@ -27867,6 +28772,21 @@ var LegacyRelationsRenderManager;
             this.item = item;
             this.register = register;
             this.viewer = viewer;
+            this.simulation = params.simulation;
+            // Ends are not this item's own Entities, so it watches the store itself rather than wait to be asked.
+            this.simulationRemoval = (_b = (_a = this.simulation) === null || _a === void 0 ? void 0 : _a.OnChanged.Subscribe((change) => {
+                if (this.disposed) {
+                    return;
+                }
+                const relations = RelationRenderEngine.TakeRelationsTouching({
+                    visualRegister: this.register,
+                    menuItemId: this.item.id,
+                    entityIds: change.entityIds
+                });
+                if (relations.length) {
+                    this.onGetterUpdate(relations);
+                }
+            })) !== null && _b !== void 0 ? _b : null;
         }
         /**
          * Starts rendering the menu item.
@@ -27909,10 +28829,13 @@ var LegacyRelationsRenderManager;
             this.drawnIds = [].concat(entityIds);
         }
         Dispose() {
+            var _a;
             if (this.disposed) {
                 return;
             }
             this.disposed = true;
+            (_a = this.simulationRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.simulationRemoval = null;
             this.register.RemoveRegos({
                 menuItemId: this.item.id
             });
@@ -28073,7 +28996,8 @@ var LegacyRelationsRenderManager;
                     menuItemId: this.item.id,
                     relations: relations,
                     viewer: this.viewer,
-                    visualRegister: this.register
+                    visualRegister: this.register,
+                    simulation: this.simulation
                 });
                 if (this.disposed) {
                     this.register.RemoveRegos({
@@ -29306,6 +30230,55 @@ var AssemblyRenderManager;
         get ModelSpace() {
             return this.modelSpace;
         }
+        /**
+         * Every node of the Assembly read so far, so a caller can work out motion in the Assembly's own terms.
+         * @param timeMs the scene time for each node's current pose. Default: the clock's.
+         * @returns per node its pose within its parent from the API (local) and as drawn at the time (current).
+         */
+        GetNodes(timeMs) {
+            const at = timeMs !== null && timeMs !== void 0 ? timeMs : JulianDate.toDate(this.viewer.clock.currentTime).getTime();
+            const rowsOf = (m) => m ? [0, 1, 2, 3].map(row => [0, 1, 2, 3].map(column => m[(column * 4) + row])) : null;
+            return Object.values(this.hierarchyNodeByEntityId || {}).map(node => {
+                var _a, _b, _c;
+                const entity = (_a = this.apiEntities.get(node.entityId)) !== null && _a !== void 0 ? _a : null;
+                const rows = (_b = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _b === void 0 ? void 0 : _b.AssemblyPosition;
+                return {
+                    entityId: node.entityId,
+                    name: node.name,
+                    parentId: (_c = node.parentId) !== null && _c !== void 0 ? _c : null,
+                    local: Manager.MatrixFromRows(rows) ? rows : null,
+                    current: rowsOf(this.localAt(node.entityId, at)),
+                    entity
+                };
+            });
+        }
+        /**
+         * The root's world frame at a time, history and simulation included, eg. to follow or frame the Assembly.
+         * @param timeMs the scene time. Default: the clock's.
+         * @returns null until the root has been read.
+         */
+        GetRootFrame(timeMs) {
+            const root = this.rootAt(timeMs !== null && timeMs !== void 0 ? timeMs : JulianDate.toDate(this.viewer.clock.currentTime).getTime());
+            return root ? Manager.rootFrame(root.pos3d, root.heading, root.pitch, root.roll) : null;
+        }
+        /**
+         * A part's world frame at a time as its records and its parents place it, size included.
+         * @param entityId the part.
+         * @param timeMs the scene time. Default: the clock's.
+         * @returns null until the root and the part have been read.
+         */
+        GetPartFrame(entityId, timeMs) {
+            const at = timeMs !== null && timeMs !== void 0 ? timeMs : JulianDate.toDate(this.viewer.clock.currentTime).getTime();
+            const rootFrame = this.GetRootFrame(at);
+            const world = entityId === this.rootId ? Matrix4.IDENTITY : this.composeWorld(entityId, at);
+            if (!rootFrame || !world) {
+                return null;
+            }
+            // Where the part is drawn, so its own ground offset is part of its frame.
+            const ground = this.groundOffsets.get(entityId);
+            const placed = ground ? Matrix4.multiply(Matrix4.fromTranslation(ground), world, new Matrix4()) : world;
+            return Matrix4.multiply(rootFrame, placed, new Matrix4());
+        }
         constructor(params) {
             this.disposed = false;
             // Cache of the hierarchy so that our scene-tree can reference it.
@@ -29315,19 +30288,41 @@ var AssemblyRenderManager;
             this.hierarchyNodeByEntityId = null;
             this.modelSpace = false;
             this.rootId = null;
-            // Where the root sits now, and which way it faces.
-            // Every child is placed through this, so a root move is one value changing rather than a refetch of the whole Assembly.
+            // Where the root sits outside its history, and which way it faces in degrees. Children are placed through it.
             this.rootPos3d = null;
             this.rootHeading = 0;
-            // Entity ID -> what was drawn for it and where it sits relative to the root.
+            this.rootPitch = 0;
+            this.rootRoll = 0;
+            // The root's recorded positions and attitudes, oldest first, kept apart since a record may name only one.
+            this.rootSeries = [];
+            this.rootAttitude = [];
+            // Every placement worked out for the scene time last asked about, shared by all parts drawn at it.
+            this.pose = null;
+            // Entity ID -> what was drawn for it.
             this.children = new Map();
+            // Entity ID -> its live position within its parent, for every node fetched including undrawn groups.
+            this.localPositions = new Map();
+            // Entity ID -> how much higher the ground under it is than under the root, along the root's up.
+            this.groundOffsets = new Map();
+            // Entity ID -> its recorded poses within its parent, oldest first.
+            this.jointSeries = new Map();
+            // Drawn children that can move with the clock, so a tick places only these and not the whole Assembly.
+            this.animatedIds = new Set();
             // The trail through the root's own movement, which describes the whole Assembly.
-            this.trackEntity = null;
+            this.trail = null;
+            this.simulationRemoval = null;
+            this.FollowsSimulation = true;
+            // Entity ID -> the record the API gave, so a cleared simulation falls back to it without a refetch.
+            this.apiEntities = new Map();
+            // Re-reads history and re-applies it, eg. after simulated records change. Set while the clock is followed.
+            this.regather = null;
+            this.followingClock = false;
             // Callback to dispose the link between scene time and the root's historic position.
             this.viewerDateTimeChangeRemoval = null;
             this.historicGatherer = null;
             this.historicAnimation = null;
             const { viewer, register: visualsManager, getters, item } = params;
+            this.simulation = params.simulation;
             this.viewer = viewer;
             this.getters = getters;
             this.item = item;
@@ -29351,10 +30346,10 @@ var AssemblyRenderManager;
             return EntityRenderEngine.GetHeightRef((_b = (_a = item === null || item === void 0 ? void 0 : item.Style) === null || _a === void 0 ? void 0 : _a.Settings) === null || _b === void 0 ? void 0 : _b["modelStyle"]);
         }
         /*
-         * The root's frame: east-north-up at its position, turned by its heading.
+         * The root's frame: east-north-up at its position, turned by its heading, pitch and roll.
          */
-        static rootFrame(rootPos3d, headingDegrees) {
-            const hpr = new HeadingPitchRoll(Math$1.toRadians(headingDegrees || 0), 0, 0);
+        static rootFrame(rootPos3d, headingDegrees, pitchDegrees = 0, rollDegrees = 0) {
+            const hpr = new HeadingPitchRoll(Math$1.toRadians(headingDegrees || 0), Math$1.toRadians(pitchDegrees || 0), Math$1.toRadians(rollDegrees || 0));
             return Transforms.headingPitchRollToFixedFrame(rootPos3d, hpr);
         }
         /**
@@ -29377,28 +30372,553 @@ var AssemblyRenderManager;
             return Matrix4.multiplyByPoint(Manager.rootFrame(rootPos3d, headingDegrees), offset, new Cartesian3());
         }
         /**
-         * Moves the whole Assembly to a new root position, without refetching any of its children.
+         * Moves where the root sits outside its history, without refetching children; recorded poses still win.
          * @param params
          */
         ApplyRootPosition(params) {
-            var _a, _b;
+            var _a, _b, _c, _d, _e, _f;
             if (this.disposed || !(params === null || params === void 0 ? void 0 : params.pos3d)) {
                 return;
             }
             this.rootPos3d = params.pos3d;
             this.rootHeading = (_b = (_a = params.heading) !== null && _a !== void 0 ? _a : this.rootHeading) !== null && _b !== void 0 ? _b : 0;
+            this.rootPitch = (_d = (_c = params.pitch) !== null && _c !== void 0 ? _c : this.rootPitch) !== null && _d !== void 0 ? _d : 0;
+            this.rootRoll = (_f = (_e = params.roll) !== null && _e !== void 0 ? _e : this.rootRoll) !== null && _f !== void 0 ? _f : 0;
+            this.repose(true);
+        }
+        /*
+         * Drops every placement worked out so far, after the root or a joint's records change.
+         * @param everyChild re-place the parts that cannot move as well, because where they rest has changed.
+         */
+        repose(everyChild = false) {
+            this.pose = null;
             for (const child of this.children.values()) {
-                const pos3d = Manager.ChildPositionFrom(this.rootPos3d, this.rootHeading, child.offset);
-                if (!pos3d) {
+                if (everyChild || Boolean(child.moving) != this.canMove(child.entityId)) {
+                    this.bindPlacement(child);
+                }
+            }
+            this.viewer.scene.requestRender();
+        }
+        /*
+         * Takes a node's pose outside its history from its record, and for the root where it stands and faces.
+         */
+        absorbNode(entity) {
+            var _a, _b, _c, _d, _e;
+            const id = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
+            const local = Manager.MatrixFromRows((_b = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _b === void 0 ? void 0 : _b.AssemblyPosition);
+            if (local) {
+                this.localPositions.set(id, local);
+            }
+            // Anchored on the root, which is usually never drawn; everything under it is placed from the hierarchy.
+            if (id === this.rootId || (!this.rootId && !this.rootPos3d)) {
+                const rootPos3d = EntityUtils.GetPos({
+                    viewer: this.viewer,
+                    entity,
+                    recordHeightRef: Manager.GetRecordHeightRef(this.item),
+                    returnHeightRef: HeightReference.NONE,
+                    allowRendered: false
+                });
+                if (rootPos3d) {
+                    this.rootPos3d = rootPos3d;
+                    this.rootHeading = EnsureNumber((_c = entity.Bruce.Transform) === null || _c === void 0 ? void 0 : _c.heading, 0);
+                    this.rootPitch = EnsureNumber((_d = entity.Bruce.Transform) === null || _d === void 0 ? void 0 : _d.pitch, 0);
+                    this.rootRoll = EnsureNumber((_e = entity.Bruce.Transform) === null || _e === void 0 ? void 0 : _e.roll, 0);
+                }
+            }
+        }
+        /*
+         * A node's record with its simulation laid over it, keeping what a stand-in leaves out, eg. its model.
+         */
+        withSimulation(entity) {
+            var _a;
+            const id = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
+            if (!this.simulation || !id) {
+                return entity;
+            }
+            const standIn = this.simulation.GetEntity(id);
+            if (!standIn) {
+                return this.simulation.Overlay(entity);
+            }
+            return { ...entity, ...standIn, Bruce: { ...entity.Bruce, ...standIn.Bruce } };
+        }
+        /*
+         * Brings the Assembly in line with a change to what is simulated.
+         */
+        onSimulationChanged(change) {
+            var _a;
+            if (this.disposed || !this.hierarchyNodeByEntityId) {
+                return;
+            }
+            const ids = change.entityIds.filter(id => this.hierarchyNodeByEntityId[id]);
+            if (!ids.length) {
+                return;
+            }
+            if (change.entities) {
+                for (const id of ids) {
+                    const api = this.apiEntities.get(id);
+                    if (!api) {
+                        // Not loaded yet, and it will be drawn from its simulation when it is.
+                        continue;
+                    }
+                    const entity = this.withSimulation(api);
+                    // A cleared blob leaves the node's own matrix where the API has none, so it is reset.
+                    if (!((_a = entity.Bruce) === null || _a === void 0 ? void 0 : _a.AssemblyPosition)) {
+                        this.localPositions.delete(id);
+                    }
+                    this.absorbNode(entity);
+                    const child = this.children.get(id);
+                    if (child) {
+                        child.entity = entity;
+                    }
+                }
+                this.repose(true);
+            }
+            if (change.records) {
+                if (this.regather) {
+                    this.regather(true);
+                }
+                else {
+                    this.viewerDateTimeSub();
+                }
+            }
+        }
+        /*
+         * Nodes of this Assembly with simulated history.
+         */
+        simulatedNodeIds() {
+            if (!this.simulation || !this.hierarchyNodeByEntityId) {
+                return [];
+            }
+            return this.simulation.GetRecordEntityIds().filter(id => this.hierarchyNodeByEntityId[id]);
+        }
+        /*
+         * Whether a node can move with time: the root has history, or it or an ancestor does.
+         */
+        canMove(entityId) {
+            return this.rootSeries.length > 0 || this.rootAttitude.length > 0 || this.animatedIds.has(entityId);
+        }
+        /*
+         * Gives a child its position and orientation, as functions of scene time only when it can move.
+         */
+        bindPlacement(child) {
+            const id = child.entityId;
+            const moving = this.canMove(id);
+            if (moving) {
+                if (!child.moving) {
+                    child.cEntity.position = new CallbackProperty((time, result) => { var _a; return Manager.cloneOrUndefined((_a = this.placementAt(id, time)) === null || _a === void 0 ? void 0 : _a.pos3d, result); }, false);
+                    child.cEntity.orientation = new CallbackProperty((time, result) => {
+                        var _a;
+                        const orient = (_a = this.placementAt(id, time)) === null || _a === void 0 ? void 0 : _a.orient;
+                        return orient ? Quaternion.clone(orient, result) : undefined;
+                    }, false);
+                    child.cEntity.model.scale = new CallbackProperty((time) => { var _a, _b; return (_b = (_a = this.placementAt(id, time)) === null || _a === void 0 ? void 0 : _a.scale) !== null && _b !== void 0 ? _b : 1; }, false);
+                }
+            }
+            else {
+                const placed = this.placementAt(id, this.viewer.clock.currentTime);
+                if (placed) {
+                    child.cEntity.position = new ConstantPositionProperty(placed.pos3d);
+                    if (placed.orient) {
+                        child.cEntity.orientation = new ConstantProperty(placed.orient);
+                    }
+                    child.cEntity.model.scale = new ConstantProperty(placed.scale);
+                }
+            }
+            if (Boolean(child.moving) != moving) {
+                child.moving = moving;
+                this.visualsManager.SetMoving({ moving, entityIds: [id], menuItemId: this.item.id });
+            }
+        }
+        /*
+         * The one scale a model takes from its part's composed matrix, the largest when they are uneven.
+         */
+        static uniformScale(world) {
+            return Cartesian3.maximumComponent(Matrix4.getScale(world, new Cartesian3()));
+        }
+        static cloneOrUndefined(pos3d, result) {
+            return pos3d ? Cartesian3.clone(pos3d, result) : undefined;
+        }
+        /*
+         * Where a node draws at a scene time, from one composition shared by every part asked about at that time.
+         */
+        placementAt(entityId, time) {
+            if (this.disposed || !time) {
+                return null;
+            }
+            const timeMs = JulianDate.toDate(time).getTime();
+            if (!this.pose || this.pose.timeMs !== timeMs) {
+                const root = this.rootAt(timeMs);
+                this.pose = {
+                    timeMs,
+                    rootFrame: root ? Manager.rootFrame(root.pos3d, root.heading, root.pitch, root.roll) : null,
+                    worlds: new Map(),
+                    placements: new Map()
+                };
+            }
+            const pose = this.pose;
+            if (!pose.rootFrame) {
+                return null;
+            }
+            let placed = pose.placements.get(entityId);
+            if (!placed) {
+                const world = this.composeWorld(entityId, timeMs, pose.worlds);
+                const offset = world
+                    ? Matrix4.getTranslation(world, new Cartesian3())
+                    : new Cartesian3(0, 0, 0);
+                const ground = this.groundOffsets.get(entityId);
+                if (ground) {
+                    Cartesian3.add(offset, ground, offset);
+                }
+                placed = {
+                    pos3d: Matrix4.multiplyByPoint(pose.rootFrame, offset, new Cartesian3()),
+                    // Without a matrix, eg. the root itself, there is no orientation of its own to apply.
+                    orient: world ? EntityUtils.GetAssemblyOrientationInFrame(pose.rootFrame, world) : null,
+                    scale: world ? Manager.uniformScale(world) : 1
+                };
+                pose.placements.set(entityId, placed);
+            }
+            return placed;
+        }
+        /*
+         * The root's pose at a time, position and attitude each following their own records as a joint's do.
+         */
+        rootAt(timeMs) {
+            const pos3d = this.rootPositionAt(timeMs);
+            if (!pos3d) {
+                return null;
+            }
+            const live = { heading: this.rootHeading, pitch: this.rootPitch, roll: this.rootRoll };
+            const series = this.rootAttitude;
+            if (!series.length || timeMs < series[0].timeMs) {
+                return { pos3d, ...live };
+            }
+            let i = 0;
+            while (i < series.length - 1 && series[i + 1].timeMs <= timeMs) {
+                i++;
+            }
+            const a = series[i];
+            const b = series[i + 1];
+            const t = b ? (timeMs - a.timeMs) / (b.timeMs - a.timeMs) : 0;
+            const turn = (from, to, fallback) => {
+                var _a, _b, _c;
+                const x = (_a = from !== null && from !== void 0 ? from : fallback) !== null && _a !== void 0 ? _a : 0;
+                const y = (_c = (_b = (b ? to : from)) !== null && _b !== void 0 ? _b : fallback) !== null && _c !== void 0 ? _c : 0;
+                // The short way round, so 350 to 10 degrees turns through north rather than all the way back.
+                return x + (Math$1.negativePiToPi(Math$1.toRadians(y - x)) * 180 / Math.PI) * t;
+            };
+            return {
+                pos3d,
+                heading: turn(a.heading, b === null || b === void 0 ? void 0 : b.heading, live.heading),
+                pitch: turn(a.pitch, b === null || b === void 0 ? void 0 : b.pitch, live.pitch),
+                roll: turn(a.roll, b === null || b === void 0 ? void 0 : b.roll, live.roll)
+            };
+        }
+        /*
+         * Where the root is at a time, from its recorded positions.
+         */
+        rootPositionAt(timeMs) {
+            const series = this.rootSeries;
+            if (!series.length || timeMs < series[0].timeMs) {
+                return this.rootPos3d;
+            }
+            let i = 0;
+            while (i < series.length - 1 && series[i + 1].timeMs <= timeMs) {
+                i++;
+            }
+            const a = series[i];
+            const b = series[i + 1];
+            if (!b) {
+                return a.pos3d;
+            }
+            const t = (timeMs - a.timeMs) / (b.timeMs - a.timeMs);
+            // A straight line between orbit samples cuts up to a kilometre inside the path, so it is lifted back out.
+            const chord = Cartesian3.lerp(a.pos3d, b.pos3d, t, new Cartesian3());
+            const carto = Cartographic.fromCartesian(chord);
+            return carto
+                ? Cartesian3.fromRadians(carto.longitude, carto.latitude, Math$1.lerp(a.height, b.height, t))
+                : chord;
+        }
+        /*
+         * Takes the root's records into its series.
+         * @param replace the records are everything held for the root, so the series becomes exactly them.
+         * @returns whether the series changed.
+         */
+        absorbRootRecords(posses, replace) {
+            if (!(posses === null || posses === void 0 ? void 0 : posses.length) && !(replace && this.rootSeries.length)) {
+                return false;
+            }
+            const byTime = new Map(replace ? [] : this.rootSeries.map(k => [k.timeMs, k]));
+            for (const pos of posses) {
+                const carto = Cartographic.fromCartesian(pos.pos3d);
+                if (!carto) {
                     continue;
                 }
-                child.cEntity.position = new ConstantPositionProperty(pos3d);
-                const orient = EntityUtils.GetAssemblyOrientation(child.entity, pos3d);
-                if (orient) {
-                    child.cEntity.orientation = new ConstantProperty(orient);
+                byTime.set(pos.dateTime.getTime(), {
+                    timeMs: pos.dateTime.getTime(),
+                    pos3d: pos.pos3d,
+                    height: carto.height
+                });
+            }
+            const series = Array.from(byTime.values()).sort((x, y) => x.timeMs - y.timeMs);
+            const changed = (series.length !== this.rootSeries.length ||
+                series.some((k, i) => !Cartesian3.equals(k.pos3d, this.rootSeries[i].pos3d)));
+            this.rootSeries = series;
+            return changed;
+        }
+        /*
+         * Takes the angles the root's records name into its attitude series, apart from where it is.
+         * @param replace the records are everything held for the root, as for absorbRootRecords.
+         * @returns whether the series changed.
+         */
+        absorbRootAttitude(records, replace) {
+            const angle = (transform, key) => {
+                var _a;
+                const value = (_a = transform === null || transform === void 0 ? void 0 : transform[key]) !== null && _a !== void 0 ? _a : transform === null || transform === void 0 ? void 0 : transform[key[0].toUpperCase() + key.slice(1)];
+                return value == null || isNaN(+value) ? null : +value;
+            };
+            const byTime = new Map(replace ? [] : this.rootAttitude.map(k => [k.timeMs, k]));
+            for (const record of records || []) {
+                const timeMs = (record === null || record === void 0 ? void 0 : record.dateTime) ? new Date(record.dateTime).getTime() : NaN;
+                const key = {
+                    timeMs,
+                    heading: angle(record === null || record === void 0 ? void 0 : record.transform, "heading"),
+                    pitch: angle(record === null || record === void 0 ? void 0 : record.transform, "pitch"),
+                    roll: angle(record === null || record === void 0 ? void 0 : record.transform, "roll")
+                };
+                if (isNaN(timeMs) || (key.heading == null && key.pitch == null && key.roll == null)) {
+                    continue;
                 }
+                byTime.set(timeMs, key);
             }
-            this.viewer.scene.requestRender();
+            const series = Array.from(byTime.values()).sort((x, y) => x.timeMs - y.timeMs);
+            const held = this.rootAttitude;
+            const differs = (k, i) => (k.timeMs !== held[i].timeMs ||
+                k.heading !== held[i].heading ||
+                k.pitch !== held[i].pitch ||
+                k.roll !== held[i].roll);
+            const changed = series.length !== held.length || series.some(differs);
+            this.rootAttitude = series;
+            return changed;
+        }
+        /*
+         * A node's matrix in the root's frame at a time, from each ancestor's pose within its parent.
+         */
+        composeWorld(entityId, timeMs, memo, localOf = (id) => this.localAt(id, timeMs)) {
+            var _a, _b, _c, _d;
+            if (memo === null || memo === void 0 ? void 0 : memo.has(entityId)) {
+                return memo.get(entityId);
+            }
+            let world = null;
+            const local = localOf(entityId);
+            if (local) {
+                const parentId = (_b = (_a = this.hierarchyNodeByEntityId) === null || _a === void 0 ? void 0 : _a[entityId]) === null || _b === void 0 ? void 0 : _b.parentId;
+                const parent = parentId ? this.composeWorld(parentId, timeMs, memo, localOf) : null;
+                world = parent ? Matrix4.multiply(parent, local, new Matrix4()) : Matrix4.clone(local);
+            }
+            else if (entityId !== this.rootId) {
+                // A node whose own position was not fetched falls back to the API's composed matrix.
+                const child = this.children.get(entityId);
+                world = Manager.MatrixFromRows((_d = (_c = child === null || child === void 0 ? void 0 : child.entity) === null || _c === void 0 ? void 0 : _c.Bruce) === null || _d === void 0 ? void 0 : _d.AssemblyWorldPosition);
+            }
+            memo === null || memo === void 0 ? void 0 : memo.set(entityId, world);
+            return world;
+        }
+        /*
+         * Under a clamped or relative style, lifts a part by how much higher its ground is than the root's.
+         */
+        measureGroundOffset(entity) {
+            var _a;
+            const entityId = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
+            this.groundOffsets.delete(entityId);
+            const root = this.apiEntities.get(this.rootId);
+            if (!entityId ||
+                entityId === this.rootId ||
+                !root ||
+                !this.rootPos3d ||
+                Manager.GetRecordHeightRef(this.item) === HeightReference.NONE) {
+                return;
+            }
+            const rootFrame = Manager.rootFrame(this.rootPos3d, this.rootHeading, this.rootPitch, this.rootRoll);
+            const toRoot = Matrix4.inverse(rootFrame, new Matrix4());
+            const groundUp = (record) => {
+                const pos3d = EntityUtils.GetPos({
+                    viewer: this.viewer,
+                    entity: record,
+                    recordHeightRef: HeightReference.CLAMP_TO_GROUND,
+                    returnHeightRef: HeightReference.NONE,
+                    allowRendered: false
+                });
+                return pos3d ? Matrix4.multiplyByPoint(toRoot, pos3d, new Cartesian3()).z : null;
+            };
+            const part = groundUp(entity);
+            const under = groundUp(root);
+            if (part == null || under == null || Math.abs(part - under) < 1e-6) {
+                return;
+            }
+            this.groundOffsets.set(entityId, new Cartesian3(0, 0, part - under));
+        }
+        /*
+         * The rigid Earth-fixed motion from where a part's record places it to where it is drawn at a time.
+         */
+        motionAt(entityId, time) {
+            if (this.disposed || !time || !this.rootPos3d) {
+                return null;
+            }
+            const timeMs = JulianDate.toDate(time).getTime();
+            const root = this.rootAt(timeMs);
+            const drawn = this.composeWorld(entityId, timeMs, new Map());
+            const stored = this.composeWorld(entityId, timeMs, new Map(), (id) => {
+                var _a, _b, _c, _d;
+                return ((_d = (_c = Manager.MatrixFromRows((_b = (_a = this.apiEntities.get(id)) === null || _a === void 0 ? void 0 : _a.Bruce) === null || _b === void 0 ? void 0 : _b.AssemblyPosition)) !== null && _c !== void 0 ? _c : this.localPositions.get(id)) !== null && _d !== void 0 ? _d : null);
+            });
+            if (!root || !drawn || !stored) {
+                return null;
+            }
+            const drawnFixed = Matrix4.multiply(Manager.rootFrame(root.pos3d, root.heading, root.pitch, root.roll), drawn, new Matrix4());
+            const storedFixed = Matrix4.multiply(Manager.rootFrame(this.rootPos3d, this.rootHeading, this.rootPitch, this.rootRoll), stored, new Matrix4());
+            return Matrix4.multiply(drawnFixed, Matrix4.inverse(storedFixed, new Matrix4()), new Matrix4());
+        }
+        /*
+         * A node's pose within its parent at a time, interpolated between the records either side.
+         */
+        localAt(entityId, timeMs) {
+            var _a;
+            // The live pose stands before the first record and the last record holds after it, as in an API read.
+            const live = (_a = this.localPositions.get(entityId)) !== null && _a !== void 0 ? _a : null;
+            const series = this.jointSeries.get(entityId);
+            if (!(series === null || series === void 0 ? void 0 : series.length) || timeMs == null || timeMs < series[0].timeMs) {
+                return live;
+            }
+            let i = 0;
+            while (i < series.length - 1 && series[i + 1].timeMs <= timeMs) {
+                i++;
+            }
+            const a = series[i];
+            const b = series[i + 1];
+            if (!b) {
+                return Matrix4.fromTranslationQuaternionRotationScale(a.translation, a.rotation, a.scale);
+            }
+            const t = (timeMs - a.timeMs) / (b.timeMs - a.timeMs);
+            return Matrix4.fromTranslationQuaternionRotationScale(Cartesian3.lerp(a.translation, b.translation, t, new Cartesian3()), Quaternion.slerp(a.rotation, b.rotation, t, new Quaternion()), Cartesian3.lerp(a.scale, b.scale, t, new Cartesian3()));
+        }
+        /*
+         * Rebuilds each node's keyframes from the historic records held so far.
+         * @returns whether any node has keyframes.
+         */
+        absorbJointRecords(recordsByIds) {
+            var _a;
+            // Everything held is given, so a node with nothing left, eg. its simulated records cleared, stops moving.
+            for (const entityId of Array.from(this.jointSeries.keys())) {
+                if (!((_a = recordsByIds === null || recordsByIds === void 0 ? void 0 : recordsByIds[entityId]) === null || _a === void 0 ? void 0 : _a.length)) {
+                    this.jointSeries.delete(entityId);
+                }
+            }
+            for (const entityId of Object.keys(recordsByIds || {})) {
+                const keyframes = [];
+                for (const record of recordsByIds[entityId] || []) {
+                    const matrix = Manager.MatrixFromRows(record.assemblyPosition);
+                    const timeMs = new Date(record.dateTime).getTime();
+                    if (!matrix || isNaN(timeMs)) {
+                        continue;
+                    }
+                    const scale = Matrix4.getScale(matrix, new Cartesian3());
+                    const rotation = Matrix4.getRotation(matrix, new Matrix3());
+                    keyframes.push({
+                        timeMs,
+                        translation: Matrix4.getTranslation(matrix, new Cartesian3()),
+                        rotation: Quaternion.fromRotationMatrix(rotation),
+                        scale
+                    });
+                }
+                if (keyframes.length) {
+                    keyframes.sort((x, y) => x.timeMs - y.timeMs);
+                    this.jointSeries.set(entityId, keyframes);
+                }
+            }
+            this.refreshAnimated();
+            return this.jointSeries.size > 0;
+        }
+        /*
+         * Rebuilds which drawn children can move with the clock, by walking each one up to the root.
+         */
+        refreshAnimated() {
+            this.animatedIds.clear();
+            if (!this.jointSeries.size) {
+                return;
+            }
+            for (const entityId of this.children.keys()) {
+                if (this.hasAnimatedAncestry(entityId)) {
+                    this.animatedIds.add(entityId);
+                }
+            }
+        }
+        /*
+         * Whether a node or anything above it has keyframes, so the clock can move it.
+         */
+        hasAnimatedAncestry(entityId) {
+            var _a, _b;
+            let at = entityId;
+            while (at && this.jointSeries.size) {
+                if (this.jointSeries.has(at)) {
+                    return true;
+                }
+                at = (_b = (_a = this.hierarchyNodeByEntityId) === null || _a === void 0 ? void 0 : _a[at]) === null || _b === void 0 ? void 0 : _b.parentId;
+            }
+            return false;
+        }
+        /*
+         * Which nodes to ask history for.
+         */
+        async historicEntityIds(api) {
+            var _a, _b;
+            // Through the Assembly when there is one, so the hierarchy follows the relation type on its record.
+            const assemblyId = this.item["Assembly.ID"];
+            const root = assemblyId ? { key: "root", AssemblyID: assemblyId } : { key: "root", RootID: this.rootId };
+            const historic = {
+                key: "historic",
+                Historic: { HistoricKey: ((_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historicAttrKey) || undefined }
+            };
+            const query = {
+                [DataLab.EReqKey.Primary]: { Items: [root, historic], Select: { Type: DataLab.ESelectType.Id } }
+            };
+            const load = 1000;
+            try {
+                const ids = [];
+                for (let skip = 0;; skip += load) {
+                    const { items } = await DataLab.Run({ api, query, skip, load });
+                    ids.push(...(items !== null && items !== void 0 ? items : []));
+                    if (!items || items.length < load) {
+                        return ids;
+                    }
+                }
+            }
+            catch (e) {
+                // An API without the historic criterion gets asked about every node, as before it existed.
+                console.warn("AssemblyRenderManager.historicEntityIds()", e);
+            }
+            return Object.keys((_b = this.hierarchyNodeByEntityId) !== null && _b !== void 0 ? _b : { [this.rootId]: null });
+        }
+        /**
+         * Builds a matrix from the row-major rows that Bruce/AssemblyPosition and AssemblyWorldPosition use.
+         * @param rows
+         */
+        static MatrixFromRows(rows) {
+            if (!Array.isArray(rows) || rows.length !== 4 || rows.some(r => !Array.isArray(r) || r.length !== 4)) {
+                return null;
+            }
+            return new Matrix4(+rows[0][0], +rows[0][1], +rows[0][2], +rows[0][3], +rows[1][0], +rows[1][1], +rows[1][2], +rows[1][3], +rows[2][0], +rows[2][1], +rows[2][2], +rows[2][3], +rows[3][0], +rows[3][1], +rows[3][2], +rows[3][3]);
+        }
+        /**
+         * The inverse of MatrixFromRows.
+         * @param matrix
+         */
+        static RowsFromMatrix(matrix) {
+            const rows = [];
+            for (let r = 0; r < 4; r++) {
+                const row = Matrix4.getRow(matrix, r, new Cartesian4());
+                rows.push([row.x, row.y, row.z, row.w]);
+            }
+            return rows;
         }
         Init() {
             this.renderPriority = this.item.renderPriority;
@@ -29406,6 +30926,7 @@ var AssemblyRenderManager;
                 this.renderPriority = 1;
             }
             (async () => {
+                var _a, _b;
                 if (this.disposed) {
                     return;
                 }
@@ -29421,6 +30942,8 @@ var AssemblyRenderManager;
                         this.hierarchyUpdate.Trigger(hierarchy);
                         // Build hierarchy node cache for quick lookups
                         this.buildHierarchyNodes(hierarchy);
+                        // A set for membership, since searching the list took minutes at 200k nodes.
+                        const seenIds = new Set();
                         const traverseHierarchy = (node, leavesOnly) => {
                             var _a;
                             if (node.Children) {
@@ -29429,7 +30952,8 @@ var AssemblyRenderManager;
                                 }
                             }
                             const addNode = !leavesOnly || !((_a = node.Children) === null || _a === void 0 ? void 0 : _a.length);
-                            if (addNode && node.ID && !flatEntityIds.includes(node.ID)) {
+                            if (addNode && node.ID && !seenIds.has(node.ID)) {
+                                seenIds.add(node.ID);
                                 flatEntityIds.push(node.ID);
                             }
                         };
@@ -29448,17 +30972,17 @@ var AssemblyRenderManager;
                         }
                     }
                     this.rootId = rootId;
+                    this.simulationRemoval = (_b = (_a = this.simulation) === null || _a === void 0 ? void 0 : _a.OnChanged.Subscribe((change) => this.onSimulationChanged(change))) !== null && _b !== void 0 ? _b : null;
                     if (this.disposed) {
                         return;
                     }
                     else if (flatEntityIds.length === 0) {
                         return;
                     }
+                    // Followed while the parts load: in a large Assembly loading takes far longer than anyone waits.
+                    const following = this.viewerDateTimeSub();
                     await this.processEntityIds(flatEntityIds);
-                    if (this.disposed) {
-                        return;
-                    }
-                    this.viewerDateTimeSub();
+                    await following;
                 }
                 catch (e) {
                     console.error("AssemblyRenderManager.Manager.Init()", e);
@@ -29485,7 +31009,7 @@ var AssemblyRenderManager;
                 if (!batch.length) {
                     continue;
                 }
-                const { entities: fetched } = await Entity$1.GetListByIds({
+                const { entities: apiEntities } = await Entity$1.GetListByIds({
                     entityIds: batch,
                     api: this.getters.GetBruceApi(),
                     expandLODs: true,
@@ -29497,6 +31021,16 @@ var AssemblyRenderManager;
                 if (this.disposed) {
                     return;
                 }
+                const fetched = apiEntities.map((entity) => {
+                    var _a;
+                    this.apiEntities.set((_a = entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID, entity);
+                    return this.withSimulation(entity);
+                });
+                for (const entity of fetched) {
+                    this.absorbNode(entity);
+                }
+                // Placements already worked out did not know about this batch's positions.
+                this.pose = null;
                 for (const entity of fetched) {
                     // Filter for valid LODs then take the highest quality one (lowest level).
                     let lods = entity.Bruce.LOD || [];
@@ -29519,57 +31053,46 @@ var AssemblyRenderManager;
                         // Won't bother with vector data for this experiment.
                         continue;
                     }
-                    const recordHeightRef = Manager.GetRecordHeightRef(this.item);
-                    const recordPos3d = EntityUtils.GetPos({
-                        viewer: this.viewer,
-                        entity,
-                        recordHeightRef: recordHeightRef,
-                        returnHeightRef: HeightReference.NONE,
-                        allowRendered: false
-                    });
-                    if (!recordPos3d) {
+                    const entityId = entity.Bruce.ID;
+                    this.measureGroundOffset(entity);
+                    // A placement cached before the offset was known would leave the part off its ground.
+                    (_a = this.pose) === null || _a === void 0 ? void 0 : _a.placements.delete(entityId);
+                    if (!this.canMove(entityId) && !this.placementAt(entityId, this.viewer.clock.currentTime)) {
                         continue;
                     }
-                    const entityId = entity.Bruce.ID;
-                    if (entityId === this.rootId || !this.rootPos3d) {
-                        // Nothing has a frame to be relative to until the root has one.
-                        this.rootPos3d = recordPos3d;
-                        this.rootHeading = EnsureNumber((_a = entity.Bruce.Transform) === null || _a === void 0 ? void 0 : _a.heading, 0);
-                    }
-                    // Held as an offset in the root's frame, so a root move places it again without
-                    // anything being fetched. Where the root already moved, that is where it goes.
-                    const offset = Manager.ChildOffsetIn(this.rootPos3d, this.rootHeading, recordPos3d);
-                    const pos3d = Manager.ChildPositionFrom(this.rootPos3d, this.rootHeading, offset);
-                    // Optional: a child with no world matrix is still worth drawing, it just has no
-                    // orientation of its own to apply.
-                    const orient = EntityUtils.GetAssemblyOrientation(entity, pos3d);
                     const cEntity = this.viewer.entities.add({
                         model: {
                             uri: lod["ClientFile"].URL,
                             ...ViewUtils.DefaultLightingProps(),
                             heightReference: HeightReference.NONE
-                        },
-                        position: pos3d,
-                        orientation: orient ? new ConstantProperty(orient) : undefined
+                        }
                     });
                     const prior = this.children.get(entityId);
                     if (prior && prior.cEntity !== cEntity) {
                         RemoveCEntityFromScene(this.viewer, prior.cEntity);
                     }
-                    this.children.set(entityId, {
+                    const child = {
                         entityId: entityId,
                         entity: entity,
-                        cEntity: cEntity,
-                        offset: offset
-                    });
+                        cEntity: cEntity
+                    };
+                    this.children.set(entityId, child);
+                    // Joins the animated set by its own ancestry, so a late part never re-walks the rest.
+                    if (this.hasAnimatedAncestry(entityId)) {
+                        this.animatedIds.add(entityId);
+                    }
                     const geometryRadius = Entity$1.GetValue({
                         entity: entity,
                         path: ["Bruce", "GeometryRadius"]
                     });
                     cEntity.model["_radius"] = geometryRadius;
                     cEntity.model["_radiusLoaded"] = true;
+                    // Placed before it is registered, so the register never measures a visual with no position.
+                    this.bindPlacement(child);
                     this.visualsManager.AddRego({
                         rego: {
+                            moving: child.moving ? true : null,
+                            motion: (time) => this.motionAt(entity.Bruce.ID, time),
                             canEdit: true,
                             entityId: entity.Bruce.ID,
                             menuItemId: this.item.id,
@@ -29589,47 +31112,89 @@ var AssemblyRenderManager;
             }
         }
         /*
-         * Follows the scene clock and moves the whole Assembly along the root Entity's historic path.
-         * Only the root is fetched: everything under it is placed through ApplyRootPosition.
+         * Follows the scene clock, moving the Assembly along the root's history and each joint along its own.
          */
-        viewerDateTimeSub() {
-            if (!Manager.IsHistoric(this.item) || this.viewerDateTimeChangeRemoval || !this.rootId) {
+        async viewerDateTimeSub() {
+            var _a;
+            const historic = Manager.IsHistoric(this.item);
+            if (this.followingClock || !this.rootId || (!historic && !this.simulatedNodeIds().length)) {
                 return;
             }
+            this.followingClock = true;
             const api = this.getters.GetBruceApi();
-            const rootEntity = { Bruce: { ID: this.rootId } };
+            const historicIds = historic ? await this.historicEntityIds(api) : [];
+            if (this.disposed) {
+                return;
+            }
+            const attrKey = (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historicAttrKey;
             const recordHeightRef = Manager.GetRecordHeightRef(this.item);
             const toPosses = (records) => {
                 return CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(this.viewer, recordHeightRef, HeightReference.NONE, records);
             };
-            this.historicGatherer = new HistoricGatherer({
-                viewer: this.viewer,
-                getApi: () => api,
-                getAttrKey: () => { var _a; return (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historicAttrKey; },
-                // For clock desync between whatever wrote the record and this client.
-                paddingMs: 15000,
-                onRecords: (recordsByIds) => {
-                    const records = recordsByIds[this.rootId];
-                    if ((records === null || records === void 0 ? void 0 : records.length) && this.historicAnimation) {
-                        this.historicAnimation.SupplementSeries(toPosses(records));
+            if (historicIds.length) {
+                this.historicGatherer = new HistoricGatherer({
+                    viewer: this.viewer,
+                    getApi: () => api,
+                    getAttrKey: () => attrKey,
+                    // For clock desync between whatever wrote the record and this client.
+                    paddingMs: 15000,
+                    simulation: this.simulation,
+                    onRecords: (recordsByIds) => {
+                        var _a;
+                        const records = recordsByIds[this.rootId];
+                        if (records === null || records === void 0 ? void 0 : records.length) {
+                            const posses = toPosses(records);
+                            (_a = this.historicAnimation) === null || _a === void 0 ? void 0 : _a.SupplementSeries(posses);
+                            const moved = this.absorbRootRecords(posses, false);
+                            if (this.absorbRootAttitude(records, false) || moved) {
+                                this.repose();
+                            }
+                        }
+                        // Joint records go in together once the gather lands, so parents never draw apart from children.
                     }
-                }
-            });
+                });
+            }
+            // The nodes with history: what the API has records for, and whatever has been simulated since.
+            const nodes = () => Array.from(new Set([...historicIds, ...this.simulatedNodeIds()]));
             let gathering = false;
-            const gather = async () => {
+            // Set when what is held changed without a fetch, eg. a simulated record arriving.
+            let stale = true;
+            const gather = async (force) => {
+                var _a, _b;
+                stale = stale || Boolean(force);
                 if (this.disposed || gathering) {
                     return;
                 }
                 gathering = true;
                 try {
-                    const { recordsByIds } = await this.historicGatherer.Gather([rootEntity]);
+                    const ids = nodes();
+                    let fetched = false;
+                    let recordsByIds;
+                    if (this.historicGatherer) {
+                        ({ fetched, recordsByIds } = await this.historicGatherer.Gather(ids.map(id => ({ Bruce: { ID: id } }))));
+                    }
+                    else {
+                        recordsByIds = (_b = (_a = this.simulation) === null || _a === void 0 ? void 0 : _a.MergeRecords({}, attrKey, ids)) !== null && _b !== void 0 ? _b : {};
+                    }
                     if (this.disposed) {
                         return;
                     }
+                    // A gather served from what is held changes nothing and runs every tick, so it stops here.
+                    if (!fetched && !stale && this.jointSeries.size) {
+                        return;
+                    }
+                    stale = false;
+                    let changed = this.absorbJointRecords(recordsByIds);
                     const posses = toPosses(recordsByIds[this.rootId] || []);
+                    changed = this.absorbRootRecords(posses, true) || changed;
+                    changed = this.absorbRootAttitude(recordsByIds[this.rootId] || [], true) || changed;
+                    if (changed) {
+                        this.repose();
+                    }
                     if (!posses.length) {
                         return;
                     }
+                    // Held for the trail alone; where the root is drawn comes from rootAt(), never from its smoothing.
                     if (!this.historicAnimation) {
                         this.historicAnimation = new CesiumAnimatedProperty.AnimatePositionSeries({
                             posses: posses,
@@ -29643,15 +31208,21 @@ var AssemblyRenderManager;
                 }
                 catch (e) {
                     console.error("AssemblyRenderManager.viewerDateTimeSub()", e);
+                    // A gather that throws would throw again straight away, so the retry waits for the next tick.
+                    stale = false;
                 }
                 finally {
                     gathering = false;
+                    // A change that landed mid-gather is not left for a tick that may never come on a paused clock.
+                    if (stale && !this.disposed) {
+                        gather();
+                    }
                 }
             };
+            this.regather = gather;
             gather();
             let lastTime = null;
             const tickRemoval = this.viewer.clock.onTick.addEventListener(() => {
-                var _a;
                 if (this.disposed) {
                     return;
                 }
@@ -29661,15 +31232,9 @@ var AssemblyRenderManager;
                 }
                 lastTime = now;
                 gather();
-                if (!this.historicAnimation) {
-                    return;
-                }
-                const pos3d = this.historicAnimation.GetValue();
-                if (pos3d) {
-                    this.ApplyRootPosition({
-                        pos3d: pos3d,
-                        heading: (_a = this.historicAnimation.GetHeadingDegrees()) !== null && _a !== void 0 ? _a : this.rootHeading
-                    });
+                // Moving parts read the clock themselves when drawn, so the scene only needs a new frame.
+                if (this.rootSeries.length || this.rootAttitude.length || this.animatedIds.size) {
+                    this.viewer.scene.requestRender();
                 }
             });
             this.viewerDateTimeChangeRemoval = () => {
@@ -29678,6 +31243,10 @@ var AssemblyRenderManager;
                 (_a = this.historicGatherer) === null || _a === void 0 ? void 0 : _a.Dispose();
                 this.historicGatherer = null;
                 this.historicAnimation = null;
+                this.regather = null;
+                this.rootSeries = [];
+                this.rootAttitude = [];
+                this.pose = null;
             };
         }
         /*
@@ -29685,7 +31254,7 @@ var AssemblyRenderManager;
          */
         applyRootTrack() {
             var _a;
-            if (!this.item.historicDrawTrack || !this.historicAnimation || this.trackEntity) {
+            if (!this.item.historicDrawTrack || !this.historicAnimation || this.trail) {
                 return;
             }
             const trackStyle = EntityRenderEngine.GetTrackStyle({
@@ -29695,41 +31264,35 @@ var AssemblyRenderManager;
             if (!trackStyle) {
                 return;
             }
-            this.trackEntity = this.viewer.entities.add({
-                id: ObjectUtils.UId(15),
-                polyline: {
-                    positions: new CallbackProperty(() => { var _a, _b; return (_b = (_a = this.historicAnimation) === null || _a === void 0 ? void 0 : _a.GetSeries()) !== null && _b !== void 0 ? _b : []; }, false),
-                    width: trackStyle.width,
-                    material: trackStyle.color,
-                    clampToGround: EntityRenderEngine.GetHeightRefPolyline(Manager.GetRecordHeightRef(this.item))
-                        == HeightReference.CLAMP_TO_GROUND,
-                    zIndex: 0,
-                    classificationType: ClassificationType.BOTH
-                }
-            });
-            this.trackEntity._noEdit = true;
-            this.trackEntity._noSelect = true;
-            CesiumEntityStyler.SetDefaultColor({
-                color: trackStyle.color,
-                entity: this.trackEntity,
+            this.trail = new HistoricTrail.Trail({
                 viewer: this.viewer,
-                override: true,
-                requestRender: false
+                color: trackStyle.color,
+                width: trackStyle.width,
+                clampToGround: EntityRenderEngine.GetHeightRefPolyline(Manager.GetRecordHeightRef(this.item))
+                    == HeightReference.CLAMP_TO_GROUND,
+                getSeries: () => { var _a, _b; return (_b = (_a = this.historicAnimation) === null || _a === void 0 ? void 0 : _a.GetSeries()) !== null && _b !== void 0 ? _b : []; },
+                trailSeconds: HistoricTrail.GetTrailSeconds(this.item),
+                // Where the root is drawn, so the trail ends on the model; nothing before the first record held.
+                positionAt: (timeMs) => (this.rootSeries.length && timeMs >= this.rootSeries[0].timeMs ? this.rootPositionAt(timeMs) : null)
             });
         }
         Dispose() {
-            var _a;
+            var _a, _b, _c;
             if (this.disposed) {
                 return;
             }
             this.disposed = true;
             (_a = this.viewerDateTimeChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
             this.viewerDateTimeChangeRemoval = null;
-            if (this.trackEntity) {
-                RemoveCEntityFromScene(this.viewer, this.trackEntity);
-                this.trackEntity = null;
-            }
+            (_b = this.simulationRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+            this.simulationRemoval = null;
+            this.apiEntities.clear();
+            (_c = this.trail) === null || _c === void 0 ? void 0 : _c.Dispose();
+            this.trail = null;
             this.children.clear();
+            this.localPositions.clear();
+            this.jointSeries.clear();
+            this.animatedIds.clear();
             this.visualsManager.RemoveRegos({
                 menuItemId: this.item.id
             });
@@ -30187,6 +31750,9 @@ var MenuItemManager;
                 this.OnSeriesUpdated.Trigger({ itemId, segments: [] });
             }
         }
+        get Simulation() {
+            return this.simulation;
+        }
         get Monitor() {
             return this.sharedMonitor;
         }
@@ -30212,6 +31778,7 @@ var MenuItemManager;
             this.visualsRegister = visualsRegister;
             this.sharedGetters = new SharedGetters.Cache();
             this.sharedHistoric = new SharedHistoricGetters.Cache();
+            this.simulation = EntitySimulation.Get(this.viewer);
             this.sharedMonitor = new CesiumViewMonitor.Monitor(this.viewer);
             this.tilesetInitQueue = new InitQueueTileset(this.getters);
         }
@@ -30425,7 +31992,8 @@ var MenuItemManager;
                             monitor: this.sharedMonitor,
                             item: params.item,
                             sharedGetters: this.sharedGetters,
-                            onSeriesDiscovered: (segment) => this.RecordSeriesSegment(rItem.id, segment)
+                            onSeriesDiscovered: (segment) => this.RecordSeriesSegment(rItem.id, segment),
+                            simulation: this.simulation
                         });
                         break;
                     case MenuItem.EType.EntitiesLoaded:
@@ -30434,7 +32002,8 @@ var MenuItemManager;
                             register: this.visualsRegister,
                             apiGetter: params.apiGetter,
                             monitor: this.sharedMonitor,
-                            item: params.item
+                            item: params.item,
+                            simulation: this.simulation
                         });
                         break;
                     case MenuItem.EType.EntitiesIds:
@@ -30444,7 +32013,8 @@ var MenuItemManager;
                             apiGetter: params.apiGetter,
                             monitor: this.sharedMonitor,
                             item: params.item,
-                            sharedHistoric: this.sharedHistoric
+                            sharedHistoric: this.sharedHistoric,
+                            simulation: this.simulation
                         });
                         break;
                     case MenuItem.EType.Entity:
@@ -30453,7 +32023,8 @@ var MenuItemManager;
                             register: this.visualsRegister,
                             apiGetter: params.apiGetter,
                             monitor: this.sharedMonitor,
-                            item: params.item
+                            item: params.item,
+                            simulation: this.simulation
                         });
                         break;
                     case MenuItem.EType.CadTileset:
@@ -30463,7 +32034,8 @@ var MenuItemManager;
                             getters: this.getters,
                             item: params.item,
                             modelSpace: params.modelSpace,
-                            initQueue: this.tilesetInitQueue
+                            initQueue: this.tilesetInitQueue,
+                            simulation: this.simulation
                         });
                         break;
                     case MenuItem.EType.Assembly:
@@ -30473,6 +32045,7 @@ var MenuItemManager;
                             getters: params.getters,
                             item: params.item,
                             modelSpace: params.modelSpace,
+                            simulation: this.simulation
                         });
                         break;
                     case MenuItem.EType.Osm:
@@ -30500,7 +32073,8 @@ var MenuItemManager;
                             getters: this.getters,
                             monitor: this.sharedMonitor,
                             item: params.item,
-                            initQueue: this.tilesetInitQueue
+                            initQueue: this.tilesetInitQueue,
+                            simulation: this.simulation
                         });
                         break;
                     case MenuItem.EType.Kml:
@@ -30524,7 +32098,8 @@ var MenuItemManager;
                             getters: params.getters,
                             item: params.item,
                             viewer: this.viewer,
-                            register: this.visualsRegister
+                            register: this.visualsRegister,
+                            simulation: this.simulation
                         });
                         break;
                     // Deprecated to support a few demos until new one is phased in.
@@ -30534,7 +32109,8 @@ var MenuItemManager;
                             apiGetter: params.apiGetter,
                             item: params.item,
                             register: this.visualsRegister,
-                            viewer: this.viewer
+                            viewer: this.viewer,
+                            simulation: this.simulation
                         });
                         break;
                     case MenuItem.EType.Relationships:
@@ -30542,7 +32118,8 @@ var MenuItemManager;
                             apiGetter: params.apiGetter,
                             item: params.item,
                             register: this.visualsRegister,
-                            viewer: this.viewer
+                            viewer: this.viewer,
+                            simulation: this.simulation
                         });
                         break;
                     case MenuItem.EType.GooglePhotoTileset:
@@ -30574,7 +32151,8 @@ var MenuItemManager;
                             item: params.item,
                             apiGetter: params.apiGetter,
                             monitor: this.sharedMonitor,
-                            visualsRegister: this.visualsRegister
+                            visualsRegister: this.visualsRegister,
+                            simulation: this.simulation
                         });
                         break;
                     // Any "none" type can be ignored. These are just containers for other items.
@@ -30787,6 +32365,63 @@ var MenuItemManager;
                 }
             }
         }
+        /**
+         * Draws Entities from data given here as well as, or instead of, the API's, until ClearSimulation is called.
+         * @param params.set the simulation this belongs to, so it can be cleared apart from others. Default "default".
+         * @param params.entities stand-ins that replace each Entity's record; API data for them is ignored.
+         * @param params.patches partial Entities laid over each Entity; live API data shows where a patch is silent.
+         * @param params.records historic records naming entityId, dateTime and only the data they change.
+         * @param params.menuItemIds the items to redraw. By default every item already drawing one of the Entities.
+         */
+        async Simulate(params) {
+            const { set, entities, patches, records, menuItemIds } = params;
+            this.simulation.SetEntities(entities, set);
+            this.simulation.SetPatches(patches, set);
+            this.simulation.SetRecords(records, set);
+            const entityIds = [
+                ...(entities || []).map(x => { var _a; return (_a = x === null || x === void 0 ? void 0 : x.Bruce) === null || _a === void 0 ? void 0 : _a.ID; }),
+                ...(patches || []).map(x => { var _a; return (_a = x === null || x === void 0 ? void 0 : x.Bruce) === null || _a === void 0 ? void 0 : _a.ID; }),
+                ...(records || []).map(x => x === null || x === void 0 ? void 0 : x.entityId)
+            ];
+            await this.reRenderSimulated(entityIds, menuItemIds);
+        }
+        /**
+         * Stops simulating these Entities, or every Entity when none are named, and redraws them.
+         * @param params.set the simulation to clear. By default every one.
+         * @param params.entities clear the stand-ins and patches. Default true.
+         * @param params.records clear the historic records. Default true.
+         */
+        async ClearSimulation(params) {
+            var _a;
+            const entityIds = (_a = params === null || params === void 0 ? void 0 : params.entityIds) !== null && _a !== void 0 ? _a : [
+                ...this.simulation.GetEntityIds(),
+                ...this.simulation.GetRecordEntityIds()
+            ];
+            this.simulation.Clear({ set: params === null || params === void 0 ? void 0 : params.set, entityIds, entities: params === null || params === void 0 ? void 0 : params.entities, records: params === null || params === void 0 ? void 0 : params.records });
+            await this.reRenderSimulated(entityIds, params === null || params === void 0 ? void 0 : params.menuItemIds);
+        }
+        /*
+         * Redraws simulated Entities only in the items holding a visual for them, unless the caller names the items.
+         */
+        async reRenderSimulated(entityIds, menuItemIds) {
+            const ids = Array.from(new Set(entityIds.filter(x => !!x)));
+            if (!ids.length) {
+                return;
+            }
+            const items = (menuItemIds === null || menuItemIds === void 0 ? void 0 : menuItemIds.length) ? this.items.filter(x => menuItemIds.includes(x.id)) : this.items;
+            for (const item of items) {
+                // Some managers follow the store themselves, and redrawing them here would only repeat that.
+                if (!item.renderManager || item.renderManager.FollowsSimulation) {
+                    continue;
+                }
+                const drawn = (menuItemIds === null || menuItemIds === void 0 ? void 0 : menuItemIds.length)
+                    ? ids
+                    : ids.filter(id => this.visualsRegister.GetRego({ entityId: id, menuItemId: item.id }));
+                if (drawn.length) {
+                    await item.renderManager.ReRender({ entityIds: drawn, force: true });
+                }
+            }
+        }
     }
     MenuItemManager.Manager = Manager;
 })(MenuItemManager || (MenuItemManager = {}));
@@ -39346,6 +40981,7 @@ function groupAttributes(paths, attributes) {
 }
 class WidgetInfoView extends Widget.AWidget {
     constructor(params) {
+        var _a;
         super(params);
         this.STYLESHEET_ID = "nextspace-info-view-stylesheet";
         this._generateStyles();
@@ -39355,10 +40991,19 @@ class WidgetInfoView extends Widget.AWidget {
                 this._updateInfoView();
             }
         });
+        // The selected Entity is read once per selection, so a change to its simulation reads it again.
+        this._simulationRemoval = (_a = this._manager.Simulation) === null || _a === void 0 ? void 0 : _a.OnChanged.Subscribe((change) => {
+            if (this._lastSelectedId && change.entityIds.includes(this._lastSelectedId)) {
+                this._lastSelectedId = null;
+                this._updateInfoView();
+            }
+        });
     }
     Dispose() {
+        var _a;
         super.Dispose();
         this._updateRemoval();
+        (_a = this._simulationRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
     }
     _generateStyles() {
         if (document.getElementById(this.STYLESHEET_ID)) {
@@ -39820,7 +41465,7 @@ class WidgetInfoView extends Widget.AWidget {
         }
     }
     async _updateInfoView() {
-        var _b, _c, _d, _e;
+        var _a, _c, _d, _e, _f;
         const selectedIds = this._manager.VisualsRegister.GetSelected();
         if (selectedIds.length <= 0) {
             this._element.style.display = "none";
@@ -39842,17 +41487,20 @@ class WidgetInfoView extends Widget.AWidget {
             this._summary.innerHTML = "";
             this._imageContainer.style.display = "none";
             const api = this._apiGetters.GetBruceApi();
-            const { entity } = await Entity$1.Get({
+            // A simulated Entity is shown as simulated: a stand-in as is, a patch over what the API has.
+            const simulation = this._manager.Simulation;
+            let entity = (_a = simulation === null || simulation === void 0 ? void 0 : simulation.GetEntity(firstId)) !== null && _a !== void 0 ? _a : (await Entity$1.Get({
                 entityId: firstId,
                 api: api,
                 migrated: true,
                 expandLocation: DISPLAY_ASSEMBLY_INFO
-            });
+            })).entity;
+            entity = entity && simulation ? simulation.Resolve(firstId, entity) : entity;
             if (!entity) {
                 throw (new Error("Could not get entity."));
             }
             const { entityType } = await EntityType.Get({
-                entityTypeId: (_b = entity.Bruce) === null || _b === void 0 ? void 0 : _b["EntityType.ID"],
+                entityTypeId: (_c = entity.Bruce) === null || _c === void 0 ? void 0 : _c["EntityType.ID"],
                 api: api
             });
             let name = Entity$1.CalculateName({
@@ -39875,7 +41523,7 @@ class WidgetInfoView extends Widget.AWidget {
             const defaultImage = images.length ? images[0] : null;
             if (defaultImage) {
                 this._imageContainer.style.display = "flex";
-                const url = (_c = defaultImage.URL) !== null && _c !== void 0 ? _c : ClientFile.GetUrl({
+                const url = (_d = defaultImage.URL) !== null && _d !== void 0 ? _d : ClientFile.GetUrl({
                     fileId: defaultImage["ClientFile.ID"],
                     api: api,
                     viaCdn: true
@@ -39888,7 +41536,7 @@ class WidgetInfoView extends Widget.AWidget {
             this._summary.appendChild(detailsTitle);
             // TODO: Selection for what mode instead of always doing "all".
             const attributes = gatherAttributes(EMode.ShowAll, entity, entityType);
-            const groups = groupAttributes(attributes, (_e = (_d = entityType.DataSchema) === null || _d === void 0 ? void 0 : _d.Structure) !== null && _e !== void 0 ? _e : []);
+            const groups = groupAttributes(attributes, (_f = (_e = entityType.DataSchema) === null || _e === void 0 ? void 0 : _e.Structure) !== null && _f !== void 0 ? _f : []);
             for (const group of groups) {
                 this._generateAttrGroup(entityType, entity, group);
             }
@@ -42485,7 +44133,7 @@ var EntityUtils;
      * @param params
      */
     async function GetLocation(params) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         let { api, viewer, samples, visualRegister, minimumAlt, paddingAlt } = params;
         if (!paddingAlt) {
             paddingAlt = 0;
@@ -43033,6 +44681,13 @@ var EntityUtils;
                 recordSamples.push(sample);
             }
         }
+        // A simulated Entity is where its blob says, never where the API has it.
+        const simulation = EntitySimulation.Get(viewer);
+        for (const sample of recordSamples) {
+            if (!sample.entity && sample.entityId) {
+                sample.entity = (_e = simulation === null || simulation === void 0 ? void 0 : simulation.GetEntity(sample.entityId)) !== null && _e !== void 0 ? _e : sample.entity;
+            }
+        }
         // Bulk requesting Entity records.
         try {
             const toSearchIds = recordSamples.filter(x => !x.entity && x.entityId).map(x => x.entityId);
@@ -43053,7 +44708,8 @@ var EntityUtils;
                 for (let i = 0; i < recordSamples.length; i++) {
                     const sample = recordSamples[i];
                     if (!sample.entity && sample.entityId) {
-                        sample.entity = entitiesMap.get(sample.entityId);
+                        const read = entitiesMap.get(sample.entityId);
+                        sample.entity = read && simulation ? simulation.Overlay(read) : read;
                     }
                 }
             }
@@ -43067,6 +44723,11 @@ var EntityUtils;
         // We have to detect whatever is an Assembly Entity and expand it.
         try {
             const needsExpansion = recordSamples.filter(x => {
+                var _a;
+                // Expanding reads the API's record, which would replace the stand-in or undo the patch.
+                if (simulation === null || simulation === void 0 ? void 0 : simulation.HasBlob((_a = x.entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID)) {
+                    return false;
+                }
                 const assemblyPos = Entity$1.GetValue({
                     entity: x.entity,
                     path: ["Bruce", "AssemblyPosition"]
@@ -43425,6 +45086,21 @@ var EntityUtils;
         return Quaternion.multiply(combined, _assemblyAxisShift, new Quaternion());
     }
     EntityUtils.GetAssemblyOrientation = GetAssemblyOrientation;
+    /**
+     * Returns the orientation a part's model is drawn with, for its world matrix within the root's frame.
+     * @param rootFrame the root's frame in the world, eg. from Transforms.headingPitchRollToFixedFrame.
+     * @param world the part's matrix within the root's frame.
+     */
+    function GetAssemblyOrientationInFrame(rootFrame, world) {
+        if (!rootFrame || !world) {
+            return null;
+        }
+        const combined = Matrix4.multiply(rootFrame, world, new Matrix4());
+        const rotation = Matrix4.getRotation(combined, new Matrix3());
+        const q = Quaternion.fromRotationMatrix(rotation);
+        return Quaternion.multiply(q, _assemblyAxisShift, new Quaternion());
+    }
+    EntityUtils.GetAssemblyOrientationInFrame = GetAssemblyOrientationInFrame;
     /**
      * Returns the position of the entity.
      * This is an async variant that checks for related assemblies.
@@ -43434,6 +45110,18 @@ var EntityUtils;
      */
     async function GetPosAsync(params) {
         let { viewer, entityId, entity, visualRegister, returnHeightRef, recordHeightRef, api } = params;
+        // A simulated Entity is where its stand-in says, or where its patch puts the API's record.
+        const simulation = EntitySimulation.Get(viewer);
+        entity = entity !== null && entity !== void 0 ? entity : simulation === null || simulation === void 0 ? void 0 : simulation.GetEntity(entityId);
+        if (!entity && entityId && (simulation === null || simulation === void 0 ? void 0 : simulation.HasBlob(entityId))) {
+            try {
+                const read = (await Entity$1.Get({ api, entityId, expandLocation: false, migrated: true })).entity;
+                entity = read ? simulation.Overlay(read) : null;
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
         // We have issues where imported BRZ files have improper expandLocation=true info.
         // As a result we'll double-request the data.
         // If there is a location then we won't bother using expanded information.
@@ -53434,7 +55122,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.6.1";
+const VERSION = "7.6.2";
 /**
  * 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.
@@ -53451,5 +55139,5 @@ const getENVIRONMENT = () => {
     return ENVIRONMENT;
 };
 
-export { VERSION, setENVIRONMENT, getENVIRONMENT, ClusterItems, PointClustering, PointClusterSize, CesiumAnimatedInOut, DisplacedSurfacePrimitive, CesiumAnimatedProperty, isStyleChanged, isOutlineChanged$1 as isOutlineChanged, StyleEffective, EntityRenderEngine, EntityRenderEngineModel3d, EntityRenderEnginePoint, extractMetadataFromFileUrl, EntityRenderEnginePolygon, EntityRenderEnginePolyline, TextureFrameSeriesAnimator, TextureValueLabels, MenuItemCreator, MenuItemManager, CesiumParabola, EntityLabel, EntityLabelGroup, LiveCursor, SharedGetters, DataSourceStaticKmlManager, DataLabRenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, AssemblyRenderManager, GoogleSearchRenderManager, RelationsRenderManager, RenderManager, TilesetArbRenderManager, TilesetCadRenderManager, TilesetEntitiesRenderManager, TilesetGooglePhotosRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TileRenderEngine, createTileset, TilesetRenderEngine, ViewRenderEngine, VisualRegisterCuller, VisualsRegister, XGridsRenderEngine, CesiumEntityStyler, DrawingUtils, EntityUtils, MeasureUtils, StyleUtils, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_KEY, CESIUM_TIMELINE_INTERVAL_KEY, CESIUM_MODEL_SPACE_KEY, DEFAULT_LIVE_PADDING_SECONDS, DEFAULT_BRIGHTNESS_SHIFT, DEFAULT_LIGHT_INTENSITY, LIGHTING_SETTINGS_VERSION, LIGHT_INTENSITY_COMPENSATION, MAX_COMPENSATED_LIGHT_INTENSITY, ViewUtils, CesiumViewMonitor, ViewGroundArea, ViewerEventTracker, ViewerUtils, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, WidgetControlViewBar, WidgetControlViewBarSearch, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks, WidgetLeftPanelTabDashboard, EMenuItemState, WidgetLeftPanelTabMenuItems, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, ECursor, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, CreateTabIconSvg, WidgetLeftPanel, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar };
+export { VERSION, setENVIRONMENT, getENVIRONMENT, ClusterItems, PointClustering, PointClusterSize, CesiumAnimatedInOut, DisplacedSurfacePrimitive, CesiumAnimatedProperty, isStyleChanged, isOutlineChanged$1 as isOutlineChanged, StyleEffective, EntityRenderEngine, EntityRenderEngineModel3d, EntityRenderEnginePoint, extractMetadataFromFileUrl, EntityRenderEnginePolygon, EntityRenderEnginePolyline, TextureFrameSeriesAnimator, TextureValueLabels, MenuItemCreator, MenuItemManager, CesiumParabola, EntityLabel, EntityLabelGroup, LiveCursor, SharedGetters, EntitySimulation, DataSourceStaticKmlManager, DataLabRenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, AssemblyRenderManager, GoogleSearchRenderManager, RelationsRenderManager, RenderManager, TilesetArbRenderManager, TilesetCadRenderManager, TilesetEntitiesRenderManager, TilesetGooglePhotosRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TileRenderEngine, createTileset, TilesetRenderEngine, ViewRenderEngine, VisualRegisterCuller, VisualsRegister, XGridsRenderEngine, CesiumEntityStyler, DrawingUtils, EntityUtils, MeasureUtils, StyleUtils, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_KEY, CESIUM_TIMELINE_INTERVAL_KEY, CESIUM_MODEL_SPACE_KEY, DEFAULT_LIVE_PADDING_SECONDS, DEFAULT_BRIGHTNESS_SHIFT, DEFAULT_LIGHT_INTENSITY, LIGHTING_SETTINGS_VERSION, LIGHT_INTENSITY_COMPENSATION, MAX_COMPENSATED_LIGHT_INTENSITY, ViewUtils, CesiumViewMonitor, ViewGroundArea, ViewerEventTracker, ViewerUtils, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, WidgetControlViewBar, WidgetControlViewBarSearch, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks, WidgetLeftPanelTabDashboard, EMenuItemState, WidgetLeftPanelTabMenuItems, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, ECursor, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, CreateTabIconSvg, WidgetLeftPanel, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar };
 //# sourceMappingURL=bruce-cesium.es5.js.map