@loaders.gl/tiles 5.0.0-alpha.2 → 5.0.0-alpha.4

package/dist/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   I3SSource: () => I3SSource,
+  I3SSpatialTransformer: () => I3SSpatialTransformer,
   ImageSet: () => ImageSet,
   IndexedArchiveTilesetSource: () => IndexedArchiveTilesetSource,
   LOD_METRIC_TYPE: () => LOD_METRIC_TYPE,
@@ -31,6 +32,7 @@ __export(index_exports, {
   STRATEGY_NEVER: () => STRATEGY_NEVER,
   STRATEGY_REPLACE: () => STRATEGY_REPLACE,
   SharedTile2DHeader: () => SharedTile2DHeader,
+  SpatialCoordinateTransformer: () => SpatialCoordinateTransformer,
   TILESET_TYPE: () => TILESET_TYPE,
   TILE_CONTENT_STATE: () => TILE_CONTENT_STATE,
   TILE_REFINEMENT: () => TILE_REFINEMENT,
@@ -41,13 +43,24 @@ __export(index_exports, {
   Tileset3D: () => Tileset3D,
   TilesetCache: () => TilesetCache,
   TilesetTraverser: () => TilesetTraverser,
+  applyTilesetSpatialOptions: () => applyTilesetSpatialOptions,
   calculateTransformProps: () => calculateTransformProps,
   createBoundingVolume: () => createBoundingVolume,
   createImplicitSubtreeReference: () => createImplicitSubtreeReference,
+  createTilesetSpatialReference: () => createTilesetSpatialReference,
+  get3DTilesSpatialReference: () => get3DTilesSpatialReference,
   getFrameState: () => getFrameState,
+  getGeoidModel: () => getGeoidModel,
+  getI3SSpatialReference: () => getI3SSpatialReference,
   getLodStatus: () => getLodStatus,
+  getSpatialCoordinateFrame: () => getSpatialCoordinateFrame,
   isTileset3DSource: () => isTileset3DSource,
+  markTilesetSpatialReferenceTransformed: () => markTilesetSpatialReferenceTransformed,
   materializeImplicitSubtree: () => materializeImplicitSubtree,
+  registerGeoidModel: () => registerGeoidModel,
+  registerGeoidModelFromPgm: () => registerGeoidModelFromPgm,
+  registerSpatialCrs: () => registerSpatialCrs,
+  registerSpatialDatumGrid: () => registerSpatialDatumGrid,
   replaceImplicitUrlTemplate: () => replaceImplicitUrlTemplate
 });
 module.exports = __toCommonJS(index_exports);
@@ -212,6 +225,232 @@ var RequestScheduler = class {
   }
 };
 
+// ../loader-utils/src/lib/request-utils/request-cache.ts
+var DEFAULT_MAX_ENTRIES = Number.POSITIVE_INFINITY;
+var DEFAULT_MAX_BYTES = Number.POSITIVE_INFINITY;
+var RequestCache = class {
+  /** Maximum number of settled entries retained by this cache. */
+  maxEntries;
+  /** Maximum estimated bytes retained by this cache. */
+  maxBytes;
+  getByteLength;
+  onRemove;
+  entries = /* @__PURE__ */ new Map();
+  retainedByteLength = 0;
+  /** Creates a request cache with optional entry and byte limits. */
+  constructor(props = {}) {
+    this.maxEntries = validateLimit(props.maxEntries, DEFAULT_MAX_ENTRIES, "maxEntries");
+    this.maxBytes = validateLimit(props.maxBytes, DEFAULT_MAX_BYTES, "maxBytes");
+    this.getByteLength = props.getByteLength || (() => 0);
+    this.onRemove = props.onRemove;
+  }
+  /** Number of pending and settled entries currently tracked. */
+  get size() {
+    return this.entries.size;
+  }
+  /** Number of requests that have not settled. */
+  get pendingSize() {
+    let pendingSize = 0;
+    for (const entry of this.entries.values()) {
+      pendingSize += entry.pending ? 1 : 0;
+    }
+    return pendingSize;
+  }
+  /** Estimated bytes retained by settled entries. */
+  get byteLength() {
+    return this.retainedByteLength;
+  }
+  /** Returns a cached request and updates its LRU position. */
+  get(key, signal) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    this.touch(key, entry);
+    return this.waitForEntry(key, entry, signal);
+  }
+  /** Returns whether a pending or settled entry exists without updating its LRU position. */
+  has(key) {
+    return this.entries.has(key);
+  }
+  /** Stores an already available value and returns it. */
+  set(key, value) {
+    this.removeEntry(key, "replace");
+    const byteLength = getValidByteLength(this.getByteLength(value));
+    const entry = {
+      promise: Promise.resolve(value),
+      pending: false,
+      waiterCount: 0,
+      byteLength
+    };
+    this.entries.set(key, entry);
+    this.retainedByteLength += byteLength;
+    this.trim();
+    return value;
+  }
+  /**
+   * Returns a cached value or starts one shared request.
+   *
+   * The loader receives a cache-owned abort signal. One caller aborting only rejects that caller;
+   * the shared request is cancelled when no waiters remain.
+   */
+  getOrLoad(key, load, signal) {
+    const cached = this.get(key, signal);
+    if (cached) {
+      return cached;
+    }
+    if (signal == null ? void 0 : signal.aborted) {
+      return Promise.reject(createAbortError());
+    }
+    const controller = new AbortController();
+    let resolveRequest;
+    let rejectRequest;
+    const promise = new Promise((resolve2, reject) => {
+      resolveRequest = resolve2;
+      rejectRequest = reject;
+    });
+    const entry = {
+      promise,
+      controller,
+      pending: true,
+      waiterCount: 0,
+      byteLength: 0
+    };
+    this.entries.set(key, entry);
+    void entry.promise.then(
+      (value) => this.handleLoadedValue(key, entry, value),
+      () => this.handleLoadError(key, entry)
+    );
+    try {
+      void Promise.resolve(load(controller.signal)).then(resolveRequest, rejectRequest);
+    } catch (error) {
+      rejectRequest(error);
+    }
+    return this.waitForEntry(key, entry, signal);
+  }
+  /** Removes one cached or pending request. */
+  delete(key) {
+    return this.removeEntry(key, "delete");
+  }
+  /** Aborts pending requests and removes every entry. */
+  clear() {
+    for (const key of Array.from(this.entries.keys())) {
+      this.removeEntry(key, "clear");
+    }
+  }
+  handleLoadedValue(key, entry, value) {
+    if (this.entries.get(key) !== entry) {
+      return;
+    }
+    entry.pending = false;
+    entry.controller = void 0;
+    try {
+      entry.byteLength = getValidByteLength(this.getByteLength(value));
+    } catch {
+      this.removeEntry(key, "error");
+      return;
+    }
+    this.retainedByteLength += entry.byteLength;
+    this.trim();
+  }
+  handleLoadError(key, entry) {
+    var _a;
+    if (this.entries.get(key) === entry) {
+      this.removeEntry(key, ((_a = entry.controller) == null ? void 0 : _a.signal.aborted) ? "abort" : "error");
+    }
+  }
+  waitForEntry(key, entry, signal) {
+    if (signal == null ? void 0 : signal.aborted) {
+      return Promise.reject(createAbortError());
+    }
+    if (!entry.pending) {
+      return entry.promise;
+    }
+    entry.waiterCount++;
+    return new Promise((resolve2, reject) => {
+      let waiting = true;
+      const finishWaiting = () => {
+        if (!waiting) return;
+        waiting = false;
+        signal == null ? void 0 : signal.removeEventListener("abort", handleAbort);
+        entry.waiterCount--;
+      };
+      const handleAbort = () => {
+        if (!waiting) return;
+        finishWaiting();
+        reject(createAbortError());
+        if (entry.pending && entry.waiterCount === 0 && this.entries.get(key) === entry) {
+          this.removeEntry(key, "abort");
+        }
+      };
+      signal == null ? void 0 : signal.addEventListener("abort", handleAbort, { once: true });
+      void entry.promise.then(
+        (value) => {
+          if (!waiting) return;
+          finishWaiting();
+          resolve2(value);
+        },
+        (error) => {
+          if (!waiting) return;
+          finishWaiting();
+          reject(error);
+        }
+      );
+    });
+  }
+  touch(key, entry) {
+    this.entries.delete(key);
+    this.entries.set(key, entry);
+  }
+  trim() {
+    let settledEntryCount = this.entries.size - this.pendingSize;
+    if (settledEntryCount <= this.maxEntries && this.retainedByteLength <= this.maxBytes) {
+      return;
+    }
+    for (const [key, entry] of this.entries) {
+      if (!entry.pending) {
+        this.removeEntry(key, "evict");
+        settledEntryCount--;
+      }
+      if (settledEntryCount <= this.maxEntries && this.retainedByteLength <= this.maxBytes) {
+        break;
+      }
+    }
+  }
+  removeEntry(key, reason) {
+    var _a, _b;
+    const entry = this.entries.get(key);
+    if (!entry) {
+      return false;
+    }
+    this.entries.delete(key);
+    this.retainedByteLength -= entry.byteLength;
+    if (entry.pending) {
+      (_a = entry.controller) == null ? void 0 : _a.abort();
+    }
+    (_b = this.onRemove) == null ? void 0 : _b.call(this, key, reason);
+    return true;
+  }
+};
+function createAbortError() {
+  const error = new Error("Request aborted");
+  error.name = "AbortError";
+  return error;
+}
+function validateLimit(value, fallback, name) {
+  const limit = value ?? fallback;
+  if (limit < 0 || Number.isNaN(limit)) {
+    throw new Error(`${name} must be a non-negative number`);
+  }
+  return limit;
+}
+function getValidByteLength(value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error("Request cache entry byte length must be a non-negative finite number");
+  }
+  return value;
+}
+
 // ../loader-utils/src/lib/request-utils/range-request-scheduler.ts
 var import_stats2 = require("@probe.gl/stats");
 var RANGE_STATS_KEYS = {
@@ -269,7 +508,7 @@ var RangeRequestScheduler = class {
       return Promise.reject(new Error("Byte range length cannot be negative"));
     }
     if ((_a = request.signal) == null ? void 0 : _a.aborted) {
-      return Promise.reject(createAbortError());
+      return Promise.reject(createAbortError2());
     }
     if (request.length === 0) {
       return Promise.resolve(new ArrayBuffer(0));
@@ -484,7 +723,7 @@ var RangeRequestScheduler = class {
       return;
     }
     request.settled = true;
-    request.reject(createAbortError());
+    request.reject(createAbortError2());
     this.trackEvent({
       type: "abort",
       sourceId: request.sourceId,
@@ -714,7 +953,7 @@ function getTimestamp() {
   var _a;
   return ((_a = globalThis.performance) == null ? void 0 : _a.now()) ?? Date.now();
 }
-function createAbortError() {
+function createAbortError2() {
   if (typeof DOMException !== "undefined") {
     return new DOMException("Request aborted", "AbortError");
   }
@@ -1216,7 +1455,7 @@ var HttpFile = class _HttpFile {
   async open(signal) {
     this.assertOpen();
     if (signal == null ? void 0 : signal.aborted) {
-      const error = createAbortError2();
+      const error = createAbortError3();
       this.transport.trackFailure(error);
       throw error;
     }
@@ -1258,7 +1497,7 @@ var HttpFile = class _HttpFile {
   async read(offset = 0, length = 0, signal) {
     this.assertOpen();
     if (signal == null ? void 0 : signal.aborted) {
-      const error = createAbortError2();
+      const error = createAbortError3();
       this.transport.trackFailure(error);
       throw error;
     }
@@ -1366,7 +1605,7 @@ function validateRange(offset, length, byteLength) {
     throw new Error("HTTP byte range extends beyond the end of the file");
   }
 }
-function createAbortError2() {
+function createAbortError3() {
   if (typeof DOMException !== "undefined") {
     return new DOMException("Request aborted", "AbortError");
   }
@@ -1379,12 +1618,12 @@ function waitForPromiseWithSignal(promise, signal) {
     return promise;
   }
   if (signal.aborted) {
-    return Promise.reject(createAbortError2());
+    return Promise.reject(createAbortError3());
   }
   return new Promise((resolve2, reject) => {
     const abortListener = () => {
       signal.removeEventListener("abort", abortListener);
-      reject(createAbortError2());
+      reject(createAbortError3());
     };
     signal.addEventListener("abort", abortListener, { once: true });
     promise.then(
@@ -1684,6 +1923,7 @@ function getFrameState(viewport, frameNumber, options = {}) {
     topDownViewport,
     height,
     cullingVolume,
+    clippingPlanes: viewport.clippingPlanes,
     frameNumber,
     // TODO: This can be the same between updates, what number is unique for between updates?
     sseDenominator: 1.15,
@@ -2024,6 +2264,177 @@ function calculateTileRequestPriority(parameters) {
   return progressiveResolutionDigits + foveatedSortingDigits + preferredSortingDigits;
 }
 
+// dist/spatial/spatial-types.js
+var import_crs = require("@math.gl/crs");
+
+// dist/spatial/get-spatial-coordinate-frame.js
+var GEOGRAPHIC_CRS = "EPSG:4326";
+var 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;
+}
+function getSpatialCoordinateFrame(definition) {
+  var _a, _b;
+  if (typeof definition === "string") {
+    const normalized = normalizeCrsIdentifier(definition);
+    if (normalized === GEOCENTRIC_CRS || /^GEOCCS\s*[\[(]/.test(normalized)) {
+      return "geocentric";
+    }
+    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";
+    }
+    return "projected";
+  }
+  const projJsonDefinition = definition;
+  if (projJsonDefinition.type === "BoundCRS" && projJsonDefinition.source_crs) {
+    return getSpatialCoordinateFrame(projJsonDefinition.source_crs);
+  }
+  if (projJsonDefinition.type === "CompoundCRS" && ((_a = projJsonDefinition.components) == null ? void 0 : _a[0])) {
+    return getSpatialCoordinateFrame(projJsonDefinition.components[0]);
+  }
+  if (String(projJsonDefinition.type).includes("Projected")) {
+    return "projected";
+  }
+  if (String(projJsonDefinition.type).includes("Geographic")) {
+    return "geographic";
+  }
+  if (String(projJsonDefinition.type).includes("Geodetic")) {
+    return ((_b = projJsonDefinition.coordinate_system) == null ? void 0 : _b.subtype) === "Cartesian" ? "geocentric" : "geographic";
+  }
+  return "projected";
+}
+
+// dist/spatial/spatial-types.js
+function createTilesetSpatialReference(discovered, options = {}) {
+  const hasSourceCrsOverride = options.sourceCrs !== void 0;
+  const sourceCrs = options.sourceCrs || discovered.sourceCrs;
+  const outputCoordinates = options.outputCoordinates || "auto";
+  const targetCrs = options.targetCrs || (outputCoordinates === "ecef" ? "EPSG:4978" : void 0);
+  const targetHeightReference = options.targetHeightReference || "native";
+  const verticalUnitScale = discovered.verticalUnitScale ?? 1;
+  const elevationUnitScale = discovered.elevationUnitScale ?? 1;
+  const elevationOffset = discovered.elevationOffset || 0;
+  const requiresSurface = discovered.elevationMode === "onTheGround" || discovered.elevationMode === "relativeToGround" || discovered.elevationMode === "relativeToScene";
+  const hasElevationProvider = discovered.elevationMode === "relativeToScene" ? Boolean(options.sceneElevationProvider) : !requiresSurface || Boolean(options.terrainElevationProvider);
+  const hasFormatVerticalOperation = verticalUnitScale !== 1 || elevationUnitScale !== 1 || discovered.elevationMode !== void 0 && (requiresSurface || discovered.elevationMode === "absoluteHeight" && elevationOffset !== 0);
+  const needsHeightTransform = targetHeightReference !== "native" && targetHeightReference !== discovered.heightReference;
+  const hasRequestedTransform = Boolean(targetCrs) || targetHeightReference !== "native" || outputCoordinates !== "auto" || hasFormatVerticalOperation;
+  const hasRequiredTarget = outputCoordinates !== "target-crs" || Boolean(targetCrs);
+  const hasHeightMetadata = !needsHeightTransform || (discovered.heightReference || "unknown") !== "unknown";
+  const hasVerticalUnits = Number.isFinite(verticalUnitScale) && verticalUnitScale > 0 && Number.isFinite(elevationUnitScale) && elevationUnitScale > 0;
+  const canTransform = Boolean(sourceCrs) && hasRequestedTransform && hasRequiredTarget && hasHeightMetadata && hasVerticalUnits && hasElevationProvider && outputCoordinates !== "local-enu";
+  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)({
+    crs: sourceCrs ? {
+      state: sourceCrsState === "default" ? "default" : "explicit",
+      definition: sourceCrs,
+      representation: !hasSourceCrsOverride && discovered.sourceCrsRepresentation || (0, import_crs.inferCRSRepresentation)(sourceCrs),
+      provenance,
+      alternatives: hasSourceCrsOverride ? void 0 : discovered.sourceCrsAlternatives
+    } : {
+      state: sourceCrsState === "unknown" ? "unknown" : "absent",
+      provenance
+    },
+    vertical: discovered.verticalCrs ? {
+      state: "explicit",
+      definition: discovered.verticalCrs,
+      representation: (0, import_crs.inferCRSRepresentation)(discovered.verticalCrs),
+      provenance: discovered.provenance || "metadata"
+    } : void 0,
+    coordinateEpoch: options.coordinateEpoch ?? discovered.coordinateEpoch,
+    coordinateFrame,
+    coordinateOrder: getCoordinateOrder(discovered.axisOrder),
+    units: hasSourceCrsOverride ? void 0 : discovered.units
+  });
+  const normalizedSourceCrs = getKnownCRSDefinition(spatialReference.crs);
+  const normalizedVerticalCrs = spatialReference.vertical ? getKnownCRSDefinition(spatialReference.vertical) : void 0;
+  const normalizedTargetCrs = targetCrs ? cloneReadonlyCRSDefinition(targetCrs) : void 0;
+  return Object.freeze({
+    ...spatialReference,
+    sourceCrs: normalizedSourceCrs,
+    verticalCrs: normalizedVerticalCrs,
+    verticalUnitScale,
+    coordinateEpoch: options.coordinateEpoch ?? discovered.coordinateEpoch,
+    heightReference: discovered.heightReference || "unknown",
+    elevationMode: discovered.elevationMode,
+    elevationOffset: discovered.elevationOffset,
+    elevationUnit: discovered.elevationUnit,
+    elevationUnitScale,
+    coordinateFrame: coordinateFrame || "unknown",
+    axisOrder: discovered.axisOrder || "unknown",
+    provenance,
+    targetCrs: normalizedTargetCrs,
+    targetHeightReference,
+    outputCoordinates,
+    status: hasRequestedTransform ? canTransform ? "transformable" : "unresolved" : "native",
+    warnings: Object.freeze([...discovered.warnings || []])
+  });
+}
+function applyTilesetSpatialOptions(discovered, options = {}) {
+  return createTilesetSpatialReference({
+    sourceCrs: discovered == null ? void 0 : discovered.sourceCrs,
+    sourceCrsState: discovered == null ? void 0 : discovered.crs.state,
+    sourceCrsRepresentation: (discovered == null ? void 0 : discovered.crs.state) === "explicit" || (discovered == null ? void 0 : discovered.crs.state) === "default" ? discovered.crs.representation : void 0,
+    sourceCrsAlternatives: (discovered == null ? void 0 : discovered.crs.state) === "explicit" || (discovered == null ? void 0 : discovered.crs.state) === "default" ? discovered.crs.alternatives : void 0,
+    verticalCrs: discovered == null ? void 0 : discovered.verticalCrs,
+    units: discovered == null ? void 0 : discovered.units,
+    verticalUnitScale: discovered == null ? void 0 : discovered.verticalUnitScale,
+    coordinateEpoch: discovered == null ? void 0 : discovered.coordinateEpoch,
+    heightReference: discovered == null ? void 0 : discovered.heightReference,
+    elevationMode: discovered == null ? void 0 : discovered.elevationMode,
+    elevationOffset: discovered == null ? void 0 : discovered.elevationOffset,
+    elevationUnit: discovered == null ? void 0 : discovered.elevationUnit,
+    elevationUnitScale: discovered == null ? void 0 : discovered.elevationUnitScale,
+    coordinateFrame: discovered == null ? void 0 : discovered.coordinateFrame,
+    axisOrder: discovered == null ? void 0 : discovered.axisOrder,
+    provenance: discovered == null ? void 0 : discovered.provenance,
+    warnings: discovered == null ? void 0 : discovered.warnings
+  }, options);
+}
+function getKnownCRSDefinition(reference) {
+  return reference.state === "explicit" || reference.state === "default" ? reference.definition : void 0;
+}
+function cloneReadonlyCRSDefinition(definition) {
+  const spatialReference = (0, import_crs.createSpatialReference)({
+    crs: {
+      state: "explicit",
+      definition,
+      representation: (0, import_crs.inferCRSRepresentation)(definition),
+      provenance: "caller-override"
+    }
+  });
+  const clonedDefinition = getKnownCRSDefinition(spatialReference.crs);
+  if (!clonedDefinition) {
+    throw new Error("Failed to normalize a known target CRS definition");
+  }
+  return clonedDefinition;
+}
+function getCoordinateOrder(axisOrder) {
+  switch (axisOrder) {
+    case "xy":
+      return ["x", "y"];
+    case "yx":
+      return ["y", "x"];
+    case "xyz":
+      return ["x", "y", "z"];
+    default:
+      return [];
+  }
+}
+function markTilesetSpatialReferenceTransformed(spatialReference) {
+  if (spatialReference.status !== "transformable" && spatialReference.status !== "transformed") {
+    throw new Error("Only a transformable spatial reference can be marked as transformed");
+  }
+  return Object.freeze({ ...spatialReference, status: "transformed" });
+}
+
 // dist/tileset-3d/common/tileset-source.js
 function isTileset3DSource(value) {
   return Boolean(value && typeof value === "object" && "initialize" in value && "getRootTileset" in value && "initializeTileHeaders" in value && "loadTileContent" in value);
@@ -2083,6 +2494,7 @@ var DEFAULT_PROPS3 = {
   foveatedInterpolationCallback: interpolateLinearly,
   foveatedTimeDelay: 0.2,
   maximumScreenSpaceError: 8,
+  skipLevelOfDetail: false,
   dynamicScreenSpaceError: true,
   dynamicScreenSpaceErrorDensity: 2e-4,
   dynamicScreenSpaceErrorFactor: 24,
@@ -2094,7 +2506,8 @@ var DEFAULT_PROPS3 = {
   loadOptions: { fetch: {} },
   attributions: [],
   basePath: "",
-  i3s: {}
+  i3s: {},
+  spatial: {}
 };
 var TILES_TOTAL = "Tiles In Tileset(s)";
 var TILES_IN_MEMORY = "Tiles In Memory";
@@ -2125,6 +2538,18 @@ var Tileset3D = class {
   root = null;
   roots = {};
   asset = {};
+  /** Inline metadata schema declared by the source tileset, when present. */
+  schema = null;
+  /** External metadata schema URI declared by the source tileset, when present. */
+  schemaUri = null;
+  /** Metadata groups declared by the source tileset, in source order. */
+  groups = [];
+  /** Tileset-wide metadata entity, preserved without property-table decoding. */
+  metadata = null;
+  /** Tileset statistics metadata, preserved for application-level inspection. */
+  statistics = null;
+  /** Normalized source and target coordinate reference system metadata. */
+  spatialReference = createTilesetSpatialReference({});
   description = "";
   properties;
   extras = null;
@@ -2209,6 +2634,10 @@ var Tileset3D = class {
     this.memoryAdjustedScreenSpaceError = this.options.maximumScreenSpaceError;
     this._cacheBytes = cacheBytes;
     this._maximumCacheOverflowBytes = maximumCacheOverflowBytes;
+    const metadata = this._getSourceMetadata();
+    if (metadata) {
+      this.spatialReference = applyTilesetSpatialOptions(metadata.spatialReference, this.options.spatial);
+    }
     this.stats = new import_stats3.Stats({ id: this.url });
     this._initializeStats();
     this.tilesetInitializationPromise = this._initializeTileSet();
@@ -2527,10 +2956,13 @@ var Tileset3D = class {
     for (const tile of this.selectedTiles) {
       if (tile.contentAvailable && tile.content) {
         tilesRenderable++;
-        if (tile.content.pointCount) {
-          pointsRenderable += tile.content.pointCount;
-        } else {
-          pointsRenderable += tile.content.vertexCount;
+        const contents = tile.contents.length ? tile.contents : [tile.content];
+        for (const content of contents) {
+          if (content.pointCount) {
+            pointsRenderable += content.pointCount;
+          } else {
+            pointsRenderable += content.vertexCount || 0;
+          }
         }
       }
     }
@@ -2540,20 +2972,21 @@ var Tileset3D = class {
     this.stats.get(MAXIMUM_SSE).count = this.memoryAdjustedScreenSpaceError;
   }
   async _initializeTileSet() {
-    var _a;
+    var _a, _b, _c;
     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") {
+      if (((_a = initialMetadata == null ? void 0 : initialMetadata.tileset) == null ? void 0 : _a.root) && typeof initialMetadata.tileset.root.then !== "function" && !this.source.prepareTileset) {
         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));
       if (!this.root) {
         this.root = this._initializeTileHeaders(metadata.tileset, null);
       }
@@ -2729,6 +3162,14 @@ var Tileset3D = class {
     this.refine = metadata.refine;
     this.contentFormats = this.source.contentFormats;
     this.asset = this.source.asset || this.asset;
+    const tileset = metadata.tileset;
+    this.schema = tileset.schema || null;
+    this.schemaUri = tileset.schemaUri || null;
+    this.groups = tileset.groups || [];
+    this.metadata = tileset.metadata || null;
+    this.statistics = tileset.statistics ?? null;
+    const spatialReference = applyTilesetSpatialOptions(metadata.spatialReference, this.options.spatial);
+    this.spatialReference = preserveTransformedSpatialReference(this.spatialReference, spatialReference);
     this.properties = this.source.properties ?? this.properties;
     this.extras = this.source.extras ?? this.extras;
     if ((_a = this.options.attributions) == null ? void 0 : _a.length) {
@@ -2762,6 +3203,9 @@ var Tileset3D = class {
     }
   }
 };
+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/indexed-archive-tileset-source.js
 var IndexedArchiveTilesetSource = class {
@@ -2888,19 +3332,13 @@ function defined(x) {
 }
 var scratchPoint = new import_core6.Vector3();
 var scratchScale = new import_core6.Vector3();
-var scratchNorthWest = new import_core6.Vector3();
-var scratchSouthEast = new import_core6.Vector3();
-var scratchCenter2 = new import_core6.Vector3();
-var scratchXAxis = new import_core6.Vector3();
-var scratchYAxis = new import_core6.Vector3();
-var scratchZAxis = new import_core6.Vector3();
 function createBoundingVolume(boundingVolumeHeader, transform, result) {
   assert(boundingVolumeHeader, "3D Tile: boundingVolume must be defined");
   if (boundingVolumeHeader.box) {
     return createBox(boundingVolumeHeader.box, transform, result);
   }
   if (boundingVolumeHeader.region) {
-    return createObbFromRegion(boundingVolumeHeader.region);
+    return (0, import_geospatial4.makeOBBFromRegion)(boundingVolumeHeader.region);
   }
   if (boundingVolumeHeader.sphere) {
     return createSphere(boundingVolumeHeader.sphere, transform, result);
@@ -2978,22 +3416,6 @@ function createSphere(sphere, transform, result) {
   }
   return new import_culling3.BoundingSphere(center, radius);
 }
-function createObbFromRegion(region) {
-  const [west, south, east, north, minHeight, maxHeight] = region;
-  const northWest = import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([(0, import_core6.degrees)(west), (0, import_core6.degrees)(north), minHeight], scratchNorthWest);
-  const southEast = import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([(0, import_core6.degrees)(east), (0, import_core6.degrees)(south), maxHeight], scratchSouthEast);
-  const centerInCartesian = new import_core6.Vector3().addVectors(northWest, southEast).multiplyByScalar(0.5);
-  import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(centerInCartesian, scratchCenter2);
-  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([(0, import_core6.degrees)(east), scratchCenter2[1], scratchCenter2[2]], scratchXAxis);
-  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([scratchCenter2[0], (0, import_core6.degrees)(north), scratchCenter2[2]], scratchYAxis);
-  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([scratchCenter2[0], scratchCenter2[1], maxHeight], scratchZAxis);
-  return createBox([
-    ...centerInCartesian,
-    ...scratchXAxis.subtract(centerInCartesian),
-    ...scratchYAxis.subtract(centerInCartesian),
-    ...scratchZAxis.subtract(centerInCartesian)
-  ], new import_core6.Matrix4());
-}
 function orientedBoundingBoxToCartographicBounds(boundingVolume) {
   const result = emptyCartographicBounds();
   const { halfAxes } = boundingVolume;
@@ -3078,19 +3500,32 @@ function getLodStatus(tile, frameState) {
   if (screenSize < 2) {
     return "OUT";
   }
-  if (!tile.header.children || screenSize <= tile.lodMetricValue) {
+  if (!tile.header.children) {
     return "DRAW";
-  } else if (tile.header.children) {
-    return "DIG";
   }
-  return "OUT";
+  switch (tile.lodMetricType) {
+    case "screenSpaceRelative": {
+      const viewportHeight = frameState.topDownViewport.height || 1;
+      return screenSize / viewportHeight <= tile.lodMetricValue ? "DRAW" : "DIG";
+    }
+    case "distanceRangeFromDefaultCamera":
+      return tile.distanceToTile(frameState) >= tile.lodMetricValue ? "DRAW" : "DIG";
+    case "maxScreenThresholdSQ": {
+      const diameterThreshold = Math.sqrt(tile.lodMetricValue / (Math.PI * 0.25));
+      return screenSize <= diameterThreshold ? "DRAW" : "DIG";
+    }
+    case "maxScreenThreshold":
+    default:
+      return screenSize <= tile.lodMetricValue ? "DRAW" : "DIG";
+  }
 }
 function getProjectedRadius(tile, frameState) {
   const { topDownViewport: viewport } = frameState;
-  const mbsLat = tile.header.mbs[1];
-  const mbsLon = tile.header.mbs[0];
-  const mbsZ = tile.header.mbs[2];
-  const mbsR = tile.header.mbs[3];
+  const mbs = tile.header.i3sLodMbs || tile.header.mbs;
+  const mbsLat = mbs[1];
+  const mbsLon = mbs[0];
+  const mbsZ = mbs[2];
+  const mbsR = mbs[3];
   const mbsCenterCartesian = [...tile.boundingVolume.center];
   const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
   import_geospatial5.Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, cameraPositionCartesian);
@@ -3341,7 +3776,7 @@ var TilesetTraverser = class {
         this.selectTile(tile, frameState);
       } else if (tile.refine === TILE_REFINEMENT.REPLACE) {
         this.loadTile(tile, frameState);
-        if (stoppedRefining) {
+        if (stoppedRefining || this.options.skipLevelOfDetail) {
           this.selectTile(tile, frameState);
         }
       }
@@ -3406,7 +3841,7 @@ var TilesetTraverser = class {
   }
   // tile to render in the browser
   selectTile(tile, frameState) {
-    if (this.shouldSelectTile(tile)) {
+    if (this.shouldSelectTile(tile, frameState)) {
       tile._selectedFrame = frameState.frameNumber;
       this.selectedTiles[tile.id] = tile;
     }
@@ -3456,8 +3891,13 @@ var TilesetTraverser = class {
   shouldLoadTile(tile) {
     return tile.hasUnloadedContent || tile.contentExpired;
   }
-  shouldSelectTile(tile) {
-    return tile.contentAvailable && !this.options.skipLevelOfDetail;
+  /**
+   * Returns whether a tile's content is available and visible for rendering.
+   * @param tile Tile considered for rendering.
+   * @param frameState Current culling state.
+   */
+  shouldSelectTile(tile, frameState) {
+    return tile.contentAvailable && tile.contentVisibility(frameState) !== "outside";
   }
   /** Decide if tile LoD (level of detail) is not sufficient under current viewport */
   shouldRefine(tile, frameState, useParentMetric = false) {
@@ -3529,6 +3969,35 @@ var TilesetTraverser = class {
 
 // dist/tileset-3d/common/tile-3d.js
 var scratchVector2 = new import_core8.Vector3();
+function getContentVisibility(contentVolumes, fallbackVolume, cullingVolume2, visibilityPlaneMask, clippingPlanes = []) {
+  const volumes = contentVolumes.length ? contentVolumes : [fallbackVolume];
+  let visibleVolume = false;
+  let intersectingVolume = false;
+  for (const contentVolume of volumes) {
+    let visibility = "inside";
+    if (visibilityPlaneMask !== import_culling4.CullingVolume.MASK_INSIDE) {
+      visibility = cullingVolume2.computeVisibility(contentVolume);
+      if (visibility === "outside") {
+        continue;
+      }
+    }
+    let clipped = false;
+    for (const clippingPlane of clippingPlanes) {
+      if (contentVolume.intersectPlane(clippingPlane) === "outside") {
+        clipped = true;
+        break;
+      }
+    }
+    if (!clipped) {
+      visibleVolume = true;
+      intersectingVolume = intersectingVolume || visibility === "intersecting";
+    }
+  }
+  if (!visibleVolume) {
+    return "outside";
+  }
+  return intersectingVolume ? "intersecting" : "inside";
+}
 function defined2(x) {
   return x !== void 0 && x !== null;
 }
@@ -3542,6 +4011,8 @@ var Tile3D = class {
   refine;
   type;
   contentUrl;
+  /** Resolved render-content URLs in source order; empty for contentless tiles. */
+  contentUrls = [];
   /** Different refinement algorithms used by I3S and 3D tiles */
   lodMetricType = "geometricError";
   /**
@@ -3561,6 +4032,17 @@ var Tile3D = class {
    * not the content's metadata in the tileset JSON file.
    */
   content = null;
+  /** Loaded payloads in the same order as {@link contentUrls}; `content` remains the primary payload. */
+  contents = [];
+  /**
+   * Metadata entity attached to this tile in the source tileset, if present.
+   *
+   * This is the raw 3D Tiles metadata reference. The generic tiles runtime preserves it without
+   * decoding schema classes or binary property tables.
+   */
+  metadata = null;
+  /** Raw metadata entities attached to tile contents, in content source order. */
+  contentMetadata = [];
   contentState = TILE_CONTENT_STATE.UNLOADED;
   gpuMemoryUsageInBytes = 0;
   /** The tile's children - an array of Tile3D objects. */
@@ -3602,7 +4084,22 @@ var Tile3D = class {
   _visibilityPlaneMask;
   _visible = void 0;
   _contentBoundingVolume;
+  _contentBoundingVolumes = [];
+  /** Source content-volume headers retained after render content is unloaded. */
+  _contentBoundingVolumeHeaders = [];
   _viewerRequestVolume;
+  /** Bounding volume used to cull the tile's first renderable content entry. */
+  get contentBoundingVolume() {
+    return this._contentBoundingVolume;
+  }
+  /** All transformed render-content bounding volumes, including tile-volume fallbacks. */
+  get contentBoundingVolumes() {
+    return this._contentBoundingVolumes;
+  }
+  /** Bounding volume that limits when this tile may be requested, when declared. */
+  get viewerRequestVolume() {
+    return this._viewerRequestVolume;
+  }
   _initialTransform = new import_core8.Matrix4();
   // Used by traverser, cannot be marked private
   _priority = 0;
@@ -3643,6 +4140,10 @@ var Tile3D = class {
     this.refine = this._getRefine(header.refine);
     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.childrenState = header.implicitSubtree ? "unloaded" : "ready";
     this._initializeLodMetric(header);
     this._initializeTransforms(header);
@@ -3774,7 +4275,8 @@ var Tile3D = class {
    * Memory usage of tile on GPU
    */
   _getGpuMemoryUsageInBytes() {
-    return this.content.gpuMemoryUsageInBytes || this.content.byteLength || 0;
+    const contents = this.contents.length ? this.contents : [this.content];
+    return contents.reduce((total, content) => total + ((content == null ? void 0 : content.gpuMemoryUsageInBytes) || (content == null ? void 0 : content.byteLength) || 0), 0);
   }
   /**
    * Returns scheduler priority for render-content requests.
@@ -3855,6 +4357,10 @@ var Tile3D = class {
     }
     try {
       const loadResult = await this.tileset.source.loadTileContent(this);
+      if (loadResult.contents) {
+        this.contents = loadResult.contents;
+        this.content = this.contents[0] || null;
+      }
       if (this.tileset.options.contentLoader) {
         await this.tileset.options.contentLoader(this);
       }
@@ -3941,6 +4447,7 @@ var Tile3D = class {
     this.refine = this._getRefine(materializedHeader.refine);
     this.type = materializedHeader.type;
     this.contentUrl = materializedHeader.contentUrl;
+    this.contentUrls = materializedHeader.contentUrls || (materializedHeader.contentUrl ? [materializedHeader.contentUrl] : []);
     this._initializeLodMetric(materializedHeader);
     this._updateLodMetricScale();
     this._initializeBoundingVolumes(this.header);
@@ -3948,9 +4455,12 @@ var Tile3D = class {
   }
   // Unloads the tile's content.
   unloadContent() {
-    if (this.content && this.content.destroy) {
-      this.content.destroy();
+    for (const content of this.contents.length ? this.contents : [this.content]) {
+      if (content && content.destroy) {
+        content.destroy();
+      }
     }
+    this.contents = [];
     this.content = null;
     if (this.header.content && this.header.content.destroy) {
       this.header.content.destroy();
@@ -4038,12 +4548,16 @@ var Tile3D = class {
     const { boundingVolume } = this;
     return cullingVolume2.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);
   }
-  // Assuming the tile's bounding volume intersects the culling volume, determines
-  // whether the tile's content's bounding volume intersects the culling volume.
-  // @param {FrameState} frameState The frame state.
-  // @returns {Intersect} The result of the intersection: the tile's content is completely outside, completely inside, or intersecting the culling volume.
-  contentVisibility() {
-    return true;
+  /**
+   * Determines whether renderable content intersects the view and configured clipping planes.
+   *
+   * Clipping planes are render-only constraints; traversal continues to use the tile volume.
+   *
+   * @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);
   }
   /**
    * Computes the (potentially approximate) distance from the closest point of the tile's bounding volume to the camera.
@@ -4135,15 +4649,18 @@ var Tile3D = class {
   }
   _initializeBoundingVolumes(tileHeader) {
     this._contentBoundingVolume = null;
+    this._contentBoundingVolumeHeaders = [];
     this._viewerRequestVolume = null;
     this._updateBoundingVolume(tileHeader);
   }
   _initializeContent(tileHeader) {
+    var _a;
     this.content = { _tileset: this.tileset, _tile: this };
+    this.contents = [];
     this.hasEmptyContent = true;
     this.contentState = TILE_CONTENT_STATE.UNLOADED;
     this.hasTilesetContent = false;
-    if (tileHeader.contentUrl) {
+    if (tileHeader.contentUrl || ((_a = tileHeader.contentUrls) == null ? void 0 : _a.length)) {
       this.content = null;
       this.hasEmptyContent = false;
     }
@@ -4182,16 +4699,18 @@ var Tile3D = class {
    * `content`.
    */
   _isTileset() {
-    var _a;
-    return ((_a = this.content) == null ? void 0 : _a.shape) === "tileset3d";
+    return (this.contents.length ? this.contents : [this.content]).some((content) => (content == null ? void 0 : content.shape) === "tileset3d");
   }
   _onContentLoaded() {
-    switch (this.content && this.content.type) {
-      case "vctr":
-      case "geom":
-        this.tileset._traverser.disableSkipLevelOfDetail = true;
-        break;
-      default:
+    const contents = this.contents.length ? this.contents : [this.content];
+    for (const content of contents) {
+      switch (content && content.type) {
+        case "vctr":
+        case "geom":
+          this.tileset._traverser.disableSkipLevelOfDetail = true;
+          break;
+        default:
+      }
     }
     if (this._isTileset()) {
       this.hasTilesetContent = true;
@@ -4205,12 +4724,12 @@ var Tile3D = class {
       this._viewerRequestVolume = createBoundingVolume(header.viewerRequestVolume, this.computedTransform, this._viewerRequestVolume);
     }
     const content = header.content;
-    if (!content) {
-      return;
-    }
-    if (content.boundingVolume) {
-      this._contentBoundingVolume = createBoundingVolume(content.boundingVolume, this.computedTransform, this._contentBoundingVolume);
+    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._contentBoundingVolume = this._contentBoundingVolumes[0] || null;
   }
   /**
    * Updates the tile's computed transform, world-space geometric error, and bounding volumes.
@@ -4376,6 +4895,259 @@ function getObbSize(halfAxes) {
   return size;
 }
 
+// dist/spatial/i3s-elevation.js
+var LINEAR_UNIT_TO_METERS = Object.freeze({
+  meter: 1,
+  millimeter: 1e-3,
+  centimeter: 0.01,
+  decimeter: 0.1,
+  kilometer: 1e3,
+  foot: 0.3048,
+  yard: 0.9144,
+  mile: 1609.344,
+  "us-foot": 1200 / 3937,
+  "us-inch": 0.0254000508001016,
+  "us-yard": 3600 / 3937,
+  "us-mile": 6336e3 / 3937,
+  "clarke-foot": 0.3047972654,
+  "clarke-yard": 0.9143917962,
+  "clarke-link": 0.201166195164,
+  "sears-yard": 0.914398414616,
+  "sears-foot": 0.304799471539,
+  "sears-chain": 20.1167651216,
+  "sears-1922-truncated-chain": 20.116756,
+  "benoit-1895-b-chain": 20.1167824944,
+  "indian-yard": 0.914398530744,
+  "indian-1937-yard": 0.91439523,
+  "gold-coast-foot": 0.304799710181
+});
+var LINEAR_UNIT_ALIASES = Object.freeze({
+  m: "meter",
+  metre: "meter",
+  meters: "meter",
+  metres: "meter",
+  mm: "millimeter",
+  millimetre: "millimeter",
+  millimeters: "millimeter",
+  millimetres: "millimeter",
+  cm: "centimeter",
+  centimetre: "centimeter",
+  centimeters: "centimeter",
+  centimetres: "centimeter",
+  dm: "decimeter",
+  decimetre: "decimeter",
+  decimeters: "decimeter",
+  decimetres: "decimeter",
+  km: "kilometer",
+  kilometre: "kilometer",
+  kilometers: "kilometer",
+  kilometres: "kilometer",
+  ft: "foot",
+  feet: "foot",
+  "us-survey-foot": "us-foot",
+  "us-survey-feet": "us-foot",
+  yd: "yard",
+  yards: "yard",
+  mi: "mile",
+  miles: "mile"
+});
+function getI3SLinearUnitScale(unit) {
+  if (!unit) {
+    return void 0;
+  }
+  const normalized = unit.trim().toLowerCase().replaceAll("_", "-");
+  const canonical = LINEAR_UNIT_ALIASES[normalized] || normalized;
+  return LINEAR_UNIT_TO_METERS[canonical];
+}
+function getI3SVerticalUnitScale(heightUnit, zFactor) {
+  if (zFactor !== void 0) {
+    return Number.isFinite(zFactor) && zFactor > 0 ? zFactor : void 0;
+  }
+  return heightUnit ? getI3SLinearUnitScale(heightUnit) : 1;
+}
+
+// dist/spatial/format-spatial-reference.js
+function getI3SSpatialReference(layer) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const spatialReference = layer.spatialReference || ((_a = layer.fullExtent) == null ? void 0 : _a.spatialReference);
+  const sourceCrs = getI3SCrsDefinition(spatialReference);
+  const verticalCrs = ((_b = layer.heightModelInfo) == null ? void 0 : _b.vertCRS) || getI3SVerticalCrsDefinition(spatialReference);
+  const heightModel = (_c = layer.heightModelInfo) == null ? void 0 : _c.heightModel;
+  const verticalUnit = (_d = layer.heightModelInfo) == null ? void 0 : _d.heightUnit;
+  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 units = getI3SCoordinateUnits(coordinateFrame, verticalUnit, layer.ZFactor);
+  const warnings = [];
+  const elevationMode = getI3SElevationMode((_e = layer.elevationInfo) == null ? void 0 : _e.mode);
+  const elevationUnit = layer.elevationInfo ? layer.elevationInfo.unit || "meter" : void 0;
+  const elevationUnitScale = getI3SLinearUnitScale(elevationUnit);
+  if (verticalUnitScale === void 0) {
+    warnings.push(layer.ZFactor !== void 0 ? `I3S ZFactor ${layer.ZFactor} is not a positive finite conversion factor` : `Unsupported I3S vertical unit ${verticalUnit}`);
+  }
+  if (layer.elevationInfo && elevationUnitScale === void 0) {
+    warnings.push(`Unsupported I3S elevation unit ${elevationUnit}`);
+  }
+  if (((_f = layer.elevationInfo) == null ? void 0 : _f.mode) && !elevationMode) {
+    warnings.push(`Unsupported I3S elevation mode ${layer.elevationInfo.mode}`);
+  }
+  if (elevationMode && elevationMode !== "absoluteHeight") {
+    warnings.push(`I3S elevation mode ${elevationMode} requires a terrain or scene elevation provider`);
+  }
+  return createTilesetSpatialReference({
+    sourceCrs,
+    sourceCrsRepresentation: sourceIdentifier !== void 0 ? "identifier" : sourceCrs ? "wkt" : void 0,
+    sourceCrsAlternatives: sourceIdentifier !== void 0 && (spatialReference == null ? void 0 : spatialReference.wkt) ? [{ definition: spatialReference.wkt, representation: "wkt" }] : void 0,
+    verticalCrs,
+    units,
+    verticalUnitScale: verticalUnitScale ?? Number.NaN,
+    heightReference,
+    elevationMode,
+    elevationOffset: (_g = layer.elevationInfo) == null ? void 0 : _g.offset,
+    elevationUnit,
+    elevationUnitScale: ((_h = layer.elevationInfo) == null ? void 0 : _h.mode) && !elevationMode ? Number.NaN : elevationUnitScale ?? (layer.elevationInfo ? Number.NaN : 1),
+    coordinateFrame,
+    axisOrder: sourceCrs ? "xyz" : "unknown",
+    provenance: sourceCrs ? "metadata" : "unknown",
+    warnings
+  });
+}
+function getI3SCoordinateUnits(coordinateFrame, verticalUnit, zFactor) {
+  if (coordinateFrame === "geocentric") {
+    return ["meter", "meter", "meter"];
+  }
+  if (coordinateFrame === "geographic" && (verticalUnit || zFactor === void 0)) {
+    return ["degree", "degree", verticalUnit || "meter"];
+  }
+  return void 0;
+}
+function getI3SElevationMode(mode) {
+  switch (mode) {
+    case "absoluteHeight":
+    case "onTheGround":
+    case "relativeToGround":
+    case "relativeToScene":
+      return mode;
+    default:
+      return void 0;
+  }
+}
+function get3DTilesSpatialReference(tileset) {
+  var _a, _b;
+  const geocentricCrs = getTilesetSemanticValue(tileset, "TILESET_CRS_GEOCENTRIC");
+  const coordinateEpoch = getTilesetSemanticValue(tileset, "TILESET_CRS_COORDINATE_EPOCH");
+  const warnings = [];
+  let sourceCrs;
+  let provenance = "unknown";
+  let sourceCrsState;
+  if (typeof geocentricCrs === "string" && geocentricCrs.toUpperCase() !== "UNKNOWN") {
+    sourceCrs = geocentricCrs;
+    provenance = "metadata";
+    sourceCrsState = "explicit";
+  } else if (geocentricCrs !== void 0) {
+    warnings.push("3D Tiles geocentric CRS is explicitly unknown");
+    provenance = "metadata";
+    sourceCrsState = "unknown";
+  } else if ((_b = (_a = tileset.root) == null ? void 0 : _a.boundingVolume) == null ? void 0 : _b.region) {
+    sourceCrs = "EPSG:4978";
+    provenance = "format-default";
+    sourceCrsState = "default";
+  } else if (tileset.schemaUri && !tileset.schema) {
+    warnings.push("External 3D Tiles metadata schema must be loaded before CRS semantics can resolve");
+  }
+  const epoch = parseCoordinateEpoch(coordinateEpoch);
+  if (coordinateEpoch !== void 0 && epoch === void 0) {
+    warnings.push("3D Tiles coordinate epoch is not a finite decimal year");
+  }
+  return createTilesetSpatialReference({
+    sourceCrs,
+    sourceCrsState,
+    sourceCrsRepresentation: sourceCrs ? "identifier" : void 0,
+    coordinateEpoch: epoch,
+    heightReference: sourceCrs ? "ellipsoidal" : "unknown",
+    coordinateFrame: sourceCrs ? "geocentric" : "unknown",
+    axisOrder: sourceCrs ? "xyz" : "unknown",
+    provenance,
+    warnings
+  });
+}
+function parseCoordinateEpoch(value) {
+  if (typeof value !== "string" && typeof value !== "number") {
+    return void 0;
+  }
+  if (typeof value === "string" && !value.trim()) {
+    return void 0;
+  }
+  const epoch = Number(value);
+  return Number.isFinite(epoch) ? epoch : void 0;
+}
+function getI3SCrsDefinition(spatialReference) {
+  const identifier = getCrsIdentifier(spatialReference);
+  if (identifier !== void 0) {
+    return `EPSG:${identifier}`;
+  }
+  return spatialReference == null ? void 0 : spatialReference.wkt;
+}
+function getI3SVerticalCrsDefinition(spatialReference) {
+  const identifier = (spatialReference == null ? void 0 : spatialReference.latestVcsWkid) ?? (spatialReference == null ? void 0 : spatialReference.vcsWkid);
+  return identifier === void 0 ? void 0 : `EPSG:${identifier}`;
+}
+function getCrsIdentifier(spatialReference) {
+  return (spatialReference == null ? void 0 : spatialReference.latestWkid) ?? (spatialReference == null ? void 0 : spatialReference.wkid);
+}
+function getIdentifierCoordinateFrame(identifier) {
+  if (identifier === 4978) {
+    return "geocentric";
+  }
+  if (identifier === 4326 || identifier === 4490 || identifier === 4979) {
+    return "geographic";
+  }
+  return "projected";
+}
+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";
+  }
+  if (rootKeyword === "PROJCS" || rootKeyword === "PROJCRS" || rootKeyword === "PROJECTEDCRS") {
+    return "projected";
+  }
+  if (rootKeyword === "GEODCRS" || rootKeyword === "GEODETICCRS") {
+    if (/\bCS\s*[\[(]\s*CARTESIAN\s*,\s*3\b/.test(normalizedWkt)) {
+      return "geocentric";
+    }
+    if (/\bCS\s*[\[(]\s*ELLIPSOIDAL\s*,\s*[23]\b/.test(normalizedWkt)) {
+      return "geographic";
+    }
+  }
+  return "unknown";
+}
+function getTilesetSemanticValue(tileset, semantic) {
+  var _a, _b, _c, _d;
+  const classIdentifier = (_a = tileset.metadata) == null ? void 0 : _a.class;
+  if (!classIdentifier) {
+    return void 0;
+  }
+  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 void 0;
+}
+
 // dist/tileset-3d/format-3d-tiles/implicit-tiling.js
 var QUADTREE_CHILD_COUNT = 4;
 var OCTREE_CHILD_COUNT = 8;
@@ -4413,7 +5185,7 @@ function materializeAvailableTile(subtree, reference, localCoordinates, globalCo
     return null;
   }
   counters.tileCount++;
-  const contentAvailable = getAvailabilityValue(getPrimaryContentAvailability(subtree.contentAvailability), availabilityIndex);
+  const contentAvailability = getContentAvailability(subtree.contentAvailability, availabilityIndex);
   const children = [];
   if (globalCoordinates.level < descriptor.maximumLevel) {
     if (localCoordinates.localLevel + 1 < descriptor.subtreeLevels) {
@@ -4432,15 +5204,15 @@ function materializeAvailableTile(subtree, reference, localCoordinates, globalCo
         const childSubtreeIndex = localCoordinates.mortonIndex * childCount + childIndex;
         if (getAvailabilityValue(subtree.childSubtreeAvailability, childSubtreeIndex)) {
           const childCoordinates = getChildCoordinates(globalCoordinates, childIndex, descriptor.subdivisionScheme);
-          children.push(createLazyImplicitTileHeader(descriptor, childCoordinates));
+          children.push(createLazyImplicitTileHeader(subtree, descriptor, childCoordinates));
           counters.childSubtreeCount++;
         }
       }
     }
   }
-  return formatImplicitTileHeader(descriptor, reference, globalCoordinates, contentAvailable, children);
+  return formatImplicitTileHeader(subtree, descriptor, reference, globalCoordinates, contentAvailability, children);
 }
-function createLazyImplicitTileHeader(descriptor, coordinates) {
+function createLazyImplicitTileHeader(subtree, descriptor, coordinates) {
   const reference = createImplicitSubtreeReference(descriptor, coordinates);
   return {
     id: getImplicitTileId(reference, coordinates),
@@ -4451,23 +5223,56 @@ function createLazyImplicitTileHeader(descriptor, coordinates) {
     lodMetricType: descriptor.lodMetricType,
     lodMetricValue: descriptor.rootLodMetricValue / 2 ** coordinates.level,
     refine: descriptor.refine,
-    type: TILE_TYPE.EMPTY
+    type: TILE_TYPE.EMPTY,
+    implicitMetadata: getImplicitSubtreeMetadata(subtree)
   };
 }
-function formatImplicitTileHeader(descriptor, reference, coordinates, contentAvailable, children) {
-  const contentUrl = contentAvailable && descriptor.contentUrlTemplate ? replaceImplicitUrlTemplate(descriptor.contentUrlTemplate, coordinates) : void 0;
+function formatImplicitTileHeader(subtree, descriptor, reference, coordinates, contentAvailability, children) {
+  var _a;
+  const contentUrlTemplates = ((_a = descriptor.contentUrlTemplates) == null ? void 0 : _a.length) ? descriptor.contentUrlTemplates : [descriptor.contentUrlTemplate];
+  const contentEntries = contentUrlTemplates.map((templateUrl, contentIndex) => {
+    if (!contentAvailability[contentIndex] || !templateUrl) {
+      return null;
+    }
+    return {
+      contentIndex,
+      contentUrl: replaceImplicitUrlTemplate(templateUrl, coordinates)
+    };
+  }).filter((entry) => Boolean(entry));
+  const availableContentUrls = contentEntries.map((entry) => entry.contentUrl);
+  const content = contentEntries.map(({ contentIndex, contentUrl: contentUrl2 }) => {
+    var _a2;
+    return {
+      ...((_a2 = descriptor.contentHeaders) == null ? void 0 : _a2[contentIndex]) || (contentIndex === 0 ? descriptor.contentHeader : {}) || {},
+      uri: contentUrl2
+    };
+  });
+  const contentUrl = availableContentUrls[0];
   const lodMetricValue = descriptor.rootLodMetricValue / 2 ** coordinates.level;
   return {
     id: getImplicitTileId(reference, coordinates),
     children,
     contentUrl,
-    content: contentUrl ? { ...descriptor.contentHeader, uri: contentUrl } : void 0,
+    content: content.length > 1 ? content : content[0],
+    contentUrls: availableContentUrls,
     refine: descriptor.refine,
     type: getImplicitTileType(contentUrl),
     lodMetricType: descriptor.lodMetricType,
     lodMetricValue,
     geometricError: lodMetricValue,
-    boundingVolume: calculateImplicitBoundingVolume(descriptor.rootBoundingVolume, coordinates, descriptor.subdivisionScheme)
+    boundingVolume: calculateImplicitBoundingVolume(descriptor.rootBoundingVolume, coordinates, descriptor.subdivisionScheme),
+    implicitMetadata: getImplicitSubtreeMetadata(subtree)
+  };
+}
+function getImplicitSubtreeMetadata(subtree) {
+  if (!subtree.propertyTables && subtree.tileMetadata === void 0 && !subtree.contentMetadata && subtree.subtreeMetadata === void 0) {
+    return void 0;
+  }
+  return {
+    propertyTables: subtree.propertyTables,
+    tileMetadata: subtree.tileMetadata,
+    contentMetadata: subtree.contentMetadata,
+    subtreeMetadata: subtree.subtreeMetadata
   };
 }
 function getImplicitTileId(reference, coordinates) {
@@ -4485,8 +5290,9 @@ function getAvailabilityValue(availability, index) {
   const bitIndex = index % 8;
   return Boolean(bitstream[byteIndex] >> bitIndex & 1);
 }
-function getPrimaryContentAvailability(availability) {
-  return Array.isArray(availability) ? availability[0] || { constant: 0 } : availability || { constant: 0 };
+function getContentAvailability(availability, index) {
+  const streams = Array.isArray(availability) ? availability : [availability];
+  return streams.map((stream) => getAvailabilityValue(stream || { constant: 0 }, index));
 }
 function getLevelOffset(childCount, localLevel) {
   return (childCount ** localLevel - 1) / (childCount - 1);
@@ -4628,12 +5434,8 @@ var Tiles3DSource = class {
   queryParams = {};
   /** Final request URLs cached by unmodified tile content URL. */
   tileUrlCache = /* @__PURE__ */ new Map();
-  /** Parsed subtree promises keyed by final source URL for request deduplication and LRU reuse. */
-  implicitSubtreeCache = /* @__PURE__ */ new Map();
-  /** URLs whose subtree resource requests have not settled. */
-  pendingImplicitSubtreeUrls = /* @__PURE__ */ new Set();
-  /** Maximum number of settled parsed subtrees retained by this source. */
-  maximumCachedSubtrees;
+  /** Parsed subtree requests keyed by final source URL for deduplication and LRU reuse. */
+  implicitSubtreeCache;
   /** Mutable counters exposed as a defensive snapshot through {@link getImplicitTilingStats}. */
   implicitTilingStats = {
     requestedSubtrees: 0,
@@ -4663,7 +5465,8 @@ var Tiles3DSource = class {
     this.coreApi = request.coreApi;
     this.loadOptions = loadOptions;
     const maximumCachedSubtrees = Number((_a = loadOptions["3d-tiles"]) == null ? void 0 : _a.maximumCachedSubtrees);
-    this.maximumCachedSubtrees = Number.isFinite(maximumCachedSubtrees) ? Math.max(0, Math.floor(maximumCachedSubtrees)) : DEFAULT_MAXIMUM_CACHED_SUBTREES;
+    const maximumCacheEntries = Number.isFinite(maximumCachedSubtrees) ? Math.max(0, Math.floor(maximumCachedSubtrees)) : DEFAULT_MAXIMUM_CACHED_SUBTREES;
+    this.implicitSubtreeCache = new RequestCache({ maxEntries: maximumCacheEntries });
   }
   /**
    * Releases URL and parsed-subtree caches and blocks late subtree installation.
@@ -4675,7 +5478,6 @@ var Tiles3DSource = class {
     this.destroyed = true;
     this.tileUrlCache.clear();
     this.implicitSubtreeCache.clear();
-    this.pendingImplicitSubtreeUrls.clear();
   }
   /**
    * Fetches and validates top-level metadata, then normalizes common fields used by {@link Tileset3D}.
@@ -4721,7 +5523,8 @@ var Tiles3DSource = class {
       tileset: this.rootTileset,
       lodMetricType: this.rootTileset.lodMetricType,
       lodMetricValue: this.rootTileset.lodMetricValue,
-      refine: (_a = this.rootTileset.root) == null ? void 0 : _a.refine
+      refine: (_a = this.rootTileset.root) == null ? void 0 : _a.refine,
+      spatialReference: get3DTilesSpatialReference(this.rootTileset)
     };
   }
   /**
@@ -4780,7 +5583,7 @@ var Tiles3DSource = class {
    * Loads binary content or nested tileset JSON for a runtime tile.
    */
   async loadTileContent(tile) {
-    const contentUrl = this.getTileUrl(tile.contentUrl);
+    const contentUrls = (tile.contentUrls || [tile.contentUrl]).filter(Boolean);
     const tilesetLoaderOptions = this.loadOptions[this.loader.id] || {};
     const options = {
       ...this.loadOptions,
@@ -4792,11 +5595,15 @@ var Tiles3DSource = class {
         assetGltfUpAxis: this.asset && this.asset.gltfUpAxis || "Y"
       }
     };
-    const content = await this.loadResourceData(contentUrl, options);
-    tile.content = content;
+    const contents = await Promise.all(contentUrls.map((contentUrl) => this.loadResourceData(this.getTileUrl(contentUrl), options)));
+    tile.contents = contents;
+    tile.content = contents[0] || null;
+    const nestedTilesets = contents.filter((content) => (content == null ? void 0 : content.shape) === "tileset3d");
     return {
       loaded: true,
-      nestedTileset: (content == null ? void 0 : content.shape) === "tileset3d" ? content : void 0
+      contents,
+      nestedTileset: nestedTilesets[0],
+      nestedTilesets
     };
   }
   /**
@@ -4843,8 +5650,8 @@ var Tiles3DSource = class {
   getImplicitTilingStats() {
     return {
       ...this.implicitTilingStats,
-      cachedSubtrees: this.implicitSubtreeCache.size - this.pendingImplicitSubtreeUrls.size,
-      pendingSubtrees: this.pendingImplicitSubtreeUrls.size
+      cachedSubtrees: this.implicitSubtreeCache.size - this.implicitSubtreeCache.pendingSize,
+      pendingSubtrees: this.implicitSubtreeCache.pendingSize
     };
   }
   /**
@@ -4939,8 +5746,11 @@ var Tiles3DSource = class {
    * Updates content-format flags and installs nested tileset subtrees.
    */
   onTileLoaded(tileset, tile, loadResult) {
-    var _a;
-    const { extensionsRemoved = [] } = ((_a = tile.content) == null ? void 0 : _a.gltf) || {};
+    const contents = tile.contents.length ? tile.contents : [tile.content];
+    const extensionsRemoved = contents.flatMap((content) => {
+      var _a;
+      return ((_a = content == null ? void 0 : content.gltf) == null ? void 0 : _a.extensionsRemoved) || [];
+    });
     if (extensionsRemoved.includes("KHR_draco_mesh_compression")) {
       this.contentFormats.draco = true;
     }
@@ -4950,8 +5760,9 @@ var Tiles3DSource = class {
     if (extensionsRemoved.includes("KHR_texture_basisu")) {
       this.contentFormats.ktx2 = true;
     }
-    if (loadResult.nestedTileset) {
-      tileset._initializeTileHeaders(loadResult.nestedTileset, tile);
+    const nestedTilesets = loadResult.nestedTilesets || (loadResult.nestedTileset ? [loadResult.nestedTileset] : []);
+    for (const nestedTileset of nestedTilesets) {
+      tileset._initializeTileHeaders(nestedTileset, tile);
     }
   }
   /**
@@ -4991,31 +5802,20 @@ var Tiles3DSource = class {
     const cachedSubtree = this.implicitSubtreeCache.get(subtreeUrl);
     if (cachedSubtree) {
       this.implicitTilingStats.cacheHits++;
-      this.implicitSubtreeCache.delete(subtreeUrl);
-      this.implicitSubtreeCache.set(subtreeUrl, cachedSubtree);
       return await cachedSubtree;
     }
     this.implicitTilingStats.requestedSubtrees++;
-    this.pendingImplicitSubtreeUrls.add(subtreeUrl);
     const loaderOptions = this.loadOptions[this.loader.id] || {};
-    const subtreePromise = this.loadResourceData(subtreeUrl, {
-      ...this.loadOptions,
-      [this.loader.id]: {
-        ...loaderOptions,
-        isTileset: false,
-        isSubtree: true
-      }
+    return await this.implicitSubtreeCache.getOrLoad(subtreeUrl, async () => {
+      return await this.loadResourceData(subtreeUrl, {
+        ...this.loadOptions,
+        [this.loader.id]: {
+          ...loaderOptions,
+          isTileset: false,
+          isSubtree: true
+        }
+      });
     });
-    this.implicitSubtreeCache.set(subtreeUrl, subtreePromise);
-    try {
-      return await subtreePromise;
-    } catch (error) {
-      this.implicitSubtreeCache.delete(subtreeUrl);
-      throw error;
-    } finally {
-      this.pendingImplicitSubtreeUrls.delete(subtreeUrl);
-      this.trimImplicitSubtreeCache();
-    }
   }
   /**
    * Instantiates every header represented by one materialized subtree.
@@ -5046,20 +5846,6 @@ var Tiles3DSource = class {
     }
     return materializedTileCount;
   }
-  /** Evicts least-recently-used settled subtree entries until the configured bound is met. */
-  trimImplicitSubtreeCache() {
-    if (this.implicitSubtreeCache.size <= this.maximumCachedSubtrees) {
-      return;
-    }
-    for (const subtreeUrl of this.implicitSubtreeCache.keys()) {
-      if (!this.pendingImplicitSubtreeUrls.has(subtreeUrl)) {
-        this.implicitSubtreeCache.delete(subtreeUrl);
-      }
-      if (this.implicitSubtreeCache.size <= this.maximumCachedSubtrees) {
-        break;
-      }
-    }
-  }
 };
 function isTilesetRequest(input) {
   return Boolean(input && typeof input === "object" && "url" in input && "loader" in input && !("type" in input));
@@ -5081,8 +5867,8 @@ function normalizeTiles3DRequest(input) {
 }
 
 // dist/tileset-3d/format-i3s/i3s-source.js
-var import_geospatial8 = require("@math.gl/geospatial");
-var import_core11 = require("@math.gl/core");
+var import_geospatial10 = require("@math.gl/geospatial");
+var import_core13 = require("@math.gl/core");
 
 // dist/tileset-3d/format-i3s/i3s-pending-tiles-register.js
 var I3SPendingTilesRegister = class {
@@ -5262,6 +6048,836 @@ 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 I3SSpatialTransformer = class {
+  /** Descriptor attached to output after all adapter-owned spatial values have been transformed. */
+  spatialReference;
+  /** Broad coordinate frame of the selected output CRS. */
+  targetCoordinateFrame;
+  /** Source-to-target position operation. */
+  positionTransformer;
+  /** Source-to-WGS84 geographic operation used for vector-frame conversion. */
+  sourceToGeographicTransformer;
+  /** WGS84-geographic-to-target operation used for normal finite differences. */
+  geographicToTargetTransformer;
+  /** Source frame recorded by I3S metadata. */
+  sourceCoordinateFrame;
+  /** Source Z multiplier that normalizes stored elevation values to meters. */
+  sourceVerticalUnitScale;
+  /** I3S elevation placement mode. */
+  elevationMode;
+  /** I3S elevation offset normalized to meters. */
+  elevationOffset;
+  /** Terrain or scene provider selected for the declared placement mode. */
+  elevationProvider;
+  /** Provider height multiplier that normalizes returned values to meters. */
+  providerUnitScale;
+  /** Optional provider-height to layer-height datum operation. */
+  providerHeightTransformer;
+  /**
+   * Creates an I3S spatial adapter.
+   *
+   * @param spatialReference - Transformable I3S spatial descriptor.
+   * @param options - Registered geoid and custom resource options used by the shared transformer.
+   */
+  constructor(spatialReference, options = {}) {
+    var _a;
+    if (spatialReference.status !== "transformable" && spatialReference.status !== "transformed") {
+      throw new Error("I3SSpatialTransformer requires a requested, transformable spatial output");
+    }
+    const targetCrs = spatialReference.targetCrs || spatialReference.sourceCrs;
+    if (!targetCrs) {
+      throw new Error("I3S spatial transformation requires a target CRS");
+    }
+    this.positionTransformer = new SpatialCoordinateTransformer(spatialReference, options);
+    this.sourceCoordinateFrame = spatialReference.coordinateFrame;
+    this.sourceVerticalUnitScale = spatialReference.verticalUnitScale;
+    this.elevationMode = spatialReference.elevationMode;
+    this.elevationOffset = (spatialReference.elevationOffset || 0) * spatialReference.elevationUnitScale;
+    this.elevationProvider = getElevationProvider(this.elevationMode, options);
+    if (this.elevationProvider && (typeof this.elevationProvider.sampleElevations !== "function" || typeof this.elevationProvider.getElevationRange !== "function")) {
+      throw new Error("An I3S elevation provider must implement sampleElevations() and getElevationRange()");
+    }
+    const providerUnitScale = getI3SLinearUnitScale(((_a = this.elevationProvider) == null ? void 0 : _a.unit) || "meter");
+    if (this.elevationProvider && providerUnitScale === void 0) {
+      throw new Error(`Unsupported elevation-provider unit ${this.elevationProvider.unit}`);
+    }
+    this.providerUnitScale = providerUnitScale || 1;
+    this.targetCoordinateFrame = getSpatialCoordinateFrame(targetCrs);
+    this.spatialReference = markTilesetSpatialReferenceTransformed(spatialReference);
+    const sourceToGeographicReference = createTilesetSpatialReference({
+      sourceCrs: spatialReference.sourceCrs,
+      heightReference: spatialReference.heightReference,
+      coordinateFrame: spatialReference.coordinateFrame,
+      axisOrder: spatialReference.axisOrder,
+      provenance: spatialReference.provenance
+    }, { targetCrs: "EPSG:4326" });
+    this.sourceToGeographicTransformer = new SpatialCoordinateTransformer(sourceToGeographicReference);
+    if (requiresElevationSurface(this.elevationMode)) {
+      if (!this.elevationProvider) {
+        const providerName = this.elevationMode === "relativeToScene" ? "scene" : "terrain";
+        throw new Error(`I3S elevation mode ${this.elevationMode} requires a ${providerName} elevation provider`);
+      }
+      if (spatialReference.heightReference === "unknown") {
+        throw new Error(`I3S elevation mode ${this.elevationMode} requires a known source height reference`);
+      }
+      const providerHeightReference = this.elevationProvider.heightReference || spatialReference.heightReference;
+      if (providerHeightReference !== spatialReference.heightReference) {
+        if (spatialReference.heightReference !== "ellipsoidal" && spatialReference.heightReference !== "orthometric") {
+          throw new Error("Converting elevation-provider heights requires an ellipsoidal or orthometric source height reference");
+        }
+        const providerHeightSpatialReference = createTilesetSpatialReference({
+          sourceCrs: "EPSG:4326",
+          heightReference: providerHeightReference,
+          coordinateFrame: "geographic",
+          axisOrder: "xyz",
+          provenance: "caller-override"
+        }, {
+          targetCrs: "EPSG:4326",
+          targetHeightReference: spatialReference.heightReference,
+          geoidModel: options.geoidModel
+        });
+        this.providerHeightTransformer = new SpatialCoordinateTransformer(providerHeightSpatialReference, options);
+      }
+    }
+    const geographicToTargetReference = createTilesetSpatialReference({
+      sourceCrs: "EPSG:4326",
+      heightReference: spatialReference.heightReference,
+      coordinateFrame: "geographic",
+      axisOrder: "xyz",
+      provenance: "format-default"
+    }, {
+      targetCrs,
+      targetHeightReference: spatialReference.targetHeightReference,
+      geoidModel: options.geoidModel
+    });
+    this.geographicToTargetTransformer = new SpatialCoordinateTransformer(geographicToTargetReference, options);
+  }
+  /** Transform one absolute I3S source position. */
+  transformPosition(position) {
+    const placedPosition = this.placeSourcePositionsSync(position);
+    const transformed = this.positionTransformer.transformPosition([
+      placedPosition[0],
+      placedPosition[1],
+      placedPosition[2]
+    ]);
+    return [transformed[0], transformed[1], transformed[2]];
+  }
+  /** Transform one absolute I3S source position after asynchronous surface placement. */
+  async transformPositionAsync(position) {
+    const placedPosition = await this.placeSourcePositions(position);
+    const transformed = this.positionTransformer.transformPosition([
+      placedPosition[0],
+      placedPosition[1],
+      placedPosition[2]
+    ]);
+    return [transformed[0], transformed[1], transformed[2]];
+  }
+  /** Transform an already placed, meter-normalized position to the requested target. */
+  transformPlacedPosition(position) {
+    const transformed = this.positionTransformer.transformPosition([
+      position[0],
+      position[1],
+      position[2]
+    ]);
+    return [transformed[0], transformed[1], transformed[2]];
+  }
+  /** Transform one absolute I3S source position to WGS84 longitude, latitude, and height. */
+  transformSourcePositionToGeographic(position) {
+    const placedPosition = this.placeSourcePositionsSync(position);
+    const transformed = this.sourceToGeographicTransformer.transformPosition([
+      placedPosition[0],
+      placedPosition[1],
+      placedPosition[2]
+    ]);
+    return [transformed[0], transformed[1], transformed[2]];
+  }
+  /** Transform one source position to WGS84 after asynchronous elevation placement. */
+  async transformSourcePositionToGeographicAsync(position) {
+    const placedPosition = await this.placeSourcePositions(position);
+    const transformed = this.sourceToGeographicTransformer.transformPosition([
+      placedPosition[0],
+      placedPosition[1],
+      placedPosition[2]
+    ]);
+    return [transformed[0], transformed[1], transformed[2]];
+  }
+  /**
+   * Transform absolute Float64 positions and return stable Float32 offsets around a target origin.
+   *
+   * @param sourcePositions - Absolute positions in source CRS order.
+   * @param sourceOrigin - Stable source origin, normally the node MBS or OBB center.
+   */
+  transformPositions(sourcePositions, sourceOrigin) {
+    const placedSourcePositions = this.placeSourcePositionsSync(sourcePositions);
+    const placedSourceOrigin = this.placeSourcePositionsSync(sourceOrigin);
+    return this.transformPlacedPositions(placedSourcePositions, placedSourceOrigin);
+  }
+  /**
+   * Transform positions after asynchronously sampling any requested terrain or scene surface.
+   *
+   * @param sourcePositions - Absolute positions in source CRS order.
+   * @param sourceOrigin - Stable source origin, normally the node MBS or OBB center.
+   * @returns Renderer-ready target-frame offsets and stable origin metadata.
+   */
+  async transformPositionsAsync(sourcePositions, sourceOrigin) {
+    const combinedPositions = new Float64Array(sourcePositions.length + 3);
+    combinedPositions.set(Array.from(sourcePositions), 0);
+    combinedPositions.set(Array.from(sourceOrigin).slice(0, 3), sourcePositions.length);
+    const placedPositions = await this.placeSourcePositions(combinedPositions);
+    return this.transformPlacedPositions(placedPositions.subarray(0, sourcePositions.length), placedPositions.subarray(sourcePositions.length));
+  }
+  /** Transform already placed positions into renderer-relative target coordinates. */
+  transformPlacedPositions(sourcePositions, sourceOrigin) {
+    const origin = this.transformPlacedPosition(sourceOrigin);
+    const positions = new Float32Array(sourcePositions.length);
+    const absoluteSourcePositions = Float64Array.from(sourcePositions);
+    for (let index = 0; index < sourcePositions.length; index += 3) {
+      const transformed = this.transformPlacedPosition([
+        sourcePositions[index],
+        sourcePositions[index + 1],
+        sourcePositions[index + 2]
+      ]);
+      positions[index] = transformed[0] - origin[0];
+      positions[index + 1] = transformed[1] - origin[1];
+      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);
+    return {
+      positions,
+      sourcePositions: absoluteSourcePositions,
+      origin,
+      cartographicOrigin: isGeographic ? origin : [0, 0, 0],
+      coordinateSystem: isGeographic ? "lnglat-offsets" : "cartesian",
+      modelMatrix
+    };
+  }
+  /**
+   * Transform I3S normals into the selected target basis.
+   *
+   * Earth-centered normals are rotated directly. Vertex-reference-frame normals are first mapped
+   * through the local east/north/up basis at each source position.
+   *
+   * @param normals - Three-component normal vectors.
+   * @param sourcePositions - Absolute source position paired with each normal.
+   * @param normalReferenceFrame - I3S normal frame declaration.
+   */
+  transformNormals(normals, sourcePositions, normalReferenceFrame = "earth-centered") {
+    const transformedNormals = new Float32Array(normals.length);
+    for (let index = 0; index < normals.length; index += 3) {
+      const geographic = this.sourceToGeographicTransformer.transformPosition([
+        sourcePositions[index],
+        sourcePositions[index + 1],
+        sourcePositions[index + 2]
+      ]);
+      const inputNormal = new import_core12.Vector3([
+        normals[index],
+        normals[index + 1],
+        normals[index + 2]
+      ]).normalize();
+      const ecefNormal = normalReferenceFrame === "earth-centered" ? inputNormal : localEnuVectorToEcef(inputNormal, geographic);
+      const outputNormal = this.transformEcefNormal(ecefNormal, geographic);
+      transformedNormals.set(outputNormal, index);
+    }
+    return transformedNormals;
+  }
+  /**
+   * Rebuild an I3S node bound from transformed corner or sphere-axis samples.
+   *
+   * @param bounds - Source MBS/OBB fields.
+   * @returns A generic tile `region` for geographic output or axis-aligned `box` otherwise.
+   */
+  transformBoundingVolume(bounds) {
+    const geographicSamples = this.getGeographicBoundSamples(bounds);
+    const targetSamples = geographicSamples.map((position) => this.geographicToTargetTransformer.transformPosition(position));
+    return this.targetCoordinateFrame === "geographic" ? { region: getGeographicRegion(targetSamples) } : { box: getAxisAlignedBox(targetSamples) };
+  }
+  /** Rebuild an I3S bound in the target frame after asynchronous elevation placement. */
+  async transformBoundingVolumeAsync(bounds) {
+    const geographicSamples = await this.getGeographicBoundSamplesAsync(bounds);
+    const targetSamples = geographicSamples.map((position) => this.geographicToTargetTransformer.transformPosition(position));
+    return this.targetCoordinateFrame === "geographic" ? { region: getGeographicRegion(targetSamples) } : { box: getAxisAlignedBox(targetSamples) };
+  }
+  /** Rebuild an I3S bound as a WGS84 geographic region for geographic traversal algorithms. */
+  transformBoundingVolumeToGeographic(bounds) {
+    return { region: getGeographicRegion(this.getGeographicBoundSamples(bounds)) };
+  }
+  /** Rebuild an I3S bound as WGS84 geographic after asynchronous elevation placement. */
+  async transformBoundingVolumeToGeographicAsync(bounds) {
+    return { region: getGeographicRegion(await this.getGeographicBoundSamplesAsync(bounds)) };
+  }
+  /** 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))));
+    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))));
+    return { box: getAxisAlignedBox(cartesianSamples) };
+  }
+  /** Return a WGS84 geographic MBS used by the I3S screen-threshold calculation. */
+  transformBoundingSphereToGeographic(bounds) {
+    var _a, _b;
+    const sourceCenter = ((_a = bounds.mbs) == null ? void 0 : _a.length) ? Array.from(bounds.mbs).slice(0, 3) : bounds.obb ? Array.from(bounds.obb.center).slice(0, 3) : null;
+    if (!sourceCenter) {
+      throw new Error("I3S spatial transformation requires an MBS or OBB bound");
+    }
+    const placedCenter = this.placeSourcePositionsSync(sourceCenter);
+    const geographicCenter = this.sourceToGeographicTransformer.transformPosition(Array.from(placedCenter));
+    const radius = ((_b = bounds.mbs) == null ? void 0 : _b.length) ? bounds.mbs[3] : Math.hypot(...Array.from(bounds.obb.halfSize).slice(0, 3));
+    return [geographicCenter[0], geographicCenter[1], geographicCenter[2], radius];
+  }
+  /** Return a placed WGS84 MBS used by the I3S screen-threshold calculation. */
+  async transformBoundingSphereToGeographicAsync(bounds) {
+    return getGeographicBoundingSphere(await this.getGeographicBoundSamplesAsync(bounds));
+  }
+  /**
+   * Rebuild traversal, target-output, and I3S LOD bounds from one elevation-sampling batch.
+   *
+   * @param bounds - Source MBS/OBB fields.
+   * @returns Parallel bounds in WGS84 ECEF, the selected output frame, and WGS84 geographic.
+   */
+  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 targetSamples = geographicSamples.map((position) => this.geographicToTargetTransformer.transformPosition(position));
+    return {
+      boundingVolume: { box: getAxisAlignedBox(cartesianSamples) },
+      spatialBoundingVolume: this.targetCoordinateFrame === "geographic" ? { region: getGeographicRegion(targetSamples) } : { box: getAxisAlignedBox(targetSamples) },
+      i3sLodMbs: requiresElevationSurface(this.elevationMode) ? getGeographicBoundingSphere(geographicSamples) : this.transformBoundingSphereToGeographic(bounds)
+    };
+  }
+  /**
+   * Rebuild Point Cloud traversal and target-output bounds from one elevation-sampling batch.
+   *
+   * @param bounds - Source OBB fields.
+   * @returns WGS84 geographic traversal bound plus the selected output-frame bound.
+   */
+  async transformPointCloudBoundsAsync(bounds) {
+    const geographicSamples = await this.getGeographicBoundSamplesAsync(bounds);
+    const targetSamples = geographicSamples.map((position) => this.geographicToTargetTransformer.transformPosition(position));
+    return {
+      boundingVolume: { region: getGeographicRegion(geographicSamples) },
+      spatialBoundingVolume: this.targetCoordinateFrame === "geographic" ? { region: getGeographicRegion(targetSamples) } : { box: getAxisAlignedBox(targetSamples) }
+    };
+  }
+  /** Sample a source I3S bound and normalize every sample to WGS84 geographic coordinates. */
+  getGeographicBoundSamples(bounds) {
+    const sourceSamples = getSourceBoundSamples(bounds, this.sourceCoordinateFrame, this.sourceToGeographicTransformer, this.sourceVerticalUnitScale);
+    if (!sourceSamples.length) {
+      throw new Error("I3S spatial transformation requires an MBS or OBB bound");
+    }
+    const placedSourceSamples = this.placeSourcePositionsSync(sourceSamples.flat(), true);
+    const placedSamples = toPositionArrays(placedSourceSamples);
+    return this.sourceCoordinateFrame === "geographic" ? placedSamples : placedSamples.map((position) => this.sourceToGeographicTransformer.transformPosition(position));
+  }
+  /** Sample, place, and normalize one source bound to WGS84 geographic coordinates. */
+  async getGeographicBoundSamplesAsync(bounds) {
+    const sourceSamples = getSourceBoundSamples(bounds, this.sourceCoordinateFrame, this.sourceToGeographicTransformer, this.sourceVerticalUnitScale);
+    if (!sourceSamples.length) {
+      throw new Error("I3S spatial transformation requires an MBS or OBB bound");
+    }
+    if (requiresElevationSurface(this.elevationMode)) {
+      const geographicSamples = this.sourceCoordinateFrame === "geographic" ? sourceSamples : sourceSamples.map((position) => this.sourceToGeographicTransformer.transformPosition(position));
+      return await this.placeGeographicBoundSamples(geographicSamples);
+    }
+    const placedSamples = toPositionArrays(await this.placeSourcePositions(sourceSamples.flat(), true));
+    return this.sourceCoordinateFrame === "geographic" ? placedSamples : placedSamples.map((position) => this.sourceToGeographicTransformer.transformPosition(position));
+  }
+  /** Apply a provider's conservative surface range to an entire geographic bound footprint. */
+  async placeGeographicBoundSamples(geographicSamples) {
+    const elevationProvider = this.elevationProvider;
+    const elevationRange = await elevationProvider.getElevationRange(getElevationBounds(geographicSamples));
+    const minimumProviderHeight = elevationRange.minimum * this.providerUnitScale;
+    const maximumProviderHeight = elevationRange.maximum * this.providerUnitScale;
+    if (!Number.isFinite(minimumProviderHeight) || !Number.isFinite(maximumProviderHeight) || minimumProviderHeight > maximumProviderHeight) {
+      throw new Error("Elevation provider returned an invalid range; minimum and maximum must be finite and ordered");
+    }
+    const sourceHeights = geographicSamples.map((position) => position[2]);
+    const minimumSourceHeight = Math.min(...sourceHeights);
+    const maximumSourceHeight = Math.max(...sourceHeights);
+    const placedSamples = [];
+    for (const [longitude, latitude] of geographicSamples) {
+      const convertedMinimum = this.providerHeightTransformer ? this.providerHeightTransformer.transformPosition([
+        longitude,
+        latitude,
+        minimumProviderHeight
+      ])[2] : minimumProviderHeight;
+      const convertedMaximum = this.providerHeightTransformer ? this.providerHeightTransformer.transformPosition([
+        longitude,
+        latitude,
+        maximumProviderHeight
+      ])[2] : maximumProviderHeight;
+      const minimumSurfaceHeight = Math.min(convertedMinimum, convertedMaximum);
+      const maximumSurfaceHeight = Math.max(convertedMinimum, convertedMaximum);
+      const minimumHeight = this.elevationMode === "onTheGround" ? minimumSurfaceHeight : minimumSurfaceHeight + minimumSourceHeight + this.elevationOffset;
+      const maximumHeight = this.elevationMode === "onTheGround" ? maximumSurfaceHeight : maximumSurfaceHeight + maximumSourceHeight + this.elevationOffset;
+      placedSamples.push([longitude, latitude, minimumHeight], [longitude, latitude, maximumHeight]);
+    }
+    return placedSamples;
+  }
+  /** Apply source units and non-surface placement without awaiting external resources. */
+  placeSourcePositionsSync(sourcePositions, sourceHeightsAreMeters = false) {
+    if (requiresElevationSurface(this.elevationMode)) {
+      throw new Error(`I3S elevation mode ${this.elevationMode} requires asynchronous surface placement`);
+    }
+    const positions = Float64Array.from(sourcePositions);
+    const offset = this.elevationMode === "absoluteHeight" ? this.elevationOffset : 0;
+    for (let index = 2; index < positions.length; index += 3) {
+      positions[index] = positions[index] * (sourceHeightsAreMeters ? 1 : this.sourceVerticalUnitScale) + offset;
+    }
+    return positions;
+  }
+  /** Apply source units and all I3S elevation-placement modes. */
+  async placeSourcePositions(sourcePositions, sourceHeightsAreMeters = false) {
+    if (!requiresElevationSurface(this.elevationMode)) {
+      return this.placeSourcePositionsSync(sourcePositions, sourceHeightsAreMeters);
+    }
+    const positions = Float64Array.from(sourcePositions);
+    const geographicLocations = toPositionArrays(positions).map((position) => {
+      const geographic = this.sourceToGeographicTransformer.transformPosition(position);
+      return [geographic[0], geographic[1]];
+    });
+    const sampledHeights = await this.elevationProvider.sampleElevations(geographicLocations);
+    if (sampledHeights.length !== geographicLocations.length) {
+      throw new Error(`Elevation provider returned ${sampledHeights.length} heights for ${geographicLocations.length} positions`);
+    }
+    for (let positionIndex = 0; positionIndex < geographicLocations.length; positionIndex++) {
+      const sampledHeight = sampledHeights[positionIndex] * this.providerUnitScale;
+      if (!Number.isFinite(sampledHeight)) {
+        throw new Error(`Elevation provider returned a non-finite height at index ${positionIndex}`);
+      }
+      const [longitude, latitude] = geographicLocations[positionIndex];
+      const surfaceHeight = this.providerHeightTransformer ? this.providerHeightTransformer.transformPosition([longitude, latitude, sampledHeight])[2] : sampledHeight;
+      const sourceHeight = positions[positionIndex * 3 + 2] * (sourceHeightsAreMeters ? 1 : this.sourceVerticalUnitScale);
+      positions[positionIndex * 3 + 2] = this.elevationMode === "onTheGround" ? surfaceHeight : surfaceHeight + sourceHeight + this.elevationOffset;
+    }
+    return positions;
+  }
+  /** Transform one earth-centered normal to the selected target basis. */
+  transformEcefNormal(ecefNormal, geographic) {
+    if (this.targetCoordinateFrame === "geocentric") {
+      return ecefNormal.normalize();
+    }
+    if (this.targetCoordinateFrame === "geographic") {
+      return ecefVectorToLocalEnu(ecefNormal, geographic).normalize();
+    }
+    const cartesian = import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core12.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 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);
+    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();
+  }
+};
+function getElevationProvider(mode, options) {
+  return mode === "relativeToScene" ? options.sceneElevationProvider : requiresElevationSurface(mode) ? options.terrainElevationProvider : void 0;
+}
+function requiresElevationSurface(mode) {
+  return mode === "onTheGround" || mode === "relativeToGround" || mode === "relativeToScene";
+}
+function toPositionArrays(positions) {
+  if (positions.length % 3 !== 0) {
+    throw new Error("I3S position arrays must contain complete XYZ tuples");
+  }
+  const result = [];
+  for (let index = 0; index < positions.length; index += 3) {
+    result.push([positions[index], positions[index + 1], positions[index + 2]]);
+  }
+  return result;
+}
+function getElevationBounds(geographicSamples) {
+  const region = getGeographicRegion(geographicSamples);
+  return {
+    west: region[0] * 180 / Math.PI,
+    south: region[1] * 180 / Math.PI,
+    east: region[2] * 180 / Math.PI,
+    north: region[3] * 180 / Math.PI
+  };
+}
+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();
+  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());
+  }
+  const geographicCenter = import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(cartesianCenter);
+  return [geographicCenter[0], geographicCenter[1], geographicCenter[2], radius];
+}
+function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransformer, sourceVerticalUnitScale) {
+  const obb = bounds.obb;
+  if (obb) {
+    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 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)
+    ];
+    if (sourceFrame === "geographic") {
+      const geographicCenter = sourceToGeographicTransformer.transformPosition(center2);
+      const cartesianCenter = import_geospatial9.Ellipsoid.WGS84.cartographicToCartesian(new import_core12.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);
+        for (let axisIndex = 0; axisIndex < 3; axisIndex++) {
+          corner.add(new import_core12.Vector3(cartesianAxes[axisIndex]).scale(signs[axisIndex]));
+        }
+        return Array.from(import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(corner));
+      });
+    }
+    return getBoxSigns().map((signs) => {
+      const corner = new import_core12.Vector3(center2);
+      for (let axisIndex = 0; axisIndex < 3; axisIndex++) {
+        corner.add(new import_core12.Vector3(axes[axisIndex]).scale(signs[axisIndex]));
+      }
+      return Array.from(corner);
+    });
+  }
+  const mbs = bounds.mbs ? Array.from(bounds.mbs) : [];
+  if (mbs.length < 4) {
+    return [];
+  }
+  const center = mbs.slice(0, 3);
+  center[2] *= sourceVerticalUnitScale;
+  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)))));
+  }
+  return getAxisDirections().map((direction) => Array.from(new import_core12.Vector3(center).add(new import_core12.Vector3(direction).scale(radius))));
+}
+function getBoxSigns() {
+  return [-1, 1].flatMap((x) => [-1, 1].flatMap((y) => [-1, 1].map((z) => [x, y, z])));
+}
+function getAxisDirections() {
+  return [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 1, 0],
+    [0, -1, 0],
+    [0, 0, 1],
+    [0, 0, -1]
+  ];
+}
+function getPositiveAxisDirections() {
+  return [new import_core12.Vector3([1, 0, 0]), new import_core12.Vector3([0, 1, 0]), new import_core12.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([
+    -Math.sin(latitude) * Math.cos(longitude),
+    -Math.sin(latitude) * Math.sin(longitude),
+    Math.cos(latitude)
+  ]);
+  const up = new import_core12.Vector3([
+    Math.cos(latitude) * Math.cos(longitude),
+    Math.cos(latitude) * Math.sin(longitude),
+    Math.sin(latitude)
+  ]);
+  return east.scale(vector[0]).add(north.scale(vector[1])).add(up.scale(vector[2]));
+}
+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([
+    -Math.sin(latitude) * Math.cos(longitude),
+    -Math.sin(latitude) * Math.sin(longitude),
+    Math.cos(latitude)
+  ]);
+  const up = new import_core12.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)]);
+}
+function getAxisAlignedBox(positions) {
+  const minimum = [Infinity, Infinity, Infinity];
+  const maximum = [-Infinity, -Infinity, -Infinity];
+  for (const position of positions) {
+    for (let component = 0; component < 3; component++) {
+      minimum[component] = Math.min(minimum[component], position[component]);
+      maximum[component] = Math.max(maximum[component], position[component]);
+    }
+  }
+  const center = minimum.map((value, index) => (value + maximum[index]) / 2);
+  const halfSize = minimum.map((value, index) => (maximum[index] - value) / 2);
+  return [center[0], center[1], center[2], halfSize[0], 0, 0, 0, halfSize[1], 0, 0, 0, halfSize[2]];
+}
+function getGeographicRegion(positions) {
+  const referenceLongitude = positions[0][0];
+  let minimumLongitude = Infinity;
+  let maximumLongitude = -Infinity;
+  let minimumLatitude = Infinity;
+  let maximumLatitude = -Infinity;
+  let minimumHeight = Infinity;
+  let maximumHeight = -Infinity;
+  for (const position of positions) {
+    const longitude = referenceLongitude + normalizeLongitude(position[0] - referenceLongitude);
+    minimumLongitude = Math.min(minimumLongitude, longitude);
+    maximumLongitude = Math.max(maximumLongitude, longitude);
+    minimumLatitude = Math.min(minimumLatitude, position[1]);
+    maximumLatitude = Math.max(maximumLatitude, position[1]);
+    minimumHeight = Math.min(minimumHeight, position[2]);
+    maximumHeight = Math.max(maximumHeight, position[2]);
+  }
+  return [
+    normalizeLongitude(minimumLongitude) * Math.PI / 180,
+    minimumLatitude * Math.PI / 180,
+    normalizeLongitude(maximumLongitude) * Math.PI / 180,
+    maximumLatitude * Math.PI / 180,
+    minimumHeight,
+    maximumHeight
+  ];
+}
+function normalizeLongitude(longitude) {
+  return ((longitude + 180) % 360 + 360) % 360 - 180;
+}
+
 // dist/tileset-3d/format-i3s/i3s-source.js
 var EMPTY_CONTENT_FORMATS2 = {
   draco: false,
@@ -5294,6 +6910,10 @@ var I3SSource = class {
   queryParams = {};
   resolver;
   rootTileset;
+  /** Spatial adapter created lazily after Tileset3D applies target options. */
+  spatialTransformer;
+  /** Root header prepared after asynchronous elevation sampling. */
+  preparedRootHeader;
   /**
    * Creates an I3S source.
    * @param input Root metadata request, or preloaded root metadata for tests and internal callers.
@@ -5309,6 +6929,7 @@ var I3SSource = class {
     this.resolver = request.resolver;
     this.coreApi = request.coreApi;
     this.loadOptions = loadOptions;
+    this.initializeQueryParams(loadOptions);
   }
   /**
    * Fetches and normalizes root I3S metadata for runtime consumption.
@@ -5316,19 +6937,12 @@ var I3SSource = class {
   async initialize() {
     var _a;
     if (!this.rootTileset) {
-      this.rootTileset = await this.loadRootData(this.url, this.loadOptions);
+      this.rootTileset = await this.loadRootData(this.getTileUrl(this.url), this.loadOptions);
     }
     this.tileset = this.rootTileset;
     if (this.rootTileset.root && typeof this.rootTileset.root.then === "function") {
       this.rootTileset.root = await this.rootTileset.root;
     }
-    const i3sOptions = this.loadOptions.i3s;
-    if (i3sOptions && typeof i3sOptions === "object" && "token" in i3sOptions) {
-      const token = i3sOptions.token;
-      if (typeof token === "string") {
-        this.queryParams.token = token;
-      }
-    }
     this.metadata = {
       type: this.type,
       loader: this.loader,
@@ -5337,7 +6951,8 @@ var I3SSource = class {
       tileset: this.rootTileset,
       lodMetricType: this.rootTileset.lodMetricType,
       lodMetricValue: this.rootTileset.lodMetricValue,
-      refine: (_a = this.rootTileset.root) == null ? void 0 : _a.refine
+      refine: (_a = this.rootTileset.root) == null ? void 0 : _a.refine,
+      spatialReference: getI3SSpatialReference(this.rootTileset)
     };
   }
   /**
@@ -5355,11 +6970,28 @@ var I3SSource = class {
   async getRootTileset() {
     return this.getMetadata().tileset;
   }
+  /** Prepare option-dependent spatial state and the asynchronously placed root bound. */
+  async prepareTileset(tileset) {
+    const spatialReference = tileset.spatialReference;
+    if (spatialReference.status === "unresolved") {
+      throw new Error(spatialReference.warnings[0] || "I3S spatial operations cannot be resolved from the supplied metadata and options");
+    }
+    if (spatialReference.status !== "transformable" && spatialReference.status !== "transformed") {
+      return;
+    }
+    this.spatialTransformer ||= new I3SSpatialTransformer(spatialReference, tileset.options.spatial);
+    tileset.spatialReference = this.spatialTransformer.spatialReference;
+    this.preparedRootHeader = await this.transformTileHeader(this.getMetadata().tileset.root);
+  }
   /**
    * Creates the runtime root tile for an I3S subtree.
    */
   initializeTileHeaders(tileset, tilesetJson, parentTile) {
-    const rootTile = new Tile3D(tileset, tilesetJson.root, parentTile || void 0);
+    const rootHeader = parentTile ? tilesetJson.root : this.preparedRootHeader || tilesetJson.root;
+    if (this.spatialTransformer && !this.preparedRootHeader) {
+      throw new Error("I3S spatial root header was not prepared before tile initialization");
+    }
+    const rootTile = new Tile3D(tileset, rootHeader, parentTile || void 0);
     if (parentTile) {
       parentTile.children.push(rootTile);
       rootTile.depth = parentTile.depth + 1;
@@ -5388,16 +7020,22 @@ var I3SSource = class {
         _tileOptions: {
           attributeUrls: tile.header.attributeUrls,
           textureUrl: tile.header.textureUrl,
+          textureUrls: tile.header.textureUrls,
           textureFormat: tile.header.textureFormat,
           textureLoaderOptions: tile.header.textureLoaderOptions,
           materialDefinition: tile.header.materialDefinition,
+          layerType: tile.header.layerType,
+          pointRenderer: tile.header.pointRenderer,
+          pointSymbol: tile.header.pointSymbol,
           isDracoGeometry: tile.header.isDracoGeometry,
           mbs: tile.header.mbs
         },
         _tilesetOptions: {
           store: metadata.tileset.store,
           attributeStorageInfo: metadata.tileset.attributeStorageInfo,
-          fields: metadata.tileset.fields
+          fields: metadata.tileset.fields,
+          spatialReference: tile.tileset.spatialReference,
+          spatialOptions: tile.tileset.options.spatial
         },
         isTileHeader: false
       }
@@ -5410,8 +7048,9 @@ var I3SSource = class {
    */
   async loadChildTileHeader(_parentTile, childId, _frameState) {
     const metadata = this.getMetadata();
-    if (metadata.tileset.nodePages) {
-      return await metadata.tileset.nodePagesTile.formTileFromNodePages(childId);
+    if (metadata.tileset.nodePages || metadata.tileset.pointNodePages) {
+      const header2 = await metadata.tileset.nodePagesTile.formTileFromNodePages(childId);
+      return await this.transformTileHeader(header2);
     }
     const nodeUrl = this.getTileUrl(`${this.url}/nodes/${childId}`);
     const i3sLoaderOptions = this.loadOptions.i3s && typeof this.loadOptions.i3s === "object" ? this.loadOptions.i3s : {};
@@ -5422,7 +7061,8 @@ var I3SSource = class {
         isTileHeader: true
       }
     };
-    return await this.loadResourceData(nodeUrl, options);
+    const header = await this.loadResourceData(nodeUrl, options);
+    return await this.transformTileHeader(header);
   }
   /**
    * Resolves an I3S request URL with source-managed query parameters.
@@ -5434,21 +7074,51 @@ var I3SSource = class {
     if (!Object.keys(this.queryParams).length) {
       return tilePath;
     }
-    const queryParams = new URLSearchParams(this.queryParams).toString();
-    return `${tilePath}${tilePath.includes("?") ? "&" : "?"}${queryParams}`;
+    const queryDelimiterIndex = tilePath.indexOf("?");
+    if (queryDelimiterIndex === -1) {
+      return `${tilePath}?${new URLSearchParams(this.queryParams).toString()}`;
+    }
+    const existingQuery = tilePath.slice(queryDelimiterIndex + 1);
+    const existingQueryKeys = new Set(existingQuery.split("&").map((parameter) => parameter.split("=", 1)[0]));
+    const queryParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(this.queryParams)) {
+      if (!existingQueryKeys.has(key)) {
+        queryParams.set(key, value);
+      }
+    }
+    const queryString = queryParams.toString();
+    return queryString ? `${tilePath}${existingQuery ? "&" : ""}${queryString}` : tilePath;
   }
   /**
    * Derives the default view state from full extent or store extent metadata.
    */
-  getViewState(_rootTile) {
+  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));
+      if (this.spatialTransformer.targetCoordinateFrame === "geographic") {
+        return {
+          boundingVolume: rootTile.boundingVolume,
+          cartographicCenter,
+          cartesianCenter: center,
+          zoom: 1
+        };
+      }
+      return {
+        boundingVolume: rootTile.boundingVolume,
+        cartographicCenter,
+        cartesianCenter: center,
+        zoom: 1
+      };
+    }
     const metadata = this.getMetadata();
     const fullExtent = metadata.tileset.fullExtent;
     if (fullExtent) {
       const { xmin, xmax, ymin, ymax, zmin, zmax } = fullExtent;
-      const cartographicCenter = new import_core11.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, zmin + (zmax - zmin) / 2);
-      const cartesianCenter = new import_core11.Vector3();
-      import_geospatial8.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
+      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);
       return {
         cartographicCenter,
         cartesianCenter,
@@ -5458,9 +7128,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_core11.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, 0);
-      const cartesianCenter = new import_core11.Vector3();
-      import_geospatial8.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
+      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);
       return {
         cartographicCenter,
         cartesianCenter,
@@ -5469,7 +7139,7 @@ var I3SSource = class {
     }
     console.warn("Extent is not defined in the tileset header");
     return {
-      cartographicCenter: new import_core11.Vector3(),
+      cartographicCenter: new import_core13.Vector3(),
       zoom: 1
     };
   }
@@ -5516,6 +7186,19 @@ var I3SSource = class {
     }
     return await this.loadWithCoreApi(url, options);
   }
+  /**
+   * Initializes query parameters before any URL-backed resource is requested.
+   * @param loadOptions Loader options that may contain an ArcGIS token.
+   */
+  initializeQueryParams(loadOptions) {
+    const i3sOptions = loadOptions.i3s;
+    if (i3sOptions && typeof i3sOptions === "object" && "token" in i3sOptions) {
+      const token = i3sOptions.token;
+      if (typeof token === "string") {
+        this.queryParams.token = token;
+      }
+    }
+  }
   /**
    * Loads tile metadata or content through an injected resolver when present, otherwise through the injected core API.
    */
@@ -5525,6 +7208,27 @@ var I3SSource = class {
     }
     return await this.loadWithCoreApi(url, options);
   }
+  /** Transform one I3S header bound after target options and elevation providers are available. */
+  async transformTileHeader(header) {
+    var _a;
+    if (!this.spatialTransformer) {
+      return header;
+    }
+    const sourceBounds = {
+      mbs: header.mbs,
+      obb: header.obb,
+      normalReferenceFrame: (_a = this.getMetadata().tileset.store) == null ? void 0 : _a.normalReferenceFrame
+    };
+    const transformedBounds = await this.spatialTransformer.transformBoundsAsync(sourceBounds);
+    return {
+      ...header,
+      // Tileset3D traversal and culling operate in WGS84 ECEF independently of content output.
+      boundingVolume: transformedBounds.boundingVolume,
+      // Preserve the renderer/output-frame bound for applications and content coordination.
+      spatialBoundingVolume: transformedBounds.spatialBoundingVolume,
+      i3sLodMbs: transformedBounds.i3sLodMbs
+    };
+  }
 };
 function isTilesetRequest2(input) {
   return Boolean(input && typeof input === "object" && "url" in input && "loader" in input && !("type" in input));
@@ -6520,6 +8224,10 @@ var RasterSet = class _RasterSet {
   static fromRasterSource(rasterSource, opts = {}) {
     return new _RasterSet({ ...opts, rasterSource });
   }
+  /** Convenience factory for sources whose requests are not viewport-shaped. */
+  static fromCallbacks(opts) {
+    return new _RasterSet(opts);
+  }
   /** Whether the manager has no requests in flight and a current raster. */
   get isLoaded() {
     return this._loadCounter === 0 && Boolean(this._currentRequest);
@@ -6630,7 +8338,7 @@ var RasterSet = class _RasterSet {
     try {
       const abortController = new AbortController();
       this._abortController = abortController;
-      const raster = await this._opts.getRaster({ ...parameters, signal: abortController.signal });
+      const raster = await this._opts.getRaster(withAbortSignal(parameters, abortController.signal));
       if (this._finalized || abortController.signal.aborted || requestId <= this._lastAcceptedRequestId) {
         return;
       }
@@ -6724,6 +8432,16 @@ var RasterSet = class _RasterSet {
     this._abortController = null;
   }
 };
+function withAbortSignal(parameters, signal) {
+  const request = Array.isArray(parameters) ? parameters.slice() : Object.create(Object.getPrototypeOf(parameters), Object.getOwnPropertyDescriptors(parameters));
+  Object.defineProperty(request, "signal", {
+    configurable: true,
+    enumerable: true,
+    value: signal,
+    writable: true
+  });
+  return request;
+}
 function normalizeRasterSetError(error, message) {
   if (error instanceof Error) {
     return error;
@@ -6738,7 +8456,7 @@ function isAbortError3(error) {
 }
 
 // dist/point-cloud/point-cloud-tileset.js
-var import_core12 = require("@math.gl/core");
+var import_core14 = require("@math.gl/core");
 var import_culling6 = require("@math.gl/culling");
 
 // dist/point-cloud/point-cloud-tile.js
@@ -6811,6 +8529,8 @@ var DEFAULT_PROPS5 = {
   debounceTime: 0,
   minimumNodePixelSize: 150,
   maximumScreenSpaceError: 1,
+  lodSelectionMetricType: "maxScreenThresholdSQ",
+  densityThreshold: 1,
   pointBudget: 2e6,
   maxDepth: Number.POSITIVE_INFINITY,
   onTileLoad: () => {
@@ -6900,7 +8620,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_core12.Vector3(center);
+    this.cartographicCenter = new import_core14.Vector3(center);
     this.zoom = (viewState == null ? void 0 : viewState.zoom) || this.estimateZoom(this.boundingVolume);
   }
   /**
@@ -6994,6 +8714,12 @@ var PointCloudTileset = class {
   }
   /** Whether a tile should refine to children based on its projected screen radius. */
   shouldRefine(tile, traversalWeight) {
+    if (tile.level < this.options.maxDepth && Number.isFinite(traversalWeight) && (tile.header.lodSelectionMetricType || this.options.lodSelectionMetricType) === "density-threshold") {
+      const projectedArea = Math.max(1, Math.PI * traversalWeight * traversalWeight);
+      const density = tile.pointCount / projectedArea;
+      const threshold = tile.header.lodThreshold || this.options.densityThreshold;
+      return density < threshold;
+    }
     return tile.level < this.options.maxDepth && Number.isFinite(traversalWeight) && traversalWeight >= this.options.minimumNodePixelSize;
   }
   /**
@@ -7191,9 +8917,13 @@ var PointCloudTileset = class {
     if (!boundingVolume) {
       return 1;
     }
+    if (boundingVolume.coordinateFrame === "cartesian") {
+      return 1;
+    }
     const [minBounds, maxBounds] = boundingVolume.cartographicBounds;
-    const longitudeSpan = Math.max(Math.abs(maxBounds[0] - minBounds[0]), 1e-6);
-    return Math.max(1, Math.round(Math.log2(360 / longitudeSpan)));
+    const longitudeSpan = boundingVolume.coversFullLongitude ? 360 : boundingVolume.wrapsDateline ? 360 - Math.abs(maxBounds[0] - minBounds[0]) : Math.abs(maxBounds[0] - minBounds[0]);
+    const normalizedLongitudeSpan = Math.max(longitudeSpan, 1e-6);
+    return Math.max(1, Math.round(Math.log2(360 / normalizedLongitudeSpan)));
   }
   haveSameIds(idsA, idsB) {
     if (idsA.size !== idsB.size) {
@@ -7211,16 +8941,32 @@ var PointCloudTileset = class {
    */
   getBoundingVolumeCorners(boundingVolume) {
     const [minBounds, maxBounds] = boundingVolume.cartographicBounds;
-    return [
-      [minBounds[0], minBounds[1], minBounds[2] || 0],
-      [minBounds[0], minBounds[1], maxBounds[2] || 0],
-      [minBounds[0], maxBounds[1], minBounds[2] || 0],
-      [minBounds[0], maxBounds[1], maxBounds[2] || 0],
-      [maxBounds[0], minBounds[1], minBounds[2] || 0],
-      [maxBounds[0], minBounds[1], maxBounds[2] || 0],
-      [maxBounds[0], maxBounds[1], minBounds[2] || 0],
-      [maxBounds[0], maxBounds[1], maxBounds[2] || 0]
-    ];
+    const longitudeIntervals = boundingVolume.coversFullLongitude ? [[-180, 180]] : boundingVolume.wrapsDateline ? [
+      [minBounds[0], 180],
+      [-180, maxBounds[0]]
+    ] : [[minBounds[0], maxBounds[0]]];
+    const corners = [];
+    const wrappedLongitudeSpan = 360 - Math.abs(maxBounds[0] - minBounds[0]);
+    const longitudeReference = minBounds[0] + wrappedLongitudeSpan / 2;
+    for (const [minimumLongitude, maximumLongitude] of longitudeIntervals) {
+      const normalizeLongitude2 = (longitude) => {
+        if (!boundingVolume.wrapsDateline) {
+          return longitude;
+        }
+        let normalizedLongitude = longitude;
+        while (normalizedLongitude - longitudeReference > 180) {
+          normalizedLongitude -= 360;
+        }
+        while (normalizedLongitude - longitudeReference < -180) {
+          normalizedLongitude += 360;
+        }
+        return normalizedLongitude;
+      };
+      const unwrappedMinimumLongitude = normalizeLongitude2(minimumLongitude);
+      const unwrappedMaximumLongitude = normalizeLongitude2(maximumLongitude);
+      corners.push([unwrappedMinimumLongitude, minBounds[1], minBounds[2] || 0], [unwrappedMinimumLongitude, minBounds[1], maxBounds[2] || 0], [unwrappedMinimumLongitude, maxBounds[1], minBounds[2] || 0], [unwrappedMinimumLongitude, maxBounds[1], maxBounds[2] || 0], [unwrappedMaximumLongitude, minBounds[1], minBounds[2] || 0], [unwrappedMaximumLongitude, minBounds[1], maxBounds[2] || 0], [unwrappedMaximumLongitude, maxBounds[1], minBounds[2] || 0], [unwrappedMaximumLongitude, maxBounds[1], maxBounds[2] || 0]);
+    }
+    return corners;
   }
   /**
    * Build a culling volume directly from the viewport frustum in common space.