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

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // dist/index.js
@@ -26,6 +36,7 @@ __export(index_exports, {
   IndexedArchiveTilesetSource: () => IndexedArchiveTilesetSource,
   LOD_METRIC_TYPE: () => LOD_METRIC_TYPE,
   PointCloudTile: () => PointCloudTile,
+  PointCloudTileSourceLoader: () => PointCloudTileSourceLoader,
   PointCloudTileset: () => PointCloudTileset,
   RasterSet: () => RasterSet,
   STRATEGY_DEFAULT: () => STRATEGY_DEFAULT,
@@ -72,1701 +83,202 @@ module.exports = __toCommonJS(index_exports);
 // dist/tileset-3d/common/tileset-3d.js
 var import_core5 = require("@math.gl/core");
 var import_geospatial3 = require("@math.gl/geospatial");
-var import_stats3 = require("@probe.gl/stats");
 
-// ../loader-utils/src/lib/env-utils/assert.ts
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message || "loader assertion failed.");
+// ../../node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
+function getHiResTimestamp() {
+  let timestamp;
+  if (typeof window !== "undefined" && window.performance) {
+    timestamp = window.performance.now();
+  } else if (typeof process !== "undefined" && process.hrtime) {
+    const timeParts = process.hrtime();
+    timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+  } else {
+    timestamp = Date.now();
   }
+  return timestamp;
 }
 
-// ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
-function sliceArrayBuffer(arrayBuffer, byteOffset, byteLength) {
-  const subArray = byteLength !== void 0 ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength) : new Uint8Array(arrayBuffer).subarray(byteOffset);
-  const arrayCopy = new Uint8Array(subArray);
-  return arrayCopy.buffer;
-}
-
-// ../loader-utils/src/lib/request-utils/request-scheduler.ts
-var import_stats = require("@probe.gl/stats");
-var STAT_QUEUED_REQUESTS = "Queued Requests";
-var STAT_ACTIVE_REQUESTS = "Active Requests";
-var STAT_CANCELLED_REQUESTS = "Cancelled Requests";
-var STAT_QUEUED_REQUESTS_EVER = "Queued Requests Ever";
-var STAT_ACTIVE_REQUESTS_EVER = "Active Requests Ever";
-var DEFAULT_PROPS = {
-  id: "request-scheduler",
-  /** Specifies if the request scheduler should throttle incoming requests, mainly for comparative testing. */
-  throttleRequests: true,
-  /** The maximum number of simultaneous active requests. Un-throttled requests do not observe this limit. */
-  maxRequests: 6,
-  /**
-   * Specifies a debounce time, in milliseconds. All requests are queued, until no new requests have
-   * been added to the queue for this amount of time.
-   */
-  debounceTime: 0
-};
-var RequestScheduler = class {
-  props;
-  stats;
-  activeRequestCount = 0;
-  /** Tracks the number of active requests and prioritizes/cancels queued requests. */
-  requestQueue = [];
-  requestMap = /* @__PURE__ */ new Map();
-  /** Pending arrival debounce or next-tick refill; only new arrivals replace this timer. */
-  updateTimer = null;
-  constructor(props = {}) {
-    this.props = { ...DEFAULT_PROPS, ...props };
-    this.stats = new import_stats.Stats({ id: this.props.id });
-    this.stats.get(STAT_QUEUED_REQUESTS);
-    this.stats.get(STAT_ACTIVE_REQUESTS);
-    this.stats.get(STAT_CANCELLED_REQUESTS);
-    this.stats.get(STAT_QUEUED_REQUESTS_EVER);
-    this.stats.get(STAT_ACTIVE_REQUESTS_EVER);
-  }
-  /**
-   * Update scheduler props. Preserves active and queued requests.
-   */
-  setProps(props) {
-    if (props.throttleRequests !== void 0) {
-      this.props.throttleRequests = props.throttleRequests;
-    }
-    if (props.maxRequests !== void 0) {
-      this.props.maxRequests = props.maxRequests;
-    }
-    if (props.debounceTime !== void 0) {
-      this.props.debounceTime = props.debounceTime;
-    }
-  }
-  /**
-   * Called by an application that wants to issue a request, without having it deeply queued by the browser
-   *
-   * When the returned promise resolved, it is OK for the application to issue a request.
-   * The promise resolves to an object that contains a `done` method.
-   * When the application's request has completed (or failed), the application must call the `done` function
-   *
-   * @param handle
-   * @param getPriority will be called when request "slots" open up,
-   *    allowing the caller to update priority or cancel the request
-   *    Highest priority executes first, priority < 0 cancels the request
-   * @returns a promise
-   *   - resolves to a object (with a `done` field) when the request can be issued without queueing,
-   *   - resolves to `null` if the request has been cancelled (by the callback return < 0).
-   *     In this case the application should not issue the request
-   */
-  scheduleRequest(handle, getPriority = () => 0) {
-    if (!this.props.throttleRequests) {
-      return Promise.resolve({ done: () => {
-      } });
-    }
-    if (this.requestMap.has(handle)) {
-      return this.requestMap.get(handle);
-    }
-    const request = { handle, priority: 0, getPriority };
-    const promise = new Promise((resolve2) => {
-      request.resolve = resolve2;
-      return request;
-    });
-    this.requestQueue.push(request);
-    this.requestMap.set(handle, promise);
-    this._issueNewRequests();
-    return promise;
-  }
-  // PRIVATE
-  _issueRequest(request) {
-    const { handle, resolve: resolve2 } = request;
-    let isDone = false;
-    const done = () => {
-      if (!isDone) {
-        isDone = true;
-        this.requestMap.delete(handle);
-        this.activeRequestCount--;
-        this.scheduleRefill();
-      }
-    };
-    this.activeRequestCount++;
-    return resolve2 ? resolve2({ done }) : Promise.resolve({ done });
-  }
-  /** Refills freed slots on the next tick while preserving any pending arrival debounce. */
-  scheduleRefill() {
-    if (this.updateTimer !== null) {
-      return;
-    }
-    this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), 0);
+// ../../node_modules/@probe.gl/stats/dist/lib/stat.js
+var Stat = class {
+  constructor(name, type) {
+    this.sampleSize = 1;
+    this.time = 0;
+    this.count = 0;
+    this.samples = 0;
+    this.lastTiming = 0;
+    this.lastSampleTime = 0;
+    this.lastSampleCount = 0;
+    this._count = 0;
+    this._time = 0;
+    this._samples = 0;
+    this._startTime = 0;
+    this._timerPending = false;
+    this.name = name;
+    this.type = type;
+    this.reset();
   }
-  /** Restarts the quiet period when a new request enters the queue. */
-  _issueNewRequests() {
-    if (this.updateTimer !== null) {
-      clearTimeout(this.updateTimer);
-    }
-    this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime);
+  reset() {
+    this.time = 0;
+    this.count = 0;
+    this.samples = 0;
+    this.lastTiming = 0;
+    this.lastSampleTime = 0;
+    this.lastSampleCount = 0;
+    this._count = 0;
+    this._time = 0;
+    this._samples = 0;
+    this._startTime = 0;
+    this._timerPending = false;
+    return this;
   }
-  /** Clears timer ownership before updating priorities and dispatching queued requests. */
-  _issueNewRequestsAsync() {
-    if (this.updateTimer !== null) {
-      clearTimeout(this.updateTimer);
-    }
-    this.updateTimer = null;
-    const freeSlots = Math.max(this.props.maxRequests - this.activeRequestCount, 0);
-    if (freeSlots === 0) {
-      return;
-    }
-    this._updateAllRequests();
-    for (let i = 0; i < freeSlots; ++i) {
-      const request = this.requestQueue.shift();
-      if (request) {
-        this._issueRequest(request);
-      }
-    }
+  setSampleSize(samples) {
+    this.sampleSize = samples;
+    return this;
   }
-  /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
-  _updateAllRequests() {
-    const requestQueue = this.requestQueue;
-    for (let i = 0; i < requestQueue.length; ++i) {
-      const request = requestQueue[i];
-      if (!this._updateRequest(request)) {
-        requestQueue.splice(i, 1);
-        this.requestMap.delete(request.handle);
-        i--;
-      }
-    }
-    requestQueue.sort((a, b) => a.priority - b.priority);
+  /** Call to increment count (+1) */
+  incrementCount() {
+    this.addCount(1);
+    return this;
   }
-  /** Update a single request by calling the callback */
-  _updateRequest(request) {
-    request.priority = request.getPriority(request.handle);
-    if (request.priority < 0) {
-      request.resolve(null);
-      return false;
-    }
-    return true;
+  /** Call to decrement count (-1) */
+  decrementCount() {
+    this.subtractCount(1);
+    return this;
   }
-};
-
-// ../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;
+  /** Increase count */
+  addCount(value) {
+    this._count += value;
+    this._samples++;
+    this._checkSampling();
+    return this;
   }
-  /** 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;
+  /** Decrease count */
+  subtractCount(value) {
+    this._count -= value;
+    this._samples++;
+    this._checkSampling();
+    return this;
   }
-  /** Estimated bytes retained by settled entries. */
-  get byteLength() {
-    return this.retainedByteLength;
+  /** Add an arbitrary timing and bump the count */
+  addTime(time) {
+    this._time += time;
+    this.lastTiming = time;
+    this._samples++;
+    this._checkSampling();
+    return this;
   }
-  /** 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;
+  /** Start a timer */
+  timeStart() {
+    this._startTime = getHiResTimestamp();
+    this._timerPending = true;
+    return this;
   }
-  /**
-   * 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);
+  /** End a timer. Adds to time and bumps the timing count. */
+  timeEnd() {
+    if (!this._timerPending) {
+      return this;
     }
-    return this.waitForEntry(key, entry, signal);
+    this.addTime(getHiResTimestamp() - this._startTime);
+    this._timerPending = false;
+    this._checkSampling();
+    return this;
   }
-  /** Removes one cached or pending request. */
-  delete(key) {
-    return this.removeEntry(key, "delete");
+  getSampleAverageCount() {
+    return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
   }
-  /** Aborts pending requests and removes every entry. */
-  clear() {
-    for (const key of Array.from(this.entries.keys())) {
-      this.removeEntry(key, "clear");
-    }
+  /** Calculate average time / count for the previous window */
+  getSampleAverageTime() {
+    return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
   }
-  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();
+  /** Calculate counts per second for the previous window */
+  getSampleHz() {
+    return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
   }
-  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");
-    }
+  getAverageCount() {
+    return this.samples > 0 ? this.count / this.samples : 0;
   }
-  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);
-        }
-      );
-    });
+  /** Calculate average time / count */
+  getAverageTime() {
+    return this.samples > 0 ? this.time / this.samples : 0;
   }
-  touch(key, entry) {
-    this.entries.delete(key);
-    this.entries.set(key, entry);
+  /** Calculate counts per second */
+  getHz() {
+    return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
   }
-  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;
-      }
+  _checkSampling() {
+    if (this._samples === this.sampleSize) {
+      this.lastSampleTime = this._time;
+      this.lastSampleCount = this._count;
+      this.count += this._count;
+      this.time += this._time;
+      this.samples += this._samples;
+      this._time = 0;
+      this._count = 0;
+      this._samples = 0;
     }
   }
-  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 = {
-  logicalRanges: "Logical Range Requests",
-  rangeBatches: "Range Request Batches",
-  transportRanges: "Transport Ranges Created",
-  completedTransportRanges: "Range Transport Requests Completed",
-  coalescedRanges: "Coalesced Logical Ranges",
-  requestedBytes: "Logical Range Request Bytes",
-  transportBytes: "Range Transport Bytes Requested",
-  responseBytes: "Range Response Bytes",
-  networkTimeMs: "Range Network Time",
-  overfetchBytes: "Range Overfetch Bytes",
-  failedTransportRanges: "Range Transport Requests Failed",
-  abortedLogicalRanges: "Aborted Logical Range Requests",
-  fullResponseFallbacks: "Full Response Fallbacks"
-};
-var DEFAULT_PROPS2 = {
-  batchDelayMs: 50,
-  maxGapBytes: 65536,
-  rangeExpansionBytes: 65536,
-  maxMergedBytes: 8388608,
-  maxConcurrency: 6,
-  maxQueueSize: 4096,
-  maxRangeBytes: 64 * 1024 * 1024,
-  stats: createRangeStats("range-request-scheduler-default"),
-  onEvent: () => {
-  }
-};
-var RangeRequestScheduler = class {
-  /** Runtime scheduler configuration with defaults filled in. */
-  props;
-  /** Runtime counters for range batching and transport behavior. */
-  stats;
-  /** Optional event callback for range batching diagnostics. */
-  onEvent;
-  pendingRequests = [];
-  /** Merged transports waiting for a concurrency slot. */
-  transportQueue = [];
-  /** Number of active transports. */
-  activeTransports = 0;
-  /** Number of unsettled logical requests. */
-  queuedRequests = 0;
-  /** Unsettled requests retained until completion or disposal. */
-  logicalRequests = /* @__PURE__ */ new Set();
-  /** Controllers for transports owned by this scheduler. */
-  transportControllers = /* @__PURE__ */ new Set();
-  /** Disposal prevents further enqueueing. */
-  finalized = false;
-  /** Pending batch window, independent of in-flight transport requests. */
-  flushTimer = null;
-  /** Creates a scheduler for one group of byte-range-addressable resources. */
-  constructor(props = {}) {
-    const rangeExpansionBytes = props.rangeExpansionBytes ?? props.maxGapBytes ?? DEFAULT_PROPS2.rangeExpansionBytes;
-    this.props = {
-      batchDelayMs: props.batchDelayMs ?? DEFAULT_PROPS2.batchDelayMs,
-      maxGapBytes: props.maxGapBytes ?? rangeExpansionBytes,
-      rangeExpansionBytes,
-      maxMergedBytes: props.maxMergedBytes ?? DEFAULT_PROPS2.maxMergedBytes,
-      maxConcurrency: props.maxConcurrency ?? 6,
-      maxQueueSize: props.maxQueueSize ?? 4096,
-      maxRangeBytes: props.maxRangeBytes ?? 64 * 1024 * 1024
-    };
-    for (const value of [
-      this.props.maxConcurrency,
-      this.props.maxQueueSize,
-      this.props.maxRangeBytes
-    ]) {
-      if (!Number.isSafeInteger(value) || value <= 0)
-        throw new Error("Range scheduler limits must be positive integers");
-    }
-    this.stats = props.stats || createRangeStats("range-request-scheduler");
-    this.onEvent = props.onEvent;
-    initializeStats(this.stats);
-  }
-  /**
-   * Enqueues one byte range request and resolves with the exact requested byte slice.
-   */
-  scheduleRequest(request) {
-    var _a;
-    if (this.finalized) return Promise.reject(new Error("Range scheduler is finalized"));
-    if (!Number.isSafeInteger(request.offset) || request.offset < 0 || !Number.isSafeInteger(request.length) || request.length > this.props.maxRangeBytes || !Number.isSafeInteger(request.offset + request.length))
-      return Promise.reject(new Error("Invalid or oversized byte range"));
-    if (this.queuedRequests >= this.props.maxQueueSize)
-      return Promise.reject(new Error("Range scheduler queue limit exceeded"));
-    if (request.length < 0) {
-      return Promise.reject(new Error("Byte range length cannot be negative"));
-    }
-    if ((_a = request.signal) == null ? void 0 : _a.aborted) {
-      return Promise.reject(request.signal.reason ?? createAbortError2());
-    }
-    if (request.length === 0) {
-      return Promise.resolve(new ArrayBuffer(0));
-    }
-    this.queuedRequests++;
-    let pendingRequest;
-    const promise = new Promise((resolve2, reject) => {
-      pendingRequest = { ...request, resolve: resolve2, reject, settled: false };
-      this.logicalRequests.add(pendingRequest);
-      if (request.signal) {
-        pendingRequest.abortListener = () => {
-          var _a2;
-          this.abortRequest(pendingRequest);
-          (_a2 = pendingRequest.onAbort) == null ? void 0 : _a2.call(pendingRequest);
-        };
-        request.signal.addEventListener("abort", pendingRequest.abortListener, { once: true });
-      }
-      this.pendingRequests.push(pendingRequest);
-    });
-    this.trackEvent({
-      type: "queued",
-      sourceId: request.sourceId,
-      offset: request.offset,
-      length: request.length,
-      logicalRequestCount: 1,
-      logicalBytes: request.length
-    });
-    this.scheduleFlush();
-    return promise.finally(() => {
-      var _a2;
-      if (pendingRequest.abortListener)
-        (_a2 = request.signal) == null ? void 0 : _a2.removeEventListener("abort", pendingRequest.abortListener);
-      this.queuedRequests--;
-      this.logicalRequests.delete(pendingRequest);
-    });
-  }
-  /**
-   * Enqueues one HTTP byte-range request and resolves with the exact requested byte slice.
-   */
-  fetch(request) {
-    const fetchFunction = request.fetch || globalThis.fetch;
-    return this.scheduleRequest({
-      sourceId: request.sourceId || request.url,
-      offset: request.offset,
-      length: request.length,
-      signal: request.signal,
-      // Different fetch calls may carry different credentials or transport implementations.
-      // Sharing is therefore opt-in through an explicit common isolation key.
-      isolationKey: request.isolationKey ?? {},
-      fetchRange: (offset, length, signal) => fetchHttpRange({
-        url: request.url,
-        offset,
-        length,
-        signal,
-        fetch: fetchFunction,
-        fetchOptions: request.fetchOptions
-      })
-    });
-  }
-  /** Immediately starts loading the currently queued requests. */
-  flush() {
-    if (this.flushTimer !== null) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-    const pendingRequests = this.pendingRequests;
-    this.pendingRequests = [];
-    const activeRequests = pendingRequests.filter((request) => {
-      var _a;
-      if (request.settled || ((_a = request.signal) == null ? void 0 : _a.aborted)) {
-        this.abortRequest(request);
-        return false;
-      }
-      return true;
-    });
-    const mergedRequests = this.mergeRequests(activeRequests);
-    if (activeRequests.length > 0) {
-      this.trackBatch(activeRequests, mergedRequests);
-    }
-    this.transportQueue.push(...mergedRequests);
-    this.startQueuedTransports();
+// ../../node_modules/@probe.gl/stats/dist/lib/stats.js
+var Stats = class {
+  constructor(options) {
+    this.stats = {};
+    this.id = options.id;
+    this.stats = {};
+    this._initializeStats(options.stats);
+    Object.seal(this);
   }
-  /** Cancels owned work and releases queued resources; borrowed users must not finalize shared schedulers. */
-  finalize() {
-    var _a;
-    this.finalized = true;
-    if (this.flushTimer !== null) clearTimeout(this.flushTimer);
-    this.flushTimer = null;
-    for (const request of this.logicalRequests) {
-      this.abortRequest(request);
-      if (request.abortListener)
-        (_a = request.signal) == null ? void 0 : _a.removeEventListener("abort", request.abortListener);
-    }
-    for (const controller of this.transportControllers) controller.abort();
-    this.transportQueue = [];
-    this.pendingRequests = [];
-    this.logicalRequests.clear();
-  }
-  /** Starts transports while respecting the configured concurrency bound. */
-  startQueuedTransports() {
-    while (this.activeTransports < this.props.maxConcurrency && this.transportQueue.length) {
-      const request = this.transportQueue.shift();
-      this.activeTransports++;
-      void this.fetchMergedRequest(request).finally(() => {
-        this.activeTransports--;
-        this.startQueuedTransports();
-      });
-    }
+  /** Acquire a stat. Create if it doesn't exist. */
+  get(name, type = "count") {
+    return this._getOrCreate({ name, type });
   }
-  /** Starts a fixed batch window only when no flush is already scheduled. */
-  scheduleFlush() {
-    if (this.flushTimer !== null) {
-      return;
-    }
-    this.flushTimer = setTimeout(() => this.flush(), this.props.batchDelayMs);
+  get size() {
+    return Object.keys(this.stats).length;
   }
-  /** Sorts active requests and combines requests for the same source when thresholds allow. */
-  mergeRequests(requests) {
-    requests.sort((left, right) => {
-      if (left.sourceId !== right.sourceId) {
-        return left.sourceId < right.sourceId ? -1 : 1;
-      }
-      return left.offset - right.offset;
-    });
-    const mergedRequests = [];
-    for (const request of requests) {
-      const requestEndOffset = request.offset + request.length;
-      const lastMergedRequest = mergedRequests[mergedRequests.length - 1];
-      if (lastMergedRequest && canMergeRequests(lastMergedRequest, request, this.props)) {
-        lastMergedRequest.endOffset = Math.max(lastMergedRequest.endOffset, requestEndOffset);
-        lastMergedRequest.requests.push(request);
-      } else {
-        mergedRequests.push({
-          sourceId: request.sourceId,
-          isolationKey: request.isolationKey ?? request.sourceId,
-          offset: request.offset,
-          endOffset: requestEndOffset,
-          fetchRange: request.fetchRange,
-          requests: [request]
-        });
-      }
+  /** Reset all stats */
+  reset() {
+    for (const stat of Object.values(this.stats)) {
+      stat.reset();
     }
-    return mergedRequests;
+    return this;
   }
-  /** Loads one merged range and resolves each child request with its sliced bytes. */
-  async fetchMergedRequest(mergedRequest) {
-    var _a, _b;
-    const { offset, endOffset, fetchRange, requests } = mergedRequest;
-    const abortController = new AbortController();
-    this.transportControllers.add(abortController);
-    const requestStartTime = getTimestamp();
-    const abortTransportIfUnused = () => {
-      if (requests.every((request) => {
-        var _a2;
-        return request.settled || ((_a2 = request.signal) == null ? void 0 : _a2.aborted);
-      })) {
-        abortController.abort();
-      }
-    };
-    try {
-      for (const request of requests) {
-        request.onAbort = abortTransportIfUnused;
-      }
-      abortTransportIfUnused();
-      if (requests.every((request) => request.settled)) {
-        return;
-      }
-      const logicalBytes = getLogicalRequestBytes(requests);
-      const length = endOffset - offset;
-      this.trackEvent({
-        type: "request",
-        sourceId: mergedRequest.sourceId,
-        offset,
-        length,
-        logicalRequestCount: requests.length,
-        logicalBytes,
-        transportBytes: length,
-        overfetchBytes: Math.max(length - logicalBytes, 0)
-      });
-      const transportResult = normalizeTransportResult(
-        await fetchRange(offset, length, abortController.signal)
-      );
-      const { arrayBuffer } = transportResult;
-      const isClampedFullResponse = transportResult.fullResponse && offset === 0 && arrayBuffer.byteLength < length;
-      const isClampedEndOfFile = arrayBuffer.byteLength < length && Number.isSafeInteger(transportResult.sourceByteLength) && offset + arrayBuffer.byteLength === transportResult.sourceByteLength;
-      if (arrayBuffer.byteLength !== length && !isClampedFullResponse && !isClampedEndOfFile) {
-        throw new Error(
-          `Byte-range transport returned ${arrayBuffer.byteLength} bytes; expected ${length}`
-        );
-      }
-      const networkTimeMs = transportResult.networkTimeMs ?? getTimestamp() - requestStartTime;
-      this.trackEvent({
-        type: "response",
-        sourceId: mergedRequest.sourceId,
-        offset,
-        length,
-        logicalRequestCount: requests.length,
-        logicalBytes,
-        transportBytes: length,
-        responseBytes: transportResult.transportBytes ?? arrayBuffer.byteLength,
-        networkTimeMs,
-        overfetchBytes: Math.max(length - logicalBytes, 0),
-        status: transportResult.status,
-        fullResponse: transportResult.fullResponse
-      });
-      for (const request of requests) {
-        if (request.settled) {
-          continue;
-        }
-        const start = request.offset - offset;
-        request.settled = true;
-        request.resolve(arrayBuffer.slice(start, start + request.length));
-      }
-    } catch (error) {
-      if (!abortController.signal.aborted) {
-        this.trackEvent({
-          type: "error",
-          sourceId: mergedRequest.sourceId,
-          offset,
-          length: endOffset - offset,
-          logicalRequestCount: requests.length,
-          logicalBytes: getLogicalRequestBytes(requests),
-          networkTimeMs: getTimestamp() - requestStartTime,
-          error
-        });
-      }
-      for (const request of requests) {
-        if (request.settled) {
-          continue;
-        }
-        if ((_a = request.signal) == null ? void 0 : _a.aborted) {
-          this.abortRequest(request);
-        } else {
-          request.settled = true;
-          request.reject(error);
-        }
-      }
-    } finally {
-      this.transportControllers.delete(abortController);
-      for (const request of requests) {
-        if (request.abortListener) {
-          (_b = request.signal) == null ? void 0 : _b.removeEventListener("abort", request.abortListener);
-        }
-        request.onAbort = void 0;
-      }
+  forEach(fn) {
+    for (const stat of Object.values(this.stats)) {
+      fn(stat);
     }
   }
-  /** Rejects and tracks one logical request exactly once when its caller aborts. */
-  abortRequest(request) {
-    var _a;
-    if (request.settled) {
-      return;
-    }
-    request.settled = true;
-    this.pendingRequests = this.pendingRequests.filter((pending) => pending !== request);
-    for (const group of this.transportQueue) {
-      group.requests = group.requests.filter((pending) => !pending.settled);
-      if (group.requests.length) {
-        group.offset = Math.min(...group.requests.map((pending) => pending.offset));
-        group.endOffset = Math.max(
-          ...group.requests.map((pending) => pending.offset + pending.length)
-        );
-      }
-    }
-    this.transportQueue = this.transportQueue.filter((group) => group.requests.length > 0);
-    request.reject(((_a = request.signal) == null ? void 0 : _a.reason) ?? createAbortError2());
-    this.trackEvent({
-      type: "abort",
-      sourceId: request.sourceId,
-      offset: request.offset,
-      length: request.length,
-      logicalRequestCount: 1,
-      logicalBytes: request.length
+  getTable() {
+    const table = {};
+    this.forEach((stat) => {
+      table[stat.name] = {
+        time: stat.time || 0,
+        count: stat.count || 0,
+        average: stat.getAverageTime() || 0,
+        hz: stat.getHz() || 0
+      };
     });
+    return table;
   }
-  /** Emits one event to Stats and to the optional callback. */
-  trackEvent(event) {
-    var _a;
-    trackStatsEvent(this.stats, event);
-    try {
-      (_a = this.onEvent) == null ? void 0 : _a.call(this, event);
-    } catch {
-    }
-  }
-  /** Emits one batch event after logical requests have been merged. */
-  trackBatch(activeRequests, mergedRequests) {
-    const logicalBytes = getLogicalRequestBytes(activeRequests);
-    const transportBytes = mergedRequests.reduce(
-      (sum, mergedRequest) => sum + mergedRequest.endOffset - mergedRequest.offset,
-      0
-    );
-    this.trackEvent({
-      type: "batch",
-      logicalRequestCount: activeRequests.length,
-      transportRequestCount: mergedRequests.length,
-      logicalBytes,
-      transportBytes,
-      overfetchBytes: Math.max(transportBytes - logicalBytes, 0)
-    });
+  _initializeStats(stats = []) {
+    stats.forEach((stat) => this._getOrCreate(stat));
   }
-};
-function trackStatsEvent(stats, event) {
-  if ((event.type === "response" || event.type === "error") && event.networkTimeMs !== void 0) {
-    stats.get(RANGE_STATS_KEYS.networkTimeMs, "time").addTime(event.networkTimeMs);
-  }
-  switch (event.type) {
-    case "queued":
-      stats.get(RANGE_STATS_KEYS.logicalRanges, "count").incrementCount();
-      stats.get(RANGE_STATS_KEYS.requestedBytes, "count").addCount(event.logicalBytes || 0);
-      break;
-    case "batch":
-      stats.get(RANGE_STATS_KEYS.rangeBatches, "count").incrementCount();
-      stats.get("Logical Ranges Batched", "count").addCount(event.logicalRequestCount || 0);
-      stats.get(RANGE_STATS_KEYS.transportRanges, "count").addCount(event.transportRequestCount || 0);
-      stats.get(RANGE_STATS_KEYS.coalescedRanges, "count").addCount(
-        Math.max((event.logicalRequestCount || 0) - (event.transportRequestCount || 0), 0)
-      );
-      stats.get(RANGE_STATS_KEYS.transportBytes, "count").addCount(event.transportBytes || 0);
-      stats.get(RANGE_STATS_KEYS.overfetchBytes, "count").addCount(event.overfetchBytes || 0);
-      break;
-    case "response":
-      stats.get(RANGE_STATS_KEYS.completedTransportRanges, "count").incrementCount();
-      stats.get(RANGE_STATS_KEYS.responseBytes, "count").addCount(event.responseBytes || 0);
-      if (event.fullResponse) {
-        stats.get(RANGE_STATS_KEYS.fullResponseFallbacks, "count").incrementCount();
-      }
-      break;
-    case "error":
-      stats.get(RANGE_STATS_KEYS.failedTransportRanges, "count").incrementCount();
-      break;
-    case "abort":
-      stats.get(RANGE_STATS_KEYS.abortedLogicalRanges, "count").incrementCount();
-      break;
-    default:
-  }
-}
-function createRangeStats(id = "range-request-scheduler") {
-  const stats = new import_stats2.Stats({ id });
-  initializeStats(stats);
-  return stats;
-}
-async function fetchHttpRange(request) {
-  const abortContext = createAbortableFetchContext(request.signal);
-  const requestStartTime = getTimestamp();
-  try {
-    let fullResponse = false;
-    let response = await request.fetch(
-      request.url,
-      createRangeFetchOptions(
-        request.fetchOptions,
-        request.offset,
-        request.length,
-        abortContext.signal
-      )
-    );
-    if (response.status === 416 && request.offset === 0) {
-      const actualLength = parseUnsatisfiedContentRange(response.headers.get("Content-Range"));
-      if (!actualLength) {
-        throw new Error("Missing content-length on 416 response");
-      }
-      response = await request.fetch(
-        request.url,
-        createRangeFetchOptions(request.fetchOptions, 0, actualLength, abortContext.signal)
-      );
-      fullResponse = true;
-    }
-    if (response.status === 200) {
-      abortContext.abort();
-      await cancelIgnoredRangeResponse(response);
-      throw new Error("Byte-range request failed: server returned 200 instead of 206");
-    }
-    if (response.status !== 206 && !response.ok) {
-      throw new Error(`Bad response code: ${response.status}`);
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    const contentRangeHeader = response.headers.get("Content-Range");
-    const contentRange = parseSatisfiedContentRange(contentRangeHeader);
-    if (contentRangeHeader && !contentRange) {
-      throw new Error(`Invalid Content-Range header: ${contentRangeHeader}`);
-    }
-    if (contentRange) {
-      const responseLength = contentRange.endOffset - contentRange.offset + 1;
-      const requestedEndOffset = request.offset + request.length - 1;
-      if (contentRange.offset !== request.offset || contentRange.endOffset > requestedEndOffset || responseLength !== arrayBuffer.byteLength || contentRange.sourceByteLength !== void 0 && contentRange.endOffset >= contentRange.sourceByteLength) {
-        throw new Error(`Content-Range does not match requested range: ${contentRangeHeader}`);
-      }
-    }
-    return {
-      arrayBuffer,
-      status: response.status,
-      sourceByteLength: contentRange == null ? void 0 : contentRange.sourceByteLength,
-      transportBytes: arrayBuffer.byteLength,
-      networkTimeMs: getTimestamp() - requestStartTime,
-      fullResponse
-    };
-  } finally {
-    abortContext.removeAbortListener();
-  }
-}
-function canMergeRequests(mergedRequest, request, props) {
-  if (mergedRequest.sourceId !== request.sourceId) {
-    return false;
-  }
-  if (mergedRequest.isolationKey !== (request.isolationKey ?? request.sourceId)) {
-    return false;
-  }
-  const requestEndOffset = request.offset + request.length;
-  const gapBytes = request.offset - mergedRequest.endOffset;
-  const mergedBytes = Math.max(mergedRequest.endOffset, requestEndOffset) - mergedRequest.offset;
-  return gapBytes <= props.rangeExpansionBytes && mergedBytes <= props.maxMergedBytes;
-}
-function initializeStats(stats) {
-  stats.get(RANGE_STATS_KEYS.logicalRanges, "count");
-  stats.get(RANGE_STATS_KEYS.requestedBytes, "count");
-  stats.get(RANGE_STATS_KEYS.rangeBatches, "count");
-  stats.get("Logical Ranges Batched", "count");
-  stats.get(RANGE_STATS_KEYS.transportRanges, "count");
-  stats.get(RANGE_STATS_KEYS.coalescedRanges, "count");
-  stats.get(RANGE_STATS_KEYS.transportBytes, "count");
-  stats.get(RANGE_STATS_KEYS.completedTransportRanges, "count");
-  stats.get(RANGE_STATS_KEYS.responseBytes, "count");
-  stats.get(RANGE_STATS_KEYS.networkTimeMs, "time");
-  stats.get(RANGE_STATS_KEYS.overfetchBytes, "count");
-  stats.get(RANGE_STATS_KEYS.fullResponseFallbacks, "count");
-  stats.get(RANGE_STATS_KEYS.failedTransportRanges, "count");
-  stats.get(RANGE_STATS_KEYS.abortedLogicalRanges, "count");
-}
-function getLogicalRequestBytes(requests) {
-  return requests.reduce((sum, request) => sum + request.length, 0);
-}
-function normalizeTransportResult(result) {
-  return result instanceof ArrayBuffer ? { arrayBuffer: result } : result;
-}
-function createRangeFetchOptions(fetchOptions, offset, length, signal) {
-  return {
-    ...fetchOptions,
-    signal,
-    headers: {
-      ...getHeadersObject(fetchOptions == null ? void 0 : fetchOptions.headers),
-      Range: `bytes=${offset}-${offset + length - 1}`
-    }
-  };
-}
-function getHeadersObject(headers) {
-  if (!headers) {
-    return {};
-  }
-  if (headers instanceof Headers) {
-    return Object.fromEntries(headers.entries());
-  }
-  if (Array.isArray(headers)) {
-    return Object.fromEntries(headers);
-  }
-  return headers;
-}
-function parseUnsatisfiedContentRange(contentRange) {
-  const match = contentRange == null ? void 0 : contentRange.match(/^bytes \*\/(\d+)$/);
-  return match ? Number(match[1]) : null;
-}
-function parseSatisfiedContentRange(contentRange) {
-  const match = contentRange == null ? void 0 : contentRange.match(/^bytes (\d+)-(\d+)\/(\d+|\*)$/);
-  if (!match) {
-    return null;
-  }
-  const offset = Number(match[1]);
-  const endOffset = Number(match[2]);
-  const sourceByteLength = match[3] === "*" ? void 0 : Number(match[3]);
-  if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(endOffset) || offset > endOffset || sourceByteLength !== void 0 && !Number.isSafeInteger(sourceByteLength)) {
-    return null;
-  }
-  return { offset, endOffset, sourceByteLength };
-}
-function createAbortableFetchContext(parentSignal) {
-  const abortController = new AbortController();
-  const abortListener = () => abortController.abort(parentSignal == null ? void 0 : parentSignal.reason);
-  if (parentSignal == null ? void 0 : parentSignal.aborted) {
-    abortController.abort(parentSignal == null ? void 0 : parentSignal.reason);
-  } else {
-    parentSignal == null ? void 0 : parentSignal.addEventListener("abort", abortListener, { once: true });
-  }
-  return {
-    signal: abortController.signal,
-    abort: () => abortController.abort(),
-    removeAbortListener: () => parentSignal == null ? void 0 : parentSignal.removeEventListener("abort", abortListener)
-  };
-}
-async function cancelIgnoredRangeResponse(response) {
-  var _a;
-  await ((_a = response.body) == null ? void 0 : _a.cancel().catch(() => {
-  }));
-}
-function getTimestamp() {
-  var _a;
-  return ((_a = globalThis.performance) == null ? void 0 : _a.now()) ?? Date.now();
-}
-function createAbortError2() {
-  if (typeof DOMException !== "undefined") {
-    return new DOMException("Request aborted", "AbortError");
-  }
-  const error = new Error("Request aborted");
-  error.name = "AbortError";
-  return error;
-}
-
-// ../loader-utils/src/lib/path-utils/path.ts
-var path_exports = {};
-__export(path_exports, {
-  dirname: () => dirname,
-  filename: () => filename,
-  join: () => join,
-  resolve: () => resolve
-});
-
-// ../loader-utils/src/lib/path-utils/get-cwd.ts
-function getCWD() {
-  var _a;
-  if (typeof process !== "undefined" && typeof process.cwd !== "undefined") {
-    return process.cwd();
-  }
-  const pathname = (_a = globalThis.location) == null ? void 0 : _a.pathname;
-  return (pathname == null ? void 0 : pathname.slice(0, pathname.lastIndexOf("/") + 1)) || "";
-}
-
-// ../loader-utils/src/lib/path-utils/path.ts
-function filename(url) {
-  const slashIndex = url ? url.lastIndexOf("/") : -1;
-  return slashIndex >= 0 ? url.substr(slashIndex + 1) : url;
-}
-function dirname(url) {
-  const slashIndex = url ? url.lastIndexOf("/") : -1;
-  return slashIndex >= 0 ? url.substr(0, slashIndex) : "";
-}
-function join(...parts) {
-  const separator = "/";
-  parts = parts.map((part, index) => {
-    if (index) {
-      part = part.replace(new RegExp(`^${separator}`), "");
-    }
-    if (index !== parts.length - 1) {
-      part = part.replace(new RegExp(`${separator}$`), "");
-    }
-    return part;
-  });
-  return parts.join(separator);
-}
-function resolve(...components) {
-  const paths = [];
-  for (let _i = 0; _i < components.length; _i++) {
-    paths[_i] = components[_i];
-  }
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  let cwd;
-  for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-    let path;
-    if (i >= 0) {
-      path = paths[i];
-    } else {
-      if (cwd === void 0) {
-        cwd = getCWD();
-      }
-      path = cwd;
-    }
-    if (path.length === 0) {
-      continue;
-    }
-    resolvedPath = `${path}/${resolvedPath}`;
-    resolvedAbsolute = path.charCodeAt(0) === SLASH;
-  }
-  resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute) {
-    return `/${resolvedPath}`;
-  } else if (resolvedPath.length > 0) {
-    return resolvedPath;
-  }
-  return ".";
-}
-var SLASH = 47;
-var DOT = 46;
-function normalizeStringPosix(path, allowAboveRoot) {
-  let res = "";
-  let lastSlash = -1;
-  let dots = 0;
-  let code;
-  let isAboveRoot = false;
-  for (let i = 0; i <= path.length; ++i) {
-    if (i < path.length) {
-      code = path.charCodeAt(i);
-    } else if (code === SLASH) {
-      break;
-    } else {
-      code = SLASH;
-    }
-    if (code === SLASH) {
-      if (lastSlash === i - 1 || dots === 1) {
-      } else if (lastSlash !== i - 1 && dots === 2) {
-        if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
-          if (res.length > 2) {
-            const start = res.length - 1;
-            let j = start;
-            for (; j >= 0; --j) {
-              if (res.charCodeAt(j) === SLASH) {
-                break;
-              }
-            }
-            if (j !== start) {
-              res = j === -1 ? "" : res.slice(0, j);
-              lastSlash = i;
-              dots = 0;
-              isAboveRoot = false;
-              continue;
-            }
-          } else if (res.length === 2 || res.length === 1) {
-            res = "";
-            lastSlash = i;
-            dots = 0;
-            isAboveRoot = false;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          if (res.length > 0) {
-            res += "/..";
-          } else {
-            res = "..";
-          }
-          isAboveRoot = true;
-        }
+  _getOrCreate(stat) {
+    const { name, type } = stat;
+    let result = this.stats[name];
+    if (!result) {
+      if (stat instanceof Stat) {
+        result = stat;
       } else {
-        const slice = path.slice(lastSlash + 1, i);
-        if (res.length > 0) {
-          res += `/${slice}`;
-        } else {
-          res = slice;
-        }
-        isAboveRoot = false;
+        result = new Stat(name, type);
       }
-      lastSlash = i;
-      dots = 0;
-    } else if (code === DOT && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
+      this.stats[name] = result;
     }
-  }
-  return res;
-}
-
-// ../loader-utils/src/lib/files/blob-file.ts
-var BlobFile = class {
-  handle;
-  size;
-  bigsize;
-  url;
-  constructor(blob) {
-    this.handle = blob instanceof ArrayBuffer ? new Blob([blob]) : blob;
-    this.size = blob instanceof ArrayBuffer ? blob.byteLength : blob.size;
-    this.bigsize = BigInt(this.size);
-    this.url = blob instanceof File ? blob.name : "";
-  }
-  async close() {
-  }
-  async stat() {
-    return {
-      size: this.handle.size,
-      bigsize: BigInt(this.handle.size),
-      isDirectory: false
-    };
-  }
-  async read(start, length, signal) {
-    if (signal == null ? void 0 : signal.aborted) {
-      throw new Error("Request aborted");
-    }
-    const arrayBuffer = await this.handle.slice(Number(start), Number(start) + Number(length)).arrayBuffer();
-    if (signal == null ? void 0 : signal.aborted) {
-      throw new Error("Request aborted");
-    }
-    return arrayBuffer;
-  }
-};
-
-// ../loader-utils/src/lib/request-utils/abort-utils.ts
-function waitForPromiseWithSignal(promise, signal) {
-  if (!signal) return promise;
-  if (signal.aborted) {
-    void promise.catch(() => {
-    });
-    return Promise.reject(signal.reason);
-  }
-  return new Promise((resolve2, reject) => {
-    const abort = () => {
-      signal.removeEventListener("abort", abort);
-      reject(signal.reason);
-    };
-    signal.addEventListener("abort", abort, { once: true });
-    void promise.then(
-      (value) => {
-        signal.removeEventListener("abort", abort);
-        resolve2(value);
-      },
-      (error) => {
-        signal.removeEventListener("abort", abort);
-        reject(error);
-      }
-    );
-  });
-}
-function waitForPromiseWithSignals(operation, signals) {
-  const controller = new AbortController();
-  const listeners = [];
-  const cleanup = () => {
-    for (const [signal, listener] of listeners) signal.removeEventListener("abort", listener);
-  };
-  for (const signal of signals) {
-    if (!signal) continue;
-    const listener = () => controller.abort(signal.reason);
-    listeners.push([signal, listener]);
-    signal.addEventListener("abort", listener, { once: true });
-    if (signal.aborted) listener();
-  }
-  try {
-    controller.signal.throwIfAborted();
-    return waitForPromiseWithSignal(operation(controller.signal), controller.signal).catch((error) => {
-      controller.abort(error);
-      throw error;
-    }).finally(cleanup);
-  } catch (error) {
-    controller.abort(error);
-    cleanup();
-    return Promise.reject(error);
-  }
-}
-
-// ../loader-utils/src/lib/files/http-file-transport.ts
-var HttpFileTransport = class {
-  /** Remote object URL. */
-  url;
-  /** Fetch implementation used for range requests. */
-  fetchFunction;
-  /** Persistent fetch options copied from the caller. */
-  fetchOptions;
-  /** Validator enforcement mode. */
-  consistency;
-  /** Caller-supplied identity information. */
-  identityHints;
-  /** Failure objects already included in telemetry. */
-  countedFailures = /* @__PURE__ */ new WeakSet();
-  /** Mutable counters backing immutable telemetry snapshots. */
-  telemetry = {
-    requestedBytes: 0,
-    downloadedBytes: 0,
-    requestCount: 0,
-    networkTimeMs: 0,
-    abortCount: 0,
-    errorCount: 0
-  };
-  /** Creates the transport for one remote object. */
-  constructor(url, options) {
-    validateKnownByteLength(options.byteLength);
-    this.url = url;
-    this.fetchFunction = options.fetch || ((input, init) => globalThis.fetch(input, init));
-    this.fetchOptions = options.fetchOptions ? { ...options.fetchOptions, headers: new Headers(options.fetchOptions.headers) } : void 0;
-    this.consistency = options.consistency || "best-effort";
-    this.identityHints = {
-      byteLength: options.byteLength,
-      etag: normalizeHeaderValue(options.etag),
-      lastModified: normalizeHeaderValue(options.lastModified)
-    };
-  }
-  /** Returns an identity that is complete enough to avoid an opening request. */
-  getInitialIdentity() {
-    const { byteLength, etag, lastModified } = this.identityHints;
-    if (byteLength !== void 0 && (etag !== void 0 || lastModified !== void 0)) {
-      return createIdentity(byteLength, etag, lastModified);
-    }
-    if (byteLength === 0 && this.consistency === "best-effort") {
-      return createIdentity(0);
-    }
-    return null;
-  }
-  /** Returns an immutable point-in-time copy of the transport counters. */
-  getTelemetry() {
-    return Object.freeze({ ...this.telemetry });
-  }
-  /** Counts each failure object once even when it passes through several async layers. */
-  trackFailure(error) {
-    if (typeof error === "object" && error !== null) {
-      if (this.countedFailures.has(error)) {
-        return;
-      }
-      this.countedFailures.add(error);
-    }
-    if (isAbortError(error)) {
-      this.telemetry.abortCount++;
-    } else {
-      this.telemetry.errorCount++;
-    }
-  }
-  /** Performs and validates one exact HTTP range request. */
-  async requestRange(offset, length, signal, expectedIdentity) {
-    var _a;
-    const requestStartTime = getTimestamp2();
-    const abortContext = createCombinedAbortContext(signal, (_a = this.fetchOptions) == null ? void 0 : _a.signal);
-    this.telemetry.requestCount++;
-    this.telemetry.requestedBytes += length;
-    try {
-      const response = await this.fetchFunction(
-        this.url,
-        createFetchOptions(this.fetchOptions, offset, length, abortContext.signal)
-      );
-      if (isEmptyIdentityProbeResponse(response, offset, length, expectedIdentity)) {
-        return await this.readEmptyIdentityProbe(response, requestStartTime);
-      }
-      if (response.status !== 206) {
-        await cancelResponse(response);
-        throw new Error(`HTTP byte-range request expected 206, received ${response.status}`);
-      }
-      const contentRange = await readContentRange(response);
-      const responseIdentity = getResponseIdentity(response, contentRange.byteLength);
-      const responseError = getIdentityError(
-        expectedIdentity,
-        responseIdentity,
-        this.identityHints,
-        this.consistency
-      ) || getRangeError(contentRange, offset, length);
-      if (responseError) {
-        await cancelResponse(response);
-        throw new Error(responseError);
-      }
-      const arrayBuffer = await response.arrayBuffer();
-      this.telemetry.downloadedBytes += arrayBuffer.byteLength;
-      if (arrayBuffer.byteLength !== length) {
-        throw new Error(
-          `HTTP byte-range response contained ${arrayBuffer.byteLength} bytes; expected ${length}`
-        );
-      }
-      return {
-        arrayBuffer,
-        identity: resolveIdentity(expectedIdentity, responseIdentity, this.identityHints),
-        status: response.status,
-        transportBytes: arrayBuffer.byteLength,
-        networkTimeMs: getTimestamp2() - requestStartTime
-      };
-    } catch (error) {
-      if (expectedIdentity === null || !isAbortError(error)) {
-        this.trackFailure(error);
-      }
-      throw error;
-    } finally {
-      abortContext.removeAbortListeners();
-      this.telemetry.networkTimeMs += getTimestamp2() - requestStartTime;
-    }
-  }
-  /** Validates and consumes the special empty-object identity response. */
-  async readEmptyIdentityProbe(response, requestStartTime) {
-    const responseIdentity = getResponseIdentity(response, 0);
-    const identityError = getIdentityError(
-      null,
-      responseIdentity,
-      this.identityHints,
-      this.consistency
-    );
-    await cancelResponse(response);
-    if (identityError) {
-      throw new Error(identityError);
-    }
-    return {
-      arrayBuffer: new ArrayBuffer(0),
-      identity: resolveIdentity(null, responseIdentity, this.identityHints),
-      status: response.status,
-      transportBytes: 0,
-      networkTimeMs: getTimestamp2() - requestStartTime
-    };
+    return result;
   }
 };
-function createFetchOptions(fetchOptions, offset, length, signal) {
-  const headers = new Headers(fetchOptions == null ? void 0 : fetchOptions.headers);
-  headers.set("Range", `bytes=${offset}-${offset + length - 1}`);
-  return {
-    ...fetchOptions,
-    method: "GET",
-    body: void 0,
-    headers,
-    signal
-  };
-}
-function isEmptyIdentityProbeResponse(response, offset, length, expectedIdentity) {
-  return response.status === 416 && expectedIdentity === null && offset === 0 && length === 1 && /^bytes \*\/0$/i.test(response.headers.get("Content-Range") || "");
-}
-async function readContentRange(response) {
-  try {
-    return parseContentRange(response.headers.get("Content-Range"));
-  } catch (error) {
-    await cancelResponse(response);
-    throw error;
-  }
-}
-function parseContentRange(contentRange) {
-  const match = contentRange == null ? void 0 : contentRange.match(/^bytes (\d+)-(\d+)\/(\d+)$/);
-  if (!match) {
-    throw new Error("HTTP byte-range response has an invalid Content-Range header");
-  }
-  return {
-    offset: Number(match[1]),
-    endOffset: Number(match[2]),
-    byteLength: Number(match[3])
-  };
-}
-function getResponseIdentity(response, byteLength) {
-  return createIdentity(
-    byteLength,
-    normalizeHeaderValue(response.headers.get("ETag")),
-    normalizeHeaderValue(response.headers.get("Last-Modified"))
-  );
-}
-function resolveIdentity(expectedIdentity, responseIdentity, identityHints) {
-  return expectedIdentity || createIdentity(
-    responseIdentity.byteLength,
-    responseIdentity.etag ?? identityHints.etag,
-    responseIdentity.lastModified ?? identityHints.lastModified
-  );
-}
-function getRangeError(contentRange, offset, length) {
-  if (!Number.isSafeInteger(contentRange.offset) || !Number.isSafeInteger(contentRange.endOffset) || !Number.isSafeInteger(contentRange.byteLength) || contentRange.offset < 0 || contentRange.endOffset < contentRange.offset || contentRange.endOffset >= contentRange.byteLength) {
-    return "HTTP byte-range response has invalid range bounds";
-  }
-  if (contentRange.offset !== offset || contentRange.endOffset !== offset + length - 1) {
-    return "HTTP byte-range response does not match the requested range";
-  }
-  return null;
-}
-function getIdentityError(expectedIdentity, responseIdentity, identityHints, consistency) {
-  const expectedByteLength = (expectedIdentity == null ? void 0 : expectedIdentity.byteLength) ?? identityHints.byteLength;
-  if (expectedByteLength !== void 0 && responseIdentity.byteLength !== expectedByteLength) {
-    return "HTTP file length changed while the file was open";
-  }
-  const expectedEtag = (expectedIdentity == null ? void 0 : expectedIdentity.etag) ?? identityHints.etag;
-  const expectedLastModified = (expectedIdentity == null ? void 0 : expectedIdentity.lastModified) ?? identityHints.lastModified;
-  if (expectedEtag) {
-    if (responseIdentity.etag) {
-      return expectedEtag === responseIdentity.etag ? null : "HTTP file ETag changed while the file was open";
-    }
-    if (consistency === "strict") {
-      return "HTTP byte-range response is missing the pinned ETag";
-    }
-    if (expectedLastModified && responseIdentity.lastModified && expectedLastModified !== responseIdentity.lastModified) {
-      return "HTTP file Last-Modified value changed while the file was open";
-    }
-    return null;
-  }
-  if (expectedLastModified) {
-    if (responseIdentity.lastModified && expectedLastModified !== responseIdentity.lastModified) {
-      return "HTTP file Last-Modified value changed while the file was open";
-    }
-    if (consistency === "strict" && !responseIdentity.lastModified) {
-      return "HTTP byte-range response is missing the pinned Last-Modified value";
-    }
-    return null;
-  }
-  if (consistency === "strict" && !responseIdentity.etag && !responseIdentity.lastModified) {
-    return "HTTP byte-range response does not provide an ETag or Last-Modified validator";
-  }
-  return null;
-}
-function createIdentity(byteLength, etag, lastModified) {
-  return Object.freeze({ byteLength, etag, lastModified });
-}
-function validateKnownByteLength(byteLength) {
-  if (byteLength !== void 0 && (!Number.isSafeInteger(byteLength) || byteLength < 0)) {
-    throw new Error("HttpFile byteLength must be a non-negative safe integer");
-  }
-}
-async function cancelResponse(response) {
-  var _a;
-  await ((_a = response.body) == null ? void 0 : _a.cancel().catch(() => {
-  }));
-}
-function normalizeHeaderValue(value) {
-  return value || void 0;
-}
-function getTimestamp2() {
-  var _a;
-  return ((_a = globalThis.performance) == null ? void 0 : _a.now()) ?? Date.now();
-}
-function isAbortError(error) {
-  return error instanceof Error && error.name === "AbortError" || error instanceof Error && /aborted/i.test(error.message);
-}
-function createCombinedAbortContext(...signals) {
-  const abortController = new AbortController();
-  const uniqueSignals = [
-    ...new Set(signals.filter((signal) => Boolean(signal)))
-  ];
-  const abortListener = () => abortController.abort();
-  for (const signal of uniqueSignals) {
-    if (signal.aborted) {
-      abortController.abort();
-    } else {
-      signal.addEventListener("abort", abortListener, { once: true });
-    }
-  }
-  return {
-    signal: abortController.signal,
-    removeAbortListeners: () => {
-      for (const signal of uniqueSignals) {
-        signal.removeEventListener("abort", abortListener);
-      }
-    }
-  };
-}
 
-// ../loader-utils/src/lib/files/http-file.ts
-var HttpFile = class _HttpFile {
-  /** URL used as the ReadableFile handle. */
-  handle;
-  /** Remote object URL. */
-  url;
-  /** HTTP transport and response validator for this file. */
-  transport;
-  /** Scheduler used to coalesce compatible range reads. */
-  rangeScheduler;
-  /** Unique key that prevents coalescing across transport or credential contexts. */
-  schedulerIsolationKey = {};
-  /** Caller-supplied length available before identity discovery. */
-  suppliedByteLength;
-  /** Pinned remote object identity. */
-  identity;
-  /** Shared opening probe, while identity discovery is in progress. */
-  openPromise = null;
-  /** Whether the file has stopped accepting operations. */
-  closed = false;
-  /** Creates a lazy HTTP file. Use {@link HttpFile.open} when identity must be pinned immediately. */
-  constructor(url, options = {}) {
-    this.handle = url;
-    this.url = url;
-    this.transport = new HttpFileTransport(url, options);
-    this.rangeScheduler = options.rangeScheduler || new RangeRequestScheduler({ batchDelayMs: 0, ...options.rangeSchedulerProps });
-    this.suppliedByteLength = options.byteLength;
-    this.identity = this.transport.getInitialIdentity();
-  }
-  /** Opens a file and pins its byte length and available validators. */
-  static async open(url, options = {}, signal) {
-    const file = new _HttpFile(url, options);
-    await file.open(signal);
-    return file;
-  }
-  /** Pins this file's byte length and available validators. */
-  async open(signal) {
-    this.assertOpen();
-    if (signal == null ? void 0 : signal.aborted) {
-      const error = createAbortError3();
-      this.transport.trackFailure(error);
-      throw error;
-    }
-    await this.getIdentity(signal);
-    return this;
-  }
-  /** Pinned file length, or zero before a lazy file has opened. */
-  get size() {
-    var _a;
-    return ((_a = this.identity) == null ? void 0 : _a.byteLength) ?? this.suppliedByteLength ?? 0;
-  }
-  /** Pinned file length as a bigint, or zero before a lazy file has opened. */
-  get bigsize() {
-    return BigInt(this.size);
-  }
-  /** Returns the pinned identity, or null before a lazy file has opened. */
-  getIdentitySnapshot() {
-    return this.identity;
-  }
-  /** Returns an immutable point-in-time copy of this file's transport counters. */
-  getTelemetry() {
-    return this.transport.getTelemetry();
-  }
-  /** Prevents new operations. Active fetches remain controlled by their read signals. */
-  async close() {
-    this.closed = true;
-  }
-  /** Returns pinned file information without issuing a HEAD request. */
-  async stat() {
-    this.assertOpen();
-    const identity = await this.getIdentity();
-    return {
-      size: identity.byteLength,
-      bigsize: BigInt(identity.byteLength),
-      isDirectory: false
-    };
-  }
-  /** Reads exactly one byte range, with optional cancellation. */
-  async read(offset = 0, length = 0, signal) {
-    this.assertOpen();
-    if (signal == null ? void 0 : signal.aborted) {
-      const error = createAbortError3();
-      this.transport.trackFailure(error);
-      throw error;
-    }
-    const identity = await this.getIdentity(signal);
-    const numericOffset = normalizeOffset(offset);
-    validateRange(numericOffset, length, identity.byteLength);
-    if (length === 0) {
-      return new ArrayBuffer(0);
-    }
-    try {
-      return await this.rangeScheduler.scheduleRequest({
-        sourceId: this.url,
-        isolationKey: this.schedulerIsolationKey,
-        offset: numericOffset,
-        length,
-        signal,
-        fetchRange: this.fetchScheduledRange
-      });
-    } catch (error) {
-      this.transport.trackFailure(error);
-      throw error;
-    }
-  }
-  /** Reads a range and returns a Response for legacy ReadableFile consumers. */
-  async fetchRange(offset, length, signal) {
-    const numericOffset = normalizeOffset(offset);
-    const arrayBuffer = await this.read(numericOffset, length, signal);
-    const headers = createIdentityHeaders(this.identity, numericOffset, length);
-    return new Response(arrayBuffer, { status: 206, headers });
-  }
-  /** Stable scheduler callback used by every read from this file. */
-  fetchScheduledRange = async (offset, length, signal) => {
-    const identity = await this.getIdentity(signal);
-    const result = await this.transport.requestRange(offset, length, signal, identity);
-    return {
-      arrayBuffer: result.arrayBuffer,
-      status: result.status,
-      transportBytes: result.transportBytes,
-      networkTimeMs: result.networkTimeMs
-    };
-  };
-  /** Returns the shared lazy identity promise, retrying after a failed probe. */
-  getIdentity(signal) {
-    if (this.identity) {
-      return Promise.resolve(this.identity);
-    }
-    if (!this.openPromise) {
-      const nextOpenPromise = this.probeIdentity();
-      const cachedOpenPromise = nextOpenPromise.catch((error) => {
-        if (this.openPromise === cachedOpenPromise) {
-          this.openPromise = null;
-        }
-        throw error;
-      });
-      this.openPromise = cachedOpenPromise;
-    }
-    return waitForPromiseWithSignal(this.openPromise, signal).catch((error) => {
-      this.transport.trackFailure(error);
-      throw error;
-    });
-  }
-  /** Uses a one-byte GET range to discover object length and validators. */
-  async probeIdentity() {
-    try {
-      const result = await this.transport.requestRange(0, 1, void 0, null);
-      this.identity = result.identity;
-      return result.identity;
-    } catch (error) {
-      this.transport.trackFailure(error);
-      throw error;
-    }
-  }
-  /** Throws when the file has been closed. */
-  assertOpen() {
-    if (this.closed) {
-      throw new Error("HttpFile is closed");
-    }
-  }
-};
-function createIdentityHeaders(identity, offset, length) {
-  const headers = new Headers();
-  if (length > 0 && identity) {
-    headers.set("Content-Range", `bytes ${offset}-${offset + length - 1}/${identity.byteLength}`);
-  }
-  if (identity == null ? void 0 : identity.etag) {
-    headers.set("ETag", identity.etag);
-  }
-  if (identity == null ? void 0 : identity.lastModified) {
-    headers.set("Last-Modified", identity.lastModified);
-  }
-  return headers;
-}
-function normalizeOffset(offset) {
-  const numericOffset = Number(offset);
-  if (!Number.isSafeInteger(numericOffset) || numericOffset < 0) {
-    throw new Error("HTTP byte-range offset must be a non-negative safe integer");
-  }
-  return numericOffset;
-}
-function validateRange(offset, length, byteLength) {
-  if (!Number.isSafeInteger(length) || length < 0) {
-    throw new Error("HTTP byte-range length must be a non-negative safe integer");
-  }
-  if (offset + length > byteLength) {
-    throw new Error("HTTP byte range extends beyond the end of the file");
-  }
-}
-function createAbortError3() {
-  if (typeof DOMException !== "undefined") {
-    return new DOMException("Request aborted", "AbortError");
-  }
-  const error = new Error("Request aborted");
-  error.name = "AbortError";
-  return error;
-}
+// dist/tileset-3d/common/tileset-3d.js
+var import_loader_utils2 = require("@loaders.gl/loader-utils");
 
 // dist/utils/doubly-linked-list-node.js
 var DoublyLinkedListNode = class {
@@ -1924,9 +436,10 @@ var TilesetCache = class {
 // dist/tileset-3d/helpers/transform-utils.js
 var import_geospatial = require("@math.gl/geospatial");
 var import_core = require("@math.gl/core");
+var import_loader_utils = require("@loaders.gl/loader-utils");
 function calculateTransformProps(tileHeader, tile) {
-  assert(tileHeader);
-  assert(tile);
+  (0, import_loader_utils.assert)(tileHeader);
+  (0, import_loader_utils.assert)(tile);
   const { rtcCenter, gltfUpAxis } = tile;
   const { computedTransform, boundingVolume: { center } } = tileHeader;
   let modelMatrix = new import_core.Matrix4(computedTransform);
@@ -1970,15 +483,14 @@ function calculateTransformProps(tileHeader, tile) {
 }
 var TRANSLATION_LIMIT_SQUARED = 1e6 ** 2;
 function _getRootNode(tile) {
-  var _a, _b;
   const gltf = tile.gltf;
   if (!gltf) {
     return null;
   }
   const sceneIndex = typeof gltf.scene === "number" ? gltf.scene : 0;
-  const scene = (_a = gltf.scenes) == null ? void 0 : _a[sceneIndex];
-  const rootNode = (_b = scene == null ? void 0 : scene.nodes) == null ? void 0 : _b[0];
-  if (!(rootNode == null ? void 0 : rootNode.matrix))
+  const scene = gltf.scenes?.[sceneIndex];
+  const rootNode = scene?.nodes?.[0];
+  if (!rootNode?.matrix)
     return null;
   const m = rootNode.matrix;
   const translationMagnitude = m[12] * m[12] + m[13] * m[13] + m[14] * m[14];
@@ -2067,7 +579,7 @@ function updateCameraMotionState(previousState, position, direction, currentTime
   const directionArray = Array.from(direction);
   const positionChanged = previousState ? positionArray.length !== previousState.position.length || positionArray.some((value, index) => Math.abs(value - previousState.position[index]) > CAMERA_POSITION_EPSILON) : false;
   const directionChanged = previousState ? directionArray.length !== previousState.direction.length || directionArray.some((value, index) => Math.abs(value - previousState.direction[index]) > CAMERA_DIRECTION_EPSILON) : false;
-  const lastMovementTime = positionChanged || directionChanged ? currentTime : (previousState == null ? void 0 : previousState.lastMovementTime) ?? Number.NEGATIVE_INFINITY;
+  const lastMovementTime = positionChanged || directionChanged ? currentTime : previousState?.lastMovementTime ?? Number.NEGATIVE_INFINITY;
   return {
     state: {
       position: positionArray,
@@ -2198,7 +710,7 @@ function getTiles3DScreenSpaceError(tile, frameState, useParentLodMetric, viewpo
 }
 function getOrthographicScreenSpaceError(lodMetricValue, frameState, lodScale, viewportHeightFraction) {
   const viewport = frameState.viewport;
-  if (!(viewport == null ? void 0 : viewport.orthographic)) {
+  if (!viewport?.orthographic) {
     return null;
   }
   const metersPerPixel = viewport.metersPerPixel;
@@ -2208,8 +720,7 @@ function getOrthographicScreenSpaceError(lodMetricValue, frameState, lodScale, v
   return lodMetricValue * lodScale * viewportHeightFraction / metersPerPixel;
 }
 function getContentBoundingVolumeHeader(root) {
-  var _a;
-  return ((_a = root.header.content) == null ? void 0 : _a.boundingVolume) || root.header.boundingVolume;
+  return root.header.content?.boundingVolume || root.header.boundingVolume;
 }
 function getRegionHeightRange(region, frameState) {
   const upDirection = scratchPositionNormal.copy(frameState.camera.position).normalize();
@@ -2411,7 +922,6 @@ function normalizeCrsIdentifier(identifier) {
 
 // dist/spatial/get-spatial-coordinate-frame.js
 function getSpatialCoordinateFrame(definition) {
-  var _a, _b;
   if (typeof definition === "string") {
     const representation = (0, import_crs.inferCRSRepresentation)(definition);
     if (representation === "wkt") {
@@ -2426,7 +936,7 @@ function getSpatialCoordinateFrame(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])) {
+  if (projJsonDefinition.type === "CompoundCRS" && projJsonDefinition.components?.[0]) {
     return getSpatialCoordinateFrame(projJsonDefinition.components[0]);
   }
   if (String(projJsonDefinition.type).includes("Projected")) {
@@ -2436,7 +946,7 @@ function getSpatialCoordinateFrame(definition) {
     return "geographic";
   }
   if (String(projJsonDefinition.type).includes("Geodetic")) {
-    return ((_b = projJsonDefinition.coordinate_system) == null ? void 0 : _b.subtype) === "Cartesian" ? "geocentric" : "geographic";
+    return projJsonDefinition.coordinate_system?.subtype === "Cartesian" ? "geocentric" : "geographic";
   }
   return "unknown";
 }
@@ -2490,8 +1000,8 @@ function getWktCoordinateFrame(definition) {
     case "GEODCRS":
     case "GEODETICCRS": {
       const coordinateSystem = root.values.find((value) => value.type === "node" && value.keyword.toUpperCase() === "CS");
-      const subtype = coordinateSystem == null ? void 0 : coordinateSystem.values[0];
-      if ((subtype == null ? void 0 : subtype.type) !== "enumeration" && (subtype == null ? void 0 : subtype.type) !== "string") {
+      const subtype = coordinateSystem?.values[0];
+      if (subtype?.type !== "enumeration" && subtype?.type !== "string") {
         return "unknown";
       }
       return subtype.value.toUpperCase() === "CARTESIAN" ? "geocentric" : subtype.value.toUpperCase() === "ELLIPSOIDAL" ? "geographic" : "unknown";
@@ -2501,10 +1011,9 @@ function getWktCoordinateFrame(definition) {
   }
 }
 function getProjStringCoordinateFrame(definition) {
-  var _a;
   try {
-    const projection = (_a = (0, import_crs.parsePROJString)(definition).parameters.find((parameter) => parameter.name.toLowerCase() === "proj")) == null ? void 0 : _a.value;
-    switch (projection == null ? void 0 : projection.toLowerCase()) {
+    const projection = (0, import_crs.parsePROJString)(definition).parameters.find((parameter) => parameter.name.toLowerCase() === "proj")?.value;
+    switch (projection?.toLowerCase()) {
       case "longlat":
       case "latlong":
         return "geographic";
@@ -2588,23 +1097,23 @@ function createTilesetSpatialReference(discovered, options = {}) {
 }
 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
+    sourceCrs: discovered?.sourceCrs,
+    sourceCrsState: discovered?.crs.state,
+    sourceCrsRepresentation: discovered?.crs.state === "explicit" || discovered?.crs.state === "default" ? discovered.crs.representation : void 0,
+    sourceCrsAlternatives: discovered?.crs.state === "explicit" || discovered?.crs.state === "default" ? discovered.crs.alternatives : void 0,
+    verticalCrs: discovered?.verticalCrs,
+    units: discovered?.units,
+    verticalUnitScale: discovered?.verticalUnitScale,
+    coordinateEpoch: discovered?.coordinateEpoch,
+    heightReference: discovered?.heightReference,
+    elevationMode: discovered?.elevationMode,
+    elevationOffset: discovered?.elevationOffset,
+    elevationUnit: discovered?.elevationUnit,
+    elevationUnitScale: discovered?.elevationUnitScale,
+    coordinateFrame: discovered?.coordinateFrame,
+    axisOrder: discovered?.axisOrder,
+    provenance: discovered?.provenance,
+    warnings: discovered?.warnings
   }, options);
 }
 function getKnownCRSDefinition(reference) {
@@ -2669,7 +1178,7 @@ function resolveMaximumCacheOverflowBytes(options, fallbackOverflowBytes) {
   const maximumCacheOverflowBytes = options.maximumCacheOverflowBytes ?? fallbackOverflowBytes;
   return validateCacheByteLength(maximumCacheOverflowBytes, "maximumCacheOverflowBytes");
 }
-var DEFAULT_PROPS3 = {
+var DEFAULT_PROPS = {
   description: "",
   ellipsoid: import_geospatial3.Ellipsoid.WGS84,
   modelMatrix: new import_core5.Matrix4(),
@@ -2797,6 +1306,7 @@ var Tileset3D = class {
   _traverser;
   _cache = new TilesetCache();
   _requestScheduler;
+  /** Drawn fallback instances retained independently for each viewport tree. */
   _heldTiles = /* @__PURE__ */ new Set();
   updatePromise = null;
   tilesetInitializationPromise;
@@ -2811,15 +1321,16 @@ var Tileset3D = class {
     }
     const suppliedOptions = options || {};
     const usesTiles3DCacheDefaults = source.type === TILESET_TYPE.TILES3D;
-    const defaultCacheBytes = usesTiles3DCacheDefaults ? DEFAULT_PROPS3.cacheBytes : DEFAULT_I3S_CACHE_BYTES;
-    const defaultMaximumCacheOverflowBytes = usesTiles3DCacheDefaults ? DEFAULT_PROPS3.maximumCacheOverflowBytes : DEFAULT_I3S_MAXIMUM_CACHE_OVERFLOW_BYTES;
+    const defaultCacheBytes = usesTiles3DCacheDefaults ? DEFAULT_PROPS.cacheBytes : DEFAULT_I3S_CACHE_BYTES;
+    const defaultMaximumCacheOverflowBytes = usesTiles3DCacheDefaults ? DEFAULT_PROPS.maximumCacheOverflowBytes : DEFAULT_I3S_MAXIMUM_CACHE_OVERFLOW_BYTES;
     const cacheBytes = resolveCacheBytes(suppliedOptions, defaultCacheBytes);
     const maximumCacheOverflowBytes = resolveMaximumCacheOverflowBytes(suppliedOptions, defaultMaximumCacheOverflowBytes);
     this.options = {
-      ...DEFAULT_PROPS3,
+      ...DEFAULT_PROPS,
       ...suppliedOptions,
       cacheBytes,
       maximumCacheOverflowBytes,
+      skipLevelOfDetail: suppliedOptions.skipLevelOfDetail ?? source.type === TILESET_TYPE.TILES3D,
       memoryAdjustedScreenSpaceError: suppliedOptions.memoryAdjustedScreenSpaceError ?? usesTiles3DCacheDefaults
     };
     this.loadOptions = this.options.loadOptions || {};
@@ -2836,7 +1347,7 @@ var Tileset3D = class {
     this.refine = "";
     this.contentFormats = this.source.contentFormats;
     this._traverser = this._initializeTraverser();
-    this._requestScheduler = new RequestScheduler({
+    this._requestScheduler = new import_loader_utils2.RequestScheduler({
       throttleRequests: this.options.throttleRequests,
       maxRequests: this.options.maxRequests
     });
@@ -2847,14 +1358,13 @@ var Tileset3D = class {
     if (metadata) {
       this.spatialReference = applyTilesetSpatialOptions(metadata.spatialReference, this.options.spatial);
     }
-    this.stats = new import_stats3.Stats({ id: this.url });
+    this.stats = new Stats({ id: this.url });
     this._initializeStats();
     this.tilesetInitializationPromise = this._initializeTileSet();
   }
   destroy() {
-    var _a, _b;
     this._clearDeferredTraversal();
-    (_b = (_a = this.source).destroy) == null ? void 0 : _b.call(_a);
+    this.source.destroy?.();
     this._destroy();
   }
   isLoaded() {
@@ -2939,8 +1449,7 @@ var Tileset3D = class {
     return this.source.getTileUrl(tilePath);
   }
   hasExtension(extensionName) {
-    var _a, _b;
-    return Boolean((_b = (_a = this.source).hasExtension) == null ? void 0 : _b.call(_a, extensionName));
+    return Boolean(this.source.hasExtension?.(extensionName));
   }
   update(viewports = null) {
     this.tilesetInitializationPromise.then(() => {
@@ -2960,12 +1469,12 @@ var Tileset3D = class {
       this.lastUpdatedVieports = viewports;
     }
     if (!this.updatePromise) {
-      this.updatePromise = new Promise((resolve2) => {
+      this.updatePromise = new Promise((resolve) => {
         setTimeout(() => {
           if (this.lastUpdatedVieports) {
             this.doUpdate(this.lastUpdatedVieports);
           }
-          resolve2(this._frameNumber);
+          resolve(this._frameNumber);
           this.updatePromise = null;
         }, this.options.debounceTime);
       });
@@ -3105,27 +1614,41 @@ var Tileset3D = class {
       this._emptyTiles = this._emptyTiles.concat(frameStateDataValue._emptyTiles);
     }
     this.selectedTiles = this.options.onTraversalComplete(this.selectedTiles);
-    const selectedIds = new Set(this.selectedTiles.map((tile) => tile.id));
+    const selectedTiles = new Set(this.selectedTiles);
     const hasUndrawnTiles = this.selectedTiles.some((tile) => !tile.tileDrawn);
     let heldBackCount = 0;
     if (hasUndrawnTiles) {
-      for (const tileId of selectedIds) {
-        this._heldTiles.add(tileId);
+      const activeRoots = new Set(Object.keys(this.frameStateData).map((viewportId) => this.roots[viewportId]));
+      const descendantReadiness = /* @__PURE__ */ new Map();
+      for (const tile of this.selectedTiles) {
+        for (let ancestor = tile.parent; ancestor; ancestor = ancestor.parent) {
+          descendantReadiness.set(ancestor, (descendantReadiness.get(ancestor) ?? true) && tile.tileDrawn);
+        }
       }
-      for (const tileId of this._heldTiles) {
-        if (selectedIds.has(tileId))
+      for (const tile of previousSelectedTiles) {
+        if (tile.tileDrawn)
+          this._heldTiles.add(tile);
+      }
+      for (const tile of this._heldTiles) {
+        let root = tile;
+        while (root.parent)
+          root = root.parent;
+        if (!activeRoots.has(root)) {
+          this._heldTiles.delete(tile);
+          continue;
+        }
+        if (selectedTiles.has(tile))
           continue;
-        const tile = this._tiles[tileId];
-        if (tile && tile.contentAvailable) {
+        if (tile.contentAvailable && !this._hasDrawnReplacement(tile, selectedTiles, descendantReadiness)) {
           tile._selectedFrame = this._frameNumber;
           this.selectedTiles.push(tile);
           heldBackCount++;
         } else {
-          this._heldTiles.delete(tileId);
+          this._heldTiles.delete(tile);
         }
       }
     } else {
-      this._heldTiles = selectedIds;
+      this._heldTiles = selectedTiles;
     }
     if (heldBackCount > 0) {
       setTimeout(() => {
@@ -3142,6 +1665,19 @@ var Tileset3D = class {
       this.options.onUpdate();
     }
   }
+  /**
+   * Releases fallback geometry once its own selected replacement has drawn.
+   * Unrelated pending branches must not delay this region's handoff. When no related
+   * replacement is selected, retain the fallback until the complete selection has drawn.
+   */
+  _hasDrawnReplacement(tile, selectedTiles, descendantReadiness) {
+    for (let ancestor = tile.parent; ancestor; ancestor = ancestor.parent) {
+      if (selectedTiles.has(ancestor)) {
+        return ancestor.tileDrawn;
+      }
+    }
+    return descendantReadiness.get(tile) === true;
+  }
   _tilesChanged(oldSelectedTiles, selectedTiles) {
     if (oldSelectedTiles.length !== selectedTiles.length) {
       return true;
@@ -3188,21 +1724,20 @@ var Tileset3D = class {
     this.stats.get(MAXIMUM_SSE).count = this.memoryAdjustedScreenSpaceError;
   }
   async _initializeTileSet() {
-    var _a, _b, _c, _d;
     try {
       const initializePromise = this.source.initialize();
       const initialMetadata = this._getSourceMetadata();
       if (initialMetadata) {
         this._syncSourceState(initialMetadata);
       }
-      if (((_a = initialMetadata == null ? void 0 : initialMetadata.tileset) == null ? void 0 : _a.root) && typeof initialMetadata.tileset.root.then !== "function" && (!this.source.prepareTileset || ((_b = this.spatialReference) == null ? void 0 : _b.status) === "native")) {
+      if (initialMetadata?.tileset?.root && typeof initialMetadata.tileset.root.then !== "function" && (!this.source.prepareTileset || this.spatialReference?.status === "native")) {
         this.root = this._initializeTileHeaders(initialMetadata.tileset, null);
         this._applyViewState();
       }
       await initializePromise;
       const metadata = this.source.getMetadata();
       this._syncSourceState(metadata);
-      await ((_d = (_c = this.source).prepareTileset) == null ? void 0 : _d.call(_c, this));
+      await this.source.prepareTileset?.(this);
       if (!this.root) {
         this.root = this._initializeTileHeaders(metadata.tileset, null);
       }
@@ -3288,16 +1823,15 @@ var Tileset3D = class {
     this.options.onTilesetError(error, this);
   }
   _onTileLoad(tile, loadResult) {
-    var _a, _b, _c, _d;
-    if (!(loadResult == null ? void 0 : loadResult.loaded)) {
+    if (!loadResult?.loaded) {
       return;
     }
     if (tile.content) {
       calculateTransformProps(tile, tile.content);
     }
-    (_b = (_a = this.source).onTileLoaded) == null ? void 0 : _b.call(_a, this, tile, loadResult);
+    this.source.onTileLoaded?.(this, tile, loadResult);
     this._syncSourceState(this.source.getMetadata());
-    const totalTiles = (_d = (_c = this.source).getTilesTotalCount) == null ? void 0 : _d.call(_c);
+    const totalTiles = this.source.getTilesTotalCount?.();
     if (totalTiles) {
       this.stats.get(TILES_TOTAL).reset();
       this.stats.get(TILES_TOTAL).addCount(totalTiles);
@@ -3367,7 +1901,6 @@ var Tileset3D = class {
     tile.destroy();
   }
   _syncSourceState(metadata) {
-    var _a;
     this.tileset = metadata.tileset;
     this.loader = metadata.loader;
     this.type = metadata.type;
@@ -3388,25 +1921,24 @@ var Tileset3D = class {
     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) {
+    if (this.options.attributions?.length) {
       this.credits = { attributions: this.options.attributions };
     } else {
       this.credits = this.source.credits || this.credits;
     }
   }
   _applyViewState() {
-    var _a, _b;
     const viewState = this.source.getViewState(this.root);
     this.asset = viewState.asset || this.source.asset || {};
     this.properties = viewState.properties ?? this.source.properties;
     this.extras = viewState.extras ?? this.source.extras ?? null;
     this.credits = viewState.credits || this.source.credits || this.credits || { attributions: this.options.attributions || [] };
     this.description = viewState.description || this.options.description || "";
-    this.boundingVolume = viewState.boundingVolume || ((_a = this.root) == null ? void 0 : _a.boundingVolume) || null;
+    this.boundingVolume = viewState.boundingVolume || this.root?.boundingVolume || null;
     this.cartographicCenter = viewState.cartographicCenter || new import_core5.Vector3();
     this.cartesianCenter = viewState.cartesianCenter || null;
     this.zoom = viewState.zoom || 1;
-    this.geometricError = ((_b = this.tileset) == null ? void 0 : _b.geometricError) || 0;
+    this.geometricError = this.tileset?.geometricError || 0;
   }
   /**
    * Returns normalized source metadata when initialization has already populated it.
@@ -3420,12 +1952,11 @@ 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;
+  return current?.status === "transformed" && current.sourceCrs === next.sourceCrs && current.targetCrs === next.targetCrs && current.targetHeightReference === next.targetHeightReference && current.outputCoordinates === next.outputCoordinates ? current : next;
 }
 
 // dist/tileset-3d/common/tileset-observability.js
 function getTileset3DTraversalSnapshot(tileset) {
-  var _a;
   const selectedTiles = tileset.selectedTiles.slice();
   const requestedTiles = tileset.requestedTiles.slice();
   const emptyTiles = tileset.emptyTiles.slice();
@@ -3435,7 +1966,7 @@ function getTileset3DTraversalSnapshot(tileset) {
     return typeof count === "number" && Number.isFinite(count) ? count : 0;
   };
   const implicitTilingSource = tileset.source;
-  const implicitTiling = (_a = implicitTilingSource.getImplicitTilingStats) == null ? void 0 : _a.call(implicitTilingSource);
+  const implicitTiling = implicitTilingSource.getImplicitTilingStats?.();
   return {
     frameNumber: tileset.frameNumber,
     selectedTileIds: getTileIds(selectedTiles),
@@ -3455,7 +1986,6 @@ function getTileset3DTraversalSnapshot(tileset) {
 
 // dist/tileset-3d/common/tileset-content-traversal.js
 async function* traverseTilesetContents(tileset, options = {}) {
-  var _a, _b;
   await tileset.tilesetInitializationPromise;
   throwIfAborted(options.signal);
   if (!tileset.root) {
@@ -3496,7 +2026,7 @@ async function* traverseTilesetContents(tileset, options = {}) {
         if (!loadResult.loaded) {
           throw new Error(`Unable to load tile content for tile ${tile.id}`);
         }
-        (_b = (_a = tileset.source).onTileLoaded) == null ? void 0 : _b.call(_a, tileset, tile, loadResult);
+        tileset.source.onTileLoaded?.(tileset, tile, loadResult);
       }
       yield { tile, contents: tile.contentEntries };
     } finally {
@@ -3510,12 +2040,13 @@ async function* traverseTilesetContents(tileset, options = {}) {
   }
 }
 function throwIfAborted(signal) {
-  if (signal == null ? void 0 : signal.aborted) {
+  if (signal?.aborted) {
     throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
   }
 }
 
 // dist/tileset-3d/common/indexed-archive-tileset-source.js
+var import_loader_utils3 = require("@loaders.gl/loader-utils");
 var IndexedArchiveTilesetSource = class {
   /** URL exposed to the tileset source that owns this archive source. */
   sourceUrl;
@@ -3583,30 +2114,30 @@ var IndexedArchiveTilesetSource = class {
   async openArchiveReadableFile() {
     const { data } = this.options;
     if (typeof data !== "string") {
-      return new BlobFile(data);
+      return new import_loader_utils3.BlobFile(data);
     }
     if (/^https?:\/\//i.test(data)) {
-      return new HttpFile(data);
+      return new import_loader_utils3.HttpFile(data);
     }
     const coreApi = this.options.getCoreApi();
     if (!coreApi) {
       throw new Error(this.options.missingCoreApiMessage);
     }
     const response = await coreApi.fetchFile(data);
-    return new BlobFile(await response.arrayBuffer());
+    return new import_loader_utils3.BlobFile(await response.arrayBuffer());
   }
   resolveArchivePath(request, baseUrl) {
     const requestWithoutQuery = stripQueryString(request);
     const archiveRoot = stripQueryString(this.sourceUrl);
     const baseWithoutQuery = stripQueryString(baseUrl);
-    const basePath = baseWithoutQuery === archiveRoot ? archiveRoot : path_exports.dirname(baseWithoutQuery);
+    const basePath = baseWithoutQuery === archiveRoot ? archiveRoot : import_loader_utils3.path.dirname(baseWithoutQuery);
     const markerExpression = new RegExp(`\\.${this.options.archiveExtension}/(.*)$`, "i");
     const markerMatch = requestWithoutQuery.match(markerExpression);
-    if (markerMatch == null ? void 0 : markerMatch[1]) {
+    if (markerMatch?.[1]) {
       return markerMatch[1];
     }
     const isAbsoluteRequest = /^[a-z][a-z0-9+.-]*:/i.test(requestWithoutQuery) || requestWithoutQuery.startsWith("/");
-    const absoluteRequest = requestWithoutQuery.startsWith(archiveRoot) ? requestWithoutQuery : baseWithoutQuery === archiveRoot && !isAbsoluteRequest ? `${archiveRoot}/${requestWithoutQuery}` : /^[a-z][a-z0-9+.-]*:\/\//i.test(baseWithoutQuery) ? new URL(requestWithoutQuery, baseWithoutQuery).href : path_exports.resolve(basePath, requestWithoutQuery);
+    const absoluteRequest = requestWithoutQuery.startsWith(archiveRoot) ? requestWithoutQuery : baseWithoutQuery === archiveRoot && !isAbsoluteRequest ? `${archiveRoot}/${requestWithoutQuery}` : /^[a-z][a-z0-9+.-]*:\/\//i.test(baseWithoutQuery) ? new URL(requestWithoutQuery, baseWithoutQuery).href : import_loader_utils3.path.resolve(basePath, requestWithoutQuery);
     if (absoluteRequest === archiveRoot) {
       return "";
     }
@@ -3636,7 +2167,6 @@ function getTile3DFeatureIdSets(payload) {
   const featureIdSets = [];
   const visited = /* @__PURE__ */ new Set();
   const visit = (value) => {
-    var _a, _b;
     if (!value || typeof value !== "object") {
       return;
     }
@@ -3645,7 +2175,7 @@ function getTile3DFeatureIdSets(payload) {
     }
     visited.add(value);
     const record = value;
-    const declarations = (_b = (_a = record.extensions) == null ? void 0 : _a.EXT_mesh_features) == null ? void 0 : _b.featureIds;
+    const declarations = record.extensions?.EXT_mesh_features?.featureIds;
     if (Array.isArray(declarations)) {
       for (const declaration of declarations) {
         if (!declaration || typeof declaration !== "object") {
@@ -3676,6 +2206,7 @@ function getTile3DFeatureIdSets(payload) {
 var import_core6 = require("@math.gl/core");
 var import_culling3 = require("@math.gl/culling");
 var import_geospatial4 = require("@math.gl/geospatial");
+var import_loader_utils4 = require("@loaders.gl/loader-utils");
 function defined(x) {
   return x !== void 0 && x !== null;
 }
@@ -3683,7 +2214,7 @@ var scratchPoint = new import_core6.Vector3();
 var scratchScale = new import_core6.Vector3();
 var identityTransform = new import_core6.Matrix4();
 function createBoundingVolume(boundingVolumeHeader, transform, result, initialTransform = transform) {
-  assert(boundingVolumeHeader, "3D Tile: boundingVolume must be defined");
+  (0, import_loader_utils4.assert)(boundingVolumeHeader, "3D Tile: boundingVolume must be defined");
   if (boundingVolumeHeader.box) {
     const boxTransform = boundingVolumeHeader.s2VolumeInfo ? identityTransform : transform;
     return createBox(boundingVolumeHeader.box, boxTransform, result);
@@ -3901,6 +2432,7 @@ function getProjectedRadius(tile, frameState) {
 }
 
 // dist/utils/managed-array.js
+var import_loader_utils5 = require("@loaders.gl/loader-utils");
 var ManagedArray = class {
   _map = /* @__PURE__ */ new Map();
   _array;
@@ -3941,7 +2473,7 @@ var ManagedArray = class {
    * @param {Number} index The index to get.
    */
   get(index) {
-    assert(index < this._array.length);
+    (0, import_loader_utils5.assert)(index < this._array.length);
     return this._array[index];
   }
   /**
@@ -3951,7 +2483,7 @@ var ManagedArray = class {
    * @param {*} element The element to set at index.
    */
   set(index, element) {
-    assert(index >= 0);
+    (0, import_loader_utils5.assert)(index >= 0);
     if (index >= this.length) {
       this.length = index + 1;
     }
@@ -4005,7 +2537,7 @@ var ManagedArray = class {
    * @param {Number} length The length.
    */
   reserve(length) {
-    assert(length >= 0);
+    (0, import_loader_utils5.assert)(length >= 0);
     if (length > this._array.length) {
       this._array.length = length;
     }
@@ -4016,7 +2548,7 @@ var ManagedArray = class {
    * @param {Number} length The length.
    */
   resize(length) {
-    assert(length >= 0);
+    (0, import_loader_utils5.assert)(length >= 0);
     this.length = length;
   }
   /**
@@ -4041,7 +2573,7 @@ var ManagedArray = class {
 };
 
 // dist/tileset-3d/common/tileset-traverser.js
-var DEFAULT_PROPS4 = {
+var DEFAULT_PROPS2 = {
   loadSiblings: false,
   skipLevelOfDetail: false,
   baseScreenSpaceError: 1024,
@@ -4081,7 +2613,7 @@ var TilesetTraverser = class {
   }
   // TODO nested props
   constructor(options) {
-    this.options = { ...DEFAULT_PROPS4, ...options };
+    this.options = { ...DEFAULT_PROPS2, ...options };
   }
   /** Returns whether skip-LOD traversal is enabled and supported by the loaded content. */
   isSkipLevelOfDetailEnabled() {
@@ -4193,9 +2725,6 @@ var TilesetTraverser = class {
           childRefines = child.contentAvailable;
         }
         refines = refines && childRefines;
-        if (!refines) {
-          return false;
-        }
       }
     }
     if (!hasVisibleChild) {
@@ -4661,7 +3190,7 @@ var Tile3D = class {
    */
   _getGpuMemoryUsageInBytes() {
     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);
+    return contents.reduce((total, content) => total + (content?.gpuMemoryUsageInBytes || content?.byteLength || 0), 0);
   }
   /**
    * Returns scheduler priority for render-content requests.
@@ -4767,13 +3296,12 @@ var Tile3D = class {
   }
   /** Loads source content and updates the tile's renderer-neutral payload state. */
   async _loadContentFromSource() {
-    var _a;
     const loadResult = await this.tileset.source.loadTileContent(this);
     if (loadResult.contents) {
       this.contents = loadResult.contents;
       this.content = this.contents[0] || null;
     }
-    this.vectorContent = ((_a = this.contents.find((content) => Boolean(content == null ? void 0 : content.vectorContent))) == null ? void 0 : _a.vectorContent) || null;
+    this.vectorContent = this.contents.find((content) => Boolean(content?.vectorContent))?.vectorContent || null;
     if (this.tileset.options.contentLoader) {
       await this.tileset.options.contentLoader(this);
     }
@@ -4870,13 +3398,12 @@ var Tile3D = class {
   }
   /** Refreshes tile and content metadata from a source or materialized tile header. */
   _initializeMetadata(header) {
-    var _a;
     this.metadata = header.metadata || null;
     const contentHeaders = Array.isArray(header.content) ? header.content : [header.content];
     this.contentMetadata = contentHeaders.filter(Boolean).map((contentHeader) => contentHeader.metadata || null);
     const firstContentHeader = contentHeaders.find(Boolean) || {};
     const groupReference = firstContentHeader.group;
-    const group = typeof groupReference === "number" ? ((_a = this.tileset.groups) == null ? void 0 : _a[groupReference]) || null : groupReference || null;
+    const group = typeof groupReference === "number" ? this.tileset.groups?.[groupReference] || null : groupReference || null;
     const metadataContext = {
       tileset: this.tileset.metadata || null,
       group,
@@ -4892,17 +3419,14 @@ var Tile3D = class {
   /** Updates payload and renderability while retaining immutable metadata descriptors. */
   _updateContentEntriesAfterLoad(loadResult) {
     if (loadResult.contentEntries) {
-      this.contentEntries = loadResult.contentEntries.map((entry, index) => {
-        var _a;
-        return {
-          ...entry,
-          index,
-          boundingVolume: entry.boundingVolume || this._contentBoundingVolumes[index] || this.boundingVolume,
-          payload: entry.payload ?? this.contents[index] ?? null,
-          featureIds: ((_a = entry.featureIds) == null ? void 0 : _a.length) ? entry.featureIds : getTile3DFeatureIdSets(entry.payload ?? this.contents[index]),
-          renderable: Boolean(entry.renderable !== false && (entry.payload ?? this.contents[index]) && !isNestedTilesetPayload(entry.payload ?? this.contents[index]))
-        };
-      });
+      this.contentEntries = loadResult.contentEntries.map((entry, index) => ({
+        ...entry,
+        index,
+        boundingVolume: entry.boundingVolume || this._contentBoundingVolumes[index] || this.boundingVolume,
+        payload: entry.payload ?? this.contents[index] ?? null,
+        featureIds: entry.featureIds?.length ? entry.featureIds : getTile3DFeatureIdSets(entry.payload ?? this.contents[index]),
+        renderable: Boolean(entry.renderable !== false && (entry.payload ?? this.contents[index]) && !isNestedTilesetPayload(entry.payload ?? this.contents[index]))
+      }));
       this.featureIdSets = this.contentEntries.flatMap((entry) => entry.featureIds);
       return;
     }
@@ -4920,8 +3444,7 @@ var Tile3D = class {
   }
   /** Returns whether an ordered content entry currently has renderable payload. */
   isContentRenderable(index) {
-    var _a;
-    return Boolean((_a = this.contentEntries[index]) == null ? void 0 : _a.renderable);
+    return Boolean(this.contentEntries[index]?.renderable);
   }
   /** Initializes additive renderer-neutral descriptors from a normalized tile header. */
   _initializeContentEntries(tileHeader) {
@@ -5004,7 +3527,6 @@ var Tile3D = class {
    * @param frameState - Current camera and viewport measurements.
    */
   _updateRequestPriorityMetrics(frameState) {
-    var _a, _b, _c, _d, _e;
     if (this.tileset.type !== TILESET_TYPE.TILES3D) {
       this._screenSpaceErrorProgressiveResolution = this._screenSpaceError;
       this._priorityProgressiveResolution = false;
@@ -5015,8 +3537,8 @@ var Tile3D = class {
     const options = this.tileset.options;
     const progressiveResolutionHeightFraction = options.progressiveResolutionHeightFraction;
     this._screenSpaceErrorProgressiveResolution = this.getScreenSpaceError(frameState, false, progressiveResolutionHeightFraction);
-    this._priorityProgressiveResolution = isProgressiveResolutionPriority(this._screenSpaceErrorProgressiveResolution, (_a = this.parent) == null ? void 0 : _a._screenSpaceErrorProgressiveResolution, this.tileset.memoryAdjustedScreenSpaceError, progressiveResolutionHeightFraction);
-    if (!options.foveatedScreenSpaceError || ((_b = frameState.viewport) == null ? void 0 : _b.orthographic) || !((_c = frameState.camera) == null ? void 0 : _c.position) || !((_d = frameState.camera) == null ? void 0 : _d.direction)) {
+    this._priorityProgressiveResolution = isProgressiveResolutionPriority(this._screenSpaceErrorProgressiveResolution, this.parent?._screenSpaceErrorProgressiveResolution, this.tileset.memoryAdjustedScreenSpaceError, progressiveResolutionHeightFraction);
+    if (!options.foveatedScreenSpaceError || frameState.viewport?.orthographic || !frameState.camera?.position || !frameState.camera?.direction) {
       this._foveatedFactor = 0;
       this.priorityDeferred = false;
       return;
@@ -5034,7 +3556,7 @@ var Tile3D = class {
       foveatedFactor: this._foveatedFactor,
       verticalFieldOfView: frameState.camera.verticalFieldOfView,
       screenSpaceError: this._screenSpaceError,
-      parentScreenSpaceError: (_e = this.parent) == null ? void 0 : _e._screenSpaceError,
+      parentScreenSpaceError: this.parent?._screenSpaceError,
       maximumScreenSpaceError: this.tileset.memoryAdjustedScreenSpaceError,
       priorityProgressiveResolution: this._priorityProgressiveResolution
     });
@@ -5106,8 +3628,7 @@ var Tile3D = class {
   // INTERNAL METHODS
   /** Initializes the tile's LOD metric from its header or its nearest available ancestor. */
   _initializeLodMetric(header) {
-    var _a;
-    this._scaleGeometricError = typeof header._scaleGeometricError === "boolean" ? header._scaleGeometricError : ((_a = this.parent) == null ? void 0 : _a._scaleGeometricError) ?? true;
+    this._scaleGeometricError = typeof header._scaleGeometricError === "boolean" ? header._scaleGeometricError : this.parent?._scaleGeometricError ?? true;
     if ("lodMetricType" in header) {
       this.lodMetricType = header.lodMetricType;
     } else {
@@ -5158,13 +3679,12 @@ var Tile3D = class {
     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 || ((_a = tileHeader.contentUrls) == null ? void 0 : _a.length)) {
+    if (tileHeader.contentUrl || tileHeader.contentUrls?.length) {
       this.content = null;
       this.hasEmptyContent = false;
     }
@@ -5203,7 +3723,7 @@ var Tile3D = class {
    * `content`.
    */
   _isTileset() {
-    return (this.contents.length ? this.contents : [this.content]).some((content) => (content == null ? void 0 : content.shape) === "tileset3d");
+    return (this.contents.length ? this.contents : [this.content]).some((content) => content?.shape === "tileset3d");
   }
   _onContentLoaded() {
     const contents = this.contents.length ? this.contents : [this.content];
@@ -5233,7 +3753,7 @@ var Tile3D = class {
       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, void 0, this._initialTransform) : this.boundingVolume) : [this.boundingVolume];
+    this._contentBoundingVolumes = contentHeaders.length ? contentHeaders.map((headerEntry) => headerEntry?.boundingVolume ? createBoundingVolume(headerEntry.boundingVolume, this.computedTransform, void 0, this._initialTransform) : this.boundingVolume) : [this.boundingVolume];
     this._contentBoundingVolume = this._contentBoundingVolumes[0] || null;
   }
   /**
@@ -5253,7 +3773,8 @@ var Tile3D = class {
 };
 
 // dist/tileset-3d/format-3d-tiles/tiles-3d-source.js
-var import_geospatial10 = require("@math.gl/geospatial");
+var import_loader_utils6 = require("@loaders.gl/loader-utils");
+var import_geospatial9 = require("@math.gl/geospatial");
 var import_core12 = require("@math.gl/core");
 
 // dist/tileset-3d/format-3d-tiles/tileset-3d-traverser.js
@@ -5309,7 +3830,7 @@ var Tileset3DTraverser = class extends TilesetTraverser {
       if (!tile.hasRenderContent) {
         this.emptyTiles[tile.id] = tile;
         this.loadTile(tile, frameState);
-        if (stoppedRefining) {
+        if (stoppedRefining && (!tile.hasEmptyContent || tile.hasChildren)) {
           this.selectDesiredTile(tile, frameState);
         }
       } else if (tile.refine === TILE_REFINEMENT.ADD) {
@@ -5350,7 +3871,7 @@ var Tileset3DTraverser = class extends TilesetTraverser {
       if (child.isVisibleAndInRequestVolume) {
         stack.push(child);
         hasVisibleChild = true;
-      } else if (this.options.loadSiblings) {
+      } else if (this.options.loadSiblings && child._inRequestVolume) {
         this.loadTile(child, frameState);
         this.touchTile(child, frameState);
       }
@@ -5430,6 +3951,9 @@ var Tileset3DTraverser = class extends TilesetTraverser {
     while (fallbackTile) {
       if (this.shouldSelectTile(fallbackTile, frameState)) {
         this.selectTile(fallbackTile, frameState);
+        if (fallbackTile !== tile) {
+          this.selectLoadedDescendants(tile, frameState, true);
+        }
         return;
       }
       fallbackTile = fallbackTile.parent;
@@ -5441,8 +3965,9 @@ var Tileset3DTraverser = class extends TilesetTraverser {
    *
    * @param root - Unavailable tile whose descendants are searched.
    * @param frameState - Current culling state.
+   * @param drawnOnly - Reuse drawn detail without starting obsolete GPU work.
    */
-  selectLoadedDescendants(root, frameState) {
+  selectLoadedDescendants(root, frameState, drawnOnly = false) {
     const stack = [{ tile: root, depth: 0 }];
     while (stack.length > 0) {
       const { tile, depth } = stack.pop();
@@ -5451,7 +3976,7 @@ var Tileset3DTraverser = class extends TilesetTraverser {
         if (!child.isVisibleAndInRequestVolume) {
           continue;
         }
-        if (child.contentAvailable) {
+        if (this.shouldSelectTile(child, frameState) && (!drawnOnly || child.tileDrawn)) {
           this.selectTile(child, frameState);
           this.touchTile(child, frameState);
         } else if (depth < 1) {
@@ -5478,8 +4003,7 @@ var Tileset3DTraverser = class extends TilesetTraverser {
    * @param frameState - Current culling and LOD state.
    */
   updateChildTiles(tile, frameState) {
-    var _a;
-    const isImplicitHierarchyRoot = ((_a = tile.header.implicitSubtree) == null ? void 0 : _a.coordinates.level) === 0;
+    const isImplicitHierarchyRoot = tile.header.implicitSubtree?.coordinates.level === 0;
     if (tile.hasUnloadedChildren && tile.isVisibleAndInRequestVolume && (isImplicitHierarchyRoot || this.shouldRefine(tile, frameState))) {
       const requestKey = `${frameState.viewport.id}:${tile.id}`;
       if (!this.pendingImplicitSubtrees.has(requestKey)) {
@@ -5662,19 +4186,18 @@ function getI3SVerticalUnitScale(heightUnit, zFactor) {
 
 // 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 spatialReference = layer.spatialReference || layer.fullExtent?.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 verticalCrs = layer.heightModelInfo?.vertCRS || getI3SVerticalCrsDefinition(spatialReference);
+  const heightModel = layer.heightModelInfo?.heightModel;
+  const verticalUnit = layer.heightModelInfo?.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 ? sourceCrs ? getSpatialCoordinateFrame(sourceCrs) : "unknown" : getSpatialCoordinateFrame(`EPSG:${sourceIdentifier}`);
   const units = getI3SCoordinateUnits(coordinateFrame, verticalUnit, layer.ZFactor);
   const warnings = [];
-  const elevationMode = getI3SElevationMode((_e = layer.elevationInfo) == null ? void 0 : _e.mode);
+  const elevationMode = getI3SElevationMode(layer.elevationInfo?.mode);
   const elevationUnit = layer.elevationInfo ? layer.elevationInfo.unit || "meter" : void 0;
   const elevationUnitScale = getI3SLinearUnitScale(elevationUnit);
   if (verticalUnitScale === void 0) {
@@ -5683,7 +4206,7 @@ function getI3SSpatialReference(layer) {
   if (layer.elevationInfo && elevationUnitScale === void 0) {
     warnings.push(`Unsupported I3S elevation unit ${elevationUnit}`);
   }
-  if (((_f = layer.elevationInfo) == null ? void 0 : _f.mode) && !elevationMode) {
+  if (layer.elevationInfo?.mode && !elevationMode) {
     warnings.push(`Unsupported I3S elevation mode ${layer.elevationInfo.mode}`);
   }
   if (elevationMode && elevationMode !== "absoluteHeight") {
@@ -5692,15 +4215,15 @@ function getI3SSpatialReference(layer) {
   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,
+    sourceCrsAlternatives: sourceIdentifier !== 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,
+    elevationOffset: layer.elevationInfo?.offset,
     elevationUnit,
-    elevationUnitScale: ((_h = layer.elevationInfo) == null ? void 0 : _h.mode) && !elevationMode ? Number.NaN : elevationUnitScale ?? (layer.elevationInfo ? Number.NaN : 1),
+    elevationUnitScale: layer.elevationInfo?.mode && !elevationMode ? Number.NaN : elevationUnitScale ?? (layer.elevationInfo ? Number.NaN : 1),
     coordinateFrame,
     axisOrder: sourceCrs ? "xyz" : "unknown",
     provenance: sourceCrs ? "metadata" : "unknown",
@@ -5728,7 +4251,6 @@ function getI3SElevationMode(mode) {
   }
 }
 function get3DTilesSpatialReference(tileset) {
-  var _a, _b;
   const draftSpatialReference = getDraft3DTilesSpatialReference(tileset);
   if (draftSpatialReference) {
     return draftSpatialReference;
@@ -5747,7 +4269,7 @@ function get3DTilesSpatialReference(tileset) {
     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) {
+  } else if (tileset.root?.boundingVolume?.region) {
     sourceCrs = "EPSG:4978";
     provenance = "format-default";
     sourceCrsState = "default";
@@ -5771,8 +4293,7 @@ function get3DTilesSpatialReference(tileset) {
   });
 }
 function getDraft3DTilesSpatialReference(tileset) {
-  var _a, _b, _c;
-  const extension = (_a = tileset.extensions) == null ? void 0 : _a.EXT_geospatial_crs;
+  const extension = tileset.extensions?.EXT_geospatial_crs;
   if (!extension) {
     return void 0;
   }
@@ -5782,8 +4303,8 @@ function getDraft3DTilesSpatialReference(tileset) {
   let epoch;
   let representation;
   if (extension.format === "wkid") {
-    const wkidExtension = (_b = extension.extensions) == null ? void 0 : _b.EXT_geospatial_crs_wkid;
-    if (typeof (wkidExtension == null ? void 0 : wkidExtension.authority) === "string" && Number.isInteger(wkidExtension.wkid)) {
+    const wkidExtension = extension.extensions?.EXT_geospatial_crs_wkid;
+    if (typeof wkidExtension?.authority === "string" && Number.isInteger(wkidExtension.wkid)) {
       sourceCrs = `${wkidExtension.authority}:${wkidExtension.wkid}`;
       representation = "identifier";
       if (Number.isInteger(wkidExtension.vcsWkid)) {
@@ -5797,8 +4318,8 @@ function getDraft3DTilesSpatialReference(tileset) {
       warnings.push("EXT_geospatial_crs_wkid requires string authority and integer wkid");
     }
   } else if (extension.format === "wkt2") {
-    const wktExtension = (_c = extension.extensions) == null ? void 0 : _c.EXT_geospatial_crs_wkt2;
-    if (typeof (wktExtension == null ? void 0 : wktExtension.wkt2) === "string" && wktExtension.wkt2.trim()) {
+    const wktExtension = extension.extensions?.EXT_geospatial_crs_wkt2;
+    if (typeof wktExtension?.wkt2 === "string" && wktExtension.wkt2.trim()) {
       sourceCrs = wktExtension.wkt2;
       representation = "wkt";
     } else {
@@ -5812,7 +4333,7 @@ function getDraft3DTilesSpatialReference(tileset) {
   if (verticalCrs && !verticalSemantics) {
     warnings.push(`Unsupported vertical CRS ${String(verticalCrs)}; vertical unit and height reference are unknown`);
   }
-  const verticalUnit = verticalCrs ? verticalSemantics == null ? void 0 : verticalSemantics.unit : "meter";
+  const verticalUnit = verticalCrs ? verticalSemantics?.unit : "meter";
   return createTilesetSpatialReference({
     sourceCrs,
     sourceCrsState: sourceCrs ? "explicit" : "unknown",
@@ -5820,8 +4341,8 @@ function getDraft3DTilesSpatialReference(tileset) {
     verticalCrs,
     coordinateEpoch: epoch,
     units: coordinateFrame === "geocentric" ? ["meter", "meter", "meter"] : coordinateFrame === "geographic" && verticalUnit ? ["degree", "degree", verticalUnit] : void 0,
-    verticalUnitScale: verticalCrs ? (verticalSemantics == null ? void 0 : verticalSemantics.verticalUnitScale) ?? Number.NaN : 1,
-    heightReference: verticalCrs ? (verticalSemantics == null ? void 0 : verticalSemantics.heightReference) ?? "unknown" : sourceCrs ? "ellipsoidal" : "unknown",
+    verticalUnitScale: verticalCrs ? verticalSemantics?.verticalUnitScale ?? Number.NaN : 1,
+    heightReference: verticalCrs ? verticalSemantics?.heightReference ?? "unknown" : sourceCrs ? "ellipsoidal" : "unknown",
     coordinateFrame,
     axisOrder: sourceCrs ? "xyz" : "unknown",
     provenance: "metadata",
@@ -5866,27 +4387,26 @@ function getI3SCrsDefinition(spatialReference) {
   if (identifier !== void 0) {
     return `EPSG:${identifier}`;
   }
-  return spatialReference == null ? void 0 : spatialReference.wkt;
+  return spatialReference?.wkt;
 }
 function getI3SVerticalCrsDefinition(spatialReference) {
-  const identifier = (spatialReference == null ? void 0 : spatialReference.latestVcsWkid) ?? (spatialReference == null ? void 0 : spatialReference.vcsWkid);
+  const identifier = spatialReference?.latestVcsWkid ?? 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);
+  return spatialReference?.latestWkid ?? spatialReference?.wkid;
 }
 function getTilesetSemanticValue(tileset, semantic) {
-  var _a, _b, _c, _d;
-  const classIdentifier = (_a = tileset.metadata) == null ? void 0 : _a.class;
+  const classIdentifier = tileset.metadata?.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;
+  const classDefinition = tileset.schema?.classes?.[classIdentifier];
+  const propertyDefinitions = classDefinition?.properties;
+  const propertyValues = tileset.metadata?.properties;
   for (const [propertyIdentifier, propertyDefinition] of Object.entries(propertyDefinitions || {})) {
     if (propertyDefinition.semantic === semantic) {
-      return propertyValues == null ? void 0 : propertyValues[propertyIdentifier];
+      return propertyValues?.[propertyIdentifier];
     }
   }
   return void 0;
@@ -5895,19 +4415,27 @@ function getTilesetSemanticValue(tileset, semantic) {
 // dist/spatial/spatial-coordinate-transformer.js
 var import_core10 = require("@math.gl/core");
 var import_geospatial7 = require("@math.gl/geospatial");
-var import_projection2 = require("@math.gl/projection");
+var import_bulk = require("@math.gl/projection/bulk");
 
 // dist/spatial/spatial-resource-registry.js
 var import_geoid = require("@math.gl/geoid");
 var import_projection = require("@math.gl/projection");
 var geoidModels = /* @__PURE__ */ new Map();
+var projectionAliases = {};
+var datumGrids = {};
+var spatialProjectionEngine = new import_projection.FullProjectionEngine();
+function getSpatialProjectionEngine() {
+  return spatialProjectionEngine;
+}
 function registerSpatialCrs(name, definition) {
   validateResourceName(name, "CRS");
-  import_projection.Projection.defineProjectionAliases({ [name]: definition });
+  projectionAliases[name] = definition;
+  spatialProjectionEngine = new import_projection.FullProjectionEngine({ aliases: projectionAliases, datumGrids });
 }
 function registerSpatialDatumGrid(name, data) {
   validateResourceName(name, "datum grid");
-  import_projection.Projection.registerDatumGrid(name, data);
+  datumGrids[name] = (0, import_projection.parseNTv2Grid)(data);
+  spatialProjectionEngine = new import_projection.FullProjectionEngine({ aliases: projectionAliases, datumGrids });
 }
 function registerGeoidModel(name, geoid) {
   validateResourceName(name, "geoid model");
@@ -5933,6 +4461,8 @@ var SpatialCoordinateTransformer = class {
   spatialReference;
   /** Projection from the source CRS directly to the requested horizontal target CRS. */
   horizontalProjection;
+  /** Reusable packed xyz projection for horizontal-only coordinate batches. */
+  horizontalProjectionBuffer;
   /** Projection from the source CRS to geographic longitude, latitude, and ellipsoidal height. */
   geographicProjection;
   /** Projection from adjusted geographic coordinates to the requested output CRS. */
@@ -5955,6 +4485,7 @@ var SpatialCoordinateTransformer = class {
    */
   constructor(spatialReference, options = {}) {
     this.spatialReference = spatialReference;
+    const projectionEngine = getSpatialProjectionEngine();
     validateTransformRequest(spatialReference);
     const outputCrs = spatialReference.targetCrs || spatialReference.sourceCrs;
     this.sourceIsGeocentric = isWgs84Geocentric(spatialReference.sourceCrs);
@@ -5962,22 +4493,28 @@ var SpatialCoordinateTransformer = class {
     this.sourceIsGeographic = isWgs84Geographic(spatialReference.sourceCrs);
     this.outputIsGeographic = isWgs84Geographic(outputCrs);
     if (spatialReference.sourceCrs && spatialReference.targetCrs && !this.sourceIsGeocentric && !this.outputIsGeocentric) {
-      this.horizontalProjection = new import_projection2.Projection({
+      this.horizontalProjection = projectionEngine.createProjection({
         from: getHorizontalProjectionDefinition(spatialReference.sourceCrs),
         to: getHorizontalProjectionDefinition(spatialReference.targetCrs),
         enforceAxis: false
       });
+      if (!requiresHeightTransformation(spatialReference)) {
+        this.horizontalProjectionBuffer = new import_bulk.ProjectionBuffer({
+          projection: this.horizontalProjection,
+          dimension: 3
+        });
+      }
     }
     if (requiresHeightTransformation(spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
       if (!this.sourceIsGeographic && !this.sourceIsGeocentric) {
-        this.geographicProjection = new import_projection2.Projection({
+        this.geographicProjection = projectionEngine.createProjection({
           from: getHorizontalProjectionDefinition(spatialReference.sourceCrs),
           to: WGS84_GEOGRAPHIC_CRS,
           enforceAxis: false
         });
       }
       if (!this.outputIsGeographic && !this.outputIsGeocentric) {
-        this.heightOutputProjection = new import_projection2.Projection({
+        this.heightOutputProjection = projectionEngine.createProjection({
           from: WGS84_GEOGRAPHIC_CRS,
           to: getHorizontalProjectionDefinition(outputCrs),
           enforceAxis: false
@@ -6017,17 +4554,23 @@ var SpatialCoordinateTransformer = class {
       return result;
     }
     if (this.horizontalProjection) {
-      const projected = this.horizontalProjection.project(result.slice(0, 3));
+      const projected = this.horizontalProjection.projectSync(result.slice(0, 3));
       result.splice(0, projected.length, ...projected);
     }
     return result;
   }
-  /** Transform a packed sequence of xyz positions, preserving the input array type only when safe. */
+  /** Transform packed xyz positions into owned Float64 storage, batching finite horizontal transforms. */
   transformPositions(positions) {
     if (positions.length % 3 !== 0) {
       throw new Error("Packed spatial positions must contain a multiple of three components");
     }
     const transformedPositions = new Float64Array(positions.length);
+    if (this.horizontalProjectionBuffer) {
+      transformedPositions.set(positions);
+      if (transformedPositions.every(Number.isFinite)) {
+        return this.horizontalProjectionBuffer.projectFlatTo(transformedPositions, transformedPositions);
+      }
+    }
     for (let index = 0; index < positions.length; index += 3) {
       const transformed = this.transformPosition([
         Number(positions[index]),
@@ -6081,7 +4624,7 @@ var SpatialCoordinateTransformer = class {
     if (this.sourceIsGeographic) {
       return coordinate.slice(0, 3);
     }
-    return this.geographicProjection.project(coordinate.slice(0, 3));
+    return this.geographicProjection.projectSync(coordinate.slice(0, 3));
   }
   /** Convert one conventional WGS84 geographic coordinate to the selected output CRS. */
   fromGeographic(coordinate) {
@@ -6091,7 +4634,7 @@ var SpatialCoordinateTransformer = class {
     if (this.outputIsGeographic) {
       return coordinate.slice(0, 3);
     }
-    return this.heightOutputProjection.project(coordinate.slice(0, 3));
+    return this.heightOutputProjection.projectSync(coordinate.slice(0, 3));
   }
 };
 function getFiniteDifferenceJacobian(transformer, position, epsilon) {
@@ -6189,7 +4732,6 @@ function transformHeight(height, geoidUndulation, source, target) {
 
 // dist/spatial/tiles-3d-spatial-transformer.js
 var import_core11 = require("@math.gl/core");
-var import_geospatial8 = require("@math.gl/geospatial");
 var Tiles3DSpatialTransformer = class {
   /** Normalized reference describing the completed operation. */
   spatialReference;
@@ -6228,16 +4770,6 @@ var Tiles3DSpatialTransformer = class {
   }
   /** Transforms one WGS84 region sample into the selected output frame. */
   transformRegionSample(sample) {
-    const [longitudeDegrees, latitudeDegrees, height] = sample;
-    const targetCrs = this.spatialReference.targetCrs || this.spatialReference.sourceCrs;
-    if (targetCrs && getSpatialCoordinateFrame(targetCrs) === "geocentric") {
-      const cartesian = import_geospatial8.Ellipsoid.WGS84.cartographicToCartesian([
-        longitudeDegrees,
-        latitudeDegrees,
-        height
-      ]);
-      return Array.from(cartesian);
-    }
     return this.geographicCoordinateTransformer.transformPosition(sample);
   }
 };
@@ -6346,10 +4878,10 @@ var import_s22 = require("@math.gl/dggs/s2");
 
 // dist/tileset-3d/helpers/s2-bounding-volume.js
 var import_s2 = require("@math.gl/dggs/s2");
-var import_geospatial9 = require("@math.gl/geospatial");
+var import_geospatial8 = require("@math.gl/geospatial");
 function convertS2BoundingVolumeToOBB(s2VolumeInfo) {
   const [[west, south], [east, north]] = (0, import_s2.getS2Bounds)(s2VolumeInfo.token);
-  const orientedBoundingBox = (0, import_geospatial9.makeOBBFromRegion)([west, south, east, north, s2VolumeInfo.minimumHeight, s2VolumeInfo.maximumHeight], import_geospatial9.Ellipsoid.WGS84, { units: "degrees" });
+  const orientedBoundingBox = (0, import_geospatial8.makeOBBFromRegion)([west, south, east, north, s2VolumeInfo.minimumHeight, s2VolumeInfo.maximumHeight], import_geospatial8.Ellipsoid.WGS84, { units: "degrees" });
   return [...orientedBoundingBox.center, ...orientedBoundingBox.halfAxes];
 }
 
@@ -6504,7 +5036,6 @@ function createLazyImplicitTileHeader(subtree, descriptor, coordinates) {
   };
 }
 function getSubtreeAttributeOverrides(attributes, rowIndex, scope) {
-  var _a, _b;
   if (!attributes || rowIndex < 0) {
     return {};
   }
@@ -6529,11 +5060,11 @@ function getSubtreeAttributeOverrides(attributes, rowIndex, scope) {
   if (scope === "content") {
     return { boundingVolume };
   }
-  const geometricError = (_a = getAttributeComponents(attributes.TILE_GEOMETRIC_ERROR, rowIndex, 1)) == null ? void 0 : _a[0];
+  const geometricError = getAttributeComponents(attributes.TILE_GEOMETRIC_ERROR, rowIndex, 1)?.[0];
   if (geometricError !== void 0 && (!Number.isFinite(geometricError) || geometricError < 0)) {
     throw new Error("3DTILES_subtree: TILE_GEOMETRIC_ERROR must be nonnegative");
   }
-  const refineValue = (_b = getAttributeComponents(attributes.TILE_REFINE, rowIndex, 1)) == null ? void 0 : _b[0];
+  const refineValue = getAttributeComponents(attributes.TILE_REFINE, rowIndex, 1)?.[0];
   if (refineValue !== void 0 && refineValue !== 0 && refineValue !== 1) {
     throw new Error("3DTILES_subtree: TILE_REFINE must be 0 or 1");
   }
@@ -6555,7 +5086,6 @@ function getAttributeComponents(values, rowIndex, componentCount) {
   return Array.from({ length: componentCount }, (_unused, componentIndex) => Number(values[offset + componentIndex]));
 }
 function getAvailabilityRank(availability, index) {
-  var _a;
   if (availability.constant === 1) {
     return index;
   }
@@ -6564,7 +5094,7 @@ function getAvailabilityRank(availability, index) {
   }
   let ranks = AVAILABILITY_RANK_CACHE.get(availability);
   if (!ranks) {
-    const bitCount = (((_a = availability.explicitBitstream) == null ? void 0 : _a.byteLength) || 0) * 8;
+    const bitCount = (availability.explicitBitstream?.byteLength || 0) * 8;
     ranks = new Uint32Array(bitCount + 1);
     for (let candidateIndex = 0; candidateIndex < bitCount; candidateIndex++) {
       ranks[candidateIndex + 1] = ranks[candidateIndex] + Number(getAvailabilityValue(availability, candidateIndex));
@@ -6574,12 +5104,11 @@ function getAvailabilityRank(availability, index) {
   return ranks[index];
 }
 function findImplicitPackageResource(files, resourceUrl) {
-  var _a;
-  if (!(files == null ? void 0 : files.length)) {
+  if (!files?.length) {
     return void 0;
   }
   const urlWithoutQuery = resourceUrl.split("?")[0];
-  const packageRelativePath = (_a = /^gltf-package:\/\/[^/]+\/(.*)$/.exec(urlWithoutQuery)) == null ? void 0 : _a[1];
+  const packageRelativePath = /^gltf-package:\/\/[^/]+\/(.*)$/.exec(urlWithoutQuery)?.[1];
   const exactFileIndex = files.findIndex((file) => {
     const reference = file.originalUri || file.name;
     return file.uri === urlWithoutQuery || Boolean(reference && (urlWithoutQuery === reference || packageRelativePath === reference));
@@ -6594,10 +5123,10 @@ function findImplicitPackageResource(files, resourceUrl) {
   return fileIndex < 0 ? void 0 : { fileIndex, files };
 }
 function mergeImplicitPackageFiles(parentFiles, childFiles) {
-  if (!(childFiles == null ? void 0 : childFiles.length)) {
+  if (!childFiles?.length) {
     return parentFiles;
   }
-  if (!(parentFiles == null ? void 0 : parentFiles.length)) {
+  if (!parentFiles?.length) {
     return childFiles;
   }
   const childReferences = new Set(childFiles.flatMap((file) => [file.uri, file.originalUri, file.name].filter(Boolean)));
@@ -6607,18 +5136,17 @@ function mergeImplicitPackageFiles(parentFiles, childFiles) {
   ];
 }
 function formatImplicitTileHeader(subtree, descriptor, reference, coordinates, availabilityIndex, contentAvailability, children) {
-  var _a, _b, _c, _d, _e;
   const tilePropertyIndex = getAvailabilityRank(subtree.tileAvailability, availabilityIndex);
-  const tileProperties = (_a = subtree.tilePropertyRows) == null ? void 0 : _a[tilePropertyIndex];
+  const tileProperties = subtree.tilePropertyRows?.[tilePropertyIndex];
   const primaryContentAvailability = Array.isArray(subtree.contentAvailability) ? subtree.contentAvailability[0] : subtree.contentAvailability;
   const contentPropertyIndex = primaryContentAvailability && getAvailabilityValue(primaryContentAvailability, availabilityIndex) ? getAvailabilityRank(primaryContentAvailability, availabilityIndex) : -1;
-  const contentProperties = (_b = subtree.contentPropertyRows) == null ? void 0 : _b[contentPropertyIndex];
-  const tileTemplateProperties = ((_c = subtree.tileTemplatePropertyRows) == null ? void 0 : _c[tilePropertyIndex]) || tileProperties;
-  const contentTemplateProperties = ((_d = subtree.contentTemplatePropertyRows) == null ? void 0 : _d[contentPropertyIndex]) || contentProperties;
+  const contentProperties = subtree.contentPropertyRows?.[contentPropertyIndex];
+  const tileTemplateProperties = subtree.tileTemplatePropertyRows?.[tilePropertyIndex] || tileProperties;
+  const contentTemplateProperties = subtree.contentTemplatePropertyRows?.[contentPropertyIndex] || contentProperties;
   const templateProperties = { ...tileTemplateProperties, ...contentTemplateProperties };
   const tileAttributes = getSubtreeAttributeOverrides(subtree.tileAttributes, tilePropertyIndex, "tile");
   const contentAttributes = getSubtreeAttributeOverrides(subtree.contentAttributes, contentPropertyIndex, "content");
-  const contentUrlTemplates = ((_e = descriptor.contentUrlTemplates) == null ? void 0 : _e.length) ? descriptor.contentUrlTemplates : [descriptor.contentUrlTemplate];
+  const contentUrlTemplates = descriptor.contentUrlTemplates?.length ? descriptor.contentUrlTemplates : [descriptor.contentUrlTemplate];
   const contentEntries = contentUrlTemplates.map((templateUrl, contentIndex) => {
     if (!contentAvailability[contentIndex] || !templateUrl) {
       return null;
@@ -6635,10 +5163,9 @@ function formatImplicitTileHeader(subtree, descriptor, reference, coordinates, a
   const availableContentUrls = contentEntries.map((entry) => entry.contentUrl);
   const resourceFiles = mergeImplicitPackageFiles(descriptor.resourceFiles, subtree.resourceFiles);
   const content = contentEntries.map(({ contentIndex, contentUrl: contentUrl2 }) => {
-    var _a2;
     const packageResource = findImplicitPackageResource(resourceFiles, contentUrl2);
     return {
-      ...((_a2 = descriptor.contentHeaders) == null ? void 0 : _a2[contentIndex]) || (contentIndex === 0 ? descriptor.contentHeader : {}) || {},
+      ...descriptor.contentHeaders?.[contentIndex] || (contentIndex === 0 ? descriptor.contentHeader : {}) || {},
       ...contentAttributes,
       uri: contentUrl2,
       ...contentProperties ? { metadata: { properties: contentProperties } } : {},
@@ -6686,10 +5213,10 @@ function getImplicitTileId(reference, coordinates) {
   return `${reference.subtreeUrl}#implicit=${coordinates.level}/${coordinates.x}/${coordinates.y}/${coordinates.z}`;
 }
 function getAvailabilityValue(availability, index) {
-  if (typeof (availability == null ? void 0 : availability.constant) === "number") {
+  if (typeof availability?.constant === "number") {
     return Boolean(availability.constant);
   }
-  const bitstream = availability == null ? void 0 : availability.explicitBitstream;
+  const bitstream = availability?.explicitBitstream;
   if (!bitstream) {
     return false;
   }
@@ -6716,7 +5243,6 @@ function getImplicitChildCount(subdivisionScheme) {
   return subdivisionScheme === "OCTREE" ? OCTREE_CHILD_COUNT : QUADTREE_CHILD_COUNT;
 }
 function calculateImplicitBoundingVolume(rootBoundingVolume, coordinates, subdivisionScheme) {
-  var _a;
   if (rootBoundingVolume.region) {
     const [west, south, east, north, minimumHeight, maximumHeight] = rootBoundingVolume.region;
     const divisionCount = 2 ** coordinates.level;
@@ -6748,7 +5274,7 @@ function calculateImplicitBoundingVolume(rootBoundingVolume, coordinates, subdiv
     if (rootBoundingVolume.s2VolumeInfo) {
       return calculateS2ImplicitBoundingVolume(rootBoundingVolume, coordinates, subdivisionScheme);
     }
-    if ((_a = rootBoundingVolume.extensions) == null ? void 0 : _a["3DTILES_shape_cylinder_region"]) {
+    if (rootBoundingVolume.extensions?.["3DTILES_shape_cylinder_region"]) {
       return {
         ...rootBoundingVolume,
         box: [...rootBoundingVolume.box]
@@ -6794,10 +5320,10 @@ function calculateS2ImplicitBoundingVolume(rootBoundingVolume, coordinates, subd
     maximumHeight: rootS2VolumeInfo.minimumHeight + (subdivisionScheme === "OCTREE" ? heightSize * (coordinates.z + 1) : heightSize * divisionCount)
   };
   const extensions = rootBoundingVolume.extensions ? { ...rootBoundingVolume.extensions } : void 0;
-  if (extensions == null ? void 0 : extensions["3DTILES_bounding_volume_S2"]) {
+  if (extensions?.["3DTILES_bounding_volume_S2"]) {
     extensions["3DTILES_bounding_volume_S2"] = childS2VolumeInfo;
   }
-  if (extensions == null ? void 0 : extensions["3DTILES_shape_s2"]) {
+  if (extensions?.["3DTILES_shape_s2"]) {
     extensions["3DTILES_shape_s2"] = childS2VolumeInfo;
   }
   return {
@@ -6818,11 +5344,10 @@ function normalizeRegionLongitude(longitude) {
   return normalizedLongitude;
 }
 function getImplicitTileType(contentUrl) {
-  var _a;
   if (!contentUrl) {
     return TILE_TYPE.EMPTY;
   }
-  const extension = (_a = contentUrl.split("?")[0].split(".").pop()) == null ? void 0 : _a.toLowerCase();
+  const extension = contentUrl.split("?")[0].split(".").pop()?.toLowerCase();
   switch (extension) {
     case "pnts":
       return TILE_TYPE.POINTCLOUD;
@@ -6917,19 +5442,18 @@ var Tiles3DSource = class {
    * @param loadOptions Loader options forwarded to tile requests.
    */
   constructor(input, loadOptions = {}) {
-    var _a;
     const request = normalizeTiles3DRequest(input);
     this.rootTileset = isTilesetRequest(input) ? null : input;
     this.tileset = this.rootTileset;
     this.loader = request.loader;
     this.url = request.url;
-    this.basePath = request.basePath || path_exports.dirname(request.url);
+    this.basePath = request.basePath || import_loader_utils6.path.dirname(request.url);
     this.resolver = request.resolver;
     this.coreApi = request.coreApi;
     this.loadOptions = loadOptions;
-    const maximumCachedSubtrees = Number((_a = loadOptions["3d-tiles"]) == null ? void 0 : _a.maximumCachedSubtrees);
+    const maximumCachedSubtrees = Number(loadOptions["3d-tiles"]?.maximumCachedSubtrees);
     const maximumCacheEntries = Number.isFinite(maximumCachedSubtrees) ? Math.max(0, Math.floor(maximumCachedSubtrees)) : DEFAULT_MAXIMUM_CACHED_SUBTREES;
-    this.implicitSubtreeCache = new RequestCache({ maxEntries: maximumCacheEntries });
+    this.implicitSubtreeCache = new import_loader_utils6.RequestCache({ maxEntries: maximumCacheEntries });
   }
   /**
    * Releases URL and parsed-subtree caches and blocks late subtree installation.
@@ -6946,7 +5470,6 @@ var Tiles3DSource = class {
    * Fetches and validates top-level metadata, then normalizes common fields used by {@link Tileset3D}.
    */
   async initialize() {
-    var _a;
     if (!this.rootTileset) {
       const loaderOptions = this.loadOptions[this.loader.id] || {};
       this.rootTileset = await this.loadRootData(this.url, {
@@ -6986,7 +5509,7 @@ 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: this.rootTileset.root?.refine,
       spatialReference: get3DTilesSpatialReference(this.rootTileset)
     };
   }
@@ -7022,7 +5545,6 @@ var Tiles3DSource = class {
    * Builds explicit runtime headers while leaving implicit subtree references lazy.
    */
   initializeTileHeaders(tileset, tilesetJson, parentTile) {
-    var _a;
     const rootHeader = parentTile ? tilesetJson.root : this.preparedRootHeader || tilesetJson.root;
     const rootTile = new Tile3D(tileset, rootHeader, parentTile || void 0);
     if (parentTile) {
@@ -7036,7 +5558,7 @@ var Tiles3DSource = class {
       const children = tile.header.children || [];
       for (const childHeader of children) {
         const childTile = new Tile3D(tileset, childHeader, tile);
-        if ((_a = childTile.contentUrl) == null ? void 0 : _a.includes("?session=")) {
+        if (childTile.contentUrl?.includes("?session=")) {
           const url = new URL(childTile.contentUrl);
           const session = url.searchParams.get("session");
           if (session) {
@@ -7060,10 +5582,9 @@ var Tiles3DSource = class {
    * Loads binary content or nested tileset JSON for a runtime tile.
    */
   async loadTileContent(tile) {
-    var _a, _b, _c, _d, _e, _f;
     const contentUrls = (tile.contentUrls || [tile.contentUrl]).filter(Boolean);
     const cachedContentHeaders = this.tileContentHeaders.get(tile);
-    const contentHeaders = cachedContentHeaders || (Array.isArray((_a = tile.header) == null ? void 0 : _a.content) ? tile.header.content : ((_b = tile.header) == null ? void 0 : _b.content) ? [tile.header.content] : []);
+    const contentHeaders = cachedContentHeaders || (Array.isArray(tile.header?.content) ? tile.header.content : tile.header?.content ? [tile.header.content] : []);
     if (!cachedContentHeaders) {
       this.tileContentHeaders.set(tile, contentHeaders);
     }
@@ -7077,17 +5598,16 @@ var Tiles3DSource = class {
         isTileset: "auto",
         assetGltfUpAxis: this.asset && this.asset.gltfUpAxis || "Y",
         _tilesetOptions: {
-          spatialReference: ((_c = tile.header) == null ? void 0 : _c._spatialReference) || ((_d = tile.tileset) == null ? void 0 : _d.spatialReference),
-          spatialOptions: (_e = tile.tileset) == null ? void 0 : _e.options.spatial,
-          spatialTransform: (_f = tile.header) == null ? void 0 : _f._spatialTransform
+          spatialReference: tile.header?._spatialReference || tile.tileset?.spatialReference,
+          spatialOptions: tile.tileset?.options.spatial,
+          spatialTransform: tile.header?._spatialTransform
         }
       }
     };
     const contents = await Promise.all(contentUrls.map((contentUrl, contentIndex) => {
-      var _a2;
       const contentHeader = contentHeaders[contentIndex] || {};
-      const vectorExtension = (_a2 = contentHeader.extensions) == null ? void 0 : _a2["3DTILES_content_gltf_vector"];
-      const vectorContent = contentHeader._vectorContent || ((vectorExtension == null ? void 0 : vectorExtension.vector) === true ? { clip: vectorExtension.clip === true } : void 0);
+      const vectorExtension = contentHeader.extensions?.["3DTILES_content_gltf_vector"];
+      const vectorContent = contentHeader._vectorContent || (vectorExtension?.vector === true ? { clip: vectorExtension.clip === true } : void 0);
       const contentOptions = vectorContent ? {
         ...options,
         [this.loader.id]: {
@@ -7099,7 +5619,7 @@ var Tiles3DSource = class {
     }));
     tile.contents = contents;
     tile.content = contents[0] || null;
-    const nestedTilesets = contents.filter((content) => (content == null ? void 0 : content.shape) === "tileset3d");
+    const nestedTilesets = contents.filter((content) => content?.shape === "tileset3d");
     return {
       loaded: true,
       contents,
@@ -7260,9 +5780,9 @@ var Tiles3DSource = class {
     let cartographicCenter;
     if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) {
       cartographicCenter = new import_core12.Vector3();
-      import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(center, cartographicCenter);
+      import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(center, cartographicCenter);
     } else {
-      cartographicCenter = new import_core12.Vector3(0, 0, -import_geospatial10.Ellipsoid.WGS84.radii[0]);
+      cartographicCenter = new import_core12.Vector3(0, 0, -import_geospatial9.Ellipsoid.WGS84.radii[0]);
     }
     return {
       asset: this.asset,
@@ -7288,10 +5808,7 @@ var Tiles3DSource = class {
    */
   onTileLoaded(tileset, tile, loadResult) {
     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) || [];
-    });
+    const extensionsRemoved = contents.flatMap((content) => content?.gltf?.extensionsRemoved || []);
     if (extensionsRemoved.includes("KHR_draco_mesh_compression")) {
       this.contentFormats.draco = true;
     }
@@ -7328,7 +5845,7 @@ var Tiles3DSource = class {
   prepareNestedTileset(tileset, nestedTileset) {
     const nestedSpatialReference = nestedTileset.spatialMetadata;
     const parentSpatialReference = tileset.spatialReference;
-    if ((nestedSpatialReference == null ? void 0 : nestedSpatialReference.status) === "unresolved" || (nestedSpatialReference == null ? void 0 : nestedSpatialReference.crs.state) === "unknown") {
+    if (nestedSpatialReference?.status === "unresolved" || nestedSpatialReference?.crs.state === "unknown") {
       throw new Error(nestedSpatialReference.warnings[0] || "Nested 3D Tiles CRS is explicitly unresolved and cannot be placed in the parent frame");
     }
     if (!nestedSpatialReference || !nestedSpatialReference.sourceCrs) {
@@ -7453,7 +5970,7 @@ var Tiles3DSource = class {
   /** Resolves a retained package-file byte range without eagerly copying other package files. */
   async getPackageFileData(file) {
     if (file.data) {
-      return sliceArrayBuffer(file.data, file.byteOffset, file.byteLength);
+      return (0, import_loader_utils6.sliceArrayBuffer)(file.data, file.byteOffset, file.byteLength);
     }
     if (file.bufferUri && this.coreApi) {
       const response = await this.coreApi.fetchFile(this.getTileUrl(file.bufferUri));
@@ -7461,7 +5978,7 @@ var Tiles3DSource = class {
         throw new Error(`Failed to fetch 3D Tiles package buffer: HTTP ${response.status}`);
       }
       const buffer = await response.arrayBuffer();
-      return sliceArrayBuffer(buffer, file.byteOffset, file.byteLength);
+      return (0, import_loader_utils6.sliceArrayBuffer)(buffer, file.byteOffset, file.byteLength);
     }
     throw new Error("3D Tiles package file has no available byte source");
   }
@@ -7501,7 +6018,6 @@ var Tiles3DSource = class {
    * @returns Number of newly allocated runtime tile nodes.
    */
   initializeMaterializedChildren(tileset, parentTile, childHeaders) {
-    var _a;
     let materializedTileCount = 0;
     const stack = [
       { parentTile, childHeaders }
@@ -7514,7 +6030,7 @@ var Tiles3DSource = class {
         childTile.depth = entry.parentTile.depth + 1;
         tileset.stats.get("Tiles In Tileset(s)").incrementCount();
         materializedTileCount++;
-        if ((_a = childHeader.children) == null ? void 0 : _a.length) {
+        if (childHeader.children?.length) {
           stack.push({ parentTile: childTile, childHeaders: childHeader.children });
         }
       }
@@ -7523,7 +6039,7 @@ var Tiles3DSource = class {
   }
 };
 function throwIfTraversalAborted(signal) {
-  if (signal == null ? void 0 : signal.aborted) {
+  if (signal?.aborted) {
     throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
   }
 }
@@ -7534,13 +6050,13 @@ function normalizeTiles3DRequest(input) {
   if (isTilesetRequest(input)) {
     return {
       ...input,
-      basePath: input.basePath || path_exports.dirname(input.url)
+      basePath: input.basePath || import_loader_utils6.path.dirname(input.url)
     };
   }
   return {
     url: input.url,
     loader: input.loader,
-    basePath: input.basePath || path_exports.dirname(input.url),
+    basePath: input.basePath || import_loader_utils6.path.dirname(input.url),
     resolver: input.resolver,
     coreApi: input.coreApi
   };
@@ -7559,7 +6075,8 @@ function addNestedSpatialReference(nestedTileset, spatialReference) {
 }
 
 // dist/tileset-3d/format-i3s/i3s-source.js
-var import_geospatial12 = require("@math.gl/geospatial");
+var import_loader_utils7 = require("@loaders.gl/loader-utils");
+var import_geospatial11 = require("@math.gl/geospatial");
 var import_core14 = require("@math.gl/core");
 
 // dist/tileset-3d/format-i3s/i3s-pending-tiles-register.js
@@ -7596,8 +6113,7 @@ var I3SPendingTilesRegister = class {
    * @returns
    */
   isZero(viewportId, frameNumber) {
-    var _a;
-    const count = ((_a = this.frameNumberMap.get(viewportId)) == null ? void 0 : _a.get(frameNumber)) || 0;
+    const count = this.frameNumberMap.get(viewportId)?.get(frameNumber) || 0;
     return count === 0;
   }
 };
@@ -7696,10 +6212,7 @@ var I3STilesetTraverser = class extends TilesetTraverser {
     const childTiles = tile.children;
     for (const child of children) {
       const extendedId = `${child.id}-${frameState.viewport.id}`;
-      const childTile = childTiles && childTiles.find((t) => {
-        var _a;
-        return t.id === extendedId || ((_a = t.header) == null ? void 0 : _a.id) === child.id;
-      });
+      const childTile = childTiles && childTiles.find((t) => t.id === extendedId || t.header?.id === child.id);
       if (!childTile) {
         const request = () => this._loadTile(tile, child.id, frameState);
         const cachedRequest = this._tileManager.find(extendedId);
@@ -7745,7 +6258,7 @@ var I3STilesetTraverser = class extends TilesetTraverser {
 
 // dist/spatial/i3s-spatial-transformer.js
 var import_core13 = require("@math.gl/core");
-var import_geospatial11 = require("@math.gl/geospatial");
+var import_geospatial10 = require("@math.gl/geospatial");
 var I3SSpatialTransformer = class {
   /** Descriptor attached to output after all adapter-owned spatial values have been transformed. */
   spatialReference;
@@ -7778,7 +6291,6 @@ var I3SSpatialTransformer = class {
    * @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");
     }
@@ -7795,7 +6307,7 @@ var I3SSpatialTransformer = class {
     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");
+    const providerUnitScale = getI3SLinearUnitScale(this.elevationProvider?.unit || "meter");
     if (this.elevationProvider && providerUnitScale === void 0) {
       throw new Error(`Unsupported elevation-provider unit ${this.elevationProvider.unit}`);
     }
@@ -7924,6 +6436,32 @@ var I3SSpatialTransformer = class {
     const placedPositions = await this.placeSourcePositions(combinedPositions);
     return this.transformPlacedPositions(placedPositions.subarray(0, sourcePositions.length), placedPositions.subarray(sourcePositions.length));
   }
+  /**
+   * Transforms conversion geometry without passing through renderer float32 offsets.
+   * Positions and normals share one batch of elevation samples. Source arrays remain unchanged.
+   * @param sourcePositions - Packed absolute xyz positions in source units.
+   * @param normals - Optional packed normals paired with the positions.
+   * @param normalReferenceFrame - I3S earth-centered or vertex-reference-frame declaration.
+   * @returns Absolute target positions and optional transformed normals.
+   */
+  async transformGeometryAsync(sourcePositions, normals, normalReferenceFrame = "earth-centered") {
+    if (sourcePositions.length % 3 || normals && normals.length !== sourcePositions.length) {
+      throw new Error("Conversion positions and normals must contain matching finite xyz triples");
+    }
+    for (let index = 0; index < sourcePositions.length; index++) {
+      if (!Number.isFinite(sourcePositions[index]) || normals && !Number.isFinite(normals[index])) {
+        throw new Error("Conversion positions and normals must contain matching finite xyz triples");
+      }
+    }
+    if (!["earth-centered", "vertex-reference-frame"].includes(normalReferenceFrame)) {
+      throw new Error("Unsupported I3S normal reference frame");
+    }
+    const placedPositions = await this.placeSourcePositions(sourcePositions);
+    return {
+      positions: this.positionTransformer.transformPositions(placedPositions),
+      normals: normals ? this.transformNormals(normals, placedPositions, normalReferenceFrame) : void 0
+    };
+  }
   /** Transform already placed positions into renderer-relative target coordinates. */
   transformPlacedPositions(sourcePositions, sourceOrigin) {
     const origin = this.transformPlacedPosition(sourceOrigin);
@@ -7961,7 +6499,19 @@ var I3SSpatialTransformer = class {
    * @param normalReferenceFrame - I3S normal frame declaration.
    */
   transformNormals(normals, sourcePositions, normalReferenceFrame = "earth-centered") {
+    if (normals.length !== sourcePositions.length || normals.length % 3) {
+      throw new Error("I3S normals and positions must have matching xyz component counts");
+    }
     const transformedNormals = new Float32Array(normals.length);
+    if (normalReferenceFrame === "earth-centered" && (this.spatialReference.targetCrs || this.spatialReference.sourceCrs) === "EPSG:4978") {
+      for (let index = 0; index < normals.length; index += 3) {
+        const length = Math.hypot(normals[index], normals[index + 1], normals[index + 2]);
+        for (let axis = 0; axis < 3; axis++) {
+          transformedNormals[index + axis] = length ? normals[index + axis] / length : normals[index + axis];
+        }
+      }
+      return transformedNormals;
+    }
     for (let index = 0; index < normals.length; index += 3) {
       const geographic = this.sourceToGeographicTransformer.transformPosition([
         sourcePositions[index],
@@ -8006,24 +6556,23 @@ var I3SSpatialTransformer = class {
   }
   /** Rebuild an I3S bound as a WGS84 ECEF box for generic `Tileset3D` traversal. */
   transformBoundingVolumeToGeocentric(bounds) {
-    const cartesianSamples = this.getGeographicBoundSamples(bounds).map((position) => Array.from(import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
+    const cartesianSamples = this.getGeographicBoundSamples(bounds).map((position) => Array.from(import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
     return { box: getAxisAlignedBox(cartesianSamples) };
   }
   /** Rebuild an I3S bound as WGS84 ECEF after asynchronous elevation placement. */
   async transformBoundingVolumeToGeocentricAsync(bounds) {
-    const cartesianSamples = (await this.getGeographicBoundSamplesAsync(bounds)).map((position) => Array.from(import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
+    const cartesianSamples = (await this.getGeographicBoundSamplesAsync(bounds)).map((position) => Array.from(import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
     return { box: getAxisAlignedBox(cartesianSamples) };
   }
   /** Return a WGS84 geographic MBS used by the I3S screen-threshold calculation. */
   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;
+    const sourceCenter = bounds.mbs?.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));
+    const radius = bounds.mbs?.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. */
@@ -8038,7 +6587,7 @@ var I3SSpatialTransformer = class {
    */
   async transformBoundsAsync(bounds) {
     const geographicSamples = await this.getGeographicBoundSamplesAsync(bounds);
-    const cartesianSamples = geographicSamples.map((position) => Array.from(import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
+    const cartesianSamples = geographicSamples.map((position) => Array.from(import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position))));
     const targetSamples = geographicSamples.map((position) => this.geographicToTargetTransformer.transformPosition(position));
     return {
       boundingVolume: { box: getAxisAlignedBox(cartesianSamples) },
@@ -8161,11 +6710,11 @@ var I3SSpatialTransformer = class {
     if (this.targetCoordinateFrame === "geographic") {
       return ecefVectorToLocalEnu(ecefNormal, geographic).normalize();
     }
-    const cartesian = import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(geographic));
+    const cartesian = import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(geographic));
     const jacobianColumns = [];
     for (const direction of getPositiveAxisDirections()) {
-      const positiveGeographic = import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(new import_core13.Vector3(cartesian).add(direction));
-      const negativeGeographic = import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(new import_core13.Vector3(cartesian).subtract(direction));
+      const positiveGeographic = import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(new import_core13.Vector3(cartesian).add(direction));
+      const negativeGeographic = import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(new import_core13.Vector3(cartesian).subtract(direction));
       const positiveTarget = this.geographicToTargetTransformer.transformPosition(positiveGeographic);
       const negativeTarget = this.geographicToTargetTransformer.transformPosition(negativeGeographic);
       jacobianColumns.push((positiveTarget[0] - negativeTarget[0]) / 2, (positiveTarget[1] - negativeTarget[1]) / 2, (positiveTarget[2] - negativeTarget[2]) / 2);
@@ -8207,7 +6756,7 @@ function getGeographicBoundingSphere(geographicSamples) {
   if (!geographicSamples.length) {
     throw new Error("I3S spatial transformation requires at least one bound sample");
   }
-  const cartesianSamples = geographicSamples.map((position) => import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position)));
+  const cartesianSamples = geographicSamples.map((position) => import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(position)));
   const cartesianCenter = new import_core13.Vector3();
   for (const sample of cartesianSamples) {
     cartesianCenter.add(sample);
@@ -8217,7 +6766,7 @@ function getGeographicBoundingSphere(geographicSamples) {
   for (const sample of cartesianSamples) {
     radius = Math.max(radius, new import_core13.Vector3(sample).subtract(cartesianCenter).magnitude());
   }
-  const geographicCenter = import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(cartesianCenter);
+  const geographicCenter = import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(cartesianCenter);
   return [geographicCenter[0], geographicCenter[1], geographicCenter[2], radius];
 }
 function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransformer, sourceVerticalUnitScale) {
@@ -8234,14 +6783,14 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
     ];
     if (sourceFrame === "geographic") {
       const geographicCenter = sourceToGeographicTransformer.transformPosition(center2);
-      const cartesianCenter = import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(geographicCenter));
+      const cartesianCenter = import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(geographicCenter));
       const cartesianAxes = bounds.normalReferenceFrame === "vertex-reference-frame" ? axes.map((axis) => localEnuVectorToEcef(axis, geographicCenter)) : axes;
       return getBoxSigns().map((signs) => {
         const corner = new import_core13.Vector3(cartesianCenter);
         for (let axisIndex = 0; axisIndex < 3; axisIndex++) {
           corner.add(new import_core13.Vector3(cartesianAxes[axisIndex]).scale(signs[axisIndex]));
         }
-        return Array.from(import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(corner));
+        return Array.from(import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(corner));
       });
     }
     return getBoxSigns().map((signs) => {
@@ -8261,8 +6810,8 @@ function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransforme
   const radius = mbs[3];
   if (sourceFrame === "geographic") {
     const geographicCenter = sourceToGeographicTransformer.transformPosition(center);
-    const cartesianCenter = import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(geographicCenter));
-    return getAxisDirections().map((direction) => Array.from(import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(new import_core13.Vector3(cartesianCenter).add(new import_core13.Vector3(direction).scale(radius)))));
+    const cartesianCenter = import_geospatial10.Ellipsoid.WGS84.cartographicToCartesian(new import_core13.Vector3(geographicCenter));
+    return getAxisDirections().map((direction) => Array.from(import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(new import_core13.Vector3(cartesianCenter).add(new import_core13.Vector3(direction).scale(radius)))));
   }
   return getAxisDirections().map((direction) => Array.from(new import_core13.Vector3(center).add(new import_core13.Vector3(direction).scale(radius))));
 }
@@ -8407,7 +6956,7 @@ var I3SSource = class {
     this.loader = request.loader;
     this.contentLoader = getI3SContentLoader(request.loader);
     this.url = request.url;
-    this.basePath = request.basePath || path_exports.dirname(request.url);
+    this.basePath = request.basePath || import_loader_utils7.path.dirname(request.url);
     this.resolver = request.resolver;
     this.coreApi = request.coreApi;
     this.loadOptions = loadOptions;
@@ -8417,7 +6966,6 @@ var I3SSource = class {
    * Fetches and normalizes root I3S metadata for runtime consumption.
    */
   async initialize() {
-    var _a;
     if (!this.rootTileset) {
       this.rootTileset = await this.loadRootData(this.getTileUrl(this.url), {
         ...this.loadOptions,
@@ -8436,7 +6984,7 @@ 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: this.rootTileset.root?.refine,
       spatialReference: getI3SSpatialReference(this.rootTileset)
     };
   }
@@ -8570,10 +7118,7 @@ var I3SSource = class {
       if (typeof childId !== "string" && typeof childId !== "number") {
         throw new Error("I3S child header is missing its node ID");
       }
-      const existingChild = parentTile.children.find((tile) => {
-        var _a;
-        return tile.id === String(childId) || ((_a = tile.header) == null ? void 0 : _a.id) === childId;
-      });
+      const existingChild = parentTile.children.find((tile) => tile.id === String(childId) || tile.header?.id === childId);
       if (existingChild) {
         orderedChildren.push(existingChild);
         continue;
@@ -8605,7 +7150,7 @@ var I3SSource = class {
     const hash = hashIndex >= 0 ? tilePath.slice(hashIndex) : "";
     const tilePathWithoutHash = hashIndex >= 0 ? tilePath.slice(0, hashIndex) : tilePath;
     const queryDelimiterIndex = tilePathWithoutHash.indexOf("?");
-    const path = queryDelimiterIndex === -1 ? tilePathWithoutHash : tilePathWithoutHash.slice(0, queryDelimiterIndex);
+    const path4 = queryDelimiterIndex === -1 ? tilePathWithoutHash : tilePathWithoutHash.slice(0, queryDelimiterIndex);
     const existingQuery = queryDelimiterIndex === -1 ? "" : tilePathWithoutHash.slice(queryDelimiterIndex + 1);
     const existingQueryParams = new URLSearchParams(existingQuery);
     const queryParams = new URLSearchParams();
@@ -8615,13 +7160,12 @@ var I3SSource = class {
       }
     }
     const queryString = queryParams.toString();
-    return `${path}${existingQuery ? `?${existingQuery}` : ""}${queryString ? `${existingQuery ? "&" : "?"}${queryString}` : ""}${hash}`;
+    return `${path4}${existingQuery ? `?${existingQuery}` : ""}${queryString ? `${existingQuery ? "&" : "?"}${queryString}` : ""}${hash}`;
   }
   /**
    * Derives the default view state from full extent or store extent metadata.
    */
   getViewState(rootTile) {
-    var _a;
     if (this.spatialTransformer && rootTile) {
       const center = new import_core14.Vector3(rootTile.boundingVolume.center);
       const cartographicCenter = new import_core14.Vector3(rootTile.header.i3sLodMbs.slice(0, 3));
@@ -8646,19 +7190,19 @@ var I3SSource = class {
       const { xmin, xmax, ymin, ymax, zmin, zmax } = fullExtent;
       const cartographicCenter = new import_core14.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, zmin + (zmax - zmin) / 2);
       const cartesianCenter = new import_core14.Vector3();
-      import_geospatial12.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
+      import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
       return {
         cartographicCenter,
         cartesianCenter,
         zoom: getZoomFromFullExtent(fullExtent, cartographicCenter, cartesianCenter)
       };
     }
-    const extent = (_a = metadata.tileset.store) == null ? void 0 : _a.extent;
+    const extent = metadata.tileset.store?.extent;
     if (extent) {
       const [xmin, ymin, xmax, ymax] = extent;
       const cartographicCenter = new import_core14.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, 0);
       const cartesianCenter = new import_core14.Vector3();
-      import_geospatial12.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
+      import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
       return {
         cartographicCenter,
         cartesianCenter,
@@ -8692,9 +7236,8 @@ var I3SSource = class {
    * Returns the total number of known tiles when node pages metadata is available.
    */
   getTilesTotalCount() {
-    var _a, _b;
     const metadata = this.getMetadata();
-    return ((_b = (_a = metadata.tileset) == null ? void 0 : _a.nodePagesTile) == null ? void 0 : _b.nodesInNodePages) || null;
+    return metadata.tileset?.nodePagesTile?.nodesInNodePages || null;
   }
   /**
    * Loads data through injected core APIs so this module stays independent from `@loaders.gl/core`.
@@ -8741,14 +7284,13 @@ var I3SSource = class {
   }
   /** 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
+      normalReferenceFrame: this.getMetadata().tileset.store?.normalReferenceFrame
     };
     const transformedBounds = await this.spatialTransformer.transformBoundsAsync(sourceBounds);
     return {
@@ -8762,7 +7304,7 @@ var I3SSource = class {
   }
 };
 function throwIfTraversalAborted2(signal) {
-  if (signal == null ? void 0 : signal.aborted) {
+  if (signal?.aborted) {
     throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
   }
 }
@@ -8776,13 +7318,13 @@ function normalizeI3SRequest(input) {
   if (isTilesetRequest2(input)) {
     return {
       ...input,
-      basePath: input.basePath || path_exports.dirname(input.url)
+      basePath: input.basePath || import_loader_utils7.path.dirname(input.url)
     };
   }
   return {
     url: input.url,
     loader: input.loader,
-    basePath: input.basePath || path_exports.dirname(input.url),
+    basePath: input.basePath || import_loader_utils7.path.dirname(input.url),
     resolver: input.resolver,
     coreApi: input.coreApi
   };
@@ -8945,12 +7487,11 @@ var SharedTile2DHeader = class {
   }
   /** Cancels an in-flight tile request. */
   abort() {
-    var _a;
     if (this.isLoaded) {
       return;
     }
     this._isCancelled = true;
-    (_a = this._abortController) == null ? void 0 : _a.abort();
+    this._abortController?.abort();
   }
 };
 function normalizeTileError(error) {
@@ -8964,7 +7505,7 @@ function normalizeTileError(error) {
 }
 
 // dist/tileset-2d/tileset-2d.js
-var import_stats4 = require("@probe.gl/stats");
+var import_loader_utils8 = require("@loaders.gl/loader-utils");
 var STRATEGY_NEVER = "never";
 var STRATEGY_REPLACE = "no-overlap";
 var STRATEGY_DEFAULT = "best-available";
@@ -9011,7 +7552,7 @@ var Tileset2D = class _Tileset2D {
   _lastTileContext = null;
   /** Creates a tileset from either `getTileData` or a loaders.gl `TileSource`. */
   constructor(opts) {
-    this.stats = new import_stats4.Stats({
+    this.stats = new Stats({
       id: "Tileset2D",
       stats: [
         { name: "Tiles In Cache" },
@@ -9029,7 +7570,7 @@ var Tileset2D = class _Tileset2D {
       getTileData: opts.getTileData || (() => null),
       tileSource: opts.tileSource
     };
-    this._requestScheduler = new RequestScheduler({
+    this._requestScheduler = new import_loader_utils8.RequestScheduler({
       throttleRequests: this.opts.maxRequests > 0 || this.opts.debounceTime > 0,
       maxRequests: this.opts.maxRequests,
       debounceTime: this.opts.debounceTime
@@ -9122,7 +7663,7 @@ var Tileset2D = class _Tileset2D {
     const previousDebounceTime = this.opts.debounceTime;
     this._applyResolvedOptions();
     if (previousMaxRequests !== this.opts.maxRequests || previousDebounceTime !== this.opts.debounceTime) {
-      this._requestScheduler = new RequestScheduler({
+      this._requestScheduler = new import_loader_utils8.RequestScheduler({
         throttleRequests: this.opts.maxRequests > 0 || this.opts.debounceTime > 0,
         maxRequests: this.opts.maxRequests,
         debounceTime: this.opts.debounceTime
@@ -9306,51 +7847,45 @@ var Tileset2D = class _Tileset2D {
   }
   /** Handles successful tile loads. */
   _handleTileLoad(tile) {
-    var _a, _b, _c;
-    (_b = (_a = this.opts).onTileLoad) == null ? void 0 : _b.call(_a, tile);
+    this.opts.onTileLoad?.(tile);
     this._cacheByteSize = this._getCacheByteSize();
     this._resizeCache();
     for (const listener of this._listeners) {
-      (_c = listener.onTileLoad) == null ? void 0 : _c.call(listener, tile);
+      listener.onTileLoad?.(tile);
     }
     this._updateStats();
   }
   /** Handles tile load failures. */
   _handleTileError(error, tile) {
-    var _a, _b, _c;
-    (_b = (_a = this.opts).onTileError) == null ? void 0 : _b.call(_a, error, tile);
+    this.opts.onTileError?.(error, tile);
     for (const listener of this._listeners) {
-      (_c = listener.onTileError) == null ? void 0 : _c.call(listener, error, tile);
+      listener.onTileError?.(error, tile);
     }
     this._updateStats();
   }
   /** Handles tile eviction from cache. */
   _handleTileUnload(tile) {
-    var _a, _b, _c;
     this._unloadedTileCount++;
-    (_b = (_a = this.opts).onTileUnload) == null ? void 0 : _b.call(_a, tile);
+    this.opts.onTileUnload?.(tile);
     for (const listener of this._listeners) {
-      (_c = listener.onTileUnload) == null ? void 0 : _c.call(listener, tile);
+      listener.onTileUnload?.(tile);
     }
     this._updateStats();
   }
   /** Notifies listeners that metadata or effective options changed. */
   _notifyUpdate() {
-    var _a;
     for (const listener of this._listeners) {
-      (_a = listener.onUpdate) == null ? void 0 : _a.call(listener);
+      listener.onUpdate?.();
     }
   }
   /** Notifies listeners about asynchronous metadata errors. */
   _notifyError(error) {
-    var _a;
     for (const listener of this._listeners) {
-      (_a = listener.onError) == null ? void 0 : _a.call(listener, error);
+      listener.onError?.(error);
     }
   }
   /** Recomputes absolute counter stats and notifies listeners. */
   _updateStats() {
-    var _a;
     this._setStatCount("Tiles In Cache", this._cache.size);
     this._setStatCount("Cache Size", this.cacheByteSize);
     this._setStatCount("Visible Tiles", this.visibleTiles.length);
@@ -9359,7 +7894,7 @@ var Tileset2D = class _Tileset2D {
     this._setStatCount("Unloaded Tiles", this._unloadedTileCount);
     this._setStatCount("Consumers", this._consumers.size);
     for (const listener of this._listeners) {
-      (_a = listener.onStatsChange) == null ? void 0 : _a.call(listener, this.stats);
+      listener.onStatsChange?.(this.stats);
     }
   }
   /** Writes an absolute count into a probe.gl stat. */
@@ -9433,7 +7968,7 @@ var Tileset2D = class _Tileset2D {
     for (const tile of this._cache.values()) {
       const parent = this._getNearestAncestor(tile);
       tile.parent = parent;
-      if (parent == null ? void 0 : parent.children) {
+      if (parent?.children) {
         parent.children.push(tile);
       }
     }
@@ -9521,8 +8056,7 @@ var ImageSet = class _ImageSet {
   }
   /** Current accepted image, if any. */
   get image() {
-    var _a;
-    return ((_a = this._currentRequest) == null ? void 0 : _a.image) || null;
+    return this._currentRequest?.image || null;
   }
   /** Current accepted request and image payload, if any. */
   get currentRequest() {
@@ -9554,7 +8088,6 @@ var ImageSet = class _ImageSet {
   }
   /** Loads metadata from the current image source or callbacks. */
   async loadMetadata() {
-    var _a, _b;
     this._startLoading();
     try {
       const metadata = await this._opts.getMetadata();
@@ -9563,7 +8096,7 @@ var ImageSet = class _ImageSet {
       }
       this.metadata = metadata;
       for (const listener of this._listeners) {
-        (_a = listener.onMetadataLoad) == null ? void 0 : _a.call(listener, metadata);
+        listener.onMetadataLoad?.(metadata);
       }
       this._emitUpdate();
       return metadata;
@@ -9571,7 +8104,7 @@ var ImageSet = class _ImageSet {
       const normalizedError = normalizeImageSetError(error, "Image metadata request failed");
       if (!this._finalized) {
         for (const listener of this._listeners) {
-          (_b = listener.onMetadataLoadError) == null ? void 0 : _b.call(listener, normalizedError);
+          listener.onMetadataLoadError?.(normalizedError);
         }
       }
       throw normalizedError;
@@ -9603,13 +8136,12 @@ var ImageSet = class _ImageSet {
   }
   /** Loads an image immediately and accepts it only if it is the newest completed request. */
   async _loadImage(requestId, parameters) {
-    var _a, _b, _c, _d;
     if (this._finalized) {
       return;
     }
     this._startLoading();
     for (const listener of this._listeners) {
-      (_a = listener.onImageLoadStart) == null ? void 0 : _a.call(listener, requestId, parameters);
+      listener.onImageLoadStart?.(requestId, parameters);
     }
     try {
       const abortController = new AbortController();
@@ -9621,21 +8153,21 @@ var ImageSet = class _ImageSet {
       this._lastAcceptedRequestId = requestId;
       this._currentRequest = { requestId, parameters, image };
       for (const listener of this._listeners) {
-        (_b = listener.onImageLoad) == null ? void 0 : _b.call(listener, this._currentRequest);
+        listener.onImageLoad?.(this._currentRequest);
       }
       this._emitUpdate();
     } catch (error) {
-      if (isAbortError2(error)) {
+      if (isAbortError(error)) {
         return;
       }
       const normalizedError = normalizeImageSetError(error, "Image request failed");
       if (!this._finalized) {
         for (const listener of this._listeners) {
-          (_c = listener.onImageLoadError) == null ? void 0 : _c.call(listener, requestId, normalizedError, parameters);
+          listener.onImageLoadError?.(requestId, normalizedError, parameters);
         }
       }
     } finally {
-      if (((_d = this._abortController) == null ? void 0 : _d.signal) === parameters.signal) {
+      if (this._abortController?.signal === parameters.signal) {
         this._abortController = null;
       }
       this._finishLoading();
@@ -9665,9 +8197,8 @@ var ImageSet = class _ImageSet {
   }
   /** Notifies listeners that current metadata or image output changed. */
   _emitUpdate() {
-    var _a;
     for (const listener of this._listeners) {
-      (_a = listener.onUpdate) == null ? void 0 : _a.call(listener);
+      listener.onUpdate?.();
     }
   }
   /** Increments the active load count and emits loading changes. */
@@ -9690,9 +8221,8 @@ var ImageSet = class _ImageSet {
   }
   /** Notifies listeners when the overall loading state changes. */
   _emitLoadingStateChange(isLoading) {
-    var _a;
     for (const listener of this._listeners) {
-      (_a = listener.onLoadingStateChange) == null ? void 0 : _a.call(listener, isLoading);
+      listener.onLoadingStateChange?.(isLoading);
     }
   }
   /** Clears any pending debounced image request. */
@@ -9704,12 +8234,11 @@ var ImageSet = class _ImageSet {
   }
   /** Aborts the current in-flight image request, if any. */
   _abortActiveRequest() {
-    var _a;
-    (_a = this._abortController) == null ? void 0 : _a.abort();
+    this._abortController?.abort();
     this._abortController = null;
   }
 };
-function isAbortError2(error) {
+function isAbortError(error) {
   return error instanceof Error && error.name === "AbortError";
 }
 function normalizeImageSetError(error, message) {
@@ -9723,6 +8252,7 @@ function normalizeImageSetError(error, message) {
 }
 
 // dist/raster-set.js
+var import_loader_utils9 = require("@loaders.gl/loader-utils");
 var DEFAULT_RASTERSET_PROPS = {
   getMetadata: async () => ({
     width: 0,
@@ -9778,8 +8308,7 @@ var RasterSet = class _RasterSet {
   }
   /** Current accepted raster, if any. */
   get raster() {
-    var _a;
-    return ((_a = this._currentRequest) == null ? void 0 : _a.raster) || null;
+    return this._currentRequest?.raster || null;
   }
   /** Current accepted request and raster payload, if any. */
   get currentRequest() {
@@ -9796,7 +8325,6 @@ var RasterSet = class _RasterSet {
   }
   /** Updates source callbacks or debounce settings, resetting state when the source changes. */
   setOptions(opts) {
-    var _a;
     const previousRasterSource = this._opts.rasterSource;
     const mergedOptions = { ...this._opts, ...opts };
     if (opts.rasterSource && opts.rasterSource !== previousRasterSource) {
@@ -9809,7 +8337,7 @@ var RasterSet = class _RasterSet {
     if (sourceChanged) {
       this._cancelScheduledRaster();
       this._abortActiveRequest();
-      (_a = this._metadataAbortController) == null ? void 0 : _a.abort();
+      this._metadataAbortController?.abort();
       this._sourceGeneration++;
       this.metadata = null;
       this._currentRequest = null;
@@ -9818,48 +8346,44 @@ var RasterSet = class _RasterSet {
   }
   /** Loads metadata from the current raster source or callbacks. */
   async loadMetadata(options = {}) {
-    var _a, _b, _c, _d, _e, _f;
     if (this._finalized)
       throw new Error("RasterSet is finalized");
-    (_a = options.signal) == null ? void 0 : _a.throwIfAborted();
-    (_b = this._metadataAbortController) == null ? void 0 : _b.abort();
+    options.signal?.throwIfAborted();
+    this._metadataAbortController?.abort();
     const abortController = new AbortController();
     this._metadataAbortController = abortController;
-    const abortFromCaller = () => {
-      var _a2;
-      return abortController.abort((_a2 = options.signal) == null ? void 0 : _a2.reason);
-    };
-    (_c = options.signal) == null ? void 0 : _c.addEventListener("abort", abortFromCaller, { once: true });
+    const abortFromCaller = () => abortController.abort(options.signal?.reason);
+    options.signal?.addEventListener("abort", abortFromCaller, { once: true });
     const metadataRequestId = ++this._metadataRequestId;
     const generation = this._sourceGeneration;
     try {
       this._startLoading();
       abortController.signal.throwIfAborted();
-      const metadata = await waitForPromiseWithSignals((signal) => this._opts.getMetadata({ signal }), [abortController.signal]);
+      const metadata = await (0, import_loader_utils9.waitForPromiseWithSignals)((signal) => this._opts.getMetadata({ signal }), [abortController.signal]);
       abortController.signal.throwIfAborted();
       if (this._finalized || generation !== this._sourceGeneration || metadataRequestId !== this._metadataRequestId) {
         return metadata;
       }
       this.metadata = metadata;
       for (const listener of this._listeners) {
-        (_d = listener.onMetadataLoad) == null ? void 0 : _d.call(listener, metadata);
+        listener.onMetadataLoad?.(metadata);
       }
       this._emitUpdate();
       return metadata;
     } catch (error) {
       if (abortController.signal.aborted)
         throw abortController.signal.reason;
-      if (isAbortError3(error))
+      if (isAbortError2(error))
         throw error;
       const normalizedError = normalizeRasterSetError(error, "Raster metadata request failed");
       if (!this._finalized && generation === this._sourceGeneration && metadataRequestId === this._metadataRequestId) {
         for (const listener of this._listeners) {
-          (_e = listener.onMetadataLoadError) == null ? void 0 : _e.call(listener, normalizedError);
+          listener.onMetadataLoadError?.(normalizedError);
         }
       }
       throw normalizedError;
     } finally {
-      (_f = options.signal) == null ? void 0 : _f.removeEventListener("abort", abortFromCaller);
+      options.signal?.removeEventListener("abort", abortFromCaller);
       if (this._metadataAbortController === abortController)
         this._metadataAbortController = null;
       this._finishLoading();
@@ -9867,14 +8391,13 @@ var RasterSet = class _RasterSet {
   }
   /** Debounces and issues a new raster request for the supplied parameters. */
   requestRaster(parameters, debounceTime = this._opts.debounceTime) {
-    var _a;
     if (this._finalized)
       return -1;
     if (!this.shouldRefetchRaster(parameters)) {
       this._cancelScheduledRaster();
       this._abortActiveRequest();
       this._nextRequestId++;
-      return ((_a = this._currentRequest) == null ? void 0 : _a.requestId) ?? -1;
+      return this._currentRequest?.requestId ?? -1;
     }
     const requestId = this._nextRequestId++;
     this._cancelScheduledRaster();
@@ -9899,55 +8422,53 @@ var RasterSet = class _RasterSet {
   }
   /** Clears timers and listeners held by the manager. */
   finalize() {
-    var _a;
     this._finalized = true;
     this._cancelScheduledRaster();
     this._abortActiveRequest();
-    (_a = this._metadataAbortController) == null ? void 0 : _a.abort();
+    this._metadataAbortController?.abort();
     this._metadataAbortController = null;
     this._loadCounter = 0;
     this._listeners.clear();
   }
   /** Loads a raster immediately and accepts it only if it is the newest completed request. */
   async _loadRaster(requestId, parameters) {
-    var _a, _b, _c;
     if (this._finalized) {
       return;
     }
     const callerSignal = parameters.signal;
-    if (callerSignal == null ? void 0 : callerSignal.aborted)
+    if (callerSignal?.aborted)
       return;
     const abortController = new AbortController();
     this._abortController = abortController;
-    const abortFromCaller = () => abortController.abort(callerSignal == null ? void 0 : callerSignal.reason);
-    callerSignal == null ? void 0 : callerSignal.addEventListener("abort", abortFromCaller, { once: true });
+    const abortFromCaller = () => abortController.abort(callerSignal?.reason);
+    callerSignal?.addEventListener("abort", abortFromCaller, { once: true });
     this._startLoading();
     try {
       abortController.signal.throwIfAborted();
       for (const listener of this._listeners)
-        (_a = listener.onRasterLoadStart) == null ? void 0 : _a.call(listener, requestId, parameters);
+        listener.onRasterLoadStart?.(requestId, parameters);
       abortController.signal.throwIfAborted();
-      const raster = await waitForPromiseWithSignals((signal) => this._opts.getRaster(withAbortSignal(parameters, signal)), [abortController.signal]);
+      const raster = await (0, import_loader_utils9.waitForPromiseWithSignals)((signal) => this._opts.getRaster(withAbortSignal(parameters, signal)), [abortController.signal]);
       if (this._finalized || abortController.signal.aborted || requestId !== this._nextRequestId - 1) {
         return;
       }
       this._currentRequest = { requestId, parameters, raster };
       for (const listener of this._listeners) {
-        (_b = listener.onRasterLoad) == null ? void 0 : _b.call(listener, this._currentRequest);
+        listener.onRasterLoad?.(this._currentRequest);
       }
       this._emitUpdate();
     } catch (error) {
-      if (abortController.signal.aborted || isAbortError3(error)) {
+      if (abortController.signal.aborted || isAbortError2(error)) {
         return;
       }
       const normalizedError = normalizeRasterSetError(error, "Raster request failed");
       if (!this._finalized && requestId === this._nextRequestId - 1) {
         for (const listener of this._listeners) {
-          (_c = listener.onRasterLoadError) == null ? void 0 : _c.call(listener, requestId, normalizedError, parameters);
+          listener.onRasterLoadError?.(requestId, normalizedError, parameters);
         }
       }
     } finally {
-      callerSignal == null ? void 0 : callerSignal.removeEventListener("abort", abortFromCaller);
+      callerSignal?.removeEventListener("abort", abortFromCaller);
       if (this._abortController === abortController)
         this._abortController = null;
       this._finishLoading();
@@ -9978,20 +8499,18 @@ var RasterSet = class _RasterSet {
   }
   /** Emits one generic update notification to all subscribers. */
   _emitUpdate() {
-    var _a;
     if (this._finalized)
       return;
     for (const listener of this._listeners) {
-      (_a = listener.onUpdate) == null ? void 0 : _a.call(listener);
+      listener.onUpdate?.();
     }
   }
   /** Emits one loading-state transition to all subscribers. */
   _emitLoadingStateChange(isLoading) {
-    var _a;
     if (this._finalized)
       return;
     for (const listener of this._listeners) {
-      (_a = listener.onLoadingStateChange) == null ? void 0 : _a.call(listener, isLoading);
+      listener.onLoadingStateChange?.(isLoading);
     }
   }
   /** Increments the active load count and emits loading-state transitions. */
@@ -10021,8 +8540,7 @@ var RasterSet = class _RasterSet {
   }
   /** Aborts the currently active raster request, if one exists. */
   _abortActiveRequest() {
-    var _a;
-    (_a = this._abortController) == null ? void 0 : _a.abort();
+    this._abortController?.abort();
     this._abortController = null;
   }
 };
@@ -10047,7 +8565,7 @@ function normalizeRasterSetError(error, message) {
   }
   return new Error(message);
 }
-function isAbortError3(error) {
+function isAbortError2(error) {
   return error instanceof Error && error.name === "AbortError";
 }
 
@@ -10121,7 +8639,7 @@ var PointCloudTile = class {
 };
 
 // dist/point-cloud/point-cloud-tileset.js
-var DEFAULT_PROPS5 = {
+var DEFAULT_PROPS3 = {
   debounceTime: 0,
   minimumNodePixelSize: 150,
   maximumScreenSpaceError: 1,
@@ -10153,7 +8671,7 @@ var PointCloudTileset = class {
   tilesMap = /* @__PURE__ */ new Map();
   constructor(dataSource, options = {}) {
     this.dataSource = dataSource;
-    this.options = { ...DEFAULT_PROPS5, ...options };
+    this.options = { ...DEFAULT_PROPS3, ...options };
     this.tilesetInitializationPromise = this.initialize();
   }
   tilesetInitializationPromise;
@@ -10209,15 +8727,14 @@ var PointCloudTileset = class {
    * Initialize the underlying source and the root tile.
    */
   async initialize() {
-    var _a, _b;
     await this.dataSource.initialize();
     const rootHeader = await this.dataSource.getRootTile();
     this.root = this.getOrCreateTile(rootHeader, null);
-    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;
+    const viewState = await this.dataSource.getViewState?.();
+    this.boundingVolume = viewState?.boundingVolume || this.root.boundingVolume;
+    const center = viewState?.cartographicCenter || this.root.boundingVolume.center;
     this.cartographicCenter = new import_core15.Vector3(center);
-    this.zoom = (viewState == null ? void 0 : viewState.zoom) || this.estimateZoom(this.boundingVolume);
+    this.zoom = viewState?.zoom || this.estimateZoom(this.boundingVolume);
   }
   /**
    * Debounced async tile selection.
@@ -10228,9 +8745,9 @@ var PointCloudTileset = class {
       this.lastUpdatedViewports = viewports;
     }
     if (!this.updatePromise) {
-      this.updatePromise = new Promise((resolve2, reject) => {
+      this.updatePromise = new Promise((resolve, reject) => {
         setTimeout(() => {
-          this.doSelectTiles().then(() => resolve2(this.frameNumberValue)).catch(reject).finally(() => {
+          this.doSelectTiles().then(() => resolve(this.frameNumberValue)).catch(reject).finally(() => {
             this.updatePromise = null;
           });
         }, this.options.debounceTime);
@@ -10568,8 +9085,7 @@ var PointCloudTileset = class {
    * Build a culling volume directly from the viewport frustum in common space.
    */
   getCullingVolume(viewport) {
-    var _a;
-    const getFrustumPlanes = (_a = viewport.getFrustumPlanes) == null ? void 0 : _a.bind(viewport);
+    const getFrustumPlanes = viewport.getFrustumPlanes?.bind(viewport);
     if (!getFrustumPlanes) {
       return null;
     }
@@ -10589,8 +9105,7 @@ var PointCloudTileset = class {
    * Approximate a tile AABB by a common-space bounding sphere for frustum culling.
    */
   getCommonSpaceBoundingSphere(boundingVolume, viewport) {
-    var _a;
-    const projectPosition = (_a = viewport.projectPosition) == null ? void 0 : _a.bind(viewport);
+    const projectPosition = viewport.projectPosition?.bind(viewport);
     if (!projectPosition) {
       return null;
     }
@@ -10623,4 +9138,82 @@ var PointCloudTileset = class {
     return new import_culling6.BoundingSphere().fromCornerPoints([minX, minY, minZ], [maxX, maxY, maxZ]);
   }
 };
+
+// dist/point-cloud-tile-source-loader-types.js
+var VERSION = true ? "5.0.0-alpha.12" : "latest";
+async function preloadPointCloudTileSource() {
+  const { PointCloudTileSourceLoaderWithParser } = await import("@loaders.gl/tiles/point-cloud-tile-source-loader");
+  return PointCloudTileSourceLoaderWithParser;
+}
+var PointCloudTileSourceLoader = {
+  dataType: null,
+  batchType: null,
+  name: "PointCloudTiler",
+  id: "point-cloud-tiler",
+  module: "tiles",
+  version: VERSION,
+  extensions: [],
+  mimeTypes: [],
+  type: "point-cloud",
+  fromUrl: false,
+  fromBlob: false,
+  testURL: () => false,
+  options: { pointCloudTiler: {} },
+  defaultOptions: { pointCloudTiler: {} },
+  preload: preloadPointCloudTileSource,
+  /** Direct construction requires the runtime rather than this metadata export. */
+  createDataSource(_input, _options = {}, _coreApi) {
+    throw new Error("PointCloudTileSourceLoader requires preload() or @loaders.gl/tiles/point-cloud-tile-source-loader");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  I3SSource,
+  I3SSpatialTransformer,
+  ImageSet,
+  IndexedArchiveTilesetSource,
+  LOD_METRIC_TYPE,
+  PointCloudTile,
+  PointCloudTileSourceLoader,
+  PointCloudTileset,
+  RasterSet,
+  STRATEGY_DEFAULT,
+  STRATEGY_NEVER,
+  STRATEGY_REPLACE,
+  SharedTile2DHeader,
+  SpatialCoordinateTransformer,
+  TILESET_TYPE,
+  TILE_CONTENT_STATE,
+  TILE_REFINEMENT,
+  TILE_TYPE,
+  Tile3D,
+  Tiles3DSource,
+  Tiles3DSpatialTransformer,
+  Tileset2D,
+  Tileset3D,
+  TilesetCache,
+  TilesetTraverser,
+  applyTilesetSpatialOptions,
+  calculateTransformProps,
+  convertS2BoundingVolumeToOBB,
+  createBoundingVolume,
+  createImplicitSubtreeReference,
+  createTilesetSpatialReference,
+  get3DTilesSpatialReference,
+  getFrameState,
+  getGeoidModel,
+  getI3SSpatialReference,
+  getLodStatus,
+  getSpatialCoordinateFrame,
+  getTileset3DTraversalSnapshot,
+  isTileset3DSource,
+  markTilesetSpatialReferenceTransformed,
+  materializeImplicitSubtree,
+  registerGeoidModel,
+  registerGeoidModelFromPgm,
+  registerSpatialCrs,
+  registerSpatialDatumGrid,
+  replaceImplicitUrlTemplate,
+  traverseTilesetContents
+});
 //# sourceMappingURL=index.cjs.map