bruce-cesium 7.6.0 → 7.6.2

package/dist/types/rendering/relation-render-engine.d.ts

@@ -1,4 +1,5 @@
 import { BruceApi, Entity, EntityRelation, IDictionary, Style } from "bruce-models";
+import { EntitySimulation } from "./render-managers/common/entity-simulation";
 import { VisualsRegister } from "./visuals-register";
 import * as Cesium from "cesium";
 export declare namespace RelationRenderEngine {
@@ -9,12 +10,21 @@ export declare namespace RelationRenderEngine {
         _dispose: () => void;
     }
     function GetRenderGroupId(relation: EntityRelation.IRelation): string;
+    /**
+     * Removes and returns a menu item's drawn relations that end at, or carry data from, any of these Entities.
+     */
+    function TakeRelationsTouching(params: {
+        visualRegister: VisualsRegister.Register;
+        menuItemId: string;
+        entityIds: string[];
+    }): EntityRelation.IRelation[];
     function Render(params: {
         apiGetter: BruceApi.IGetter;
         viewer: Cesium.Viewer;
         visualRegister: VisualsRegister.Register;
         menuItemId: string;
         relations: EntityRelation.IRelation[];
+        simulation?: EntitySimulation.Store;
     }): Promise<IDictionary<ICesiumEntityExt>>;
     namespace Parabola {
         interface IParabola {

package/dist/types/rendering/render-managers/common/entity-label-group.d.ts

@@ -1,5 +1,6 @@
 import { BruceApi, Calculator, DataLab, Entity } from "bruce-models";
 import { EntityLabel } from "./entity-label";
+import { EntitySimulation } from "./entity-simulation";
 import type { VisualsRegister } from "../../visuals-register";
 export declare namespace EntityLabelGroup {
     interface IOptions extends Omit<EntityLabel.IOptions, "text" | "icon" | "iconUrl" | "iconClass" | "iconColor" | "iconBackground" | "iconPriority" | "iconStatus" | "iconScale" | "iconPhoto" | "photo"> {
@@ -73,8 +74,8 @@ export declare namespace EntityLabelGroup {
      * Returns if we need to resolve Entity data to create the label data.
      */
     function NeedsEntityData(options?: IOptions): boolean;
-    function Hydrate(items: IItem[], api?: BruceApi.Api, signal?: AbortSignal): Promise<IItem[]>;
-    function Loader(source: TSource, api?: BruceApi.Api, signal?: AbortSignal, hydrate?: boolean): Promise<(offset: number, limit: number, signal: AbortSignal) => Promise<IPage>>;
+    function Hydrate(items: IItem[], api?: BruceApi.Api, signal?: AbortSignal, simulation?: EntitySimulation.Store): Promise<IItem[]>;
+    function Loader(source: TSource, api?: BruceApi.Api, signal?: AbortSignal, hydrate?: boolean, simulation?: EntitySimulation.Store): Promise<(offset: number, limit: number, signal: AbortSignal) => Promise<IPage>>;
     class Manager {
         private register;
         private changed;

package/dist/types/rendering/render-managers/common/entity-label.d.ts

@@ -91,6 +91,7 @@ export declare namespace EntityLabel {
         iconRadius?: number;
         modelBox?: IModelBoxFrame;
         boxBlend?: number;
+        follows?: boolean;
         id: string;
         text?: string;
         clusterBounds?: {
@@ -215,6 +216,7 @@ export declare namespace EntityLabel {
         selected: () => boolean;
         hovered: () => boolean;
         near: () => boolean;
+        motion?: () => Cesium.Matrix4 | null;
     }
     export class ModelBoxes {
         private entries;
@@ -229,6 +231,8 @@ export declare namespace EntityLabel {
         private looks;
         private memberLooks;
         Set(id: string, corners: Cesium.Cartesian3[], entityId: string, inputs: IModelBoxEntry): void;
+        private forget;
+        private follow;
         Frame(id: string): IModelBoxFrame;
         Hull(id: string): TPoint[];
         Request(id: string, request: IModelBoxRequest): void;
@@ -299,6 +303,7 @@ export declare namespace EntityLabel {
          * Recalling will be ignored.
          */
         Dispose(): void;
+        Reload(): void;
         Configure(options?: IOptions, groupId?: string): void;
         /**
          * Creates cesium entity for the label if one does not exist.

package/dist/types/rendering/render-managers/common/entity-rerender-maintain-state.d.ts

@@ -1,9 +1,29 @@
 import { Entity, IDictionary } from "bruce-models";
+import { EntitySimulation } from "./entity-simulation";
+/**
+ * The instant and historic key a manager reads its Entities at, or null to read them as they are now.
+ */
+export type TPointInTime = () => {
+    timeMs: number;
+    attrKey?: string;
+} | null;
 /**
  * Tracks per-entity rerender state for unsaved blob maintenance and stale API response suppression.
  */
 export declare class EntityReRenderMaintainState {
+    private simulation?;
+    private pointInTime?;
     private maintainedEntitiesById;
+    constructor(simulation?: EntitySimulation.Store, pointInTime?: TPointInTime);
+    private atPoint;
+    /**
+     * Whether a simulated stand-in replaces this Entity, so nothing from the API may replace what is drawn.
+     */
+    isSimulated(entityId: string): boolean;
+    /**
+     * Swaps any simulated Entity in a set the API returned for its stand-in, or lays its patch over it.
+     */
+    withSimulated(entities: Entity.IEntity[]): Entity.IEntity[];
     private apiRevisionByEntityId;
     private skipApiRunByEntityId;
     private checkRunId;

package/dist/types/rendering/render-managers/common/entity-simulation.d.ts

@@ -0,0 +1,126 @@
+import * as Cesium from "cesium";
+import { BruceEvent, Entity, EntityHistoricData, IDictionary } from "bruce-models";
+/**
+ * Entity data a caller asserts instead of what the API says, held for every menu item until it is cleared.
+ */
+export declare namespace EntitySimulation {
+    /**
+     * The set used when a caller does not name one.
+     */
+    const DEFAULT_SET = "default";
+    /**
+     * The store for a viewer, made on first use and shared by everything drawing into that scene.
+     */
+    function Get(viewer: Cesium.Viewer): Store | null;
+    interface IChange {
+        entityIds: string[];
+        entities: boolean;
+        records: boolean;
+        set: string | null;
+    }
+    /**
+     * 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<T>(base: T, patch: any, whole?: Set<string>): T;
+    class Store {
+        private sets;
+        private onChanged;
+        /**
+         * Triggered after anything is simulated or cleared, naming the Entities affected.
+         */
+        get OnChanged(): BruceEvent<IChange>;
+        /**
+         * Whether anything at all is simulated, so a caller can skip the work when nothing is.
+         */
+        get IsEmpty(): boolean;
+        /**
+         * The names of the sets holding anything, oldest first.
+         */
+        GetSets(): string[];
+        /**
+         * The time each set's records span, oldest set first, for sets holding any records.
+         */
+        GetSetRanges(): {
+            set: string;
+            startMs: number;
+            endMs: number;
+            entityIds: string[];
+        }[];
+        private setFor;
+        /**
+         * Replaces the stand-in for each Entity given, within a set.
+         */
+        SetEntities(entities: Entity.IEntity[], set?: string): void;
+        /**
+         * Replaces the patch for each Entity given, within a set. A patch names only the data it changes.
+         */
+        SetPatches(patches: Entity.IEntity[], set?: string): void;
+        private setBlobs;
+        /**
+         * Adds records to each Entity's simulated history within a set, replacing any at the same instant.
+         */
+        SetRecords(records: EntityHistoricData.IData[], set?: string): void;
+        /**
+         * 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?: {
+            set?: string;
+            entityIds?: string[];
+            entities?: boolean;
+            records?: boolean;
+        }): void;
+        /**
+         * The Entity's stand-in, with any patches laid over it, or null when nothing stands in for it.
+         */
+        GetEntity(entityId: string): Entity.IEntity | null;
+        /**
+         * Whether a stand-in replaces this Entity, so the API need not be asked for it.
+         */
+        HasEntity(entityId: string): boolean;
+        /**
+         * Whether a stand-in or a patch changes this Entity.
+         */
+        HasBlob(entityId: string): boolean;
+        /**
+         * Returns an Entity with its simulated patches laid over it. The input is never changed.
+         */
+        Overlay(entity: Entity.IEntity): Entity.IEntity;
+        /**
+         * 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: string, read?: Entity.IEntity): Entity.IEntity | null;
+        /**
+         * Every Entity with a simulated stand-in or patch.
+         */
+        GetEntityIds(): string[];
+        /**
+         * Every Entity with simulated history.
+         */
+        GetRecordEntityIds(): string[];
+        /**
+         * An Entity's simulated history for a historic key, oldest first, every set's record at an instant merged.
+         */
+        GetRecords(entityId: string, attrKey?: string): EntityHistoricData.IData[];
+        /**
+         * Each value an Entity's simulated history names, with the instant from which it is the simulation's.
+         */
+        private ownedFrom;
+        /**
+         * 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: Entity.IEntity, timeMs: number, attrKey?: string): Entity.IEntity;
+        /**
+         * API records with the simulated ones joined in, for the named Entities or every simulated one.
+         */
+        MergeRecords(recordsByIds: IDictionary<EntityHistoricData.IData[]>, attrKey?: string, entityIds?: string[]): IDictionary<EntityHistoricData.IData[]>;
+    }
+}

package/dist/types/rendering/render-managers/common/historic-trail.d.ts

@@ -0,0 +1,30 @@
+import * as Cesium from "cesium";
+/**
+ * The line drawn through where a moving thing has been, from its history, as a whole path or a fading trail.
+ */
+export declare namespace HistoricTrail {
+    interface IParams {
+        viewer: Cesium.Viewer;
+        color: Cesium.Color;
+        width: number;
+        clampToGround: boolean;
+        getSeries: () => Cesium.Cartesian3[];
+        trailSeconds?: number;
+        positionAt?: (timeMs: number) => Cesium.Cartesian3 | null;
+    }
+    /**
+     * The trail length a menu item asks for in its historicTrackSeconds, or null for the whole path.
+     */
+    function GetTrailSeconds(item: object | null | undefined): number | null;
+    class Trail {
+        private viewer;
+        private entities;
+        private memoTime;
+        private memo;
+        constructor(params: IParams);
+        private add;
+        private sample;
+        private slice;
+        Dispose(): void;
+    }
+}

package/dist/types/rendering/render-managers/common/historic-utils.d.ts

@@ -1,6 +1,7 @@
 import * as Cesium from "cesium";
 import { Bounds, BruceApi, Entity, EntityHistoricData, IDictionary } from "bruce-models";
 import { CesiumViewMonitor } from "../../../viewer/cesium-view-monitor";
+import { EntitySimulation } from "./entity-simulation";
 /**
  * How often a historic refresh is worth running, and which Entities it should ask about first.
  */
@@ -177,6 +178,8 @@ export declare class HistoricGatherer {
         onRecords?: (recordsByIds: IDictionary<EntityHistoricData.IData[]>) => void;
         paddingMs?: number;
         liveTailMs?: number;
+        simulation?: EntitySimulation.Store;
+        simulatedOnly?: boolean;
     });
     get Records(): IDictionary<EntityHistoricData.IData[]>;
     Clear(): void;
@@ -193,6 +196,7 @@ export declare class HistoricGatherer {
         fetched: boolean;
         recordsByIds: IDictionary<EntityHistoricData.IData[]>;
     }>;
+    private withSimulated;
     private holdTo;
     private request;
 }

package/dist/types/rendering/render-managers/entities/entities-datalab-render-manager.d.ts

@@ -3,6 +3,7 @@ import * as Cesium from "cesium";
 import { VisualsRegister } from "../../visuals-register";
 import { RenderManager } from "../render-manager";
 import { CesiumViewMonitor } from "../../../viewer/cesium-view-monitor";
+import { EntitySimulation } from "../common/entity-simulation";
 export declare namespace DataLabRenderManager {
     class Manager implements RenderManager.IManager, RenderManager.IHandoffCapableManager, RenderManager.IHandoffReceiver {
         private viewer;
@@ -31,6 +32,7 @@ export declare namespace DataLabRenderManager {
             apiGetter: BruceApi.IGetter;
             monitor: CesiumViewMonitor.Monitor;
             visualsRegister: VisualsRegister.Register;
+            simulation?: EntitySimulation.Store;
         });
         Init(params?: {
             item?: MenuItem.Item.IDataLab;

package/dist/types/rendering/render-managers/entities/entities-ids-render-manager.d.ts

@@ -4,6 +4,7 @@ import { CesiumViewMonitor } from "../../../viewer/cesium-view-monitor";
 import { VisualsRegister } from "../../visuals-register";
 import { RenderManager } from "../render-manager";
 import { SharedHistoricGetters } from "../common/shared-getters-historic";
+import { EntitySimulation } from "../common/entity-simulation";
 /**
  * Render manager for rendering an array of entity ids.
  * This will render them in batches to avoid overloading the viewer.
@@ -40,6 +41,7 @@ export declare namespace EntitiesIdsRenderManager {
             monitor: CesiumViewMonitor.Monitor;
             item: MenuItem.Item.IEntityIds;
             sharedHistoric?: SharedHistoricGetters.Cache;
+            simulation?: EntitySimulation.Store;
         });
         Init(params?: {
             item?: MenuItem.Item.IEntityIds;

package/dist/types/rendering/render-managers/entities/entities-loaded-render-manager.d.ts

@@ -3,6 +3,7 @@ import * as Cesium from "cesium";
 import { CesiumViewMonitor } from "../../../viewer/cesium-view-monitor";
 import { VisualsRegister } from "../../visuals-register";
 import { RenderManager } from "../render-manager";
+import { EntitySimulation } from "../common/entity-simulation";
 /**
  * Render manager for a group of pre-loaded entities.
  * The entities may or may not have records.
@@ -30,6 +31,7 @@ export declare namespace EntitiesLoadedRenderManager {
             apiGetter: BruceApi.IGetter;
             monitor: CesiumViewMonitor.Monitor;
             item: MenuItem.Item.IEntitiesLoaded;
+            simulation?: EntitySimulation.Store;
         });
         /**
          * Adds entities to menu item and queues the render for them.

package/dist/types/rendering/render-managers/entities/entities-render-manager.d.ts

@@ -3,6 +3,7 @@ import * as Cesium from "cesium";
 import { ISeriesSegment } from "../../../internal/series-segment";
 import { CesiumViewMonitor } from "../../../viewer/cesium-view-monitor";
 import { VisualsRegister } from "../../visuals-register";
+import { EntitySimulation } from "../common/entity-simulation";
 import { SharedGetters } from "../common/shared-getters";
 import { RenderManager } from "../render-manager";
 /**
@@ -52,6 +53,7 @@ export declare namespace EntitiesRenderManager {
             item: MenuItem.Item.IEntities;
             sharedGetters: SharedGetters.Cache;
             onSeriesDiscovered?: (segment: ISeriesSegment) => void;
+            simulation?: EntitySimulation.Store;
         });
         Init(params?: {
             item: MenuItem.Item.IEntities;

package/dist/types/rendering/render-managers/entities/entity-render-manager.d.ts

@@ -3,6 +3,7 @@ import * as Cesium from "cesium";
 import { CesiumViewMonitor } from "../../../viewer/cesium-view-monitor";
 import { VisualsRegister } from "../../visuals-register";
 import { RenderManager } from "../render-manager";
+import { EntitySimulation } from "../common/entity-simulation";
 /**
  * Manager for rendering a single Bruce entity.
  */
@@ -25,6 +26,7 @@ export declare namespace EntityRenderManager {
             apiGetter: BruceApi.IGetter;
             monitor: CesiumViewMonitor.Monitor;
             item: MenuItem.Item.IEntity;
+            simulation?: EntitySimulation.Store;
         });
         Init(): void;
         Dispose(): void;

package/dist/types/rendering/render-managers/other/assembly-render-manager.d.ts

@@ -2,6 +2,7 @@ import { ApiGetters, BruceEvent, Entity, MenuItem } from "bruce-models";
 import { RenderManager } from "../render-manager";
 import { VisualsRegister } from "../../visuals-register";
 import * as Cesium from "cesium";
+import { EntitySimulation } from "../common/entity-simulation";
 interface IHierarchyNode {
     entityId: string;
     name: string;
@@ -30,11 +31,52 @@ export declare namespace AssemblyRenderManager {
         private hierarchyNodeByEntityId;
         private modelSpace;
         get ModelSpace(): boolean;
+        /**
+         * 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?: number): {
+            entityId: string;
+            name: string;
+            parentId: string | null;
+            local: number[][] | null;
+            current: number[][] | null;
+            entity: Entity.IEntity | null;
+        }[];
+        /**
+         * 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?: number): Cesium.Matrix4 | 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: string, timeMs?: number): Cesium.Matrix4 | null;
         private rootId;
         private rootPos3d;
         private rootHeading;
+        private rootPitch;
+        private rootRoll;
+        private rootSeries;
+        private rootAttitude;
+        private pose;
         private children;
-        private trackEntity;
+        private localPositions;
+        private groundOffsets;
+        private jointSeries;
+        private animatedIds;
+        private trail;
+        private simulation;
+        private simulationRemoval;
+        readonly FollowsSimulation = true;
+        private apiEntities;
+        private regather;
+        private followingClock;
         private viewerDateTimeChangeRemoval;
         private historicGatherer;
         private historicAnimation;
@@ -44,6 +86,7 @@ export declare namespace AssemblyRenderManager {
             getters: ApiGetters;
             item: MenuItem.Item.IAssembly;
             modelSpace?: boolean;
+            simulation?: EntitySimulation.Store;
         });
         /**
          * Returns whether this Assembly's root moves over time.
@@ -71,13 +114,47 @@ export declare namespace AssemblyRenderManager {
          */
         static ChildPositionFrom(rootPos3d: Cesium.Cartesian3, headingDegrees: number, offset: Cesium.Cartesian3): 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: {
             pos3d: Cesium.Cartesian3;
             heading?: number;
+            pitch?: number;
+            roll?: number;
         }): void;
+        private repose;
+        private absorbNode;
+        private withSimulation;
+        private onSimulationChanged;
+        private simulatedNodeIds;
+        private canMove;
+        private bindPlacement;
+        private static uniformScale;
+        private static cloneOrUndefined;
+        private placementAt;
+        private rootAt;
+        private rootPositionAt;
+        private absorbRootRecords;
+        private absorbRootAttitude;
+        private composeWorld;
+        private measureGroundOffset;
+        private motionAt;
+        private localAt;
+        private absorbJointRecords;
+        private refreshAnimated;
+        private hasAnimatedAncestry;
+        private historicEntityIds;
+        /**
+         * Builds a matrix from the row-major rows that Bruce/AssemblyPosition and AssemblyWorldPosition use.
+         * @param rows
+         */
+        static MatrixFromRows(rows: number[][] | any): Cesium.Matrix4;
+        /**
+         * The inverse of MatrixFromRows.
+         * @param matrix
+         */
+        static RowsFromMatrix(matrix: Cesium.Matrix4): number[][];
         Init(): void;
         /**
          * Processes given entity IDs and renders them in the viewer.

package/dist/types/rendering/render-managers/other/legacy-relations-render-manager.d.ts

@@ -2,6 +2,7 @@ import { BruceApi, MenuItem } from "bruce-models";
 import { RenderManager } from "../render-manager";
 import { VisualsRegister } from "../../visuals-register";
 import * as Cesium from "cesium";
+import { EntitySimulation } from "../common/entity-simulation";
 /**
  * Deprecated relations render manager.
  * This follows original navigator logic that renders both up/downstream relationships and ALL relationship types.
@@ -14,12 +15,16 @@ export declare namespace LegacyRelationsRenderManager {
         private item;
         private register;
         private viewer;
+        private simulation;
+        private simulationRemoval;
+        readonly FollowsSimulation = true;
         private drawnIds;
         constructor(params: {
             apiGetter: BruceApi.IGetter;
             item: MenuItem.Item.ILegacyRelationships;
             register: VisualsRegister.Register;
             viewer: Cesium.Viewer;
+            simulation?: EntitySimulation.Store;
         });
         /**
          * Starts rendering the menu item.

package/dist/types/rendering/render-managers/other/relations-render-manager.d.ts

@@ -2,6 +2,7 @@ import { BruceApi, MenuItem } from "bruce-models";
 import { RenderManager } from "../render-manager";
 import { VisualsRegister } from "../../visuals-register";
 import * as Cesium from "cesium";
+import { EntitySimulation } from "../common/entity-simulation";
 export declare namespace RelationsRenderManager {
     class Manager implements RenderManager.IManager {
         private disposed;
@@ -10,11 +11,15 @@ export declare namespace RelationsRenderManager {
         private item;
         private register;
         private viewer;
+        private simulation;
+        private simulationRemoval;
+        readonly FollowsSimulation = true;
         constructor(params: {
             apiGetter: BruceApi.IGetter;
             item: MenuItem.Item.IRelationships;
             register: VisualsRegister.Register;
             viewer: Cesium.Viewer;
+            simulation?: EntitySimulation.Store;
         });
         /**
          * Starts rendering the menu item.

package/dist/types/rendering/render-managers/render-manager.d.ts

@@ -15,6 +15,10 @@ export declare namespace RenderManager {
             force?: boolean;
             maintain?: true;
         }): Promise<void>;
+        /**
+         * Set when the manager follows the shared simulation store itself, so the menu item manager need not.
+         */
+        FollowsSimulation?: boolean;
     }
     /**
      * Free-form bag of already-loaded resources a manager hands off to its replacement.

package/dist/types/rendering/render-managers/tilesets/tileset-arb-render-manager.d.ts

@@ -4,6 +4,7 @@ import { XGridsRenderEngine } from "../../xgrids-render-engine";
 import { TilesetRenderEngine } from "../../tileset-render-engine";
 import { VisualsRegister } from "../../visuals-register";
 import { RenderManager } from "../render-manager";
+import { EntitySimulation } from "../common/entity-simulation";
 export declare namespace TilesetArbRenderManager {
     interface IInitQueueParams {
         owner: object;
@@ -28,6 +29,7 @@ export declare namespace TilesetArbRenderManager {
     }
     class Manager implements RenderManager.IManager {
         private viewer;
+        private simulation;
         private getters;
         private item;
         private disposed;
@@ -58,6 +60,7 @@ export declare namespace TilesetArbRenderManager {
             item: MenuItem.Item.IArbTileset;
             getters: ApiGetters;
             register: VisualsRegister.Register;
+            simulation?: EntitySimulation.Store;
         });
         Init(): void;
         /**

package/dist/types/rendering/render-managers/tilesets/tileset-cad-render-manager.d.ts

@@ -5,6 +5,7 @@ import { TilesetRenderEngine } from "../../tileset-render-engine";
 import { VisualsRegister } from '../../visuals-register';
 import { RenderManager } from "../render-manager";
 import { TilesetArbRenderManager } from "./tileset-arb-render-manager";
+import { EntitySimulation } from "../common/entity-simulation";
 interface IModelTreeNode {
     entityId: string;
     typeId: string;
@@ -19,6 +20,9 @@ interface IModelTreeNode {
 export declare namespace TilesetCadRenderManager {
     class Manager implements RenderManager.IManager, RenderManager.IHandoffCapableManager, RenderManager.IHandoffReceiver {
         private viewer;
+        private simulation;
+        private simulationRemoval;
+        private restCoords;
         private getters;
         private item;
         private disposed;
@@ -51,7 +55,7 @@ export declare namespace TilesetCadRenderManager {
         private viewerDateTimeChangeRemoval;
         private historicAnimation;
         private historicGatherer;
-        private trackEntity;
+        private trail;
         private historicPossesLoadingProm;
         private featureQueue;
         private featureQueueStates;
@@ -66,6 +70,7 @@ export declare namespace TilesetCadRenderManager {
             item: MenuItem.Item.ICadTileset;
             modelSpace?: boolean;
             initQueue?: TilesetArbRenderManager.IInitQueue;
+            simulation?: EntitySimulation.Store;
         });
         Init(): void;
         private onCTilesetLoad;
@@ -204,6 +209,11 @@ export declare namespace TilesetCadRenderManager {
          * @param tileset
          */
         private viewerDateTimeSub;
+        private followSimulation;
+        private regatherRoot;
+        private atClock;
+        private applyRootRest;
+        private simulatedRootCoords;
         private viewerDateTimeDispose;
         /**
          * Updates the Tileset with latest coordinates.

package/dist/types/rendering/render-managers/tilesets/tileset-entities-render-manager.d.ts

@@ -5,10 +5,12 @@ import { VisualsRegister } from "../../visuals-register";
 import { RenderManager } from "../render-manager";
 import { TilesetArbRenderManager } from "./tileset-arb-render-manager";
 import { CesiumViewMonitor } from "../../../viewer/cesium-view-monitor";
+import { EntitySimulation } from "../common/entity-simulation";
 export declare namespace TilesetEntitiesRenderManager {
     class Manager implements RenderManager.IManager, RenderManager.IHandoffCapableManager, RenderManager.IHandoffReceiver {
         private initCounter;
         private viewer;
+        private simulation;
         private getters;
         private item;
         private disposed;
@@ -42,6 +44,7 @@ export declare namespace TilesetEntitiesRenderManager {
             item: MenuItem.Item.IEntitiesTileset;
             initQueue?: TilesetArbRenderManager.IInitQueue;
             monitor?: CesiumViewMonitor.Monitor;
+            simulation?: EntitySimulation.Store;
         });
         Init(params?: {
             item: MenuItem.Item.IEntitiesTileset;

package/dist/types/rendering/tileset-styler.d.ts

@@ -1,5 +1,6 @@
 import { BruceApi, BruceEvent, Entity, Style } from "bruce-models";
 import * as Cesium from "cesium";
+import { EntitySimulation } from "./render-managers/common/entity-simulation";
 import { VisualsRegister } from "./visuals-register";
 import { CesiumViewMonitor } from "../viewer/cesium-view-monitor";
 /**
@@ -80,6 +81,7 @@ export declare class TilesetStyler {
         historic?: boolean;
         applyStyles?: boolean;
         monitor?: CesiumViewMonitor.Monitor;
+        simulation?: EntitySimulation.Store;
     }): void;
     /**
      * Updates style mapping and fallback style.