bruce-cesium 7.6.1 → 7.6.2

package/dist/bruce-cesium.umd.js

@@ -2621,13 +2621,13 @@
         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;
@@ -2657,6 +2657,7 @@
                 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();
@@ -2680,6 +2681,17 @@
                     }
                 }
             }
+            /**
+             * 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.
              */
@@ -2727,106 +2739,47 @@
             /*
              * 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 + (Cesium.Math.negativePiToPi(Cesium.Math.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 = Cesium.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 ||
-                    !Cesium.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 (Cesium.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 = Cesium.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 = Cesium.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 Cesium.Cartesian3.lerp(lastPos, targetPos, progress, new Cesium.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.
@@ -2852,14 +2805,14 @@
              * 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 Cesium.Cartesian3(),
                         indexLast: -1,
-                        indexNext: -1,
-                        applyOverTime: false
+                        indexNext: -1
                     };
                 }
                 // See if we're before the first position.
@@ -2867,8 +2820,7 @@
                     return {
                         pos3d: posses[0].pos3d,
                         indexLast: 0,
-                        indexNext: 0,
-                        applyOverTime: true
+                        indexNext: 0
                     };
                 }
                 // See if we're after the last position.
@@ -2877,8 +2829,7 @@
                     return {
                         pos3d: posses[lastIndex].pos3d,
                         indexLast: lastIndex,
-                        indexNext: lastIndex,
-                        applyOverTime: true
+                        indexNext: lastIndex
                     };
                 }
                 // Binary search to find the closest position.
@@ -2904,20 +2855,25 @@
                     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 = Cesium.Cartesian3.lerp(last.pos3d, next.pos3d, progress, new Cesium.Cartesian3());
+                // A straight line between two points on a curved path cuts inside it, so it is lifted back out.
+                const chord = Cesium.Cartesian3.lerp(last.pos3d, next.pos3d, progress, new Cesium.Cartesian3());
+                const chordCarto = Cesium.Cartographic.fromCartesian(chord);
+                const lastHeight = (_a = Cesium.Cartographic.fromCartesian(last.pos3d)) === null || _a === void 0 ? void 0 : _a.height;
+                const nextHeight = (_b = Cesium.Cartographic.fromCartesian(next.pos3d)) === null || _b === void 0 ? void 0 : _b.height;
+                const interpolatedPos = chordCarto && lastHeight != null && nextHeight != null
+                    ? Cesium.Cartesian3.fromRadians(chordCarto.longitude, chordCarto.latitude, Cesium.Math.lerp(lastHeight, nextHeight, progress))
+                    : chord;
                 return {
                     pos3d: interpolatedPos,
                     indexLast: lastIndex,
-                    indexNext: nextIndex,
-                    applyOverTime: false
+                    indexNext: nextIndex
                 };
             }
             /**
@@ -5481,6 +5437,481 @@
         return result;
     }
 
+    (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 BModels.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: BModels.Entity.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;
+    })(exports.EntitySimulation || (exports.EntitySimulation = {}));
+
     /**
      * Returns cesium property's value.
      * This will check if it's one that changes over time, or just a fixed value.
@@ -5532,6 +5963,8 @@
         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.
@@ -6748,6 +7181,7 @@
             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.
@@ -6765,7 +7199,7 @@
             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;
                 }
@@ -6773,17 +7207,41 @@
                     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 => Cesium.Matrix4.multiplyByPoint(motion, corner, new Cesium.Cartesian3()));
+                    if (moved.every((corner, i) => Cesium.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.
              */
@@ -6851,6 +7309,7 @@
              */
             Resolve(viewer, pointer) {
                 var _a, _b, _c, _d;
+                this.follow();
                 this.frames.clear();
                 this.hulls.clear();
                 this.drawn = [];
@@ -7273,9 +7732,16 @@
                     }
                     if (this.api) {
                         const rego = this.rego;
+                        const simulation = exports.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 BModels.Entity.Get({ api: this.api, entityId: rego.entityId, migrated: true })).entity;
+                            simulated = simulation.Resolve(rego.entityId, read);
+                        }
                         this.rego.name = await BModels.Entity.CalculateNameAsync({
                             api: this.api,
-                            entity: null,
+                            entity: simulated,
                             entityId: rego.entityId,
                             defaultToId: false
                         });
@@ -7304,6 +7770,21 @@
                 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.
              */
@@ -7534,7 +8015,7 @@
                         }
                         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;
                             }
@@ -7561,16 +8042,19 @@
                                     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 = exports.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 BModels.Entity.Get({
+                                            entity = entity !== null && entity !== void 0 ? entity : (await BModels.Entity.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.
@@ -7954,11 +8438,17 @@
                     // 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 = Cesium.Cartesian3.midpoint(corners[0], corners[7], new Cesium.Cartesian3());
+                        if (motion) {
+                            Cesium.Matrix4.multiplyByPoint(motion, centre, centre);
+                        }
                         if (Cesium.Cartesian3.distance(centre, found) > Cesium.Cartesian3.distance(corners[0], corners[7]) * 0.75 + 2) {
                             return;
                         }
@@ -7966,6 +8456,7 @@
                         // 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: () => {
@@ -8946,9 +9437,9 @@
          * 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();
@@ -8959,12 +9450,15 @@
                 }
                 const chunk = missing.slice(start, start + HYDRATE_AT_ONCE);
                 try {
-                    const { entities } = await BModels.Entity.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 BModels.Entity.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 : [] } } };
@@ -8981,7 +9475,7 @@
         /*
          * 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") {
@@ -8996,7 +9490,7 @@
                 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
                     };
                 };
@@ -9138,7 +9632,7 @@
                 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), exports.EntitySimulation.Get(this.register.Viewer));
                     let offset = 0;
                     for (let pageNumber = 0;; pageNumber++) {
                         if (controller.signal.aborted || this.register.Disposed) {
@@ -9960,8 +10454,25 @@
             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 = [];
@@ -9979,13 +10490,15 @@
             }
             // Turn the set unique.
             neededEntityIdsIds = neededEntityIdsIds.filter((v, i, a) => a.indexOf(v) === i);
-            // Get all entities in one go.
-            let entities = (await BModels.Entity.GetListByIds({
-                entityIds: neededEntityIdsIds,
+            // 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 BModels.Entity.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++) {
@@ -10479,6 +10992,8 @@
             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.
             exports.VisualsRegister.IsForeignCollection(rego) ||
@@ -11313,6 +11828,7 @@
             }
             get OnLabelGroupsChanged() { return this.labelGroupsChanged; }
             constructor(params) {
+                var _a, _b;
                 this.id = BModels.ObjectUtils.UId();
                 this.disposed = false;
                 this.rego = {};
@@ -11352,6 +11868,8 @@
                 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 BModels.BruceEvent();
                 this.hoverRingState = {};
                 this.retiringHoverLabels = new Map();
@@ -11386,6 +11904,33 @@
                 this.cameraCullerDispose = exports.VisualRegisterCuller.Monitor({
                     register: this
                 });
+                this.simulationRemoval = (_b = (_a = exports.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 = exports.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.
@@ -12288,7 +12833,9 @@
                 (_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;
                 exports.CesiumEntityStyler.SetDimming(this.viewer, this.id, false);
                 this.ClearLabelHover();
                 clearTimeout(this.hoverRingReset);
@@ -12298,14 +12845,14 @@
                     exports.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)
                         exports.EntityLabel.Detatch({ rego, force: true });
                 }
                 exports.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;
@@ -12321,7 +12868,7 @@
                 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);
@@ -12330,7 +12877,7 @@
                 this.menuItemSources.clear();
                 // Hand every tileset's show flag back to its owner, holding whatever the owner last asked for.
                 for (const rego of Array.from(this.tilesets.values())) {
-                    (_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();
             }
@@ -12504,21 +13051,7 @@
                             changed = true;
                         }
                         if (editing) {
-                            const parts = exports.EntityUtils.GatherEntity({
-                                entity: rego.visual
-                            });
-                            for (let k = 0; k < parts.length; k++) {
-                                const part = parts[k];
-                                if (!(part instanceof Cesium.Entity)) {
-                                    continue;
-                                }
-                                const removalPending = exports.VisualRegisterCuller.CancelQueuedSceneChange(part);
-                                const wasCulled = part[exports.VisualRegisterCuller.VISUAL_CULL_KEY] == true || removalPending;
-                                delete part[exports.VisualRegisterCuller.VISUAL_CULL_KEY];
-                                if (wasCulled && !IsCEntityInScene(this.viewer, part)) {
-                                    AddCEntityToScene(this.viewer, part, rego.collection);
-                                }
-                            }
+                            this.restoreCulled(rego);
                         }
                         else {
                             exports.VisualRegisterCuller.InvalidateBounds(rego.visual);
@@ -12530,6 +13063,56 @@
                     (_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 {
+                            exports.VisualRegisterCuller.InvalidateBounds(rego.visual);
+                            exports.VisualRegisterCuller.MarkShouldRecheck(this.viewer);
+                        }
+                    }
+                }
+            }
+            /*
+             * Puts back whatever the culler took out of a visual that is now exempt from it.
+             */
+            restoreCulled(rego) {
+                const parts = exports.EntityUtils.GatherEntity({
+                    entity: rego.visual
+                });
+                for (let k = 0; k < parts.length; k++) {
+                    const part = parts[k];
+                    if (!(part instanceof Cesium.Entity)) {
+                        continue;
+                    }
+                    const removalPending = exports.VisualRegisterCuller.CancelQueuedSceneChange(part);
+                    const wasCulled = part[exports.VisualRegisterCuller.VISUAL_CULL_KEY] == true || removalPending;
+                    delete part[exports.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;
@@ -14022,12 +14605,41 @@
      * 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++) {
@@ -14049,15 +14661,21 @@
             }
         }
         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;
@@ -14114,7 +14732,7 @@
         }
         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) {
@@ -14123,8 +14741,12 @@
                 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);
         }
     }
 
@@ -15560,7 +16182,7 @@
             this.cache = new HistoricRangeCache();
         }
         get Records() {
-            return this.cache.GetRecords();
+            return this.withSimulated(this.cache.GetRecords());
         }
         Clear() {
             this.cache.Clear();
@@ -15584,8 +16206,9 @@
          */
         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();
@@ -15605,7 +16228,7 @@
             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;
@@ -15640,7 +16263,17 @@
                     }
                 }
             }
-            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.
@@ -15675,7 +16308,7 @@
             }).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(() => {
@@ -15747,7 +16380,6 @@
                 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;
@@ -15767,6 +16399,14 @@
                  */
                 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: Cesium.JulianDate.toDate(this.viewer.clock.currentTime).getTime(), attrKey: bruceEntity.historicAttrKey };
+                });
                 this.viewer = viewer;
                 this.sharedGetters = sharedGetters;
                 this.monitor = monitor;
@@ -15780,7 +16420,8 @@
                     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) {
@@ -15961,8 +16602,9 @@
                         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 = [];
@@ -15970,10 +16612,10 @@
                             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.
@@ -16013,6 +16655,10 @@
                         // 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,
@@ -17136,7 +17782,6 @@
                 // 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.
@@ -17146,6 +17791,7 @@
                  */
                 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;
@@ -17268,7 +17914,8 @@
                             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();
             }
@@ -17910,8 +18557,15 @@
                 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: Cesium.JulianDate.toDate(this.viewer.clock.currentTime).getTime(), attrKey: bruceEntity.historicAttrKey };
+                });
                 this.sharedHistoric = params.sharedHistoric;
                 this.viewer = viewer;
                 this.apiGetter = apiGetter;
@@ -17924,7 +18578,8 @@
                     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);
@@ -18382,9 +19037,9 @@
                 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;
@@ -18658,6 +19313,122 @@
         ];
     })(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: BModels.ObjectUtils.UId(15),
+                    polyline: {
+                        positions: new Cesium.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 ? Cesium.ArcType.GEODESIC : Cesium.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 ? Cesium.ClassificationType.BOTH : undefined
+                    }
+                });
+                entity._noEdit = true;
+                entity._noSelect = true;
+                exports.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 && Cesium.JulianDate.equals(this.memoTime, time)) {
+                    return this.memo;
+                }
+                this.memoTime = Cesium.JulianDate.clone(time, (_a = this.memoTime) !== null && _a !== void 0 ? _a : new Cesium.JulianDate());
+                const nowMs = Cesium.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) {
@@ -18665,7 +19436,11 @@
             }
             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;
@@ -19242,15 +20017,19 @@
                                 }
                             }
                         }
+                        // 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));
@@ -19614,7 +20393,7 @@
                         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);
@@ -21138,6 +21917,9 @@
                 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;
@@ -21175,7 +21957,7 @@
                 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 = [];
@@ -21189,6 +21971,7 @@
                 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;
@@ -21353,7 +22136,7 @@
                                 historicPoint: this.viewer.clock.currentTime.toString(),
                                 api: api
                             });
-                            coords = coordsFromHistoricEntity(root);
+                            coords = coordsFromHistoricEntity(this.atClock(root));
                         }
                         catch (e) {
                             console.error(e);
@@ -21394,6 +22177,10 @@
                         this.doDispose();
                         return;
                     }
+                    this.restCoords = coords;
+                    if (this.simulatedRootCoords()) {
+                        this.applyCoords(tileset, this.simulatedRootCoords());
+                    }
                     this.viewer.scene.requestRender();
                     exports.TilesetRenderEngine.OnTilesetReady(this.cTileset).then(() => {
                         var _a, _b, _c;
@@ -21413,6 +22200,7 @@
                             }
                             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.
@@ -21428,6 +22216,7 @@
                             });
                             this.viewer.scene.requestRender();
                             // Monitor scene time changes and update the root Entity.
+                            this.followSimulation(tileset);
                             this.viewerDateTimeSub(tileset);
                         }
                         catch (e) {
@@ -21483,7 +22272,7 @@
              */
             applyRootTrack() {
                 var _a;
-                if (!this.item.historicDrawTrack || !this.historicAnimation || this.trackEntity) {
+                if (!this.item.historicDrawTrack || !this.historicAnimation || this.trail) {
                     return;
                 }
                 const trackStyle = exports.EntityRenderEngine.GetTrackStyle({
@@ -21493,26 +22282,14 @@
                 if (!trackStyle) {
                     return;
                 }
-                this.trackEntity = this.viewer.entities.add({
-                    id: BModels.ObjectUtils.UId(15),
-                    polyline: {
-                        positions: new Cesium.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: exports.EntityRenderEngine.GetHeightRefPolyline(Manager.GetRecordHeightRef(this.item))
-                            == Cesium.HeightReference.CLAMP_TO_GROUND,
-                        zIndex: 0,
-                        classificationType: Cesium.ClassificationType.BOTH
-                    }
-                });
-                this.trackEntity._noEdit = true;
-                this.trackEntity._noSelect = true;
-                exports.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: exports.EntityRenderEngine.GetHeightRefPolyline(Manager.GetRecordHeightRef(this.item))
+                        == Cesium.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 : []; }
                 });
             }
             /**
@@ -21565,7 +22342,7 @@
             }
             // 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;
                 }
@@ -21583,9 +22360,11 @@
                 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 = {
@@ -21606,7 +22385,7 @@
             // 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;
@@ -21637,6 +22416,7 @@
                 // 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,
@@ -21670,7 +22450,9 @@
                     }
                 });
                 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);
                 }
             }
@@ -22258,7 +23040,7 @@
                 this.doDispose();
             }
             doDispose() {
-                var _a, _b, _c;
+                var _a, _b, _c, _d;
                 if (this.featureQueueInterval) {
                     clearInterval(this.featureQueueInterval);
                     this.featureQueueInterval = null;
@@ -22293,6 +23075,8 @@
                     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;
@@ -22318,8 +23102,11 @@
              * @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();
@@ -22348,6 +23135,8 @@
                     // 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];
@@ -22375,6 +23164,7 @@
                  */
                 const getInitialPosses = async () => {
                     this.historicPossesLoadingProm = new Promise(async (res) => {
+                        var _a;
                         try {
                             if (this.disposed) {
                                 res(false);
@@ -22387,11 +23177,16 @@
                                 return;
                             }
                             // Also request the current position in case its not in the range.
-                            const { entity } = await BModels.Entity.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 BModels.Entity.Get({
                                 entityId: this.rootId,
                                 historicPoint: this.viewer.clock.currentTime.toString(),
                                 api: api
-                            });
+                            })).entity);
                             if (this.disposed || !entity) {
                                 res(false);
                                 return;
@@ -22471,14 +23266,15 @@
                         }
                     });
                     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;
@@ -22486,10 +23282,84 @@
                     };
                 });
             }
-            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, Cesium.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 = Cesium.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.
@@ -23630,11 +24500,11 @@
                 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;
@@ -23731,7 +24601,8 @@
                     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() {
@@ -25478,6 +26349,7 @@
                 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;
@@ -25578,6 +26450,7 @@
                                 if (Manager.NeedsStyler(this.item)) {
                                     const api = this.getters.GetBruceApi();
                                     this.styler.Init({
+                                        simulation: this.simulation,
                                         viewer: this.viewer,
                                         api: api,
                                         cTileset: this.cTileset,
@@ -25935,6 +26808,7 @@
                 const needsStyler = Manager.NeedsStyler(this.item);
                 if (needsStyler) {
                     this.styler.Init({
+                        simulation: this.simulation,
                         viewer: this.viewer,
                         api: this.getters.GetBruceApi(),
                         cTileset: this.cTileset,
@@ -26619,6 +27493,7 @@
                 // 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.
@@ -26853,6 +27728,7 @@
                                     this.item.Type == BModels.MenuItem.EType.IonTileset) {
                                     const api = this.getters.GetBruceApi();
                                     this.styler.Init({
+                                        simulation: this.simulation,
                                         viewer: this.viewer,
                                         api: api,
                                         cTileset: this.cTileset,
@@ -27193,14 +28069,32 @@
             }
             ;
             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.
@@ -27269,10 +28163,13 @@
                 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
                 });
@@ -27511,7 +28408,8 @@
                         menuItemId: this.item.id,
                         relations: relations,
                         viewer: this.viewer,
-                        visualRegister: this.register
+                        visualRegister: this.register,
+                        simulation: this.simulation
                     });
                     if (this.disposed) {
                         this.register.RemoveRegos({
@@ -27793,9 +28691,12 @@
             }
             ;
             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 = [];
@@ -27804,6 +28705,21 @@
                 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.
@@ -27846,10 +28762,13 @@
                 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
                 });
@@ -28010,7 +28929,8 @@
                         menuItemId: this.item.id,
                         relations: relations,
                         viewer: this.viewer,
-                        visualRegister: this.register
+                        visualRegister: this.register,
+                        simulation: this.simulation
                     });
                     if (this.disposed) {
                         this.register.RemoveRegos({
@@ -29235,6 +30155,55 @@
             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 : Cesium.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 : Cesium.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 : Cesium.JulianDate.toDate(this.viewer.clock.currentTime).getTime();
+                const rootFrame = this.GetRootFrame(at);
+                const world = entityId === this.rootId ? Cesium.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 ? Cesium.Matrix4.multiply(Cesium.Matrix4.fromTranslation(ground), world, new Cesium.Matrix4()) : world;
+                return Cesium.Matrix4.multiply(rootFrame, placed, new Cesium.Matrix4());
+            }
             constructor(params) {
                 this.disposed = false;
                 // Cache of the hierarchy so that our scene-tree can reference it.
@@ -29244,19 +30213,41 @@
                 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;
@@ -29280,10 +30271,10 @@
                 return exports.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 Cesium.HeadingPitchRoll(Cesium.Math.toRadians(headingDegrees || 0), 0, 0);
+            static rootFrame(rootPos3d, headingDegrees, pitchDegrees = 0, rollDegrees = 0) {
+                const hpr = new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(headingDegrees || 0), Cesium.Math.toRadians(pitchDegrees || 0), Cesium.Math.toRadians(rollDegrees || 0));
                 return Cesium.Transforms.headingPitchRollToFixedFrame(rootPos3d, hpr);
             }
             /**
@@ -29306,28 +30297,553 @@
                 return Cesium.Matrix4.multiplyByPoint(Manager.rootFrame(rootPos3d, headingDegrees), offset, new Cesium.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 = exports.EntityUtils.GetPos({
+                        viewer: this.viewer,
+                        entity,
+                        recordHeightRef: Manager.GetRecordHeightRef(this.item),
+                        returnHeightRef: Cesium.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 Cesium.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 Cesium.CallbackProperty((time, result) => {
+                            var _a;
+                            const orient = (_a = this.placementAt(id, time)) === null || _a === void 0 ? void 0 : _a.orient;
+                            return orient ? Cesium.Quaternion.clone(orient, result) : undefined;
+                        }, false);
+                        child.cEntity.model.scale = new Cesium.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 Cesium.ConstantPositionProperty(placed.pos3d);
+                        if (placed.orient) {
+                            child.cEntity.orientation = new Cesium.ConstantProperty(placed.orient);
+                        }
+                        child.cEntity.model.scale = new Cesium.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 Cesium.Cartesian3.maximumComponent(Cesium.Matrix4.getScale(world, new Cesium.Cartesian3()));
+            }
+            static cloneOrUndefined(pos3d, result) {
+                return pos3d ? Cesium.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 = Cesium.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
+                        ? Cesium.Matrix4.getTranslation(world, new Cesium.Cartesian3())
+                        : new Cesium.Cartesian3(0, 0, 0);
+                    const ground = this.groundOffsets.get(entityId);
+                    if (ground) {
+                        Cesium.Cartesian3.add(offset, ground, offset);
+                    }
+                    placed = {
+                        pos3d: Cesium.Matrix4.multiplyByPoint(pose.rootFrame, offset, new Cesium.Cartesian3()),
+                        // Without a matrix, eg. the root itself, there is no orientation of its own to apply.
+                        orient: world ? exports.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 + (Cesium.Math.negativePiToPi(Cesium.Math.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 = Cesium.Cartesian3.lerp(a.pos3d, b.pos3d, t, new Cesium.Cartesian3());
+                const carto = Cesium.Cartographic.fromCartesian(chord);
+                return carto
+                    ? Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, Cesium.Math.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 = Cesium.Cartographic.fromCartesian(pos.pos3d);
+                    if (!carto) {
                         continue;
                     }
-                    child.cEntity.position = new Cesium.ConstantPositionProperty(pos3d);
-                    const orient = exports.EntityUtils.GetAssemblyOrientation(child.entity, pos3d);
-                    if (orient) {
-                        child.cEntity.orientation = new Cesium.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) => !Cesium.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 ? Cesium.Matrix4.multiply(parent, local, new Cesium.Matrix4()) : Cesium.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) === Cesium.HeightReference.NONE) {
+                    return;
+                }
+                const rootFrame = Manager.rootFrame(this.rootPos3d, this.rootHeading, this.rootPitch, this.rootRoll);
+                const toRoot = Cesium.Matrix4.inverse(rootFrame, new Cesium.Matrix4());
+                const groundUp = (record) => {
+                    const pos3d = exports.EntityUtils.GetPos({
+                        viewer: this.viewer,
+                        entity: record,
+                        recordHeightRef: Cesium.HeightReference.CLAMP_TO_GROUND,
+                        returnHeightRef: Cesium.HeightReference.NONE,
+                        allowRendered: false
+                    });
+                    return pos3d ? Cesium.Matrix4.multiplyByPoint(toRoot, pos3d, new Cesium.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 Cesium.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 = Cesium.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 = Cesium.Matrix4.multiply(Manager.rootFrame(root.pos3d, root.heading, root.pitch, root.roll), drawn, new Cesium.Matrix4());
+                const storedFixed = Cesium.Matrix4.multiply(Manager.rootFrame(this.rootPos3d, this.rootHeading, this.rootPitch, this.rootRoll), stored, new Cesium.Matrix4());
+                return Cesium.Matrix4.multiply(drawnFixed, Cesium.Matrix4.inverse(storedFixed, new Cesium.Matrix4()), new Cesium.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 Cesium.Matrix4.fromTranslationQuaternionRotationScale(a.translation, a.rotation, a.scale);
+                }
+                const t = (timeMs - a.timeMs) / (b.timeMs - a.timeMs);
+                return Cesium.Matrix4.fromTranslationQuaternionRotationScale(Cesium.Cartesian3.lerp(a.translation, b.translation, t, new Cesium.Cartesian3()), Cesium.Quaternion.slerp(a.rotation, b.rotation, t, new Cesium.Quaternion()), Cesium.Cartesian3.lerp(a.scale, b.scale, t, new Cesium.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 = Cesium.Matrix4.getScale(matrix, new Cesium.Cartesian3());
+                        const rotation = Cesium.Matrix4.getRotation(matrix, new Cesium.Matrix3());
+                        keyframes.push({
+                            timeMs,
+                            translation: Cesium.Matrix4.getTranslation(matrix, new Cesium.Cartesian3()),
+                            rotation: Cesium.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 = {
+                    [BModels.DataLab.EReqKey.Primary]: { Items: [root, historic], Select: { Type: BModels.DataLab.ESelectType.Id } }
+                };
+                const load = 1000;
+                try {
+                    const ids = [];
+                    for (let skip = 0;; skip += load) {
+                        const { items } = await BModels.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 Cesium.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 = Cesium.Matrix4.getRow(matrix, r, new Cesium.Cartesian4());
+                    rows.push([row.x, row.y, row.z, row.w]);
+                }
+                return rows;
             }
             Init() {
                 this.renderPriority = this.item.renderPriority;
@@ -29335,6 +30851,7 @@
                     this.renderPriority = 1;
                 }
                 (async () => {
+                    var _a, _b;
                     if (this.disposed) {
                         return;
                     }
@@ -29350,6 +30867,8 @@
                             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) {
@@ -29358,7 +30877,8 @@
                                     }
                                 }
                                 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);
                                 }
                             };
@@ -29377,17 +30897,17 @@
                             }
                         }
                         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);
@@ -29414,7 +30934,7 @@
                     if (!batch.length) {
                         continue;
                     }
-                    const { entities: fetched } = await BModels.Entity.GetListByIds({
+                    const { entities: apiEntities } = await BModels.Entity.GetListByIds({
                         entityIds: batch,
                         api: this.getters.GetBruceApi(),
                         expandLODs: true,
@@ -29426,6 +30946,16 @@
                     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 || [];
@@ -29448,57 +30978,46 @@
                             // Won't bother with vector data for this experiment.
                             continue;
                         }
-                        const recordHeightRef = Manager.GetRecordHeightRef(this.item);
-                        const recordPos3d = exports.EntityUtils.GetPos({
-                            viewer: this.viewer,
-                            entity,
-                            recordHeightRef: recordHeightRef,
-                            returnHeightRef: Cesium.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 = exports.EntityUtils.GetAssemblyOrientation(entity, pos3d);
                         const cEntity = this.viewer.entities.add({
                             model: {
                                 uri: lod["ClientFile"].URL,
                                 ...exports.ViewUtils.DefaultLightingProps(),
                                 heightReference: Cesium.HeightReference.NONE
-                            },
-                            position: pos3d,
-                            orientation: orient ? new Cesium.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 = BModels.Entity.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,
@@ -29518,47 +31037,89 @@
                 }
             }
             /*
-             * 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 exports.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(this.viewer, recordHeightRef, Cesium.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 exports.CesiumAnimatedProperty.AnimatePositionSeries({
                                 posses: posses,
@@ -29572,15 +31133,21 @@
                     }
                     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;
                     }
@@ -29590,15 +31157,9 @@
                     }
                     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 = () => {
@@ -29607,6 +31168,10 @@
                     (_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;
                 };
             }
             /*
@@ -29614,7 +31179,7 @@
              */
             applyRootTrack() {
                 var _a;
-                if (!this.item.historicDrawTrack || !this.historicAnimation || this.trackEntity) {
+                if (!this.item.historicDrawTrack || !this.historicAnimation || this.trail) {
                     return;
                 }
                 const trackStyle = exports.EntityRenderEngine.GetTrackStyle({
@@ -29624,41 +31189,35 @@
                 if (!trackStyle) {
                     return;
                 }
-                this.trackEntity = this.viewer.entities.add({
-                    id: BModels.ObjectUtils.UId(15),
-                    polyline: {
-                        positions: new Cesium.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: exports.EntityRenderEngine.GetHeightRefPolyline(Manager.GetRecordHeightRef(this.item))
-                            == Cesium.HeightReference.CLAMP_TO_GROUND,
-                        zIndex: 0,
-                        classificationType: Cesium.ClassificationType.BOTH
-                    }
-                });
-                this.trackEntity._noEdit = true;
-                this.trackEntity._noSelect = true;
-                exports.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: exports.EntityRenderEngine.GetHeightRefPolyline(Manager.GetRecordHeightRef(this.item))
+                        == Cesium.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
                 });
@@ -30112,6 +31671,9 @@
                     this.OnSeriesUpdated.Trigger({ itemId, segments: [] });
                 }
             }
+            get Simulation() {
+                return this.simulation;
+            }
             get Monitor() {
                 return this.sharedMonitor;
             }
@@ -30137,6 +31699,7 @@
                 this.visualsRegister = visualsRegister;
                 this.sharedGetters = new exports.SharedGetters.Cache();
                 this.sharedHistoric = new SharedHistoricGetters.Cache();
+                this.simulation = exports.EntitySimulation.Get(this.viewer);
                 this.sharedMonitor = new exports.CesiumViewMonitor.Monitor(this.viewer);
                 this.tilesetInitQueue = new InitQueueTileset(this.getters);
             }
@@ -30350,7 +31913,8 @@
                                 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 BModels.MenuItem.EType.EntitiesLoaded:
@@ -30359,7 +31923,8 @@
                                 register: this.visualsRegister,
                                 apiGetter: params.apiGetter,
                                 monitor: this.sharedMonitor,
-                                item: params.item
+                                item: params.item,
+                                simulation: this.simulation
                             });
                             break;
                         case BModels.MenuItem.EType.EntitiesIds:
@@ -30369,7 +31934,8 @@
                                 apiGetter: params.apiGetter,
                                 monitor: this.sharedMonitor,
                                 item: params.item,
-                                sharedHistoric: this.sharedHistoric
+                                sharedHistoric: this.sharedHistoric,
+                                simulation: this.simulation
                             });
                             break;
                         case BModels.MenuItem.EType.Entity:
@@ -30378,7 +31944,8 @@
                                 register: this.visualsRegister,
                                 apiGetter: params.apiGetter,
                                 monitor: this.sharedMonitor,
-                                item: params.item
+                                item: params.item,
+                                simulation: this.simulation
                             });
                             break;
                         case BModels.MenuItem.EType.CadTileset:
@@ -30388,7 +31955,8 @@
                                 getters: this.getters,
                                 item: params.item,
                                 modelSpace: params.modelSpace,
-                                initQueue: this.tilesetInitQueue
+                                initQueue: this.tilesetInitQueue,
+                                simulation: this.simulation
                             });
                             break;
                         case BModels.MenuItem.EType.Assembly:
@@ -30398,6 +31966,7 @@
                                 getters: params.getters,
                                 item: params.item,
                                 modelSpace: params.modelSpace,
+                                simulation: this.simulation
                             });
                             break;
                         case BModels.MenuItem.EType.Osm:
@@ -30425,7 +31994,8 @@
                                 getters: this.getters,
                                 monitor: this.sharedMonitor,
                                 item: params.item,
-                                initQueue: this.tilesetInitQueue
+                                initQueue: this.tilesetInitQueue,
+                                simulation: this.simulation
                             });
                             break;
                         case BModels.MenuItem.EType.Kml:
@@ -30449,7 +32019,8 @@
                                 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.
@@ -30459,7 +32030,8 @@
                                 apiGetter: params.apiGetter,
                                 item: params.item,
                                 register: this.visualsRegister,
-                                viewer: this.viewer
+                                viewer: this.viewer,
+                                simulation: this.simulation
                             });
                             break;
                         case BModels.MenuItem.EType.Relationships:
@@ -30467,7 +32039,8 @@
                                 apiGetter: params.apiGetter,
                                 item: params.item,
                                 register: this.visualsRegister,
-                                viewer: this.viewer
+                                viewer: this.viewer,
+                                simulation: this.simulation
                             });
                             break;
                         case BModels.MenuItem.EType.GooglePhotoTileset:
@@ -30499,7 +32072,8 @@
                                 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.
@@ -30712,6 +32286,63 @@
                     }
                 }
             }
+            /**
+             * 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;
     })(exports.MenuItemManager || (exports.MenuItemManager = {}));
@@ -39248,6 +40879,7 @@
     }
     class WidgetInfoView extends exports.Widget.AWidget {
         constructor(params) {
+            var _a;
             super(params);
             this.STYLESHEET_ID = "nextspace-info-view-stylesheet";
             this._generateStyles();
@@ -39257,10 +40889,19 @@
                     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)) {
@@ -39722,7 +41363,7 @@
             }
         }
         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";
@@ -39744,17 +41385,20 @@
                 this._summary.innerHTML = "";
                 this._imageContainer.style.display = "none";
                 const api = this._apiGetters.GetBruceApi();
-                const { entity } = await BModels.Entity.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 BModels.Entity.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 BModels.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 = BModels.Entity.CalculateName({
@@ -39777,7 +41421,7 @@
                 const defaultImage = images.length ? images[0] : null;
                 if (defaultImage) {
                     this._imageContainer.style.display = "flex";
-                    const url = (_c = defaultImage.URL) !== null && _c !== void 0 ? _c : BModels.ClientFile.GetUrl({
+                    const url = (_d = defaultImage.URL) !== null && _d !== void 0 ? _d : BModels.ClientFile.GetUrl({
                         fileId: defaultImage["ClientFile.ID"],
                         api: api,
                         viaCdn: true
@@ -39790,7 +41434,7 @@
                 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);
                 }
@@ -42384,7 +44028,7 @@
          * @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;
@@ -42932,6 +44576,13 @@
                     recordSamples.push(sample);
                 }
             }
+            // A simulated Entity is where its blob says, never where the API has it.
+            const simulation = exports.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);
@@ -42952,7 +44603,8 @@
                     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;
                         }
                     }
                 }
@@ -42966,6 +44618,11 @@
             // 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 = BModels.Entity.GetValue({
                         entity: x.entity,
                         path: ["Bruce", "AssemblyPosition"]
@@ -43324,6 +44981,21 @@
             return Cesium.Quaternion.multiply(combined, _assemblyAxisShift, new Cesium.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 = Cesium.Matrix4.multiply(rootFrame, world, new Cesium.Matrix4());
+            const rotation = Cesium.Matrix4.getRotation(combined, new Cesium.Matrix3());
+            const q = Cesium.Quaternion.fromRotationMatrix(rotation);
+            return Cesium.Quaternion.multiply(q, _assemblyAxisShift, new Cesium.Quaternion());
+        }
+        EntityUtils.GetAssemblyOrientationInFrame = GetAssemblyOrientationInFrame;
         /**
          * Returns the position of the entity.
          * This is an async variant that checks for related assemblies.
@@ -43333,6 +45005,18 @@
          */
         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 = exports.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 BModels.Entity.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.
@@ -53294,7 +54978,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.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.