bruce-cesium 7.5.2 → 7.5.4

package/dist/bruce-cesium.umd.js

@@ -3026,6 +3026,7 @@
     }
     let _selectColor = Cesium.Color.fromAlpha(Cesium.Color.YELLOW, 0.5);
     let _highlightColor = Cesium.Color.fromCssColorString("#33b1ff").withAlpha(0.5);
+    const DIMMING_REGISTERS_KEY = "_nextspaceDimmingRegisters";
     const STORE_COLOR_PREFIX = "_storeColor_";
     function getStoreKey(key) {
         return STORE_COLOR_PREFIX + key;
@@ -3182,6 +3183,10 @@
             getColor$1(viewer, "default", graphic);
         }
         let color = (_a = getColor$1(viewer, key, graphic)) !== null && _a !== void 0 ? _a : Cesium.Color.WHITE;
+        // A model that is itself dimmed stays see-through. Only the ones standing out from dimmed surroundings go opaque.
+        if (key != "default" && (opacity == null || opacity >= 1) && exports.CesiumEntityStyler.IsSelectionOpaque(viewer, graphic)) {
+            color = color.withAlpha(1);
+        }
         // If we're selecting and it's highlighted, don't change the color.
         if (key != "select" || getKeyState(graphic, "highlight") == false) {
             let animateMs = key == "highlight" ? ANIMATE_COLOR_HIGHLIGHT_MS : ANIMATE_COLOR_MS;
@@ -3352,6 +3357,50 @@
         return value == null ? false : value;
     }
     (function (CesiumEntityStyler) {
+        /**
+         * Whether a graphic or visual is a 3D model, ie: a tileset feature from a CAD or assembly import, or a model Entity.
+         * @param graphic
+         */
+        function IsModel(graphic) {
+            if (graphic instanceof Cesium.Entity) {
+                return Boolean(graphic.model);
+            }
+            return graphic instanceof Cesium.Cesium3DTileFeature || graphic instanceof Cesium.ModelGraphics;
+        }
+        CesiumEntityStyler.IsModel = IsModel;
+        /**
+         * Whether a graphic is drawn with an opaque selection and highlight because something on its viewer is dimmed.
+         * Only 3D models are. GIS graphics keep the colour's own alpha.
+         * @param viewer
+         * @param graphic
+         */
+        function IsSelectionOpaque(viewer, graphic) {
+            var _a;
+            return Boolean((_a = viewer === null || viewer === void 0 ? void 0 : viewer[DIMMING_REGISTERS_KEY]) === null || _a === void 0 ? void 0 : _a.size) && IsModel(graphic);
+        }
+        CesiumEntityStyler.IsSelectionOpaque = IsSelectionOpaque;
+        /**
+         * Records whether a register dims anything on a viewer, by isolation or by opacity.
+         * @param viewer
+         * @param registerId
+         * @param dimming
+         * @returns Whether the viewer went into or out of dimming, so selected models can be recoloured.
+         */
+        function SetDimming(viewer, registerId, dimming) {
+            let ids = viewer[DIMMING_REGISTERS_KEY];
+            const before = Boolean(ids === null || ids === void 0 ? void 0 : ids.size);
+            if (dimming) {
+                if (!ids) {
+                    ids = viewer[DIMMING_REGISTERS_KEY] = new Set();
+                }
+                ids.add(registerId);
+            }
+            else {
+                ids === null || ids === void 0 ? void 0 : ids.delete(registerId);
+            }
+            return before !== Boolean(ids === null || ids === void 0 ? void 0 : ids.size);
+        }
+        CesiumEntityStyler.SetDimming = SetDimming;
         function UpdateColorSetting(key, color) {
             if (key == "highlight") {
                 _highlightColor = color.clone();
@@ -9836,6 +9885,8 @@
                 // Caches GetIsIsolatedAny(). `null` means "unknown, recompute".
                 // Invalidated on any write that could affect isolation.
                 this.isolatedAnyCache = null;
+                // Set when isolation or opacity changes, so the next update checks whether anything is still dimmed.
+                this.dimmingDirty = false;
                 // Caches GetIsolationOpacity(). `undefined` means "unknown, recompute", `null` means
                 // "isolation (if any) is the legacy boolean/full-hide kind, not a numeric dim".
                 // Invalidated alongside isolatedAnyCache.
@@ -10104,6 +10155,7 @@
                             this.updateQueueInterval = null;
                             return;
                         }
+                        this.syncDimming();
                         const batch = this.updateQueue.splice(0, BATCH_SIZE);
                         const cache = {};
                         for (let i = 0; i < batch.length; i++) {
@@ -10338,6 +10390,9 @@
                     this.isolatedAnyCache = null;
                     this.isolationOpacityCache = undefined;
                 }
+                if (keys.includes("isolated") || keys.includes("opacity")) {
+                    this.dimmingDirty = true;
+                }
                 let changed = false;
                 const eStates = this.states[entityId] || {};
                 this.states[entityId] = eStates;
@@ -10769,8 +10824,36 @@
                 const { rego } = params;
                 markEntity(this, rego, rego.visual, false);
             }
+            /**
+             * Tells the styler whether this register dims anything, by isolation or opacity.
+             */
+            syncDimming() {
+                var _a, _b;
+                if (!this.dimmingDirty) {
+                    return;
+                }
+                this.dimmingDirty = false;
+                const dimming = Object.values(this.states).some(states => Object.values(states).some(state => state.isolated || (state.opacity != null && state.opacity < 1)));
+                if (!exports.CesiumEntityStyler.SetDimming(this.viewer, this.id, dimming)) {
+                    return;
+                }
+                const entityIds = new Set([...this.GetSelected(), ...this.GetHighlighted()]);
+                for (const entityId of entityIds) {
+                    for (const rego of (_a = this.rego[entityId]) !== null && _a !== void 0 ? _a : []) {
+                        if (exports.CesiumEntityStyler.IsModel(rego.visual)) {
+                            exports.CesiumEntityStyler.Refresh({
+                                viewer: this.viewer,
+                                entity: rego.visual,
+                                requestRender: false
+                            });
+                        }
+                    }
+                }
+                (_b = this.viewer.scene) === null || _b === void 0 ? void 0 : _b.requestRender();
+            }
             Dispose() {
                 var _a, _b, _c, _d, _e;
+                exports.CesiumEntityStyler.SetDimming(this.viewer, this.id, false);
                 this.ClearLabelHover();
                 clearTimeout(this.hoverRingReset);
                 this.hoverRingState = {};
@@ -11397,6 +11480,7 @@
                     // Mutated `isolated` directly rather than through setStateValues().
                     this.isolatedAnyCache = false;
                     this.isolationOpacityCache = null;
+                    this.dimmingDirty = true;
                 }
                 if (changed && (params === null || params === void 0 ? void 0 : params.doUpdate) !== false) {
                     this.updateAllEntities({
@@ -12133,6 +12217,7 @@
                 }
             }
             async updateAllEntities(params) {
+                this.syncDimming();
                 const ids = Object.keys(this.rego);
                 const interval = setInterval(() => {
                     const batch = ids.splice(0, 3000);
@@ -12227,6 +12312,7 @@
                 const clearedIds = new Set();
                 this.ForEachState((state) => {
                     if (!clearedIds.has(state.entityId) && state.opacity != null) {
+                        this.dimmingDirty = true;
                         this.markLazyExclusion(state.entityId);
                         this.queueUpdate({
                             entityId: state.entityId,
@@ -17169,6 +17255,9 @@
                 }
             };
         }
+        HasEntityDataOverride(eId) {
+            return this.entityDataOverrides.has(eId);
+        }
         SetEntityDataOverride(eId, entity) {
             if (this.disposed) {
                 return;
@@ -17865,6 +17954,24 @@
         }
         return style;
     }
+    /**
+     * Reads the baked attribute declaration from a loaded tileset, keyed by path.
+     * @param cTileset
+     */
+    function getBakedAttributes(cTileset) {
+        var _a, _b;
+        const result = new Map();
+        const declared = (_b = (_a = cTileset === null || cTileset === void 0 ? void 0 : cTileset.extras) === null || _a === void 0 ? void 0 : _a.bruce) === null || _b === void 0 ? void 0 : _b.bakedAttributes;
+        if (!Array.isArray(declared)) {
+            return result;
+        }
+        for (const baked of declared) {
+            if (Array.isArray(baked === null || baked === void 0 ? void 0 : baked.path) && baked.path.length && typeof baked.property == "string") {
+                result.set(JSON.stringify(baked.path), baked);
+            }
+        }
+        return result;
+    }
     function colorToCColor$3(color) {
         return new Cesium.Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
     }
@@ -17935,6 +18042,10 @@
             // When false the Entity data is still gathered and the regos still updated, but no colour is
             // applied. A historic item that did not ask for styling needs the first without the second.
             this.applyStyles = true;
+            // Attribute values the tiles carry per feature, keyed by JSON path. Empty for a tileset without them.
+            this.bakedAttributes = new Map();
+            // Entities changed since the tileset was generated, so their baked values can no longer be trusted.
+            this.bakedStaleIds = new Set();
             this.reRenderState = new EntityReRenderMaintainState();
             // More expensive process.
             // When an Entity is styled, the rego is reviewed and updated if needed.
@@ -17976,6 +18087,7 @@
             this.viewer = viewer;
             this.api = api;
             this.cTileset = cTileset;
+            this.bakedAttributes = getBakedAttributes(cTileset);
             this.register = register;
             this.menuItemId = menuItemId;
             this.historic = Boolean(historic);
@@ -18054,6 +18166,7 @@
                     for (const [internalId, entityId] of this.styledByInternalId) {
                         if (BModels.RecordChangeFeed.isEntityInternalIdInRangeString(rangeStr, internalId)) {
                             this.feedPendingRestyleIds.add(entityId);
+                            this.bakedStaleIds.add(entityId);
                         }
                     }
                     if (this.feedPendingRestyleIds.size && !this.feedRestyleThrottleTimer) {
@@ -18293,8 +18406,6 @@
                 console.error(e);
             }
             // Before we start the loop we'll do a single request for the needed Entity Types.
-            // This will be aimed at rows that don't specify a Style and if the default fallback-
-            //is set to 0 (using the default of the Entity Type).
             const typeMap = new Map();
             const typeIds = styleMapping.map(x => x.StyleID == -1 || Boolean(x.style) ? null : x.EntityTypeID).filter(x => !!x);
             if (typeIds.length) {
@@ -18360,23 +18471,7 @@
                 }
                 this.styleMappingsLoaded.set(styleMap.EntityTypeID, true);
                 if (this.loaded) {
-                    // If we have a bunch of Entities that were waiting for the style to load,
-                    // then we can pass them to the gatherer now.
-                    const relatedIds = this.stylePendingEntityIds.get(styleMap.EntityTypeID);
-                    if (relatedIds) {
-                        if (this.getTilesetFeatureNeedsFullData(styleMap.EntityTypeID)) {
-                            this.entityGatherer.Queue(Array.from(relatedIds));
-                        }
-                        else {
-                            relatedIds.forEach(id => {
-                                const rego = this.getEntityRego(id);
-                                if (rego) {
-                                    this.styleTilesetFeature(rego);
-                                }
-                            });
-                        }
-                        this.stylePendingEntityIds.delete(styleMap.EntityTypeID);
-                    }
+                    this.flushPendingForType(styleMap.EntityTypeID);
                 }
             }
             if (this.loadingCounter != counter) {
@@ -18392,22 +18487,63 @@
                 for (const key of pendingKeys) {
                     const relatedIds = this.stylePendingEntityIds.get(key);
                     if (relatedIds) {
-                        if (this.getTilesetFeatureNeedsFullData(key)) {
-                            this.entityGatherer.Queue(Array.from(relatedIds));
-                        }
-                        else {
-                            relatedIds.forEach(id => {
-                                const rego = this.getEntityRego(id);
-                                if (rego) {
-                                    this.styleTilesetFeature(rego);
-                                }
-                            });
-                        }
+                        this.styleOrGatherIds(key, relatedIds);
                     }
                 }
                 this.stylePendingEntityIds.clear();
             }
         }
+        /**
+         * Passes the Entities waiting on an Entity Type's style on to be styled, now that the style is known.
+         * @param entityTypeId
+         */
+        flushPendingForType(entityTypeId) {
+            const relatedIds = this.stylePendingEntityIds.get(entityTypeId);
+            if (!relatedIds) {
+                return;
+            }
+            this.styleOrGatherIds(entityTypeId, relatedIds);
+            this.stylePendingEntityIds.delete(entityTypeId);
+        }
+        hasMappingRow(entityTypeId) {
+            var _a;
+            return Boolean((_a = this.styleMapping) === null || _a === void 0 ? void 0 : _a.some(x => x.EntityTypeID == entityTypeId));
+        }
+        /**
+         * Loads the default style of an Entity Type that the style mapping does not list.
+         * @param entityTypeId
+         */
+        async loadEntityTypeDefaultStyle(entityTypeId) {
+            const counter = this.loadingCounter;
+            const styleMap = { EntityTypeID: entityTypeId, StyleID: 0, style: null };
+            this.styleMapping.push(styleMap);
+            try {
+                const { entityType } = await BModels.EntityType.Get({
+                    api: this.api,
+                    entityTypeId
+                });
+                const styleId = entityType === null || entityType === void 0 ? void 0 : entityType["DisplaySetting.ID"];
+                if (styleId && styleId != -1) {
+                    const { style } = await BModels.Style.Get({
+                        api: this.api,
+                        styleId
+                    });
+                    if (style) {
+                        styleMap.style = style;
+                        styleMap.StyleID = styleId;
+                    }
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+            // A reload in the meantime resolves the row itself, or replaces the mapping and re-queues everything.
+            if (this.disposed || this.loadingCounter != counter) {
+                return;
+            }
+            this.styleMappingsLoaded.set(entityTypeId, true);
+            this.flushPendingForType(entityTypeId);
+        }
         disposeGatherer() {
             if (this.feedRestyleThrottleTimer) {
                 clearTimeout(this.feedRestyleThrottleTimer);
@@ -18446,21 +18582,15 @@
                     this.overrideFeatureColor.set(rego.entityId, false);
                 }
                 const typeId = rego.entityTypeId || "";
-                if (this.styleMappingLoaded || this.styleMappingsLoaded.get(typeId)) {
-                    if (this.getTilesetFeatureNeedsFullData(typeId)) {
-                        needsDataIds.push(rego.entityId);
-                    }
-                    else {
-                        this.styleTilesetFeature(rego);
-                    }
+                // With no fallback style to use instead, a type the mapping does not list falls back to its own default.
+                if (this.styleMappingLoaded && typeId && !this.fallbackStyle && !this.hasMappingRow(typeId)) {
+                    this.loadEntityTypeDefaultStyle(typeId);
+                }
+                if (this.styleMappingsLoaded.get(typeId) || (this.styleMappingLoaded && !this.hasMappingRow(typeId))) {
+                    this.styleOrCollect(rego, typeId, needsDataIds);
                 }
                 else if (!this.styleMappingsLoaded.has(typeId) && this.styleFallbackLoaded) {
-                    if (this.getTilesetFeatureNeedsFullData(typeId)) {
-                        needsDataIds.push(rego.entityId);
-                    }
-                    else {
-                        this.styleTilesetFeature(rego);
-                    }
+                    this.styleOrCollect(rego, typeId, needsDataIds);
                 }
                 else {
                     if (!this.stylePendingEntityIds.has(typeId)) {
@@ -18473,6 +18603,96 @@
                 this.entityGatherer.Queue(needsDataIds, highPriority);
             }
         }
+        /**
+         * Styles each Entity waiting on a type's style, gathering the records of those that need one.
+         * @param entityTypeId
+         * @param entityIds
+         */
+        styleOrGatherIds(entityTypeId, entityIds) {
+            const gatherIds = [];
+            for (const id of entityIds) {
+                const rego = this.getEntityRego(id);
+                if (rego) {
+                    this.styleOrCollect(rego, entityTypeId, gatherIds);
+                }
+            }
+            if (gatherIds.length) {
+                this.entityGatherer.Queue(gatherIds);
+            }
+        }
+        /**
+         * Styles a feature now when its style reads no record, or reads only values its tile carries, and otherwise collects it for gathering.
+         * @param rego
+         * @param entityTypeId
+         * @param gatherIds Receives the Entity ID when its record is needed.
+         */
+        styleOrCollect(rego, entityTypeId, gatherIds) {
+            if (!this.getTilesetFeatureNeedsFullData(entityTypeId)) {
+                this.styleTilesetFeature(rego);
+                return;
+            }
+            const record = this.canStyleFromBaked(rego.entityId, entityTypeId) ? this.readBakedRecord(rego.visual) : null;
+            if (!record) {
+                gatherIds.push(rego.entityId);
+                return;
+            }
+            this.styleTilesetFeatureFullData(rego, record, []);
+            // A later edit has to reach the record path, and the change feed finds Entities by Internal ID.
+            if (rego.internalId != null) {
+                this.styledByInternalId.set(rego.internalId, rego.entityId);
+            }
+        }
+        /**
+         * Returns if the tile's baked values hold everything this Entity's style would read from its record.
+         * @param entityId
+         * @param entityTypeId
+         */
+        canStyleFromBaked(entityId, entityTypeId) {
+            var _a, _b, _c;
+            // Baked values are the base record at generation time, which a scenario, a point in time or merged sources all differ from.
+            if (!this.bakedAttributes.size || this.historic || !!this.scenario || this.expandSources) {
+                return false;
+            }
+            if (this.bakedStaleIds.has(entityId) || ((_a = this.entityGatherer) === null || _a === void 0 ? void 0 : _a.HasEntityDataOverride(entityId))) {
+                return false;
+            }
+            const paths = BModels.Calculator.GetFieldPaths((_c = (_b = this.getTilesetFeatureStyle(entityTypeId)) === null || _b === void 0 ? void 0 : _b.modelStyle) === null || _c === void 0 ? void 0 : _c.fillColor);
+            return paths != null && paths.every(path => this.bakedAttributes.has(JSON.stringify(path)));
+        }
+        /**
+         * Builds a stand-in record from a feature's baked values, holding only the attributes that have one.
+         * Returns null when the feature's tile lacks a declared column, so the record is gathered instead.
+         * @param visual
+         */
+        readBakedRecord(visual) {
+            if (!(visual instanceof Cesium.Cesium3DTileFeature)) {
+                return null;
+            }
+            const record = {};
+            for (const baked of this.bakedAttributes.values()) {
+                if (!visual.hasProperty(baked.property)) {
+                    return null;
+                }
+                let value = visual.getProperty(baked.property);
+                if (value == null) {
+                    continue;
+                }
+                // Booleans travel as 0/1 because a boolean column has no way to say "no value".
+                if (baked.type == "BOOLEAN") {
+                    value = value != 0;
+                }
+                let target = record;
+                for (let i = 0; i < baked.path.length - 1; i++) {
+                    const segment = baked.path[i];
+                    if (target[segment] == null || typeof target[segment] != "object") {
+                        target[segment] = {};
+                    }
+                    target = target[segment];
+                }
+                target[baked.path[baked.path.length - 1]] = value;
+            }
+            return record;
+        }
         styleTilesetFeature(rego) {
             this.styleTilesetFeatureFullData(rego, null, []);
         }
@@ -40491,6 +40711,47 @@
         }
         return Cesium.Matrix4.multiplyByPoint(enuFrame, new Cesium.Cartesian3(tx, ty, tz), new Cesium.Cartesian3());
     }
+    // Records created within about this long ago are the ones the oversized GeometryRadius bug could have written.
+    const GEOMETRY_RADIUS_SUSPECT_AGE_MS = 1000 * 60 * 60 * 24 * 183;
+    // Above this a recent record's radius is treated as that bug rather than a real size.
+    const GEOMETRY_RADIUS_SUSPECT_ABOVE = 500;
+    /**
+     * Returns an entity's Bruce.GeometryRadius, or null when there is none or it looks like the oversized-radius bug.
+     * The size cap only applies to records created recently; older ones and ones with no known date are taken as they are.
+     * @param entity
+     */
+    function getTrustedGeometryRadius(entity) {
+        var _a;
+        const radius = EnsureNumber(BModels.Entity.GetValue({
+            entity: entity,
+            path: ["Bruce", "GeometryRadius"]
+        }));
+        if (!(radius > 0)) {
+            return null;
+        }
+        const created = Date.parse((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.Created);
+        const recent = !isNaN(created) && Date.now() - created < GEOMETRY_RADIUS_SUSPECT_AGE_MS;
+        if (recent && radius >= GEOMETRY_RADIUS_SUSPECT_ABOVE) {
+            return null;
+        }
+        return radius;
+    }
+    /**
+     * Returns the world centre of a model's own bounds, applying the entity's orientation to the offset.
+     * The position is the one GetLocation already resolved, so height references are honoured.
+     * @param viewer
+     * @param part
+     * @param pos3d
+     * @param bounds
+     */
+    function getModelBoundsCenter(viewer, part, pos3d, bounds) {
+        const orientation = GetValue$1(viewer, part.orientation);
+        const rotation = orientation
+            ? Cesium.Matrix3.fromQuaternion(orientation, new Cesium.Matrix3())
+            : Cesium.Matrix4.getMatrix3(Cesium.Transforms.eastNorthUpToFixedFrame(pos3d), new Cesium.Matrix3());
+        const offset = Cesium.Matrix3.multiplyByVector(rotation, bounds.center, new Cesium.Cartesian3());
+        return Cesium.Cartesian3.add(pos3d, offset, new Cesium.Cartesian3());
+    }
     // +90° rotation around Z: aligns GLTF Y-up forward with Cesium ENU North.
     const _assemblyAxisShift = new Cesium.Quaternion(0, 0, -Math.SQRT1_2, Math.SQRT1_2);
     (function (EntityUtils) {
@@ -40541,6 +40802,9 @@
                 rectangle: null,
                 sphere: null
             };
+            const spheres = [];
+            // The tile holding a rendered feature that says nothing of where it is, used only when nothing better turns up.
+            const tileSpheres = [];
             const processPosHeight = async (pos3d, heightRef) => {
                 // Raise to minimumAlt if needed.
                 if ((!isNaN(minimumAlt) && minimumAlt != null)) {
@@ -40618,7 +40882,7 @@
                  * Returns an array of positions from the entity's currently rendered graphics.
                  */
                 const evaluateRendered = async () => {
-                    var _a, _b;
+                    var _a, _b, _c, _d;
                     const rego = visualRegister ? visualRegister.GetRego({
                         entityId: sample.entityId,
                         menuItemId: sample.menuItemId
@@ -40750,9 +41014,14 @@
                                     posses.push(pos3d);
                                     if (part.model) {
                                         const modelExt = part.model;
-                                        if (modelExt._radius && modelExt._radius > -1) {
+                                        const bounds = modelExt._bounds;
+                                        if ((bounds === null || bounds === void 0 ? void 0 : bounds.radius) > 0) {
+                                            spheres.push(new Cesium.BoundingSphere(getModelBoundsCenter(viewer, part, pos3d, bounds), bounds.radius));
+                                        }
+                                        else if (modelExt._radius && modelExt._radius > -1) {
                                             const sphere = Cesium.BoundingSphere.fromPoints([pos3d]);
                                             sphere.radius = modelExt._radius;
+                                            spheres.push(sphere);
                                         }
                                     }
                                     else if (part.ellipse) {
@@ -40771,6 +41040,7 @@
                                         const radius = Math.max(semiMajorAxis, semiMinorAxis, height);
                                         if (radius && radius > 0) {
                                             const sphere = new Cesium.BoundingSphere(pos3d, radius);
+                                            spheres.push(sphere);
                                         }
                                     }
                                 }
@@ -40789,6 +41059,14 @@
                                 posses.push(pos3d);
                                 if (data.radius != null && !isNaN(data.radius)) {
                                     const sphere = new Cesium.BoundingSphere(pos3d, data.radius);
+                                    spheres.push(sphere);
+                                }
+                            }
+                            else {
+                                // Missing from the typings this library builds against, but there at runtime.
+                                const tileSphere = (_d = (_c = part.content) === null || _c === void 0 ? void 0 : _c.tile) === null || _d === void 0 ? void 0 : _d.boundingSphere;
+                                if ((tileSphere === null || tileSphere === void 0 ? void 0 : tileSphere.radius) > 0) {
+                                    tileSpheres.push(Cesium.BoundingSphere.clone(tileSphere));
                                 }
                             }
                         }
@@ -40868,7 +41146,7 @@
                     }
                     const boundaries = BModels.Entity.GetValue({
                         entity: entity,
-                        path: ["Bruce, Boundaries"]
+                        path: ["Bruce", "Boundaries"]
                     });
                     if (boundaries && typeof boundaries == "object") {
                         const point = {
@@ -40921,16 +41199,9 @@
                                     const transformedOffset = Cesium.Matrix3.multiplyByVector(transformHpr, offset, new Cesium.Cartesian3());
                                     pos3d = Cesium.Matrix4.multiplyByPoint(m1, transformedOffset, new Cesium.Cartesian3());
                                     pos3d = await processPosHeight(pos3d, Cesium.HeightReference.NONE);
-                                    const geometryRadius = BModels.Entity.GetValue({
-                                        entity: entity,
-                                        path: ["Bruce", "GeometryRadius"]
-                                    });
+                                    const geometryRadius = getTrustedGeometryRadius(entity);
                                     if (geometryRadius && (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-                                        const sphere = Cesium.BoundingSphere.fromPoints([pos3d]);
-                                        // For now making sure it's less than x amount because we had a bug which made it huge.
-                                        if (geometryRadius && geometryRadius < 500 && geometryRadius > 0.1) {
-                                            sphere.radius = geometryRadius;
-                                        }
+                                        spheres.push(new Cesium.BoundingSphere(pos3d, geometryRadius));
                                     }
                                     return [pos3d];
                                 }
@@ -40938,16 +41209,9 @@
                                     if (location) {
                                         let pos3d = Cesium.Cartesian3.fromDegrees(longitude, latitude, EnsureNumber(location.altitude));
                                         pos3d = await processPosHeight(pos3d, Cesium.HeightReference.NONE);
-                                        const geometryRadius = BModels.Entity.GetValue({
-                                            entity: entity,
-                                            path: ["Bruce", "GeometryRadius"]
-                                        });
+                                        const geometryRadius = getTrustedGeometryRadius(entity);
                                         if (geometryRadius && (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-                                            const sphere = Cesium.BoundingSphere.fromPoints([pos3d]);
-                                            // For now making sure it's less than x amount because we had a bug which made it huge.
-                                            if (geometryRadius && geometryRadius < 500 && geometryRadius > 0.1) {
-                                                sphere.radius = geometryRadius;
-                                            }
+                                            spheres.push(new Cesium.BoundingSphere(pos3d, geometryRadius));
                                         }
                                         return [pos3d];
                                     }
@@ -40970,16 +41234,9 @@
                     }
                     if (pos3d) {
                         pos3d = await processPosHeight(pos3d, Cesium.HeightReference.NONE);
-                        const geometryRadius = BModels.Entity.GetValue({
-                            entity: entity,
-                            path: ["Bruce", "GeometryRadius"]
-                        });
+                        const geometryRadius = getTrustedGeometryRadius(entity);
                         if (geometryRadius && (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-                            const sphere = Cesium.BoundingSphere.fromPoints([pos3d]);
-                            // For now making sure it's less than x amount because we had a bug which made it huge.
-                            if (geometryRadius && geometryRadius < 500 && geometryRadius > 0.1) {
-                                sphere.radius = geometryRadius;
-                            }
+                            spheres.push(new Cesium.BoundingSphere(pos3d, geometryRadius));
                         }
                         return [pos3d];
                     }
@@ -40999,16 +41256,9 @@
                                 if (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x) {
                                     pos3d = await processPosHeight(pos3d, Cesium.HeightReference.NONE);
                                 }
-                                const geometryRadius = BModels.Entity.GetValue({
-                                    entity: entity,
-                                    path: ["Bruce", "GeometryRadius"]
-                                });
+                                const geometryRadius = getTrustedGeometryRadius(entity);
                                 if (geometryRadius && (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-                                    const sphere = Cesium.BoundingSphere.fromPoints([pos3d]);
-                                    // For now making sure it's less than x amount because we had a bug which made it huge.
-                                    if (geometryRadius && geometryRadius < 500 && geometryRadius > 0.1) {
-                                        sphere.radius = geometryRadius;
-                                    }
+                                    spheres.push(new Cesium.BoundingSphere(pos3d, geometryRadius));
                                 }
                             }
                         }
@@ -41243,6 +41493,7 @@
                         radius /= 2;
                     }
                     const sphere = new Cesium.BoundingSphere(data.pos3d, radius);
+                    spheres.push(sphere);
                     data.sphere = sphere;
                 }
                 else {
@@ -41252,23 +41503,24 @@
             else if (allPosses.length == 1) {
                 data.pos3d = allPosses[0];
             }
-            /*
-            Was used to clean up bad radius data but now seems to do more harm than good.
-            TODO: re-review edge cases.
-            if ((data.rectangle && spheres.length > 1) || (!data.rectangle && spheres.length > 0)) {
-                const allPointSphere = Cesium.BoundingSphere.fromPoints(allPosses);
-                spheres.push(allPointSphere);
-                if (data.rectangle) {
-                    const rectSphere = Cesium.BoundingSphere.fromRectangle3D(data.rectangle);
-                    spheres.push(rectSphere);
-                }
-                const combinedSphere = Cesium.BoundingSphere.fromBoundingSpheres(spheres);
-                data.sphere = combinedSphere;
+            // The entities' own sizes, so a large piece is framed whole and a small one is not left far away.
+            // The rectangle sphere above only spans the sampled points, which for one entity is its pivot alone.
+            const sizeSpheres = spheres.filter(x => x !== data.sphere && x.radius > 0);
+            if (sizeSpheres.length) {
+                data.sphere = Cesium.BoundingSphere.fromBoundingSpheres(data.sphere ? [data.sphere, ...sizeSpheres] : sizeSpheres);
+                if (allPosses.length <= 1) {
+                    data.pos3d = data.sphere.center;
+                }
             }
-            */
             if (data.sphere && data.sphere.radius <= 0) {
                 data.sphere = null;
             }
+            // An Assembly part's record can come back without a location while the API has yet to resolve its model's
+            // bounds, and its feature carries no position of its own. The tile it is drawn in still says roughly where.
+            if (!data.pos3d && tileSpheres.length) {
+                data.sphere = Cesium.BoundingSphere.fromBoundingSpheres(tileSpheres);
+                data.pos3d = data.sphere.center;
+            }
             return data;
         }
         EntityUtils.GetLocation = GetLocation;
@@ -43827,6 +44079,10 @@
                             }
                             let radius = modelPrim.boundingSphere.radius;
                             let centerOffset = modelPrim.boundingSphere.center;
+                            const bounds = {
+                                center: centerOffset ? Cesium.Cartesian3.clone(centerOffset) : Cesium.Cartesian3.ZERO.clone(),
+                                radius: modelPrim.boundingSphere.radius
+                            };
                             if (centerOffset) {
                                 // Add the center offset to the radius because I am not good at math.
                                 const magnitude = Cesium.Cartesian3.magnitude(centerOffset);
@@ -43838,7 +44094,7 @@
                                 }
                             }
                             kill();
-                            res(radius);
+                            res({ radius, bounds });
                         };
                         let readyEventRemoval = null;
                         // Newer Cesium versions have readyEvent. They don't use readyPromise.
@@ -43863,9 +44119,10 @@
                 });
                 _fileRadiusCache.Set(fileRadiusKey, heightProm);
             }
-            heightProm.then((radius) => {
+            heightProm.then((measured) => {
                 if (model) {
-                    model._radius = radius;
+                    model._radius = measured ? measured.radius : null;
+                    model._bounds = measured ? measured.bounds : null;
                     model._radiusLoaded = true;
                     if (params.viewer && params.viewer.scene && !params.viewer.isDestroyed()) {
                         exports.VisualRegisterCuller.MarkShouldRecheck(params.viewer);
@@ -49649,9 +49906,6 @@ void main() {
         StyleEffective.Combine = Combine;
         /**
          * Returns true if every segment in the filter string appears in the subject effective string.
-         * A filter segment matches if the subject contains a segment starting with the same key,
-         * and either no value filter is given or the value matches exactly.
-         * Passing a partial effective value (e.g. just "f0:gradient") also matches.
          */
         function MatchesFilter(effective, filter) {
             if (!filter) {
@@ -50916,7 +51170,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.5.2";
+    const VERSION = "7.5.4";
     /**
      * 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.