@loaders.gl/tiles 5.0.0-alpha.10 → 5.0.0-alpha.11

package/dist/index.cjs

@@ -2797,6 +2797,7 @@ var Tileset3D = class {
   _traverser;
   _cache = new TilesetCache();
   _requestScheduler;
+  /** Drawn fallback instances retained independently for each viewport tree. */
   _heldTiles = /* @__PURE__ */ new Set();
   updatePromise = null;
   tilesetInitializationPromise;
@@ -2820,6 +2821,7 @@ var Tileset3D = class {
       ...suppliedOptions,
       cacheBytes,
       maximumCacheOverflowBytes,
+      skipLevelOfDetail: suppliedOptions.skipLevelOfDetail ?? source.type === TILESET_TYPE.TILES3D,
       memoryAdjustedScreenSpaceError: suppliedOptions.memoryAdjustedScreenSpaceError ?? usesTiles3DCacheDefaults
     };
     this.loadOptions = this.options.loadOptions || {};
@@ -3105,27 +3107,41 @@ var Tileset3D = class {
       this._emptyTiles = this._emptyTiles.concat(frameStateDataValue._emptyTiles);
     }
     this.selectedTiles = this.options.onTraversalComplete(this.selectedTiles);
-    const selectedIds = new Set(this.selectedTiles.map((tile) => tile.id));
+    const selectedTiles = new Set(this.selectedTiles);
     const hasUndrawnTiles = this.selectedTiles.some((tile) => !tile.tileDrawn);
     let heldBackCount = 0;
     if (hasUndrawnTiles) {
-      for (const tileId of selectedIds) {
-        this._heldTiles.add(tileId);
+      const activeRoots = new Set(Object.keys(this.frameStateData).map((viewportId) => this.roots[viewportId]));
+      const descendantReadiness = /* @__PURE__ */ new Map();
+      for (const tile of this.selectedTiles) {
+        for (let ancestor = tile.parent; ancestor; ancestor = ancestor.parent) {
+          descendantReadiness.set(ancestor, (descendantReadiness.get(ancestor) ?? true) && tile.tileDrawn);
+        }
+      }
+      for (const tile of previousSelectedTiles) {
+        if (tile.tileDrawn)
+          this._heldTiles.add(tile);
       }
-      for (const tileId of this._heldTiles) {
-        if (selectedIds.has(tileId))
+      for (const tile of this._heldTiles) {
+        let root = tile;
+        while (root.parent)
+          root = root.parent;
+        if (!activeRoots.has(root)) {
+          this._heldTiles.delete(tile);
           continue;
-        const tile = this._tiles[tileId];
-        if (tile && tile.contentAvailable) {
+        }
+        if (selectedTiles.has(tile))
+          continue;
+        if (tile.contentAvailable && !this._hasDrawnReplacement(tile, selectedTiles, descendantReadiness)) {
           tile._selectedFrame = this._frameNumber;
           this.selectedTiles.push(tile);
           heldBackCount++;
         } else {
-          this._heldTiles.delete(tileId);
+          this._heldTiles.delete(tile);
         }
       }
     } else {
-      this._heldTiles = selectedIds;
+      this._heldTiles = selectedTiles;
     }
     if (heldBackCount > 0) {
       setTimeout(() => {
@@ -3142,6 +3158,19 @@ var Tileset3D = class {
       this.options.onUpdate();
     }
   }
+  /**
+   * Releases fallback geometry once its own selected replacement has drawn.
+   * Unrelated pending branches must not delay this region's handoff. When no related
+   * replacement is selected, retain the fallback until the complete selection has drawn.
+   */
+  _hasDrawnReplacement(tile, selectedTiles, descendantReadiness) {
+    for (let ancestor = tile.parent; ancestor; ancestor = ancestor.parent) {
+      if (selectedTiles.has(ancestor)) {
+        return ancestor.tileDrawn;
+      }
+    }
+    return descendantReadiness.get(tile) === true;
+  }
   _tilesChanged(oldSelectedTiles, selectedTiles) {
     if (oldSelectedTiles.length !== selectedTiles.length) {
       return true;
@@ -4193,9 +4222,6 @@ var TilesetTraverser = class {
           childRefines = child.contentAvailable;
         }
         refines = refines && childRefines;
-        if (!refines) {
-          return false;
-        }
       }
     }
     if (!hasVisibleChild) {
@@ -5253,7 +5279,7 @@ var Tile3D = class {
 };
 
 // dist/tileset-3d/format-3d-tiles/tiles-3d-source.js
-var import_geospatial10 = require("@math.gl/geospatial");
+var import_geospatial9 = require("@math.gl/geospatial");
 var import_core12 = require("@math.gl/core");
 
 // dist/tileset-3d/format-3d-tiles/tileset-3d-traverser.js
@@ -5309,7 +5335,7 @@ var Tileset3DTraverser = class extends TilesetTraverser {
       if (!tile.hasRenderContent) {
         this.emptyTiles[tile.id] = tile;
         this.loadTile(tile, frameState);
-        if (stoppedRefining) {
+        if (stoppedRefining && (!tile.hasEmptyContent || tile.hasChildren)) {
           this.selectDesiredTile(tile, frameState);
         }
       } else if (tile.refine === TILE_REFINEMENT.ADD) {
@@ -5350,7 +5376,7 @@ var Tileset3DTraverser = class extends TilesetTraverser {
       if (child.isVisibleAndInRequestVolume) {
         stack.push(child);
         hasVisibleChild = true;
-      } else if (this.options.loadSiblings) {
+      } else if (this.options.loadSiblings && child._inRequestVolume) {
         this.loadTile(child, frameState);
         this.touchTile(child, frameState);
       }
@@ -5430,6 +5456,9 @@ var Tileset3DTraverser = class extends TilesetTraverser {
     while (fallbackTile) {
       if (this.shouldSelectTile(fallbackTile, frameState)) {
         this.selectTile(fallbackTile, frameState);
+        if (fallbackTile !== tile) {
+          this.selectLoadedDescendants(tile, frameState, true);
+        }
         return;
       }
       fallbackTile = fallbackTile.parent;
@@ -5441,8 +5470,9 @@ var Tileset3DTraverser = class extends TilesetTraverser {
    *
    * @param root - Unavailable tile whose descendants are searched.
    * @param frameState - Current culling state.
+   * @param drawnOnly - Reuse drawn detail without starting obsolete GPU work.
    */
-  selectLoadedDescendants(root, frameState) {
+  selectLoadedDescendants(root, frameState, drawnOnly = false) {
     const stack = [{ tile: root, depth: 0 }];
     while (stack.length > 0) {
       const { tile, depth } = stack.pop();
@@ -5451,7 +5481,7 @@ var Tileset3DTraverser = class extends TilesetTraverser {
         if (!child.isVisibleAndInRequestVolume) {
           continue;
         }
-        if (child.contentAvailable) {
+        if (this.shouldSelectTile(child, frameState) && (!drawnOnly || child.tileDrawn)) {
           this.selectTile(child, frameState);
           this.touchTile(child, frameState);
         } else if (depth < 1) {
@@ -5895,19 +5925,26 @@ function getTilesetSemanticValue(tileset, semantic) {
 // dist/spatial/spatial-coordinate-transformer.js
 var import_core10 = require("@math.gl/core");
 var import_geospatial7 = require("@math.gl/geospatial");
-var import_projection2 = require("@math.gl/projection");
 
 // dist/spatial/spatial-resource-registry.js
 var import_geoid = require("@math.gl/geoid");
 var import_projection = require("@math.gl/projection");
 var geoidModels = /* @__PURE__ */ new Map();
+var projectionAliases = {};
+var datumGrids = {};
+var spatialProjectionEngine = new import_projection.FullProjectionEngine();
+function getSpatialProjectionEngine() {
+  return spatialProjectionEngine;
+}
 function registerSpatialCrs(name, definition) {
   validateResourceName(name, "CRS");
-  import_projection.Projection.defineProjectionAliases({ [name]: definition });
+  projectionAliases[name] = definition;
+  spatialProjectionEngine = new import_projection.FullProjectionEngine({ aliases: projectionAliases, datumGrids });
 }
 function registerSpatialDatumGrid(name, data) {
   validateResourceName(name, "datum grid");
-  import_projection.Projection.registerDatumGrid(name, data);
+  datumGrids[name] = (0, import_projection.parseNTv2Grid)(data);
+  spatialProjectionEngine = new import_projection.FullProjectionEngine({ aliases: projectionAliases, datumGrids });
 }
 function registerGeoidModel(name, geoid) {
   validateResourceName(name, "geoid model");
@@ -5955,6 +5992,7 @@ var SpatialCoordinateTransformer = class {
    */
   constructor(spatialReference, options = {}) {
     this.spatialReference = spatialReference;
+    const projectionEngine = getSpatialProjectionEngine();
     validateTransformRequest(spatialReference);
     const outputCrs = spatialReference.targetCrs || spatialReference.sourceCrs;
     this.sourceIsGeocentric = isWgs84Geocentric(spatialReference.sourceCrs);
@@ -5962,7 +6000,7 @@ var SpatialCoordinateTransformer = class {
     this.sourceIsGeographic = isWgs84Geographic(spatialReference.sourceCrs);
     this.outputIsGeographic = isWgs84Geographic(outputCrs);
     if (spatialReference.sourceCrs && spatialReference.targetCrs && !this.sourceIsGeocentric && !this.outputIsGeocentric) {
-      this.horizontalProjection = new import_projection2.Projection({
+      this.horizontalProjection = projectionEngine.createProjection({
         from: getHorizontalProjectionDefinition(spatialReference.sourceCrs),
         to: getHorizontalProjectionDefinition(spatialReference.targetCrs),
         enforceAxis: false
@@ -5970,14 +6008,14 @@ var SpatialCoordinateTransformer = class {
     }
     if (requiresHeightTransformation(spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
       if (!this.sourceIsGeographic && !this.sourceIsGeocentric) {
-        this.geographicProjection = new import_projection2.Projection({
+        this.geographicProjection = projectionEngine.createProjection({
           from: getHorizontalProjectionDefinition(spatialReference.sourceCrs),
           to: WGS84_GEOGRAPHIC_CRS,
           enforceAxis: false
         });
       }
       if (!this.outputIsGeographic && !this.outputIsGeocentric) {
-        this.heightOutputProjection = new import_projection2.Projection({
+        this.heightOutputProjection = projectionEngine.createProjection({
           from: WGS84_GEOGRAPHIC_CRS,
           to: getHorizontalProjectionDefinition(outputCrs),
           enforceAxis: false
@@ -6017,7 +6055,7 @@ var SpatialCoordinateTransformer = class {
       return result;
     }
     if (this.horizontalProjection) {
-      const projected = this.horizontalProjection.project(result.slice(0, 3));
+      const projected = this.horizontalProjection.projectSync(result.slice(0, 3));
       result.splice(0, projected.length, ...projected);
     }
     return result;
@@ -6081,7 +6119,7 @@ var SpatialCoordinateTransformer = class {
     if (this.sourceIsGeographic) {
       return coordinate.slice(0, 3);
     }
-    return this.geographicProjection.project(coordinate.slice(0, 3));
+    return this.geographicProjection.projectSync(coordinate.slice(0, 3));
   }
   /** Convert one conventional WGS84 geographic coordinate to the selected output CRS. */
   fromGeographic(coordinate) {
@@ -6091,7 +6129,7 @@ var SpatialCoordinateTransformer = class {
     if (this.outputIsGeographic) {
       return coordinate.slice(0, 3);
     }
-    return this.heightOutputProjection.project(coordinate.slice(0, 3));
+    return this.heightOutputProjection.projectSync(coordinate.slice(0, 3));
   }
 };
 function getFiniteDifferenceJacobian(transformer, position, epsilon) {
@@ -6189,7 +6227,6 @@ function transformHeight(height, geoidUndulation, source, target) {
 
 // dist/spatial/tiles-3d-spatial-transformer.js
 var import_core11 = require("@math.gl/core");
-var import_geospatial8 = require("@math.gl/geospatial");
 var Tiles3DSpatialTransformer = class {
   /** Normalized reference describing the completed operation. */
   spatialReference;
@@ -6228,16 +6265,6 @@ var Tiles3DSpatialTransformer = class {
   }
   /** Transforms one WGS84 region sample into the selected output frame. */
   transformRegionSample(sample) {
-    const [longitudeDegrees, latitudeDegrees, height] = sample;
-    const targetCrs = this.spatialReference.targetCrs || this.spatialReference.sourceCrs;
-    if (targetCrs && getSpatialCoordinateFrame(targetCrs) === "geocentric") {
-      const cartesian = import_geospatial8.Ellipsoid.WGS84.cartographicToCartesian([
-        longitudeDegrees,
-        latitudeDegrees,
-        height
-      ]);
-      return Array.from(cartesian);
-    }
     return this.geographicCoordinateTransformer.transformPosition(sample);
   }
 };
@@ -6346,10 +6373,10 @@ var import_s22 = require("@math.gl/dggs/s2");
 
 // dist/tileset-3d/helpers/s2-bounding-volume.js
 var import_s2 = require("@math.gl/dggs/s2");
-var import_geospatial9 = require("@math.gl/geospatial");
+var import_geospatial8 = require("@math.gl/geospatial");
 function convertS2BoundingVolumeToOBB(s2VolumeInfo) {
   const [[west, south], [east, north]] = (0, import_s2.getS2Bounds)(s2VolumeInfo.token);
-  const orientedBoundingBox = (0, import_geospatial9.makeOBBFromRegion)([west, south, east, north, s2VolumeInfo.minimumHeight, s2VolumeInfo.maximumHeight], import_geospatial9.Ellipsoid.WGS84, { units: "degrees" });
+  const orientedBoundingBox = (0, import_geospatial8.makeOBBFromRegion)([west, south, east, north, s2VolumeInfo.minimumHeight, s2VolumeInfo.maximumHeight], import_geospatial8.Ellipsoid.WGS84, { units: "degrees" });
   return [...orientedBoundingBox.center, ...orientedBoundingBox.halfAxes];
 }
 
@@ -7260,9 +7287,9 @@ var Tiles3DSource = class {
     let cartographicCenter;
     if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) {
       cartographicCenter = new import_core12.Vector3();
-      import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(center, cartographicCenter);
+      import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(center, cartographicCenter);
     } else {
-      cartographicCenter = new import_core12.Vector3(0, 0, -import_geospatial10.Ellipsoid.WGS84.radii[0]);
+      cartographicCenter = new import_core12.Vector3(0, 0, -import_geospatial9.Ellipsoid.WGS84.radii[0]);
     }
     return {
       asset: this.asset,
@@ -7559,7 +7586,7 @@ function addNestedSpatialReference(nestedTileset, spatialReference) {
 }
 
 // dist/tileset-3d/format-i3s/i3s-source.js
-var import_geospatial12 = require("@math.gl/geospatial");
+var import_geospatial11 = require("@math.gl/geospatial");
 var import_core14 = require("@math.gl/core");
 
 // dist/tileset-3d/format-i3s/i3s-pending-tiles-register.js
@@ -7745,7 +7772,7 @@ var I3STilesetTraverser = class extends TilesetTraverser {
 
 // dist/spatial/i3s-spatial-transformer.js
 var import_core13 = require("@math.gl/core");
-var import_geospatial11 = require("@math.gl/geospatial");
+var import_geospatial10 = require("@math.gl/geospatial");
 var I3SSpatialTransformer = class {
   /** Descriptor attached to output after all adapter-owned spatial values have been transformed. */
   spatialReference;
@@ -7924,6 +7951,32 @@ var I3SSpatialTransformer = class {
     const placedPositions = await this.placeSourcePositions(combinedPositions);
     return this.transformPlacedPositions(placedPositions.subarray(0, sourcePositions.length), placedPositions.subarray(sourcePositions.length));
   }
+  /**
+   * Transforms conversion geometry without passing through renderer float32 offsets.
+   * Positions and normals share one batch of elevation samples. Source arrays remain unchanged.
+   * @param sourcePositions - Packed absolute xyz positions in source units.
+   * @param normals - Optional packed normals paired with the positions.
+   * @param normalReferenceFrame - I3S earth-centered or vertex-reference-frame declaration.
+   * @returns Absolute target positions and optional transformed normals.
+   */
+  async transformGeometryAsync(sourcePositions, normals, normalReferenceFrame = "earth-centered") {
+    if (sourcePositions.length % 3 || normals && normals.length !== sourcePositions.length) {
+      throw new Error("Conversion positions and normals must contain matching finite xyz triples");
+    }
+    for (let index = 0; index < sourcePositions.length; index++) {
+      if (!Number.isFinite(sourcePositions[index]) || normals && !Number.isFinite(normals[index])) {
+        throw new Error("Conversion positions and normals must contain matching finite xyz triples");
+      }
+    }
+    if (!["earth-centered", "vertex-reference-frame"].includes(normalReferenceFrame)) {
+      throw new Error("Unsupported I3S normal reference frame");
+    }
+    const placedPositions = await this.placeSourcePositions(sourcePositions);
+    return {
+      positions: this.positionTransformer.transformPositions(placedPositions),
+      normals: normals ? this.transformNormals(normals, placedPositions, normalReferenceFrame) : void 0
+    };
+  }
   /** Transform already placed positions into renderer-relative target coordinates. */
   transformPlacedPositions(sourcePositions, sourceOrigin) {
     const origin = this.transformPlacedPosition(sourceOrigin);
@@ -7961,7 +8014,19 @@ var I3SSpatialTransformer = class {
    * @param normalReferenceFrame - I3S normal frame declaration.
    */
   transformNormals(normals, sourcePositions, normalReferenceFrame = "earth-centered") {
+    if (normals.length !== sourcePositions.length || normals.length % 3) {
+      throw new Error("I3S normals and positions must have matching xyz component counts");
+    }
     const transformedNormals = new Float32Array(normals.length);
+    if (normalReferenceFrame === "earth-centered" && (this.spatialReference.targetCrs || this.spatialReference.sourceCrs) === "EPSG:4978") {
+      for (let index = 0; index < normals.length; index += 3) {
+        const length = Math.hypot(normals[index], normals[index + 1], normals[index + 2]);
+        for (let axis = 0; axis < 3; axis++) {
+          transformedNormals[index + axis] = length ? normals[index + axis] / length : normals[index + axis];
+        }
+      }
+      return transformedNormals;
+    }
     for (let index = 0; index < normals.length; index += 3) {
       const geographic = this.sourceToGeographicTransformer.transformPosition([
         sourcePositions[index],
@@ -8006,12 +8071,12 @@ var I3SSpatialTransformer = class {
   }
   /** Rebuild an I3S bound as a WGS84 ECEF box for generic `Tileset3D` traversal. */
   transformBoundingVolumeToGeocentric(bounds) {
-    const cartesianSamples = this.getGeographicBoundSamples(bounds).map((position) => Array.from(import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
+    const cartesianSamples = this.getGeographicBoundSamples(bounds).map((position) => Array.from(import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
     return { box: getAxisAlignedBox(cartesianSamples) };
   }
   /** Rebuild an I3S bound as WGS84 ECEF after asynchronous elevation placement. */
   async transformBoundingVolumeToGeocentricAsync(bounds) {
-    const cartesianSamples = (await this.getGeographicBoundSamplesAsync(bounds)).map((position) => Array.from(import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
+    const cartesianSamples = (await this.getGeographicBoundSamplesAsync(bounds)).map((position) => Array.from(import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
     return { box: getAxisAlignedBox(cartesianSamples) };
   }
   /** Return a WGS84 geographic MBS used by the I3S screen-threshold calculation. */
@@ -8038,7 +8103,7 @@ var I3SSpatialTransformer = class {
    */
   async transformBoundsAsync(bounds) {
     const geographicSamples = await this.getGeographicBoundSamplesAsync(bounds);
-    const cartesianSamples = geographicSamples.map((position) => Array.from(import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
+    const cartesianSamples = geographicSamples.map((position) => Array.from(import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
     const targetSamples = geographicSamples.map((position) => this.geographicToTargetTransformer.transformPosition(position));
     return {
       boundingVolume: { box: getAxisAlignedBox(cartesianSamples) },
@@ -8161,11 +8226,11 @@ var I3SSpatialTransformer = class {
     if (this.targetCoordinateFrame === "geographic") {
       return ecefVectorToLocalEnu(ecefNormal, geographic).normalize();
     }
-    const cartesian = import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(geographic));
+    const cartesian = import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(geographic));
     const jacobianColumns = [];
     for (const direction of getPositiveAxisDirections()) {
-      const positiveGeographic = import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(new import_core13.Vector3(cartesian).add(direction));
-      const negativeGeographic = import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(new import_core13.Vector3(cartesian).subtract(direction));
+      const positiveGeographic = import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(new import_core13.Vector3(cartesian).add(direction));
+      const negativeGeographic = import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(new import_core13.Vector3(cartesian).subtract(direction));
       const positiveTarget = this.geographicToTargetTransformer.transformPosition(positiveGeographic);
       const negativeTarget = this.geographicToTargetTransformer.transformPosition(negativeGeographic);
       jacobianColumns.push((positiveTarget[0] - negativeTarget[0]) / 2, (positiveTarget[1] - negativeTarget[1]) / 2, (positiveTarget[2] - negativeTarget[2]) / 2);
@@ -8207,7 +8272,7 @@ function getGeographicBoundingSphere(geographicSamples) {
   if (!geographicSamples.length) {
     throw new Error("I3S spatial transformation requires at least one bound sample");
   }
-  const cartesianSamples = geographicSamples.map((position) => import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position)));
+  const cartesianSamples = geographicSamples.map((position) => import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position)));
   const cartesianCenter = new import_core13.Vector3();
   for (const sample of cartesianSamples) {
     cartesianCenter.add(sample);
@@ -8217,7 +8282,7 @@ function getGeographicBoundingSphere(geographicSamples) {
   for (const sample of cartesianSamples) {
     radius = Math.max(radius, new import_core13.Vector3(sample).subtract(cartesianCenter).magnitude());
   }
-  const geographicCenter = import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(cartesianCenter);
+  const geographicCenter = import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(cartesianCenter);
   return [geographicCenter[0], geographicCenter[1], geographicCenter[2], radius];
 }
 function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransformer, sourceVerticalUnitScale) {
@@ -8234,14 +8299,14 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
     ];
     if (sourceFrame === "geographic") {
       const geographicCenter = sourceToGeographicTransformer.transformPosition(center2);
-      const cartesianCenter = import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(geographicCenter));
+      const cartesianCenter = import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(geographicCenter));
       const cartesianAxes = bounds.normalReferenceFrame === "vertex-reference-frame" ? axes.map((axis) => localEnuVectorToEcef(axis, geographicCenter)) : axes;
       return getBoxSigns().map((signs) => {
         const corner = new import_core13.Vector3(cartesianCenter);
         for (let axisIndex = 0; axisIndex < 3; axisIndex++) {
           corner.add(new import_core13.Vector3(cartesianAxes[axisIndex]).scale(signs[axisIndex]));
         }
-        return Array.from(import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(corner));
+        return Array.from(import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(corner));
       });
     }
     return getBoxSigns().map((signs) => {
@@ -8261,8 +8326,8 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
   const radius = mbs[3];
   if (sourceFrame === "geographic") {
     const geographicCenter = sourceToGeographicTransformer.transformPosition(center);
-    const cartesianCenter = import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(geographicCenter));
-    return getAxisDirections().map((direction) => Array.from(import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(new import_core13.Vector3(cartesianCenter).add(new import_core13.Vector3(direction).scale(radius)))));
+    const cartesianCenter = import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(geographicCenter));
+    return getAxisDirections().map((direction) => Array.from(import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(new import_core13.Vector3(cartesianCenter).add(new import_core13.Vector3(direction).scale(radius)))));
   }
   return getAxisDirections().map((direction) => Array.from(new import_core13.Vector3(center).add(new import_core13.Vector3(direction).scale(radius))));
 }
@@ -8646,7 +8711,7 @@ var I3SSource = class {
       const { xmin, xmax, ymin, ymax, zmin, zmax } = fullExtent;
       const cartographicCenter = new import_core14.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, zmin + (zmax - zmin) / 2);
       const cartesianCenter = new import_core14.Vector3();
-      import_geospatial12.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
+      import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
       return {
         cartographicCenter,
         cartesianCenter,
@@ -8658,7 +8723,7 @@ var I3SSource = class {
       const [xmin, ymin, xmax, ymax] = extent;
       const cartographicCenter = new import_core14.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, 0);
       const cartesianCenter = new import_core14.Vector3();
-      import_geospatial12.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
+      import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
       return {
         cartographicCenter,
         cartesianCenter,