bruce-cesium 7.7.6 → 7.7.8

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, HeightReference, ColorBlendMode, HeadingPitchRoll, Math as Math$1, Transforms, ShadowMode, Cartesian3, Model, ClassificationType, Matrix4, JulianDate, Quaternion, ConstantPositionProperty, DistanceDisplayCondition, ArcType, CornerType, ShaderSource, Ellipsoid, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, PixelDatatype, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, ImageMaterialProperty, SceneMode, IntersectionTests, Ray, SceneTransforms, HorizontalOrigin, VerticalOrigin, PolygonHierarchy, PolylineGraphics, Rectangle, NearFarScalar, Matrix3, KmlDataSource, FeatureDetection, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileColorBlendMode, Cesium3DTileset, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Intersect, WebGLConstants, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, OrthographicFrustum, EasingFunction, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, ScreenSpaceEventHandler, ScreenSpaceEventType, CustomDataSource, PolygonPipeline, GeometryInstance, Fullscreen, CzmlDataSource } from 'cesium';
-import { Cartes, LRUCache, Carto, ProjectViewTile, EntityHistoricData, BruceEvent, DelayQueue, Entity as Entity$1, EntityTag, ClientFile, ENVIRONMENT, EntityAttachmentType, EntityRelationType, EntityType, Tileset, Calculator, DataLab, Style, ObjectUtils, MenuItem, AccountConcept, RecordChangeFeed, EntityLod, UrlUtils, Geometry as Geometry$1, ClientFileValueMap, Color as Color$1, ProjectView, ProjectViewBookmark, ZoomControl, Api, Bounds, Assembly, EntityCoords, BruceApi, EntityRelation, EntitySource, ProgramKey, ProjectViewLegacyTile, Camera, Account, AccountLimits, Session, ProjectViewBookmarkGroup, EntityAttachment, EntityAttribute, MathUtils } from 'bruce-models';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, ShaderSource, Cartesian3, Math as Math$1, Ellipsoid, Transforms, Matrix4, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, PixelDatatype, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, HeightReference, ColorBlendMode, HeadingPitchRoll, Model, ClassificationType, ConstantPositionProperty, DistanceDisplayCondition, ArcType, CornerType, JulianDate, Quaternion, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, HorizontalOrigin, VerticalOrigin, SceneMode, IntersectionTests, Ray, SceneTransforms, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, FeatureDetection, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileColorBlendMode, Cesium3DTileset, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Intersect, OrthographicFrustum, EasingFunction, WebGLConstants, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, PolygonPipeline, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, CesiumInspector, ClockRange, ShadowMode, DynamicEnvironmentMapManager, GeometryInstance, PrimitiveCollection, PolylineCollection, LabelCollection, LabelStyle, Material, Event, CustomDataSource, CameraEventType, Plane, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
+import { Cartes, LRUCache, Carto, ProjectViewTile, EntityHistoricData, BruceEvent, DelayQueue, Entity as Entity$1, EntityTag, PathUtils, ClientFile, ENVIRONMENT, EntityAttachmentType, EntityRelationType, EntityType, Tileset, Calculator, DataLab, Style, ObjectUtils, MenuItem, AccountConcept, RecordChangeFeed, EntityLod, UrlUtils, Geometry as Geometry$1, Bounds, ClientFileValueMap, Color as Color$1, Assembly, EntityCoords, ZoomControl, ProjectView, ProjectViewBookmark, Api, EntityRelation, BruceApi, ProgramKey, ProjectViewLegacyTile, Camera, EntitySource, Account, AccountLimits, Session, EntityAttachment, EntityAttribute, MathUtils, ProjectViewBookmarkGroup } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -907,6 +907,546 @@ function CompareCPolygonHierarchies(a, b) {
     return true;
 }
 
+const CESIUM_CAMERA_CONTROLS_KEY = "_nextspace_camera_controls";
+// How far a wheel notch or its drag equivalent moves the camera, as a share of the distance to what it points at.
+const ZOOM_SHARE = 0.18;
+// The distance a zoom step treats anything closer as, so the camera keeps moving through a surface instead of stalling.
+const MIN_ZOOM_DISTANCE = 4;
+// How far from the origin zooming out may take a model-space camera, beyond which the scene is a dot on a planet.
+const MODEL_SPACE_MAX_RANGE = 250000;
+// Above this height a geospatial scene is a planet, which CesiumJS's own controller navigates better.
+const GEO_HANDOFF_HEIGHT = 15000;
+// The furthest a depth pick is trusted from a camera close to the ground; further up the limit grows with height.
+const PLAUSIBLE_PICK_FLOOR = 1000;
+// Pixels of right drag that make one wheel notch.
+const DRAG_PIXELS_PER_NOTCH = 40;
+// Share of the outstanding wheel movement applied each animation frame.
+const ZOOM_EASE = 0.35;
+// A pan plane seen closer to edge on than this (sine of the angle) is swapped for one facing the camera.
+const GRAZING_SINE = 0.12;
+// Closest the view may get to straight up or down while orbiting, in radians, so the camera never flips over.
+const ORBIT_POLE_MARGIN = Math$1.toRadians(1);
+var EDrag;
+(function (EDrag) {
+    EDrag["Pan"] = "pan";
+    EDrag["Orbit"] = "orbit";
+    EDrag["Zoom"] = "zoom";
+})(EDrag || (EDrag = {}));
+/**
+ * Mouse navigation that keeps moving near, through and below the ground, where CesiumJS's own controller stalls.
+ */
+var CameraControls;
+(function (CameraControls) {
+    /**
+     * Takes over mouse drag and wheel navigation close to the ground; CesiumJS keeps planet scale, pinch and look.
+     */
+    function Attach(viewer) {
+        var _a, _b, _c;
+        if (!viewer || viewer.isDestroyed() || viewer[CESIUM_CAMERA_CONTROLS_KEY]) {
+            return;
+        }
+        const scene = viewer.scene;
+        const controller = scene === null || scene === void 0 ? void 0 : scene.screenSpaceCameraController;
+        if (!controller || !scene.canvas || !scene.preUpdate) {
+            return;
+        }
+        const state = {
+            viewer,
+            getModelSpaceFrame: null,
+            drag: null,
+            touches: new Set(),
+            pendingZoom: new Cartesian3(),
+            zoomFrame: null,
+            zoomPosition: null,
+            lastDistance: 100,
+            saved: {
+                rotateEventTypes: controller.rotateEventTypes,
+                zoomEventTypes: controller.zoomEventTypes,
+                tiltEventTypes: controller.tiltEventTypes,
+                enableCollisionDetection: controller.enableCollisionDetection,
+                backFaceAlpha: (_b = (_a = scene.globe) === null || _a === void 0 ? void 0 : _a.translucency) === null || _b === void 0 ? void 0 : _b.backFaceAlpha,
+                showSkirts: (_c = scene.globe) === null || _c === void 0 ? void 0 : _c.showSkirts
+            },
+            ours: false,
+            removals: []
+        };
+        viewer[CESIUM_CAMERA_CONTROLS_KEY] = state;
+        // The camera may go below the ground; zooming slows near a surface, so it takes a deliberate push.
+        controller.enableCollisionDetection = false;
+        const canvas = scene.canvas;
+        const listen = (target, type, handler, options) => {
+            target.addEventListener(type, handler, options);
+            state.removals.push(() => target.removeEventListener(type, handler, options));
+        };
+        listen(canvas, "pointerdown", (e) => onPointerDown(state, e));
+        listen(window, "pointermove", (e) => onPointerMove(state, e));
+        listen(window, "pointerup", (e) => onPointerUp(state, e));
+        listen(window, "pointercancel", (e) => onPointerUp(state, e));
+        listen(canvas, "wheel", (e) => onWheel(state, e), { passive: true });
+        state.removals.push(scene.preUpdate.addEventListener(() => syncController(state)));
+        syncController(state);
+        scene.requestRender();
+    }
+    CameraControls.Attach = Attach;
+    /**
+     * Hands navigation back to CesiumJS's own camera controller, as it was before Attach.
+     */
+    function Detach(viewer) {
+        const state = viewer === null || viewer === void 0 ? void 0 : viewer[CESIUM_CAMERA_CONTROLS_KEY];
+        if (!state) {
+            return;
+        }
+        SetModelSpace(viewer, null);
+        viewer[CESIUM_CAMERA_CONTROLS_KEY] = null;
+        state.removals.forEach((removal) => removal());
+        state.removals = [];
+        if (state.zoomFrame != null) {
+            cancelAnimationFrame(state.zoomFrame);
+        }
+        if (viewer.isDestroyed()) {
+            return;
+        }
+        restoreCesiumGestures(state);
+        viewer.scene.screenSpaceCameraController.enableCollisionDetection = state.saved.enableCollisionDetection;
+        viewer.scene.requestRender();
+    }
+    CameraControls.Detach = Detach;
+    function IsAttached(viewer) {
+        return Boolean(viewer === null || viewer === void 0 ? void 0 : viewer[CESIUM_CAMERA_CONTROLS_KEY]);
+    }
+    CameraControls.IsAttached = IsAttached;
+    /**
+     * Switches to navigating model-space measured from the frame getFrame returns, or back to geospatial with null.
+     */
+    function SetModelSpace(viewer, getFrame) {
+        const state = viewer === null || viewer === void 0 ? void 0 : viewer[CESIUM_CAMERA_CONTROLS_KEY];
+        if (!state || viewer.isDestroyed()) {
+            return;
+        }
+        const wasModelSpace = Boolean(state.getModelSpaceFrame);
+        state.getModelSpaceFrame = getFrame !== null && getFrame !== void 0 ? getFrame : null;
+        syncController(state);
+        if (wasModelSpace === Boolean(getFrame)) {
+            return;
+        }
+        const globe = viewer.scene.globe;
+        const translucency = globe === null || globe === void 0 ? void 0 : globe.translucency;
+        if (getFrame) {
+            // The ground is see-through from below, so what stands on it stays in view underground.
+            if (translucency && typeof translucency.backFaceAlpha === "number") {
+                translucency.backFaceAlpha = 0.5;
+            }
+            // Skirts hide seams flat model-space ground never has, and below it they are walls.
+            if (typeof state.saved.showSkirts === "boolean") {
+                globe.showSkirts = false;
+            }
+        }
+        else {
+            if (translucency && typeof state.saved.backFaceAlpha === "number") {
+                translucency.backFaceAlpha = state.saved.backFaceAlpha;
+            }
+            if (typeof state.saved.showSkirts === "boolean") {
+                globe.showSkirts = state.saved.showSkirts;
+            }
+        }
+        viewer.scene.requestRender();
+    }
+    CameraControls.SetModelSpace = SetModelSpace;
+})(CameraControls || (CameraControls = {}));
+function restoreCesiumGestures(state) {
+    const controller = state.viewer.scene.screenSpaceCameraController;
+    controller.rotateEventTypes = state.saved.rotateEventTypes;
+    controller.zoomEventTypes = state.saved.zoomEventTypes;
+    controller.tiltEventTypes = state.saved.tiltEventTypes;
+}
+/*
+ * Decides each frame who has the mouse: these controls near the ground, CesiumJS for planets, orthographic and tracking.
+ */
+function syncController(state) {
+    const viewer = state.viewer;
+    if (viewer.isDestroyed() || state.drag) {
+        return;
+    }
+    const ours = shouldControl(state);
+    if (ours === state.ours) {
+        return;
+    }
+    state.ours = ours;
+    if (ours) {
+        const controller = viewer.scene.screenSpaceCameraController;
+        controller.rotateEventTypes = [];
+        controller.zoomEventTypes = [CameraEventType.PINCH];
+        controller.tiltEventTypes = [CameraEventType.PINCH];
+    }
+    else {
+        restoreCesiumGestures(state);
+    }
+}
+function shouldControl(state) {
+    const viewer = state.viewer;
+    const camera = viewer.camera;
+    if (viewer.scene.mode !== SceneMode.SCENE3D || camera.frustum instanceof OrthographicFrustum) {
+        return false;
+    }
+    // A camera following something is CesiumJS's to move.
+    if (!Matrix4.equals(camera.transform, Matrix4.IDENTITY)) {
+        return false;
+    }
+    if (state.getModelSpaceFrame) {
+        return true;
+    }
+    return heightOf(state, camera.positionWC) < GEO_HANDOFF_HEIGHT;
+}
+function ellipsoidOf(state) {
+    var _a, _b;
+    return (_b = (_a = state.viewer.scene.globe) === null || _a === void 0 ? void 0 : _a.ellipsoid) !== null && _b !== void 0 ? _b : Ellipsoid.WGS84;
+}
+function heightOf(state, position) {
+    const carto = ellipsoidOf(state).cartesianToCartographic(position);
+    return carto ? carto.height : Number.POSITIVE_INFINITY;
+}
+function canvasPosition(viewer, e) {
+    const rect = viewer.scene.canvas.getBoundingClientRect();
+    return new Cartesian2(e.clientX - rect.left, e.clientY - rect.top);
+}
+/*
+ * Up at a point: the model-space frame's up in model-space, else the ellipsoid's surface normal there.
+ */
+function upAt(state, position) {
+    if (state.getModelSpaceFrame) {
+        const up = Matrix4.multiplyByPointAsVector(state.getModelSpaceFrame(), Cartesian3.UNIT_Z, new Cartesian3());
+        return Cartesian3.normalize(up, up);
+    }
+    return ellipsoidOf(state).geodeticSurfaceNormal(position, new Cartesian3());
+}
+/*
+ * The level plane standing in for the ground when nothing is drawn under the cursor.
+ */
+function groundPlane(state) {
+    if (state.getModelSpaceFrame) {
+        const frame = state.getModelSpaceFrame();
+        return Plane.fromPointNormal(Matrix4.getTranslation(frame, new Cartesian3()), upAt(state, null));
+    }
+    const camera = state.viewer.camera;
+    const ellipsoid = ellipsoidOf(state);
+    const surface = ellipsoid.scaleToGeodeticSurface(camera.positionWC, new Cartesian3());
+    if (!surface) {
+        return null;
+    }
+    return Plane.fromPointNormal(surface, ellipsoid.geodeticSurfaceNormal(surface, new Cartesian3()));
+}
+/*
+ * How far away a depth pick is believable, since below ground the depth buffer can hold the globe's inside.
+ */
+function plausibleDistance(state) {
+    const camera = state.viewer.camera;
+    if (state.getModelSpaceFrame) {
+        const origin = Matrix4.getTranslation(state.getModelSpaceFrame(), new Cartesian3());
+        return Math.max(PLAUSIBLE_PICK_FLOOR, Cartesian3.distance(camera.positionWC, origin) * 10);
+    }
+    const height = Math.abs(heightOf(state, camera.positionWC) - (Number(state.viewer.scene.globeHeight) || 0));
+    const horizon = Math.sqrt(2 * ellipsoidOf(state).maximumRadius * Math.max(height, 0));
+    return Math.max(PLAUSIBLE_PICK_FLOOR, height * 10, horizon * 1.5);
+}
+/*
+ * The point under a screen position: what is drawn there, else the ground plane, else a point at the last distance.
+ */
+function pickTarget(state, position) {
+    const viewer = state.viewer;
+    const scene = viewer.scene;
+    const camera = viewer.camera;
+    const ray = camera.getPickRay(position);
+    if (!ray) {
+        return null;
+    }
+    let picked;
+    if (scene.pickPositionSupported) {
+        try {
+            picked = scene.pickPosition(position);
+        }
+        catch (e) {
+            picked = null;
+        }
+    }
+    const plausible = plausibleDistance(state);
+    if (isAhead(camera, picked) && Cartesian3.distance(picked, camera.positionWC) < plausible) {
+        return picked;
+    }
+    const ground = groundPlane(state);
+    const onGround = ground ? IntersectionTests.rayPlane(ray, ground) : null;
+    if (isAhead(camera, onGround) && Cartesian3.distance(onGround, camera.positionWC) < plausible) {
+        return onGround;
+    }
+    return Ray.getPoint(ray, state.lastDistance);
+}
+function isAhead(camera, point) {
+    if (!point || !Number.isFinite(point.x) || !Number.isFinite(point.y) || !Number.isFinite(point.z)) {
+        return false;
+    }
+    const toPoint = Cartesian3.subtract(point, camera.positionWC, new Cartesian3());
+    return Cartesian3.dot(toPoint, camera.directionWC) > 0;
+}
+/*
+ * Picks which gesture a button and its modifiers start, matching CesiumJS's own mapping.
+ */
+function dragKind(e) {
+    if (e.shiftKey) {
+        // Shift drag looks around, which CesiumJS still handles.
+        return null;
+    }
+    if (e.button === 1 || (e.ctrlKey && (e.button === 0 || e.button === 2))) {
+        return EDrag.Orbit;
+    }
+    if (e.button === 0) {
+        return EDrag.Pan;
+    }
+    if (e.button === 2) {
+        return EDrag.Zoom;
+    }
+    return null;
+}
+function allows(state, kind) {
+    const controller = state.viewer.scene.screenSpaceCameraController;
+    if (!controller.enableInputs) {
+        return false;
+    }
+    switch (kind) {
+        case EDrag.Pan:
+            return controller.enableRotate;
+        case EDrag.Orbit:
+            return controller.enableTilt;
+        case EDrag.Zoom:
+            return controller.enableZoom;
+    }
+    return false;
+}
+function onPointerDown(state, e) {
+    const viewer = state.viewer;
+    if (viewer.isDestroyed() || !state.ours) {
+        return;
+    }
+    if (e.pointerType === "touch") {
+        state.touches.add(e.pointerId);
+        // A second finger makes it a pinch, which CesiumJS handles.
+        if (state.touches.size > 1) {
+            endDrag(state);
+            return;
+        }
+    }
+    const kind = dragKind(e);
+    if (!kind || !allows(state, kind)) {
+        return;
+    }
+    const position = canvasPosition(viewer, e);
+    const target = pickTarget(state, position);
+    if (!target) {
+        return;
+    }
+    const camera = viewer.camera;
+    const distance = Cartesian3.distance(camera.positionWC, target);
+    state.lastDistance = Math.max(distance, MIN_ZOOM_DISTANCE);
+    const drag = { kind, pointerId: e.pointerId, last: position, target, up: upAt(state, target), distance };
+    if (kind === EDrag.Pan) {
+        drag.plane = panPlane(camera, target, drag.up);
+    }
+    else if (kind === EDrag.Zoom) {
+        drag.direction = Cartesian3.normalize(Cartesian3.subtract(target, camera.positionWC, new Cartesian3()), new Cartesian3());
+    }
+    state.drag = drag;
+}
+/*
+ * A level plane through the grabbed point, or one facing the camera when the level one is seen edge on.
+ */
+function panPlane(camera, target, up) {
+    if (Math.abs(Cartesian3.dot(camera.directionWC, up)) > GRAZING_SINE) {
+        return Plane.fromPointNormal(target, up);
+    }
+    return Plane.fromPointNormal(target, Cartesian3.negate(camera.directionWC, new Cartesian3()));
+}
+function onPointerMove(state, e) {
+    const drag = state.drag;
+    const viewer = state.viewer;
+    if (!drag || drag.pointerId !== e.pointerId || viewer.isDestroyed()) {
+        return;
+    }
+    if (!allows(state, drag.kind)) {
+        endDrag(state);
+        return;
+    }
+    const position = canvasPosition(viewer, e);
+    const dx = position.x - drag.last.x;
+    const dy = position.y - drag.last.y;
+    if (dx === 0 && dy === 0) {
+        return;
+    }
+    switch (drag.kind) {
+        case EDrag.Pan:
+            pan(state, drag, position);
+            break;
+        case EDrag.Orbit:
+            orbit(state, drag, dx, dy);
+            break;
+        case EDrag.Zoom:
+            // Dragging down zooms in, as it does in CesiumJS.
+            moveAlong(state, drag.direction, drag.target, dy / DRAG_PIXELS_PER_NOTCH);
+            break;
+    }
+    drag.last = position;
+    viewer.scene.requestRender();
+}
+function onPointerUp(state, e) {
+    var _a;
+    state.touches.delete(e.pointerId);
+    if (((_a = state.drag) === null || _a === void 0 ? void 0 : _a.pointerId) === e.pointerId) {
+        endDrag(state);
+    }
+}
+function endDrag(state) {
+    state.drag = null;
+}
+/*
+ * Slides the camera so the grabbed point stays under the cursor.
+ */
+function pan(state, drag, position) {
+    const camera = state.viewer.camera;
+    const ray = camera.getPickRay(position);
+    const hit = ray ? IntersectionTests.rayPlane(ray, drag.plane) : null;
+    if (!isAhead(camera, hit)) {
+        return;
+    }
+    const delta = Cartesian3.subtract(drag.target, hit, new Cartesian3());
+    // Near the horizon a pixel covers kilometres, so one move is capped at a few times the grab distance.
+    const limit = Math.max(drag.distance, MIN_ZOOM_DISTANCE) * 3;
+    const length = Cartesian3.magnitude(delta);
+    if (length > limit) {
+        Cartesian3.multiplyByScalar(delta, limit / length, delta);
+    }
+    Cartesian3.add(camera.position, delta, camera.position);
+}
+/*
+ * Turns the camera around the grabbed point: sideways about up there, and up or down about the camera's right.
+ */
+function orbit(state, drag, dx, dy) {
+    const viewer = state.viewer;
+    const camera = viewer.camera;
+    const canvas = viewer.scene.canvas;
+    const up = drag.up;
+    const heading = -dx / Math.max(canvas.clientWidth, 1) * Math.PI * 2;
+    // Dragging down looks further down, as CesiumJS's own tilt does.
+    let pitch = -dy / Math.max(canvas.clientHeight, 1) * Math.PI;
+    // Keeps the view from tipping past straight up or down, where it would flip over.
+    const elevation = Math.asin(Math$1.clamp(Cartesian3.dot(camera.direction, up), -1, 1));
+    const limit = Math.PI / 2 - ORBIT_POLE_MARGIN;
+    pitch = Math$1.clamp(elevation + pitch, -limit, limit) - elevation;
+    rotateAbout(camera, drag.target, up, heading);
+    const right = Cartesian3.cross(camera.direction, up, new Cartesian3());
+    if (Cartesian3.magnitude(right) > Math$1.EPSILON6) {
+        Cartesian3.normalize(right, right);
+        rotateAbout(camera, drag.target, right, pitch);
+    }
+    levelCamera(camera, upAt(state, camera.position));
+}
+function rotateAbout(camera, pivot, axis, angle) {
+    if (!angle) {
+        return;
+    }
+    const rotation = Matrix3.fromQuaternion(Quaternion.fromAxisAngle(axis, angle));
+    const offset = Cartesian3.subtract(camera.position, pivot, new Cartesian3());
+    Matrix3.multiplyByVector(rotation, offset, offset);
+    Cartesian3.add(pivot, offset, camera.position);
+    Matrix3.multiplyByVector(rotation, camera.direction, camera.direction);
+    Matrix3.multiplyByVector(rotation, camera.up, camera.up);
+    Matrix3.multiplyByVector(rotation, camera.right, camera.right);
+}
+/*
+ * Takes any roll out, so the horizon stays level however the camera has turned.
+ */
+function levelCamera(camera, up) {
+    const direction = Cartesian3.normalize(camera.direction, camera.direction);
+    const right = Cartesian3.cross(direction, up, new Cartesian3());
+    if (Cartesian3.magnitude(right) < Math$1.EPSILON6) {
+        return;
+    }
+    Cartesian3.normalize(right, camera.right);
+    Cartesian3.cross(camera.right, direction, camera.up);
+    Cartesian3.normalize(camera.up, camera.up);
+}
+function onWheel(state, e) {
+    const viewer = state.viewer;
+    if (viewer.isDestroyed() || !state.ours || !allows(state, EDrag.Zoom)) {
+        return;
+    }
+    let notches = e.deltaMode === 1 ? e.deltaY / 3 : e.deltaMode === 2 ? e.deltaY : e.deltaY / 100;
+    notches = Math$1.clamp(-notches, -3, 3);
+    if (!notches) {
+        return;
+    }
+    const position = canvasPosition(viewer, e);
+    const camera = viewer.camera;
+    const target = pickTarget(state, position);
+    const ray = camera.getPickRay(position);
+    if (!target || !ray) {
+        return;
+    }
+    const step = zoomStep(state, ray.direction, target, notches);
+    Cartesian3.add(state.pendingZoom, step, state.pendingZoom);
+    state.zoomPosition = Cartesian3.clone(camera.position);
+    if (state.zoomFrame == null) {
+        state.zoomFrame = requestAnimationFrame(() => easeZoom(state));
+    }
+}
+/*
+ * Applies part of the outstanding wheel movement each frame, so a notch glides rather than jumps.
+ */
+function easeZoom(state) {
+    state.zoomFrame = null;
+    const viewer = state.viewer;
+    if (viewer.isDestroyed() || !viewer[CESIUM_CAMERA_CONTROLS_KEY]) {
+        return;
+    }
+    // A tool locking the camera mid glide (walkthrough, a camera lock) owns it from then on.
+    if (!allows(state, EDrag.Zoom) ||
+        !state.zoomPosition ||
+        !Cartesian3.equalsEpsilon(viewer.camera.position, state.zoomPosition, 0, 1e-3)) {
+        state.pendingZoom = new Cartesian3();
+        return;
+    }
+    const remaining = Cartesian3.magnitude(state.pendingZoom);
+    const share = remaining < 0.01 ? 1 : ZOOM_EASE;
+    const step = Cartesian3.multiplyByScalar(state.pendingZoom, share, new Cartesian3());
+    Cartesian3.subtract(state.pendingZoom, step, state.pendingZoom);
+    Cartesian3.add(viewer.camera.position, step, viewer.camera.position);
+    state.zoomPosition = Cartesian3.clone(viewer.camera.position);
+    viewer.scene.requestRender();
+    if (share < 1) {
+        state.zoomFrame = requestAnimationFrame(() => easeZoom(state));
+    }
+}
+function moveAlong(state, direction, target, notches) {
+    const step = zoomStep(state, direction, target, notches);
+    Cartesian3.add(state.viewer.camera.position, step, state.viewer.camera.position);
+}
+/*
+ * The move for some notches toward a target along a direction, a share of the distance with a floor so it never stalls.
+ */
+function zoomStep(state, direction, target, notches) {
+    const camera = state.viewer.camera;
+    const distance = Math.max(Cartesian3.distance(camera.positionWC, target), MIN_ZOOM_DISTANCE);
+    state.lastDistance = distance;
+    let length = distance * ZOOM_SHARE * notches;
+    // A geospatial camera zooming out hands over to CesiumJS once it is high enough, so only model-space is capped.
+    if (length < 0 && state.getModelSpaceFrame) {
+        const origin = Matrix4.getTranslation(state.getModelSpaceFrame(), new Cartesian3());
+        const pending = Cartesian3.add(camera.positionWC, state.pendingZoom, new Cartesian3());
+        const range = Cartesian3.distance(pending, origin);
+        length = Math.max(length, range - MODEL_SPACE_MAX_RANGE);
+        if (length >= 0) {
+            return new Cartesian3();
+        }
+    }
+    return Cartesian3.multiplyByScalar(Cartesian3.normalize(direction, new Cartesian3()), length, new Cartesian3());
+}
+
 const CESIUM_INSPECTOR_KEY = "_nextspace_inspector";
 const CESIUM_TIMELINE_KEY = "_nextspace_timeline";
 const CESIUM_TIMELINE_LIVE_KEY = "_nextspace_timeline_live";
@@ -1384,6 +1924,13 @@ var ViewUtils;
         return overriddenImageBasedLighting || null;
     }
     ViewUtils.GetDefaultImageBasedLighting = GetDefaultImageBasedLighting;
+    /**
+     * Shadow mode for the Entity graphics this library draws, following the scene's shadow switch.
+     */
+    function GetEntityShadowMode(viewer) {
+        return (viewer === null || viewer === void 0 ? void 0 : viewer.shadows) ? ShadowMode.ENABLED : ShadowMode.DISABLED;
+    }
+    ViewUtils.GetEntityShadowMode = GetEntityShadowMode;
     function EngineShadesModelsDarker() {
         return typeof DynamicEnvironmentMapManager !== "undefined";
     }
@@ -1455,6 +2002,7 @@ var ViewUtils;
         viewer[CESIUM_MODEL_SPACE_KEY] = modelSpace;
         // Reload globe since we display it differently between the two modes.
         SetGlobeDetails({ viewer });
+        CameraControls.SetModelSpace(viewer, modelSpace ? () => GetModelSpaceFrame(viewer) : null);
     }
     ViewUtils.SetModelSpace = SetModelSpace;
     function GetModelSpace(viewer) {
@@ -6177,7 +6725,7 @@ var EntitySimulation;
             const byTime = new Map();
             for (const set of this.sets.values()) {
                 for (const [ms, record] of set.records.get(entityId) || []) {
-                    if (attrKey && record.attrKey && record.attrKey !== attrKey) {
+                    if (attrKey && record.attrKey && !PathUtils.Equals(record.attrKey, attrKey)) {
                         continue;
                     }
                     const held = byTime.get(ms);
@@ -11982,6 +12530,28 @@ function getHighestZIndex(viewer, visual) {
     return highest;
 }
 const MAX_SHOW_DEPTH = 10;
+// Entity graphics whose shadows follow the scene's shadow switch.
+const SHADOWED_GRAPHICS = ["model", "polygon", "polyline", "corridor"];
+/*
+ * Points a registered Entity graphic, and the graphics drawn beside it, at the given shadow mode.
+ */
+function updateCEntityShadows(viewer, visual, mode, depth = 0) {
+    if (!visual || depth > MAX_SHOW_DEPTH) {
+        return;
+    }
+    for (const key of SHADOWED_GRAPHICS) {
+        const graphic = visual[key];
+        // Only graphics drawn with a mode; one left at Cesium's default was never meant to shadow.
+        if ((graphic === null || graphic === void 0 ? void 0 : graphic.shadows) != null) {
+            SetCPropIfChanged({ viewer, graphic, property: "shadows", value: mode });
+        }
+    }
+    if (visual._siblingGraphics) {
+        for (let i = 0; i < visual._siblingGraphics.length; i++) {
+            updateCEntityShadows(viewer, visual._siblingGraphics[i], mode, depth + 1);
+        }
+    }
+}
 function updateCEntityShow(viewer, visual, rego, show, ignoreParent, depth = 0) {
     if (depth > MAX_SHOW_DEPTH) {
         console.warn("updateCEntityShow(): Max show depth reached. EntityId = " + rego.entityId);
@@ -12318,7 +12888,7 @@ var VisualsRegister;
         }
         get OnLabelGroupsChanged() { return this.labelGroupsChanged; }
         constructor(params) {
-            var _a, _b;
+            var _a, _b, _c, _d, _e, _f, _g;
             this.id = ObjectUtils.UId();
             this.disposed = false;
             this.rego = {};
@@ -12368,6 +12938,7 @@ var VisualsRegister;
             this.sourceOrderDirty = false;
             // Stops following what is simulated, so labels can read it again when it changes.
             this.simulationRemoval = null;
+            this.shadowsRemoval = null;
             this.labelGroupsChanged = new BruceEvent();
             this.hoverRingState = {};
             this.retiringHoverLabels = new Map();
@@ -12403,6 +12974,27 @@ var VisualsRegister;
                 register: this
             });
             this.simulationRemoval = (_b = (_a = EntitySimulation.Get(this.viewer)) === null || _a === void 0 ? void 0 : _a.OnChanged.Subscribe((change) => this.reloadLabels(change.entityIds))) !== null && _b !== void 0 ? _b : null;
+            this.entityShadows = Boolean((_c = this.viewer) === null || _c === void 0 ? void 0 : _c.shadows);
+            this.shadowsRemoval = (_g = (_f = (_e = (_d = this.viewer) === null || _d === void 0 ? void 0 : _d.scene) === null || _e === void 0 ? void 0 : _e.preUpdate) === null || _f === void 0 ? void 0 : _f.addEventListener(() => this.syncEntityShadows())) !== null && _g !== void 0 ? _g : null;
+        }
+        /*
+         * Follows the scene's shadow switch on every registered Entity, whichever app or bookmark flipped it.
+         */
+        syncEntityShadows() {
+            const viewer = this.viewer;
+            const enabled = Boolean(viewer === null || viewer === void 0 ? void 0 : viewer.shadows);
+            if (enabled === this.entityShadows || this.disposed || !viewer || viewer.isDestroyed()) {
+                return;
+            }
+            this.entityShadows = enabled;
+            const mode = enabled ? ShadowMode.ENABLED : ShadowMode.DISABLED;
+            for (const regos of Object.values(this.rego)) {
+                for (const rego of regos) {
+                    if (rego.visual instanceof Entity) {
+                        updateCEntityShadows(viewer, rego.visual, mode);
+                    }
+                }
+            }
         }
         /*
          * Tells labels to read their Entity again, since they keep what they read when drawn.
@@ -13331,9 +13923,11 @@ var VisualsRegister;
             (_b = this.viewer.scene) === null || _b === void 0 ? void 0 : _b.requestRender();
         }
         Dispose() {
-            var _a, _b, _c, _d, _e, _f;
+            var _a, _b, _c, _d, _e, _f, _g;
             (_a = this.simulationRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
             this.simulationRemoval = null;
+            (_b = this.shadowsRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+            this.shadowsRemoval = null;
             CesiumEntityStyler.SetDimming(this.viewer, this.id, false);
             this.ClearLabelHover();
             clearTimeout(this.hoverRingReset);
@@ -13343,14 +13937,14 @@ var VisualsRegister;
                 EntityLabel.Detatch({ label });
             }
             this.retiringHoverLabels.clear();
-            (_b = this.labelGroups) === null || _b === void 0 ? void 0 : _b.Dispose();
+            (_c = this.labelGroups) === null || _c === void 0 ? void 0 : _c.Dispose();
             this.labelGroupsChanged.Clear();
             for (const regos of Object.values(this.rego)) {
                 for (const rego of regos)
                     EntityLabel.Detatch({ rego, force: true });
             }
             EntityLabel.SetContainer(this.viewer);
-            (_c = this.cameraCullerDispose) === null || _c === void 0 ? void 0 : _c.call(this, {
+            (_d = this.cameraCullerDispose) === null || _d === void 0 ? void 0 : _d.call(this, {
                 uncull: false
             });
             this.cameraCullerDispose = null;
@@ -13367,7 +13961,7 @@ var VisualsRegister;
             this.disposed = true;
             for (const record of Array.from(this.menuItemSources.values())) {
                 try {
-                    (_e = (_d = this.viewer) === null || _d === void 0 ? void 0 : _d.dataSources) === null || _e === void 0 ? void 0 : _e.remove(record.source, true);
+                    (_f = (_e = this.viewer) === null || _e === void 0 ? void 0 : _e.dataSources) === null || _f === void 0 ? void 0 : _f.remove(record.source, true);
                 }
                 catch (e) {
                     console.error(e);
@@ -13376,7 +13970,7 @@ var VisualsRegister;
             this.menuItemSources.clear();
             // Hand every tileset's show flag back to its owner, holding whatever the owner last asked for.
             for (const rego of Array.from(this.tilesets.values())) {
-                (_f = rego.gate) === null || _f === void 0 ? void 0 : _f.Release();
+                (_g = rego.gate) === null || _g === void 0 ? void 0 : _g.Release();
             }
             this.tilesets.clear();
         }
@@ -14100,8 +14694,11 @@ var VisualsRegister;
                 }
             }
             // Add the new visual to the register.
+            // Tileset managers add the same rego again for each tile holding more of the Entity.
             const entityRegos = (_a = this.rego[entityId]) !== null && _a !== void 0 ? _a : [];
-            entityRegos.push(rego);
+            if (!entityRegos.includes(rego)) {
+                entityRegos.push(rego);
+            }
             this.rego[entityId] = entityRegos;
             this.indexMenuItemEntity(rego.menuItemId, entityId);
             // Mark the visual as part of this register so selection works.
@@ -14535,6 +15132,28 @@ var VisualsRegister;
                 }
             }
         }
+        /*
+         * Hands a tile feature rego to a sibling feature from another tile when its own tile unloads.
+         * An Entity split across tiles keeps drawing from those, so it must stay registered for them.
+         */
+        promoteTileSibling(rego, removing) {
+            var _a;
+            const departing = rego.visual;
+            if (!(departing instanceof Cesium3DTileFeature) || !((_a = departing._siblingGraphics) === null || _a === void 0 ? void 0 : _a.length)) {
+                return false;
+            }
+            const remaining = departing._siblingGraphics.filter(s => !removing.has(s));
+            if (!remaining.length) {
+                return false;
+            }
+            departing._siblingGraphics = undefined;
+            unmarkEntity(departing, true);
+            const promoted = remaining[0];
+            promoted._siblingGraphics = remaining.slice(1);
+            rego.visual = promoted;
+            markEntity(this, rego, promoted, false);
+            return true;
+        }
         /**
          * Removes regos matching given visuals.
          * This is used when we cannot unpack properties from the visual any longer to determine its ID.
@@ -14545,6 +15164,7 @@ var VisualsRegister;
             var _a, _b, _c;
             const { doRemove = true, requestRender = true, source, doUpdate, menuItemId } = params;
             const removedEntityIds = new Set();
+            const removing = new Set(params.visuals);
             for (const visual of params.visuals) {
                 const visExt = visual;
                 const rego = (visExt === null || visExt === void 0 ? void 0 : visExt._register) === this ? visExt._rego : null;
@@ -14556,7 +15176,20 @@ var VisualsRegister;
                 if (!entityRegos) {
                     continue;
                 }
-                if (rego.visual === visual) {
+                if (rego.visual === visual && this.promoteTileSibling(rego, removing)) {
+                    if (doRemove != false) {
+                        removeEntity(this.viewer, visual);
+                    }
+                    // The label was placed against the departing feature, the refresh attaches it again.
+                    EntityLabel.Detatch({
+                        rego, force: true
+                    });
+                    this.queueUpdate({
+                        entityId: entityId,
+                        refresh: true
+                    });
+                }
+                else if (rego.visual === visual) {
                     EntityLabel.Detatch({
                         rego, force: true
                     });
@@ -16212,6 +16845,304 @@ class TilesetStyler {
     }
 }
 
+// viewer[VIEWER_WATCH_KEY] is true once the viewer's canvas reports context loss to DeviceProfile.
+const VIEWER_WATCH_KEY = "_bruceDeviceProfileWatch";
+// localStorage[DEMOTION_KEY] holds an IDemotion written after this browser lost a WebGL context.
+const DEMOTION_KEY = "bruce-cesium-device-demotion";
+// A lost context demotes for this long, so one driver reset does not cap a strong device forever.
+// Measured on the wall clock, not the viewer's: it spans sessions, and a scene clock can be historic.
+const DEMOTION_MS = 14 * 24 * 60 * 60 * 1000;
+// Each loss demotes one more tier, up to this many.
+const DEMOTION_MAX = 2;
+/*
+ * Reads the demotion left by earlier context losses, ignoring an expired or unreadable one.
+ */
+function readDemotion(now) {
+    try {
+        const value = JSON.parse(window.localStorage.getItem(DEMOTION_KEY));
+        if (value &&
+            Number.isFinite(value.count) &&
+            Number.isFinite(value.at) &&
+            now - value.at < DEMOTION_MS) {
+            return value;
+        }
+    }
+    catch (e) {
+        // Storage is blocked (private mode, sandboxed frame) or holds junk; treat as no demotion.
+    }
+    return null;
+}
+/*
+ * Stores or clears the demotion, carrying on without it where storage is blocked.
+ */
+function writeDemotion(value) {
+    try {
+        if (value) {
+            window.localStorage.setItem(DEMOTION_KEY, JSON.stringify(value));
+        }
+        else {
+            window.localStorage.removeItem(DEMOTION_KEY);
+        }
+    }
+    catch (e) {
+        // Without storage the demotion lasts only for this page.
+    }
+}
+/*
+ * Reads the GPU name, preferring the unmasked one, which browsers that hide it simply do not offer.
+ */
+function readRenderer(gl) {
+    try {
+        const ext = gl.getExtension("WEBGL_debug_renderer_info");
+        const name = ext ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) : gl.getParameter(gl.RENDERER);
+        return typeof name === "string" && name ? name : undefined;
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+/**
+ * Picks how much the scene may hold in memory on this device, from a hardware guess and past sessions.
+ */
+var DeviceProfile;
+(function (DeviceProfile) {
+    let ETier;
+    (function (ETier) {
+        ETier["Low"] = "LOW";
+        ETier["Mid"] = "MID";
+        ETier["High"] = "HIGH";
+    })(ETier = DeviceProfile.ETier || (DeviceProfile.ETier = {}));
+    DeviceProfile.BUDGETS = {
+        [ETier.Low]: { tilesetMb: 384, splats: 1000000 },
+        [ETier.Mid]: { tilesetMb: 1024, splats: 3000000 },
+        [ETier.High]: { tilesetMb: 2048, splats: 6000000 }
+    };
+    const ORDER = [ETier.Low, ETier.Mid, ETier.High];
+    /**
+     * Raised after the override or a demotion changes the tier, so live budgets can be redistributed.
+     */
+    DeviceProfile.Changed = new Event();
+    let override = null;
+    let detected = null;
+    let logged = false;
+    /*
+     * Sorts a GPU name into a class. Order matters: Intel Arc is discrete, SwiftShader names any vendor.
+     */
+    function ClassifyGpu(renderer) {
+        const name = (renderer || "").toLowerCase();
+        if (!name) {
+            return "unknown";
+        }
+        if (/swiftshader|llvmpipe|softpipe|lavapipe|software|basic render/.test(name)) {
+            return "software";
+        }
+        if (/mali|adreno|powervr|apple gpu|videocore|immortalis|xclipse|tegra/.test(name)) {
+            return "mobile";
+        }
+        if (/apple m\d+ (pro|max|ultra)/.test(name)) {
+            return "discrete";
+        }
+        if (/nvidia|geforce|quadro|rtx|radeon (rx|pro|r9|vii)|firepro|arc(\(tm\))? a\d/.test(name)) {
+            return "discrete";
+        }
+        if (/intel|apple m\d|radeon(\(tm\))? graphics|vega \d/.test(name)) {
+            return "integrated";
+        }
+        return "unknown";
+    }
+    DeviceProfile.ClassifyGpu = ClassifyGpu;
+    /**
+     * Guesses a tier from the hardware alone. Unknown hardware stays mid; only clear evidence moves it.
+     */
+    function Classify(env) {
+        const ua = (env.userAgent || "").toLowerCase();
+        const mobile = /android|iphone|ipad|ipod|mobile/.test(ua) || (/macintosh/.test(ua) && env.maxTouchPoints > 1);
+        const gpuClass = ClassifyGpu(env.gpuRenderer);
+        const memory = env.deviceMemory;
+        const reasons = [];
+        let tier = ETier.Mid;
+        if (gpuClass === "software") {
+            reasons.push("software renderer");
+            tier = ETier.Low;
+        }
+        if (mobile) {
+            reasons.push("mobile device");
+            tier = ETier.Low;
+        }
+        if (Number.isFinite(memory) && memory < 4) {
+            reasons.push(`${memory} GB device memory`);
+            tier = ETier.Low;
+        }
+        if (Number.isFinite(env.maxTextureSize) && env.maxTextureSize < 8192) {
+            reasons.push(`max texture ${env.maxTextureSize}`);
+            tier = ETier.Low;
+        }
+        if (tier === ETier.Mid && gpuClass === "discrete") {
+            if (!Number.isFinite(memory) || memory >= 8) {
+                reasons.push("discrete GPU");
+                tier = ETier.High;
+            }
+            else {
+                reasons.push(`discrete GPU held to mid by ${memory} GB device memory`);
+            }
+        }
+        if (!reasons.length) {
+            reasons.push(`${gpuClass} GPU`);
+        }
+        return { tier, gpuClass, mobile, reasons };
+    }
+    DeviceProfile.Classify = Classify;
+    /*
+     * Reads the browser environment, from the viewer's GL context when given rather than a spare one.
+     */
+    function readEnvironment(viewer) {
+        var _a, _b, _c;
+        const nav = typeof navigator !== "undefined" ? navigator : {};
+        const env = {
+            userAgent: nav.userAgent,
+            maxTouchPoints: nav.maxTouchPoints,
+            deviceMemory: nav.deviceMemory,
+            hardwareConcurrency: nav.hardwareConcurrency
+        };
+        let gl = (_b = (_a = viewer === null || viewer === void 0 ? void 0 : viewer.scene) === null || _a === void 0 ? void 0 : _a.context) === null || _b === void 0 ? void 0 : _b._gl;
+        let spare = false;
+        if (!gl && typeof document !== "undefined") {
+            try {
+                gl = document.createElement("canvas").getContext("webgl");
+                spare = Boolean(gl);
+            }
+            catch (e) {
+                gl = null;
+            }
+        }
+        // Detection must never stop a scene loading, so anything odd leaves the GPU unknown.
+        if (gl &&
+            typeof gl.getParameter === "function" &&
+            typeof gl.getExtension === "function") {
+            env.gpuRenderer = readRenderer(gl);
+            try {
+                env.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE) || undefined;
+                if (spare) {
+                    // Browsers cap live contexts per page; give this one back now rather than at GC.
+                    (_c = gl.getExtension("WEBGL_lose_context")) === null || _c === void 0 ? void 0 : _c.loseContext();
+                }
+            }
+            catch (e) {
+                // Leave it unknown.
+            }
+        }
+        return env;
+    }
+    /**
+     * Returns this device's profile, detecting it once per page. Pass the viewer to read its GL context.
+     */
+    function Get(viewer) {
+        var _a, _b;
+        if (!detected) {
+            const environment = readEnvironment(viewer);
+            detected = { ...Classify(environment), environment };
+        }
+        const demotion = readDemotion(Date.now());
+        const demoted = Math.min((_a = demotion === null || demotion === void 0 ? void 0 : demotion.count) !== null && _a !== void 0 ? _a : 0, DEMOTION_MAX);
+        let tier = ORDER[Math.max(0, ORDER.indexOf(detected.tier) - demoted)];
+        if (override) {
+            tier = override;
+        }
+        const profile = {
+            tier,
+            detectedTier: detected.tier,
+            gpuClass: detected.gpuClass,
+            mobile: detected.mobile,
+            demoted,
+            overridden: Boolean(override),
+            reasons: [...detected.reasons],
+            environment: { ...detected.environment }
+        };
+        if (!logged) {
+            logged = true;
+            console.info(`[DeviceProfile] tier ${profile.tier} (${profile.reasons.join(", ")}` +
+                `${demoted ? `, demoted ${demoted} after lost WebGL context` : ""}` +
+                `${override ? ", overridden" : ""}). GPU: ${(_b = profile.environment.gpuRenderer) !== null && _b !== void 0 ? _b : "unknown"}.`);
+        }
+        return profile;
+    }
+    DeviceProfile.Get = Get;
+    /**
+     * Returns the memory budgets for this device's tier, or for a given tier.
+     */
+    function GetBudget(tier) {
+        return DeviceProfile.BUDGETS[tier !== null && tier !== void 0 ? tier : Get().tier];
+    }
+    DeviceProfile.GetBudget = GetBudget;
+    /**
+     * Forces a tier, for a user who knows better than the guess. Null returns to detection.
+     */
+    function SetOverride(tier) {
+        const next = tier && ORDER.includes(tier) ? tier : null;
+        if (next === override) {
+            return;
+        }
+        override = next;
+        DeviceProfile.Changed.raiseEvent();
+    }
+    DeviceProfile.SetOverride = SetOverride;
+    /**
+     * Returns the forced tier, or null while detection decides.
+     */
+    function GetOverride() {
+        return override;
+    }
+    DeviceProfile.GetOverride = GetOverride;
+    /**
+     * Records that a WebGL context was lost, so this and later sessions start a tier lower.
+     */
+    function RecordContextLost() {
+        var _a, _b;
+        const now = Date.now();
+        const count = Math.min(((_b = (_a = readDemotion(now)) === null || _a === void 0 ? void 0 : _a.count) !== null && _b !== void 0 ? _b : 0) + 1, DEMOTION_MAX);
+        writeDemotion({ count, at: now });
+        console.warn(`[DeviceProfile] WebGL context lost; demoting the memory tier by ${count}.`);
+        DeviceProfile.Changed.raiseEvent();
+    }
+    DeviceProfile.RecordContextLost = RecordContextLost;
+    /**
+     * Forgets earlier context losses, for a host that offers a reset.
+     */
+    function ClearDemotion() {
+        writeDemotion(null);
+        DeviceProfile.Changed.raiseEvent();
+    }
+    DeviceProfile.ClearDemotion = ClearDemotion;
+    /**
+     * Reports the viewer's context losses. Safe to call repeatedly.
+     */
+    function WatchViewer(viewer) {
+        const canvas = viewer === null || viewer === void 0 ? void 0 : viewer.canvas;
+        if (!canvas ||
+            viewer[VIEWER_WATCH_KEY] ||
+            typeof canvas.addEventListener !== "function") {
+            return;
+        }
+        viewer[VIEWER_WATCH_KEY] = true;
+        canvas.addEventListener("webglcontextlost", () => {
+            // Ignore a loss caused by tearing the viewer down.
+            if (!viewer.isDestroyed()) {
+                RecordContextLost();
+            }
+        });
+    }
+    DeviceProfile.WatchViewer = WatchViewer;
+    /**
+     * Forgets the detected hardware and override, for tests.
+     */
+    function Reset() {
+        detected = null;
+        override = null;
+        logged = false;
+    }
+    DeviceProfile.Reset = Reset;
+})(DeviceProfile || (DeviceProfile = {}));
+
 /**
  * Returns if a given tileset is alive and in the scene.
  * @param viewer
@@ -16230,7 +17161,7 @@ function isAlive$2(viewer, cTileset) {
     }
     return viewer.scene.primitives.contains(cTileset);
 }
-const VIEWER_WATCH_KEY = "bruce-viewer-watch";
+const VIEWER_WATCH_KEY$1 = "bruce-viewer-watch";
 const WATCH_KEY = "bruce-tileset-watch";
 const VIEWER_DATE_RANGE_WATCH_KEY = "bruce-viewer-date-range-watch";
 const DATE_RANGE_WATCH_KEY = "bruce-tileset-date-range-watch";
@@ -16292,6 +17223,22 @@ function setDateRangeVisible(renderObject, visible) {
     }
     renderObject._bruceDateRangeVisible = visible;
 }
+// A tileset may pass its cache share by this fraction before Cesium coarsens it to fit.
+const TILESET_OVERFLOW_RATIO = 0.25;
+/*
+ * Returns the options capping a tileset's tile cache at the given MB, in the form the running Cesium reads.
+ */
+function getTilesetMemoryProps(mb) {
+    const prototype = Cesium3DTileset.prototype;
+    if ("cacheBytes" in prototype) {
+        const props = { cacheBytes: Math.round(mb * 1024 * 1024) };
+        if ("maximumCacheOverflowBytes" in prototype) {
+            props.maximumCacheOverflowBytes = Math.round(mb * TILESET_OVERFLOW_RATIO * 1024 * 1024);
+        }
+        return props;
+    }
+    return { maximumMemoryUsage: mb };
+}
 /**
  * Creates and returns a tileset instance from a given url.
  * This is made to handle the difference between old and new cesium versions.
@@ -16308,8 +17255,8 @@ async function createTileset(url, props, noMemoryLimit) {
     };
     Object.assign(defaultProps, ViewUtils.DefaultLightingProps());
     if (noMemoryLimit != true) {
-        // "The maximum amount of memory in MB that can be used by the tileset.".
-        defaultProps.maximumMemoryUsage = 512;
+        // The memory watcher narrows this to a share once the tileset joins it.
+        Object.assign(defaultProps, getTilesetMemoryProps(TilesetRenderEngine.GetTilesetMemoryBudget()));
     }
     const C3DT = Cesium3DTileset;
     if (C3DT.fromUrl) {
@@ -16861,10 +17808,23 @@ var TilesetRenderEngine;
     }
     TilesetRenderEngine.UnwatchDateRange = UnwatchDateRange;
     /**
-     * The maximum memory in MB that can be used by all tilesets.
-     * This is distributed evenly between all loaded tilesets.
+     * Total MB all tilesets may use, split evenly; null leaves it to the DeviceProfile tier.
+     */
+    TilesetRenderEngine.MAX_TILESET_MEMORY = null;
+    /**
+     * Smallest MB share a tileset gets; small, since Cesium coarsens one that needs more.
      */
-    TilesetRenderEngine.MAX_TILESET_MEMORY = 1024;
+    TilesetRenderEngine.MIN_TILESET_MEMORY = 32;
+    /**
+     * Returns the total MB all tilesets may use, from MAX_TILESET_MEMORY or else the device tier.
+     */
+    function GetTilesetMemoryBudget() {
+        if (Number.isFinite(TilesetRenderEngine.MAX_TILESET_MEMORY) && TilesetRenderEngine.MAX_TILESET_MEMORY > 0) {
+            return TilesetRenderEngine.MAX_TILESET_MEMORY;
+        }
+        return DeviceProfile.GetBudget().tilesetMb;
+    }
+    TilesetRenderEngine.GetTilesetMemoryBudget = GetTilesetMemoryBudget;
     /**
      * Watches tileset date cutoffs and toggles their primitive visibility based on the viewer clock.
      */
@@ -16955,23 +17915,26 @@ var TilesetRenderEngine;
         constructor(viewer) {
             this.watched = [];
             this.viewer = viewer;
+            DeviceProfile.Get(viewer);
+            DeviceProfile.WatchViewer(viewer);
+            this.removeChanged = DeviceProfile.Changed.addEventListener(() => this.distributeMemory());
         }
         distributeMemory() {
             this.clean();
-            // Total 1gb as default.
-            // We'll need to allow user to change this somehow.
-            const maxMemory = TilesetRenderEngine.MAX_TILESET_MEMORY;
-            // Minimum memory in MB per tileset.
-            const minMemory = 80;
-            const totalPerTileset = Math.max(this.watched.length ? maxMemory / this.watched.length : maxMemory, minMemory);
+            if (!this.watched.length) {
+                return;
+            }
+            const share = Math.max(GetTilesetMemoryBudget() / this.watched.length, TilesetRenderEngine.MIN_TILESET_MEMORY);
+            const props = getTilesetMemoryProps(share);
             this.watched.forEach(x => {
-                // Newer Cesium killed this property.
-                // TODO: Check if it's needed then.
-                x["maximumMemoryUsage"] = totalPerTileset;
+                Object.assign(x, props);
             });
         }
         destroy() {
+            var _a;
             this.watched = [];
+            (_a = this.removeChanged) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.removeChanged = null;
         }
         /**
          * Remove all dead tilesets.
@@ -17020,10 +17983,10 @@ var TilesetRenderEngine;
         if (!viewer || viewer.isDestroyed()) {
             return null;
         }
-        if (!viewer[VIEWER_WATCH_KEY]) {
-            viewer[VIEWER_WATCH_KEY] = new MemoryWatcher(viewer);
+        if (!viewer[VIEWER_WATCH_KEY$1]) {
+            viewer[VIEWER_WATCH_KEY$1] = new MemoryWatcher(viewer);
         }
-        return viewer[VIEWER_WATCH_KEY];
+        return viewer[VIEWER_WATCH_KEY$1];
     }
     TilesetRenderEngine.GetMemoryWatcher = GetMemoryWatcher;
     function GetDateRangeWatcher(viewer) {
@@ -28227,7 +29190,9 @@ var XGridsRenderEngine;
         if (loadUrl.indexOf("?") !== -1) {
             loadUrl = loadUrl.split("?")[0];
         }
-        let maxSplats = 6000000;
+        const profile = DeviceProfile.Get(viewer);
+        DeviceProfile.WatchViewer(viewer);
+        let maxSplats = DeviceProfile.GetBudget(profile.tier).splats;
         /*
          * Configures optional LOD capabilities once metadata or initial geometry is ready.
          */
@@ -28312,8 +29277,7 @@ var XGridsRenderEngine;
         }
         try {
             const sdkBudget = typeof obj.getCurrentConfig === "function" ? (_d = obj.getCurrentConfig()) === null || _d === void 0 ? void 0 : _d.maxLoadSplatCount : undefined;
-            // Preserve the SDK's mobile and weak-GPU limits before applying any temporary startup cap.
-            maxSplats = Number.isFinite(sdkBudget) && sdkBudget > 0 && sdkBudget <= 2000000 ? sdkBudget : 6000000;
+            maxSplats = GetSplatBudget(sdkBudget, profile);
             if (LCCRender.nextspaceMetadataReady === 1 &&
                 typeof obj.setNextspaceMetadataCallback === "function" &&
                 typeof obj.setMaxSplats === "function") {
@@ -28354,6 +29318,21 @@ var XGridsRenderEngine;
         return obj;
     }
     XGridsRenderEngine.Render = Render;
+    /*
+     * The most splats a scan may load: the tier's, lowered by the SDK's GPU limit unless overridden.
+     */
+    function GetSplatBudget(sdkBudget, profile) {
+        const budget = DeviceProfile.GetBudget(profile.tier).splats;
+        // Above 2M the SDK is reporting its flat default, not a limit it chose for this GPU.
+        if (!profile.overridden &&
+            Number.isFinite(sdkBudget) &&
+            sdkBudget > 0 &&
+            sdkBudget <= 2000000) {
+            return Math.min(sdkBudget, budget);
+        }
+        return budget;
+    }
+    XGridsRenderEngine.GetSplatBudget = GetSplatBudget;
     /*
      * Detaches optional tuning before unloading the scan.
      */
@@ -38815,6 +39794,1238 @@ var TileRenderEngine;
     })(Terrain = TileRenderEngine.Terrain || (TileRenderEngine.Terrain = {}));
 })(TileRenderEngine || (TileRenderEngine = {}));
 
+// Builds simple meshes into binary glTF in code. Nothing here imports Cesium, so it can move to bruce-models as is.
+const GLB_MAGIC = 0x46546C67;
+const GLB_CHUNK_JSON = 0x4E4F534A;
+const GLB_CHUNK_BIN = 0x004E4942;
+const GL_ARRAY_BUFFER = 34962;
+const GL_ELEMENT_ARRAY_BUFFER = 34963;
+const GL_UNSIGNED_SHORT = 5123;
+const GL_UNSIGNED_INT = 5125;
+const GL_FLOAT = 5126;
+const GL_TRIANGLES = 4;
+/**
+ * Writes meshes as binary glTF (GLB), for models simple enough to describe in code rather than ship as files.
+ */
+var GltfGenerator;
+(function (GltfGenerator) {
+    /**
+     * Vertices and triangles collected by the shape functions, one material's worth.
+     */
+    class Mesh {
+        constructor() {
+            this.positions = [];
+            this.normals = [];
+            this.indices = [];
+        }
+        AddVertex(position, normal) {
+            this.positions.push(position[0], position[1], position[2]);
+            this.normals.push(normal[0], normal[1], normal[2]);
+            return this.positions.length / 3 - 1;
+        }
+        /**
+         * Adds a triangle wound so its front faces along normal, whichever order the corners come in.
+         * Per corner normals smooth it; without them every corner takes the face normal.
+         */
+        AddTriangle(a, b, c, normal, corners) {
+            var _a, _b, _c;
+            const ia = this.AddVertex(a, (_a = corners === null || corners === void 0 ? void 0 : corners[0]) !== null && _a !== void 0 ? _a : normal);
+            const ib = this.AddVertex(b, (_b = corners === null || corners === void 0 ? void 0 : corners[1]) !== null && _b !== void 0 ? _b : normal);
+            const ic = this.AddVertex(c, (_c = corners === null || corners === void 0 ? void 0 : corners[2]) !== null && _c !== void 0 ? _c : normal);
+            if (Dot(Cross(Sub(b, a), Sub(c, a)), normal) >= 0) {
+                this.indices.push(ia, ib, ic);
+            }
+            else {
+                this.indices.push(ia, ic, ib);
+            }
+        }
+        /**
+         * Joins three added vertices into a triangle facing along normal, so shapes can share corners.
+         */
+        AddIndexedTriangle(ia, ib, ic, normal) {
+            const at = (i) => [this.positions[i * 3], this.positions[i * 3 + 1], this.positions[i * 3 + 2]];
+            const a = at(ia);
+            if (Dot(Cross(Sub(at(ib), a), Sub(at(ic), a)), normal) >= 0) {
+                this.indices.push(ia, ib, ic);
+            }
+            else {
+                this.indices.push(ia, ic, ib);
+            }
+        }
+        get VertexCount() {
+            return this.positions.length / 3;
+        }
+    }
+    GltfGenerator.Mesh = Mesh;
+    function Add(a, b) {
+        return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+    }
+    GltfGenerator.Add = Add;
+    function Sub(a, b) {
+        return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+    }
+    GltfGenerator.Sub = Sub;
+    function Scale(a, s) {
+        return [a[0] * s, a[1] * s, a[2] * s];
+    }
+    GltfGenerator.Scale = Scale;
+    function Dot(a, b) {
+        return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+    }
+    GltfGenerator.Dot = Dot;
+    function Cross(a, b) {
+        return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+    }
+    GltfGenerator.Cross = Cross;
+    function Normalize(a) {
+        const length = Math.hypot(a[0], a[1], a[2]);
+        return length ? Scale(a, 1 / length) : [0, 0, 0];
+    }
+    GltfGenerator.Normalize = Normalize;
+    /*
+     * Two unit vectors at right angles to an axis and each other, the first along start where one is given.
+     */
+    function perpendiculars(axis, start) {
+        const n = Normalize(axis);
+        let u = start ? Sub(start, Scale(n, Dot(start, n))) : null;
+        if (!u || Math.hypot(u[0], u[1], u[2]) < 1e-9) {
+            u = Math.abs(n[0]) < 0.9 ? Cross(n, [1, 0, 0]) : Cross(n, [0, 1, 0]);
+        }
+        u = Normalize(u);
+        return [u, Cross(n, u)];
+    }
+    /*
+     * The point on a circle around centre at a given turn, in the plane the two perpendiculars span.
+     */
+    function onCircle(centre, u, v, radius, angle) {
+        return Add(centre, Add(Scale(u, Math.cos(angle) * radius), Scale(v, Math.sin(angle) * radius)));
+    }
+    /**
+     * Adds a flat disc facing along normal.
+     */
+    function AddDisc(mesh, params) {
+        const { centre, radius, sides } = params;
+        const normal = Normalize(params.normal);
+        const [u, v] = perpendiculars(normal, params.start);
+        for (let i = 0; i < sides; i++) {
+            const a = onCircle(centre, u, v, radius, i / sides * Math.PI * 2);
+            const b = onCircle(centre, u, v, radius, (i + 1) / sides * Math.PI * 2);
+            mesh.AddTriangle(centre, a, b, normal);
+        }
+    }
+    GltfGenerator.AddDisc = AddDisc;
+    /**
+     * Adds a smooth sided cylinder between two points, closed at the start by default.
+     */
+    function AddCylinder(mesh, params) {
+        const { start, end, radius, sides } = params;
+        const axis = Normalize(Sub(end, start));
+        const [u, v] = perpendiculars(axis);
+        for (let i = 0; i < sides; i++) {
+            const angleA = i / sides * Math.PI * 2;
+            const angleB = (i + 1) / sides * Math.PI * 2;
+            const outA = onCircle([0, 0, 0], u, v, 1, angleA);
+            const outB = onCircle([0, 0, 0], u, v, 1, angleB);
+            const a0 = onCircle(start, u, v, radius, angleA);
+            const b0 = onCircle(start, u, v, radius, angleB);
+            const a1 = onCircle(end, u, v, radius, angleA);
+            const b1 = onCircle(end, u, v, radius, angleB);
+            const face = Normalize(Add(outA, outB));
+            mesh.AddTriangle(a0, b0, b1, face, [outA, outB, outB]);
+            mesh.AddTriangle(a0, b1, a1, face, [outA, outB, outA]);
+        }
+        if (params.capStart != false) {
+            AddDisc(mesh, { centre: start, normal: Scale(axis, -1), radius, sides });
+        }
+        if (params.capEnd) {
+            AddDisc(mesh, { centre: end, normal: axis, radius, sides });
+        }
+    }
+    GltfGenerator.AddCylinder = AddCylinder;
+    /**
+     * Adds a cone from a base circle to a tip, closed at the base by default.
+     */
+    function AddCone(mesh, params) {
+        const { base, tip, radius, sides } = params;
+        const toTip = Sub(tip, base);
+        const height = Math.hypot(toTip[0], toTip[1], toTip[2]);
+        const axis = Normalize(toTip);
+        const [u, v] = perpendiculars(axis, params.start);
+        // A side normal leans toward the tip by the slope of the side.
+        const sideNormal = (angle) => Normalize(Add(Scale(onCircle([0, 0, 0], u, v, 1, angle), height), Scale(axis, radius)));
+        for (let i = 0; i < sides; i++) {
+            const angleA = i / sides * Math.PI * 2;
+            const angleB = (i + 1) / sides * Math.PI * 2;
+            const a = onCircle(base, u, v, radius, angleA);
+            const b = onCircle(base, u, v, radius, angleB);
+            const face = sideNormal((angleA + angleB) / 2);
+            mesh.AddTriangle(a, b, tip, face, params.faceted ? undefined : [sideNormal(angleA), sideNormal(angleB), face]);
+        }
+        if (params.cap != false) {
+            AddDisc(mesh, { centre: base, normal: Scale(axis, -1), radius, sides, start: params.start });
+        }
+    }
+    GltfGenerator.AddCone = AddCone;
+    /**
+     * Adds a smooth ring of tube around an axis through centre.
+     */
+    function AddTorus(mesh, params) {
+        const { centre, radius, tube, segments, sides } = params;
+        const axis = Normalize(params.axis);
+        const [u, v] = perpendiculars(axis);
+        // A grid of shared corners, wrapping round both ways.
+        const first = mesh.VertexCount;
+        for (let i = 0; i < segments; i++) {
+            const out = onCircle([0, 0, 0], u, v, 1, i / segments * Math.PI * 2);
+            for (let j = 0; j < sides; j++) {
+                const turn = j / sides * Math.PI * 2;
+                const normal = Add(Scale(out, Math.cos(turn)), Scale(axis, Math.sin(turn)));
+                mesh.AddVertex(Add(Add(centre, Scale(out, radius)), Scale(normal, tube)), normal);
+            }
+        }
+        const at = (i, j) => first + (i % segments) * sides + (j % sides);
+        const normalAt = (i) => [mesh.normals[i * 3], mesh.normals[i * 3 + 1], mesh.normals[i * 3 + 2]];
+        for (let i = 0; i < segments; i++) {
+            for (let j = 0; j < sides; j++) {
+                const quad = [at(i, j), at(i + 1, j), at(i + 1, j + 1), at(i, j + 1)];
+                const normal = Normalize(Add(normalAt(quad[0]), normalAt(quad[2])));
+                mesh.AddIndexedTriangle(quad[0], quad[1], quad[2], normal);
+                mesh.AddIndexedTriangle(quad[0], quad[2], quad[3], normal);
+            }
+        }
+    }
+    GltfGenerator.AddTorus = AddTorus;
+    /**
+     * Adds a flat convex outline, given in a plane's own across and up coordinates, facing along normal.
+     */
+    function AddConvexOutline(mesh, params) {
+        const { points, origin, across, up } = params;
+        const normal = Normalize(params.normal);
+        const at = ([x, y]) => Add(origin, Add(Scale(across, x), Scale(up, y)));
+        for (let i = 1; i < points.length - 1; i++) {
+            mesh.AddTriangle(at(points[0]), at(points[i]), at(points[i + 1]), normal);
+        }
+    }
+    GltfGenerator.AddConvexOutline = AddConvexOutline;
+    function align4(length) {
+        return Math.ceil(length / 4) * 4;
+    }
+    function bounds(positions) {
+        const min = [Infinity, Infinity, Infinity];
+        const max = [-Infinity, -Infinity, -Infinity];
+        for (let i = 0; i < positions.length; i++) {
+            const k = i % 3;
+            min[k] = Math.min(min[k], positions[i]);
+            max[k] = Math.max(max[k], positions[i]);
+        }
+        return { min, max };
+    }
+    /**
+     * Packs a mesh into GLB bytes, under a chain of node matrices (outermost first) when given.
+     */
+    function ToGlb(params) {
+        var _a, _b, _c;
+        const { mesh, material } = params;
+        const count = mesh.VertexCount;
+        const wide = count > 0xFFFF;
+        const IndexArray = wide ? Uint32Array : Uint16Array;
+        const indexLength = mesh.indices.length * IndexArray.BYTES_PER_ELEMENT;
+        const indexBytes = align4(indexLength);
+        const vertexBytes = count * 12;
+        const bin = new ArrayBuffer(indexBytes + vertexBytes * 2);
+        new IndexArray(bin, 0, mesh.indices.length).set(mesh.indices);
+        new Float32Array(bin, indexBytes, count * 3).set(mesh.positions);
+        new Float32Array(bin, indexBytes + vertexBytes, count * 3).set(mesh.normals);
+        // The mesh node is last, each matrix node holding the next.
+        const matrices = (_a = params.matrices) !== null && _a !== void 0 ? _a : [];
+        const nodes = matrices.map((matrix, i) => ({ matrix, children: [i + 1] }));
+        nodes.push({ mesh: 0 });
+        const json = {
+            asset: { version: "2.0", generator: "bruce-cesium GltfGenerator" },
+            scene: 0,
+            scenes: [{ nodes: [0] }],
+            nodes,
+            meshes: [{ primitives: [{ attributes: { POSITION: 1, NORMAL: 2 }, indices: 0, material: 0, mode: GL_TRIANGLES }] }],
+            materials: [{
+                    pbrMetallicRoughness: {
+                        baseColorFactor: material.color,
+                        metallicFactor: (_b = material.metallic) !== null && _b !== void 0 ? _b : 0,
+                        roughnessFactor: (_c = material.roughness) !== null && _c !== void 0 ? _c : 1
+                    },
+                    doubleSided: Boolean(material.doubleSided)
+                }],
+            buffers: [{ byteLength: bin.byteLength }],
+            bufferViews: [
+                { buffer: 0, byteOffset: 0, byteLength: indexLength, target: GL_ELEMENT_ARRAY_BUFFER },
+                { buffer: 0, byteOffset: indexBytes, byteLength: vertexBytes, target: GL_ARRAY_BUFFER },
+                { buffer: 0, byteOffset: indexBytes + vertexBytes, byteLength: vertexBytes, target: GL_ARRAY_BUFFER }
+            ],
+            accessors: [
+                { bufferView: 0, componentType: wide ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, count: mesh.indices.length, type: "SCALAR" },
+                { bufferView: 1, componentType: GL_FLOAT, count, type: "VEC3", ...bounds(mesh.positions) },
+                { bufferView: 2, componentType: GL_FLOAT, count, type: "VEC3" }
+            ]
+        };
+        let text = JSON.stringify(json);
+        text += " ".repeat(align4(text.length) - text.length);
+        const jsonBytes = new TextEncoder().encode(text);
+        const glb = new Uint8Array(20 + jsonBytes.length + 8 + bin.byteLength);
+        const view = new DataView(glb.buffer);
+        view.setUint32(0, GLB_MAGIC, true);
+        view.setUint32(4, 2, true);
+        view.setUint32(8, glb.length, true);
+        view.setUint32(12, jsonBytes.length, true);
+        view.setUint32(16, GLB_CHUNK_JSON, true);
+        glb.set(jsonBytes, 20);
+        const binStart = 20 + jsonBytes.length;
+        view.setUint32(binStart, bin.byteLength, true);
+        view.setUint32(binStart + 4, GLB_CHUNK_BIN, true);
+        glb.set(new Uint8Array(bin), binStart + 8);
+        return glb;
+    }
+    GltfGenerator.ToGlb = ToGlb;
+    /**
+     * Packs a mesh into a GLB data URI, which loads as a model url with nothing to fetch.
+     */
+    function ToDataUri(params) {
+        const glb = ToGlb(params);
+        let binary = "";
+        for (let i = 0; i < glb.length; i += 0x8000) {
+            binary += String.fromCharCode.apply(null, glb.subarray(i, i + 0x8000));
+        }
+        return "data:model/gltf-binary;base64," + btoa(binary);
+    }
+    GltfGenerator.ToDataUri = ToDataUri;
+})(GltfGenerator || (GltfGenerator = {}));
+
+// Sides on an arrow's shaft and cone.
+const ARROW_SIDES = 16;
+const SHAFT_RADIUS = 2.4;
+const SHAFT_LENGTH = 265;
+const CONE_RADIUS = 10;
+const CONE_BASE = 264.6;
+const CONE_TIP = 306.3;
+const RING_RADIUS = 210;
+const RING_TUBE = 1;
+const RING_SEGMENTS = 60;
+const RING_SIDES = 10;
+// The ring's two arrowheads sit either side of its 45 degree mark, each pointing back toward it.
+const RING_MARK_ANGLES = [137.64, -47.64];
+const RING_MARK_LENGTH = 5.82;
+const RING_MARK_CENTRE = 209.8;
+const RING_MARK_RADIUS = 8.5;
+const RING_MARK_SIDES = 8;
+// Turns the original models' Y up node into the Z up frame the pieces were drawn in.
+const ROOT_MATRIX = [1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1];
+// Points a piece drawn along +Z down another axis, as the original models' mesh nodes did.
+const TO_X_MATRIX = [0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1];
+const TO_Y_ARROW_MATRIX = [0, 0, -1, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1];
+const TO_Y_RING_MATRIX = [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1];
+const RED = { color: [1, 0, 0, 1] };
+const GREEN = { color: [0.2196, 0.5216, 0.1647, 1] };
+const BLUE = { color: [0.1608, 0.3843, 0.698, 1] };
+const LETTER_X = {
+    across: [0, 1, 0],
+    facing: [-1, 0, 0],
+    strokes: [
+        [[16.4, 318.6], [16.4, 324.2], [-19.4, 349.8], [-19.4, 343.9]],
+        [[-19.4, 316.9], [-19.4, 322.6], [16.4, 348.8], [16.4, 343.6]]
+    ]
+};
+const LETTER_Y = {
+    across: [0, 1, 0],
+    facing: [-1, 0, 0],
+    strokes: [
+        [[-1.9, 320.1], [2.8, 320.1], [2.8, 337.7], [-1.9, 337.7]],
+        [[-1.9, 335.3], [2.8, 335.3], [-10.7, 355.9], [-16.2, 355.9]],
+        [[-1.9, 335.3], [2.8, 335.3], [16.6, 355.9], [10.9, 355.9]]
+    ]
+};
+const LETTER_Z = {
+    across: [1, 0, 0],
+    facing: [0, -1, 0],
+    strokes: [
+        [[-14.6, 319], [13.7, 319], [13.7, 323.3], [-14.6, 323.3]],
+        [[-14.6, 323.3], [-9.1, 323.3], [13.1, 350.6], [7.5, 350.6]],
+        [[-12.5, 350.6], [13.1, 350.6], [13.1, 354.8], [-12.5, 354.8]]
+    ]
+};
+/*
+ * An axis arrow along +Z: shaft, cone and the axis letter past the tip.
+ */
+function arrowMesh(letter) {
+    const mesh = new GltfGenerator.Mesh();
+    GltfGenerator.AddCylinder(mesh, { start: [0, 0, 0], end: [0, 0, SHAFT_LENGTH], radius: SHAFT_RADIUS, sides: ARROW_SIDES });
+    GltfGenerator.AddCone(mesh, { base: [0, 0, CONE_BASE], tip: [0, 0, CONE_TIP], radius: CONE_RADIUS, sides: ARROW_SIDES });
+    for (const stroke of letter.strokes) {
+        GltfGenerator.AddConvexOutline(mesh, { points: stroke, origin: [0, 0, 0], across: letter.across, up: [0, 0, 1], normal: letter.facing });
+    }
+    return mesh;
+}
+function onRing(degrees, radius) {
+    const angle = degrees * Math.PI / 180;
+    return [Math.cos(angle) * radius, Math.sin(angle) * radius, 0];
+}
+/*
+ * A rotation ring about +Z with its two arrowheads.
+ */
+function ringMesh() {
+    const mesh = new GltfGenerator.Mesh();
+    GltfGenerator.AddTorus(mesh, {
+        centre: [0, 0, 0],
+        axis: [0, 0, 1],
+        radius: RING_RADIUS,
+        tube: RING_TUBE,
+        segments: RING_SEGMENTS,
+        sides: RING_SIDES
+    });
+    for (const degrees of RING_MARK_ANGLES) {
+        const toward = degrees > 45 ? -RING_MARK_LENGTH : RING_MARK_LENGTH;
+        GltfGenerator.AddCone(mesh, {
+            base: onRing(degrees, RING_MARK_CENTRE),
+            tip: onRing(degrees + toward, RING_MARK_CENTRE),
+            radius: RING_MARK_RADIUS,
+            sides: RING_MARK_SIDES,
+            faceted: true,
+            // A rim corner points at the ring's centre, as the original arrowheads' did.
+            start: onRing(degrees, 1)
+        });
+    }
+    return mesh;
+}
+/**
+ * The transform gizmo's pieces as GLB data URIs, built on first use so there are no model files to host.
+ * Sizes, colours and frames match the models they replaced (Navigator's public/res/gizmo), scales included.
+ */
+var GltfGizmo;
+(function (GltfGizmo) {
+    let EPiece;
+    (function (EPiece) {
+        EPiece["X"] = "x";
+        EPiece["Y"] = "y";
+        EPiece["Z"] = "z";
+        EPiece["XRotation"] = "x-rot";
+        EPiece["YRotation"] = "y-rot";
+        EPiece["ZRotation"] = "z-rot";
+    })(EPiece = GltfGizmo.EPiece || (GltfGizmo.EPiece = {}));
+    const BUILDERS = {
+        [EPiece.X]: () => GltfGenerator.ToDataUri({ mesh: arrowMesh(LETTER_X), material: RED, matrices: [ROOT_MATRIX, TO_X_MATRIX] }),
+        [EPiece.Y]: () => GltfGenerator.ToDataUri({ mesh: arrowMesh(LETTER_Y), material: GREEN, matrices: [ROOT_MATRIX, TO_Y_ARROW_MATRIX] }),
+        [EPiece.Z]: () => GltfGenerator.ToDataUri({ mesh: arrowMesh(LETTER_Z), material: BLUE, matrices: [ROOT_MATRIX] }),
+        [EPiece.XRotation]: () => GltfGenerator.ToDataUri({ mesh: ringMesh(), material: RED, matrices: [ROOT_MATRIX, TO_X_MATRIX] }),
+        [EPiece.YRotation]: () => GltfGenerator.ToDataUri({ mesh: ringMesh(), material: GREEN, matrices: [ROOT_MATRIX, TO_Y_RING_MATRIX] }),
+        [EPiece.ZRotation]: () => GltfGenerator.ToDataUri({ mesh: ringMesh(), material: BLUE, matrices: [ROOT_MATRIX] })
+    };
+    // Built pieces, so every gizmo shares one string per piece and CesiumJS's model cache sees the same url.
+    const built = {};
+    /**
+     * Returns a piece's model as a data URI, to pass wherever a model url is taken.
+     */
+    function GetUri(piece) {
+        if (!built[piece]) {
+            built[piece] = BUILDERS[piece]();
+        }
+        return built[piece];
+    }
+    GltfGizmo.GetUri = GetUri;
+})(GltfGizmo || (GltfGizmo = {}));
+
+// viewer[CLASS_INSTANCE_KEY] will point at an instance of MapGridHandler.
+const CLASS_INSTANCE_KEY = "nextspace-navigator-grid-handler";
+// viewer[UPDATE_MARKER_KEY] will point at a number that is incremented every time the grid is updated.
+// This is used to determine if the grid is still valid or if it needs to be redrawn.
+const UPDATE_MARKER_KEY = "nextspace-marker-grid";
+// viewer[LAST_SETTINGS_KEY] will point at the last settings used for the grid.
+const LAST_SETTINGS_KEY = "nextspace-navigator-last-settings-grid";
+/*
+ * The point a distance in metres along a heading in degrees from another, over a spherical earth.
+ */
+function offsetPoint$1(point, distance, heading) {
+    // Radius of earth.
+    const radius = 6371e3;
+    const δ = distance / radius;
+    const θ = Math$1.toRadians(heading);
+    const φ1 = Math$1.toRadians(point.latitude);
+    const λ1 = Math$1.toRadians(point.longitude);
+    const sinφ2 = Math.sin(φ1) * Math.cos(δ) + Math.cos(φ1) * Math.sin(δ) * Math.cos(θ);
+    const φ2 = Math.asin(sinφ2);
+    const y = Math.sin(θ) * Math.sin(δ) * Math.cos(φ1);
+    const x = Math.cos(δ) - Math.sin(φ1) * sinφ2;
+    const λ2 = λ1 + Math.atan2(y, x);
+    return {
+        altitude: point.altitude,
+        latitude: Math$1.toDegrees(φ2),
+        longitude: Math$1.toDegrees(λ2)
+    };
+}
+/**
+ * Handler for drawing a grid of lines on the map with a specified spacing.
+ * Initially this grid is for model-space viewing which means we start at 0,0 lat/lon and have it expand from there.
+ * However, it should be a general-use tool for drawing a grid anywhere.
+ *
+ * It reacts to camera changes and draws the grid within view with padding.
+ * This helps avoid performance issues around drawing too many lines.
+ */
+class MapGridHandler {
+    constructor(viewer, spacingInMeters = 100, modelSpace = false) {
+        this.gridCenterGizmoPieces = [];
+        this.maxCacheSize = 1000;
+        // === Thresholds for grid stability.
+        // As a fraction of current grid extent.
+        this.CAMERA_MOVE_THRESHOLD = 0.5;
+        // 40% change in camera height triggers redraw.
+        this.HEIGHT_CHANGE_THRESHOLD = 0.4;
+        // 40% change in grid extent triggers redraw.
+        this.GRID_EXTENT_CHANGE_THRESHOLD = 0.4;
+        // 5km - distance that triggers origin reset.
+        this.EXTREME_DISTANCE_THRESHOLD = 5000;
+        // Grid limits to prevent drawing too many lines.
+        this.MAX_LINES = 500;
+        // 50% padding around visible area.
+        this.VIEW_PADDING_FACTOR = 0.5;
+        // Minimum pixels between grid lines to show them.
+        this.MIN_GRID_PIXEL_SIZE = 20;
+        // Base ratio - will be adjusted dynamically based on spacing size and camera height.
+        this.BASE_MAX_VISIBILITY_RATIO = 30;
+        // Height to spacing ratio.
+        this.HEIGHT_TO_SPACING_RATIO = 100;
+        // === Label settings
+        // Label every nth intersection.
+        this.LABEL_INTERVAL = 2;
+        // Maximum number of labels to show.
+        this.MAX_LABELS = 100;
+        // Spacing levels to use for adaptive spacing.
+        this.SPACING_LEVELS = [
+            1, 2, 5, 10, 20, 25, 50, 100, 200, 250, 300, 400, 500, 1000, 2000, 2500, 5000, 10000, 20000, 25000, 50000, 100000
+        ];
+        // Minimum zoom distance to prevent precision issues.
+        this.MINIMUM_ZOOM_DISTANCE = 40;
+        // Base spacing to use for adaptive spacing.
+        this.BASE_SPACING = 1;
+        // Maximum number of attempts to find a suitable spacing.
+        this.MAX_ADAPTIVE_ATTEMPTS = 5;
+        this.viewer = viewer;
+        this.spacingInMeters = spacingInMeters;
+        this.isUpdating = false;
+        this.modelSpace = modelSpace;
+        this.lastCameraPosition = null;
+        this.fixedGridOrigin = null;
+        this.lastGridExtent = 0;
+        this.offsetCache = new Map();
+        this.gridPrimitives = new PrimitiveCollection();
+        this.viewer.scene.primitives.add(this.gridPrimitives);
+        this.currentMarker = viewer[UPDATE_MARKER_KEY] || 1;
+        const isMac = typeof navigator !== "undefined" && (navigator.platform.toUpperCase().indexOf("MAC") !== -1 ||
+            navigator.userAgent.toUpperCase().indexOf("MAC") !== -1);
+        if (modelSpace && isMac) {
+            console.log("[MAC-FIX] Applying camera distance limits for Mac");
+            viewer.scene.screenSpaceCameraController.minimumZoomDistance = this.MINIMUM_ZOOM_DISTANCE;
+        }
+        const manager = ViewerUtils.GetManager({
+            viewer: this.viewer,
+            createIfMissing: false
+        });
+        if (manager) {
+            this.cameraChangeRemoval = manager.Monitor.Updated().Subscribe(() => {
+                this.onCameraChanged();
+            });
+        }
+        // Initial grid draw.
+        this.onCameraChanged();
+    }
+    Update(spacingInMeters, modelSpace) {
+        this.currentMarker = this.viewer[UPDATE_MARKER_KEY] || 1;
+        let needsUpdate = false;
+        if (this.spacingInMeters !== spacingInMeters) {
+            this.spacingInMeters = spacingInMeters;
+            needsUpdate = true;
+        }
+        if (modelSpace !== undefined && this.modelSpace !== modelSpace) {
+            this.modelSpace = modelSpace;
+            needsUpdate = true;
+        }
+        if (needsUpdate) {
+            this.clearGrid();
+            // When spacing or model space changes, clear the cached origin to force recalculation
+            // This ensures grid alignment at the new spacing.
+            this.fixedGridOrigin = null;
+            this.offsetCache.clear();
+            this.onCameraChanged();
+        }
+    }
+    Dispose() {
+        this.clearGrid();
+        this.clearGizmoPieces();
+        if (this.cameraChangeRemoval) {
+            this.cameraChangeRemoval();
+            this.cameraChangeRemoval = null;
+        }
+        if (this.gridPrimitives) {
+            this.viewer.scene.primitives.remove(this.gridPrimitives);
+            this.gridPrimitives = null;
+        }
+        if (this.viewer) {
+            this.viewer = null;
+        }
+        this.offsetCache.clear();
+        this.fixedGridOrigin = null;
+    }
+    clearGrid() {
+        if (this.gridPrimitives) {
+            this.gridPrimitives.removeAll();
+            this.gridLines = null;
+            this.gridLabels = null;
+        }
+    }
+    calculateAdaptiveSpacing(cameraHeight, baseSpacing) {
+        // Define spacing levels that look good (powers of 2, 5, and 10)
+        const spacingLevels = this.SPACING_LEVELS;
+        // Ensure base spacing is at least 1m
+        const adjustedBaseSpacing = Math.max(this.BASE_SPACING, baseSpacing);
+        // For very close cameras, use much smaller spacing regardless of base
+        if (cameraHeight < 10) {
+            // Find the smallest reasonable spacing for this height
+            // Rule: spacing should be roughly 1/20th to 1/50th of camera height, but at least 1m
+            const targetSpacing = Math.max(this.BASE_SPACING, cameraHeight / 30);
+            // Find the closest spacing level to our target
+            let bestSpacing = this.BASE_SPACING; // Start with minimum
+            let bestDifference = Math.abs(1 - targetSpacing);
+            for (const spacing of spacingLevels) {
+                if (spacing >= this.BASE_SPACING) { // Only consider valid spacings
+                    const difference = Math.abs(spacing - targetSpacing);
+                    if (difference < bestDifference) {
+                        bestSpacing = spacing;
+                        bestDifference = difference;
+                    }
+                }
+            }
+            return bestSpacing;
+        }
+        // For medium distances (10m - 200m), scale more gradually
+        if (cameraHeight < 200) {
+            const targetSpacing = cameraHeight / 10; // More conservative scaling// Find closest spacing level, but prefer going up from base spacing
+            let bestSpacing = adjustedBaseSpacing;
+            let bestDifference = Math.abs(adjustedBaseSpacing - targetSpacing);
+            for (const spacing of spacingLevels) {
+                if (spacing >= Math.min(adjustedBaseSpacing, targetSpacing)) {
+                    const difference = Math.abs(spacing - targetSpacing);
+                    if (difference < bestDifference) {
+                        bestSpacing = spacing;
+                        bestDifference = difference;
+                    }
+                }
+            }
+            return bestSpacing;
+        }
+        // For far distances (100m+), scale up aggressively
+        const targetSpacing = cameraHeight / 20;
+        // Find the spacing level that's closest to target but not smaller than base
+        let bestSpacing = adjustedBaseSpacing;
+        let bestDifference = Math.abs(adjustedBaseSpacing - targetSpacing);
+        for (const spacing of spacingLevels) {
+            if (spacing >= adjustedBaseSpacing) {
+                const difference = Math.abs(spacing - targetSpacing);
+                if (difference < bestDifference) {
+                    bestSpacing = spacing;
+                    bestDifference = difference;
+                }
+            }
+        }
+        return bestSpacing;
+    }
+    /*
+     * The point model-space treats as 0,0,0: the UCS in UCS placement, otherwise 0,0 lat/lon at sea level.
+     */
+    modelSpaceOrigin() {
+        const origin = ViewUtils.IsModelSpaceUcs(this.viewer) ? ViewUtils.GetModelSpaceOrigin(this.viewer) : null;
+        return origin !== null && origin !== void 0 ? origin : { latitude: 0, longitude: 0, altitude: 0 };
+    }
+    /*
+     * The origin as a scene position, where the axis gizmo sits.
+     */
+    modelSpaceOriginPos3d() {
+        const origin = this.modelSpaceOrigin();
+        return Cartesian3.fromDegrees(origin.longitude, origin.latitude, origin.altitude);
+    }
+    drawGizmoPieces() {
+        if (this.gridCenterGizmoPieces.length) {
+            return;
+        }
+        // X.
+        {
+            const pos3d = this.modelSpaceOriginPos3d();
+            const scale = new CallbackProperty(() => Cartesian3.distance(this.viewer.camera.position, pos3d) * 0.0002, false);
+            const orientation = Transforms.headingPitchRollQuaternion(pos3d, new HeadingPitchRoll(Math$1.toRadians(90), 0, 0));
+            const entity = this.viewer.entities.add(new Entity({
+                model: {
+                    uri: GltfGizmo.GetUri(GltfGizmo.EPiece.X),
+                    heightReference: HeightReference.NONE,
+                    shadows: ShadowMode.DISABLED,
+                    distanceDisplayCondition: new DistanceDisplayCondition(0, Number.MAX_VALUE),
+                    scale
+                },
+                position: pos3d,
+                orientation: new ConstantProperty(orientation)
+            }));
+            this.gridCenterGizmoPieces.push(entity);
+        }
+        // Y.
+        {
+            const pos3d = this.modelSpaceOriginPos3d();
+            const scale = new CallbackProperty(() => Cartesian3.distance(this.viewer.camera.position, pos3d) * 0.0002, false);
+            const orientation = Transforms.headingPitchRollQuaternion(pos3d, new HeadingPitchRoll(Math$1.toRadians(90), 0, 0));
+            const entity = this.viewer.entities.add(new Entity({
+                model: {
+                    uri: GltfGizmo.GetUri(GltfGizmo.EPiece.Y),
+                    heightReference: HeightReference.NONE,
+                    shadows: ShadowMode.DISABLED,
+                    distanceDisplayCondition: new DistanceDisplayCondition(0, Number.MAX_VALUE),
+                    scale
+                },
+                position: pos3d,
+                orientation: new ConstantProperty(orientation)
+            }));
+            this.gridCenterGizmoPieces.push(entity);
+        }
+        // Z.
+        {
+            const pos3d = this.modelSpaceOriginPos3d();
+            const scale = new CallbackProperty(() => Cartesian3.distance(this.viewer.camera.position, pos3d) * 0.0002, false);
+            const orientation = Transforms.headingPitchRollQuaternion(pos3d, new HeadingPitchRoll(Math$1.toRadians(90), 0, 0));
+            const entity = this.viewer.entities.add(new Entity({
+                model: {
+                    uri: GltfGizmo.GetUri(GltfGizmo.EPiece.Z),
+                    heightReference: HeightReference.NONE,
+                    shadows: ShadowMode.DISABLED,
+                    distanceDisplayCondition: new DistanceDisplayCondition(0, Number.MAX_VALUE),
+                    scale
+                },
+                position: pos3d,
+                orientation: new ConstantProperty(orientation)
+            }));
+            this.gridCenterGizmoPieces.push(entity);
+        }
+    }
+    clearGizmoPieces() {
+        for (const piece of this.gridCenterGizmoPieces) {
+            if (piece && this.viewer.entities.contains(piece)) {
+                this.viewer.entities.remove(piece);
+            }
+        }
+        this.gridCenterGizmoPieces = [];
+    }
+    onCameraChanged() {
+        if (this.isUpdating) {
+            return;
+        }
+        else if (this.currentMarker !== this.viewer[UPDATE_MARKER_KEY]) {
+            return;
+        }
+        this.isUpdating = true;
+        // Small delay to avoid excessive updates during camera movement.
+        setTimeout(() => {
+            if (this.currentMarker !== this.viewer[UPDATE_MARKER_KEY]) {
+                this.isUpdating = false;
+                return;
+            }
+            try {
+                // The grid goes first, since it notices when the origin has moved and the gizmo has to follow.
+                this.updateGrid();
+                if (this.modelSpace) {
+                    this.drawGizmoPieces();
+                }
+                else {
+                    this.clearGizmoPieces();
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+            finally {
+                this.isUpdating = false;
+            }
+        }, 100);
+    }
+    cachedOffsetPoint(point, distance, heading) {
+        const key = `${point.latitude.toFixed(8)},${point.longitude.toFixed(8)},${distance.toFixed(1)},${heading}`;
+        if (this.offsetCache.has(key)) {
+            return this.offsetCache.get(key);
+        }
+        const result = offsetPoint$1(point, distance, heading);
+        this.offsetCache.set(key, result);
+        if (this.offsetCache.size > this.maxCacheSize) {
+            const keys = Array.from(this.offsetCache.keys());
+            for (let i = 0; i < 100; i++) {
+                this.offsetCache.delete(keys[i]);
+            }
+        }
+        return result;
+    }
+    /**
+     * Calculates a dynamic visibility ratio based on spacing size.
+     * For small grid spacings, we can show the grid from farther away.
+     * For large grid spacings, we need to hide it sooner to prevent performance issues.
+     */
+    getMaxVisibilityRatio() {
+        if (this.spacingInMeters <= 10) {
+            return this.BASE_MAX_VISIBILITY_RATIO;
+        }
+        if (this.spacingInMeters <= 100) {
+            const factor = 1 - ((this.spacingInMeters - 10) / 90);
+            return this.BASE_MAX_VISIBILITY_RATIO * (0.5 + (factor * 0.5));
+        }
+        const largeGridFactor = Math.min(1, 100 / this.spacingInMeters);
+        return this.BASE_MAX_VISIBILITY_RATIO * 0.5 * largeGridFactor;
+    }
+    updateGrid() {
+        const cameraPosition = this.viewer.camera.position;
+        const cameraCartographic = Cartographic.fromCartesian(cameraPosition);
+        const cameraHeight = cameraCartographic.height;
+        let adaptiveSpacing = this.calculateAdaptiveSpacing(cameraHeight, this.spacingInMeters);
+        // Calculate visible area.
+        const visibleArea = this.calculateVisibleArea();
+        if (!visibleArea) {
+            return;
+        }
+        let densityCheckPassed = false;
+        let attempts = 0;
+        while (!densityCheckPassed && attempts < this.MAX_ADAPTIVE_ATTEMPTS) {
+            if (this.isGridDensityAcceptable(visibleArea, cameraHeight, adaptiveSpacing)) {
+                densityCheckPassed = true;
+            }
+            else {
+                adaptiveSpacing *= 2;
+                attempts++;
+            }
+        }
+        // The origin follows the UCS of what is shown, so the grid moves with it when that changes.
+        if (this.modelSpace && this.fixedGridOrigin && !Carto.IsEqual(this.fixedGridOrigin, this.modelSpaceOrigin())) {
+            this.fixedGridOrigin = null;
+            this.lastCameraPosition = null;
+            this.clearGizmoPieces();
+        }
+        // Calculate grid origin if we don't have one yet.
+        if (!this.fixedGridOrigin) {
+            if (this.modelSpace) {
+                this.fixedGridOrigin = this.modelSpaceOrigin();
+            }
+            else {
+                const centerCartographic = Cartographic.fromCartesian(visibleArea.centerCartesian);
+                const centerPoint = {
+                    latitude: Math$1.toDegrees(centerCartographic.latitude),
+                    longitude: Math$1.toDegrees(centerCartographic.longitude),
+                    altitude: 0
+                };
+                // Simple attempt at snapping to the grid, should do something smarter.
+                this.fixedGridOrigin = {
+                    latitude: Math.round(centerPoint.latitude * 100000) / 100000,
+                    longitude: Math.round(centerPoint.longitude * 100000) / 100000,
+                    altitude: 0
+                };
+            }
+        }
+        // Calculate appropriate grid extent based on camera height.
+        // For larger grid spacings, we use a tighter extent to prevent performance issues.
+        const scaledExtentFactor = Math.max(0.5, Math.min(3, 3 - Math.log10(Math.max(1, adaptiveSpacing)) * 0.5));
+        const visibilityRadius = Math.min(cameraHeight * scaledExtentFactor, Infinity);
+        // Check if we should redraw the grid.
+        const shouldRedraw = this.shouldRedrawGrid(cameraPosition, cameraHeight, visibilityRadius, adaptiveSpacing);
+        if (!shouldRedraw) {
+            return;
+        }
+        // Remember current settings for next comparison.
+        this.lastCameraHeight = cameraHeight;
+        this.lastCameraPosition = cameraPosition.clone();
+        this.lastGridExtent = visibilityRadius;
+        // Clear existing grid and create a new one.
+        this.clearGrid();
+        this.gridLines = new PolylineCollection();
+        this.gridLabels = new LabelCollection({
+            scene: this.viewer.scene
+        });
+        this.gridPrimitives.add(this.gridLines);
+        this.gridPrimitives.add(this.gridLabels);
+        // Generate grid lines and labels using our fixed origin.
+        this.generateGridLines(this.fixedGridOrigin, visibilityRadius, adaptiveSpacing);
+    }
+    shouldRedrawGrid(cameraPosition, cameraHeight, gridExtent, currentSpacing) {
+        // check if the spacing has changed
+        if (this.lastUsedSpacing && this.lastUsedSpacing !== currentSpacing) {
+            return true;
+        }
+        // Always draw if we don't have a grid yet.
+        if (!this.gridLines || !this.lastCameraPosition || !this.fixedGridOrigin) {
+            return true;
+        }
+        // Check for significant height change.
+        const heightRatio = cameraHeight / this.lastCameraHeight;
+        if (heightRatio > (1 + this.HEIGHT_CHANGE_THRESHOLD) ||
+            heightRatio < (1 - this.HEIGHT_CHANGE_THRESHOLD)) {
+            return true;
+        }
+        // Check for significant position change relative to current grid extent.
+        const distance = Cartesian3.distance(cameraPosition, this.lastCameraPosition);
+        const moveThreshold = gridExtent * this.CAMERA_MOVE_THRESHOLD;
+        if (distance > moveThreshold) {
+            return true;
+        }
+        // Check for significant grid extent change.
+        const extentRatio = gridExtent / this.lastGridExtent;
+        if (extentRatio > (1 + this.GRID_EXTENT_CHANGE_THRESHOLD) ||
+            extentRatio < (1 - this.GRID_EXTENT_CHANGE_THRESHOLD)) {
+            return true;
+        }
+        // No significant changes, keep current grid.
+        return false;
+    }
+    isGridDensityAcceptable(visibleArea, cameraHeight, spacingToCheck = this.spacingInMeters) {
+        const lonRange = visibleArea.eastLon - visibleArea.westLon;
+        const latRange = visibleArea.northLat - visibleArea.southLat;
+        // Convert to approximate meters at center
+        const centerCartographic = Cartographic.fromCartesian(visibleArea.centerCartesian);
+        const metersPerDegreeLon = 111319.9 * Math.cos(centerCartographic.latitude);
+        const canvas = this.viewer.scene.canvas;
+        const spacingInDegrees = spacingToCheck / metersPerDegreeLon;
+        const canvasWidth = canvas.clientWidth;
+        const pixelsPerDegree = canvasWidth / lonRange;
+        const pixelsBetweenGridLines = pixelsPerDegree * spacingInDegrees;
+        const minPixelSize = 1;
+        return pixelsBetweenGridLines >= minPixelSize;
+    }
+    calculateVisibleArea() {
+        const scene = this.viewer.scene;
+        const camera = scene.camera;
+        const globe = scene.globe;
+        // Get the corners of the view frustum
+        const canvas = scene.canvas;
+        const corners = [
+            new Cartesian2(0, 0),
+            new Cartesian2(canvas.clientWidth, 0),
+            new Cartesian2(0, canvas.clientHeight),
+            new Cartesian2(canvas.clientWidth, canvas.clientHeight),
+            new Cartesian2(canvas.clientWidth / 2, canvas.clientHeight / 2) // Center
+        ];
+        // Project corners to the globe
+        const cartographicCorners = [];
+        for (const corner of corners) {
+            const ray = camera.getPickRay(corner);
+            if (!ray) {
+                continue;
+            }
+            const position = globe.pick(ray, scene);
+            if (!position) {
+                continue;
+            }
+            cartographicCorners.push(Cartographic.fromCartesian(position));
+        }
+        if (cartographicCorners.length === 0) {
+            return null;
+        }
+        // Find the bounding rectangle
+        let westLon = Number.POSITIVE_INFINITY;
+        let eastLon = Number.NEGATIVE_INFINITY;
+        let southLat = Number.POSITIVE_INFINITY;
+        let northLat = Number.NEGATIVE_INFINITY;
+        for (const corner of cartographicCorners) {
+            westLon = Math.min(westLon, corner.longitude);
+            eastLon = Math.max(eastLon, corner.longitude);
+            southLat = Math.min(southLat, corner.latitude);
+            northLat = Math.max(northLat, corner.latitude);
+        }
+        // Add some padding around the visible area
+        const lonPadding = (eastLon - westLon) * this.VIEW_PADDING_FACTOR;
+        const latPadding = (northLat - southLat) * this.VIEW_PADDING_FACTOR;
+        westLon -= lonPadding;
+        eastLon += lonPadding;
+        southLat -= latPadding;
+        northLat += latPadding;
+        // Get center position for reference
+        const centerCartographic = new Cartographic((westLon + eastLon) / 2, (southLat + northLat) / 2);
+        const centerCartesian = Cartesian3.fromRadians(centerCartographic.longitude, centerCartographic.latitude, 0);
+        return {
+            westLon: Math$1.toDegrees(westLon),
+            eastLon: Math$1.toDegrees(eastLon),
+            southLat: Math$1.toDegrees(southLat),
+            northLat: Math$1.toDegrees(northLat),
+            centerCartesian: centerCartesian
+        };
+    }
+    generateGridLines(originPoint, visibilityRadius, actualSpacing = this.spacingInMeters) {
+        // Number of grid cells in each direction (add 1 for edge lines).
+        const gridCellCount = Math.ceil(visibilityRadius / actualSpacing) + 1;
+        const maxCells = Math.min(gridCellCount, Math.floor(this.MAX_LINES / 2));
+        // Calculate interval to skip lines for density control.
+        const spacingFactor = actualSpacing / 100;
+        const heightFactor = this.lastCameraHeight / 500;
+        let lineSkipInterval = Math.floor(spacingFactor * heightFactor);
+        lineSkipInterval = Math.min(Math.max(lineSkipInterval, 1), 10); // Clamp between 1 and 10
+        const intersections = [];
+        // Generate north-south grid lines (longitude lines)
+        for (let i = -maxCells; i <= maxCells; i++) {
+            if (i % lineSkipInterval !== 0) {
+                continue;
+            }
+            const positions = [];
+            // Create a vertical line at this longitude offset.
+            // East heading for longitude.
+            const startPoint = this.cachedOffsetPoint(originPoint, i * actualSpacing, 90);
+            // Draw the line from south to north
+            for (let j = -maxCells; j <= maxCells; j++) {
+                if (j % lineSkipInterval !== 0) {
+                    continue;
+                }
+                // North heading for latitude.
+                const linePoint = this.cachedOffsetPoint(startPoint, j * actualSpacing, 0);
+                const position = Cartesian3.fromDegrees(linePoint.longitude, linePoint.latitude, linePoint.altitude);
+                positions.push(position);
+                intersections.push({
+                    position: position,
+                    i: i,
+                    j: j
+                });
+            }
+            if (positions.length >= 2) {
+                // Check if this is the primary Y axis (i=0) in model space
+                const isPrimaryYAxis = this.modelSpace && i === 0;
+                this.addGridLine(positions, isPrimaryYAxis ? "y" : null);
+            }
+        }
+        // Generate east-west grid lines (latitude lines).
+        for (let j = -maxCells; j <= maxCells; j++) {
+            if (j % lineSkipInterval !== 0) {
+                continue;
+            }
+            const positions = [];
+            // Create a horizontal line at this latitude offset
+            // North heading for latitude.
+            const startPoint = this.cachedOffsetPoint(originPoint, j * actualSpacing, 0);
+            // Draw the line from west to east.
+            for (let i = -maxCells; i <= maxCells; i++) {
+                if (i % lineSkipInterval !== 0) {
+                    continue;
+                }
+                // East heading for longitude.
+                const linePoint = this.cachedOffsetPoint(startPoint, i * actualSpacing, 90);
+                const position = Cartesian3.fromDegrees(linePoint.longitude, linePoint.latitude, linePoint.altitude);
+                positions.push(position);
+            }
+            if (positions.length >= 2) {
+                // Check if this is the primary X axis (j=0) in model space
+                const isPrimaryXAxis = this.modelSpace && j === 0;
+                this.addGridLine(positions, isPrimaryXAxis ? "x" : null);
+            }
+        }
+        this.addGridLabels(intersections, actualSpacing);
+    }
+    addGridLabels(intersections, actualSpacing) {
+        if (!this.gridLabels) {
+            return;
+        }
+        // Determine label interval based on number of intersections.
+        // Use higher interval for more intersections to prevent crowding.
+        const totalIntersections = intersections.length;
+        let labelInterval = this.LABEL_INTERVAL;
+        if (totalIntersections > 1000) {
+            labelInterval = 5;
+        }
+        else if (totalIntersections > 500) {
+            labelInterval = 3;
+        }
+        let labelCount = 0;
+        // Filter intersections to only those at the labelInterval.
+        const labelPoints = intersections.filter(point => {
+            // Always label the origin (0,0).
+            if (point.i === 0 && point.j === 0) {
+                return true;
+            }
+            return (point.i % labelInterval === 0 && point.j % labelInterval === 0);
+        });
+        // Sort points by distance from origin.
+        labelPoints.sort((a, b) => {
+            const distA = Math.abs(a.i) + Math.abs(a.j);
+            const distB = Math.abs(b.i) + Math.abs(b.j);
+            return distA - distB;
+        });
+        // Add labels, prioritizing those closest to the origin.
+        for (const point of labelPoints) {
+            if (labelCount >= this.MAX_LABELS) {
+                // Limit reached.
+                break;
+            }
+            let labelText;
+            // Model space coordinates (meters from origin).
+            if (this.modelSpace) {
+                const xMeters = point.i * actualSpacing;
+                const yMeters = point.j * actualSpacing;
+                if (point.i === 0 && point.j === 0) {
+                    labelText = "0,0,0";
+                }
+                else {
+                    labelText = `${xMeters},${yMeters}`;
+                }
+            }
+            // Geographic coordinates (degrees).
+            else {
+                const cartographic = Cartographic.fromCartesian(point.position);
+                const latitude = Math$1.toDegrees(cartographic.latitude);
+                const longitude = Math$1.toDegrees(cartographic.longitude);
+                const latFormatted = latitude.toFixed(5);
+                const lonFormatted = longitude.toFixed(5);
+                labelText = `${latFormatted}, ${lonFormatted}`;
+            }
+            this.gridLabels.add({
+                position: point.position,
+                text: labelText,
+                font: this.modelSpace && point.i === 0 && point.j === 0 ? "20px sans-serif" : "14px sans-serif",
+                fillColor: this.modelSpace && point.i === 0 && point.j === 0 ? Color.WHITE : Color.WHITE.withAlpha(0.5),
+                style: LabelStyle.FILL,
+                horizontalOrigin: HorizontalOrigin.CENTER,
+                verticalOrigin: VerticalOrigin.TOP,
+                pixelOffset: new Cartesian2(0, 10),
+                // Fade out with distance.
+                translucencyByDistance: new NearFarScalar(1000, 1.0, 15000, 0.4)
+            });
+            labelCount++;
+        }
+    }
+    addGridLine(positions, primaryAxis = null) {
+        if (!this.gridLines || positions.length < 2) {
+            return;
+        }
+        let lineColor;
+        let lineWidth = 1.0;
+        let lineAlpha = 0.2;
+        // Red for X axis.
+        if (primaryAxis === "x") {
+            lineColor = Color.RED;
+            lineAlpha = 0.5;
+            lineWidth = 1.5;
+        }
+        // Green for Y axis.
+        else if (primaryAxis === "y") {
+            lineColor = Color.GREEN;
+            lineAlpha = 0.5;
+            lineWidth = 1.5;
+        }
+        // Default gray for regular grid lines.
+        else {
+            lineColor = Color.LIGHTGRAY;
+        }
+        this.gridLines.add({
+            positions: positions,
+            width: lineWidth,
+            material: Material.fromType("Color", {
+                color: lineColor.withAlpha(lineAlpha)
+            })
+        });
+    }
+}
+// Grid square size used when settings name none, in metres.
+const DEFAULT_SPACING = 50;
+var CesiumMapGrid;
+(function (CesiumMapGrid) {
+    function GetCurrentSpacing(viewer) {
+        if (!viewer || viewer.isDestroyed()) {
+            return 0;
+        }
+        const handler = viewer[CLASS_INSTANCE_KEY];
+        return handler ? handler.getCurrentSpacing() : 0;
+    }
+    CesiumMapGrid.GetCurrentSpacing = GetCurrentSpacing;
+    function Remove(viewer) {
+        if (!viewer || viewer.isDestroyed()) {
+            return;
+        }
+        else if (!viewer[LAST_SETTINGS_KEY]) {
+            return;
+        }
+        if (!viewer[UPDATE_MARKER_KEY]) {
+            viewer[UPDATE_MARKER_KEY] = 1;
+        }
+        else {
+            viewer[UPDATE_MARKER_KEY]++;
+        }
+        // Dispose of the handler.
+        if (viewer[CLASS_INSTANCE_KEY]) {
+            viewer[CLASS_INSTANCE_KEY].Dispose();
+            viewer[CLASS_INSTANCE_KEY] = null;
+        }
+        viewer[LAST_SETTINGS_KEY] = {
+            ...viewer[LAST_SETTINGS_KEY],
+            enabled: false
+        };
+    }
+    CesiumMapGrid.Remove = Remove;
+    function Draw(viewer, spacingInMeters, modelSpace = true) {
+        if (!viewer || viewer.isDestroyed()) {
+            return;
+        }
+        let settings = viewer[LAST_SETTINGS_KEY];
+        if (settings) {
+            // See if the settings are the same as the last time.
+            if (settings.spacing === spacingInMeters &&
+                settings.modelSpace === modelSpace &&
+                settings.enabled) {
+                return;
+            }
+        }
+        if (!viewer[UPDATE_MARKER_KEY]) {
+            viewer[UPDATE_MARKER_KEY] = 1;
+        }
+        else {
+            viewer[UPDATE_MARKER_KEY]++;
+        }
+        settings = {
+            ...settings,
+            enabled: true,
+            spacing: spacingInMeters,
+            modelSpace: modelSpace
+        };
+        viewer[LAST_SETTINGS_KEY] = settings;
+        // Create or update the handler.
+        if (viewer[CLASS_INSTANCE_KEY]) {
+            viewer[CLASS_INSTANCE_KEY].Update(spacingInMeters, modelSpace);
+        }
+        else {
+            viewer[CLASS_INSTANCE_KEY] = new MapGridHandler(viewer, spacingInMeters, modelSpace);
+        }
+    }
+    CesiumMapGrid.Draw = Draw;
+    /**
+     * Draws a bookmark's grid, or removes the grid when it has none; only model-space draws one.
+     */
+    function Apply(viewer, grid, modelSpace) {
+        if ((grid === null || grid === void 0 ? void 0 : grid.enabled) && modelSpace) {
+            Draw(viewer, Number(grid.spacing) || DEFAULT_SPACING, modelSpace);
+        }
+        else {
+            Remove(viewer);
+        }
+    }
+    CesiumMapGrid.Apply = Apply;
+    function GetIsEnabled(viewer) {
+        if (!viewer || viewer.isDestroyed()) {
+            return false;
+        }
+        const settings = viewer[LAST_SETTINGS_KEY];
+        if (settings) {
+            return Boolean(settings.enabled);
+        }
+        return false;
+    }
+    CesiumMapGrid.GetIsEnabled = GetIsEnabled;
+    /**
+     * Returns the last applied grid settings.
+     */
+    function GetSettings(viewer) {
+        if (!viewer || viewer.isDestroyed()) {
+            return null;
+        }
+        return viewer[LAST_SETTINGS_KEY];
+    }
+    CesiumMapGrid.GetSettings = GetSettings;
+})(CesiumMapGrid || (CesiumMapGrid = {}));
+
 // TODO: Move these to the data model.
 const MIN_SHADOW_SIZE = 2048;
 const MAX_SHADOW_SIZE = 32768;
@@ -39006,7 +41217,7 @@ async function renderLegacyNavigator(iteration, params, bookmark, view) {
  * @param view
  */
 async function renderNavigator(iteration, params, bookmark, view, getters) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9;
     const viewer = params.manager.Viewer;
     const scene = viewer.scene;
     // Ion requests go through the server-side proxy (set up during viewer init or here as fallback).
@@ -39231,15 +41442,7 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
         scene.globe.translucency.frontFaceAlphaByDistance.farValue = 1;
     }
     scene.globe.translucency.frontFaceAlphaByDistance.nearValue = EnsureNumber(globeAlpha, 1);
-    let shadows = bSettings === null || bSettings === void 0 ? void 0 : bSettings.shadows;
-    if (shadows == null) {
-        shadows = (_u = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _u === void 0 ? void 0 : _u.shadows;
-    }
-    if (shadows == null) {
-        shadows = {
-            enabled: false
-        };
-    }
+    const shadows = ViewRenderEngine.ResolveShadows(bSettings, defaults === null || defaults === void 0 ? void 0 : defaults.settings, contentType);
     viewer.shadows = Boolean(shadows.enabled);
     viewer.shadowMap.enabled = Boolean(shadows.enabled);
     let size = EnsureNumber(shadows.pixelSize);
@@ -39252,9 +41455,11 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
     viewer.shadowMap.size = size;
     viewer.shadowMap.softShadows = Boolean(shadows.soften);
     viewer.shadowMap.darkness = EnsureNumber(shadows.darkness, 0.3);
+    // Drawn after the model-space origin is resolved above, since the grid starts from it.
+    CesiumMapGrid.Apply(viewer, (_u = bSettings.grid) !== null && _u !== void 0 ? _u : (_v = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _v === void 0 ? void 0 : _v.grid, contentType == ProjectViewBookmark.EContentType.WEB_3D_MODEL_SPACE);
     let ambientOcclusion = bSettings === null || bSettings === void 0 ? void 0 : bSettings.ambientOcclusion;
     if (ambientOcclusion == null) {
-        ambientOcclusion = (_v = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _v === void 0 ? void 0 : _v.ambientOcclusion;
+        ambientOcclusion = (_w = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _w === void 0 ? void 0 : _w.ambientOcclusion;
     }
     if (ambientOcclusion == null) {
         ambientOcclusion = {
@@ -39277,7 +41482,7 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
     }
     let lighting = bSettings === null || bSettings === void 0 ? void 0 : bSettings.lighting;
     if (lighting == null) {
-        lighting = (_w = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _w === void 0 ? void 0 : _w.lighting;
+        lighting = (_x = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _x === void 0 ? void 0 : _x.lighting;
     }
     if (lighting == null) {
         lighting = {
@@ -39295,7 +41500,7 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
     ViewUtils.ApplyDefaultBrightness(viewer, EnsureNumber(lighting.brightnessShift, DEFAULT_BRIGHTNESS_SHIFT));
     let quality = bSettings === null || bSettings === void 0 ? void 0 : bSettings.quality;
     if (quality == null) {
-        quality = (_x = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _x === void 0 ? void 0 : _x.quality;
+        quality = (_y = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _y === void 0 ? void 0 : _y.quality;
     }
     if (quality == null) {
         quality = {
@@ -39306,11 +41511,11 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
     fxaa.enabled = Boolean(quality.fxaa);
     let dateTime = bSettings === null || bSettings === void 0 ? void 0 : bSettings.dateTime;
     if (dateTime == null) {
-        dateTime = (_y = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _y === void 0 ? void 0 : _y.dateTime;
+        dateTime = (_z = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _z === void 0 ? void 0 : _z.dateTime;
     }
     let timeline = bSettings === null || bSettings === void 0 ? void 0 : bSettings.timeline;
     if (timeline == null) {
-        timeline = (_z = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _z === void 0 ? void 0 : _z.timeline;
+        timeline = (_0 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _0 === void 0 ? void 0 : _0.timeline;
     }
     if (timeline == null) {
         timeline = {
@@ -39334,7 +41539,7 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
     // Newer version that has states per Entity ID + Menu Item ID.
     let states = bSettings === null || bSettings === void 0 ? void 0 : bSettings.states;
     if (states == null) {
-        states = (_0 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _0 === void 0 ? void 0 : _0.states;
+        states = (_1 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _1 === void 0 ? void 0 : _1.states;
     }
     if (states != null) {
         params.manager.VisualsRegister.OverrideStates(states);
@@ -39343,7 +41548,7 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
     else {
         let selectedIds = bSettings === null || bSettings === void 0 ? void 0 : bSettings.selectedEntityIds;
         if (selectedIds == null) {
-            selectedIds = (_1 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _1 === void 0 ? void 0 : _1.selectedEntityIds;
+            selectedIds = (_2 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _2 === void 0 ? void 0 : _2.selectedEntityIds;
         }
         if (selectedIds != null) {
             params.manager.VisualsRegister.ClearSelected();
@@ -39357,7 +41562,7 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
         params.manager.VisualsRegister.ClearHidden();
         let hiddenIds = bSettings === null || bSettings === void 0 ? void 0 : bSettings.hiddenEntityIds;
         if (hiddenIds == null) {
-            hiddenIds = (_2 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _2 === void 0 ? void 0 : _2.hiddenEntityIds;
+            hiddenIds = (_3 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _3 === void 0 ? void 0 : _3.hiddenEntityIds;
         }
         if (hiddenIds != null) {
             params.manager.VisualsRegister.SetHidden({
@@ -39369,7 +41574,7 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
         params.manager.VisualsRegister.ClearIsolated();
         let isolatedIds = bSettings === null || bSettings === void 0 ? void 0 : bSettings.isolatedEntityIds;
         if (isolatedIds == null) {
-            isolatedIds = (_3 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _3 === void 0 ? void 0 : _3.isolatedEntityIds;
+            isolatedIds = (_4 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _4 === void 0 ? void 0 : _4.isolatedEntityIds;
         }
         if (isolatedIds != null) {
             params.manager.VisualsRegister.SetIsolated({
@@ -39380,7 +41585,7 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
         }
         let labelledIds = bSettings === null || bSettings === void 0 ? void 0 : bSettings.labelledEntityIds;
         if (labelledIds == null) {
-            labelledIds = (_4 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _4 === void 0 ? void 0 : _4.labelledEntityIds;
+            labelledIds = (_5 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _5 === void 0 ? void 0 : _5.labelledEntityIds;
         }
         if (!(labelledIds === null || labelledIds === void 0 ? void 0 : labelledIds.length)) {
             params.manager.VisualsRegister.ClearLabelled({
@@ -39404,7 +41609,7 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
         params.manager.VisualsRegister.ClearOpacity();
         let entityOpacityMap = bSettings === null || bSettings === void 0 ? void 0 : bSettings.entityOpacityMap;
         if (entityOpacityMap == null) {
-            entityOpacityMap = (_5 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _5 === void 0 ? void 0 : _5.entityOpacityMap;
+            entityOpacityMap = (_6 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _6 === void 0 ? void 0 : _6.entityOpacityMap;
         }
         if (entityOpacityMap != null) {
             for (const entityId in entityOpacityMap) {
@@ -39419,7 +41624,7 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
             }
         }
     }
-    let imagery = (bSettings === null || bSettings === void 0 ? void 0 : bSettings.imagery) != null ? bSettings.imagery : (_6 = defaults.settings) === null || _6 === void 0 ? void 0 : _6.imagery;
+    let imagery = (bSettings === null || bSettings === void 0 ? void 0 : bSettings.imagery) != null ? bSettings.imagery : (_7 = defaults.settings) === null || _7 === void 0 ? void 0 : _7.imagery;
     if (imagery == null) {
         // TODO: Need global default.
         imagery = [
@@ -39489,7 +41694,7 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
     // Otherwise we cause a flicker of rendered graphics.
     // Maybe TODO to such a function for menu item manager.
     const curEnabled = params.manager.GetEnabledItemIds();
-    const newItemIds = (_7 = bSettings === null || bSettings === void 0 ? void 0 : bSettings.menuItemIds) !== null && _7 !== void 0 ? _7 : [];
+    const newItemIds = (_8 = bSettings === null || bSettings === void 0 ? void 0 : bSettings.menuItemIds) !== null && _8 !== void 0 ? _8 : [];
     for (const id of curEnabled) {
         let shouldRemove;
         if (id == RELATION_MENU_ITEM_ID) {
@@ -39563,7 +41768,7 @@ async function renderNavigator(iteration, params, bookmark, view, getters) {
     }
     let gOcclusion = bSettings === null || bSettings === void 0 ? void 0 : bSettings.groundOcclusion;
     if (gOcclusion == null) {
-        gOcclusion = (_8 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _8 === void 0 ? void 0 : _8.groundOcclusion;
+        gOcclusion = (_9 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _9 === void 0 ? void 0 : _9.groundOcclusion;
     }
     if (gOcclusion == null) {
         // TODO: Need global default.
@@ -39581,6 +41786,17 @@ var ViewRenderEngine;
         ProjectViewBookmark.EContentType.WEB_3D_MODEL_SPACE,
         ProjectViewBookmark.EContentType.WEB_3D_SPLIT_PLUGIN
     ];
+    /**
+     * A bookmark's own shadows, else the view's defaults unless it is model-space, which reads brighter without.
+     */
+    function ResolveShadows(bSettings, defaults, contentType) {
+        let shadows = bSettings === null || bSettings === void 0 ? void 0 : bSettings.shadows;
+        if (shadows == null && contentType != ProjectViewBookmark.EContentType.WEB_3D_MODEL_SPACE) {
+            shadows = defaults === null || defaults === void 0 ? void 0 : defaults.shadows;
+        }
+        return shadows !== null && shadows !== void 0 ? shadows : { enabled: false };
+    }
+    ViewRenderEngine.ResolveShadows = ResolveShadows;
     /**
      * Returns where a model-space bookmark's camera goes, measured from the origin in effect.
      * @param viewer
@@ -44312,7 +46528,7 @@ const HOLD_ACTIVATION_TIME_MS = 350;
 const HOLD_LOADER_DELAY_MS = 150;
 const CONTINUOUS_ANIMATION_SPEED = 0.02 / 3;
 const ZOOM_DISTANCE = 0.85;
-const MIN_ZOOM_DISTANCE = 0.3;
+const MIN_ZOOM_DISTANCE$1 = 0.3;
 const NEAR_NADIR_PITCH = -Math.PI / 2 + 0.05;
 const MIN_ORBIT_OFFSET_METERS = 5;
 // Caps how far a pivot may be from the camera relative to the camera's own altitude.
@@ -44518,7 +46734,7 @@ function DoZoom(params) {
     const mag = (ZOOM_DISTANCE * 0.5) / Math.max(1, 4 - Math.log10(height));
     const zoom = zoomIn ? 1 - mag : 1 + mag;
     const offset = Cartesian3.multiplyByScalar(Cartesian3.subtract(p, ground, new Cartesian3()), zoom, new Cartesian3());
-    if (zoomIn && Cartesian3.magnitude(offset) <= MIN_ZOOM_DISTANCE) {
+    if (zoomIn && Cartesian3.magnitude(offset) <= MIN_ZOOM_DISTANCE$1) {
         return Promise.resolve(null);
     }
     const to = Cartesian3.add(ground, offset, new Cartesian3());
@@ -44742,7 +46958,7 @@ function StartContinuousZoom(params) {
         const mag = (ZOOM_DISTANCE * 0.5) / Math.max(1, 4 - Math.log10(height));
         const zoom = zoomIn ? 1 - mag * 0.03 : 1 + mag * 0.03;
         const offset = Cartesian3.multiplyByScalar(Cartesian3.subtract(p, ground, new Cartesian3()), zoom, new Cartesian3());
-        if (zoomIn && Cartesian3.magnitude(offset) <= MIN_ZOOM_DISTANCE) {
+        if (zoomIn && Cartesian3.magnitude(offset) <= MIN_ZOOM_DISTANCE$1) {
             active = false;
             return;
         }
@@ -45552,7 +47768,7 @@ var ViewerUtils;
      * @param viewer
      */
     function InitViewer(params) {
-        const { viewer, destroyWidgets, styleContainer, nextspaceWidgets, widgetParams } = params;
+        const { viewer, destroyWidgets, styleContainer, nextspaceWidgets, widgetParams, cameraControls } = params;
         const data = { widgets: {} };
         if (destroyWidgets != false) {
             try {
@@ -45579,6 +47795,12 @@ var ViewerUtils;
         // Newer cesium is much dimmer by default so we shift brightness a bit.
         ViewUtils.ApplyDefaultBrightness(viewer);
         backgroundRendering(viewer);
+        if (cameraControls != false) {
+            CameraControls.Attach(viewer);
+            if (ViewUtils.GetModelSpace(viewer)) {
+                CameraControls.SetModelSpace(viewer, () => ViewUtils.GetModelSpaceFrame(viewer));
+            }
+        }
         // Capturing the destroy call to destroy all widgets.
         const olDestroy = viewer.destroy;
         viewer.destroy = () => {
@@ -45587,6 +47809,7 @@ var ViewerUtils;
             }
             try {
                 ViewerUtils.DisposeNextspaceWidgets(viewer);
+                CameraControls.Detach(viewer);
             }
             // We don't want the actual destroy to fail.
             catch (e) {
@@ -49731,7 +51954,7 @@ var EntityRenderEngineModel3d;
                     ...ViewUtils.DefaultLightingProps(),
                     heightReference: heightRef,
                     scale: new CallbackProperty(() => scale * styleScale, true),
-                    shadows: ShadowMode.ENABLED,
+                    shadows: ViewUtils.GetEntityShadowMode(params.viewer),
                     colorBlendAmount: blendAmount,
                     colorBlendMode: blendMode,
                     color: new CallbackProperty(() => {
@@ -49766,7 +51989,7 @@ var EntityRenderEngineModel3d;
                 cEntity.model.uri = new ConstantProperty(params.lodUrl);
             }
             cEntity.model.heightReference = new ConstantProperty(heightRef);
-            cEntity.model.shadows = new ConstantProperty(ShadowMode.ENABLED);
+            cEntity.model.shadows = new ConstantProperty(ViewUtils.GetEntityShadowMode(params.viewer));
             cEntity.model.colorBlendAmount = new ConstantProperty(blendAmount);
             cEntity.model.colorBlendMode = new ConstantProperty(blendMode);
             cEntity.model.distanceDisplayCondition = new ConstantProperty(EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
@@ -50608,7 +52831,7 @@ var EntityRenderEnginePolyline;
                     zIndex: getZIndex(style, entity, params.tags),
                     distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width),
                     cornerType: CornerType.MITERED,
-                    shadows: ShadowMode.ENABLED,
+                    shadows: ViewUtils.GetEntityShadowMode(params.viewer),
                     fill: true
                 } : null,
                 position: EntityUtils.GetPos({
@@ -55007,6 +57230,12 @@ var EntityRenderEnginePolygon;
                 ? Geometry$1.ParsePoints(ring.LinearRing).map((point) => point.altitude)
                 : [])
         });
+        const drapesOnGround = (heightRef === HeightReference.CLAMP_TO_GROUND &&
+            extrusion.value == undefined &&
+            !drawsDisplacedSurface);
+        if (drapesOnGround) {
+            posses = groundPosses(posses);
+        }
         posses = CullDuplicateCPosses(posses);
         if (posses.length < 4) {
             return null;
@@ -55015,6 +57244,9 @@ var EntityRenderEnginePolygon;
         const holePosses = holeRings.map((x) => {
             const points = Geometry$1.ParsePoints(x.LinearRing);
             let holePosses = points.map(x => Cartesian3.fromDegrees(EnsureNumber(x.longitude), EnsureNumber(x.latitude), EnsureNumber(x.altitude)));
+            if (drapesOnGround) {
+                holePosses = groundPosses(holePosses);
+            }
             holePosses = CullDuplicateCPosses(holePosses);
             Cartes.CloseRing3(holePosses);
             return holePosses;
@@ -55065,7 +57297,7 @@ var EntityRenderEnginePolygon;
                     fill: !drawsDisplacedSurface,
                     extrudedHeight: extrusion.value,
                     extrudedHeightReference: extrusion.exHeightRef,
-                    shadows: ShadowMode.ENABLED,
+                    shadows: ViewUtils.GetEntityShadowMode(params.viewer),
                     heightReference: heightRef,
                     classificationType: classification,
                     perPositionHeight: heightRef == HeightReference.CLAMP_TO_GROUND ? false : true,
@@ -55145,7 +57377,7 @@ var EntityRenderEnginePolygon;
                 viewer: params.viewer,
                 graphic: cEntity.polygon,
                 property: "shadows",
-                value: ShadowMode.ENABLED
+                value: ViewUtils.GetEntityShadowMode(params.viewer)
             });
             SetCPropIfChanged({
                 viewer: params.viewer,
@@ -55280,7 +57512,7 @@ var EntityRenderEnginePolygon;
                         cornerType: CornerType.MITERED,
                         classificationType: classification,
                         distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width, false, size),
-                        shadows: ShadowMode.ENABLED
+                        shadows: ViewUtils.GetEntityShadowMode(params.viewer)
                     } : null,
                     show: true
                 });
@@ -55403,7 +57635,7 @@ var EntityRenderEnginePolygon;
                         cornerType: CornerType.MITERED,
                         classificationType: classification,
                         distanceDisplayCondition: EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width, false, size),
-                        shadows: ShadowMode.ENABLED,
+                        shadows: ViewUtils.GetEntityShadowMode(params.viewer),
                     } : null,
                     show: true
                 });
@@ -55801,6 +58033,18 @@ function waterFor(style) {
 /*
  * The lon/lat bounding rectangle of a ring, which is the frame Cesium drapes an image material in.
  */
+/*
+ * Moves a ring onto the ellipsoid, as Cesium fills only a strip of a ground polygon with high vertices.
+ */
+function groundPosses(posses) {
+    return posses.map((pos) => {
+        const carto = Cartographic.fromCartesian(pos);
+        if (!carto) {
+            return pos;
+        }
+        return Cartesian3.fromRadians(carto.longitude, carto.latitude, 0);
+    });
+}
 function polygonBbox(posses) {
     if (!posses || posses.length === 0) {
         return undefined;
@@ -57727,7 +59971,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.7.6";
+const VERSION = "7.7.8";
 /**
  * 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.
@@ -57744,5 +59988,5 @@ const getENVIRONMENT = () => {
     return ENVIRONMENT;
 };
 
-export { VERSION, setENVIRONMENT, getENVIRONMENT, ClusterItems, PointClustering, PointClusterSize, CesiumAnimatedInOut, DisplacedSurfacePrimitive, CesiumAnimatedProperty, isStyleChanged, isOutlineChanged$1 as isOutlineChanged, StyleEffective, EntityRenderEngine, EntityRenderEngineModel3d, EntityRenderEnginePoint, extractMetadataFromFileUrl, EntityRenderEnginePolygon, EntityRenderEnginePolyline, TextureFrameSeriesAnimator, TextureValueLabels, MenuItemCreator, MenuItemManager, MenuItemStyles, MenuItemStyleOverlay, CesiumParabola, EntityLabel, EntityLabelGroup, LiveCursor, SharedGetters, EntitySimulation, DataSourceStaticKmlManager, DataLabRenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, AssemblyRenderManager, GoogleSearchRenderManager, RelationsRenderManager, RenderManager, TilesetArbRenderManager, TilesetCadRenderManager, TilesetEntitiesRenderManager, TilesetGooglePhotosRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TileRenderEngine, createTileset, TilesetRenderEngine, ViewRenderEngine, VisualRegisterCuller, VisualsRegister, XGridsRenderEngine, CesiumEntityStyler, DrawingUtils, EntityUtils, MeasureUtils, StyleUtils, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_KEY, CESIUM_TIMELINE_INTERVAL_KEY, CESIUM_MODEL_SPACE_KEY, CESIUM_MODEL_SPACE_POSITIONING_KEY, DEFAULT_LIVE_PADDING_SECONDS, DEFAULT_BRIGHTNESS_SHIFT, DEFAULT_LIGHT_INTENSITY, LIGHTING_SETTINGS_VERSION, LIGHT_INTENSITY_COMPENSATION, MAX_COMPENSATED_LIGHT_INTENSITY, ViewUtils, CesiumViewMonitor, ViewGroundArea, ViewerEventTracker, ViewerUtils, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, WidgetControlViewBar, WidgetControlViewBarSearch, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks, WidgetLeftPanelTabDashboard, EMenuItemState, WidgetLeftPanelTabMenuItems, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, ECursor, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, CreateTabIconSvg, WidgetLeftPanel, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar };
+export { VERSION, setENVIRONMENT, getENVIRONMENT, ClusterItems, PointClustering, PointClusterSize, CesiumAnimatedInOut, DisplacedSurfacePrimitive, CesiumAnimatedProperty, isStyleChanged, isOutlineChanged$1 as isOutlineChanged, StyleEffective, EntityRenderEngine, EntityRenderEngineModel3d, EntityRenderEnginePoint, extractMetadataFromFileUrl, EntityRenderEnginePolygon, EntityRenderEnginePolyline, TextureFrameSeriesAnimator, TextureValueLabels, MenuItemCreator, MenuItemManager, MenuItemStyles, MenuItemStyleOverlay, CesiumParabola, EntityLabel, EntityLabelGroup, LiveCursor, SharedGetters, EntitySimulation, DataSourceStaticKmlManager, DataLabRenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, AssemblyRenderManager, GoogleSearchRenderManager, RelationsRenderManager, RenderManager, TilesetArbRenderManager, TilesetCadRenderManager, TilesetEntitiesRenderManager, TilesetGooglePhotosRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TileRenderEngine, createTileset, TilesetRenderEngine, ViewRenderEngine, VisualRegisterCuller, VisualsRegister, XGridsRenderEngine, CesiumEntityStyler, DrawingUtils, EntityUtils, MeasureUtils, StyleUtils, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_KEY, CESIUM_TIMELINE_INTERVAL_KEY, CESIUM_MODEL_SPACE_KEY, CESIUM_MODEL_SPACE_POSITIONING_KEY, DEFAULT_LIVE_PADDING_SECONDS, DEFAULT_BRIGHTNESS_SHIFT, DEFAULT_LIGHT_INTENSITY, LIGHTING_SETTINGS_VERSION, LIGHT_INTENSITY_COMPENSATION, MAX_COMPENSATED_LIGHT_INTENSITY, ViewUtils, CesiumMapGrid, GltfGenerator, GltfGizmo, DeviceProfile, CesiumViewMonitor, CameraControls, ViewGroundArea, ViewerEventTracker, ViewerUtils, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, WidgetControlViewBar, WidgetControlViewBarSearch, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks, WidgetLeftPanelTabDashboard, EMenuItemState, WidgetLeftPanelTabMenuItems, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, ECursor, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, CreateTabIconSvg, WidgetLeftPanel, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar };
 //# sourceMappingURL=bruce-cesium.es5.js.map