bruce-cesium 7.2.0 → 7.2.1

package/dist/bruce-cesium.umd.js

@@ -10700,6 +10700,468 @@
         }
     }
 
+    /**
+     * How often a historic refresh is worth running, and which Entities it should ask about first.
+     *
+     * A handful of tracked vehicles can afford to re-read on almost every clock tick. Thousands of
+     * parcels cannot, and refreshing them that often was never buying anything since the answer barely
+     * changes between ticks.
+     */
+    var HistoricFetchOrder;
+    (function (HistoricFetchOrder) {
+        // The cadence for a set small enough that latency is what the user notices.
+        HistoricFetchOrder.MIN_INTERVAL_MS = 250;
+        // The cadence for a set large enough that the request itself is what the user notices.
+        HistoricFetchOrder.MAX_INTERVAL_MS = 10000;
+        // Below this many Entities the cadence stays at its fastest.
+        HistoricFetchOrder.SMALL_SET = 30;
+        // At and above this many it stays at its slowest.
+        HistoricFetchOrder.LARGE_SET = 5000;
+        /**
+         * Returns how long to wait between historic refreshes for a set of this size.
+         */
+        function IntervalFor(entityCount, minMs = HistoricFetchOrder.MIN_INTERVAL_MS, maxMs = HistoricFetchOrder.MAX_INTERVAL_MS) {
+            if (!(entityCount > HistoricFetchOrder.SMALL_SET)) {
+                return minMs;
+            }
+            if (entityCount >= HistoricFetchOrder.LARGE_SET) {
+                return maxMs;
+            }
+            // Log scaled, so going from 30 to 300 Entities costs more than going from 3000 to 5000.
+            const progress = Math.log(entityCount / HistoricFetchOrder.SMALL_SET) / Math.log(HistoricFetchOrder.LARGE_SET / HistoricFetchOrder.SMALL_SET);
+            return Math.round(minMs + ((maxMs - minMs) * progress));
+        }
+        HistoricFetchOrder.IntervalFor = IntervalFor;
+        /**
+         * Returns the Entities grouped into bands by distance from the camera, nearest band first.
+         *
+         * Bands rather than a true sort, so a small camera move does not reshuffle the whole queue and
+         * restart it. What the user is looking at resolves first either way.
+         */
+        function ByCameraDistance(params) {
+            var _a;
+            const { viewer, entities } = params;
+            const bands = params.bands || [500, 2000, 10000, 50000];
+            if (!(entities === null || entities === void 0 ? void 0 : entities.length)) {
+                return [];
+            }
+            const cameraPos = (_a = viewer === null || viewer === void 0 ? void 0 : viewer.camera) === null || _a === void 0 ? void 0 : _a.position;
+            if (!cameraPos) {
+                return [entities];
+            }
+            // One band past the named bounds, for everything beyond the last of them.
+            const banded = bands.map(() => []).concat([[]]);
+            for (const entity of entities) {
+                const pos = SafePos(entity, viewer);
+                if (!pos) {
+                    banded[banded.length - 1].push(entity);
+                    continue;
+                }
+                const distance = Cesium.Cartesian3.distance(cameraPos, pos);
+                let index = bands.findIndex(bound => distance <= bound);
+                if (index < 0) {
+                    index = banded.length - 1;
+                }
+                banded[index].push(entity);
+            }
+            return banded.filter(band => band.length > 0);
+        }
+        HistoricFetchOrder.ByCameraDistance = ByCameraDistance;
+        /*
+         * Returns an Entity's world position, or null when it has none to place it by.
+         */
+        function SafePos(entity, viewer) {
+            try {
+                const pos = exports.EntityUtils.GetPos({
+                    entity: entity,
+                    viewer: viewer,
+                    allowRendered: true
+                });
+                if (!pos || isNaN(pos.x) || isNaN(pos.y) || isNaN(pos.z)) {
+                    return null;
+                }
+                return pos;
+            }
+            catch {
+                return null;
+            }
+        }
+    })(HistoricFetchOrder || (HistoricFetchOrder = {}));
+    /**
+     * Decides what slice of history is worth fetching for the clock as it is currently moving.
+     */
+    var HistoricFetchPlan;
+    (function (HistoricFetchPlan) {
+        // How many seconds of playback the detail window tries to stay ahead by.
+        HistoricFetchPlan.DEFAULT_LEAD_SECONDS = 10;
+        // The detail window never shrinks below this, so a paused clock still has something around it.
+        HistoricFetchPlan.DEFAULT_MIN_DETAIL_MS = 60 * 1000;
+        // Nor grows past it, which is what stops a fast scrub asking for the whole archive.
+        HistoricFetchPlan.DEFAULT_MAX_DETAIL_MS = 6 * 60 * 60 * 1000;
+        // Records the coarse pass may spend describing the whole range.
+        HistoricFetchPlan.DEFAULT_SAMPLE = 200;
+        /*
+         * Returns how wide the detail window should be for the rate the clock is moving at.
+         */
+        function DetailSpanFor(trajectory, leadSeconds, minMs, maxMs) {
+            const rate = Math.abs((trajectory === null || trajectory === void 0 ? void 0 : trajectory.ratePerSecondMs) || 0);
+            const span = rate * leadSeconds;
+            if (!(span > minMs)) {
+                return minMs;
+            }
+            return Math.min(span, maxMs);
+        }
+        HistoricFetchPlan.DetailSpanFor = DetailSpanFor;
+        /**
+         * Returns the detail window and the coarse pass for the clock as it stands.
+         */
+        function Plan(params) {
+            var _a;
+            const { currentTime, windowStart, windowStop, trajectory, leadSeconds = HistoricFetchPlan.DEFAULT_LEAD_SECONDS, minDetailMs = HistoricFetchPlan.DEFAULT_MIN_DETAIL_MS, maxDetailMs = HistoricFetchPlan.DEFAULT_MAX_DETAIL_MS, sample = HistoricFetchPlan.DEFAULT_SAMPLE } = params;
+            if (!(windowStop > windowStart)) {
+                return { detail: null, coarse: null };
+            }
+            // A range that fits the detail budget has nothing worth sampling: reading it whole is both
+            // cheaper than two requests and better than an approximation of it.
+            if ((windowStop - windowStart) <= maxDetailMs) {
+                return { detail: { start: windowStart, stop: windowStop }, coarse: null };
+            }
+            const span = DetailSpanFor(trajectory, leadSeconds, minDetailMs, maxDetailMs);
+            const direction = (_a = trajectory === null || trajectory === void 0 ? void 0 : trajectory.direction) !== null && _a !== void 0 ? _a : 0;
+            // Time running forward only ever reveals what is ahead, so the window leads rather than centres.
+            // A little is still kept behind so a record just passed can still be interpolated from.
+            const behind = direction === 0 ? span / 2 : span * 0.2;
+            const ahead = direction === 0 ? span / 2 : span * 0.8;
+            let start = direction < 0 ? currentTime - ahead : currentTime - behind;
+            let stop = direction < 0 ? currentTime + behind : currentTime + ahead;
+            start = Math.max(windowStart, start);
+            stop = Math.min(windowStop, stop);
+            if (!(stop > start)) {
+                return { detail: null, coarse: { start: windowStart, stop: windowStop, sample } };
+            }
+            const detail = { start, stop };
+            // Nothing to be coarse about once the detail window is the whole range.
+            if (start <= windowStart && stop >= windowStop) {
+                return { detail, coarse: null };
+            }
+            return { detail, coarse: { start: windowStart, stop: windowStop, sample } };
+        }
+        HistoricFetchPlan.Plan = Plan;
+        /**
+         * Tracks which way the clock is moving and how fast, from the times it is observed at.
+         * Playback and a user dragging the timeline both look the same here, which is the point.
+         */
+        class TrajectoryTracker {
+            // Smooths the rate so one slow frame does not collapse the window.
+            constructor(smoothing = 0.4) {
+                this.smoothing = smoothing;
+                this.lastTime = null;
+                this.lastObservedAt = null;
+                this.direction = 0;
+                this.ratePerSecondMs = 0;
+            }
+            /**
+             * Records where the clock is now. observedAt is the wall clock, in milliseconds.
+             */
+            Observe(sceneTime, observedAt) {
+                if (this.lastTime == null) {
+                    this.lastTime = sceneTime;
+                    this.lastObservedAt = observedAt;
+                    return;
+                }
+                const elapsed = observedAt - this.lastObservedAt;
+                const moved = sceneTime - this.lastTime;
+                this.lastTime = sceneTime;
+                this.lastObservedAt = observedAt;
+                if (!(elapsed > 0)) {
+                    return;
+                }
+                if (moved === 0) {
+                    this.direction = 0;
+                    this.ratePerSecondMs = 0;
+                    return;
+                }
+                this.direction = moved > 0 ? 1 : -1;
+                const rate = Math.abs(moved) / (elapsed / 1000);
+                this.ratePerSecondMs = this.ratePerSecondMs === 0
+                    ? rate
+                    : (this.ratePerSecondMs * (1 - this.smoothing)) + (rate * this.smoothing);
+            }
+            Get() {
+                return { direction: this.direction, ratePerSecondMs: this.ratePerSecondMs };
+            }
+            Reset() {
+                this.lastTime = null;
+                this.lastObservedAt = null;
+                this.direction = 0;
+                this.ratePerSecondMs = 0;
+            }
+        }
+        HistoricFetchPlan.TrajectoryTracker = TrajectoryTracker;
+    })(HistoricFetchPlan || (HistoricFetchPlan = {}));
+    /**
+     * Tracks which time ranges of historic data have already been requested, and the records they
+     * returned, so moving the clock only fetches the part that is genuinely new.
+     *
+     * Coverage is tracked by the ranges that were asked for, not by the timestamps that came back. A
+     * window holding no records is still covered, otherwise an empty stretch is re-requested forever.
+     */
+    class HistoricRangeCache {
+        // Ranges this far apart are treated as one, so a scrub does not leave a trail of slivers.
+        constructor(mergeToleranceMs = 60000) {
+            this.mergeToleranceMs = mergeToleranceMs;
+            // Requested ranges, kept sorted and non-overlapping.
+            this.held = [];
+            // Ranges covered only by a sampled read, which describe their span without holding every record.
+            this.heldCoarse = [];
+            this.records = {};
+        }
+        /**
+         * Returns the parts of the window that have not been requested yet.
+         */
+        MissingRanges(start, stop) {
+            if (!(stop > start)) {
+                return [];
+            }
+            const missing = [];
+            let cursor = start;
+            for (const range of this.held) {
+                if (range.stop <= cursor) {
+                    continue;
+                }
+                if (range.start >= stop) {
+                    break;
+                }
+                if (range.start > cursor) {
+                    missing.push({ start: cursor, stop: Math.min(range.start, stop) });
+                }
+                cursor = Math.max(cursor, range.stop);
+                if (cursor >= stop) {
+                    break;
+                }
+            }
+            if (cursor < stop) {
+                missing.push({ start: cursor, stop: stop });
+            }
+            return this.mergeAdjacent(missing);
+        }
+        /**
+         * Marks a range as requested and merges the records it returned into what is already held.
+         */
+        Absorb(start, stop, recordsByIds, coarse = false) {
+            if (stop > start) {
+                if (coarse) {
+                    this.heldCoarse = this.mergeAdjacent([...this.heldCoarse, { start, stop }].sort((a, b) => a.start - b.start));
+                }
+                else {
+                    this.held = this.mergeAdjacent([...this.held, { start, stop }].sort((a, b) => a.start - b.start));
+                }
+            }
+            if (!recordsByIds) {
+                return;
+            }
+            for (const entityId of Object.keys(recordsByIds)) {
+                const incoming = recordsByIds[entityId] || [];
+                const current = this.records[entityId] || [];
+                // Keyed by instant so a range fetched twice cannot double up its records.
+                const byInstant = new Map();
+                for (const record of current) {
+                    byInstant.set(new Date(record.dateTime).getTime(), record);
+                }
+                for (const record of incoming) {
+                    byInstant.set(new Date(record.dateTime).getTime(), record);
+                }
+                this.records[entityId] = Array.from(byInstant.values())
+                    .sort((a, b) => new Date(a.dateTime).getTime() - new Date(b.dateTime).getTime());
+            }
+        }
+        GetRecords() {
+            return this.records;
+        }
+        /**
+         * Returns whether the window is already covered in full.
+         */
+        Covers(start, stop) {
+            return this.MissingRanges(start, stop).length === 0;
+        }
+        /**
+         * Returns whether a sampled pass already describes the window.
+         */
+        CoversCoarse(start, stop) {
+            if (!(stop > start)) {
+                return true;
+            }
+            return this.heldCoarse.some(range => range.start <= start && range.stop >= stop);
+        }
+        Clear() {
+            this.held = [];
+            this.heldCoarse = [];
+            this.records = {};
+        }
+        mergeAdjacent(ranges) {
+            if (ranges.length <= 1) {
+                return ranges;
+            }
+            const sorted = [...ranges].sort((a, b) => a.start - b.start);
+            const merged = [];
+            let current = { ...sorted[0] };
+            for (let i = 1; i < sorted.length; i++) {
+                const next = sorted[i];
+                if (next.start - current.stop <= this.mergeToleranceMs) {
+                    current.stop = Math.max(current.stop, next.stop);
+                }
+                else {
+                    merged.push(current);
+                    current = { ...next };
+                }
+            }
+            merged.push(current);
+            return merged;
+        }
+    }
+    /**
+     * Pulls historic records for the visible clock range: what to ask for, in what order, and what has
+     * already been asked for.
+     */
+    class HistoricGatherer {
+        constructor(params) {
+            this.params = params;
+            this.trajectory = new HistoricFetchPlan.TrajectoryTracker();
+            // Range key to the request in flight for it, so the same range is never asked for twice at once.
+            this.inFlight = new Map();
+            this.disposed = false;
+            this.cache = new HistoricRangeCache();
+        }
+        get Records() {
+            return this.cache.GetRecords();
+        }
+        Clear() {
+            this.cache.Clear();
+            this.trajectory.Reset();
+            this.inFlight.clear();
+        }
+        Dispose() {
+            this.disposed = true;
+            this.Clear();
+        }
+        /**
+         * Returns how long to wait between refreshes for a set of this size.
+         */
+        IntervalFor(entityCount) {
+            return HistoricFetchOrder.IntervalFor(entityCount);
+        }
+        /**
+         * Fetches whatever the current clock range needs that is not already held.
+         * Returns whether anything was requested, alongside every record held for these Entities.
+         */
+        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 { viewer } = this.params;
+            const windowStart = new Date(viewer.clock.startTime.toString()).getTime();
+            const windowStop = new Date(viewer.clock.stopTime.toString()).getTime();
+            const currentTime = new Date(viewer.clock.currentTime.toString()).getTime();
+            this.trajectory.Observe(currentTime, Date.now());
+            const liveEdge = exports.ViewUtils.GetTimeDetails({ viewer }).isLive ? currentTime : null;
+            const liveTail = (_a = this.params.liveTailMs) !== null && _a !== void 0 ? _a : HistoricGatherer.LIVE_TAIL_MS;
+            const plan = HistoricFetchPlan.Plan({
+                currentTime,
+                windowStart,
+                windowStop,
+                trajectory: this.trajectory.Get(),
+                sample: this.params.sample
+            });
+            let fetched = false;
+            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() };
+                }
+                this.cache.Absorb(plan.coarse.start, this.holdTo(plan.coarse.stop, liveEdge, liveTail), records, true);
+                fetched = true;
+            }
+            if (plan.detail) {
+                const bands = entities.length > HistoricFetchOrder.SMALL_SET
+                    ? HistoricFetchOrder.ByCameraDistance({ viewer, entities })
+                    : [entities];
+                for (const range of this.cache.MissingRanges(plan.detail.start, plan.detail.stop)) {
+                    if (this.disposed) {
+                        break;
+                    }
+                    for (const band of bands) {
+                        if (this.disposed) {
+                            break;
+                        }
+                        const records = await this.request(range.start, range.stop, band, 0);
+                        if (this.disposed) {
+                            break;
+                        }
+                        // Records land as each band arrives, while the range is only marked held once
+                        // every band has been asked for.
+                        this.cache.Absorb(0, 0, records);
+                        fetched = true;
+                    }
+                    if (this.disposed) {
+                        break;
+                    }
+                    const heldTo = this.holdTo(range.stop, liveEdge, liveTail);
+                    if (heldTo > range.start) {
+                        this.cache.Absorb(range.start, heldTo, {});
+                    }
+                }
+            }
+            return { fetched, recordsByIds: this.cache.GetRecords() };
+        }
+        /*
+         * Returns how much of a range that was just read may be marked as held.
+         */
+        holdTo(stop, liveEdge, liveTailMs) {
+            if (liveEdge == null) {
+                return stop;
+            }
+            return Math.min(stop, liveEdge - liveTailMs);
+        }
+        /*
+         * Reads one range, joining a request already in flight for it rather than repeating it.
+         */
+        request(start, stop, entities, sample) {
+            var _a;
+            const padding = (_a = this.params.paddingMs) !== null && _a !== void 0 ? _a : 0;
+            const dateTimeFrom = new Date(start - padding).toISOString();
+            const dateTimeTo = new Date(stop + padding).toISOString();
+            const entityIds = entities.map(x => { var _a; return (_a = x.Bruce) === null || _a === void 0 ? void 0 : _a.ID; }).filter(x => !!x);
+            const key = `${dateTimeFrom}|${dateTimeTo}|${sample}|${entityIds.join(",")}`;
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const prom = BModels.EntityHistoricData.GetRecordsByEntity({
+                attrKey: this.params.getAttrKey(),
+                dateTimeFrom,
+                dateTimeTo,
+                entityIds,
+                sample: sample > 0 ? sample : undefined,
+                api: this.params.getApi()
+            }).then((res) => {
+                const records = res.recordsByIds || {};
+                if (!this.disposed && this.params.onRecords) {
+                    this.params.onRecords(records);
+                }
+                return records;
+            }).finally(() => {
+                this.inFlight.delete(key);
+            });
+            this.inFlight.set(key, prom);
+            return prom;
+        }
+    }
+    // How far back from the live edge is left unheld, so a record written moments ago still falls in
+    // something that gets asked for again. It has to outlast a write, a commit and a refresh, plus
+    // whatever the writer's clock and this one disagree by.
+    HistoricGatherer.LIVE_TAIL_MS = 15000;
+
     const BATCH_SIZE = 500;
     const CHECK_BATCH_SIZE = 250;
     function getValue$2(viewer, obj) {
@@ -10784,6 +11246,13 @@
                 this.item = item;
                 this.visualsManager = visualsManager;
                 this.onSeriesDiscovered = onSeriesDiscovered;
+                this.historicGatherer = new HistoricGatherer({
+                    viewer: this.viewer,
+                    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
+                });
                 this.useGeojson = item.renderAsGeojson == true;
                 if (item.enableClustering) {
                     this.clustering = new PointClustering(this.visualsManager, this.item.id);
@@ -11747,6 +12216,13 @@
                 this.renderAsIndividualsChain = next;
                 return next;
             }
+            /**
+             * Returns the historic records to interpolate between, fetching only what is not already held.
+             */
+            async gatherHistoric(entities) {
+                const { recordsByIds } = await this.historicGatherer.Gather(entities);
+                return recordsByIds;
+            }
             async doRenderAsIndividuals(entities, force = false) {
                 var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
                 // When live we just want to show the latest pos.
@@ -11761,19 +12237,7 @@
                 const isHistoric = ((_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic) || ((_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b.historicAttrKey);
                 // If we're interpolating then we request additional records to quickly swap between.
                 if (!isLive && isHistoric && entities.length && this.item.historicInterpolation) {
-                    // We'll add/remove 1 second to ensure we cover all records.
-                    const startTmp = Cesium.JulianDate.toDate(this.viewer.clock.startTime);
-                    const stopTmp = Cesium.JulianDate.toDate(this.viewer.clock.stopTime);
-                    const startStr = new Date(startTmp.getTime() - 1000).toISOString();
-                    const stopStr = new Date(stopTmp.getTime() + 1000).toISOString();
-                    const historicData = await BModels.EntityHistoricData.GetList({
-                        attrKey: this.item.BruceEntity.historicAttrKey,
-                        dateTimeFrom: startStr,
-                        dateTimeTo: stopStr,
-                        entityIds: entities.map(x => x.Bruce.ID),
-                        api: this.apiGetter.getApi()
-                    });
-                    entitiesHistoric = historicData.recordsByIds;
+                    entitiesHistoric = await this.gatherHistoric(entities);
                 }
                 if (this.disposed) {
                     this.doDispose();
@@ -12887,6 +13351,13 @@
                 this.monitor = monitor;
                 this.item = item;
                 this.visualsManager = visualsManager;
+                this.historicGatherer = new HistoricGatherer({
+                    viewer: this.viewer,
+                    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
+                });
                 if (this.item.enableClustering) {
                     this.clustering = new PointClustering(visualsManager, this.item.id, (_a = this.item) === null || _a === void 0 ? void 0 : _a.clustering);
                 }
@@ -13236,138 +13707,22 @@
              * @param entities
              */
             async getHistoricInfo(entities) {
-                // Time padding in milliseconds (15 seconds).
-                // Helps account for desync between client and server.
-                const TIME_PADDING_MS = 15000;
-                const minDateTimeStr = this.viewer.clock.startTime.toString();
-                const maxDateTimeStr = this.viewer.clock.stopTime.toString();
-                const minDateTime = new Date(minDateTimeStr).getTime();
-                const maxDateTime = new Date(maxDateTimeStr).getTime();
-                const tDetails = exports.ViewUtils.GetTimeDetails({
-                    viewer: this.viewer,
-                });
-                const isLive = tDetails.isLive;
-                let rangesToRequest = [{
-                        start: minDateTime,
-                        stop: maxDateTime
-                    }];
-                // If we already have cached data, determine what ranges we're missing.
-                if (Object.keys(this.entitiesHistoric).length >= entities.length) {
-                    let foundMinDateTime = null;
-                    let foundMaxDateTime = null;
-                    // Find the min/max based on cached data.
-                    // Since we set the values sorted, we only have to check the first and last records for each entity.
-                    for (const entityId of Object.keys(this.entitiesHistoric)) {
-                        const records = this.entitiesHistoric[entityId] || [];
-                        if (records.length) {
-                            const dateTime = new Date(records[0].dateTime).getTime();
-                            if (foundMinDateTime == null || dateTime < foundMinDateTime) {
-                                foundMinDateTime = dateTime;
-                            }
-                            const dateTime2 = new Date(records[records.length - 1].dateTime).getTime();
-                            if (foundMaxDateTime == null || dateTime2 > foundMaxDateTime) {
-                                foundMaxDateTime = dateTime2;
-                            }
-                        }
-                    }
-                    // Complete overlap - we already have all the data.
-                    if (foundMinDateTime != null && foundMaxDateTime != null && foundMinDateTime <= minDateTime && foundMaxDateTime >= maxDateTime) {
-                        return [false, this.entitiesHistoric];
-                    }
-                    // Calculate missing ranges.
-                    rangesToRequest = [];
-                    // Check if we need data before our cached range.
-                    if (foundMinDateTime != null && foundMinDateTime > minDateTime) {
-                        // When live we focus on getting the next range rather than old data.
-                        // Ends up being one less request to perform every second.
-                        if (!isLive || foundMinDateTime == null) {
-                            rangesToRequest.push({
-                                start: minDateTime,
-                                stop: new Date(foundMinDateTime).getTime()
-                            });
-                        }
-                    }
-                    // Check if we need data after our cached range.
-                    if (foundMaxDateTime != null && foundMaxDateTime < maxDateTime) {
-                        rangesToRequest.push({
-                            start: new Date(foundMaxDateTime).getTime(),
-                            stop: maxDateTime
-                        });
-                    }
-                    // If the ranges to request are within a tolerance, combine them.
-                    if (rangesToRequest.length > 1) {
-                        const TOLERANCE_MS = 60000; // 1 minute.
-                        let currentRange = rangesToRequest[0];
-                        for (let i = 1; i < rangesToRequest.length; i++) {
-                            const nextRange = rangesToRequest[i];
-                            if (nextRange.start - currentRange.stop <= TOLERANCE_MS) {
-                                currentRange.stop = nextRange.stop;
-                            }
-                            else {
-                                currentRange = nextRange;
-                            }
-                        }
-                    }
-                }
-                const entityIds = entities.map(x => x.Bruce.ID);
-                const combined = { ...this.entitiesHistoric };
-                // Make requests for each missing range
-                for (const range of rangesToRequest) {
-                    if (this.disposed) {
-                        break;
-                    }
-                    const start = new Date(range.start - TIME_PADDING_MS);
-                    const stop = new Date(range.stop + TIME_PADDING_MS);
-                    const historicData = await BModels.EntityHistoricData.GetList({
-                        attrKey: this.item.BruceEntity.historicAttrKey,
-                        dateTimeFrom: start.toISOString(),
-                        dateTimeTo: stop.toISOString(),
-                        entityIds: entityIds,
-                        api: this.apiGetter.getApi()
-                    });
-                    if (this.disposed) {
-                        break;
-                    }
-                    // Merge the new data with existing data
-                    const records = historicData.recordsByIds;
-                    const recordsIds = Object.keys(records);
-                    for (let i = 0; i < recordsIds.length; i++) {
-                        const entityId = recordsIds[i];
-                        const latest = records[entityId] || [];
-                        const current = combined[entityId] || [];
-                        // Use a Map to de-duplicate by timestamp.
-                        const tmp = new Map();
-                        for (let j = 0; j < current.length; j++) {
-                            const record = current[j];
-                            const dateTime = new Date(record.dateTime).getTime();
-                            tmp.set(dateTime, record);
-                        }
-                        for (let j = 0; j < latest.length; j++) {
-                            const record = latest[j];
-                            const dateTime = new Date(record.dateTime).getTime();
-                            tmp.set(dateTime, record);
-                        }
-                        // Convert to array and sort by date.
-                        const sorted = Array.from(tmp.values()).sort((a, b) => {
-                            return new Date(a.dateTime).getTime() - new Date(b.dateTime).getTime();
-                        });
-                        combined[entityId] = sorted;
-                    }
-                }
+                const { fetched, recordsByIds } = await this.historicGatherer.Gather(entities);
                 if (!this.disposed) {
-                    this.entitiesHistoric = combined;
+                    this.entitiesHistoric = recordsByIds;
                 }
-                return [rangesToRequest.length > 0, combined];
+                return [fetched, recordsByIds];
             }
             viewerDateTimeSub() {
                 var _a, _b;
                 if ((!((_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic) && !((_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b.historicAttrKey)) || this.viewerDateTimeChangeRemoval) {
                     return;
                 }
-                const THROTTLE_INTERVAL = 2000;
+                // Scaled by how many Entities are on screen rather than fixed, since the cost of a refresh
+                // is the set size and a large set barely changes between ticks anyway.
                 let queue = new BModels.DelayQueue(() => {
                     this.onGetterUpdate(Object.keys(this.renderedEntities));
-                }, THROTTLE_INTERVAL, true);
+                }, this.historicGatherer.IntervalFor(Object.keys(this.renderedEntities).length), true);
                 let clockTickRemoval;
                 let prevTick = this.viewer.clock.currentTime.toString();
                 clockTickRemoval = this.viewer.clock.onTick.addEventListener(() => {
@@ -14055,6 +14410,9 @@
             // Indicates that we are retrieving historic records.
             // This means that the current scene's time is included in the request.
             this.historic = false;
+            // When false the Entity data is still gathered and the regos still updated, but no colour is
+            // applied. A historic item that did not ask for styling needs the first without the second.
+            this.applyStyles = true;
             this.reRenderState = new EntityReRenderMaintainState();
             // More expensive process.
             // When an Entity is styled, the rego is reviewed and updated if needed.
@@ -14091,13 +14449,16 @@
         }
         Init(params) {
             var _a, _b;
-            let { viewer, api, cTileset, fallbackStyleId, styleMapping, expandSources, menuItemId, register, scenario, historic } = params;
+            let { viewer, api, cTileset, fallbackStyleId, styleMapping, expandSources, menuItemId, register, scenario, historic, applyStyles } = params;
             this.viewer = viewer;
             this.api = api;
             this.cTileset = cTileset;
             this.register = register;
             this.menuItemId = menuItemId;
             this.historic = Boolean(historic);
+            if (applyStyles != null) {
+                this.applyStyles = Boolean(applyStyles);
+            }
             if (expandSources != null) {
                 this.expandSources = expandSources;
             }
@@ -14591,33 +14952,31 @@
                 return;
             }
             const { settings: style, styleId: resolvedStyleId } = this.getTilesetFeatureStyleWithId(rego.entityTypeId);
-            const fillColorTrace = (style && ((_a = style.modelStyle) === null || _a === void 0 ? void 0 : _a.fillColor)) ? BModels.Calculator.TraceGetColor(style.modelStyle.fillColor, data, tags) : { value: null, effective: null };
-            const bColor = fillColorTrace.value;
-            let cColor = null;
-            if (bColor == null) {
-                cColor = Cesium.Color.WHITE;
-            }
-            else {
-                cColor = colorToCColor$3(bColor);
-            }
+            const fillColorTrace = (this.applyStyles && style && ((_a = style.modelStyle) === null || _a === void 0 ? void 0 : _a.fillColor)) ? BModels.Calculator.TraceGetColor(style.modelStyle.fillColor, data, tags) : { value: null, effective: null };
+            // Without styling the feature keeps whatever the tileset baked in. Falling through would paint
+            // it the default white, which is a visible change for an item that only asked for historic.
             const override = this.overrideFeatureColor.get(rego.entityId) == true;
-            exports.CesiumEntityStyler.SetDefaultColor({
-                color: cColor,
-                entity: visual,
-                viewer: this.viewer,
-                override: override
-            });
-            this.overrideFeatureColor.set(rego.entityId, true);
-            if (((_b = data === null || data === void 0 ? void 0 : data.Bruce) === null || _b === void 0 ? void 0 : _b.InternalID) != null) {
+            if (this.applyStyles) {
+                const bColor = fillColorTrace.value;
+                const cColor = bColor == null ? Cesium.Color.WHITE : colorToCColor$3(bColor);
+                exports.CesiumEntityStyler.SetDefaultColor({
+                    color: cColor,
+                    entity: visual,
+                    viewer: this.viewer,
+                    override: override
+                });
+                this.overrideFeatureColor.set(rego.entityId, true);
+                if (resolvedStyleId != null) {
+                    rego.styleId = resolvedStyleId;
+                }
+                rego.styleEffective = (_b = exports.StyleEffective.Combine([
+                    { key: "color", effective: fillColorTrace.effective }
+                ])) !== null && _b !== void 0 ? _b : rego.styleEffective;
+            }
+            if (((_c = data === null || data === void 0 ? void 0 : data.Bruce) === null || _c === void 0 ? void 0 : _c.InternalID) != null) {
                 rego.internalId = data.Bruce.InternalID;
                 this.styledByInternalId.set(data.Bruce.InternalID, rego.entityId);
             }
-            if (resolvedStyleId != null) {
-                rego.styleId = resolvedStyleId;
-            }
-            rego.styleEffective = (_c = exports.StyleEffective.Combine([
-                { key: "color", effective: fillColorTrace.effective }
-            ])) !== null && _c !== void 0 ? _c : rego.styleEffective;
             this.styledEntityIds.set(rego.entityId, true);
             this._styleProgressQueue.Call();
             // Since we only need to update it for scenarios right now.
@@ -15582,6 +15941,7 @@
                 // Series of points to help interpolate movement when the timeline changes.
                 this.historicPossesInitialLoaded = false;
                 this.historicAnimation = null;
+                this.historicGatherer = null;
                 this.historicPossesLoadingProm = null;
                 // Queue of loaded in features that we haven't processed yet.
                 this.featureQueue = [];
@@ -16619,120 +16979,41 @@
                 const api = this.getters.GetBruceApi({
                     accountId: accountId
                 });
-                // Time padding in milliseconds (15 seconds).
-                // Helps account for desync between client and server.
-                const TIME_PADDING_MS = 15000;
-                // 'start-stop' time string that maps to a pending request.
-                // Helps us avoid repeated requests that are the same.
-                const pendingRequests = new Map();
-                /**
-                 * Returns a list of historic positions for a given time range.
-                 * @param startStr
-                 * @param stopStr
-                 * @returns
+                // The root Entity is the only one here, so nothing is banded and the plan sees a set of one.
+                const rootEntity = { Bruce: { ID: this.rootId } };
+                /*
+                 * Turns historic records into the animated positions this tileset moves along.
                  */
-                const getPossesForRange = async (startStr, stopStr) => {
-                    const requestKey = `${startStr}-${stopStr}`;
-                    if (pendingRequests.has(requestKey)) {
-                        return pendingRequests.get(requestKey);
-                    }
-                    const requestPromise = new Promise(async (res) => {
-                        try {
-                            const historicData = await BModels.EntityHistoricData.GetList({
-                                attrKey: null,
-                                dateTimeFrom: startStr,
-                                dateTimeTo: stopStr,
-                                entityIds: [this.rootId],
-                                api: api
-                            });
-                            const posses = exports.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(this.viewer, Cesium.HeightReference.NONE, Cesium.HeightReference.CLAMP_TO_GROUND, historicData.recordsByIds[this.rootId]);
-                            res(posses);
-                        }
-                        catch (e) {
-                            console.error(e);
-                            res([]);
-                        }
-                        finally {
-                            pendingRequests.delete(requestKey);
-                        }
-                    });
-                    pendingRequests.set(requestKey, requestPromise);
-                    return requestPromise;
+                const toPosses = (records) => {
+                    return exports.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(this.viewer, Cesium.HeightReference.NONE, Cesium.HeightReference.CLAMP_TO_GROUND, records);
                 };
+                this.historicGatherer = new HistoricGatherer({
+                    viewer: this.viewer,
+                    getApi: () => api,
+                    // The assembly root snapshots the whole Entity, so no key narrows it.
+                    getAttrKey: () => null,
+                    // Time padding in milliseconds (15 seconds).
+                    // Helps account for desync between client and server.
+                    paddingMs: 15000,
+                    onRecords: (recordsByIds) => {
+                        var _a;
+                        const records = recordsByIds[this.rootId];
+                        if (!(records === null || records === void 0 ? void 0 : records.length) || !((_a = this.historicAnimation) === null || _a === void 0 ? void 0 : _a.addPositions)) {
+                            return;
+                        }
+                        this.historicAnimation.addPositions(toPosses(records));
+                    }
+                });
                 /**
-                 * Checks if the current timeline range is not fully loaded and requests the difference.
-                 * This will call getPossesForRange() if it needs more data.
+                 * Fetches whatever the current timeline range needs that is not already held.
+                 * Positions reach the animation through the gatherer's callback as each batch lands.
                  * @returns
                  */
                 const checkTimelineRange = async () => {
-                    // Current timeline range.
-                    const minDateTime = new Date(this.viewer.clock.startTime.toString()).getTime();
-                    const maxDateTime = new Date(this.viewer.clock.stopTime.toString()).getTime();
-                    // What we have loaded.
-                    const range = this.historicAnimation.getDateRange();
-                    const foundMinDateTime = (range === null || range === void 0 ? void 0 : range.minDate) ? range.minDate.getTime() : null;
-                    const foundMaxDateTime = (range === null || range === void 0 ? void 0 : range.maxDate) ? range.maxDate.getTime() : null;
-                    // See if the current range is within the range we already have.
-                    if (this.historicPossesInitialLoaded &&
-                        foundMinDateTime &&
-                        foundMaxDateTime &&
-                        minDateTime >= foundMinDateTime &&
-                        maxDateTime <= foundMaxDateTime) {
-                        return;
-                    }
-                    const tDetails = exports.ViewUtils.GetTimeDetails({
-                        viewer: this.viewer,
-                    });
-                    const isLive = tDetails.isLive;
-                    // See if the requested range is before or after the range we have.
-                    const fetchBefore = !foundMinDateTime || (!isLive && minDateTime < foundMinDateTime);
-                    const fetchAfter = !foundMaxDateTime || maxDateTime > foundMaxDateTime;
-                    if (!fetchBefore && !fetchAfter) {
-                        // Already have the data we need.
+                    if (this.disposed) {
                         return;
                     }
-                    // No known range so we need to fetch the whole thing.
-                    if (!foundMinDateTime || !foundMaxDateTime) {
-                        const startStr = new Date(minDateTime - TIME_PADDING_MS).toISOString();
-                        const stopStr = new Date(maxDateTime + TIME_PADDING_MS).toISOString();
-                        const newPositions = await getPossesForRange(startStr, stopStr);
-                        if (this.disposed) {
-                            return;
-                        }
-                        if (this.historicAnimation && this.historicAnimation.addPositions) {
-                            this.historicAnimation.addPositions(newPositions);
-                        }
-                    }
-                    else {
-                        // The data we want is before the range we've currently loaded.
-                        if (fetchBefore) {
-                            // Calculate the missing difference and request it.
-                            const startStr = new Date(minDateTime - TIME_PADDING_MS).toISOString();
-                            const stopStr = new Date(foundMinDateTime + TIME_PADDING_MS).toISOString();
-                            getPossesForRange(startStr, stopStr).then((newPositions) => {
-                                if (this.disposed) {
-                                    return;
-                                }
-                                if (this.historicAnimation && this.historicAnimation.addPositions) {
-                                    this.historicAnimation.addPositions(newPositions);
-                                }
-                            });
-                        }
-                        // The data we want is after the range we've currently loaded.
-                        if (fetchAfter) {
-                            // Calculate the missing difference and request it.
-                            const startStr = new Date(foundMaxDateTime - TIME_PADDING_MS).toISOString();
-                            const stopStr = new Date(maxDateTime + TIME_PADDING_MS).toISOString();
-                            getPossesForRange(startStr, stopStr).then((newPositions) => {
-                                if (this.disposed) {
-                                    return;
-                                }
-                                if (this.historicAnimation && this.historicAnimation.addPositions) {
-                                    this.historicAnimation.addPositions(newPositions);
-                                }
-                            });
-                        }
-                    }
+                    await this.historicGatherer.Gather([rootEntity]);
                 };
                 /**
                  * Requests the initial set of historic positions for the timeline range.
@@ -16746,11 +17027,8 @@
                                 res(false);
                                 return;
                             }
-                            const startTmp = Cesium.JulianDate.toDate(this.viewer.clock.startTime);
-                            const stopTmp = Cesium.JulianDate.toDate(this.viewer.clock.stopTime);
-                            const startStr = new Date(startTmp.getTime() - 1000).toISOString();
-                            const stopStr = new Date(stopTmp.getTime() + 1000).toISOString();
-                            const positions = await getPossesForRange(startStr, stopStr);
+                            const { recordsByIds } = await this.historicGatherer.Gather([rootEntity]);
+                            const positions = toPosses(recordsByIds[this.rootId] || []);
                             if (this.disposed) {
                                 res(false);
                                 return;
@@ -19531,12 +19809,11 @@
                         }
                         this.viewer.scene.requestRender();
                         exports.TilesetRenderEngine.OnTilesetReady(this.cTileset).then(() => {
-                            var _a;
                             try {
                                 if (this.disposed || this.viewer.isDestroyed()) {
                                     return;
                                 }
-                                if (this.item.ApplyStyles) {
+                                if (Manager.NeedsStyler(this.item)) {
                                     const api = this.getters.GetBruceApi();
                                     this.styler.Init({
                                         viewer: this.viewer,
@@ -19547,7 +19824,8 @@
                                         expandSources: false,
                                         menuItemId: this.item.id,
                                         register: this.visualsManager,
-                                        historic: (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic
+                                        historic: Manager.IsHistoric(this.item),
+                                        applyStyles: Boolean(this.item.ApplyStyles)
                                     });
                                 }
                                 this.onCTilesetLoad();
@@ -19754,6 +20032,19 @@
             get HandoffKey() {
                 return Manager.GetHandoffKey(this.item);
             }
+            /*
+             * Returns whether the item asks for Entities as they were at the scene time.
+             */
+            static IsHistoric(item) {
+                var _a, _b;
+                return Boolean(((_a = item === null || item === void 0 ? void 0 : item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic) || ((_b = item === null || item === void 0 ? void 0 : item.BruceEntity) === null || _b === void 0 ? void 0 : _b.historicAttrKey));
+            }
+            /*
+             * Returns whether the styler has to run, which it does for historic even without styling.
+             */
+            static NeedsStyler(item) {
+                return Boolean(item === null || item === void 0 ? void 0 : item.ApplyStyles) || Manager.IsHistoric(item);
+            }
             static GetHandoffKey(item) {
                 var _a, _b;
                 const tilesetId = (_a = item === null || item === void 0 ? void 0 : item.tileset) === null || _a === void 0 ? void 0 : _a.TilesetID;
@@ -19763,7 +20054,10 @@
                 const accountId = ((_b = item.tileset) === null || _b === void 0 ? void 0 : _b.ClientAccountID) || "";
                 // Styled <-> unstyled has no cheap revert path, force a reload instead.
                 const applyStyles = Boolean(item.ApplyStyles);
-                return `${accountId}:${tilesetId}:${applyStyles}`;
+                // Historic drives a different gather,
+                // so a handoff must not reuse a styler set up for the other mode.
+                const historic = Manager.IsHistoric(item);
+                return `${accountId}:${tilesetId}:${applyStyles}:${historic}`;
             }
             // Returns null (fall back to a normal Dispose()) if the tileset hasn't finished loading yet.
             PrepareHandoff() {
@@ -19803,7 +20097,6 @@
             // 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;
                 this.cTileset = payload.cTileset;
                 this.tileset = payload.tileset;
                 this.typeId = payload.typeId;
@@ -19835,7 +20128,7 @@
                     toPriority: this.renderPriority,
                     requestRender: false
                 });
-                if (this.item.ApplyStyles) {
+                if (Manager.NeedsStyler(this.item)) {
                     this.styler.Init({
                         viewer: this.viewer,
                         api: this.getters.GetBruceApi(),
@@ -19845,7 +20138,8 @@
                         expandSources: false,
                         menuItemId: this.item.id,
                         register: this.visualsManager,
-                        historic: (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic
+                        historic: Manager.IsHistoric(this.item),
+                        applyStyles: Boolean(this.item.ApplyStyles)
                     });
                     this.queueHandoffRestyle(this.visualsManager.GetRegos({ menuItemId: this.item.id }));
                 }
@@ -43525,7 +43819,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.2.0";
+    const VERSION = "7.2.1";
     /**
      * 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.