@loaders.gl/tiles 5.0.0-alpha.5 → 5.0.0-alpha.7

package/dist/index.cjs

@@ -39,12 +39,14 @@ __export(index_exports, {
   TILE_TYPE: () => TILE_TYPE,
   Tile3D: () => Tile3D,
   Tiles3DSource: () => Tiles3DSource,
+  Tiles3DSpatialTransformer: () => Tiles3DSpatialTransformer,
   Tileset2D: () => Tileset2D,
   Tileset3D: () => Tileset3D,
   TilesetCache: () => TilesetCache,
   TilesetTraverser: () => TilesetTraverser,
   applyTilesetSpatialOptions: () => applyTilesetSpatialOptions,
   calculateTransformProps: () => calculateTransformProps,
+  convertS2BoundingVolumeToOBB: () => convertS2BoundingVolumeToOBB,
   createBoundingVolume: () => createBoundingVolume,
   createImplicitSubtreeReference: () => createImplicitSubtreeReference,
   createTilesetSpatialReference: () => createTilesetSpatialReference,
@@ -54,6 +56,7 @@ __export(index_exports, {
   getI3SSpatialReference: () => getI3SSpatialReference,
   getLodStatus: () => getLodStatus,
   getSpatialCoordinateFrame: () => getSpatialCoordinateFrame,
+  getTileset3DTraversalSnapshot: () => getTileset3DTraversalSnapshot,
   isTileset3DSource: () => isTileset3DSource,
   markTilesetSpatialReferenceTransformed: () => markTilesetSpatialReferenceTransformed,
   materializeImplicitSubtree: () => materializeImplicitSubtree,
@@ -77,6 +80,13 @@ function assert(condition, message) {
   }
 }
 
+// ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
+function sliceArrayBuffer(arrayBuffer, byteOffset, byteLength) {
+  const subArray = byteLength !== void 0 ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength) : new Uint8Array(arrayBuffer).subarray(byteOffset);
+  const arrayCopy = new Uint8Array(subArray);
+  return arrayCopy.buffer;
+}
+
 // ../loader-utils/src/lib/request-utils/request-scheduler.ts
 var import_stats = require("@probe.gl/stats");
 var STAT_QUEUED_REQUESTS = "Queued Requests";
@@ -1900,7 +1910,7 @@ function getFrameState(viewport, frameNumber, options = {}) {
   ).normalize();
   commonSpacePlanesToWGS84(viewport);
   const ViewportClass = viewport.constructor;
-  const { longitude, latitude, width, bearing, zoom } = viewport;
+  const { longitude, latitude, width, bearing, zoom, position } = viewport;
   const topDownViewport = new ViewportClass({
     longitude,
     latitude,
@@ -1908,6 +1918,7 @@ function getFrameState(viewport, frameNumber, options = {}) {
     width,
     bearing,
     zoom,
+    position,
     pitch: 0
   });
   return {
@@ -2265,30 +2276,32 @@ function calculateTileRequestPriority(parameters) {
 }
 
 // dist/spatial/spatial-types.js
-var import_crs = require("@math.gl/crs");
+var import_crs2 = require("@math.gl/crs");
 
 // dist/spatial/get-spatial-coordinate-frame.js
-var GEOGRAPHIC_CRS = "EPSG:4326";
-var GEOCENTRIC_CRS = "EPSG:4978";
+var import_crs = require("@math.gl/crs");
+
+// dist/spatial/normalize-crs-identifier.js
+var WGS84_GEOGRAPHIC_CRS = "EPSG:4326";
+var WGS84_GEOCENTRIC_CRS = "EPSG:4978";
 function normalizeCrsIdentifier(identifier) {
   const normalizedIdentifier = identifier.trim().toUpperCase();
   const ogcMatch = normalizedIdentifier.match(/(?:\/DEF\/CRS\/|URN:OGC:DEF:CRS:)([A-Z0-9_-]+)(?:\/|::)(?:[^/:]*[/:])?([A-Z0-9_.-]+)$/);
   return ogcMatch ? `${ogcMatch[1]}:${ogcMatch[2]}` : normalizedIdentifier;
 }
+
+// dist/spatial/get-spatial-coordinate-frame.js
 function getSpatialCoordinateFrame(definition) {
   var _a, _b;
   if (typeof definition === "string") {
-    const normalized = normalizeCrsIdentifier(definition);
-    if (normalized === GEOCENTRIC_CRS || /^GEOCCS\s*[\[(]/.test(normalized)) {
-      return "geocentric";
+    const representation = (0, import_crs.inferCRSRepresentation)(definition);
+    if (representation === "wkt") {
+      return getWktCoordinateFrame(definition);
     }
-    if (normalized === GEOGRAPHIC_CRS || normalized === "EPSG:4490" || normalized === "EPSG:4979" || normalized === "OGC:CRS84" || normalized.includes("+PROJ=LONGLAT") || normalized.includes("+PROJ=LATLONG") || /^(?:GEOGCS|GEOGCRS|GEOGRAPHICCRS|GEOGRAPHIC2DCRS|GEOGRAPHIC3DCRS)\s*[\[(]/.test(normalized)) {
-      return "geographic";
-    }
-    if (/^(?:GEODCRS|GEODETICCRS)\s*[\[(]/.test(normalized)) {
-      return /CS\s*[\[(]\s*CARTESIAN/.test(normalized) ? "geocentric" : "geographic";
+    if (representation === "proj-string") {
+      return getProjStringCoordinateFrame(definition);
     }
-    return "projected";
+    return getKnownCrsIdentifierCoordinateFrame(definition) || "projected";
   }
   const projJsonDefinition = definition;
   if (projJsonDefinition.type === "BoundCRS" && projJsonDefinition.source_crs) {
@@ -2306,7 +2319,84 @@ function getSpatialCoordinateFrame(definition) {
   if (String(projJsonDefinition.type).includes("Geodetic")) {
     return ((_b = projJsonDefinition.coordinate_system) == null ? void 0 : _b.subtype) === "Cartesian" ? "geocentric" : "geographic";
   }
-  return "projected";
+  return "unknown";
+}
+function getKnownCrsIdentifierCoordinateFrame(definition) {
+  if (typeof definition !== "string") {
+    return void 0;
+  }
+  const normalized = normalizeCrsIdentifier(definition);
+  if (normalized === WGS84_GEOCENTRIC_CRS) {
+    return "geocentric";
+  }
+  if (normalized === WGS84_GEOGRAPHIC_CRS || normalized === "OGC:CRS84") {
+    return "geographic";
+  }
+  const epsgMatch = /^EPSG:(\d+)$/.exec(normalized);
+  if (!epsgMatch) {
+    return void 0;
+  }
+  const identifier = Number(epsgMatch[1]);
+  if (identifier === 7789) {
+    return "geocentric";
+  }
+  if (identifier === 4490 || identifier === 4979) {
+    return "geographic";
+  }
+  if (identifier === 3857 || identifier >= 32601 && identifier <= 32660 || identifier >= 32701 && identifier <= 32760) {
+    return "projected";
+  }
+  return void 0;
+}
+function getWktCoordinateFrame(definition) {
+  let root;
+  try {
+    root = (0, import_crs.parseWKTCRS)(definition).root;
+  } catch {
+    return "unknown";
+  }
+  switch (root.keyword.toUpperCase()) {
+    case "GEOCCS":
+      return "geocentric";
+    case "GEOGCS":
+    case "GEOGCRS":
+    case "GEOGRAPHICCRS":
+    case "GEOGRAPHIC2DCRS":
+    case "GEOGRAPHIC3DCRS":
+      return "geographic";
+    case "PROJCS":
+    case "PROJCRS":
+    case "PROJECTEDCRS":
+      return "projected";
+    case "GEODCRS":
+    case "GEODETICCRS": {
+      const coordinateSystem = root.values.find((value) => value.type === "node" && value.keyword.toUpperCase() === "CS");
+      const subtype = coordinateSystem == null ? void 0 : coordinateSystem.values[0];
+      if ((subtype == null ? void 0 : subtype.type) !== "enumeration" && (subtype == null ? void 0 : subtype.type) !== "string") {
+        return "unknown";
+      }
+      return subtype.value.toUpperCase() === "CARTESIAN" ? "geocentric" : subtype.value.toUpperCase() === "ELLIPSOIDAL" ? "geographic" : "unknown";
+    }
+    default:
+      return "unknown";
+  }
+}
+function getProjStringCoordinateFrame(definition) {
+  var _a;
+  try {
+    const projection = (_a = (0, import_crs.parsePROJString)(definition).parameters.find((parameter) => parameter.name.toLowerCase() === "proj")) == null ? void 0 : _a.value;
+    switch (projection == null ? void 0 : projection.toLowerCase()) {
+      case "longlat":
+      case "latlong":
+        return "geographic";
+      case "geocent":
+        return "geocentric";
+      default:
+        return projection ? "projected" : "unknown";
+    }
+  } catch {
+    return "unknown";
+  }
 }
 
 // dist/spatial/spatial-types.js
@@ -2331,11 +2421,11 @@ function createTilesetSpatialReference(discovered, options = {}) {
   const provenance = hasSourceCrsOverride ? "caller-override" : discovered.provenance || "unknown";
   const coordinateFrame = hasSourceCrsOverride && sourceCrs ? getSpatialCoordinateFrame(sourceCrs) : discovered.coordinateFrame;
   const sourceCrsState = hasSourceCrsOverride ? "explicit" : discovered.sourceCrsState || (sourceCrs ? provenance === "format-default" ? "default" : "explicit" : "absent");
-  const spatialReference = (0, import_crs.createSpatialReference)({
+  const spatialReference = (0, import_crs2.createSpatialReference)({
     crs: sourceCrs ? {
       state: sourceCrsState === "default" ? "default" : "explicit",
       definition: sourceCrs,
-      representation: !hasSourceCrsOverride && discovered.sourceCrsRepresentation || (0, import_crs.inferCRSRepresentation)(sourceCrs),
+      representation: !hasSourceCrsOverride && discovered.sourceCrsRepresentation || (0, import_crs2.inferCRSRepresentation)(sourceCrs),
       provenance,
       alternatives: hasSourceCrsOverride ? void 0 : discovered.sourceCrsAlternatives
     } : {
@@ -2345,7 +2435,7 @@ function createTilesetSpatialReference(discovered, options = {}) {
     vertical: discovered.verticalCrs ? {
       state: "explicit",
       definition: discovered.verticalCrs,
-      representation: (0, import_crs.inferCRSRepresentation)(discovered.verticalCrs),
+      representation: (0, import_crs2.inferCRSRepresentation)(discovered.verticalCrs),
       provenance: discovered.provenance || "metadata"
     } : void 0,
     coordinateEpoch: options.coordinateEpoch ?? discovered.coordinateEpoch,
@@ -2402,11 +2492,11 @@ function getKnownCRSDefinition(reference) {
   return reference.state === "explicit" || reference.state === "default" ? reference.definition : void 0;
 }
 function cloneReadonlyCRSDefinition(definition) {
-  const spatialReference = (0, import_crs.createSpatialReference)({
+  const spatialReference = (0, import_crs2.createSpatialReference)({
     crs: {
       state: "explicit",
       definition,
-      representation: (0, import_crs.inferCRSRepresentation)(definition),
+      representation: (0, import_crs2.inferCRSRepresentation)(definition),
       provenance: "caller-override"
     }
   });
@@ -2495,6 +2585,10 @@ var DEFAULT_PROPS3 = {
   foveatedTimeDelay: 0.2,
   maximumScreenSpaceError: 8,
   skipLevelOfDetail: false,
+  baseScreenSpaceError: 1024,
+  skipScreenSpaceErrorFactor: 16,
+  skipLevels: 1,
+  immediatelyLoadDesiredLevelOfDetail: false,
   dynamicScreenSpaceError: true,
   dynamicScreenSpaceErrorDensity: 2e-4,
   dynamicScreenSpaceErrorFactor: 24,
@@ -2657,6 +2751,24 @@ var Tileset3D = class {
   get frameNumber() {
     return this._frameNumber;
   }
+  /**
+   * Returns the tiles requested during the most recent completed traversal.
+   *
+   * A defensive copy makes request ordering deterministic for diagnostics and prevents callers
+   * from mutating the scheduler's working set.
+   */
+  get requestedTiles() {
+    return this._requestedTiles.slice();
+  }
+  /**
+   * Returns empty tiles considered during the most recent completed traversal.
+   *
+   * Empty tiles can still be useful hierarchy placeholders, but their IDs are included in
+   * observability snapshots so applications can distinguish traversal work from render content.
+   */
+  get emptyTiles() {
+    return this._emptyTiles.slice();
+  }
   /**
    * Gets or sets the soft target, in bytes, for cached tile content not needed this frame.
    *
@@ -2784,6 +2896,12 @@ var Tileset3D = class {
       return;
     }
     const preparedViewports = viewports instanceof Array ? viewports : [viewports];
+    const activeViewportIds = new Set(preparedViewports.map((viewport) => viewport.id));
+    for (const frameStateId of Object.keys(this.frameStateData)) {
+      if (!activeViewportIds.has(frameStateId)) {
+        delete this.frameStateData[frameStateId];
+      }
+    }
     this._cache.reset();
     this._frameNumber++;
     this.traverseCounter = preparedViewports.length;
@@ -2972,21 +3090,21 @@ var Tileset3D = class {
     this.stats.get(MAXIMUM_SSE).count = this.memoryAdjustedScreenSpaceError;
   }
   async _initializeTileSet() {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     try {
       const initializePromise = this.source.initialize();
       const initialMetadata = this._getSourceMetadata();
       if (initialMetadata) {
         this._syncSourceState(initialMetadata);
       }
-      if (((_a = initialMetadata == null ? void 0 : initialMetadata.tileset) == null ? void 0 : _a.root) && typeof initialMetadata.tileset.root.then !== "function" && !this.source.prepareTileset) {
+      if (((_a = initialMetadata == null ? void 0 : initialMetadata.tileset) == null ? void 0 : _a.root) && typeof initialMetadata.tileset.root.then !== "function" && (!this.source.prepareTileset || ((_b = this.spatialReference) == null ? void 0 : _b.status) === "native")) {
         this.root = this._initializeTileHeaders(initialMetadata.tileset, null);
         this._applyViewState();
       }
       await initializePromise;
       const metadata = this.source.getMetadata();
       this._syncSourceState(metadata);
-      await ((_c = (_b = this.source).prepareTileset) == null ? void 0 : _c.call(_b, this));
+      await ((_d = (_c = this.source).prepareTileset) == null ? void 0 : _d.call(_c, this));
       if (!this.root) {
         this.root = this._initializeTileHeaders(metadata.tileset, null);
       }
@@ -3207,6 +3325,36 @@ function preserveTransformedSpatialReference(current, next) {
   return (current == null ? void 0 : current.status) === "transformed" && current.sourceCrs === next.sourceCrs && current.targetCrs === next.targetCrs && current.targetHeightReference === next.targetHeightReference && current.outputCoordinates === next.outputCoordinates ? current : next;
 }
 
+// dist/tileset-3d/common/tileset-observability.js
+function getTileset3DTraversalSnapshot(tileset) {
+  var _a;
+  const selectedTiles = tileset.selectedTiles.slice();
+  const requestedTiles = tileset.requestedTiles.slice();
+  const emptyTiles = tileset.emptyTiles.slice();
+  const getTileIds = (tiles) => tiles.map((tile) => String(tile.id)).sort();
+  const getStatCount = (name) => {
+    const count = tileset.stats.get(name).count;
+    return typeof count === "number" && Number.isFinite(count) ? count : 0;
+  };
+  const implicitTilingSource = tileset.source;
+  const implicitTiling = (_a = implicitTilingSource.getImplicitTilingStats) == null ? void 0 : _a.call(implicitTilingSource);
+  return {
+    frameNumber: tileset.frameNumber,
+    selectedTileIds: getTileIds(selectedTiles),
+    requestedTileIds: getTileIds(requestedTiles),
+    emptyTileIds: getTileIds(emptyTiles),
+    visibleTileCount: selectedTiles.length,
+    renderableTileCount: selectedTiles.filter((tile) => tile.contentAvailable && Boolean(tile.content)).length,
+    loadingTileCount: getStatCount("Tiles Loading"),
+    loadedTileCount: getStatCount("Tiles Loaded"),
+    failedTileCount: getStatCount("Failed Tile Loads"),
+    cachedTileCount: getStatCount("Tiles In Memory"),
+    cacheBytes: tileset.gpuMemoryUsageInBytes,
+    maximumScreenSpaceError: tileset.memoryAdjustedScreenSpaceError,
+    ...implicitTiling ? { implicitTiling } : {}
+  };
+}
+
 // dist/tileset-3d/common/indexed-archive-tileset-source.js
 var IndexedArchiveTilesetSource = class {
   /** URL exposed to the tileset source that owns this archive source. */
@@ -3323,6 +3471,47 @@ function stripQueryString(url) {
 var import_core8 = require("@math.gl/core");
 var import_culling4 = require("@math.gl/culling");
 
+// dist/tileset-3d/common/tile-3d-contracts.js
+function getTile3DFeatureIdSets(payload) {
+  const featureIdSets = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    var _a, _b;
+    if (!value || typeof value !== "object") {
+      return;
+    }
+    if (visited.has(value)) {
+      return;
+    }
+    visited.add(value);
+    const record = value;
+    const declarations = (_b = (_a = record.extensions) == null ? void 0 : _a.EXT_mesh_features) == null ? void 0 : _b.featureIds;
+    if (Array.isArray(declarations)) {
+      for (const declaration of declarations) {
+        if (!declaration || typeof declaration !== "object") {
+          continue;
+        }
+        const source = declaration.texture ? "texture" : declaration.implicit ? "implicit" : declaration.attribute !== void 0 ? "attribute" : declaration.propertyTable !== void 0 ? "property-table" : "constant";
+        featureIdSets.push({
+          source,
+          attribute: declaration.attribute,
+          propertyTable: declaration.propertyTable,
+          constant: declaration.constant,
+          texture: declaration.texture,
+          implicit: declaration.implicit,
+          values: declaration.values,
+          details: declaration
+        });
+      }
+    }
+    for (const child of Object.values(record)) {
+      visit(child);
+    }
+  };
+  visit(payload);
+  return featureIdSets;
+}
+
 // dist/tileset-3d/helpers/bounding-volume.js
 var import_core6 = require("@math.gl/core");
 var import_culling3 = require("@math.gl/culling");
@@ -3332,21 +3521,25 @@ function defined(x) {
 }
 var scratchPoint = new import_core6.Vector3();
 var scratchScale = new import_core6.Vector3();
-function createBoundingVolume(boundingVolumeHeader, transform, result) {
+var identityTransform = new import_core6.Matrix4();
+function createBoundingVolume(boundingVolumeHeader, transform, result, initialTransform = transform) {
   assert(boundingVolumeHeader, "3D Tile: boundingVolume must be defined");
   if (boundingVolumeHeader.box) {
-    return createBox(boundingVolumeHeader.box, transform, result);
+    const boxTransform = boundingVolumeHeader.s2VolumeInfo ? identityTransform : transform;
+    return createBox(boundingVolumeHeader.box, boxTransform, result);
   }
   if (boundingVolumeHeader.region) {
-    return (0, import_geospatial4.makeOBBFromRegion)(boundingVolumeHeader.region);
+    const boundingVolume = (0, import_geospatial4.makeOBBFromRegion)(boundingVolumeHeader.region);
+    const regionTransform = transform.equals(initialTransform) ? identityTransform : transform.clone().multiplyRight(initialTransform.clone().invert());
+    return createBox([...boundingVolume.center, ...boundingVolume.halfAxes], regionTransform, result);
   }
   if (boundingVolumeHeader.sphere) {
     return createSphere(boundingVolumeHeader.sphere, transform, result);
   }
   throw new Error("3D Tile: boundingVolume must contain a sphere, region, or box");
 }
-function getCartographicBounds(boundingVolumeHeader, boundingVolume) {
-  if (boundingVolumeHeader.box) {
+function getCartographicBounds(boundingVolumeHeader, boundingVolume, isRegionTransformed = false) {
+  if (boundingVolumeHeader.box || boundingVolumeHeader.region && isRegionTransformed) {
     return orientedBoundingBoxToCartographicBounds(boundingVolume);
   }
   if (boundingVolumeHeader.region) {
@@ -3691,6 +3884,10 @@ var ManagedArray = class {
 var DEFAULT_PROPS4 = {
   loadSiblings: false,
   skipLevelOfDetail: false,
+  baseScreenSpaceError: 1024,
+  skipScreenSpaceErrorFactor: 16,
+  skipLevels: 1,
+  immediatelyLoadDesiredLevelOfDetail: false,
   updateTransforms: true,
   onTraversalEnd: () => {
   },
@@ -3699,6 +3896,8 @@ var DEFAULT_PROPS4 = {
 };
 var TilesetTraverser = class {
   options;
+  /** Whether loaded content has disabled skip-LOD traversal for this tileset. */
+  disableSkipLevelOfDetail = false;
   // fulfill in traverse call
   root = null;
   // tiles should be rendered
@@ -3724,6 +3923,10 @@ var TilesetTraverser = class {
   constructor(options) {
     this.options = { ...DEFAULT_PROPS4, ...options };
   }
+  /** Returns whether skip-LOD traversal is enabled and supported by the loaded content. */
+  isSkipLevelOfDetailEnabled() {
+    return this.options.skipLevelOfDetail && !this.disableSkipLevelOfDetail;
+  }
   // tiles should be visible
   traverse(root, frameState, options) {
     this.root = root;
@@ -3776,13 +3979,17 @@ var TilesetTraverser = class {
         this.selectTile(tile, frameState);
       } else if (tile.refine === TILE_REFINEMENT.REPLACE) {
         this.loadTile(tile, frameState);
-        if (stoppedRefining || this.options.skipLevelOfDetail) {
+        if (stoppedRefining || this.isSkipLevelOfDetailEnabled()) {
           this.selectTile(tile, frameState);
         }
       }
       this.touchTile(tile, frameState);
       tile._shouldRefine = shouldRefine && parentRefines;
     }
+    this.completeTraversal(frameState);
+  }
+  /** Notifies the owning tileset when traversal is complete or its debounce interval expires. */
+  completeTraversal(frameState) {
     const newTime = (/* @__PURE__ */ new Date()).getTime();
     if (this.traversalFinished(frameState) || newTime - this.lastUpdate > this.updateDebounceTime) {
       this.lastUpdate = newTime;
@@ -3797,7 +4004,8 @@ var TilesetTraverser = class {
   }
   /* eslint-disable complexity, max-statements */
   updateAndPushChildren(tile, frameState, stack, depth) {
-    const { loadSiblings, skipLevelOfDetail } = this.options;
+    const { loadSiblings } = this.options;
+    const skipLevelOfDetail = this.isSkipLevelOfDetailEnabled();
     const children = tile.children;
     children.sort(this.compareDistanceToCamera.bind(this));
     const checkRefines = tile.refine === TILE_REFINEMENT.REPLACE && tile.hasRenderContent && !skipLevelOfDetail;
@@ -3811,7 +4019,7 @@ var TilesetTraverser = class {
         }
         stack.push(child);
         hasVisibleChild = true;
-      } else if (checkRefines || loadSiblings) {
+      } else if ((checkRefines || loadSiblings) && child._inRequestVolume) {
         this.loadTile(child, frameState);
         this.touchTile(child, frameState);
       }
@@ -3998,6 +4206,13 @@ function getContentVisibility(contentVolumes, fallbackVolume, cullingVolume2, vi
   }
   return intersectingVolume ? "intersecting" : "inside";
 }
+function isNestedTilesetPayload(payload) {
+  if (!payload || typeof payload !== "object") {
+    return false;
+  }
+  const record = payload;
+  return record.shape === "tileset3d" || record.type === "tileset3d" || Boolean(record.tileset);
+}
 function defined2(x) {
   return x !== void 0 && x !== null;
 }
@@ -4025,6 +4240,8 @@ var Tile3D = class {
    * separate ensures transform updates never compound an already-scaled geometric error.
    */
   _unscaledLodMetricValue = 0;
+  /** Whether the source format defines geometric error in transform-local units. */
+  _scaleGeometricError = true;
   /** @todo math.gl is not exporting BoundingVolume base type? */
   boundingVolume = null;
   /**
@@ -4034,6 +4251,14 @@ var Tile3D = class {
   content = null;
   /** Loaded payloads in the same order as {@link contentUrls}; `content` remains the primary payload. */
   contents = [];
+  /** Ordered renderer-neutral descriptors for each source content entry. */
+  contentEntries = [];
+  /** Raw metadata references inherited by this tile and its content. */
+  metadataContext = {};
+  /** Feature-id declarations normalized from supported content extensions. */
+  featureIdSets = [];
+  /** Decoded 3D Tiles vector topology for the primary loaded content, when present. */
+  vectorContent = null;
   /**
    * Metadata entity attached to this tile in the source tileset, if present.
    *
@@ -4100,6 +4325,7 @@ var Tile3D = class {
   get viewerRequestVolume() {
     return this._viewerRequestVolume;
   }
+  /** Accumulated tile transforms from the source JSON, excluding the tileset model matrix. */
   _initialTransform = new import_core8.Matrix4();
   // Used by traverser, cannot be marked private
   _priority = 0;
@@ -4141,15 +4367,14 @@ var Tile3D = class {
     this.type = header.type;
     this.contentUrl = header.contentUrl;
     this.contentUrls = header.contentUrls || (header.contentUrl ? [header.contentUrl] : []);
-    this.metadata = header.metadata || null;
-    const contentHeaders = Array.isArray(header.content) ? header.content : [header.content];
-    this.contentMetadata = contentHeaders.filter(Boolean).map((contentHeader) => contentHeader.metadata || null);
+    this._initializeMetadata(header);
     this.childrenState = header.implicitSubtree ? "unloaded" : "ready";
     this._initializeLodMetric(header);
     this._initializeTransforms(header);
     this._updateLodMetricScale();
     this._initializeBoundingVolumes(header);
     this._initializeContent(header);
+    this._initializeContentEntries(header);
     this._initializeRenderingState(header);
     Object.seal(this);
   }
@@ -4234,12 +4459,12 @@ var Tile3D = class {
     return this._screenSpaceError;
   }
   /**
-   * Get bounding box in cartographic coordinates
+   * Get the current world-space bounding volume in cartographic coordinates.
    * @returns [min, max] each in [longitude, latitude, altitude]
    */
   get boundingBox() {
     if (!this._boundingBox) {
-      this._boundingBox = getCartographicBounds(this.header.boundingVolume, this.boundingVolume);
+      this._boundingBox = getCartographicBounds(this.header.boundingVolume, this.boundingVolume, !this.computedTransform.equals(this._initialTransform));
     }
     return this._boundingBox;
   }
@@ -4307,7 +4532,7 @@ var Tile3D = class {
   // eslint-disable-next-line complexity
   _calculateRequestPriority(allowUnloadedContent) {
     const traverser = this.tileset._traverser;
-    const { skipLevelOfDetail } = traverser.options;
+    const skipLevelOfDetail = traverser.options.skipLevelOfDetail && !traverser.disableSkipLevelOfDetail;
     const maySkipTile = this.refine === TILE_REFINEMENT.ADD || skipLevelOfDetail;
     if (maySkipTile && !this.isVisible && this._visible !== void 0) {
       return -1;
@@ -4339,6 +4564,7 @@ var Tile3D = class {
    */
   // eslint-disable-next-line max-statements, complexity
   async loadContent() {
+    var _a;
     if (this.hasEmptyContent) {
       return { loaded: false };
     }
@@ -4361,11 +4587,13 @@ var Tile3D = class {
         this.contents = loadResult.contents;
         this.content = this.contents[0] || null;
       }
+      this.vectorContent = ((_a = this.contents.find((content) => Boolean(content == null ? void 0 : content.vectorContent))) == null ? void 0 : _a.vectorContent) || null;
       if (this.tileset.options.contentLoader) {
         await this.tileset.options.contentLoader(this);
       }
       this.contentState = TILE_CONTENT_STATE.READY;
       this._onContentLoaded();
+      this._updateContentEntriesAfterLoad(loadResult);
       return loadResult;
     } catch (error) {
       this.contentState = TILE_CONTENT_STATE.FAILED;
@@ -4428,30 +4656,114 @@ var Tile3D = class {
   /**
    * Replaces a contentless implicit placeholder with its materialized subtree-root header.
    *
-   * Transform state is intentionally preserved: the placeholder already owns the composed
-   * transform, and reapplying the root transform here would double-transform bounds and geometric
-   * error. Content and raw geometric error are reinitialized from the newly available header.
+   * The placeholder transform is preserved when the subtree omits a root transform. An explicit
+   * subtree-root transform replaces it and is recomposed against the runtime parent. Content,
+   * metadata, bounds, and raw geometric error are reinitialized from the available header.
    *
    * @param materializedHeader - Available root header produced from one subtree resource.
    */
   applyImplicitSubtreeHeader(materializedHeader) {
     const existingTransform = this.header.transform;
     const existingTransformMatrix = this.header.transformMatrix;
+    const hasMaterializedTransform = materializedHeader.transform !== void 0;
     this.header = {
       ...this.header,
       ...materializedHeader,
-      transform: existingTransform,
-      transformMatrix: existingTransformMatrix,
+      transform: hasMaterializedTransform ? materializedHeader.transform : existingTransform,
+      transformMatrix: hasMaterializedTransform ? materializedHeader.transformMatrix : existingTransformMatrix,
       implicitSubtree: void 0
     };
+    if (hasMaterializedTransform) {
+      this._initializeTransforms(this.header);
+    }
     this.refine = this._getRefine(materializedHeader.refine);
     this.type = materializedHeader.type;
     this.contentUrl = materializedHeader.contentUrl;
     this.contentUrls = materializedHeader.contentUrls || (materializedHeader.contentUrl ? [materializedHeader.contentUrl] : []);
+    this._initializeMetadata(this.header);
     this._initializeLodMetric(materializedHeader);
     this._updateLodMetricScale();
     this._initializeBoundingVolumes(this.header);
+    this._boundingBox = void 0;
     this._initializeContent(this.header);
+    this._initializeContentEntries(this.header);
+  }
+  /** Refreshes tile and content metadata from a source or materialized tile header. */
+  _initializeMetadata(header) {
+    var _a;
+    this.metadata = header.metadata || null;
+    const contentHeaders = Array.isArray(header.content) ? header.content : [header.content];
+    this.contentMetadata = contentHeaders.filter(Boolean).map((contentHeader) => contentHeader.metadata || null);
+    const firstContentHeader = contentHeaders.find(Boolean) || {};
+    const groupReference = firstContentHeader.group;
+    const group = typeof groupReference === "number" ? ((_a = this.tileset.groups) == null ? void 0 : _a[groupReference]) || null : groupReference || null;
+    const metadataContext = {
+      tileset: this.tileset.metadata || null,
+      group,
+      tile: this.metadata,
+      content: this.contentMetadata[0] || null,
+      subtree: header.implicitMetadata || null
+    };
+    if (this.tileset.groups) {
+      metadataContext.groups = this.tileset.groups;
+    }
+    this.metadataContext = metadataContext;
+  }
+  /** Updates payload and renderability while retaining immutable metadata descriptors. */
+  _updateContentEntriesAfterLoad(loadResult) {
+    if (loadResult.contentEntries) {
+      this.contentEntries = loadResult.contentEntries.map((entry, index) => {
+        var _a;
+        return {
+          ...entry,
+          index,
+          boundingVolume: entry.boundingVolume || this._contentBoundingVolumes[index] || this.boundingVolume,
+          payload: entry.payload ?? this.contents[index] ?? null,
+          featureIds: ((_a = entry.featureIds) == null ? void 0 : _a.length) ? entry.featureIds : getTile3DFeatureIdSets(entry.payload ?? this.contents[index]),
+          renderable: Boolean(entry.renderable !== false && (entry.payload ?? this.contents[index]) && !isNestedTilesetPayload(entry.payload ?? this.contents[index]))
+        };
+      });
+      this.featureIdSets = this.contentEntries.flatMap((entry) => entry.featureIds);
+      return;
+    }
+    this.contentEntries = this.contentEntries.map((entry, index) => ({
+      ...entry,
+      payload: this.contents[index] ?? null,
+      featureIds: getTile3DFeatureIdSets(this.contents[index]),
+      renderable: Boolean(this.contents[index]) && !isNestedTilesetPayload(this.contents[index])
+    }));
+    this.featureIdSets = this.contentEntries.flatMap((entry) => entry.featureIds);
+  }
+  /** Returns one ordered content descriptor, or null when the index is out of range. */
+  getContentEntry(index) {
+    return this.contentEntries[index] || null;
+  }
+  /** Returns whether an ordered content entry currently has renderable payload. */
+  isContentRenderable(index) {
+    var _a;
+    return Boolean((_a = this.contentEntries[index]) == null ? void 0 : _a.renderable);
+  }
+  /** Initializes additive renderer-neutral descriptors from a normalized tile header. */
+  _initializeContentEntries(tileHeader) {
+    const headers = Array.isArray(tileHeader.content) ? tileHeader.content : tileHeader.content ? [tileHeader.content] : [];
+    this.contentEntries = headers.map((contentHeader, index) => {
+      const normalizedContentHeader = contentHeader || {};
+      return {
+        index,
+        uri: this.contentUrls[index] || normalizedContentHeader.uri || normalizedContentHeader.url,
+        group: normalizedContentHeader.group,
+        type: normalizedContentHeader.type,
+        payload: null,
+        metadata: normalizedContentHeader.metadata || null,
+        boundingVolume: this._contentBoundingVolumes[index] || this.boundingVolume,
+        featureIds: this._getFeatureIdSets(normalizedContentHeader),
+        renderable: false
+      };
+    });
+  }
+  /** Extracts renderer-neutral feature-id declarations without decoding property values. */
+  _getFeatureIdSets(contentHeader) {
+    return getTile3DFeatureIdSets(contentHeader);
   }
   // Unloads the tile's content.
   unloadContent() {
@@ -4462,6 +4774,13 @@ var Tile3D = class {
     }
     this.contents = [];
     this.content = null;
+    this.vectorContent = null;
+    this.contentEntries = this.contentEntries.map((entry) => ({
+      ...entry,
+      payload: null,
+      renderable: false
+    }));
+    this.featureIdSets = this.contentEntries.flatMap((entry) => entry.featureIds);
     if (this.header.content && this.header.content.destroy) {
       this.header.content.destroy();
     }
@@ -4523,9 +4842,11 @@ var Tile3D = class {
       return;
     }
     this._foveatedFactor = calculateFoveatedFactor(this.boundingVolume, frameState.camera);
+    const traverser = this.tileset._traverser;
+    const skipLevelOfDetail = traverser.options.skipLevelOfDetail && !traverser.disableSkipLevelOfDetail;
     const deferralEligible = isFoveatedRequestDeferred({
       refinement: this.refine,
-      skipLevelOfDetail: this.tileset._traverser.options.skipLevelOfDetail,
+      skipLevelOfDetail,
       foveatedScreenSpaceError: options.foveatedScreenSpaceError,
       foveatedConeSize: options.foveatedConeSize,
       minimumScreenSpaceErrorRelaxation: options.foveatedMinimumScreenSpaceErrorRelaxation,
@@ -4556,8 +4877,9 @@ var Tile3D = class {
    * @param frameState Current camera, culling, and optional clipping-plane state.
    * @returns The content visibility classification.
    */
-  contentVisibility(frameState) {
-    return getContentVisibility(this._contentBoundingVolumes, this.boundingVolume, frameState.cullingVolume, this._visibilityPlaneMask, frameState.clippingPlanes);
+  contentVisibility(frameState, contentIndex) {
+    const contentVolumes = contentIndex === void 0 ? this._contentBoundingVolumes : this._contentBoundingVolumes[contentIndex] ? [this._contentBoundingVolumes[contentIndex]] : [];
+    return getContentVisibility(contentVolumes, this.boundingVolume, frameState.cullingVolume, this._visibilityPlaneMask, frameState.clippingPlanes);
   }
   /**
    * Computes the (potentially approximate) distance from the closest point of the tile's bounding volume to the camera.
@@ -4604,6 +4926,8 @@ var Tile3D = class {
   // INTERNAL METHODS
   /** Initializes the tile's LOD metric from its header or its nearest available ancestor. */
   _initializeLodMetric(header) {
+    var _a;
+    this._scaleGeometricError = typeof header._scaleGeometricError === "boolean" ? header._scaleGeometricError : ((_a = this.parent) == null ? void 0 : _a._scaleGeometricError) ?? true;
     if ("lodMetricType" in header) {
       this.lodMetricType = header.lodMetricType;
     } else {
@@ -4639,7 +4963,7 @@ var Tile3D = class {
    * I3S `maxScreenThreshold` is already a screen-space metric and must not be transform-scaled.
    */
   _updateLodMetricScale() {
-    if (this.lodMetricType !== LOD_METRIC_TYPE.GEOMETRIC_ERROR) {
+    if (this.lodMetricType !== LOD_METRIC_TYPE.GEOMETRIC_ERROR || !this._scaleGeometricError) {
       this.lodMetricValue = this._unscaledLodMetricValue;
       return;
     }
@@ -4719,16 +5043,17 @@ var Tile3D = class {
     }
   }
   _updateBoundingVolume(header) {
-    this.boundingVolume = createBoundingVolume(header.boundingVolume, this.computedTransform, this.boundingVolume);
+    this._boundingBox = void 0;
+    this.boundingVolume = createBoundingVolume(header.boundingVolume, this.computedTransform, this.boundingVolume, this._initialTransform);
     if (header.viewerRequestVolume) {
-      this._viewerRequestVolume = createBoundingVolume(header.viewerRequestVolume, this.computedTransform, this._viewerRequestVolume);
+      this._viewerRequestVolume = createBoundingVolume(header.viewerRequestVolume, this.computedTransform, this._viewerRequestVolume, this._initialTransform);
     }
     const content = header.content;
     if (content) {
       this._contentBoundingVolumeHeaders = Array.isArray(content) ? content : [content];
     }
     const contentHeaders = content ? Array.isArray(content) ? content : [content] : this._contentBoundingVolumeHeaders;
-    this._contentBoundingVolumes = contentHeaders.length ? contentHeaders.map((headerEntry) => (headerEntry == null ? void 0 : headerEntry.boundingVolume) ? createBoundingVolume(headerEntry.boundingVolume, this.computedTransform) : this.boundingVolume) : [this.boundingVolume];
+    this._contentBoundingVolumes = contentHeaders.length ? contentHeaders.map((headerEntry) => (headerEntry == null ? void 0 : headerEntry.boundingVolume) ? createBoundingVolume(headerEntry.boundingVolume, this.computedTransform, void 0, this._initialTransform) : this.boundingVolume) : [this.boundingVolume];
     this._contentBoundingVolume = this._contentBoundingVolumes[0] || null;
   }
   /**
@@ -4748,8 +5073,8 @@ var Tile3D = class {
 };
 
 // dist/tileset-3d/format-3d-tiles/tiles-3d-source.js
-var import_geospatial7 = require("@math.gl/geospatial");
-var import_core10 = require("@math.gl/core");
+var import_geospatial10 = require("@math.gl/geospatial");
+var import_core12 = require("@math.gl/core");
 
 // dist/tileset-3d/format-3d-tiles/tileset-3d-traverser.js
 var Tileset3DTraverser = class extends TilesetTraverser {
@@ -4770,14 +5095,201 @@ var Tileset3DTraverser = class extends TilesetTraverser {
     }
     return true;
   }
+  /**
+   * Runs normal replacement traversal or the dedicated skip-LOD traversal selected by options.
+   *
+   * @param root - Root of the runtime subtree to traverse.
+   * @param frameState - Current culling and LOD state.
+   */
+  executeTraversal(root, frameState) {
+    if (!this.isSkipLevelOfDetailEnabled()) {
+      super.executeTraversal(root, frameState);
+      return;
+    }
+    this.executeSkipTraversal(root, frameState);
+  }
+  /**
+   * Traverses visible replacement branches without requesting skipped intermediate content.
+   *
+   * Base-traversal tiles establish coarse coverage. Below that base, only final desired tiles and
+   * tiles that cross the configured depth/SSE thresholds are requested. Already available
+   * ancestors remain selectable while those requests stream in.
+   *
+   * @param root - Root of the runtime subtree to traverse.
+   * @param frameState - Current culling and LOD state.
+   */
+  executeSkipTraversal(root, frameState) {
+    const stack = [root];
+    root._selectionDepth = root.parent ? root.parent._selectionDepth : 1;
+    while (stack.length > 0) {
+      const tile = stack.pop();
+      const parentRefines = !tile.parent || tile.parent._shouldRefine;
+      const shouldRefine = this.canTraverse(tile, frameState) && this.updateAndPushSkipChildren(tile, frameState, stack) && parentRefines;
+      const stoppedRefining = !shouldRefine && parentRefines;
+      if (!tile.hasRenderContent) {
+        this.emptyTiles[tile.id] = tile;
+        this.loadTile(tile, frameState);
+        if (stoppedRefining) {
+          this.selectDesiredTile(tile, frameState);
+        }
+      } else if (tile.refine === TILE_REFINEMENT.ADD) {
+        this.loadTile(tile, frameState);
+        this.selectDesiredTile(tile, frameState);
+      } else if (tile.refine === TILE_REFINEMENT.REPLACE) {
+        if (this.isInBaseTraversal(tile, frameState)) {
+          this.loadTile(tile, frameState);
+          if (stoppedRefining) {
+            this.selectDesiredTile(tile, frameState);
+          }
+        } else if (stoppedRefining) {
+          this.loadTile(tile, frameState);
+          this.selectDesiredTile(tile, frameState);
+        } else if (this.hasReachedSkippingThreshold(tile, frameState)) {
+          this.loadTile(tile, frameState);
+        }
+      }
+      this.touchTile(tile, frameState);
+      tile._shouldRefine = shouldRefine;
+    }
+    this.completeTraversal(frameState);
+  }
+  /**
+   * Updates and pushes visible children for skip traversal without requiring sibling readiness.
+   *
+   * @param tile - Parent whose children are considered.
+   * @param frameState - Current culling and LOD state.
+   * @param stack - Depth-first traversal stack.
+   * @returns `true` when at least one visible child continues refinement.
+   */
+  updateAndPushSkipChildren(tile, frameState, stack) {
+    this.updateChildTiles(tile, frameState);
+    tile.children.sort(this.compareDistanceToCamera.bind(this));
+    let hasVisibleChild = false;
+    for (const child of tile.children) {
+      child._selectionDepth = tile.hasRenderContent ? tile._selectionDepth + 1 : tile._selectionDepth;
+      if (child.isVisibleAndInRequestVolume) {
+        stack.push(child);
+        hasVisibleChild = true;
+      } else if (this.options.loadSiblings) {
+        this.loadTile(child, frameState);
+        this.touchTile(child, frameState);
+      }
+    }
+    return hasVisibleChild;
+  }
+  /**
+   * Determines whether a tile belongs to the coarse non-skipping portion of the traversal.
+   *
+   * @param tile - Tile considered for loading.
+   * @param frameState - Current traversal frame.
+   * @returns `true` when the tile should always be requested for fallback coverage.
+   */
+  isInBaseTraversal(tile, frameState) {
+    if (this.options.immediatelyLoadDesiredLevelOfDetail) {
+      return false;
+    }
+    if (!this.findNearestRequestedOrLoadedAncestor(tile, frameState)) {
+      return true;
+    }
+    const configuredBaseScreenSpaceError = Number.isFinite(this.options.baseScreenSpaceError) ? Math.max(this.options.baseScreenSpaceError, 0) : 1024;
+    const baseScreenSpaceError = Math.max(configuredBaseScreenSpaceError, tile.tileset.memoryAdjustedScreenSpaceError);
+    if (tile._screenSpaceError === 0 && tile.parent) {
+      return tile.parent._screenSpaceError > baseScreenSpaceError;
+    }
+    return tile._screenSpaceError > baseScreenSpaceError;
+  }
+  /**
+   * Determines whether a skipped branch has crossed its configured request threshold.
+   *
+   * @param tile - Tile considered for loading.
+   * @param frameState - Current traversal frame.
+   * @returns `true` when the tile must be requested instead of skipped.
+   */
+  hasReachedSkippingThreshold(tile, frameState) {
+    if (this.options.immediatelyLoadDesiredLevelOfDetail) {
+      return false;
+    }
+    const progressiveResolutionLeaf = tile._priorityProgressiveResolution && tile._screenSpaceErrorProgressiveResolution <= tile.tileset.memoryAdjustedScreenSpaceError && Boolean(tile.parent && tile.parent._screenSpaceErrorProgressiveResolution > tile.tileset.memoryAdjustedScreenSpaceError);
+    if (progressiveResolutionLeaf) {
+      return true;
+    }
+    const ancestor = this.findNearestRequestedOrLoadedAncestor(tile, frameState);
+    if (!ancestor) {
+      return false;
+    }
+    const skipScreenSpaceErrorFactor = Number.isFinite(this.options.skipScreenSpaceErrorFactor) && this.options.skipScreenSpaceErrorFactor > 0 ? this.options.skipScreenSpaceErrorFactor : 16;
+    const skipLevels = Number.isFinite(this.options.skipLevels) ? Math.max(Math.floor(this.options.skipLevels), 0) : 1;
+    return tile._screenSpaceError < ancestor._screenSpaceError / skipScreenSpaceErrorFactor && tile.depth > ancestor.depth + skipLevels;
+  }
+  /**
+   * Finds the nearest ancestor whose render content is loaded, loading, or requested this frame.
+   *
+   * @param tile - Descendant whose request threshold needs an anchor.
+   * @param frameState - Current traversal frame.
+   * @returns The nearest request anchor, or `null` when none exists.
+   */
+  findNearestRequestedOrLoadedAncestor(tile, frameState) {
+    let ancestor = tile.parent;
+    while (ancestor) {
+      const contentIsUsableAnchor = ancestor.hasRenderContent && !ancestor.contentFailed && (!ancestor.hasUnloadedContent || ancestor._requestedFrame === frameState.frameNumber);
+      if (contentIsUsableAnchor) {
+        return ancestor;
+      }
+      ancestor = ancestor.parent;
+    }
+    return null;
+  }
+  /**
+   * Selects the desired tile, its nearest ready ancestor, or nearby ready descendants.
+   *
+   * @param tile - Tile that ended the desired refinement branch.
+   * @param frameState - Current culling state.
+   */
+  selectDesiredTile(tile, frameState) {
+    let fallbackTile = tile;
+    while (fallbackTile) {
+      if (this.shouldSelectTile(fallbackTile, frameState)) {
+        this.selectTile(fallbackTile, frameState);
+        return;
+      }
+      fallbackTile = fallbackTile.parent;
+    }
+    this.selectLoadedDescendants(tile, frameState);
+  }
+  /**
+   * Selects ready descendants near an unavailable desired tile to reduce temporary empty regions.
+   *
+   * @param root - Unavailable tile whose descendants are searched.
+   * @param frameState - Current culling state.
+   */
+  selectLoadedDescendants(root, frameState) {
+    const stack = [{ tile: root, depth: 0 }];
+    while (stack.length > 0) {
+      const { tile, depth } = stack.pop();
+      for (const child of tile.children) {
+        this.updateTile(child, frameState);
+        if (!child.isVisibleAndInRequestVolume) {
+          continue;
+        }
+        if (child.contentAvailable) {
+          this.selectTile(child, frameState);
+          this.touchTile(child, frameState);
+        } else if (depth < 1) {
+          stack.push({ tile: child, depth: depth + 1 });
+        }
+      }
+    }
+  }
   compareDistanceToCamera(a, b) {
     return b._distanceToCamera === 0 && a._distanceToCamera === 0 ? b._centerZDepth - a._centerZDepth : b._distanceToCamera - a._distanceToCamera;
   }
   /**
-   * Starts an implicit subtree request only after culling, request-volume, and SSE eligibility.
+   * Starts an implicit subtree request after culling and request-volume eligibility.
    *
-   * The current parent remains the traversal boundary while metadata is loading, which preserves
-   * REPLACE coverage and ADD accumulation. Request scheduling reads the tile's existing
+   * The first subtree of an implicit hierarchy materializes independently of SSE because its
+   * placeholder has no render content. Deeper subtree boundaries remain SSE-gated. The current
+   * parent remains the traversal boundary while metadata is loading, which preserves REPLACE
+   * coverage and ADD accumulation. Request scheduling reads the tile's existing
    * progressive-resolution and foveated metrics, so subtree metadata follows the same priority
    * policy as render content. A completion notification lets the owning tileset publish the newly
    * materialized traversal result on the next update.
@@ -4786,7 +5298,9 @@ var Tileset3DTraverser = class extends TilesetTraverser {
    * @param frameState - Current culling and LOD state.
    */
   updateChildTiles(tile, frameState) {
-    if (tile.hasUnloadedChildren && tile.isVisibleAndInRequestVolume && this.shouldRefine(tile, frameState)) {
+    var _a;
+    const isImplicitHierarchyRoot = ((_a = tile.header.implicitSubtree) == null ? void 0 : _a.coordinates.level) === 0;
+    if (tile.hasUnloadedChildren && tile.isVisibleAndInRequestVolume && (isImplicitHierarchyRoot || this.shouldRefine(tile, frameState))) {
       const requestKey = `${frameState.viewport.id}:${tile.id}`;
       if (!this.pendingImplicitSubtrees.has(requestKey)) {
         this.pendingImplicitSubtrees.set(requestKey, frameState.frameNumber);
@@ -4977,7 +5491,7 @@ function getI3SSpatialReference(layer) {
   const verticalUnitScale = getI3SVerticalUnitScale(verticalUnit, layer.ZFactor);
   const heightReference = heightModel === "ellipsoidal" ? "ellipsoidal" : heightModel === "gravity_related_height" ? "orthometric" : "unknown";
   const sourceIdentifier = getCrsIdentifier(spatialReference);
-  const coordinateFrame = sourceIdentifier === void 0 ? getWktCoordinateFrame(spatialReference == null ? void 0 : spatialReference.wkt) : getIdentifierCoordinateFrame(sourceIdentifier);
+  const coordinateFrame = sourceIdentifier === void 0 ? sourceCrs ? getSpatialCoordinateFrame(sourceCrs) : "unknown" : getSpatialCoordinateFrame(`EPSG:${sourceIdentifier}`);
   const units = getI3SCoordinateUnits(coordinateFrame, verticalUnit, layer.ZFactor);
   const warnings = [];
   const elevationMode = getI3SElevationMode((_e = layer.elevationInfo) == null ? void 0 : _e.mode);
@@ -5035,6 +5549,10 @@ function getI3SElevationMode(mode) {
 }
 function get3DTilesSpatialReference(tileset) {
   var _a, _b;
+  const draftSpatialReference = getDraft3DTilesSpatialReference(tileset);
+  if (draftSpatialReference) {
+    return draftSpatialReference;
+  }
   const geocentricCrs = getTilesetSemanticValue(tileset, "TILESET_CRS_GEOCENTRIC");
   const coordinateEpoch = getTilesetSemanticValue(tileset, "TILESET_CRS_COORDINATE_EPOCH");
   const warnings = [];
@@ -5072,6 +5590,87 @@ function get3DTilesSpatialReference(tileset) {
     warnings
   });
 }
+function getDraft3DTilesSpatialReference(tileset) {
+  var _a, _b, _c;
+  const extension = (_a = tileset.extensions) == null ? void 0 : _a.EXT_geospatial_crs;
+  if (!extension) {
+    return void 0;
+  }
+  const warnings = [];
+  let sourceCrs;
+  let verticalCrs;
+  let epoch;
+  let representation;
+  if (extension.format === "wkid") {
+    const wkidExtension = (_b = extension.extensions) == null ? void 0 : _b.EXT_geospatial_crs_wkid;
+    if (typeof (wkidExtension == null ? void 0 : wkidExtension.authority) === "string" && Number.isInteger(wkidExtension.wkid)) {
+      sourceCrs = `${wkidExtension.authority}:${wkidExtension.wkid}`;
+      representation = "identifier";
+      if (Number.isInteger(wkidExtension.vcsWkid)) {
+        verticalCrs = `${wkidExtension.authority}:${wkidExtension.vcsWkid}`;
+      }
+      epoch = parseCoordinateEpoch(wkidExtension.epoch);
+      if (wkidExtension.epoch !== void 0 && epoch === void 0) {
+        warnings.push("EXT_geospatial_crs_wkid epoch is not a finite decimal year");
+      }
+    } else {
+      warnings.push("EXT_geospatial_crs_wkid requires string authority and integer wkid");
+    }
+  } else if (extension.format === "wkt2") {
+    const wktExtension = (_c = extension.extensions) == null ? void 0 : _c.EXT_geospatial_crs_wkt2;
+    if (typeof (wktExtension == null ? void 0 : wktExtension.wkt2) === "string" && wktExtension.wkt2.trim()) {
+      sourceCrs = wktExtension.wkt2;
+      representation = "wkt";
+    } else {
+      warnings.push("EXT_geospatial_crs_wkt2 requires a nonempty wkt2 string");
+    }
+  } else {
+    warnings.push(`Unsupported EXT_geospatial_crs format ${String(extension.format)}`);
+  }
+  const coordinateFrame = representation === "wkt" ? getSpatialCoordinateFrame(sourceCrs) : getKnownCrsIdentifierCoordinateFrame(sourceCrs) || "unknown";
+  const verticalSemantics = getDraftVerticalCrsSemantics(verticalCrs);
+  if (verticalCrs && !verticalSemantics) {
+    warnings.push(`Unsupported vertical CRS ${String(verticalCrs)}; vertical unit and height reference are unknown`);
+  }
+  const verticalUnit = verticalCrs ? verticalSemantics == null ? void 0 : verticalSemantics.unit : "meter";
+  return createTilesetSpatialReference({
+    sourceCrs,
+    sourceCrsState: sourceCrs ? "explicit" : "unknown",
+    sourceCrsRepresentation: representation,
+    verticalCrs,
+    coordinateEpoch: epoch,
+    units: coordinateFrame === "geocentric" ? ["meter", "meter", "meter"] : coordinateFrame === "geographic" && verticalUnit ? ["degree", "degree", verticalUnit] : void 0,
+    verticalUnitScale: verticalCrs ? (verticalSemantics == null ? void 0 : verticalSemantics.verticalUnitScale) ?? Number.NaN : 1,
+    heightReference: verticalCrs ? (verticalSemantics == null ? void 0 : verticalSemantics.heightReference) ?? "unknown" : sourceCrs ? "ellipsoidal" : "unknown",
+    coordinateFrame,
+    axisOrder: sourceCrs ? "xyz" : "unknown",
+    provenance: "metadata",
+    warnings
+  });
+}
+function getDraftVerticalCrsSemantics(verticalCrs) {
+  if (typeof verticalCrs !== "string") {
+    return void 0;
+  }
+  const epsgMatch = /^EPSG:(\d+)$/i.exec(verticalCrs);
+  if (!epsgMatch) {
+    return void 0;
+  }
+  switch (Number(epsgMatch[1])) {
+    case 5702:
+    // NGVD29 height (ftUS)
+    case 6360:
+      return {
+        unit: "us-foot",
+        verticalUnitScale: 1200 / 3937,
+        heightReference: "orthometric"
+      };
+    case 5703:
+      return { unit: "meter", verticalUnitScale: 1, heightReference: "orthometric" };
+    default:
+      return void 0;
+  }
+}
 function parseCoordinateEpoch(value) {
   if (typeof value !== "string" && typeof value !== "number") {
     return void 0;
@@ -5096,71 +5695,493 @@ function getI3SVerticalCrsDefinition(spatialReference) {
 function getCrsIdentifier(spatialReference) {
   return (spatialReference == null ? void 0 : spatialReference.latestWkid) ?? (spatialReference == null ? void 0 : spatialReference.wkid);
 }
-function getIdentifierCoordinateFrame(identifier) {
-  if (identifier === 4978) {
-    return "geocentric";
+function getTilesetSemanticValue(tileset, semantic) {
+  var _a, _b, _c, _d;
+  const classIdentifier = (_a = tileset.metadata) == null ? void 0 : _a.class;
+  if (!classIdentifier) {
+    return void 0;
   }
-  if (identifier === 4326 || identifier === 4490 || identifier === 4979) {
-    return "geographic";
+  const classDefinition = (_c = (_b = tileset.schema) == null ? void 0 : _b.classes) == null ? void 0 : _c[classIdentifier];
+  const propertyDefinitions = classDefinition == null ? void 0 : classDefinition.properties;
+  const propertyValues = (_d = tileset.metadata) == null ? void 0 : _d.properties;
+  for (const [propertyIdentifier, propertyDefinition] of Object.entries(propertyDefinitions || {})) {
+    if (propertyDefinition.semantic === semantic) {
+      return propertyValues == null ? void 0 : propertyValues[propertyIdentifier];
+    }
   }
-  return "projected";
+  return void 0;
 }
-function getWktCoordinateFrame(wkt) {
-  var _a;
-  if (!wkt) {
-    return "unknown";
-  }
-  const normalizedWkt = wkt.trim().toUpperCase();
-  const rootKeyword = (_a = normalizedWkt.match(/^([A-Z][A-Z0-9_]*)\s*[\[(]/)) == null ? void 0 : _a[1];
-  if (rootKeyword === "GEOCCS") {
-    return "geocentric";
-  }
-  if (rootKeyword === "GEOGCS" || rootKeyword === "GEOGRAPHICCRS" || rootKeyword === "GEOGRAPHIC2DCRS" || rootKeyword === "GEOGRAPHIC3DCRS") {
-    return "geographic";
+
+// dist/spatial/spatial-coordinate-transformer.js
+var import_core10 = require("@math.gl/core");
+var import_geospatial7 = require("@math.gl/geospatial");
+var import_proj42 = require("@math.gl/proj4");
+
+// dist/spatial/spatial-resource-registry.js
+var import_geoid = require("@math.gl/geoid");
+var import_proj4 = require("@math.gl/proj4");
+var geoidModels = /* @__PURE__ */ new Map();
+function registerSpatialCrs(name, definition) {
+  validateResourceName(name, "CRS");
+  import_proj4.Proj4Projection.defineProjectionAliases({ [name]: definition });
+}
+function registerSpatialDatumGrid(name, data) {
+  validateResourceName(name, "datum grid");
+  import_proj4.Proj4Projection.registerDatumGrid(name, data);
+}
+function registerGeoidModel(name, geoid) {
+  validateResourceName(name, "geoid model");
+  geoidModels.set(name, geoid);
+}
+function registerGeoidModelFromPgm(name, data, options = {}) {
+  const geoid = (0, import_geoid.parsePGM)(data, options);
+  registerGeoidModel(name, geoid);
+  return geoid;
+}
+function getGeoidModel(name) {
+  return geoidModels.get(name);
+}
+function validateResourceName(name, resourceType) {
+  if (!name.trim()) {
+    throw new Error(`${resourceType} name must not be empty`);
   }
-  if (rootKeyword === "PROJCS" || rootKeyword === "PROJCRS" || rootKeyword === "PROJECTEDCRS") {
-    return "projected";
+}
+
+// dist/spatial/spatial-coordinate-transformer.js
+var SpatialCoordinateTransformer = class {
+  /** Normalized spatial metadata describing this transformation. */
+  spatialReference;
+  /** Projection from the source CRS directly to the requested horizontal target CRS. */
+  horizontalProjection;
+  /** Projection from the source CRS to geographic longitude, latitude, and ellipsoidal height. */
+  geographicProjection;
+  /** Projection from adjusted geographic coordinates to the requested output CRS. */
+  heightOutputProjection;
+  /** Whether source coordinates use the WGS84 geocentric frame handled by math.gl. */
+  sourceIsGeocentric;
+  /** Whether output coordinates use the WGS84 geocentric frame handled by math.gl. */
+  outputIsGeocentric;
+  /** Whether source coordinates already use conventional WGS84 longitude/latitude order. */
+  sourceIsGeographic;
+  /** Whether output coordinates use conventional WGS84 longitude/latitude order. */
+  outputIsGeographic;
+  /** Geoid model used to convert between ellipsoidal and orthometric heights. */
+  geoid;
+  /**
+   * Creates a coordinate transformer.
+   *
+   * @param spatialReference - Format-discovered and option-normalized spatial metadata.
+   * @param options - Application options containing an optional geoid model.
+   */
+  constructor(spatialReference, options = {}) {
+    this.spatialReference = spatialReference;
+    validateTransformRequest(spatialReference);
+    const outputCrs = spatialReference.targetCrs || spatialReference.sourceCrs;
+    this.sourceIsGeocentric = isWgs84Geocentric(spatialReference.sourceCrs);
+    this.outputIsGeocentric = isWgs84Geocentric(outputCrs);
+    this.sourceIsGeographic = isWgs84Geographic(spatialReference.sourceCrs);
+    this.outputIsGeographic = isWgs84Geographic(outputCrs);
+    if (spatialReference.sourceCrs && spatialReference.targetCrs && !this.sourceIsGeocentric && !this.outputIsGeocentric) {
+      this.horizontalProjection = new import_proj42.Proj4Projection({
+        from: getHorizontalProj4Definition(spatialReference.sourceCrs),
+        to: getHorizontalProj4Definition(spatialReference.targetCrs),
+        enforceAxis: false
+      });
+    }
+    if (requiresHeightTransformation(spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
+      if (!this.sourceIsGeographic && !this.sourceIsGeocentric) {
+        this.geographicProjection = new import_proj42.Proj4Projection({
+          from: getHorizontalProj4Definition(spatialReference.sourceCrs),
+          to: WGS84_GEOGRAPHIC_CRS,
+          enforceAxis: false
+        });
+      }
+      if (!this.outputIsGeographic && !this.outputIsGeocentric) {
+        this.heightOutputProjection = new import_proj42.Proj4Projection({
+          from: WGS84_GEOGRAPHIC_CRS,
+          to: getHorizontalProj4Definition(outputCrs),
+          enforceAxis: false
+        });
+      }
+    }
+    if (requiresHeightTransformation(spatialReference)) {
+      this.geoid = resolveGeoid(options.geoidModel);
+      if (!this.geoid) {
+        const modelName = typeof options.geoidModel === "string" ? ` "${options.geoidModel}"` : "";
+        throw new Error(`Height conversion requires a registered geoid model${modelName}; call registerGeoidModel() or pass a parsed Geoid instance`);
+      }
+    }
   }
-  if (rootKeyword === "GEODCRS" || rootKeyword === "GEODETICCRS") {
-    if (/\bCS\s*[\[(]\s*CARTESIAN\s*,\s*3\b/.test(normalizedWkt)) {
-      return "geocentric";
+  /**
+   * Transforms one `[x, y, z?]` coordinate while retaining additional components.
+   *
+   * @param coordinate - Source coordinate in the format adapter's normalized `x/y/z` order.
+   * @returns A new transformed coordinate array.
+   */
+  transformPosition(coordinate) {
+    if (coordinate.length < 2) {
+      throw new Error("A spatial coordinate must contain at least x and y components");
     }
-    if (/\bCS\s*[\[(]\s*ELLIPSOIDAL\s*,\s*[23]\b/.test(normalizedWkt)) {
-      return "geographic";
+    const result = [...coordinate];
+    if (requiresHeightTransformation(this.spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
+      if (result.length < 3 || !Number.isFinite(result[2])) {
+        throw new Error("Three-dimensional CRS conversion requires a finite z coordinate");
+      }
+      const geographic = this.toGeographic(result);
+      if (requiresHeightTransformation(this.spatialReference)) {
+        const geoidUndulation = this.geoid.getHeight(geographic[1], geographic[0]);
+        geographic[2] = transformHeight(geographic[2], geoidUndulation, this.spatialReference.heightReference, this.spatialReference.targetHeightReference);
+      }
+      const projected = this.fromGeographic(geographic);
+      result.splice(0, projected.length, ...projected);
+      return result;
     }
+    if (this.horizontalProjection) {
+      const projected = this.horizontalProjection.project(result.slice(0, 3));
+      result.splice(0, projected.length, ...projected);
+    }
+    return result;
   }
-  return "unknown";
+  /** Transform a packed sequence of xyz positions, preserving the input array type only when safe. */
+  transformPositions(positions) {
+    if (positions.length % 3 !== 0) {
+      throw new Error("Packed spatial positions must contain a multiple of three components");
+    }
+    const transformedPositions = new Float64Array(positions.length);
+    for (let index = 0; index < positions.length; index += 3) {
+      const transformed = this.transformPosition([
+        Number(positions[index]),
+        Number(positions[index + 1]),
+        Number(positions[index + 2])
+      ]);
+      transformedPositions[index] = transformed[0];
+      transformedPositions[index + 1] = transformed[1];
+      transformedPositions[index + 2] = transformed[2];
+    }
+    return transformedPositions;
+  }
+  /** Transform packed xyz normals using a local finite-difference tangent approximation. */
+  transformNormals(normals, positions) {
+    if (normals.length !== positions.length || normals.length % 3 !== 0) {
+      throw new Error("Spatial normals and positions must have matching xyz component counts");
+    }
+    const transformedNormals = new Float32Array(normals.length);
+    const epsilon = 1e-5;
+    for (let index = 0; index < normals.length; index += 3) {
+      const position = [
+        Number(positions[index]),
+        Number(positions[index + 1]),
+        Number(positions[index + 2])
+      ];
+      const normal = [
+        Number(normals[index]),
+        Number(normals[index + 1]),
+        Number(normals[index + 2])
+      ];
+      const jacobian = getFiniteDifferenceJacobian(this, position, epsilon);
+      const transformedNormal = inverseTransposeMultiply(jacobian, normal);
+      const length = Math.hypot(...transformedNormal);
+      if (length > 0 && Number.isFinite(length)) {
+        transformedNormals[index] = transformedNormal[0] / length;
+        transformedNormals[index + 1] = transformedNormal[1] / length;
+        transformedNormals[index + 2] = transformedNormal[2] / length;
+      } else {
+        transformedNormals[index] = normal[0];
+        transformedNormals[index + 1] = normal[1];
+        transformedNormals[index + 2] = normal[2];
+      }
+    }
+    return transformedNormals;
+  }
+  /** Convert one source coordinate to conventional WGS84 longitude, latitude, and height. */
+  toGeographic(coordinate) {
+    if (this.sourceIsGeocentric) {
+      return Array.from(import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(new import_core10.Vector3(coordinate)));
+    }
+    if (this.sourceIsGeographic) {
+      return coordinate.slice(0, 3);
+    }
+    return this.geographicProjection.project(coordinate.slice(0, 3));
+  }
+  /** Convert one conventional WGS84 geographic coordinate to the selected output CRS. */
+  fromGeographic(coordinate) {
+    if (this.outputIsGeocentric) {
+      return Array.from(import_geospatial7.Ellipsoid.WGS84.cartographicToCartesian(new import_core10.Vector3(coordinate)));
+    }
+    if (this.outputIsGeographic) {
+      return coordinate.slice(0, 3);
+    }
+    return this.heightOutputProjection.project(coordinate.slice(0, 3));
+  }
+};
+function getFiniteDifferenceJacobian(transformer, position, epsilon) {
+  const columns = [];
+  for (let axis = 0; axis < 3; axis++) {
+    const plus = position.slice();
+    const minus = position.slice();
+    plus[axis] += epsilon;
+    minus[axis] -= epsilon;
+    const plusPosition = transformer.transformPosition(plus);
+    const minusPosition = transformer.transformPosition(minus);
+    columns.push([
+      (plusPosition[0] - minusPosition[0]) / (2 * epsilon),
+      (plusPosition[1] - minusPosition[1]) / (2 * epsilon),
+      (plusPosition[2] - minusPosition[2]) / (2 * epsilon)
+    ]);
+  }
+  return columns;
 }
-function getTilesetSemanticValue(tileset, semantic) {
-  var _a, _b, _c, _d;
-  const classIdentifier = (_a = tileset.metadata) == null ? void 0 : _a.class;
-  if (!classIdentifier) {
-    return void 0;
+function inverseTransposeMultiply(jacobianColumns, vector) {
+  const [a, b, c] = jacobianColumns;
+  const determinant = a[0] * (b[1] * c[2] - b[2] * c[1]) - b[0] * (a[1] * c[2] - a[2] * c[1]) + c[0] * (a[1] * b[2] - a[2] * b[1]);
+  if (!Number.isFinite(determinant) || Math.abs(determinant) < 1e-15) {
+    return vector;
   }
-  const classDefinition = (_c = (_b = tileset.schema) == null ? void 0 : _b.classes) == null ? void 0 : _c[classIdentifier];
-  const propertyDefinitions = classDefinition == null ? void 0 : classDefinition.properties;
-  const propertyValues = (_d = tileset.metadata) == null ? void 0 : _d.properties;
-  for (const [propertyIdentifier, propertyDefinition] of Object.entries(propertyDefinitions || {})) {
-    if (propertyDefinition.semantic === semantic) {
-      return propertyValues == null ? void 0 : propertyValues[propertyIdentifier];
+  const inverseTranspose = [
+    [b[1] * c[2] - b[2] * c[1], a[2] * c[1] - a[1] * c[2], a[1] * b[2] - a[2] * b[1]],
+    [b[2] * c[0] - b[0] * c[2], a[0] * c[2] - a[2] * c[0], a[2] * b[0] - a[0] * b[2]],
+    [b[0] * c[1] - b[1] * c[0], a[1] * c[0] - a[0] * c[1], a[0] * b[1] - a[1] * b[0]]
+  ];
+  return inverseTranspose.map((row) => (row[0] * vector[0] + row[1] * vector[1] + row[2] * vector[2]) / determinant);
+}
+function getHorizontalProj4Definition(definition) {
+  if (!definition) {
+    throw new Error("Cannot construct a projection because the CRS is unknown");
+  }
+  return (0, import_proj42.toProj4CRSDefinition)(definition, { mode: "horizontal" });
+}
+function validateTransformRequest(spatialReference) {
+  if (spatialReference.outputCoordinates === "local-enu") {
+    throw new Error("local-enu output requires a dataset-derived local origin and must be created by a tileset source");
+  }
+  if (spatialReference.outputCoordinates === "target-crs" && !spatialReference.targetCrs) {
+    throw new Error("target-crs output requires targetCrs");
+  }
+  if (!spatialReference.sourceCrs && spatialReference.status === "unresolved") {
+    throw new Error("Cannot transform coordinates because the source CRS is unknown");
+  }
+  if (requiresHeightTransformation(spatialReference) && spatialReference.heightReference === "unknown") {
+    throw new Error("Cannot convert heights because the source height reference is unknown");
+  }
+  if (spatialReference.coordinateFrame === "geocentric" && !isWgs84Geocentric(spatialReference.sourceCrs)) {
+    throw new Error("Only EPSG:4978 geocentric coordinates are supported by the current spatial transformer");
+  }
+  if (spatialReference.status === "unresolved") {
+    throw new Error("The requested spatial output cannot be resolved from the available metadata");
+  }
+}
+function isWgs84Geocentric(definition) {
+  return typeof definition === "string" && normalizeCrsIdentifier(definition) === WGS84_GEOCENTRIC_CRS;
+}
+function isWgs84Geographic(definition) {
+  if (typeof definition !== "string") {
+    return false;
+  }
+  const identifier = normalizeCrsIdentifier(definition);
+  return identifier === WGS84_GEOGRAPHIC_CRS || identifier === "EPSG:4979" || identifier === "OGC:CRS84";
+}
+function requiresHeightTransformation(spatialReference) {
+  const target = spatialReference.targetHeightReference;
+  return target !== "native" && target !== spatialReference.heightReference;
+}
+function resolveGeoid(model) {
+  return typeof model === "string" ? getGeoidModel(model) : model;
+}
+function transformHeight(height, geoidUndulation, source, target) {
+  if (source === target || target === "native") {
+    return height;
+  }
+  if (source === "orthometric" && target === "ellipsoidal") {
+    return height + geoidUndulation;
+  }
+  if (source === "ellipsoidal" && target === "orthometric") {
+    return height - geoidUndulation;
+  }
+  throw new Error(`Unsupported height conversion from ${source} to ${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;
+  coordinateTransformer;
+  geographicCoordinateTransformer;
+  /** Creates a 3D Tiles transformer for a requested target CRS. */
+  constructor(spatialReference, options = {}) {
+    this.coordinateTransformer = new SpatialCoordinateTransformer(spatialReference, options);
+    const geographicSpatialReference = {
+      ...spatialReference,
+      sourceCrs: "EPSG:4326",
+      targetCrs: spatialReference.targetCrs || spatialReference.sourceCrs,
+      coordinateFrame: "geographic",
+      axisOrder: "xy"
+    };
+    this.geographicCoordinateTransformer = new SpatialCoordinateTransformer(geographicSpatialReference, options);
+    this.spatialReference = spatialReference;
+  }
+  /** Transform packed POSITION values into the target CRS. */
+  transformPositions(positions) {
+    return this.coordinateTransformer.transformPositions(positions);
+  }
+  /** Transform packed NORMAL values using the corresponding source positions. */
+  transformNormals(normals, positions) {
+    return this.coordinateTransformer.transformNormals(normals, positions);
+  }
+  /** Rebuild a conservative target-frame volume from a source volume. */
+  transformBoundingVolume(volume, sourceTransform) {
+    const transform = sourceTransform ? new import_core11.Matrix4(Array.from(sourceTransform)) : void 0;
+    const samples = volume.region ? getRegionSamples(volume.region) : getVolumeSamples(volume).map((sample) => transform ? Array.from(transform.transformAsPoint(sample)) : sample);
+    if (!samples.length) {
+      return volume;
+    }
+    const transformed = volume.region ? samples.map((sample) => this.transformRegionSample(sample)) : samples.map((sample) => this.coordinateTransformer.transformPosition(sample));
+    return { box: createAxisAlignedBox(transformed) };
+  }
+  /** 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);
   }
-  return void 0;
+};
+function getRegionSamples(region) {
+  if (region.length < 6 || region.some((value) => !Number.isFinite(value))) {
+    return [];
+  }
+  const [west, south, east, north, minimumHeight, maximumHeight] = region;
+  const longitudeEnd = east < west ? east + Math.PI * 2 : east;
+  const longitudes = getIntervalSamples(west, longitudeEnd);
+  const latitudes = getIntervalSamples(south, north);
+  const samples = [];
+  for (const longitude of longitudes) {
+    for (const latitude of latitudes) {
+      for (const height of [minimumHeight, maximumHeight]) {
+        samples.push([longitude * 180 / Math.PI, latitude * 180 / Math.PI, height]);
+      }
+    }
+  }
+  return samples;
+}
+function getIntervalSamples(start, end) {
+  const samples = [start, (start + end) / 2, end];
+  const angularStep = Math.PI / 2;
+  const firstCriticalIndex = Math.ceil(start / angularStep);
+  const lastCriticalIndex = Math.floor(end / angularStep);
+  for (let criticalIndex = firstCriticalIndex; criticalIndex <= lastCriticalIndex; criticalIndex++) {
+    samples.push(criticalIndex * angularStep);
+  }
+  return samples;
+}
+function getVolumeSamples(volume) {
+  if (volume.box && volume.box.length >= 12) {
+    const center = volume.box.slice(0, 3);
+    const axes = [volume.box.slice(3, 6), volume.box.slice(6, 9), volume.box.slice(9, 12)];
+    const samples = [];
+    for (let firstIndex = 0; firstIndex <= 4; firstIndex++) {
+      for (let secondIndex = 0; secondIndex <= 4; secondIndex++) {
+        for (let thirdIndex = 0; thirdIndex <= 4; thirdIndex++) {
+          const first = firstIndex / 2 - 1;
+          const second = secondIndex / 2 - 1;
+          const third = thirdIndex / 2 - 1;
+          samples.push([
+            center[0] + first * axes[0][0] + second * axes[1][0] + third * axes[2][0],
+            center[1] + first * axes[0][1] + second * axes[1][1] + third * axes[2][1],
+            center[2] + first * axes[0][2] + second * axes[1][2] + third * axes[2][2]
+          ]);
+        }
+      }
+    }
+    return samples;
+  }
+  if (volume.sphere && volume.sphere.length >= 4) {
+    const [x, y, z, radius] = volume.sphere;
+    const samples = [
+      [x - radius, y, z],
+      [x + radius, y, z],
+      [x, y - radius, z],
+      [x, y + radius, z],
+      [x, y, z - radius],
+      [x, y, z + radius]
+    ];
+    for (let longitudeIndex = 0; longitudeIndex < 16; longitudeIndex++) {
+      const longitude = longitudeIndex * Math.PI * 2 / 16;
+      samples.push([x + radius * Math.cos(longitude), y + radius * Math.sin(longitude), z]);
+    }
+    return samples;
+  }
+  return [];
+}
+function createAxisAlignedBox(samples) {
+  const minimum = [Infinity, Infinity, Infinity];
+  const maximum = [-Infinity, -Infinity, -Infinity];
+  for (const sample of samples) {
+    for (let axis = 0; axis < 3; axis++) {
+      minimum[axis] = Math.min(minimum[axis], sample[axis]);
+      maximum[axis] = Math.max(maximum[axis], sample[axis]);
+    }
+  }
+  const padding = [
+    Math.max((maximum[0] - minimum[0]) * 0.01, 1e-9),
+    Math.max((maximum[1] - minimum[1]) * 0.01, 1e-9),
+    Math.max((maximum[2] - minimum[2]) * 0.01, 1e-9)
+  ];
+  const center = [
+    (minimum[0] + maximum[0]) / 2,
+    (minimum[1] + maximum[1]) / 2,
+    (minimum[2] + maximum[2]) / 2
+  ];
+  return [
+    ...center,
+    (maximum[0] - minimum[0]) / 2 + padding[0],
+    0,
+    0,
+    0,
+    (maximum[1] - minimum[1]) / 2 + padding[1],
+    0,
+    0,
+    0,
+    (maximum[2] - minimum[2]) / 2 + padding[2]
+  ];
+}
+
+// dist/tileset-3d/format-3d-tiles/implicit-tiling.js
+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");
+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" });
+  return [...orientedBoundingBox.center, ...orientedBoundingBox.halfAxes];
 }
 
 // dist/tileset-3d/format-3d-tiles/implicit-tiling.js
 var QUADTREE_CHILD_COUNT = 4;
 var OCTREE_CHILD_COUNT = 8;
+var AVAILABILITY_RANK_CACHE = /* @__PURE__ */ new WeakMap();
 function createImplicitSubtreeReference(descriptor, coordinates) {
   return {
     coordinates,
     subtreeUrl: replaceImplicitUrlTemplate(descriptor.subtreesUrlTemplate, coordinates),
-    descriptor
+    descriptor,
+    resource: findImplicitPackageResource(descriptor.resourceFiles, replaceImplicitUrlTemplate(descriptor.subtreesUrlTemplate, coordinates))
   };
 }
 function materializeImplicitSubtree(subtree, reference) {
   const { descriptor } = reference;
   validateImplicitDescriptor(descriptor);
+  validateImplicitSubtree(subtree, descriptor);
   const counters = { tileCount: 0, childSubtreeCount: 0 };
   const root = materializeAvailableTile(subtree, reference, { localLevel: 0, mortonIndex: 0 }, reference.coordinates, counters);
   if (!root) {
@@ -5168,14 +6189,79 @@ function materializeImplicitSubtree(subtree, reference) {
   }
   return { root, ...counters };
 }
-function replaceImplicitUrlTemplate(templateUrl, coordinates) {
+function validateImplicitSubtree(subtree, descriptor) {
+  const childCount = getImplicitChildCount(descriptor.subdivisionScheme);
+  const tileElementCount = (childCount ** descriptor.subtreeLevels - 1) / (childCount - 1);
+  const childSubtreeElementCount = childCount ** descriptor.subtreeLevels;
+  validateAvailabilityLength(subtree.tileAvailability, tileElementCount, "tile");
+  const contentAvailabilityStreams = Array.isArray(subtree.contentAvailability) ? subtree.contentAvailability : subtree.contentAvailability ? [subtree.contentAvailability] : [];
+  for (const contentAvailability of contentAvailabilityStreams) {
+    validateAvailabilityLength(contentAvailability, tileElementCount, "content");
+  }
+  validateAvailabilityLength(subtree.childSubtreeAvailability, childSubtreeElementCount, "child subtree");
+  const availableTileCount = countAvailableElements(subtree.tileAvailability, tileElementCount);
+  const availableContentCount = contentAvailabilityStreams[0] ? countAvailableElements(contentAvailabilityStreams[0], tileElementCount) : 0;
+  validateAttributeLengths(subtree.tileAttributes, availableTileCount, "tile");
+  validateAttributeLengths(subtree.contentAttributes, availableContentCount, "content");
+  if (subtree.tilePropertyRows && subtree.tilePropertyRows.length !== availableTileCount) {
+    throw new Error("3DTILES_subtree: tile property-table count does not match availability");
+  }
+  if (subtree.contentPropertyRows && subtree.contentPropertyRows.length !== availableContentCount) {
+    throw new Error("3DTILES_subtree: content property-table count does not match availability");
+  }
+}
+function validateAvailabilityLength(availability, elementCount, label) {
+  if (availability.constant === 0 || availability.constant === 1) {
+    return;
+  }
+  if (!availability.explicitBitstream || availability.explicitBitstream.byteLength * 8 < elementCount) {
+    throw new Error(`3DTILES_subtree: ${label} availability bitstream is too short`);
+  }
+}
+function countAvailableElements(availability, elementCount) {
+  if (availability.constant === 1) {
+    return elementCount;
+  }
+  if (availability.constant === 0) {
+    return 0;
+  }
+  let availableCount = 0;
+  for (let index = 0; index < elementCount; index++) {
+    if (getAvailabilityValue(availability, index)) {
+      availableCount++;
+    }
+  }
+  return availableCount;
+}
+function validateAttributeLengths(attributes, availableCount, label) {
+  const componentCounts = {
+    TILE_BOUNDING_BOX: 16,
+    TILE_BOUNDING_SPHERE: 4,
+    TILE_GEOMETRIC_ERROR: 1,
+    TILE_REFINE: 1,
+    TILE_TRANSFORM: 16,
+    CONTENT_BOUNDING_BOX: 16,
+    CONTENT_BOUNDING_SPHERE: 4
+  };
+  for (const [semantic, values] of Object.entries(attributes || {})) {
+    const componentCount = componentCounts[semantic];
+    if (componentCount && values.length !== availableCount * componentCount) {
+      throw new Error(`3DTILES_subtree: ${label} attribute ${semantic} count does not match availability`);
+    }
+  }
+}
+function replaceImplicitUrlTemplate(templateUrl, coordinates, properties = {}) {
   const values = {
     level: coordinates.level,
     x: coordinates.x,
     y: coordinates.y,
-    z: coordinates.z
+    z: coordinates.z,
+    ...properties
   };
-  return templateUrl.replace(/{(level|x|y|z)}/gi, (_match, coordinateName) => String(values[coordinateName.toLowerCase()]));
+  return templateUrl.replace(/{([^{}]+)}/g, (match, propertyName) => {
+    const value = Object.hasOwn(values, propertyName) ? values[propertyName] : values[propertyName.toLowerCase()];
+    return value === void 0 ? match : String(value);
+  });
 }
 function materializeAvailableTile(subtree, reference, localCoordinates, globalCoordinates, counters) {
   const { descriptor } = reference;
@@ -5210,10 +6296,12 @@ function materializeAvailableTile(subtree, reference, localCoordinates, globalCo
       }
     }
   }
-  return formatImplicitTileHeader(subtree, descriptor, reference, globalCoordinates, contentAvailability, children);
+  return formatImplicitTileHeader(subtree, descriptor, reference, globalCoordinates, availabilityIndex, contentAvailability, children);
 }
 function createLazyImplicitTileHeader(subtree, descriptor, coordinates) {
-  const reference = createImplicitSubtreeReference(descriptor, coordinates);
+  const resourceFiles = mergeImplicitPackageFiles(descriptor.resourceFiles, subtree.resourceFiles);
+  const childDescriptor = resourceFiles ? { ...descriptor, resourceFiles } : descriptor;
+  const reference = createImplicitSubtreeReference(childDescriptor, coordinates);
   return {
     id: getImplicitTileId(reference, coordinates),
     children: [],
@@ -5224,55 +6312,187 @@ function createLazyImplicitTileHeader(subtree, descriptor, coordinates) {
     lodMetricValue: descriptor.rootLodMetricValue / 2 ** coordinates.level,
     refine: descriptor.refine,
     type: TILE_TYPE.EMPTY,
-    implicitMetadata: getImplicitSubtreeMetadata(subtree)
+    implicitMetadata: getImplicitSubtreeMetadata(subtree),
+    _scaleGeometricError: descriptor.scaleGeometricError !== false
+  };
+}
+function getSubtreeAttributeOverrides(attributes, rowIndex, scope) {
+  var _a, _b;
+  if (!attributes || rowIndex < 0) {
+    return {};
+  }
+  const box = getAttributeComponents(attributes[scope === "tile" ? "TILE_BOUNDING_BOX" : "CONTENT_BOUNDING_BOX"], rowIndex, 16);
+  const sphere = getAttributeComponents(attributes[scope === "tile" ? "TILE_BOUNDING_SPHERE" : "CONTENT_BOUNDING_SPHERE"], rowIndex, 4);
+  const boundingVolume = box ? {
+    box: [
+      box[12],
+      box[13],
+      box[14],
+      box[0] / 2,
+      box[1] / 2,
+      box[2] / 2,
+      box[4] / 2,
+      box[5] / 2,
+      box[6] / 2,
+      box[8] / 2,
+      box[9] / 2,
+      box[10] / 2
+    ]
+  } : sphere ? { sphere } : void 0;
+  if (scope === "content") {
+    return { boundingVolume };
+  }
+  const geometricError = (_a = getAttributeComponents(attributes.TILE_GEOMETRIC_ERROR, rowIndex, 1)) == null ? void 0 : _a[0];
+  if (geometricError !== void 0 && (!Number.isFinite(geometricError) || geometricError < 0)) {
+    throw new Error("3DTILES_subtree: TILE_GEOMETRIC_ERROR must be nonnegative");
+  }
+  const refineValue = (_b = getAttributeComponents(attributes.TILE_REFINE, rowIndex, 1)) == null ? void 0 : _b[0];
+  if (refineValue !== void 0 && refineValue !== 0 && refineValue !== 1) {
+    throw new Error("3DTILES_subtree: TILE_REFINE must be 0 or 1");
+  }
+  return {
+    boundingVolume,
+    geometricError,
+    refine: refineValue === void 0 ? void 0 : refineValue === 0 ? TILE_REFINEMENT.ADD : TILE_REFINEMENT.REPLACE,
+    transform: getAttributeComponents(attributes.TILE_TRANSFORM, rowIndex, 16)
   };
 }
-function formatImplicitTileHeader(subtree, descriptor, reference, coordinates, contentAvailability, children) {
+function getAttributeComponents(values, rowIndex, componentCount) {
+  if (!values) {
+    return void 0;
+  }
+  const offset = rowIndex * componentCount;
+  if (offset + componentCount > values.length) {
+    throw new Error("3DTILES_subtree: attribute accessor is shorter than availability");
+  }
+  return Array.from({ length: componentCount }, (_unused, componentIndex) => Number(values[offset + componentIndex]));
+}
+function getAvailabilityRank(availability, index) {
+  var _a;
+  if (availability.constant === 1) {
+    return index;
+  }
+  if (availability.constant === 0) {
+    return 0;
+  }
+  let ranks = AVAILABILITY_RANK_CACHE.get(availability);
+  if (!ranks) {
+    const bitCount = (((_a = availability.explicitBitstream) == null ? void 0 : _a.byteLength) || 0) * 8;
+    ranks = new Uint32Array(bitCount + 1);
+    for (let candidateIndex = 0; candidateIndex < bitCount; candidateIndex++) {
+      ranks[candidateIndex + 1] = ranks[candidateIndex] + Number(getAvailabilityValue(availability, candidateIndex));
+    }
+    AVAILABILITY_RANK_CACHE.set(availability, ranks);
+  }
+  return ranks[index];
+}
+function findImplicitPackageResource(files, resourceUrl) {
   var _a;
-  const contentUrlTemplates = ((_a = descriptor.contentUrlTemplates) == null ? void 0 : _a.length) ? descriptor.contentUrlTemplates : [descriptor.contentUrlTemplate];
+  if (!(files == null ? void 0 : files.length)) {
+    return void 0;
+  }
+  const urlWithoutQuery = resourceUrl.split("?")[0];
+  const packageRelativePath = (_a = /^gltf-package:\/\/[^/]+\/(.*)$/.exec(urlWithoutQuery)) == null ? void 0 : _a[1];
+  const exactFileIndex = files.findIndex((file) => {
+    const reference = file.originalUri || file.name;
+    return file.uri === urlWithoutQuery || Boolean(reference && (urlWithoutQuery === reference || packageRelativePath === reference));
+  });
+  if (exactFileIndex >= 0) {
+    return { fileIndex: exactFileIndex, files };
+  }
+  const fileIndex = files.findIndex((file) => {
+    const reference = file.originalUri || file.name;
+    return Boolean(reference && (urlWithoutQuery.endsWith(`/${reference}`) || urlWithoutQuery.endsWith(`:${reference}`)));
+  });
+  return fileIndex < 0 ? void 0 : { fileIndex, files };
+}
+function mergeImplicitPackageFiles(parentFiles, childFiles) {
+  if (!(childFiles == null ? void 0 : childFiles.length)) {
+    return parentFiles;
+  }
+  if (!(parentFiles == null ? void 0 : parentFiles.length)) {
+    return childFiles;
+  }
+  const childReferences = new Set(childFiles.flatMap((file) => [file.uri, file.originalUri, file.name].filter(Boolean)));
+  return [
+    ...childFiles,
+    ...parentFiles.filter((file) => ![file.uri, file.originalUri, file.name].some((reference) => reference && childReferences.has(reference)))
+  ];
+}
+function formatImplicitTileHeader(subtree, descriptor, reference, coordinates, availabilityIndex, contentAvailability, children) {
+  var _a, _b, _c, _d, _e;
+  const tilePropertyIndex = getAvailabilityRank(subtree.tileAvailability, availabilityIndex);
+  const tileProperties = (_a = subtree.tilePropertyRows) == null ? void 0 : _a[tilePropertyIndex];
+  const primaryContentAvailability = Array.isArray(subtree.contentAvailability) ? subtree.contentAvailability[0] : subtree.contentAvailability;
+  const contentPropertyIndex = primaryContentAvailability && getAvailabilityValue(primaryContentAvailability, availabilityIndex) ? getAvailabilityRank(primaryContentAvailability, availabilityIndex) : -1;
+  const contentProperties = (_b = subtree.contentPropertyRows) == null ? void 0 : _b[contentPropertyIndex];
+  const tileTemplateProperties = ((_c = subtree.tileTemplatePropertyRows) == null ? void 0 : _c[tilePropertyIndex]) || tileProperties;
+  const contentTemplateProperties = ((_d = subtree.contentTemplatePropertyRows) == null ? void 0 : _d[contentPropertyIndex]) || contentProperties;
+  const templateProperties = { ...tileTemplateProperties, ...contentTemplateProperties };
+  const tileAttributes = getSubtreeAttributeOverrides(subtree.tileAttributes, tilePropertyIndex, "tile");
+  const contentAttributes = getSubtreeAttributeOverrides(subtree.contentAttributes, contentPropertyIndex, "content");
+  const contentUrlTemplates = ((_e = descriptor.contentUrlTemplates) == null ? void 0 : _e.length) ? descriptor.contentUrlTemplates : [descriptor.contentUrlTemplate];
   const contentEntries = contentUrlTemplates.map((templateUrl, contentIndex) => {
     if (!contentAvailability[contentIndex] || !templateUrl) {
       return null;
     }
+    const contentUrl2 = replaceImplicitUrlTemplate(templateUrl, coordinates, templateProperties);
+    if (/{[^{}]+}/.test(contentUrl2)) {
+      throw new Error(`Implicit content URI has unresolved template values: ${contentUrl2}`);
+    }
     return {
       contentIndex,
-      contentUrl: replaceImplicitUrlTemplate(templateUrl, coordinates)
+      contentUrl: contentUrl2
     };
   }).filter((entry) => Boolean(entry));
   const availableContentUrls = contentEntries.map((entry) => entry.contentUrl);
+  const resourceFiles = mergeImplicitPackageFiles(descriptor.resourceFiles, subtree.resourceFiles);
   const content = contentEntries.map(({ contentIndex, contentUrl: contentUrl2 }) => {
     var _a2;
+    const packageResource = findImplicitPackageResource(resourceFiles, contentUrl2);
     return {
       ...((_a2 = descriptor.contentHeaders) == null ? void 0 : _a2[contentIndex]) || (contentIndex === 0 ? descriptor.contentHeader : {}) || {},
-      uri: contentUrl2
+      ...contentAttributes,
+      uri: contentUrl2,
+      ...contentProperties ? { metadata: { properties: contentProperties } } : {},
+      ...packageResource ? { _resource: packageResource } : {}
     };
   });
   const contentUrl = availableContentUrls[0];
-  const lodMetricValue = descriptor.rootLodMetricValue / 2 ** coordinates.level;
+  const computedLodMetricValue = descriptor.rootLodMetricValue / 2 ** coordinates.level;
+  const lodMetricValue = tileAttributes.geometricError ?? computedLodMetricValue;
+  const computedBoundingVolume = calculateImplicitBoundingVolume(descriptor.rootBoundingVolume, coordinates, descriptor.subdivisionScheme);
   return {
     id: getImplicitTileId(reference, coordinates),
     children,
     contentUrl,
     content: content.length > 1 ? content : content[0],
+    contents: descriptor.useCanonicalContents && content.length ? content : void 0,
     contentUrls: availableContentUrls,
-    refine: descriptor.refine,
+    refine: tileAttributes.refine || descriptor.refine,
     type: getImplicitTileType(contentUrl),
     lodMetricType: descriptor.lodMetricType,
     lodMetricValue,
     geometricError: lodMetricValue,
-    boundingVolume: calculateImplicitBoundingVolume(descriptor.rootBoundingVolume, coordinates, descriptor.subdivisionScheme),
-    implicitMetadata: getImplicitSubtreeMetadata(subtree)
+    boundingVolume: tileAttributes.boundingVolume || computedBoundingVolume,
+    transform: tileAttributes.transform,
+    transformMatrix: tileAttributes.transform,
+    metadata: tileProperties ? { properties: tileProperties } : void 0,
+    implicitMetadata: getImplicitSubtreeMetadata(subtree, tileProperties, contentProperties),
+    _scaleGeometricError: descriptor.scaleGeometricError !== false
   };
 }
-function getImplicitSubtreeMetadata(subtree) {
-  if (!subtree.propertyTables && subtree.tileMetadata === void 0 && !subtree.contentMetadata && subtree.subtreeMetadata === void 0) {
+function getImplicitSubtreeMetadata(subtree, tileProperties, contentProperties) {
+  if (!subtree.propertyTables && subtree.tileMetadata === void 0 && !subtree.contentMetadata && subtree.subtreeMetadata === void 0 && !tileProperties && !contentProperties) {
     return void 0;
   }
   return {
     propertyTables: subtree.propertyTables,
     tileMetadata: subtree.tileMetadata,
     contentMetadata: subtree.contentMetadata,
-    subtreeMetadata: subtree.subtreeMetadata
+    subtreeMetadata: subtree.subtreeMetadata,
+    tileProperties,
+    contentProperties
   };
 }
 function getImplicitTileId(reference, coordinates) {
@@ -5309,12 +6529,15 @@ function getImplicitChildCount(subdivisionScheme) {
   return subdivisionScheme === "OCTREE" ? OCTREE_CHILD_COUNT : QUADTREE_CHILD_COUNT;
 }
 function calculateImplicitBoundingVolume(rootBoundingVolume, coordinates, subdivisionScheme) {
+  var _a;
   if (rootBoundingVolume.region) {
     const [west, south, east, north, minimumHeight, maximumHeight] = rootBoundingVolume.region;
     const divisionCount = 2 ** coordinates.level;
-    const longitudeSize = (east - west) / divisionCount;
+    const longitudeSpan = east >= west ? east - west : east + 2 * Math.PI - west;
+    const longitudeSize = longitudeSpan / divisionCount;
     const latitudeSize = (north - south) / divisionCount;
-    const childWest = west + longitudeSize * coordinates.x;
+    const childWest = normalizeRegionLongitude(west + longitudeSize * coordinates.x);
+    const childEast = normalizeRegionLongitude(west + longitudeSize * (coordinates.x + 1));
     const childSouth = south + latitudeSize * coordinates.y;
     let childMinimumHeight = minimumHeight;
     let childMaximumHeight = maximumHeight;
@@ -5327,7 +6550,7 @@ function calculateImplicitBoundingVolume(rootBoundingVolume, coordinates, subdiv
       region: [
         childWest,
         childSouth,
-        childWest + longitudeSize,
+        childEast,
         childSouth + latitudeSize,
         childMinimumHeight,
         childMaximumHeight
@@ -5336,7 +6559,13 @@ function calculateImplicitBoundingVolume(rootBoundingVolume, coordinates, subdiv
   }
   if (rootBoundingVolume.box) {
     if (rootBoundingVolume.s2VolumeInfo) {
-      return { box: [...rootBoundingVolume.box], s2VolumeInfo: rootBoundingVolume.s2VolumeInfo };
+      return calculateS2ImplicitBoundingVolume(rootBoundingVolume, coordinates, subdivisionScheme);
+    }
+    if ((_a = rootBoundingVolume.extensions) == null ? void 0 : _a["3DTILES_shape_cylinder_region"]) {
+      return {
+        ...rootBoundingVolume,
+        box: [...rootBoundingVolume.box]
+      };
     }
     const box = rootBoundingVolume.box;
     const divisionCount = 2 ** coordinates.level;
@@ -5366,6 +6595,41 @@ function calculateImplicitBoundingVolume(rootBoundingVolume, coordinates, subdiv
   }
   throw new Error(`Unsupported implicit 3D Tiles bounding volume: ${JSON.stringify(rootBoundingVolume)}`);
 }
+function calculateS2ImplicitBoundingVolume(rootBoundingVolume, coordinates, subdivisionScheme) {
+  const rootS2VolumeInfo = rootBoundingVolume.s2VolumeInfo;
+  const rootIndex = (0, import_s22.getS2IndexFromToken)(rootS2VolumeInfo.token);
+  const descendantIndex = (0, import_s22.getS2DescendantIndex)(rootIndex, coordinates.level, coordinates.x, coordinates.y);
+  const divisionCount = 2 ** coordinates.level;
+  const heightSize = (rootS2VolumeInfo.maximumHeight - rootS2VolumeInfo.minimumHeight) / divisionCount;
+  const childS2VolumeInfo = {
+    token: (0, import_s22.getS2TokenFromIndex)(descendantIndex),
+    minimumHeight: rootS2VolumeInfo.minimumHeight + (subdivisionScheme === "OCTREE" ? heightSize * coordinates.z : 0),
+    maximumHeight: rootS2VolumeInfo.minimumHeight + (subdivisionScheme === "OCTREE" ? heightSize * (coordinates.z + 1) : heightSize * divisionCount)
+  };
+  const extensions = rootBoundingVolume.extensions ? { ...rootBoundingVolume.extensions } : void 0;
+  if (extensions == null ? void 0 : extensions["3DTILES_bounding_volume_S2"]) {
+    extensions["3DTILES_bounding_volume_S2"] = childS2VolumeInfo;
+  }
+  if (extensions == null ? void 0 : extensions["3DTILES_shape_s2"]) {
+    extensions["3DTILES_shape_s2"] = childS2VolumeInfo;
+  }
+  return {
+    ...rootBoundingVolume,
+    ...extensions ? { extensions } : {},
+    s2VolumeInfo: childS2VolumeInfo,
+    box: convertS2BoundingVolumeToOBB(childS2VolumeInfo)
+  };
+}
+function normalizeRegionLongitude(longitude) {
+  let normalizedLongitude = longitude;
+  while (normalizedLongitude > Math.PI) {
+    normalizedLongitude -= 2 * Math.PI;
+  }
+  while (normalizedLongitude < -Math.PI) {
+    normalizedLongitude += 2 * Math.PI;
+  }
+  return normalizedLongitude;
+}
 function getImplicitTileType(contentUrl) {
   var _a;
   if (!contentUrl) {
@@ -5434,6 +6698,12 @@ var Tiles3DSource = class {
   queryParams = {};
   /** Final request URLs cached by unmodified tile content URL. */
   tileUrlCache = /* @__PURE__ */ new Map();
+  /** Original content descriptors retained across {@link Tile3D.unloadContent} calls. */
+  tileContentHeaders = /* @__PURE__ */ new WeakMap();
+  /** Source-local namespaces assigned to distinct embedded glTF package file collections. */
+  packageNamespaces = /* @__PURE__ */ new WeakMap();
+  /** Next source-local package namespace. */
+  nextPackageNamespace = 0;
   /** Parsed subtree requests keyed by final source URL for deduplication and LRU reuse. */
   implicitSubtreeCache;
   /** Mutable counters exposed as a defensive snapshot through {@link getImplicitTilingStats}. */
@@ -5448,6 +6718,10 @@ var Tiles3DSource = class {
   extensionsUsed = [];
   resolver;
   rootTileset;
+  /** CRS transformer shared by this source's headers and decoded glTF content. */
+  spatialTransformer;
+  /** Root header after composing source-frame transforms and rebuilding target bounds. */
+  preparedRootHeader;
   /**
    * Creates a 3D Tiles source.
    * @param input Root metadata request, or preloaded root metadata for tests and internal callers.
@@ -5505,8 +6779,8 @@ var Tiles3DSource = class {
     if (!this.asset) {
       throw new Error("Tileset must have an asset property.");
     }
-    if (this.asset.version !== "0.0" && this.asset.version !== "1.0" && this.asset.version !== "1.1") {
-      throw new Error("The tileset must be 3D Tiles version either 0.0 or 1.0 or 1.1.");
+    if (this.rootTileset.formatVersion !== "2.0-draft" && this.asset.version !== "0.0" && this.asset.version !== "1.0" && this.asset.version !== "1.1") {
+      throw new Error("The tileset must be 3D Tiles version 0.0, 1.0, 1.1, or 2.0-draft.");
     }
     if ("tilesetVersion" in this.asset) {
       this.setQueryParameter("v", this.asset.tilesetVersion);
@@ -5542,12 +6816,26 @@ var Tiles3DSource = class {
   async getRootTileset() {
     return this.getMetadata().tileset;
   }
+  /** Prepare nonlinear CRS state before runtime headers are materialized. */
+  async prepareTileset(tileset) {
+    const spatialReference = tileset.spatialReference;
+    if (spatialReference.status === "unresolved") {
+      throw new Error(spatialReference.warnings[0] || "3D Tiles spatial operations cannot be resolved from the supplied metadata and options");
+    }
+    if (spatialReference.status !== "transformable" && spatialReference.status !== "transformed") {
+      return;
+    }
+    this.spatialTransformer ||= new Tiles3DSpatialTransformer(spatialReference, tileset.options.spatial);
+    tileset.spatialReference = markTilesetSpatialReferenceTransformed(spatialReference);
+    this.preparedRootHeader = this.transformTileHeader(this.getMetadata().tileset.root, new import_core12.Matrix4());
+  }
   /**
    * Builds explicit runtime headers while leaving implicit subtree references lazy.
    */
   initializeTileHeaders(tileset, tilesetJson, parentTile) {
     var _a;
-    const rootTile = new Tile3D(tileset, tilesetJson.root, parentTile || void 0);
+    const rootHeader = parentTile ? tilesetJson.root : this.preparedRootHeader || tilesetJson.root;
+    const rootTile = new Tile3D(tileset, rootHeader, parentTile || void 0);
     if (parentTile) {
       parentTile.children.push(rootTile);
       rootTile.depth = parentTile.depth + 1;
@@ -5583,7 +6871,13 @@ var Tiles3DSource = class {
    * Loads binary content or nested tileset JSON for a runtime tile.
    */
   async loadTileContent(tile) {
+    var _a, _b, _c, _d, _e, _f;
     const contentUrls = (tile.contentUrls || [tile.contentUrl]).filter(Boolean);
+    const cachedContentHeaders = this.tileContentHeaders.get(tile);
+    const contentHeaders = cachedContentHeaders || (Array.isArray((_a = tile.header) == null ? void 0 : _a.content) ? tile.header.content : ((_b = tile.header) == null ? void 0 : _b.content) ? [tile.header.content] : []);
+    if (!cachedContentHeaders) {
+      this.tileContentHeaders.set(tile, contentHeaders);
+    }
     const tilesetLoaderOptions = this.loadOptions[this.loader.id] || {};
     const options = {
       ...this.loadOptions,
@@ -5592,10 +6886,28 @@ var Tiles3DSource = class {
         // Content bytes, rather than URL suffixes, distinguish external tilesets from renderable
         // payloads. This is required for signed and extensionless resources.
         isTileset: "auto",
-        assetGltfUpAxis: this.asset && this.asset.gltfUpAxis || "Y"
+        assetGltfUpAxis: this.asset && this.asset.gltfUpAxis || "Y",
+        _tilesetOptions: {
+          spatialReference: ((_c = tile.header) == null ? void 0 : _c._spatialReference) || ((_d = tile.tileset) == null ? void 0 : _d.spatialReference),
+          spatialOptions: (_e = tile.tileset) == null ? void 0 : _e.options.spatial,
+          spatialTransform: (_f = tile.header) == null ? void 0 : _f._spatialTransform
+        }
       }
     };
-    const contents = await Promise.all(contentUrls.map((contentUrl) => this.loadResourceData(this.getTileUrl(contentUrl), options)));
+    const contents = await Promise.all(contentUrls.map((contentUrl, contentIndex) => {
+      var _a2;
+      const contentHeader = contentHeaders[contentIndex] || {};
+      const vectorExtension = (_a2 = contentHeader.extensions) == null ? void 0 : _a2["3DTILES_content_gltf_vector"];
+      const vectorContent = contentHeader._vectorContent || ((vectorExtension == null ? void 0 : vectorExtension.vector) === true ? { clip: vectorExtension.clip === true } : void 0);
+      const contentOptions = vectorContent ? {
+        ...options,
+        [this.loader.id]: {
+          ...options[this.loader.id],
+          vectorContent
+        }
+      } : options;
+      return this.loadContentResource(this.getTileUrl(contentUrl), contentHeader._resource, contentOptions);
+    }));
     tile.contents = contents;
     tile.content = contents[0] || null;
     const nestedTilesets = contents.filter((content) => (content == null ? void 0 : content.shape) === "tileset3d");
@@ -5606,6 +6918,34 @@ var Tiles3DSource = class {
       nestedTilesets
     };
   }
+  /** Transform a tile header and its eagerly declared descendants. */
+  transformTileHeader(header, parentTransform = new import_core12.Matrix4()) {
+    if (!this.spatialTransformer) {
+      return header;
+    }
+    return this.transformTileHeaderWithTransformer(header, this.spatialTransformer, parentTransform);
+  }
+  /** Rebuilds one header subtree using an explicitly selected CRS transformer. */
+  transformTileHeaderWithTransformer(header, transformer, parentTransform, spatialReference) {
+    const localTransform = header.transform ? new import_core12.Matrix4(header.transform) : new import_core12.Matrix4();
+    const composedTransform = new import_core12.Matrix4(parentTransform).multiplyRight(localTransform);
+    const content = Array.isArray(header.content) ? header.content.map((entry) => this.transformContentHeader(entry, composedTransform, transformer)) : header.content ? this.transformContentHeader(header.content, composedTransform, transformer) : header.content;
+    return {
+      ...header,
+      transform: void 0,
+      boundingVolume: header.boundingVolume ? transformer.transformBoundingVolume(header.boundingVolume, composedTransform) : header.boundingVolume,
+      _spatialReference: spatialReference,
+      _spatialTransform: composedTransform.toArray(),
+      content,
+      children: Array.isArray(header.children) ? header.children.map((child) => this.transformTileHeaderWithTransformer(child, transformer, composedTransform, spatialReference)) : header.children
+    };
+  }
+  transformContentHeader(content, composedTransform, transformer) {
+    return {
+      ...content,
+      boundingVolume: content.boundingVolume ? transformer.transformBoundingVolume(content.boundingVolume, composedTransform) : content.boundingVolume
+    };
+  }
   /**
    * Loads, materializes, and installs exactly one implicit subtree.
    *
@@ -5624,7 +6964,7 @@ var Tiles3DSource = class {
       return { loaded: false, tileCount: 0, childSubtreeCount: 0 };
     }
     const subtreeUrl = this.getTileUrl(reference.subtreeUrl);
-    const subtree = await this.loadImplicitSubtreeResource(subtreeUrl);
+    const subtree = await this.loadImplicitSubtreeResource(subtreeUrl, reference.resource);
     if (this.destroyed || tile.isDestroyed()) {
       return { loaded: false, tileCount: 0, childSubtreeCount: 0 };
     }
@@ -5632,8 +6972,11 @@ var Tiles3DSource = class {
       ...reference,
       subtreeUrl
     });
-    tile.applyImplicitSubtreeHeader(materializedSubtree.root);
-    const materializedTileCount = this.initializeMaterializedChildren(tile.tileset, tile, materializedSubtree.root.children);
+    const nestedSpatialReference = tile.header._spatialReference;
+    const subtreeTransformer = nestedSpatialReference ? new Tiles3DSpatialTransformer(nestedSpatialReference, tile.tileset.options.spatial) : this.spatialTransformer;
+    const materializedRoot = subtreeTransformer ? this.transformTileHeaderWithTransformer(materializedSubtree.root, subtreeTransformer, new import_core12.Matrix4(), nestedSpatialReference) : materializedSubtree.root;
+    tile.applyImplicitSubtreeHeader(materializedRoot);
+    const materializedTileCount = this.initializeMaterializedChildren(tile.tileset, tile, materializedRoot.children);
     this.implicitTilingStats.loadedSubtrees++;
     this.implicitTilingStats.materializedTiles += materializedTileCount;
     return {
@@ -5720,10 +7063,10 @@ var Tiles3DSource = class {
     const { center } = rootTile.boundingVolume;
     let cartographicCenter;
     if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) {
-      cartographicCenter = new import_core10.Vector3();
-      import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(center, cartographicCenter);
+      cartographicCenter = new import_core12.Vector3();
+      import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(center, cartographicCenter);
     } else {
-      cartographicCenter = new import_core10.Vector3(0, 0, -import_geospatial7.Ellipsoid.WGS84.radii[0]);
+      cartographicCenter = new import_core12.Vector3(0, 0, -import_geospatial10.Ellipsoid.WGS84.radii[0]);
     }
     return {
       asset: this.asset,
@@ -5762,9 +7105,59 @@ var Tiles3DSource = class {
     }
     const nestedTilesets = loadResult.nestedTilesets || (loadResult.nestedTileset ? [loadResult.nestedTileset] : []);
     for (const nestedTileset of nestedTilesets) {
-      tileset._initializeTileHeaders(nestedTileset, tile);
+      tileset._initializeTileHeaders(this.prepareNestedTileset(tileset, nestedTileset), tile);
     }
   }
+  /**
+   * Resolves a nested tileset's CRS independently and adapts it to the owning tileset output frame.
+   *
+   * Nested resources may use a different source CRS from their parent. Their headers and glTF
+   * payloads must therefore use a transformer built from the nested descriptor, while the parent
+   * runtime continues to expose one requested output frame to traversal and rendering.
+   */
+  prepareNestedTileset(tileset, nestedTileset) {
+    const nestedSpatialReference = nestedTileset.spatialMetadata;
+    const parentSpatialReference = tileset.spatialReference;
+    if ((nestedSpatialReference == null ? void 0 : nestedSpatialReference.status) === "unresolved" || (nestedSpatialReference == null ? void 0 : nestedSpatialReference.crs.state) === "unknown") {
+      throw new Error(nestedSpatialReference.warnings[0] || "Nested 3D Tiles CRS is explicitly unresolved and cannot be placed in the parent frame");
+    }
+    if (!nestedSpatialReference || !nestedSpatialReference.sourceCrs) {
+      if (this.spatialTransformer && (parentSpatialReference.status === "transformable" || parentSpatialReference.status === "transformed")) {
+        return {
+          ...nestedTileset,
+          spatialMetadata: parentSpatialReference,
+          root: this.transformTileHeaderWithTransformer(nestedTileset.root, this.spatialTransformer, new import_core12.Matrix4(), parentSpatialReference)
+        };
+      }
+      return addNestedSpatialReference(nestedTileset, parentSpatialReference);
+    }
+    const parentCoordinateEpoch = parentSpatialReference.coordinateEpoch;
+    const nestedCoordinateEpoch = nestedSpatialReference.coordinateEpoch;
+    if (parentCoordinateEpoch !== void 0 && nestedCoordinateEpoch !== void 0 && parentCoordinateEpoch !== nestedCoordinateEpoch) {
+      throw new Error(`Nested 3D Tiles coordinate epoch ${nestedCoordinateEpoch} differs from parent epoch ${parentCoordinateEpoch}; epoch-aware transformation is unavailable`);
+    }
+    const outputCrs = parentSpatialReference.targetCrs || parentSpatialReference.sourceCrs;
+    if (!outputCrs) {
+      return addNestedSpatialReference(nestedTileset, nestedSpatialReference);
+    }
+    const nestedOutputReference = applyTilesetSpatialOptions(nestedSpatialReference, {
+      ...tileset.options.spatial,
+      outputCoordinates: "target-crs",
+      targetCrs: outputCrs
+    });
+    if (nestedOutputReference.status === "unresolved") {
+      throw new Error(nestedOutputReference.warnings[0] || "Nested 3D Tiles CRS cannot be resolved in the parent output frame");
+    }
+    if (nestedOutputReference.status === "native") {
+      return addNestedSpatialReference(nestedTileset, nestedOutputReference);
+    }
+    const nestedTransformer = new Tiles3DSpatialTransformer(nestedOutputReference, tileset.options.spatial);
+    return {
+      ...nestedTileset,
+      spatialMetadata: nestedOutputReference,
+      root: this.transformTileHeaderWithTransformer(nestedTileset.root, nestedTransformer, new import_core12.Matrix4(), nestedOutputReference)
+    };
+  }
   /**
    * Loads data through injected core APIs so this module stays independent from `@loaders.gl/core`.
    */
@@ -5792,13 +7185,84 @@ var Tiles3DSource = class {
     }
     return await this.loadWithCoreApi(url, options, loader);
   }
+  /** Loads a URL content reference or parses a buffer-view file retained from a glTF package. */
+  async loadContentResource(url, packageResource, options) {
+    if (!packageResource) {
+      return await this.loadResourceData(url, options);
+    }
+    const file = packageResource.files[packageResource.fileIndex];
+    if (!file) {
+      throw new Error(`3D Tiles package references missing file ${packageResource.fileIndex}`);
+    }
+    if (file.uri) {
+      return await this.loadResourceData(this.getTileUrl(file.uri), options);
+    }
+    if (!this.coreApi) {
+      throw new Error("Tiles3DSource requires an injected coreApi to parse embedded package data");
+    }
+    const data = await this.getPackageFileData(file);
+    const packageNamespace = this.getPackageNamespace(packageResource.files);
+    const packageRootUrl = `gltf-package://${packageNamespace}/${packageResource.fileIndex}`;
+    const fileName = file.name || "content";
+    const directorySeparatorIndex = fileName.lastIndexOf("/");
+    const packageBaseUrl = directorySeparatorIndex >= 0 ? `${packageRootUrl}/${fileName.slice(0, directorySeparatorIndex)}` : packageRootUrl;
+    return await this.coreApi.parse(data, this.loader, options, {
+      url: `${packageRootUrl}/${fileName}`,
+      filename: fileName,
+      baseUrl: packageBaseUrl,
+      loaders: [this.loader],
+      coreApi: this.coreApi,
+      _parse: this.coreApi.parse,
+      _tiles3dPackageFiles: packageResource.files,
+      fetch: async (resource, init) => {
+        const reference = resource.startsWith(`${packageRootUrl}/`) ? resource.slice(packageRootUrl.length + 1) : resource;
+        const referencedFile = packageResource.files.find((packageFile) => packageFile.name === reference || packageFile.originalUri === reference);
+        if (!referencedFile) {
+          throw new Error(`3D Tiles glTF package does not contain file ${reference}`);
+        }
+        if (referencedFile.uri) {
+          return await this.coreApi.fetchFile(this.getTileUrl(referencedFile.uri), init);
+        }
+        const referencedData = await this.getPackageFileData(referencedFile);
+        return new Response(referencedData, {
+          headers: { "content-type": referencedFile.mimeType }
+        });
+      }
+    });
+  }
+  /** Returns a stable source-local namespace for one embedded glTF package file collection. */
+  getPackageNamespace(files) {
+    const existingNamespace = this.packageNamespaces.get(files);
+    if (existingNamespace !== void 0) {
+      return existingNamespace;
+    }
+    const packageNamespace = this.nextPackageNamespace++;
+    this.packageNamespaces.set(files, packageNamespace);
+    return packageNamespace;
+  }
+  /** Resolves a retained package-file byte range without eagerly copying other package files. */
+  async getPackageFileData(file) {
+    if (file.data) {
+      return sliceArrayBuffer(file.data, file.byteOffset, file.byteLength);
+    }
+    if (file.bufferUri && this.coreApi) {
+      const response = await this.coreApi.fetchFile(this.getTileUrl(file.bufferUri));
+      if (!response.ok) {
+        throw new Error(`Failed to fetch 3D Tiles package buffer: HTTP ${response.status}`);
+      }
+      const buffer = await response.arrayBuffer();
+      return sliceArrayBuffer(buffer, file.byteOffset, file.byteLength);
+    }
+    throw new Error("3D Tiles package file has no available byte source");
+  }
   /**
    * Returns a parsed subtree from the LRU cache or starts one source-managed request.
    *
    * @param subtreeUrl - Final subtree URL after query inheritance.
+   * @param packageResource - Optional glTF package file satisfying the subtree reference.
    * @returns Parsed subtree availability data.
    */
-  async loadImplicitSubtreeResource(subtreeUrl) {
+  async loadImplicitSubtreeResource(subtreeUrl, packageResource) {
     const cachedSubtree = this.implicitSubtreeCache.get(subtreeUrl);
     if (cachedSubtree) {
       this.implicitTilingStats.cacheHits++;
@@ -5807,14 +7271,15 @@ var Tiles3DSource = class {
     this.implicitTilingStats.requestedSubtrees++;
     const loaderOptions = this.loadOptions[this.loader.id] || {};
     return await this.implicitSubtreeCache.getOrLoad(subtreeUrl, async () => {
-      return await this.loadResourceData(subtreeUrl, {
+      const options = {
         ...this.loadOptions,
         [this.loader.id]: {
           ...loaderOptions,
           isTileset: false,
           isSubtree: true
         }
-      });
+      };
+      return await (packageResource ? this.loadContentResource(subtreeUrl, packageResource, options) : this.loadResourceData(subtreeUrl, options));
     });
   }
   /**
@@ -5865,10 +7330,22 @@ function normalizeTiles3DRequest(input) {
     coreApi: input.coreApi
   };
 }
+function addNestedSpatialReference(nestedTileset, spatialReference) {
+  const addToHeader = (header) => ({
+    ...header,
+    _spatialReference: spatialReference,
+    children: Array.isArray(header.children) ? header.children.map(addToHeader) : header.children
+  });
+  return {
+    ...nestedTileset,
+    spatialMetadata: spatialReference,
+    root: addToHeader(nestedTileset.root)
+  };
+}
 
 // dist/tileset-3d/format-i3s/i3s-source.js
-var import_geospatial10 = require("@math.gl/geospatial");
-var import_core13 = require("@math.gl/core");
+var import_geospatial12 = require("@math.gl/geospatial");
+var import_core14 = require("@math.gl/core");
 
 // dist/tileset-3d/format-i3s/i3s-pending-tiles-register.js
 var I3SPendingTilesRegister = class {
@@ -6049,224 +7526,8 @@ var I3STilesetTraverser = class extends TilesetTraverser {
 };
 
 // dist/spatial/i3s-spatial-transformer.js
-var import_core12 = require("@math.gl/core");
-var import_geospatial9 = require("@math.gl/geospatial");
-
-// dist/spatial/spatial-coordinate-transformer.js
-var import_core11 = require("@math.gl/core");
-var import_geospatial8 = require("@math.gl/geospatial");
-var import_proj42 = require("@math.gl/proj4");
-
-// dist/spatial/spatial-resource-registry.js
-var import_geoid = require("@math.gl/geoid");
-var import_proj4 = require("@math.gl/proj4");
-var geoidModels = /* @__PURE__ */ new Map();
-function registerSpatialCrs(name, definition) {
-  validateResourceName(name, "CRS");
-  import_proj4.Proj4Projection.defineProjectionAliases({ [name]: definition });
-}
-function registerSpatialDatumGrid(name, data) {
-  validateResourceName(name, "datum grid");
-  import_proj4.Proj4Projection.registerDatumGrid(name, data);
-}
-function registerGeoidModel(name, geoid) {
-  validateResourceName(name, "geoid model");
-  geoidModels.set(name, geoid);
-}
-function registerGeoidModelFromPgm(name, data, options = {}) {
-  const geoid = (0, import_geoid.parsePGM)(data, options);
-  registerGeoidModel(name, geoid);
-  return geoid;
-}
-function getGeoidModel(name) {
-  return geoidModels.get(name);
-}
-function validateResourceName(name, resourceType) {
-  if (!name.trim()) {
-    throw new Error(`${resourceType} name must not be empty`);
-  }
-}
-
-// dist/spatial/spatial-coordinate-transformer.js
-var GEOGRAPHIC_CRS2 = "EPSG:4326";
-var GEOCENTRIC_CRS2 = "EPSG:4978";
-var SpatialCoordinateTransformer = class {
-  /** Normalized spatial metadata describing this transformation. */
-  spatialReference;
-  /** Projection from the source CRS directly to the requested horizontal target CRS. */
-  horizontalProjection;
-  /** Projection from the source CRS to geographic longitude, latitude, and ellipsoidal height. */
-  geographicProjection;
-  /** Projection from adjusted geographic coordinates to the requested output CRS. */
-  heightOutputProjection;
-  /** Whether source coordinates use the WGS84 geocentric frame handled by math.gl. */
-  sourceIsGeocentric;
-  /** Whether output coordinates use the WGS84 geocentric frame handled by math.gl. */
-  outputIsGeocentric;
-  /** Whether source coordinates already use conventional WGS84 longitude/latitude order. */
-  sourceIsGeographic;
-  /** Whether output coordinates use conventional WGS84 longitude/latitude order. */
-  outputIsGeographic;
-  /** Geoid model used to convert between ellipsoidal and orthometric heights. */
-  geoid;
-  /**
-   * Creates a coordinate transformer.
-   *
-   * @param spatialReference - Format-discovered and option-normalized spatial metadata.
-   * @param options - Application options containing an optional geoid model.
-   */
-  constructor(spatialReference, options = {}) {
-    this.spatialReference = spatialReference;
-    validateTransformRequest(spatialReference);
-    const outputCrs = spatialReference.targetCrs || spatialReference.sourceCrs;
-    this.sourceIsGeocentric = isWgs84Geocentric(spatialReference.sourceCrs);
-    this.outputIsGeocentric = isWgs84Geocentric(outputCrs);
-    this.sourceIsGeographic = isWgs84Geographic(spatialReference.sourceCrs);
-    this.outputIsGeographic = isWgs84Geographic(outputCrs);
-    if (spatialReference.sourceCrs && spatialReference.targetCrs && !this.sourceIsGeocentric && !this.outputIsGeocentric) {
-      this.horizontalProjection = new import_proj42.Proj4Projection({
-        from: getHorizontalProj4Definition(spatialReference.sourceCrs),
-        to: getHorizontalProj4Definition(spatialReference.targetCrs),
-        enforceAxis: false
-      });
-    }
-    if (requiresHeightTransformation(spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
-      if (!this.sourceIsGeographic && !this.sourceIsGeocentric) {
-        this.geographicProjection = new import_proj42.Proj4Projection({
-          from: getHorizontalProj4Definition(spatialReference.sourceCrs),
-          to: GEOGRAPHIC_CRS2,
-          enforceAxis: false
-        });
-      }
-      if (!this.outputIsGeographic && !this.outputIsGeocentric) {
-        this.heightOutputProjection = new import_proj42.Proj4Projection({
-          from: GEOGRAPHIC_CRS2,
-          to: getHorizontalProj4Definition(outputCrs),
-          enforceAxis: false
-        });
-      }
-    }
-    if (requiresHeightTransformation(spatialReference)) {
-      this.geoid = resolveGeoid(options.geoidModel);
-      if (!this.geoid) {
-        const modelName = typeof options.geoidModel === "string" ? ` "${options.geoidModel}"` : "";
-        throw new Error(`Height conversion requires a registered geoid model${modelName}; call registerGeoidModel() or pass a parsed Geoid instance`);
-      }
-    }
-  }
-  /**
-   * Transforms one `[x, y, z?]` coordinate while retaining additional components.
-   *
-   * @param coordinate - Source coordinate in the format adapter's normalized `x/y/z` order.
-   * @returns A new transformed coordinate array.
-   */
-  transformPosition(coordinate) {
-    if (coordinate.length < 2) {
-      throw new Error("A spatial coordinate must contain at least x and y components");
-    }
-    const result = [...coordinate];
-    if (requiresHeightTransformation(this.spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
-      if (result.length < 3 || !Number.isFinite(result[2])) {
-        throw new Error("Three-dimensional CRS conversion requires a finite z coordinate");
-      }
-      const geographic = this.toGeographic(result);
-      if (requiresHeightTransformation(this.spatialReference)) {
-        const geoidUndulation = this.geoid.getHeight(geographic[1], geographic[0]);
-        geographic[2] = transformHeight(geographic[2], geoidUndulation, this.spatialReference.heightReference, this.spatialReference.targetHeightReference);
-      }
-      const projected = this.fromGeographic(geographic);
-      result.splice(0, projected.length, ...projected);
-      return result;
-    }
-    if (this.horizontalProjection) {
-      const projected = this.horizontalProjection.project(result.slice(0, 3));
-      result.splice(0, projected.length, ...projected);
-    }
-    return result;
-  }
-  /** Convert one source coordinate to conventional WGS84 longitude, latitude, and height. */
-  toGeographic(coordinate) {
-    if (this.sourceIsGeocentric) {
-      return Array.from(import_geospatial8.Ellipsoid.WGS84.cartesianToCartographic(new import_core11.Vector3(coordinate)));
-    }
-    if (this.sourceIsGeographic) {
-      return coordinate.slice(0, 3);
-    }
-    return this.geographicProjection.project(coordinate.slice(0, 3));
-  }
-  /** Convert one conventional WGS84 geographic coordinate to the selected output CRS. */
-  fromGeographic(coordinate) {
-    if (this.outputIsGeocentric) {
-      return Array.from(import_geospatial8.Ellipsoid.WGS84.cartographicToCartesian(new import_core11.Vector3(coordinate)));
-    }
-    if (this.outputIsGeographic) {
-      return coordinate.slice(0, 3);
-    }
-    return this.heightOutputProjection.project(coordinate.slice(0, 3));
-  }
-};
-function getHorizontalProj4Definition(definition) {
-  if (!definition) {
-    throw new Error("Cannot construct a projection because the CRS is unknown");
-  }
-  return (0, import_proj42.toProj4CRSDefinition)(definition, { mode: "horizontal" });
-}
-function validateTransformRequest(spatialReference) {
-  if (spatialReference.outputCoordinates === "local-enu") {
-    throw new Error("local-enu output requires a dataset-derived local origin and must be created by a tileset source");
-  }
-  if (spatialReference.outputCoordinates === "target-crs" && !spatialReference.targetCrs) {
-    throw new Error("target-crs output requires targetCrs");
-  }
-  if (!spatialReference.sourceCrs && spatialReference.status === "unresolved") {
-    throw new Error("Cannot transform coordinates because the source CRS is unknown");
-  }
-  if (requiresHeightTransformation(spatialReference) && spatialReference.heightReference === "unknown") {
-    throw new Error("Cannot convert heights because the source height reference is unknown");
-  }
-  if (spatialReference.coordinateFrame === "geocentric" && !isWgs84Geocentric(spatialReference.sourceCrs)) {
-    throw new Error("Only EPSG:4978 geocentric coordinates are supported by the current spatial transformer");
-  }
-  if (spatialReference.status === "unresolved") {
-    throw new Error("The requested spatial output cannot be resolved from the available metadata");
-  }
-}
-function isWgs84Geocentric(definition) {
-  return typeof definition === "string" && normalizeCrsIdentifier2(definition) === GEOCENTRIC_CRS2;
-}
-function isWgs84Geographic(definition) {
-  if (typeof definition !== "string") {
-    return false;
-  }
-  const identifier = normalizeCrsIdentifier2(definition);
-  return identifier === GEOGRAPHIC_CRS2 || identifier === "EPSG:4979" || identifier === "OGC:CRS84";
-}
-function normalizeCrsIdentifier2(identifier) {
-  const normalizedIdentifier = identifier.trim().toUpperCase();
-  const ogcMatch = normalizedIdentifier.match(/(?:\/DEF\/CRS\/|URN:OGC:DEF:CRS:)([A-Z0-9_-]+)(?:\/|::)(?:[^/:]*[/:])?([A-Z0-9_.-]+)$/);
-  return ogcMatch ? `${ogcMatch[1]}:${ogcMatch[2]}` : normalizedIdentifier;
-}
-function requiresHeightTransformation(spatialReference) {
-  const target = spatialReference.targetHeightReference;
-  return target !== "native" && target !== spatialReference.heightReference;
-}
-function resolveGeoid(model) {
-  return typeof model === "string" ? getGeoidModel(model) : model;
-}
-function transformHeight(height, geoidUndulation, source, target) {
-  if (source === target || target === "native") {
-    return height;
-  }
-  if (source === "orthometric" && target === "ellipsoidal") {
-    return height + geoidUndulation;
-  }
-  if (source === "ellipsoidal" && target === "orthometric") {
-    return height - geoidUndulation;
-  }
-  throw new Error(`Unsupported height conversion from ${source} to ${target}`);
-}
-
-// dist/spatial/i3s-spatial-transformer.js
+var import_core13 = require("@math.gl/core");
+var import_geospatial11 = require("@math.gl/geospatial");
 var I3SSpatialTransformer = class {
   /** Descriptor attached to output after all adapter-owned spatial values have been transformed. */
   spatialReference;
@@ -6461,7 +7722,7 @@ var I3SSpatialTransformer = class {
       positions[index + 2] = transformed[2] - origin[2];
     }
     const isGeographic = this.targetCoordinateFrame === "geographic";
-    const modelMatrix = isGeographic ? new import_core12.Matrix4() : new import_core12.Matrix4().translate(origin);
+    const modelMatrix = isGeographic ? new import_core13.Matrix4() : new import_core13.Matrix4().translate(origin);
     return {
       positions,
       sourcePositions: absoluteSourcePositions,
@@ -6489,7 +7750,7 @@ var I3SSpatialTransformer = class {
         sourcePositions[index + 1],
         sourcePositions[index + 2]
       ]);
-      const inputNormal = new import_core12.Vector3([
+      const inputNormal = new import_core13.Vector3([
         normals[index],
         normals[index + 1],
         normals[index + 2]
@@ -6527,12 +7788,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_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core12.Vector3(position))));
+    const cartesianSamples = this.getGeographicBoundSamples(bounds).map((position) => Array.from(import_geospatial11.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_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core12.Vector3(position))));
+    const cartesianSamples = (await this.getGeographicBoundSamplesAsync(bounds)).map((position) => Array.from(import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
     return { box: getAxisAlignedBox(cartesianSamples) };
   }
   /** Return a WGS84 geographic MBS used by the I3S screen-threshold calculation. */
@@ -6559,7 +7820,7 @@ var I3SSpatialTransformer = class {
    */
   async transformBoundsAsync(bounds) {
     const geographicSamples = await this.getGeographicBoundSamplesAsync(bounds);
-    const cartesianSamples = geographicSamples.map((position) => Array.from(import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core12.Vector3(position))));
+    const cartesianSamples = geographicSamples.map((position) => Array.from(import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
     const targetSamples = geographicSamples.map((position) => this.geographicToTargetTransformer.transformPosition(position));
     return {
       boundingVolume: { box: getAxisAlignedBox(cartesianSamples) },
@@ -6682,21 +7943,21 @@ var I3SSpatialTransformer = class {
     if (this.targetCoordinateFrame === "geographic") {
       return ecefVectorToLocalEnu(ecefNormal, geographic).normalize();
     }
-    const cartesian = import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core12.Vector3(geographic));
+    const cartesian = import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(geographic));
     const jacobianColumns = [];
     for (const direction of getPositiveAxisDirections()) {
-      const positiveGeographic = import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(new import_core12.Vector3(cartesian).add(direction));
-      const negativeGeographic = import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(new import_core12.Vector3(cartesian).subtract(direction));
+      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 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);
     }
-    const normalMatrix = new import_core12.Matrix3(jacobianColumns);
+    const normalMatrix = new import_core13.Matrix3(jacobianColumns);
     if (Math.abs(normalMatrix.determinant()) < 1e-12) {
       throw new Error("Cannot transform an I3S normal through a singular local projection");
     }
     normalMatrix.invert().transpose();
-    return new import_core12.Vector3(ecefNormal).transformByMatrix3(normalMatrix).normalize();
+    return new import_core13.Vector3(ecefNormal).transformByMatrix3(normalMatrix).normalize();
   }
 };
 function getElevationProvider(mode, options) {
@@ -6728,17 +7989,17 @@ function getGeographicBoundingSphere(geographicSamples) {
   if (!geographicSamples.length) {
     throw new Error("I3S spatial transformation requires at least one bound sample");
   }
-  const cartesianSamples = geographicSamples.map((position) => import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core12.Vector3(position)));
-  const cartesianCenter = new import_core12.Vector3();
+  const cartesianSamples = geographicSamples.map((position) => import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position)));
+  const cartesianCenter = new import_core13.Vector3();
   for (const sample of cartesianSamples) {
     cartesianCenter.add(sample);
   }
   cartesianCenter.scale(1 / cartesianSamples.length);
   let radius = 0;
   for (const sample of cartesianSamples) {
-    radius = Math.max(radius, new import_core12.Vector3(sample).subtract(cartesianCenter).magnitude());
+    radius = Math.max(radius, new import_core13.Vector3(sample).subtract(cartesianCenter).magnitude());
   }
-  const geographicCenter = import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(cartesianCenter);
+  const geographicCenter = import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(cartesianCenter);
   return [geographicCenter[0], geographicCenter[1], geographicCenter[2], radius];
 }
 function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransformer, sourceVerticalUnitScale) {
@@ -6747,28 +8008,28 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
     const center2 = Array.from(obb.center).slice(0, 3);
     center2[2] *= sourceVerticalUnitScale;
     const halfSize = Array.from(obb.halfSize).slice(0, 3);
-    const quaternion = new import_core12.Quaternion().fromArray(Array.from(obb.quaternion));
+    const quaternion = new import_core13.Quaternion().fromArray(Array.from(obb.quaternion));
     const axes = [
-      new import_core12.Vector3([halfSize[0], 0, 0]).transformByQuaternion(quaternion),
-      new import_core12.Vector3([0, halfSize[1], 0]).transformByQuaternion(quaternion),
-      new import_core12.Vector3([0, 0, halfSize[2]]).transformByQuaternion(quaternion)
+      new import_core13.Vector3([halfSize[0], 0, 0]).transformByQuaternion(quaternion),
+      new import_core13.Vector3([0, halfSize[1], 0]).transformByQuaternion(quaternion),
+      new import_core13.Vector3([0, 0, halfSize[2]]).transformByQuaternion(quaternion)
     ];
     if (sourceFrame === "geographic") {
       const geographicCenter = sourceToGeographicTransformer.transformPosition(center2);
-      const cartesianCenter = import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core12.Vector3(geographicCenter));
+      const cartesianCenter = import_geospatial11.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_core12.Vector3(cartesianCenter);
+        const corner = new import_core13.Vector3(cartesianCenter);
         for (let axisIndex = 0; axisIndex < 3; axisIndex++) {
-          corner.add(new import_core12.Vector3(cartesianAxes[axisIndex]).scale(signs[axisIndex]));
+          corner.add(new import_core13.Vector3(cartesianAxes[axisIndex]).scale(signs[axisIndex]));
         }
-        return Array.from(import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(corner));
+        return Array.from(import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(corner));
       });
     }
     return getBoxSigns().map((signs) => {
-      const corner = new import_core12.Vector3(center2);
+      const corner = new import_core13.Vector3(center2);
       for (let axisIndex = 0; axisIndex < 3; axisIndex++) {
-        corner.add(new import_core12.Vector3(axes[axisIndex]).scale(signs[axisIndex]));
+        corner.add(new import_core13.Vector3(axes[axisIndex]).scale(signs[axisIndex]));
       }
       return Array.from(corner);
     });
@@ -6782,10 +8043,10 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
   const radius = mbs[3];
   if (sourceFrame === "geographic") {
     const geographicCenter = sourceToGeographicTransformer.transformPosition(center);
-    const cartesianCenter = import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core12.Vector3(geographicCenter));
-    return getAxisDirections().map((direction) => Array.from(import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(new import_core12.Vector3(cartesianCenter).add(new import_core12.Vector3(direction).scale(radius)))));
+    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)))));
   }
-  return getAxisDirections().map((direction) => Array.from(new import_core12.Vector3(center).add(new import_core12.Vector3(direction).scale(radius))));
+  return getAxisDirections().map((direction) => Array.from(new import_core13.Vector3(center).add(new import_core13.Vector3(direction).scale(radius))));
 }
 function getBoxSigns() {
   return [-1, 1].flatMap((x) => [-1, 1].flatMap((y) => [-1, 1].map((z) => [x, y, z])));
@@ -6801,18 +8062,18 @@ function getAxisDirections() {
   ];
 }
 function getPositiveAxisDirections() {
-  return [new import_core12.Vector3([1, 0, 0]), new import_core12.Vector3([0, 1, 0]), new import_core12.Vector3([0, 0, 1])];
+  return [new import_core13.Vector3([1, 0, 0]), new import_core13.Vector3([0, 1, 0]), new import_core13.Vector3([0, 0, 1])];
 }
 function localEnuVectorToEcef(vector, geographic) {
   const longitude = geographic[0] * Math.PI / 180;
   const latitude = geographic[1] * Math.PI / 180;
-  const east = new import_core12.Vector3([-Math.sin(longitude), Math.cos(longitude), 0]);
-  const north = new import_core12.Vector3([
+  const east = new import_core13.Vector3([-Math.sin(longitude), Math.cos(longitude), 0]);
+  const north = new import_core13.Vector3([
     -Math.sin(latitude) * Math.cos(longitude),
     -Math.sin(latitude) * Math.sin(longitude),
     Math.cos(latitude)
   ]);
-  const up = new import_core12.Vector3([
+  const up = new import_core13.Vector3([
     Math.cos(latitude) * Math.cos(longitude),
     Math.cos(latitude) * Math.sin(longitude),
     Math.sin(latitude)
@@ -6822,18 +8083,18 @@ function localEnuVectorToEcef(vector, geographic) {
 function ecefVectorToLocalEnu(vector, geographic) {
   const longitude = geographic[0] * Math.PI / 180;
   const latitude = geographic[1] * Math.PI / 180;
-  const east = new import_core12.Vector3([-Math.sin(longitude), Math.cos(longitude), 0]);
-  const north = new import_core12.Vector3([
+  const east = new import_core13.Vector3([-Math.sin(longitude), Math.cos(longitude), 0]);
+  const north = new import_core13.Vector3([
     -Math.sin(latitude) * Math.cos(longitude),
     -Math.sin(latitude) * Math.sin(longitude),
     Math.cos(latitude)
   ]);
-  const up = new import_core12.Vector3([
+  const up = new import_core13.Vector3([
     Math.cos(latitude) * Math.cos(longitude),
     Math.cos(latitude) * Math.sin(longitude),
     Math.sin(latitude)
   ]);
-  return new import_core12.Vector3([east.dot(vector), north.dot(vector), up.dot(vector)]);
+  return new import_core13.Vector3([east.dot(vector), north.dot(vector), up.dot(vector)]);
 }
 function getAxisAlignedBox(positions) {
   const minimum = [Infinity, Infinity, Infinity];
@@ -6888,8 +8149,10 @@ var EMPTY_CONTENT_FORMATS2 = {
 var I3SSource = class {
   /** I3S format discriminator. */
   type = TILESET_TYPE.I3S;
-  /** Loader used for tile metadata and content requests. */
+  /** Primary I3S loader used for root and child metadata requests. */
   loader;
+  /** Worker-capable loader used for binary tile content when supplied by the format loader. */
+  contentLoader;
   /** Root I3S layer URL. */
   url;
   /** Base path used for relative tile resource resolution. */
@@ -6924,6 +8187,7 @@ var I3SSource = class {
     this.rootTileset = isTilesetRequest2(input) ? null : input;
     this.tileset = this.rootTileset;
     this.loader = request.loader;
+    this.contentLoader = getI3SContentLoader(request.loader);
     this.url = request.url;
     this.basePath = request.basePath || path_exports.dirname(request.url);
     this.resolver = request.resolver;
@@ -7040,7 +8304,7 @@ var I3SSource = class {
         isTileHeader: false
       }
     };
-    tile.content = await this.loadResourceData(contentUrl, options);
+    tile.content = await this.loadResourceData(contentUrl, options, this.contentLoader);
     return { loaded: true };
   }
   /**
@@ -7095,8 +8359,8 @@ var I3SSource = class {
   getViewState(rootTile) {
     var _a;
     if (this.spatialTransformer && rootTile) {
-      const center = new import_core13.Vector3(rootTile.boundingVolume.center);
-      const cartographicCenter = new import_core13.Vector3(rootTile.header.i3sLodMbs.slice(0, 3));
+      const center = new import_core14.Vector3(rootTile.boundingVolume.center);
+      const cartographicCenter = new import_core14.Vector3(rootTile.header.i3sLodMbs.slice(0, 3));
       if (this.spatialTransformer.targetCoordinateFrame === "geographic") {
         return {
           boundingVolume: rootTile.boundingVolume,
@@ -7116,9 +8380,9 @@ var I3SSource = class {
     const fullExtent = metadata.tileset.fullExtent;
     if (fullExtent) {
       const { xmin, xmax, ymin, ymax, zmin, zmax } = fullExtent;
-      const cartographicCenter = new import_core13.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, zmin + (zmax - zmin) / 2);
-      const cartesianCenter = new import_core13.Vector3();
-      import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
+      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);
       return {
         cartographicCenter,
         cartesianCenter,
@@ -7128,9 +8392,9 @@ var I3SSource = class {
     const extent = (_a = metadata.tileset.store) == null ? void 0 : _a.extent;
     if (extent) {
       const [xmin, ymin, xmax, ymax] = extent;
-      const cartographicCenter = new import_core13.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, 0);
-      const cartesianCenter = new import_core13.Vector3();
-      import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
+      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);
       return {
         cartographicCenter,
         cartesianCenter,
@@ -7139,7 +8403,7 @@ var I3SSource = class {
     }
     console.warn("Extent is not defined in the tileset header");
     return {
-      cartographicCenter: new import_core13.Vector3(),
+      cartographicCenter: new import_core14.Vector3(),
       zoom: 1
     };
   }
@@ -7171,11 +8435,11 @@ var I3SSource = class {
   /**
    * Loads data through injected core APIs so this module stays independent from `@loaders.gl/core`.
    */
-  async loadWithCoreApi(url, options) {
+  async loadWithCoreApi(url, options, loader = this.loader) {
     if (!this.coreApi) {
       throw new Error("I3SSource requires an injected coreApi to load tileset data");
     }
-    return await this.coreApi.load(url, this.loader, options);
+    return await this.coreApi.load(url, loader, options);
   }
   /**
    * Loads data through an injected resolver when present, otherwise through the injected core API.
@@ -7202,11 +8466,11 @@ var I3SSource = class {
   /**
    * Loads tile metadata or content through an injected resolver when present, otherwise through the injected core API.
    */
-  async loadResourceData(url, options) {
+  async loadResourceData(url, options, loader = this.loader) {
     if (this.resolver) {
-      return await this.resolver.loadResource(url, this.loader, options);
+      return await this.resolver.loadResource(url, loader, options);
     }
-    return await this.loadWithCoreApi(url, options);
+    return await this.loadWithCoreApi(url, options, loader);
   }
   /** Transform one I3S header bound after target options and elevation providers are available. */
   async transformTileHeader(header) {
@@ -7230,6 +8494,9 @@ var I3SSource = class {
     };
   }
 };
+function getI3SContentLoader(loader) {
+  return loader.contentLoader || loader;
+}
 function isTilesetRequest2(input) {
   return Boolean(input && typeof input === "object" && "url" in input && "loader" in input && !("type" in input));
 }
@@ -8456,7 +9723,7 @@ function isAbortError3(error) {
 }
 
 // dist/point-cloud/point-cloud-tileset.js
-var import_core14 = require("@math.gl/core");
+var import_core15 = require("@math.gl/core");
 var import_culling6 = require("@math.gl/culling");
 
 // dist/point-cloud/point-cloud-tile.js
@@ -8620,7 +9887,7 @@ var PointCloudTileset = class {
     const viewState = await ((_b = (_a = this.dataSource).getViewState) == null ? void 0 : _b.call(_a));
     this.boundingVolume = (viewState == null ? void 0 : viewState.boundingVolume) || this.root.boundingVolume;
     const center = (viewState == null ? void 0 : viewState.cartographicCenter) || this.root.boundingVolume.center;
-    this.cartographicCenter = new import_core14.Vector3(center);
+    this.cartographicCenter = new import_core15.Vector3(center);
     this.zoom = (viewState == null ? void 0 : viewState.zoom) || this.estimateZoom(this.boundingVolume);
   }
   /**