bruce-cesium 7.3.4 → 7.3.5

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-import { Cartographic, ShaderSource, Cartesian3, Math as Math$1, Ellipsoid, Transforms, Matrix4, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, Cartesian2, Cartesian4, ColorMaterialProperty, Color, JulianDate, Quaternion, HeadingPitchRoll, HeightReference, Entity, DistanceDisplayCondition, ColorBlendMode, CallbackProperty, ShadowMode, ConstantProperty, ClassificationType, Model, Primitive, Cesium3DTileFeature, ImageMaterialProperty, ArcType, CornerType, ConstantPositionProperty, HorizontalOrigin, VerticalOrigin, PolygonHierarchy, PolylineGraphics, Rectangle, SceneTransforms, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileColorBlendMode, Cesium3DTileset, OrthographicFrustum, EasingFunction, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Intersect, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, PolygonPipeline, GeometryInstance, CustomDataSource, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, ScreenSpaceEventHandler, ScreenSpaceEventType, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, Fullscreen, CzmlDataSource } from 'cesium';
-import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Calculator, ClientFile, Entity as Entity$1, EntityLod, EntityTag, EntityType, ObjectUtils, Style, ClientFileValueMap, Color as Color$1, Carto, Geometry as Geometry$1, Api, Bounds, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, RecordChangeFeed, BruceApi, EntityRelation, EntitySource, Camera, ProgramKey, ProjectViewLegacyTile, Account, AccountLimits, Session, UrlUtils, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType, EntityHistoricData } from 'bruce-models';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, HeightReference, DistanceDisplayCondition, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, Matrix4, ShaderSource, Ellipsoid, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, Cartesian2, Cartesian4, ClassificationType, ArcType, CornerType, ShadowMode, ConstantPositionProperty, ColorBlendMode, Model, HorizontalOrigin, VerticalOrigin, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, SceneTransforms, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, SceneMode, Ion, IonResource, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileset, Intersect, Cesium3DTileColorBlendMode, OrthographicFrustum, EasingFunction, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, PolygonPipeline, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, CustomDataSource, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, ScreenSpaceEventHandler, ScreenSpaceEventType, GeometryInstance, Fullscreen, CzmlDataSource } from 'cesium';
+import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Calculator, Carto, Entity as Entity$1, EntityTag, EntityType, Geometry as Geometry$1, ObjectUtils, Style, ClientFile, EntityLod, Api, Bounds, ClientFileValueMap, Color as Color$1, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, BruceApi, RecordChangeFeed, EntityRelation, EntitySource, Camera, ProgramKey, ProjectViewLegacyTile, Account, AccountLimits, Session, UrlUtils, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType, EntityHistoricData } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -182,6 +182,37 @@ var DrawingUtils;
         };
     }
     DrawingUtils.PointAcrossPolyline = PointAcrossPolyline;
+    const _sampledTerrain = new LRUCache(4000);
+    const _samplingTerrain = new Map();
+    // How precisely a sample is keyed. Roughly a metre, well under the resolution of any terrain we
+    // serve, so a camera that has not really moved asks the same question.
+    const SAMPLE_KEY_DECIMALS = 5;
+    // Identity for the provider a sample came from. Keyed on the object rather than on the tileset it
+    // was built from, so swapping terrain invalidates every height held against the old one.
+    const _providerIds = new WeakMap();
+    let _nextProviderId = 1;
+    /*
+     * Returns a stable id for a terrain provider, assigning one on first sight.
+     */
+    function terrainProviderId(provider) {
+        if (!provider) {
+            return 0;
+        }
+        let id = _providerIds.get(provider);
+        if (id == null) {
+            id = _nextProviderId++;
+            _providerIds.set(provider, id);
+        }
+        return id;
+    }
+    /**
+     * Empties the sampled terrain heights. For a terrain provider swap, or a test.
+     */
+    function ClearSampledTerrain() {
+        _sampledTerrain.Clear();
+        _samplingTerrain.clear();
+    }
+    DrawingUtils.ClearSampledTerrain = ClearSampledTerrain;
     /**
      * Returns terrain height from current viewer's provider.
      * On error or flat terrain, it will return 0.
@@ -205,17 +236,36 @@ var DrawingUtils;
                     height: 0
                 };
             }
-            const sample = await sampleTerrainMostDetailed(viewer.scene.terrainProvider, [Cartographic.fromCartesian(pos3d)]);
-            const height = (sample === null || sample === void 0 ? void 0 : sample.length) ? sample[0].height : null;
-            if (isNaN(height)) {
-                return {
-                    height: 0,
-                    error: "NaN"
-                };
-            }
-            return {
-                height: height
-            };
+            const carto = Cartographic.fromCartesian(pos3d);
+            const key = `${terrainProviderId(viewer.scene.terrainProvider)}`
+                + `_${carto.longitude.toFixed(SAMPLE_KEY_DECIMALS)}`
+                + `_${carto.latitude.toFixed(SAMPLE_KEY_DECIMALS)}`;
+            const held = _sampledTerrain.Get(key);
+            if (held != null) {
+                return { height: held };
+            }
+            // Two callers on the same point wait on the one sample rather than each asking for it.
+            const sampling = _samplingTerrain.get(key);
+            if (sampling) {
+                return sampling;
+            }
+            const prom = sampleTerrainMostDetailed(viewer.scene.terrainProvider, [carto])
+                .then((sample) => {
+                const height = (sample === null || sample === void 0 ? void 0 : sample.length) ? sample[0].height : null;
+                if (height == null || isNaN(height)) {
+                    return {
+                        height: 0,
+                        error: "NaN"
+                    };
+                }
+                _sampledTerrain.Set(key, height);
+                return { height: height };
+            })
+                .finally(() => {
+                _samplingTerrain.delete(key);
+            });
+            _samplingTerrain.set(key, prom);
+            return prom;
         }
         catch (e) {
             return {
@@ -11014,6 +11064,22 @@ var HistoricFetchOrder;
         return Math.round(minMs + ((maxMs - minMs) * progress));
     }
     HistoricFetchOrder.IntervalFor = IntervalFor;
+    /**
+     * Returns the cadence for a set of this size on a clock running at this rate.
+     * @param entityCount
+     * @param multiplier the viewer clock's, ie. scene seconds per real second
+     */
+    function IntervalForClock(entityCount, multiplier) {
+        const bySize = IntervalFor(entityCount);
+        const rate = Math.abs(multiplier);
+        if (!(rate > 0)) {
+            return HistoricFetchOrder.MAX_INTERVAL_MS;
+        }
+        // How long one second of scene time takes to pass, which is how often a record can appear.
+        const perRecord = 1000 / rate;
+        return Math.min(HistoricFetchOrder.MAX_INTERVAL_MS, Math.max(bySize, perRecord));
+    }
+    HistoricFetchOrder.IntervalForClock = IntervalForClock;
     // Upper bounds in metres for the distance bands, nearest first.
     HistoricFetchOrder.DEFAULT_BANDS = [500, 2000, 10000, 50000];
     /**
@@ -11396,7 +11462,8 @@ class HistoricGatherer {
      * Returns how long to wait between refreshes for a set of this size.
      */
     IntervalFor(entityCount) {
-        return HistoricFetchOrder.IntervalFor(entityCount);
+        var _a, _b, _c;
+        return HistoricFetchOrder.IntervalForClock(entityCount, (_c = (_b = (_a = this.params.viewer) === null || _a === void 0 ? void 0 : _a.clock) === null || _b === void 0 ? void 0 : _b.multiplier) !== null && _c !== void 0 ? _c : 1);
     }
     /**
      * Fetches whatever the current clock range needs that is not already held.
@@ -13722,6 +13789,7 @@ var EntitiesIdsRenderManager;
             this.renderQueueForceFlags = [];
             this.reRenderState = new EntityReRenderMaintainState();
             const { viewer, apiGetter, monitor, item, register: visualsManager } = params;
+            this.sharedHistoric = params.sharedHistoric;
             this.viewer = viewer;
             this.apiGetter = apiGetter;
             this.monitor = monitor;
@@ -13856,6 +13924,51 @@ var EntitiesIdsRenderManager;
                 this.onGetterUpdate(entityIds);
             }
         }
+        /*
+         * The lane this item reads through, or null when it does not follow the clock.
+         */
+        getHistoricLane() {
+            var _a, _b, _c;
+            if (!this.sharedHistoric ||
+                (!((_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic) && !((_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b.historicAttrKey))) {
+                return null;
+            }
+            if (!this.historicLane) {
+                const historicKey = (_c = this.item.BruceEntity) === null || _c === void 0 ? void 0 : _c.historicAttrKey;
+                this.historicLane = this.sharedHistoric.GetOrCreateLane({
+                    baseUrl: this.apiGetter.getApi().GetBaseUrl(),
+                    attrKey: historicKey,
+                    getMinIntervalMs: () => this.historicGatherer.IntervalFor(Object.keys(this.renderedEntities).length),
+                    subscribeToChanges: (onChanged) => {
+                        var _a;
+                        const feed = (_a = this.apiGetter.getApi()) === null || _a === void 0 ? void 0 : _a.RecordChangeFeed;
+                        if (!feed) {
+                            return null;
+                        }
+                        return feed.Subscribe({
+                            concepts: [AccountConcept.EConcept.ENTITY],
+                            actions: ["C", "U"]
+                        }, (event) => {
+                            if (typeof event.data === "string" && event.data) {
+                                onChanged(event.data);
+                            }
+                        });
+                    },
+                    isFeedConnected: () => { var _a, _b; return Boolean((_b = (_a = this.apiGetter.getApi()) === null || _a === void 0 ? void 0 : _a.RecordChangeFeed) === null || _b === void 0 ? void 0 : _b.IsConnected); },
+                    read: (entityIds, at) => Entity$1.GetListByIds({
+                        api: this.apiGetter.getApi(),
+                        entityIds: entityIds,
+                        historicPoint: new Date(at).toISOString(),
+                        historicKey: historicKey,
+                        expandSources: true,
+                        expandLocation: true,
+                        migrated: true,
+                        maxSearchTimeSec: 60 * 5,
+                    }).then(res => res.entities || [])
+                });
+            }
+            return this.historicLane;
+        }
         async onGetterUpdate(entityIds, force = false) {
             var _a, _b;
             if (this.disposed || this.viewer.isDestroyed() || !(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
@@ -13877,25 +13990,23 @@ var EntitiesIdsRenderManager;
                 if (!apiIds.length) {
                     return;
                 }
-                const api = this.apiGetter.getApi();
                 const revisions = this.reRenderState.captureApiRevisions(apiIds);
-                let newDateTime = null;
-                if (this.item.BruceEntity.historic || this.item.BruceEntity.historicAttrKey) {
-                    newDateTime = JulianDate.toDate(this.viewer.clock.currentTime).toISOString();
-                }
-                const { entities } = await Entity$1.GetListByIds({
-                    api,
-                    entityIds: apiIds,
-                    historicPoint: newDateTime,
-                    historicKey: this.item.BruceEntity.historicAttrKey,
-                    expandSources: true,
-                    expandLocation: true,
-                    migrated: true,
-                    // If we're taking 5+ minutes to make a query, it's a dud.
-                    // This is a timeout imposed on our DB and not external sources.
-                    // Honestly could lower down to 30 seconds, but we'll keep it high for now.
-                    maxSearchTimeSec: 60 * 5,
-                });
+                const lane = this.getHistoricLane();
+                const entities = lane
+                    ? await lane.Request({
+                        subscriberId: this.item.id,
+                        entityIds: apiIds,
+                        at: JulianDate.toDate(this.viewer.clock.currentTime).getTime(),
+                        force: force
+                    })
+                    : (await Entity$1.GetListByIds({
+                        api: this.apiGetter.getApi(),
+                        entityIds: apiIds,
+                        expandSources: true,
+                        expandLocation: true,
+                        migrated: true,
+                        maxSearchTimeSec: 60 * 5,
+                    })).entities;
                 const resolved = this.reRenderState.filterCurrentApiEntities({
                     entities,
                     revisions
@@ -14111,6 +14222,7 @@ var EntitiesIdsRenderManager;
                     return;
                 }
                 prevTick = currentTick;
+                queue.delay = this.historicGatherer.IntervalFor(Object.keys(this.renderedEntities).length);
                 queue.Call();
             });
             this.viewerDateTimeChangeRemoval = () => {
@@ -14123,9 +14235,11 @@ var EntitiesIdsRenderManager;
             };
         }
         viewerDateTimeDispose() {
-            var _a;
+            var _a, _b;
             (_a = this.viewerDateTimeChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
             this.viewerDateTimeChangeRemoval = null;
+            // Whatever this item was waiting on is nobody's answer now.
+            (_b = this.historicLane) === null || _b === void 0 ? void 0 : _b.Drop(this.item.id);
         }
     }
     EntitiesIdsRenderManager.Manager = Manager;
@@ -19547,6 +19661,351 @@ var DataLabRenderManager;
     DataLabRenderManager.Manager = Manager;
 })(DataLabRenderManager || (DataLabRenderManager = {}));
 
+/**
+ * The shared read path for Entities whose position comes from the clock.
+ */
+var SharedHistoricGetters;
+(function (SharedHistoricGetters) {
+    // The floor between two reads on a lane, so a fast server is not read from as fast as it answers.
+    SharedHistoricGetters.DEFAULT_MIN_INTERVAL_MS = 250;
+    // How far from a held answer's instant it still answers a new ask.
+    SharedHistoricGetters.DEFAULT_FRESH_MS = 200;
+    // How slow the idle backoff is allowed to make a lane.
+    SharedHistoricGetters.DEFAULT_MAX_INTERVAL_MS = 3000;
+    // How many unchanged reads it takes to reach that, doubling the wait each time.
+    SharedHistoricGetters.IDLE_DOUBLINGS = 6;
+    // The idle cap while a record change feed is connected.
+    SharedHistoricGetters.FEED_MAX_INTERVAL_MS = 15000;
+    /*
+     * What an Entity looks like to the idle check: where it is, how it is turned, and when it was last written.
+     */
+    function SignatureOf(entity) {
+        const bruce = entity === null || entity === void 0 ? void 0 : entity.Bruce;
+        if (!bruce) {
+            return "";
+        }
+        const location = bruce.Location;
+        const transform = bruce.Transform;
+        return [
+            bruce.Updated || "",
+            location ? `${location.latitude},${location.longitude},${location.altitude}` : "",
+            transform ? `${transform.heading},${transform.pitch},${transform.roll}` : ""
+        ].join("|");
+    }
+    SharedHistoricGetters.SignatureOf = SignatureOf;
+    /**
+     * One read path, shared by every manager reading the same Entities the same way.
+     */
+    class Lane {
+        constructor(params) {
+            this.params = params;
+            // Subscriber to their one outstanding ask.
+            this.pending = new Map();
+            this.inFlight = false;
+            this.lastSentAt = 0;
+            this.pumpTimeout = null;
+            // Set between an ask arriving and the pump running, so asks made in the same turn merge.
+            this.pumpScheduled = false;
+            this.disposed = false;
+            // The last answer, kept so an ask that lands beside it is served rather than sent.
+            this.held = null;
+            // Entity id to what it looked like on the last read, for deciding whether anything moved.
+            this.heldSignatures = {};
+            // How many reads in a row have come back saying the same thing.
+            this.idleReads = 0;
+            // Entity internal id to its id, for matching what the feed reports against what is held.
+            this.heldInternalIds = new Map();
+            this.feedRemoval = null;
+            this.feedWired = false;
+        }
+        /**
+         * Asks for these Entities at this instant, resolving with them however the lane gets there:
+         * from the held answer, from a read already about to happen, or from one this ask starts.
+         */
+        Request(ask) {
+            if (this.disposed) {
+                return Promise.resolve([]);
+            }
+            this.wireFeed();
+            if (ask.force) {
+                this.idleReads = 0;
+            }
+            const fresh = this.freshAnswerFor(ask);
+            if (fresh) {
+                return Promise.resolve(fresh);
+            }
+            return new Promise((resolve, reject) => {
+                // Whoever was waiting on this subscriber's previous ask is answered by this one, so
+                // they are handed the newer read rather than left hanging on a dropped request.
+                const superseded = this.pending.get(ask.subscriberId);
+                this.pending.set(ask.subscriberId, {
+                    ask,
+                    resolve: (entities) => {
+                        superseded === null || superseded === void 0 ? void 0 : superseded.resolve(entities);
+                        resolve(entities);
+                    },
+                    reject: (error) => {
+                        superseded === null || superseded === void 0 ? void 0 : superseded.reject(error);
+                        reject(error);
+                    }
+                });
+                this.schedulePump();
+            });
+        }
+        /**
+         * Forgets a subscriber, for a manager that has been disposed while it was waiting.
+         */
+        Drop(subscriberId) {
+            const waiter = this.pending.get(subscriberId);
+            if (waiter) {
+                this.pending.delete(subscriberId);
+                waiter.resolve([]);
+            }
+        }
+        /**
+         * Tells the lane that records it holds have changed, so its next read happens on the caller's
+         * cadence rather than behind whatever backoff a quiet spell had earned.
+         */
+        NotifyChanged() {
+            if (this.disposed) {
+                return;
+            }
+            this.idleReads = 0;
+            this.schedulePump();
+        }
+        /**
+         * The same, for a feed event naming Entity internal ids as ranges.
+         * @param rangeString as reported by the record change feed.
+         */
+        NotifyChangedRange(rangeString) {
+            if (this.disposed || !rangeString || !this.heldInternalIds.size) {
+                return;
+            }
+            for (const internalId of Array.from(this.heldInternalIds.keys())) {
+                if (RecordChangeFeed.isEntityInternalIdInRangeString(rangeString, internalId)) {
+                    this.NotifyChanged();
+                    return;
+                }
+            }
+        }
+        Dispose() {
+            var _a;
+            this.disposed = true;
+            (_a = this.feedRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.feedRemoval = null;
+            if (this.pumpTimeout != null) {
+                clearTimeout(this.pumpTimeout);
+                this.pumpTimeout = null;
+            }
+            for (const waiter of Array.from(this.pending.values())) {
+                waiter.resolve([]);
+            }
+            this.pending.clear();
+            this.held = null;
+            this.heldSignatures = {};
+            this.heldInternalIds.clear();
+        }
+        /**
+         * How many reads in a row have come back unchanged, which is what the wait is scaled by.
+         */
+        get IdleReads() {
+            return this.idleReads;
+        }
+        /**
+         * The wait the lane would apply before its next read,
+         * ie. the caller's cadence after however far the idle backoff has widened it.
+         */
+        get IntervalMs() {
+            return this.intervalNow();
+        }
+        /**
+         * What the lane is currently holding, for a caller that wants it without asking for a read.
+         */
+        get Held() {
+            return this.held;
+        }
+        /*
+         * The wait before the next read: the caller's cadence, widened while nothing is changing.
+         */
+        intervalNow() {
+            var _a, _b, _c;
+            const base = this.params.getMinIntervalMs
+                ? this.params.getMinIntervalMs() : SharedHistoricGetters.DEFAULT_MIN_INTERVAL_MS;
+            if (!this.idleReads) {
+                return base;
+            }
+            const maxInterval = (_a = this.params.maxIntervalMs) !== null && _a !== void 0 ? _a : (((_c = (_b = this.params).isFeedConnected) === null || _c === void 0 ? void 0 : _c.call(_b)) ? SharedHistoricGetters.FEED_MAX_INTERVAL_MS : SharedHistoricGetters.DEFAULT_MAX_INTERVAL_MS);
+            const widened = base * Math.pow(2, Math.min(this.idleReads, SharedHistoricGetters.IDLE_DOUBLINGS));
+            return Math.min(Math.max(base, maxInterval), widened);
+        }
+        /*
+         * Returns the held answer when it covers this ask, or null when a read is needed.
+         */
+        freshAnswerFor(ask) {
+            var _a;
+            const freshMs = (_a = this.params.freshMs) !== null && _a !== void 0 ? _a : SharedHistoricGetters.DEFAULT_FRESH_MS;
+            if (ask.force || !this.held || Math.abs(ask.at - this.held.at) > freshMs) {
+                return null;
+            }
+            const entities = [];
+            for (const entityId of ask.entityIds) {
+                const entity = this.held.byId[entityId];
+                // A partial answer is not an answer: the Entity may simply never have been asked for.
+                if (!entity) {
+                    return null;
+                }
+                entities.push(entity);
+            }
+            return entities;
+        }
+        /*
+         * Subscribes to the record change feed, on the first ask that finds one.
+         */
+        wireFeed() {
+            if (this.feedWired || !this.params.subscribeToChanges) {
+                return;
+            }
+            const removal = this.params.subscribeToChanges((rangeString) => this.NotifyChangedRange(rangeString));
+            if (!removal) {
+                return;
+            }
+            this.feedWired = true;
+            this.feedRemoval = removal;
+        }
+        /*
+         * Runs the pump at the end of this turn rather than during it.
+         */
+        schedulePump() {
+            if (this.pumpScheduled || this.disposed) {
+                return;
+            }
+            this.pumpScheduled = true;
+            Promise.resolve().then(() => {
+                this.pumpScheduled = false;
+                this.pump();
+            });
+        }
+        /*
+         * Sends the next read when there is one to send and the lane is free to send it.
+         */
+        pump() {
+            var _a;
+            if (this.disposed || this.inFlight || !this.pending.size) {
+                return;
+            }
+            const now = ((_a = this.params.now) !== null && _a !== void 0 ? _a : Date.now)();
+            const waitFor = (this.lastSentAt + this.intervalNow()) - now;
+            if (waitFor > 0) {
+                // The pending map keeps absorbing asks meanwhile, so what eventually goes is the
+                // union of everything wanted during the wait rather than the ask that started it.
+                if (this.pumpTimeout == null) {
+                    this.pumpTimeout = setTimeout(() => {
+                        this.pumpTimeout = null;
+                        this.pump();
+                    }, waitFor);
+                }
+                return;
+            }
+            // Taken now rather than when each ask arrived, which is what makes an overtaken ask cost
+            // nothing: it is simply part of this read instead of a read of its own.
+            const waiters = Array.from(this.pending.values());
+            this.pending.clear();
+            const entityIds = [];
+            const seen = {};
+            let at = 0;
+            for (const waiter of waiters) {
+                at = Math.max(at, waiter.ask.at);
+                for (const entityId of waiter.ask.entityIds) {
+                    if (entityId && !seen[entityId]) {
+                        seen[entityId] = true;
+                        entityIds.push(entityId);
+                    }
+                }
+            }
+            if (!entityIds.length) {
+                for (const waiter of waiters) {
+                    waiter.resolve([]);
+                }
+                return;
+            }
+            this.inFlight = true;
+            this.lastSentAt = now;
+            this.params.read(entityIds, at).then((entities) => {
+                var _a, _b, _c;
+                const signatureOf = (_a = this.params.signatureOf) !== null && _a !== void 0 ? _a : SignatureOf;
+                const byId = {};
+                let changed = false;
+                for (const entity of entities || []) {
+                    const id = (_b = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _b === void 0 ? void 0 : _b.ID;
+                    if (!id) {
+                        continue;
+                    }
+                    byId[id] = entity;
+                    const internalId = (_c = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _c === void 0 ? void 0 : _c.InternalID;
+                    if (internalId != null) {
+                        this.heldInternalIds.set(internalId, id);
+                    }
+                    const signature = signatureOf(entity);
+                    // An Entity read for the first time is not a change: there is nothing it differs
+                    // from, and counting it as one would restart the backoff on every widened set.
+                    if (this.heldSignatures[id] != null && this.heldSignatures[id] !== signature) {
+                        changed = true;
+                    }
+                    this.heldSignatures[id] = signature;
+                }
+                this.idleReads = changed ? 0 : this.idleReads + 1;
+                this.held = { at, byId };
+                for (const waiter of waiters) {
+                    waiter.resolve(waiter.ask.entityIds.map(id => byId[id]).filter(x => !!x));
+                }
+            }).catch((error) => {
+                for (const waiter of waiters) {
+                    waiter.reject(error);
+                }
+            }).finally(() => {
+                this.inFlight = false;
+                this.schedulePump();
+            });
+        }
+    }
+    SharedHistoricGetters.Lane = Lane;
+    /**
+     * The lanes in play, keyed so that two managers reading the same Entities the same way land on the same one.
+     */
+    class Cache {
+        constructor() {
+            this.lanes = {};
+        }
+        /**
+         * Returns the lane for this endpoint and attribute key, creating it on first use.
+         * @param params
+         */
+        GetOrCreateLane(params) {
+            const key = `${params.baseUrl}|${params.attrKey || ""}`;
+            let lane = this.lanes[key];
+            if (!lane) {
+                lane = new Lane({
+                    read: params.read,
+                    getMinIntervalMs: params.getMinIntervalMs,
+                    freshMs: params.freshMs,
+                    maxIntervalMs: params.maxIntervalMs,
+                    subscribeToChanges: params.subscribeToChanges,
+                    isFeedConnected: params.isFeedConnected
+                });
+                this.lanes[key] = lane;
+            }
+            return lane;
+        }
+        Dispose() {
+            for (const key of Object.keys(this.lanes)) {
+                this.lanes[key].Dispose();
+            }
+            this.lanes = {};
+        }
+    }
+    SharedHistoricGetters.Cache = Cache;
+})(SharedHistoricGetters || (SharedHistoricGetters = {}));
+
 const DEFAULT_GROUNDED_HEIGHT = 300;
 const MINIMUM_VIEW_AREA_SIZE_DEGREES = 0.01;
 const NET_STEP_PERCENT = 5;
@@ -24898,6 +25357,7 @@ var MenuItemManager;
             }
             this.visualsRegister = visualsRegister;
             this.sharedGetters = new SharedGetters.Cache();
+            this.sharedHistoric = new SharedHistoricGetters.Cache();
             this.sharedMonitor = new CesiumViewMonitor.Monitor(this.viewer);
             this.tilesetInitQueue = new InitQueueTileset(this.getters);
         }
@@ -24906,7 +25366,7 @@ var MenuItemManager;
          * This will dispose all render managers and unregister all menu items.
          */
         Dispose(params) {
-            var _a, _b;
+            var _a, _b, _c;
             const { disposeRegister } = params !== null && params !== void 0 ? params : {};
             for (let i = 0; i < this.items.length; i++) {
                 const item = this.items[i];
@@ -24921,6 +25381,7 @@ var MenuItemManager;
             this.FlushPendingHandoffs();
             this.tilesetInitQueue.Dispose();
             (_b = this.sharedMonitor) === null || _b === void 0 ? void 0 : _b.Dispose();
+            (_c = this.sharedHistoric) === null || _c === void 0 ? void 0 : _c.Dispose();
             if (this.visualsRegister && disposeRegister != false) {
                 this.visualsRegister.Dispose();
             }
@@ -25128,7 +25589,8 @@ var MenuItemManager;
                             register: this.visualsRegister,
                             apiGetter: params.apiGetter,
                             monitor: this.sharedMonitor,
-                            item: params.item
+                            item: params.item,
+                            sharedHistoric: this.sharedHistoric
                         });
                         break;
                     case MenuItem.EType.Entity:
@@ -47052,7 +47514,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.3.4";
+const VERSION = "7.3.5";
 /**
  * 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.