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

package/dist/index.cjs

@@ -18,8 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
+var index_exports = {};
+__export(index_exports, {
   I3SSource: () => I3SSource,
   ImageSet: () => ImageSet,
   IndexedArchiveTilesetSource: () => IndexedArchiveTilesetSource,
@@ -43,17 +43,1362 @@ __export(dist_exports, {
   TilesetTraverser: () => TilesetTraverser,
   calculateTransformProps: () => calculateTransformProps,
   createBoundingVolume: () => createBoundingVolume,
+  createImplicitSubtreeReference: () => createImplicitSubtreeReference,
   getFrameState: () => getFrameState,
   getLodStatus: () => getLodStatus,
-  isTileset3DSource: () => isTileset3DSource
+  isTileset3DSource: () => isTileset3DSource,
+  materializeImplicitSubtree: () => materializeImplicitSubtree,
+  replaceImplicitUrlTemplate: () => replaceImplicitUrlTemplate
 });
-module.exports = __toCommonJS(dist_exports);
+module.exports = __toCommonJS(index_exports);
 
 // dist/tileset-3d/common/tileset-3d.js
-var import_core3 = require("@math.gl/core");
+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.");
+  }
+}
+
+// ../loader-utils/src/lib/request-utils/request-scheduler.ts
 var import_stats = require("@probe.gl/stats");
-var import_loader_utils2 = require("@loaders.gl/loader-utils");
+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();
+  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._issueNewRequests();
+      }
+    };
+    this.activeRequestCount++;
+    return resolve2 ? resolve2({ done }) : Promise.resolve({ done });
+  }
+  /** We check requests asynchronously, to prevent multiple updates */
+  _issueNewRequests() {
+    if (this.updateTimer !== null) {
+      clearTimeout(this.updateTimer);
+    }
+    this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime);
+  }
+  /** Refresh all 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);
+      }
+    }
+  }
+  /** 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);
+  }
+  /** 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;
+  }
+};
+
+// ../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,
+  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 = [];
+  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
+    };
+    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 (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(createAbortError());
+    }
+    if (request.length === 0) {
+      return Promise.resolve(new ArrayBuffer(0));
+    }
+    const promise = new Promise((resolve2, reject) => {
+      const pendingRequest = { ...request, resolve: resolve2, reject, settled: false };
+      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;
+  }
+  /**
+   * 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) {
+      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);
+    }
+    for (const mergedRequest of mergedRequests) {
+      this.fetchMergedRequest(mergedRequest);
+    }
+  }
+  /** Schedules the next pending-request flush. */
+  scheduleFlush() {
+    if (this.flushTimer) {
+      return;
+    }
+    this.flushTimer = setTimeout(() => this.flush(), this.props.batchDelayMs);
+  }
+  /** 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]
+        });
+      }
+    }
+    return mergedRequests;
+  }
+  /** 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();
+    const requestStartTime = getTimestamp();
+    const abortTransportIfUnused = () => {
+      if (requests.every((request) => {
+        var _a2;
+        return (_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) {
+      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 {
+      for (const request of requests) {
+        if (request.abortListener) {
+          (_b = request.signal) == null ? void 0 : _b.removeEventListener("abort", request.abortListener);
+        }
+        request.onAbort = void 0;
+      }
+    }
+  }
+  /** Rejects and tracks one logical request exactly once when its caller aborts. */
+  abortRequest(request) {
+    if (request.settled) {
+      return;
+    }
+    request.settled = true;
+    request.reject(createAbortError());
+    this.trackEvent({
+      type: "abort",
+      sourceId: request.sourceId,
+      offset: request.offset,
+      length: request.length,
+      logicalRequestCount: 1,
+      logicalBytes: request.length
+    });
+  }
+  /** 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)
+    });
+  }
+};
+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();
+  if (parentSignal == null ? void 0 : parentSignal.aborted) {
+    abortController.abort();
+  } 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 createAbortError() {
+  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 = window.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;
+        }
+      } else {
+        const slice = path.slice(lastSlash + 1, i);
+        if (res.length > 0) {
+          res += `/${slice}`;
+        } else {
+          res = slice;
+        }
+        isAboveRoot = false;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === DOT && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  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/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
+    };
+  }
+};
+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 = createAbortError2();
+      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 = createAbortError2();
+      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 createAbortError2() {
+  if (typeof DOMException !== "undefined") {
+    return new DOMException("Request aborted", "AbortError");
+  }
+  const error = new Error("Request aborted");
+  error.name = "AbortError";
+  return error;
+}
+function waitForPromiseWithSignal(promise, signal) {
+  if (!signal) {
+    return promise;
+  }
+  if (signal.aborted) {
+    return Promise.reject(createAbortError2());
+  }
+  return new Promise((resolve2, reject) => {
+    const abortListener = () => {
+      signal.removeEventListener("abort", abortListener);
+      reject(createAbortError2());
+    };
+    signal.addEventListener("abort", abortListener, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", abortListener);
+        resolve2(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", abortListener);
+        reject(error);
+      }
+    );
+  });
+}
 
 // dist/utils/doubly-linked-list-node.js
 var DoublyLinkedListNode = class {
@@ -181,14 +1526,23 @@ var TilesetCache = class {
       unloadCallback(tileset, tile);
     }
   }
+  /**
+   * Unloads least-recently-used tiles until the byte-native cache target is met.
+   *
+   * Tiles touched after the frame sentinel remain protected, so {@link Tileset3D.cacheBytes} is a
+   * soft target rather than a hard cap on the visible working set. Overflow headroom affects
+   * memory-adjusted SSE, not eviction of unused tiles.
+   *
+   * @param tileset - Tileset that owns the cache and reports estimated content memory.
+   * @param unloadCallback - Callback that releases content and decrements the memory estimate.
+   */
   unloadTiles(tileset, unloadCallback) {
     const trimTiles = this._trimTiles;
     this._trimTiles = false;
     const list = this._list;
-    const maximumMemoryUsageInBytes = tileset.maximumMemoryUsage * 1024 * 1024;
     const sentinel = this._sentinel;
     let node = list.head;
-    while (node !== sentinel && (tileset.gpuMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)) {
+    while (node !== sentinel && (tileset.gpuMemoryUsageInBytes > tileset.cacheBytes || trimTiles)) {
       const tile = node.item;
       node = node.next;
       this.unloadTile(tileset, tile, unloadCallback);
@@ -202,10 +1556,9 @@ 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) {
-  (0, import_loader_utils.assert)(tileHeader);
-  (0, import_loader_utils.assert)(tile);
+  assert(tileHeader);
+  assert(tile);
   const { rtcCenter, gltfUpAxis } = tile;
   const { computedTransform, boundingVolume: { center } } = tileHeader;
   let modelMatrix = new import_core.Matrix4(computedTransform);
@@ -272,6 +1625,8 @@ var import_culling = require("@math.gl/culling");
 var import_geospatial2 = require("@math.gl/geospatial");
 var scratchVector = new import_core2.Vector3();
 var scratchPosition = new import_core2.Vector3();
+var CAMERA_POSITION_EPSILON = 1e-5;
+var CAMERA_DIRECTION_EPSILON = 1e-7;
 var cullingVolume = new import_culling.CullingVolume([
   new import_culling.Plane(),
   new import_culling.Plane(),
@@ -280,17 +1635,26 @@ var cullingVolume = new import_culling.CullingVolume([
   new import_culling.Plane(),
   new import_culling.Plane()
 ]);
-function getFrameState(viewport, frameNumber) {
-  const { cameraDirection, cameraUp, height } = viewport;
+function getFrameState(viewport, frameNumber, options = {}) {
+  const { cameraUp, height } = viewport;
+  const cameraDirection = viewport.cameraDirection;
   const { metersPerUnit } = viewport.distanceScales;
   const viewportCenterCartesian = worldToCartesian(viewport, viewport.center);
   const enuToFixedTransform = import_geospatial2.Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);
   const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
   const cameraPositionCartesian2 = import_geospatial2.Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, new import_core2.Vector3());
-  const cameraDirectionCartesian = new import_core2.Vector3(
-    // @ts-ignore
-    enuToFixedTransform.transformAsVector(new import_core2.Vector3(cameraDirection).scale(metersPerUnit))
-  ).normalize();
+  let cameraDirectionCartesian;
+  if (cameraDirection) {
+    cameraDirectionCartesian = new import_core2.Vector3(
+      // @ts-ignore
+      enuToFixedTransform.transformAsVector(new import_core2.Vector3(cameraDirection).scale(metersPerUnit))
+    ).normalize();
+  } else {
+    const nearPlane = viewport.getFrustumPlanes().near;
+    const nearCenterCommon = closestPointOnPlane(nearPlane, viewport.cameraPosition);
+    const nearCenterCartesian = worldToCartesian(viewport, nearCenterCommon);
+    cameraDirectionCartesian = new import_core2.Vector3(nearCenterCartesian).subtract(cameraPositionCartesian2).normalize();
+  }
   const cameraUpCartesian = new import_core2.Vector3(
     // @ts-ignore
     enuToFixedTransform.transformAsVector(new import_core2.Vector3(cameraUp).scale(metersPerUnit))
@@ -311,7 +1675,10 @@ function getFrameState(viewport, frameNumber) {
     camera: {
       position: cameraPositionCartesian2,
       direction: cameraDirectionCartesian,
-      up: cameraUpCartesian
+      up: cameraUpCartesian,
+      cartographicPosition: cameraPositionCartographic,
+      verticalFieldOfView: Number.isFinite(viewport.fovy) && Number(viewport.fovy) > 0 ? Number(viewport.fovy) * Math.PI / 180 : Math.PI / 3,
+      timeSinceMovement: options.timeSinceCameraMovement ?? Number.POSITIVE_INFINITY
     },
     viewport,
     topDownViewport,
@@ -319,63 +1686,342 @@ function getFrameState(viewport, frameNumber) {
     cullingVolume,
     frameNumber,
     // TODO: This can be the same between updates, what number is unique for between updates?
-    sseDenominator: 1.15
+    sseDenominator: 1.15,
     // Assumes fovy = 60 degrees
+    // Tileset3D fills this immediately before traversal because it depends on the root volume.
+    dynamicScreenSpaceErrorDensity: 0
+  };
+}
+function updateCameraMotionState(previousState, position, direction, currentTime) {
+  const positionArray = Array.from(position);
+  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;
+  return {
+    state: {
+      position: positionArray,
+      direction: directionArray,
+      lastMovementTime
+    },
+    timeSinceMovement: Math.max((currentTime - lastMovementTime) / 1e3, 0)
+  };
+}
+function limitSelectedTiles(tiles, frameState, maximumTilesSelected) {
+  if (maximumTilesSelected === 0 || tiles.length <= maximumTilesSelected) {
+    return [tiles, []];
+  }
+  const tuples = [];
+  const { longitude: viewportLongitude, latitude: viewportLatitude } = frameState.viewport;
+  for (const [index, tile] of tiles.entries()) {
+    const [longitude, latitude] = tile.header.mbs;
+    const deltaLon = Math.abs(viewportLongitude - longitude);
+    const deltaLat = Math.abs(viewportLatitude - latitude);
+    const distance = Math.sqrt(deltaLat * deltaLat + deltaLon * deltaLon);
+    tuples.push([index, distance]);
+  }
+  const tuplesSorted = tuples.sort((a, b) => a[1] - b[1]);
+  const selectedTiles = [];
+  for (let i = 0; i < maximumTilesSelected; i++) {
+    selectedTiles.push(tiles[tuplesSorted[i][0]]);
+  }
+  const unselectedTiles = [];
+  for (let i = maximumTilesSelected; i < tuplesSorted.length; i++) {
+    unselectedTiles.push(tiles[tuplesSorted[i][0]]);
+  }
+  return [selectedTiles, unselectedTiles];
+}
+function commonSpacePlanesToWGS84(viewport) {
+  const frustumPlanes = viewport.getFrustumPlanes();
+  const nearCenterCommon = closestPointOnPlane(frustumPlanes.near, viewport.cameraPosition);
+  const nearCenterCartesian = worldToCartesian(viewport, nearCenterCommon);
+  const cameraCartesian = worldToCartesian(viewport, viewport.cameraPosition, scratchPosition);
+  let i = 0;
+  cullingVolume.planes[i++].fromPointNormal(nearCenterCartesian, scratchVector.copy(nearCenterCartesian).subtract(cameraCartesian));
+  for (const dir in frustumPlanes) {
+    if (dir === "near") {
+      continue;
+    }
+    const plane = frustumPlanes[dir];
+    const posCommon = closestPointOnPlane(plane, nearCenterCommon, scratchPosition);
+    const cartesianPos = worldToCartesian(viewport, posCommon, scratchPosition);
+    cullingVolume.planes[i++].fromPointNormal(
+      cartesianPos,
+      // Want the normal to point into the frustum since that's what culling expects
+      scratchVector.copy(nearCenterCartesian).subtract(cartesianPos)
+    );
+  }
+}
+function closestPointOnPlane(plane, refPoint, out = new import_core2.Vector3()) {
+  const distanceToRef = plane.normal.dot(refPoint);
+  out.copy(plane.normal).scale(plane.distance - distanceToRef).add(refPoint);
+  return out;
+}
+function worldToCartesian(viewport, point, out = new import_core2.Vector3()) {
+  const cartographicPos = viewport.unprojectPosition(point);
+  return import_geospatial2.Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, out);
+}
+
+// dist/tileset-3d/helpers/tiles-3d-lod.js
+var import_core3 = require("@math.gl/core");
+var scratchPositionNormal = new import_core3.Vector3();
+var scratchCartographic = new import_core3.Vector3();
+var scratchCenter = new import_core3.Vector3();
+var scratchPosition2 = new import_core3.Vector3();
+var scratchDirection = new import_core3.Vector3();
+var scratchBoxXAxis = new import_core3.Vector3();
+var scratchBoxYAxis = new import_core3.Vector3();
+var scratchBoxZAxis = new import_core3.Vector3();
+var scratchBoxQuaternion = new import_core3.Quaternion();
+var unitZDirection = new import_core3.Vector3(0, 0, 1);
+function updateRootTransformForDynamicScreenSpaceError(root, modelMatrix) {
+  root._updateTransform(modelMatrix);
+}
+function calculateDynamicScreenSpaceErrorDensity(root, frameState, options) {
+  if (!Number.isFinite(options.dynamicScreenSpaceErrorDensity) || options.dynamicScreenSpaceErrorDensity <= 0) {
+    return 0;
+  }
+  const boundingVolumeHeader = getContentBoundingVolumeHeader(root);
+  const heightRange = boundingVolumeHeader.region ? getRegionHeightRange(boundingVolumeHeader.region, frameState) : getCartesianHeightRange(root, boundingVolumeHeader, frameState);
+  if (!heightRange) {
+    return 0;
+  }
+  const heightFalloff = (0, import_core3.clamp)(options.dynamicScreenSpaceErrorHeightFalloff, 0, 1);
+  const heightClose = heightRange.minimumHeight + (heightRange.maximumHeight - heightRange.minimumHeight) * heightFalloff;
+  const heightSpan = heightRange.maximumHeight - heightClose;
+  const heightPercentage = heightSpan > 0 ? (0, import_core3.clamp)((heightRange.cameraHeight - heightClose) / heightSpan, 0, 1) : heightRange.cameraHeight >= heightRange.maximumHeight ? 1 : 0;
+  const verticalAlignment = (0, import_core3.clamp)(Math.abs(heightRange.cameraDirection.dot(heightRange.upDirection)), 0, 1);
+  const horizonFactor = (1 - verticalAlignment) * (1 - heightPercentage);
+  return options.dynamicScreenSpaceErrorDensity * horizonFactor;
+}
+function getDynamicScreenSpaceErrorFog(distanceToCamera, density) {
+  const scalar = distanceToCamera * density;
+  return 1 - Math.exp(-(scalar * scalar));
+}
+function getDynamicScreenSpaceError(distanceToCamera, density, factor) {
+  if (density <= 0 || factor <= 0 || !Number.isFinite(density) || !Number.isFinite(factor)) {
+    return 0;
+  }
+  return getDynamicScreenSpaceErrorFog(distanceToCamera, density) * factor;
+}
+function getTiles3DScreenSpaceError(tile, frameState, useParentLodMetric, viewportHeightFraction = 1) {
+  const tileset = tile.tileset;
+  const parentLodMetricValue = tile.parent && tile.parent.lodMetricValue || tile.lodMetricValue;
+  const lodMetricValue = useParentLodMetric ? parentLodMetricValue : tile.lodMetricValue;
+  if (lodMetricValue === 0) {
+    return 0;
+  }
+  const { viewDistanceScale } = tileset.options;
+  const lodScale = viewDistanceScale || 1;
+  const heightFraction = Number.isFinite(viewportHeightFraction) ? Math.max(viewportHeightFraction, 0) : 1;
+  const orthographicError = getOrthographicScreenSpaceError(lodMetricValue, frameState, lodScale, heightFraction);
+  if (orthographicError !== null) {
+    return orthographicError;
+  }
+  const distanceToCamera = Math.max(tile._distanceToCamera, 1e-7);
+  const { height, sseDenominator } = frameState;
+  let screenSpaceError = lodMetricValue * height * heightFraction * lodScale / (distanceToCamera * sseDenominator);
+  if (tileset.options.dynamicScreenSpaceError && !frameState.viewport.orthographic) {
+    screenSpaceError -= getDynamicScreenSpaceError(distanceToCamera, frameState.dynamicScreenSpaceErrorDensity, tileset.options.dynamicScreenSpaceErrorFactor);
+  }
+  return screenSpaceError;
+}
+function getOrthographicScreenSpaceError(lodMetricValue, frameState, lodScale, viewportHeightFraction) {
+  const viewport = frameState.viewport;
+  if (!(viewport == null ? void 0 : viewport.orthographic)) {
+    return null;
+  }
+  const metersPerPixel = viewport.metersPerPixel;
+  if (!Number.isFinite(metersPerPixel) || !metersPerPixel || metersPerPixel <= 0) {
+    return null;
+  }
+  return lodMetricValue * lodScale * viewportHeightFraction / metersPerPixel;
+}
+function getContentBoundingVolumeHeader(root) {
+  var _a;
+  return ((_a = root.header.content) == null ? void 0 : _a.boundingVolume) || root.header.boundingVolume;
+}
+function getRegionHeightRange(region, frameState) {
+  const upDirection = scratchPositionNormal.copy(frameState.camera.position).normalize();
+  const cameraDirection = scratchDirection.copy(frameState.camera.direction).normalize();
+  return {
+    cameraHeight: frameState.camera.cartographicPosition[2],
+    minimumHeight: region[4],
+    maximumHeight: region[5],
+    cameraDirection,
+    upDirection
+  };
+}
+function getCartesianHeightRange(root, boundingVolumeHeader, frameState) {
+  const halfHeight = getBoundingVolumeCenterAndHalfHeight(boundingVolumeHeader, scratchCenter);
+  if (halfHeight === null) {
+    return null;
+  }
+  const localTransform = new import_core3.Matrix4(root.computedTransform).invert();
+  const ellipsoid = root.tileset.ellipsoid;
+  const centerMagnitude = Math.hypot(scratchCenter[0], scratchCenter[1], scratchCenter[2]);
+  if (centerMagnitude > ellipsoid.minimumRadius) {
+    const centerCartographic = ellipsoid.cartesianToCartographic(scratchCenter, scratchCartographic);
+    const upDirection = scratchPositionNormal.copy(frameState.camera.position).normalize();
+    const cameraDirection = scratchDirection.copy(frameState.camera.direction).normalize();
+    return {
+      cameraHeight: frameState.camera.cartographicPosition[2],
+      minimumHeight: 0,
+      maximumHeight: centerCartographic[2] * 2,
+      cameraDirection,
+      upDirection
+    };
+  }
+  localTransform.transformAsPoint(frameState.camera.position, scratchPosition2);
+  localTransform.transformAsVector(frameState.camera.direction, scratchDirection);
+  scratchDirection.normalize();
+  return {
+    cameraHeight: scratchPosition2[2],
+    minimumHeight: scratchCenter[2] - halfHeight,
+    maximumHeight: scratchCenter[2] + halfHeight,
+    cameraDirection: scratchDirection,
+    upDirection: unitZDirection
   };
 }
-function limitSelectedTiles(tiles, frameState, maximumTilesSelected) {
-  if (maximumTilesSelected === 0 || tiles.length <= maximumTilesSelected) {
-    return [tiles, []];
+function getBoundingVolumeCenterAndHalfHeight(boundingVolumeHeader, result) {
+  if (boundingVolumeHeader.box) {
+    const box = boundingVolumeHeader.box;
+    result.set(box[0], box[1], box[2]);
+    return getBoxHalfHeight(box);
   }
-  const tuples = [];
-  const { longitude: viewportLongitude, latitude: viewportLatitude } = frameState.viewport;
-  for (const [index, tile] of tiles.entries()) {
-    const [longitude, latitude] = tile.header.mbs;
-    const deltaLon = Math.abs(viewportLongitude - longitude);
-    const deltaLat = Math.abs(viewportLatitude - latitude);
-    const distance = Math.sqrt(deltaLat * deltaLat + deltaLon * deltaLon);
-    tuples.push([index, distance]);
+  if (boundingVolumeHeader.sphere) {
+    const sphere = boundingVolumeHeader.sphere;
+    result.set(sphere[0], sphere[1], sphere[2]);
+    return sphere[3];
   }
-  const tuplesSorted = tuples.sort((a, b) => a[1] - b[1]);
-  const selectedTiles = [];
-  for (let i = 0; i < maximumTilesSelected; i++) {
-    selectedTiles.push(tiles[tuplesSorted[i][0]]);
+  return null;
+}
+function getBoxHalfHeight(box) {
+  if (box.length === 10) {
+    scratchBoxQuaternion.fromArray(box, 6);
+    scratchBoxXAxis.set(box[3], 0, 0).transformByQuaternion(scratchBoxQuaternion);
+    scratchBoxYAxis.set(0, box[4], 0).transformByQuaternion(scratchBoxQuaternion);
+    scratchBoxZAxis.set(0, 0, box[5]).transformByQuaternion(scratchBoxQuaternion);
+    return Math.abs(scratchBoxXAxis[2]) + Math.abs(scratchBoxYAxis[2]) + Math.abs(scratchBoxZAxis[2]);
   }
-  const unselectedTiles = [];
-  for (let i = maximumTilesSelected; i < tuplesSorted.length; i++) {
-    unselectedTiles.push(tiles[tuplesSorted[i][0]]);
+  return Math.abs(box[5]) + Math.abs(box[8]) + Math.abs(box[11]);
+}
+
+// dist/tileset-3d/helpers/tiles-3d-request-priority.js
+var import_core4 = require("@math.gl/core");
+var import_culling2 = require("@math.gl/culling");
+
+// dist/constants.js
+var TILE_CONTENT_STATE = {
+  UNLOADED: 0,
+  // Has never been requested
+  LOADING: 1,
+  // Is waiting on a pending request
+  PROCESSING: 2,
+  // Request received.  Contents are being processed for rendering.  Depending on the content, it might make its own requests for external data.
+  READY: 3,
+  // Ready to render.
+  EXPIRED: 4,
+  // Is expired and will be unloaded once new content is loaded.
+  FAILED: 5
+  // Request failed.
+};
+var TILE_REFINEMENT;
+(function(TILE_REFINEMENT2) {
+  TILE_REFINEMENT2[TILE_REFINEMENT2["ADD"] = 1] = "ADD";
+  TILE_REFINEMENT2[TILE_REFINEMENT2["REPLACE"] = 2] = "REPLACE";
+})(TILE_REFINEMENT || (TILE_REFINEMENT = {}));
+var TILE_TYPE;
+(function(TILE_TYPE2) {
+  TILE_TYPE2["EMPTY"] = "empty";
+  TILE_TYPE2["SCENEGRAPH"] = "scenegraph";
+  TILE_TYPE2["POINTCLOUD"] = "pointcloud";
+  TILE_TYPE2["MESH"] = "mesh";
+})(TILE_TYPE || (TILE_TYPE = {}));
+var TILESET_TYPE;
+(function(TILESET_TYPE2) {
+  TILESET_TYPE2["I3S"] = "I3S";
+  TILESET_TYPE2["TILES3D"] = "TILES3D";
+})(TILESET_TYPE || (TILESET_TYPE = {}));
+var LOD_METRIC_TYPE;
+(function(LOD_METRIC_TYPE2) {
+  LOD_METRIC_TYPE2["GEOMETRIC_ERROR"] = "geometricError";
+  LOD_METRIC_TYPE2["MAX_SCREEN_THRESHOLD"] = "maxScreenThreshold";
+})(LOD_METRIC_TYPE || (LOD_METRIC_TYPE = {}));
+var TILE3D_OPTIMIZATION_HINT = {
+  NOT_COMPUTED: -1,
+  USE_OPTIMIZATION: 1,
+  SKIP_OPTIMIZATION: 0
+};
+
+// dist/tileset-3d/helpers/tiles-3d-request-priority.js
+var PREFERRED_SORTING_DIGITS = 1e4;
+var FOVEATED_SORTING_SCALE = 1e4;
+var PROGRESSIVE_RESOLUTION_PENALTY = 1e8;
+var scratchBoundingSphere = new import_culling2.BoundingSphere();
+var scratchCenterOffset = new import_core4.Vector3();
+var scratchClosestPointOnLine = new import_core4.Vector3();
+var scratchVectorToLine = new import_core4.Vector3();
+var scratchClosestPointOnSphere = new import_core4.Vector3();
+function interpolateLinearly(minimumValue, maximumValue, interpolationAmount) {
+  return minimumValue + (maximumValue - minimumValue) * interpolationAmount;
+}
+function calculateFoveatedFactor(boundingVolume, camera) {
+  const boundingSphere = boundingVolume instanceof import_culling2.BoundingSphere ? boundingVolume : boundingVolume.getBoundingSphere(scratchBoundingSphere);
+  const { center, radius } = boundingSphere;
+  scratchCenterOffset.copy(center).subtract(camera.position);
+  const centerZDepth = Math.max(scratchCenterOffset.dot(camera.direction), 0);
+  scratchClosestPointOnLine.copy(camera.direction).scale(centerZDepth).add(camera.position);
+  scratchVectorToLine.copy(scratchClosestPointOnLine).subtract(center);
+  const distanceToCenterLine = scratchVectorToLine.magnitude();
+  if (distanceToCenterLine <= radius) {
+    return 0;
   }
-  return [selectedTiles, unselectedTiles];
+  scratchClosestPointOnSphere.copy(scratchVectorToLine).normalize().scale(radius).add(center).subtract(camera.position);
+  if (scratchClosestPointOnSphere.magnitude() === 0) {
+    return 0;
+  }
+  scratchClosestPointOnSphere.normalize();
+  return Math.min(Math.max(1 - scratchClosestPointOnSphere.dot(camera.direction), 0), 1);
 }
-function commonSpacePlanesToWGS84(viewport) {
-  const frustumPlanes = viewport.getFrustumPlanes();
-  const nearCenterCommon = closestPointOnPlane(frustumPlanes.near, viewport.cameraPosition);
-  const nearCenterCartesian = worldToCartesian(viewport, nearCenterCommon);
-  const cameraCartesian = worldToCartesian(viewport, viewport.cameraPosition, scratchPosition);
-  let i = 0;
-  cullingVolume.planes[i++].fromPointNormal(nearCenterCartesian, scratchVector.copy(nearCenterCartesian).subtract(cameraCartesian));
-  for (const dir in frustumPlanes) {
-    if (dir === "near") {
-      continue;
-    }
-    const plane = frustumPlanes[dir];
-    const posCommon = closestPointOnPlane(plane, nearCenterCommon, scratchPosition);
-    const cartesianPos = worldToCartesian(viewport, posCommon, scratchPosition);
-    cullingVolume.planes[i++].fromPointNormal(
-      cartesianPos,
-      // Want the normal to point into the frustum since that's what culling expects
-      scratchVector.copy(nearCenterCartesian).subtract(cartesianPos)
-    );
+function isProgressiveResolutionPriority(screenSpaceError, parentScreenSpaceError, maximumScreenSpaceError, progressiveResolutionHeightFraction) {
+  if (!Number.isFinite(progressiveResolutionHeightFraction) || progressiveResolutionHeightFraction <= 0 || progressiveResolutionHeightFraction > 0.5) {
+    return false;
+  }
+  if (screenSpaceError > maximumScreenSpaceError) {
+    return true;
   }
+  return parentScreenSpaceError !== void 0 && parentScreenSpaceError > maximumScreenSpaceError;
 }
-function closestPointOnPlane(plane, refPoint, out = new import_core2.Vector3()) {
-  const distanceToRef = plane.normal.dot(refPoint);
-  out.copy(plane.normal).scale(plane.distance - distanceToRef).add(refPoint);
-  return out;
+function isFoveatedRequestDeferred(parameters) {
+  const coneSize = Number.isFinite(parameters.foveatedConeSize) ? Math.min(Math.max(parameters.foveatedConeSize, 0), 1) : 1;
+  const replacementRefinement = parameters.refinement === TILE_REFINEMENT.REPLACE;
+  if (replacementRefinement && !parameters.skipLevelOfDetail || !parameters.foveatedScreenSpaceError || coneSize >= 1 || replacementRefinement && parameters.skipLevelOfDetail && parameters.priorityProgressiveResolution) {
+    return false;
+  }
+  const verticalFieldOfView = Number.isFinite(parameters.verticalFieldOfView) && parameters.verticalFieldOfView > 0 ? parameters.verticalFieldOfView : Math.PI / 3;
+  const maximumFoveatedFactor = 1 - Math.cos(verticalFieldOfView * 0.5);
+  const coneFactor = coneSize * maximumFoveatedFactor;
+  if (parameters.foveatedFactor <= coneFactor || maximumFoveatedFactor <= coneFactor) {
+    return false;
+  }
+  const interpolationAmount = Math.min(Math.max((parameters.foveatedFactor - coneFactor) / (maximumFoveatedFactor - coneFactor), 0), 1);
+  const interpolationCallback = typeof parameters.interpolationCallback === "function" ? parameters.interpolationCallback : interpolateLinearly;
+  const interpolatedRelaxation = interpolationCallback(parameters.minimumScreenSpaceErrorRelaxation, parameters.maximumScreenSpaceError, interpolationAmount);
+  const screenSpaceErrorRelaxation = Number.isFinite(interpolatedRelaxation) ? Math.min(Math.max(interpolatedRelaxation, 0), parameters.maximumScreenSpaceError) : 0;
+  const screenSpaceError = parameters.screenSpaceError === 0 && parameters.parentScreenSpaceError !== void 0 ? parameters.parentScreenSpaceError * 0.5 : parameters.screenSpaceError;
+  return parameters.maximumScreenSpaceError - screenSpaceErrorRelaxation <= screenSpaceError;
 }
-function worldToCartesian(viewport, point, out = new import_core2.Vector3()) {
-  const cartographicPos = viewport.unprojectPosition(point);
-  return import_geospatial2.Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, out);
+function isFoveatedRequestDelayActive(deferralEligible, timeSinceMovement, foveatedTimeDelay) {
+  return deferralEligible && Number.isFinite(timeSinceMovement) && Number.isFinite(foveatedTimeDelay) && foveatedTimeDelay > 0 && timeSinceMovement < foveatedTimeDelay;
+}
+function calculateTileRequestPriority(parameters) {
+  const normalizedReverseScreenSpaceError = parameters.rootScreenSpaceError > 0 ? Math.min(Math.max(parameters.reverseScreenSpaceError / parameters.rootScreenSpaceError, 0), 1) : 0;
+  const preferredSortingDigits = Math.floor(normalizedReverseScreenSpaceError * (PREFERRED_SORTING_DIGITS - 1));
+  const normalizedFoveatedFactor = Number.isFinite(parameters.foveatedFactor) ? Math.min(Math.max(parameters.foveatedFactor, 0), 1) : 0;
+  const foveatedSortingDigits = Math.floor(normalizedFoveatedFactor * (PREFERRED_SORTING_DIGITS - 1)) * FOVEATED_SORTING_SCALE;
+  const progressiveResolutionDigits = parameters.priorityProgressiveResolution ? 0 : PROGRESSIVE_RESOLUTION_PENALTY;
+  return progressiveResolutionDigits + foveatedSortingDigits + preferredSortingDigits;
 }
 
 // dist/tileset-3d/common/tileset-source.js
@@ -384,14 +2030,35 @@ function isTileset3DSource(value) {
 }
 
 // dist/tileset-3d/common/tileset-3d.js
-var DEFAULT_PROPS = {
+var BYTES_PER_MEBIBYTE = 1024 * 1024;
+var DEFAULT_CACHE_BYTES = 512 * BYTES_PER_MEBIBYTE;
+var DEFAULT_MAXIMUM_CACHE_OVERFLOW_BYTES = 512 * BYTES_PER_MEBIBYTE;
+var DEFAULT_I3S_CACHE_BYTES = 32 * BYTES_PER_MEBIBYTE;
+var DEFAULT_I3S_MAXIMUM_CACHE_OVERFLOW_BYTES = BYTES_PER_MEBIBYTE;
+function validateCacheByteLength(value, optionName) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`${optionName} must be a finite number greater than or equal to 0`);
+  }
+  return value;
+}
+function resolveCacheBytes(options, fallbackCacheBytes) {
+  const cacheBytes = options.cacheBytes ?? (options.maximumMemoryUsage !== void 0 ? options.maximumMemoryUsage * BYTES_PER_MEBIBYTE : fallbackCacheBytes);
+  return validateCacheByteLength(cacheBytes, "cacheBytes");
+}
+function resolveMaximumCacheOverflowBytes(options, fallbackOverflowBytes) {
+  const maximumCacheOverflowBytes = options.maximumCacheOverflowBytes ?? (options.memoryCacheOverflow !== void 0 ? options.memoryCacheOverflow * BYTES_PER_MEBIBYTE : fallbackOverflowBytes);
+  return validateCacheByteLength(maximumCacheOverflowBytes, "maximumCacheOverflowBytes");
+}
+var DEFAULT_PROPS3 = {
   description: "",
   ellipsoid: import_geospatial3.Ellipsoid.WGS84,
-  modelMatrix: new import_core3.Matrix4(),
+  modelMatrix: new import_core5.Matrix4(),
   throttleRequests: true,
   maxRequests: 64,
-  maximumMemoryUsage: 32,
-  memoryCacheOverflow: 1,
+  cacheBytes: DEFAULT_CACHE_BYTES,
+  maximumCacheOverflowBytes: DEFAULT_MAXIMUM_CACHE_OVERFLOW_BYTES,
+  maximumMemoryUsage: DEFAULT_CACHE_BYTES / BYTES_PER_MEBIBYTE,
+  memoryCacheOverflow: DEFAULT_MAXIMUM_CACHE_OVERFLOW_BYTES / BYTES_PER_MEBIBYTE,
   maximumTilesSelected: 0,
   debounceTime: 0,
   onTileLoad: () => {
@@ -409,8 +2076,18 @@ var DEFAULT_PROPS = {
   },
   contentLoader: void 0,
   viewDistanceScale: 1,
+  progressiveResolutionHeightFraction: 0.3,
+  foveatedScreenSpaceError: true,
+  foveatedConeSize: 0.1,
+  foveatedMinimumScreenSpaceErrorRelaxation: 0,
+  foveatedInterpolationCallback: interpolateLinearly,
+  foveatedTimeDelay: 0.2,
   maximumScreenSpaceError: 8,
-  memoryAdjustedScreenSpaceError: false,
+  dynamicScreenSpaceError: true,
+  dynamicScreenSpaceErrorDensity: 2e-4,
+  dynamicScreenSpaceErrorFactor: 24,
+  dynamicScreenSpaceErrorHeightFalloff: 0.25,
+  memoryAdjustedScreenSpaceError: true,
   loadTiles: true,
   updateTransforms: true,
   viewportTraversersMap: null,
@@ -459,12 +2136,14 @@ var Tileset3D = class {
   cartesianCenter = null;
   zoom = 1;
   boundingVolume = null;
+  /** Effective dynamic SSE density calculated for the most recently traversed viewport. */
   dynamicScreenSpaceErrorComputedDensity = 0;
-  maximumMemoryUsage = 32;
+  /** Estimated bytes currently retained by loaded tile content. */
   gpuMemoryUsageInBytes = 0;
+  /** Active SSE threshold after optional cache-pressure adjustment, in logical/CSS pixels. */
   memoryAdjustedScreenSpaceError = 0;
-  _cacheBytes = 0;
-  _cacheOverflowBytes = 0;
+  _cacheBytes = DEFAULT_CACHE_BYTES;
+  _maximumCacheOverflowBytes = DEFAULT_MAXIMUM_CACHE_OVERFLOW_BYTES;
   _frameNumber = 0;
   _tiles = {};
   _pendingCount = 0;
@@ -475,6 +2154,10 @@ var Tileset3D = class {
   _requestedTiles = [];
   _emptyTiles = [];
   frameStateData = {};
+  /** Last camera pose retained independently for each viewport. */
+  _cameraMotionStates = {};
+  /** Pending traversal that releases requests after camera motion settles. */
+  _deferredTraversalTimeout = null;
   _traverser;
   _cache = new TilesetCache();
   _requestScheduler;
@@ -487,11 +2170,25 @@ var Tileset3D = class {
    * @param options Traversal and runtime options.
    */
   constructor(source, options) {
-    this.options = { ...DEFAULT_PROPS, ...options };
-    this.loadOptions = this.options.loadOptions || {};
     if (!isTileset3DSource(source)) {
       throw new Error("Tileset3D requires a Tileset3DSource instance");
     }
+    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 cacheBytes = resolveCacheBytes(suppliedOptions, defaultCacheBytes);
+    const maximumCacheOverflowBytes = resolveMaximumCacheOverflowBytes(suppliedOptions, defaultMaximumCacheOverflowBytes);
+    this.options = {
+      ...DEFAULT_PROPS3,
+      ...suppliedOptions,
+      cacheBytes,
+      maximumCacheOverflowBytes,
+      maximumMemoryUsage: cacheBytes / BYTES_PER_MEBIBYTE,
+      memoryCacheOverflow: maximumCacheOverflowBytes / BYTES_PER_MEBIBYTE,
+      memoryAdjustedScreenSpaceError: suppliedOptions.memoryAdjustedScreenSpaceError ?? usesTiles3DCacheDefaults
+    };
+    this.loadOptions = this.options.loadOptions || {};
     this.source = source;
     this.tileset = null;
     this.loader = this.source.loader;
@@ -505,18 +2202,21 @@ var Tileset3D = class {
     this.refine = "";
     this.contentFormats = this.source.contentFormats;
     this._traverser = this._initializeTraverser();
-    this._requestScheduler = new import_loader_utils2.RequestScheduler({
+    this._requestScheduler = new RequestScheduler({
       throttleRequests: this.options.throttleRequests,
       maxRequests: this.options.maxRequests
     });
     this.memoryAdjustedScreenSpaceError = this.options.maximumScreenSpaceError;
-    this._cacheBytes = this.options.maximumMemoryUsage * 1024 * 1024;
-    this._cacheOverflowBytes = this.options.memoryCacheOverflow * 1024 * 1024;
-    this.stats = new import_stats.Stats({ id: this.url });
+    this._cacheBytes = cacheBytes;
+    this._maximumCacheOverflowBytes = maximumCacheOverflowBytes;
+    this.stats = new import_stats3.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._destroy();
   }
   isLoaded() {
@@ -528,13 +2228,73 @@ var Tileset3D = class {
   get frameNumber() {
     return this._frameNumber;
   }
+  /**
+   * Gets or sets the soft target, in bytes, for cached tile content not needed this frame.
+   *
+   * Current-frame tiles remain protected even when their estimated memory exceeds this target.
+   * Reducing the value makes unused least-recently-used tiles eligible for eviction on the next
+   * traversal.
+   * @default 536870912 for 3D Tiles; 33554432 for I3S
+   */
+  get cacheBytes() {
+    return this._cacheBytes;
+  }
+  set cacheBytes(value) {
+    this._cacheBytes = validateCacheByteLength(value, "cacheBytes");
+    this.options.cacheBytes = this._cacheBytes;
+    this.options.maximumMemoryUsage = this._cacheBytes / BYTES_PER_MEBIBYTE;
+  }
+  /**
+   * Gets or sets the additional current-frame headroom, in bytes, before memory-adjusted SSE rises.
+   *
+   * The pressure ceiling is `cacheBytes + maximumCacheOverflowBytes`. This value does not change
+   * the base target used to evict tiles that were not touched in the current frame.
+   * @default 536870912 for 3D Tiles; 1048576 for I3S
+   */
+  get maximumCacheOverflowBytes() {
+    return this._maximumCacheOverflowBytes;
+  }
+  set maximumCacheOverflowBytes(value) {
+    this._maximumCacheOverflowBytes = validateCacheByteLength(value, "maximumCacheOverflowBytes");
+    this.options.maximumCacheOverflowBytes = this._maximumCacheOverflowBytes;
+    this.options.memoryCacheOverflow = this._maximumCacheOverflowBytes / BYTES_PER_MEBIBYTE;
+  }
+  /**
+   * Gets or sets the soft cache target in mebibytes.
+   * @deprecated Use {@link Tileset3D.cacheBytes}. Assignments remain synchronized for compatibility.
+   */
+  get maximumMemoryUsage() {
+    return this.cacheBytes / BYTES_PER_MEBIBYTE;
+  }
+  set maximumMemoryUsage(value) {
+    this.cacheBytes = validateCacheByteLength(value * BYTES_PER_MEBIBYTE, "maximumMemoryUsage");
+  }
   get queryParams() {
     const rootUrl = this.source.getTileUrl(this.url);
     const queryIndex = rootUrl.indexOf("?");
     return queryIndex >= 0 ? rootUrl.slice(queryIndex + 1) : "";
   }
+  /**
+   * Updates traversal and runtime options, synchronizing byte-native and deprecated cache values.
+   *
+   * For each budget, the byte-native option takes precedence when both unit forms are supplied.
+   * Unspecified budgets retain their current byte values, avoiding repeated MiB conversion.
+   *
+   * @param props - Partial runtime options to apply.
+   */
   setProps(props) {
-    this.options = { ...this.options, ...props };
+    const cacheBytes = resolveCacheBytes(props, this.cacheBytes);
+    const maximumCacheOverflowBytes = resolveMaximumCacheOverflowBytes(props, this.maximumCacheOverflowBytes);
+    this.options = {
+      ...this.options,
+      ...props,
+      cacheBytes,
+      maximumCacheOverflowBytes,
+      maximumMemoryUsage: cacheBytes / BYTES_PER_MEBIBYTE,
+      memoryCacheOverflow: maximumCacheOverflowBytes / BYTES_PER_MEBIBYTE
+    };
+    this._cacheBytes = cacheBytes;
+    this._maximumCacheOverflowBytes = maximumCacheOverflowBytes;
   }
   getTileUrl(tilePath) {
     return this.source.getTileUrl(tilePath);
@@ -561,22 +2321,29 @@ var Tileset3D = class {
       this.lastUpdatedVieports = viewports;
     }
     if (!this.updatePromise) {
-      this.updatePromise = new Promise((resolve) => {
+      this.updatePromise = new Promise((resolve2) => {
         setTimeout(() => {
           if (this.lastUpdatedVieports) {
             this.doUpdate(this.lastUpdatedVieports);
           }
-          resolve(this._frameNumber);
+          resolve2(this._frameNumber);
           this.updatePromise = null;
         }, this.options.debounceTime);
       });
     }
     return this.updatePromise;
   }
+  /**
+   * Moves the active LOD threshold toward the configured SSE or away from cache pressure.
+   *
+   * Usage below {@link Tileset3D.cacheBytes} restores quality in two-percent steps. Usage above
+   * `cacheBytes + maximumCacheOverflowBytes` reduces refinement in two-percent steps. Values in
+   * the overflow window leave the threshold unchanged, preventing rapid load/evict oscillation.
+   */
   adjustScreenSpaceError() {
-    if (this.gpuMemoryUsageInBytes < this._cacheBytes) {
+    if (this.gpuMemoryUsageInBytes < this.cacheBytes) {
       this.memoryAdjustedScreenSpaceError = Math.max(this.memoryAdjustedScreenSpaceError / 1.02, this.options.maximumScreenSpaceError);
-    } else if (this.gpuMemoryUsageInBytes > this._cacheBytes + this._cacheOverflowBytes) {
+    } else if (this.gpuMemoryUsageInBytes > this.cacheBytes + this.maximumCacheOverflowBytes) {
       this.memoryAdjustedScreenSpaceError *= 1.02;
     }
   }
@@ -591,6 +2358,8 @@ var Tileset3D = class {
     this._cache.reset();
     this._frameNumber++;
     this.traverseCounter = preparedViewports.length;
+    const currentTime = Date.now();
+    let minimumDeferredTraversalDelay = Number.POSITIVE_INFINITY;
     const viewportsToTraverse = [];
     for (const viewport of preparedViewports) {
       const id = viewport.id;
@@ -609,7 +2378,47 @@ var Tileset3D = class {
         continue;
       }
       const frameState = getFrameState(viewport, this._frameNumber);
-      this._traverser.traverse(this.roots[id], frameState, this.options);
+      const root = this.roots[id];
+      const cameraMotionUpdate = updateCameraMotionState(this._cameraMotionStates[id], frameState.camera.position, frameState.camera.direction, currentTime);
+      this._cameraMotionStates[id] = cameraMotionUpdate.state;
+      frameState.camera.timeSinceMovement = cameraMotionUpdate.timeSinceMovement;
+      updateRootTransformForDynamicScreenSpaceError(root, this.modelMatrix);
+      frameState.dynamicScreenSpaceErrorDensity = this.type === TILESET_TYPE.TILES3D && this.options.dynamicScreenSpaceError && !frameState.viewport.orthographic ? calculateDynamicScreenSpaceErrorDensity(root, frameState, this.options) : 0;
+      this.dynamicScreenSpaceErrorComputedDensity = frameState.dynamicScreenSpaceErrorDensity;
+      this._traverser.traverse(root, frameState, this.options);
+      if (Object.keys(this._traverser.deferredTiles).length > 0) {
+        minimumDeferredTraversalDelay = Math.min(minimumDeferredTraversalDelay, Math.max(this.options.foveatedTimeDelay - cameraMotionUpdate.timeSinceMovement, 0));
+      }
+    }
+    if (Number.isFinite(minimumDeferredTraversalDelay)) {
+      this._scheduleDeferredTraversal(minimumDeferredTraversalDelay);
+    } else {
+      this._clearDeferredTraversal();
+    }
+  }
+  /**
+   * Schedules one follow-up traversal when the moving-camera deferral window expires.
+   *
+   * Replacing an existing timer ensures continuing camera movement pushes the retry window forward
+   * instead of creating a queue of redundant traversals.
+   *
+   * @param delayInSeconds - Remaining stationary delay before deferred requests become eligible.
+   */
+  _scheduleDeferredTraversal(delayInSeconds) {
+    this._clearDeferredTraversal();
+    this._deferredTraversalTimeout = setTimeout(() => {
+      this._deferredTraversalTimeout = null;
+      this.selectTiles().catch((error) => {
+        const traversalError = error instanceof Error ? error : new Error(String(error));
+        this._onTilesetError(traversalError);
+      });
+    }, Math.max(delayInSeconds * 1e3, 0));
+  }
+  /** Clears a pending moving-camera follow-up traversal. */
+  _clearDeferredTraversal() {
+    if (this._deferredTraversalTimeout !== null) {
+      clearTimeout(this._deferredTraversalTimeout);
+      this._deferredTraversalTimeout = null;
     }
   }
   _needTraverse(viewportId) {
@@ -708,6 +2517,9 @@ var Tileset3D = class {
   }
   _unloadTiles() {
     this._cache.unloadTiles(this, (tileset, tile) => tileset._unloadTile(tile));
+    if (this.options.memoryAdjustedScreenSpaceError) {
+      this.adjustScreenSpaceError();
+    }
   }
   _updateStats() {
     let tilesRenderable = 0;
@@ -792,6 +2604,27 @@ var Tileset3D = class {
       this._onTileLoad(tile, loadResult);
     }
   }
+  /**
+   * Loads a source-managed lazy child-header group and reports failures through tile callbacks.
+   *
+   * Subtree metadata shares the normal loading counters but is not reported as render content and
+   * is not added to the GPU cache. Traversal is notified separately after the promise settles.
+   *
+   * @param tile - Runtime tile that owns the lazy subtree reference.
+   * @param frameState - View state that made the subtree eligible for refinement.
+   */
+  async _loadTileChildren(tile, frameState) {
+    try {
+      this._onStartTileLoading();
+      await tile.loadChildren(frameState);
+    } catch (error) {
+      const tileError = error instanceof Error ? error : new Error("subtree load failed");
+      this._onSourceError(tileError, tile);
+      this._onTileLoadError(tile, tileError);
+    } finally {
+      this._onEndTileLoading();
+    }
+  }
   _onTileLoadError(tile, error) {
     this.stats.get(TILES_LOAD_FAILED).incrementCount();
     const message = error.message || error.toString();
@@ -913,7 +2746,7 @@ var Tileset3D = class {
     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.cartographicCenter = viewState.cartographicCenter || new import_core3.Vector3();
+    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;
@@ -931,7 +2764,6 @@ var Tileset3D = class {
 };
 
 // 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;
@@ -998,30 +2830,30 @@ var IndexedArchiveTilesetSource = class {
   async openArchiveReadableFile() {
     const { data } = this.options;
     if (typeof data !== "string") {
-      return new import_loader_utils3.BlobFile(data);
+      return new BlobFile(data);
     }
     if (/^https?:\/\//i.test(data)) {
-      return new import_loader_utils3.HttpFile(data);
+      return new HttpFile(data);
     }
     const coreApi = this.options.getCoreApi();
     if (!coreApi) {
       throw new Error(this.options.missingCoreApiMessage);
     }
     const response = await coreApi.fetchFile(data);
-    return new import_loader_utils3.BlobFile(await response.arrayBuffer());
+    return new 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 : import_loader_utils3.path.dirname(baseWithoutQuery);
+    const basePath = baseWithoutQuery === archiveRoot ? archiveRoot : path_exports.dirname(baseWithoutQuery);
     const markerExpression = new RegExp(`\\.${this.options.archiveExtension}/(.*)$`, "i");
     const markerMatch = requestWithoutQuery.match(markerExpression);
     if (markerMatch == null ? void 0 : 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}` : import_loader_utils3.path.resolve(basePath, requestWithoutQuery);
+    const absoluteRequest = requestWithoutQuery.startsWith(archiveRoot) ? requestWithoutQuery : baseWithoutQuery === archiveRoot && !isAbsoluteRequest ? `${archiveRoot}/${requestWithoutQuery}` : path_exports.resolve(basePath, requestWithoutQuery);
     if (absoluteRequest === archiveRoot) {
       return "";
     }
@@ -1044,70 +2876,26 @@ function stripQueryString(url) {
 }
 
 // dist/tileset-3d/common/tile-3d.js
-var import_core7 = require("@math.gl/core");
-var import_culling3 = require("@math.gl/culling");
-
-// dist/constants.js
-var TILE_CONTENT_STATE = {
-  UNLOADED: 0,
-  // Has never been requested
-  LOADING: 1,
-  // Is waiting on a pending request
-  PROCESSING: 2,
-  // Request received.  Contents are being processed for rendering.  Depending on the content, it might make its own requests for external data.
-  READY: 3,
-  // Ready to render.
-  EXPIRED: 4,
-  // Is expired and will be unloaded once new content is loaded.
-  FAILED: 5
-  // Request failed.
-};
-var TILE_REFINEMENT;
-(function(TILE_REFINEMENT2) {
-  TILE_REFINEMENT2[TILE_REFINEMENT2["ADD"] = 1] = "ADD";
-  TILE_REFINEMENT2[TILE_REFINEMENT2["REPLACE"] = 2] = "REPLACE";
-})(TILE_REFINEMENT || (TILE_REFINEMENT = {}));
-var TILE_TYPE;
-(function(TILE_TYPE2) {
-  TILE_TYPE2["EMPTY"] = "empty";
-  TILE_TYPE2["SCENEGRAPH"] = "scenegraph";
-  TILE_TYPE2["POINTCLOUD"] = "pointcloud";
-  TILE_TYPE2["MESH"] = "mesh";
-})(TILE_TYPE || (TILE_TYPE = {}));
-var TILESET_TYPE;
-(function(TILESET_TYPE2) {
-  TILESET_TYPE2["I3S"] = "I3S";
-  TILESET_TYPE2["TILES3D"] = "TILES3D";
-})(TILESET_TYPE || (TILESET_TYPE = {}));
-var LOD_METRIC_TYPE;
-(function(LOD_METRIC_TYPE2) {
-  LOD_METRIC_TYPE2["GEOMETRIC_ERROR"] = "geometricError";
-  LOD_METRIC_TYPE2["MAX_SCREEN_THRESHOLD"] = "maxScreenThreshold";
-})(LOD_METRIC_TYPE || (LOD_METRIC_TYPE = {}));
-var TILE3D_OPTIMIZATION_HINT = {
-  NOT_COMPUTED: -1,
-  USE_OPTIMIZATION: 1,
-  SKIP_OPTIMIZATION: 0
-};
+var import_core8 = require("@math.gl/core");
+var import_culling4 = require("@math.gl/culling");
 
 // dist/tileset-3d/helpers/bounding-volume.js
-var import_core4 = require("@math.gl/core");
-var import_culling2 = require("@math.gl/culling");
+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;
 }
-var scratchPoint = new import_core4.Vector3();
-var scratchScale = new import_core4.Vector3();
-var scratchNorthWest = new import_core4.Vector3();
-var scratchSouthEast = new import_core4.Vector3();
-var scratchCenter = new import_core4.Vector3();
-var scratchXAxis = new import_core4.Vector3();
-var scratchYAxis = new import_core4.Vector3();
-var scratchZAxis = new import_core4.Vector3();
+var scratchPoint = new import_core6.Vector3();
+var scratchScale = new import_core6.Vector3();
+var scratchNorthWest = new import_core6.Vector3();
+var scratchSouthEast = new import_core6.Vector3();
+var scratchCenter2 = new import_core6.Vector3();
+var scratchXAxis = new import_core6.Vector3();
+var scratchYAxis = new import_core6.Vector3();
+var scratchZAxis = new import_core6.Vector3();
 function createBoundingVolume(boundingVolumeHeader, transform, result) {
-  (0, import_loader_utils4.assert)(boundingVolumeHeader, "3D Tile: boundingVolume must be defined");
+  assert(boundingVolumeHeader, "3D Tile: boundingVolume must be defined");
   if (boundingVolumeHeader.box) {
     return createBox(boundingVolumeHeader.box, transform, result);
   }
@@ -1126,8 +2914,8 @@ function getCartographicBounds(boundingVolumeHeader, boundingVolume) {
   if (boundingVolumeHeader.region) {
     const [west, south, east, north, minHeight, maxHeight] = boundingVolumeHeader.region;
     return [
-      [(0, import_core4.degrees)(west), (0, import_core4.degrees)(south), minHeight],
-      [(0, import_core4.degrees)(east), (0, import_core4.degrees)(north), maxHeight]
+      [(0, import_core6.degrees)(west), (0, import_core6.degrees)(south), minHeight],
+      [(0, import_core6.degrees)(east), (0, import_core6.degrees)(north), maxHeight]
     ];
   }
   if (boundingVolumeHeader.sphere) {
@@ -1136,16 +2924,16 @@ function getCartographicBounds(boundingVolumeHeader, boundingVolume) {
   throw new Error("Unkown boundingVolume type");
 }
 function createBox(box, transform, result) {
-  const center = new import_core4.Vector3(box[0], box[1], box[2]);
+  const center = new import_core6.Vector3(box[0], box[1], box[2]);
   transform.transform(center, center);
   let origin = [];
   if (box.length === 10) {
     const halfSize = box.slice(3, 6);
-    const quaternion = new import_core4.Quaternion();
+    const quaternion = new import_core6.Quaternion();
     quaternion.fromArray(box, 6);
-    const x = new import_core4.Vector3([1, 0, 0]);
-    const y = new import_core4.Vector3([0, 1, 0]);
-    const z = new import_core4.Vector3([0, 0, 1]);
+    const x = new import_core6.Vector3([1, 0, 0]);
+    const y = new import_core6.Vector3([0, 1, 0]);
+    const z = new import_core6.Vector3([0, 0, 1]);
     x.transformByQuaternion(quaternion);
     x.scale(halfSize[0]);
     y.transformByQuaternion(quaternion);
@@ -1159,7 +2947,7 @@ function createBox(box, transform, result) {
   const xAxis = transform.transformAsVector(origin.slice(0, 3));
   const yAxis = transform.transformAsVector(origin.slice(3, 6));
   const zAxis = transform.transformAsVector(origin.slice(6, 9));
-  const halfAxes = new import_core4.Matrix3([
+  const halfAxes = new import_core6.Matrix3([
     xAxis[0],
     xAxis[1],
     xAxis[2],
@@ -1175,10 +2963,10 @@ function createBox(box, transform, result) {
     result.halfAxes = halfAxes;
     return result;
   }
-  return new import_culling2.OrientedBoundingBox(center, halfAxes);
+  return new import_culling3.OrientedBoundingBox(center, halfAxes);
 }
 function createSphere(sphere, transform, result) {
-  const center = new import_core4.Vector3(sphere[0], sphere[1], sphere[2]);
+  const center = new import_core6.Vector3(sphere[0], sphere[1], sphere[2]);
   transform.transform(center, center);
   const scale = transform.getScale(scratchScale);
   const uniformScale = Math.max(Math.max(scale[0], scale[1]), scale[2]);
@@ -1188,30 +2976,30 @@ function createSphere(sphere, transform, result) {
     result.radius = radius;
     return result;
   }
-  return new import_culling2.BoundingSphere(center, radius);
+  return new import_culling3.BoundingSphere(center, radius);
 }
 function createObbFromRegion(region) {
   const [west, south, east, north, minHeight, maxHeight] = region;
-  const northWest = import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([(0, import_core4.degrees)(west), (0, import_core4.degrees)(north), minHeight], scratchNorthWest);
-  const southEast = import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([(0, import_core4.degrees)(east), (0, import_core4.degrees)(south), maxHeight], scratchSouthEast);
-  const centerInCartesian = new import_core4.Vector3().addVectors(northWest, southEast).multiplyByScalar(0.5);
-  import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(centerInCartesian, scratchCenter);
-  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([(0, import_core4.degrees)(east), scratchCenter[1], scratchCenter[2]], scratchXAxis);
-  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([scratchCenter[0], (0, import_core4.degrees)(north), scratchCenter[2]], scratchYAxis);
-  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([scratchCenter[0], scratchCenter[1], maxHeight], scratchZAxis);
+  const northWest = import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([(0, import_core6.degrees)(west), (0, import_core6.degrees)(north), minHeight], scratchNorthWest);
+  const southEast = import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([(0, import_core6.degrees)(east), (0, import_core6.degrees)(south), maxHeight], scratchSouthEast);
+  const centerInCartesian = new import_core6.Vector3().addVectors(northWest, southEast).multiplyByScalar(0.5);
+  import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(centerInCartesian, scratchCenter2);
+  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([(0, import_core6.degrees)(east), scratchCenter2[1], scratchCenter2[2]], scratchXAxis);
+  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([scratchCenter2[0], (0, import_core6.degrees)(north), scratchCenter2[2]], scratchYAxis);
+  import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian([scratchCenter2[0], scratchCenter2[1], maxHeight], scratchZAxis);
   return createBox([
     ...centerInCartesian,
     ...scratchXAxis.subtract(centerInCartesian),
     ...scratchYAxis.subtract(centerInCartesian),
     ...scratchZAxis.subtract(centerInCartesian)
-  ], new import_core4.Matrix4());
+  ], new import_core6.Matrix4());
 }
 function orientedBoundingBoxToCartographicBounds(boundingVolume) {
   const result = emptyCartographicBounds();
   const { halfAxes } = boundingVolume;
-  const xAxis = new import_core4.Vector3(halfAxes.getColumn(0));
-  const yAxis = new import_core4.Vector3(halfAxes.getColumn(1));
-  const zAxis = new import_core4.Vector3(halfAxes.getColumn(2));
+  const xAxis = new import_core6.Vector3(halfAxes.getColumn(0));
+  const yAxis = new import_core6.Vector3(halfAxes.getColumn(1));
+  const zAxis = new import_core6.Vector3(halfAxes.getColumn(2));
   for (let x = 0; x < 2; x++) {
     for (let y = 0; y < 2; y++) {
       for (let z = 0; z < 2; z++) {
@@ -1236,13 +3024,13 @@ function boundingSphereToCartographicBounds(boundingVolume) {
   if (point) {
     zAxis = import_geospatial4.Ellipsoid.WGS84.geodeticSurfaceNormal(point);
   } else {
-    zAxis = new import_core4.Vector3(0, 0, 1);
+    zAxis = new import_core6.Vector3(0, 0, 1);
   }
-  let xAxis = new import_core4.Vector3(zAxis[2], -zAxis[1], 0);
+  let xAxis = new import_core6.Vector3(zAxis[2], -zAxis[1], 0);
   if (xAxis.len() > 0) {
     xAxis.normalize();
   } else {
-    xAxis = new import_core4.Vector3(0, 1, 0);
+    xAxis = new import_core6.Vector3(0, 1, 0);
   }
   const yAxis = xAxis.clone().cross(zAxis);
   for (const axis of [xAxis, yAxis, zAxis]) {
@@ -1263,77 +3051,25 @@ function emptyCartographicBounds() {
   ];
 }
 function addToCartographicBounds(target, cartesian) {
-  import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(cartesian, scratchPoint);
-  target[0][0] = Math.min(target[0][0], scratchPoint[0]);
-  target[0][1] = Math.min(target[0][1], scratchPoint[1]);
-  target[0][2] = Math.min(target[0][2], scratchPoint[2]);
-  target[1][0] = Math.max(target[1][0], scratchPoint[0]);
-  target[1][1] = Math.max(target[1][1], scratchPoint[1]);
-  target[1][2] = Math.max(target[1][2], scratchPoint[2]);
-}
-
-// dist/tileset-3d/helpers/tiles-3d-lod.js
-var import_core5 = require("@math.gl/core");
-var scratchPositionNormal = new import_core5.Vector3();
-var scratchCartographic = new import_core5.Vector3();
-var scratchMatrix = new import_core5.Matrix4();
-var scratchCenter2 = new import_core5.Vector3();
-var scratchPosition2 = new import_core5.Vector3();
-var scratchDirection = new import_core5.Vector3();
-function fog(distanceToCamera, density) {
-  const scalar = distanceToCamera * density;
-  return 1 - Math.exp(-(scalar * scalar));
-}
-function getDynamicScreenSpaceError(tileset, distanceToCamera) {
-  if (tileset.dynamicScreenSpaceError && tileset.dynamicScreenSpaceErrorComputedDensity) {
-    const density = tileset.dynamicScreenSpaceErrorComputedDensity;
-    const factor = tileset.dynamicScreenSpaceErrorFactor;
-    const dynamicError = fog(distanceToCamera, density) * factor;
-    return dynamicError;
-  }
-  return 0;
-}
-function getTiles3DScreenSpaceError(tile, frameState, useParentLodMetric) {
-  const tileset = tile.tileset;
-  const parentLodMetricValue = tile.parent && tile.parent.lodMetricValue || tile.lodMetricValue;
-  const lodMetricValue = useParentLodMetric ? parentLodMetricValue : tile.lodMetricValue;
-  if (lodMetricValue === 0) {
-    return 0;
-  }
-  const { viewDistanceScale } = tileset.options;
-  const lodScale = viewDistanceScale || 1;
-  const orthographicError = getOrthographicScreenSpaceError(lodMetricValue, frameState, lodScale);
-  if (orthographicError !== null) {
-    return orthographicError;
-  }
-  const distance = Math.max(tile._distanceToCamera, 1e-7);
-  const { height, sseDenominator } = frameState;
-  let error = lodMetricValue * height * lodScale / (distance * sseDenominator);
-  error -= getDynamicScreenSpaceError(tileset, distance);
-  return error;
-}
-function getOrthographicScreenSpaceError(lodMetricValue, frameState, lodScale) {
-  const viewport = frameState.viewport;
-  if (!(viewport == null ? void 0 : viewport.orthographic)) {
-    return null;
-  }
-  const metersPerPixel = viewport.metersPerPixel;
-  if (!Number.isFinite(metersPerPixel) || metersPerPixel <= 0) {
-    return null;
-  }
-  return lodMetricValue * lodScale / metersPerPixel;
+  import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(cartesian, scratchPoint);
+  target[0][0] = Math.min(target[0][0], scratchPoint[0]);
+  target[0][1] = Math.min(target[0][1], scratchPoint[1]);
+  target[0][2] = Math.min(target[0][2], scratchPoint[2]);
+  target[1][0] = Math.max(target[1][0], scratchPoint[0]);
+  target[1][1] = Math.max(target[1][1], scratchPoint[1]);
+  target[1][2] = Math.max(target[1][2], scratchPoint[2]);
 }
 
 // dist/tileset-3d/helpers/i3s-lod.js
-var import_core6 = require("@math.gl/core");
+var import_core7 = require("@math.gl/core");
 var import_geospatial5 = require("@math.gl/geospatial");
-var cameraPositionCartesian = new import_core6.Vector3();
-var toEye = new import_core6.Vector3();
-var cameraPositionEnu = new import_core6.Vector3();
-var extraVertexEnu = new import_core6.Vector3();
-var projectedOriginVector = new import_core6.Vector3();
-var enuToCartesianMatrix = new import_core6.Matrix4();
-var cartesianToEnuMatrix = new import_core6.Matrix4();
+var cameraPositionCartesian = new import_core7.Vector3();
+var toEye = new import_core7.Vector3();
+var cameraPositionEnu = new import_core7.Vector3();
+var extraVertexEnu = new import_core7.Vector3();
+var projectedOriginVector = new import_core7.Vector3();
+var enuToCartesianMatrix = new import_core7.Matrix4();
+var cartesianToEnuMatrix = new import_core7.Matrix4();
 function getLodStatus(tile, frameState) {
   if (tile.lodMetricValue === 0 || Number.isNaN(tile.lodMetricValue)) {
     return "DIG";
@@ -1377,7 +3113,6 @@ 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;
@@ -1418,7 +3153,7 @@ var ManagedArray = class {
    * @param {Number} index The index to get.
    */
   get(index) {
-    (0, import_loader_utils5.assert)(index < this._array.length);
+    assert(index < this._array.length);
     return this._array[index];
   }
   /**
@@ -1428,7 +3163,7 @@ var ManagedArray = class {
    * @param {*} element The element to set at index.
    */
   set(index, element) {
-    (0, import_loader_utils5.assert)(index >= 0);
+    assert(index >= 0);
     if (index >= this.length) {
       this.length = index + 1;
     }
@@ -1482,7 +3217,7 @@ var ManagedArray = class {
    * @param {Number} length The length.
    */
   reserve(length) {
-    (0, import_loader_utils5.assert)(length >= 0);
+    assert(length >= 0);
     if (length > this._array.length) {
       this._array.length = length;
     }
@@ -1493,7 +3228,7 @@ var ManagedArray = class {
    * @param {Number} length The length.
    */
   resize(length) {
-    (0, import_loader_utils5.assert)(length >= 0);
+    assert(length >= 0);
     this.length = length;
   }
   /**
@@ -1518,7 +3253,7 @@ var ManagedArray = class {
 };
 
 // dist/tileset-3d/common/tileset-traverser.js
-var DEFAULT_PROPS2 = {
+var DEFAULT_PROPS4 = {
   loadSiblings: false,
   skipLevelOfDetail: false,
   updateTransforms: true,
@@ -1535,9 +3270,11 @@ var TilesetTraverser = class {
   selectedTiles = {};
   // tiles should be loaded from server
   requestedTiles = {};
+  /** Tiles intentionally held until the camera has remained still for the configured delay. */
+  deferredTiles = {};
   // tiles does not have render content
   emptyTiles = {};
-  lastUpdate = new Date().getTime();
+  lastUpdate = (/* @__PURE__ */ new Date()).getTime();
   updateDebounceTime = 1e3;
   /** temporary storage to hold the traversed tiles during a traversal */
   _traversalStack = new ManagedArray();
@@ -1550,7 +3287,7 @@ var TilesetTraverser = class {
   }
   // TODO nested props
   constructor(options) {
-    this.options = { ...DEFAULT_PROPS2, ...options };
+    this.options = { ...DEFAULT_PROPS4, ...options };
   }
   // tiles should be visible
   traverse(root, frameState, options) {
@@ -1563,6 +3300,7 @@ var TilesetTraverser = class {
   }
   reset() {
     this.requestedTiles = {};
+    this.deferredTiles = {};
     this.selectedTiles = {};
     this.emptyTiles = {};
     this._traversalStack.reset();
@@ -1610,7 +3348,7 @@ var TilesetTraverser = class {
       this.touchTile(tile, frameState);
       tile._shouldRefine = shouldRefine && parentRefines;
     }
-    const newTime = new Date().getTime();
+    const newTime = (/* @__PURE__ */ new Date()).getTime();
     if (this.traversalFinished(frameState) || newTime - this.lastUpdate > this.updateDebounceTime) {
       this.lastUpdate = newTime;
       this.options.onTraversalEnd(frameState);
@@ -1676,11 +3414,28 @@ var TilesetTraverser = class {
   // tile to load from server
   loadTile(tile, frameState) {
     if (this.shouldLoadTile(tile)) {
+      if (this.shouldDeferTileRequest(tile)) {
+        this.deferredTiles[tile.id] = tile;
+        return;
+      }
       tile._requestedFrame = frameState.frameNumber;
       tile._priority = tile._getPriority();
       this.requestedTiles[tile.id] = tile;
     }
   }
+  /**
+   * Returns whether an eligible peripheral request should wait for camera motion to settle.
+   *
+   * Eligibility and the current time window are calculated together when tile visibility updates.
+   * Keeping the active state on the tile also lets a queued scheduler callback cancel work that
+   * became deferred after its original traversal.
+   *
+   * @param tile - Tile considered for loading.
+   * @returns `true` when the request should be retried after the remaining delay.
+   */
+  shouldDeferTileRequest(tile) {
+    return tile.priorityDeferred;
+  }
   // cache tile
   touchTile(tile, frameState) {
     tile.tileset._cache.touch(tile);
@@ -1742,12 +3497,17 @@ var TilesetTraverser = class {
   // Ignores visibility.
   executeEmptyTraversal(root, frameState) {
     let allDescendantsLoaded = true;
+    let hasPendingLazyChildren = false;
     const stack = this._emptyTraversalStack;
     stack.push(root);
     while (stack.length > 0) {
       const tile = stack.pop();
       const traverse = !tile.hasRenderContent && this.canTraverse(tile, frameState);
       const emptyLeaf = !tile.hasRenderContent && tile.children.length === 0;
+      if (tile.header.implicitSubtree) {
+        hasPendingLazyChildren = true;
+        allDescendantsLoaded = false;
+      }
       if (!traverse && !tile.contentAvailable && !emptyLeaf) {
         allDescendantsLoaded = false;
       }
@@ -1763,12 +3523,12 @@ var TilesetTraverser = class {
         }
       }
     }
-    return root.hasEmptyContent || allDescendantsLoaded;
+    return root.hasEmptyContent && !hasPendingLazyChildren || allDescendantsLoaded;
   }
 };
 
 // dist/tileset-3d/common/tile-3d.js
-var scratchVector2 = new import_core7.Vector3();
+var scratchVector2 = new import_core8.Vector3();
 function defined2(x) {
   return x !== void 0 && x !== null;
 }
@@ -1805,9 +3565,11 @@ var Tile3D = class {
   gpuMemoryUsageInBytes = 0;
   /** The tile's children - an array of Tile3D objects. */
   children = [];
+  /** Current lifecycle state for a lazy implicit subtree rooted at this tile. */
+  childrenState = "ready";
   depth = 0;
   viewportIds = [];
-  transform = new import_core7.Matrix4();
+  transform = new import_core8.Matrix4();
   extensions = null;
   /** TODO Cesium 3d tiles specific */
   implicitTiling = null;
@@ -1823,15 +3585,25 @@ var Tile3D = class {
   // TODO Cesium 3d tiles specific
   _expireDate = null;
   _expiredContent = null;
+  /** In-flight source request shared by repeated traversal frames. */
+  _childrenPromise = null;
   _boundingBox = void 0;
   /** updated every frame for tree traversal and rendering optimizations: */
   _distanceToCamera = 0;
   _screenSpaceError = 0;
+  /** SSE calculated at the reduced viewport height used to prioritize coarse coverage. */
+  _screenSpaceErrorProgressiveResolution = 0;
+  /** Whether this tile should be promoted into the progressive-resolution request pass. */
+  _priorityProgressiveResolution = false;
+  /** Angular distance from the camera view axis used to prioritize center tiles. */
+  _foveatedFactor = 0;
+  /** Whether this peripheral request is currently inside the camera-motion deferral window. */
+  priorityDeferred = false;
   _visibilityPlaneMask;
   _visible = void 0;
   _contentBoundingVolume;
   _viewerRequestVolume;
-  _initialTransform = new import_core7.Matrix4();
+  _initialTransform = new import_core8.Matrix4();
   // Used by traverser, cannot be marked private
   _priority = 0;
   _selectedFrame = 0;
@@ -1871,6 +3643,7 @@ var Tile3D = class {
     this.refine = this._getRefine(header.refine);
     this.type = header.type;
     this.contentUrl = header.contentUrl;
+    this.childrenState = header.implicitSubtree ? "unloaded" : "ready";
     this._initializeLodMetric(header);
     this._initializeTransforms(header);
     this._updateLodMetricScale();
@@ -1900,7 +3673,15 @@ var Tile3D = class {
   }
   /** Returns true if tile has children */
   get hasChildren() {
-    return this.children.length > 0 || this.header.children && this.header.children.length > 0;
+    return this.children.length > 0 || this.header.children && this.header.children.length > 0 || Boolean(this.header.implicitSubtree && this.childrenState !== "ready");
+  }
+  /** Returns whether traversal may request an unresolved lazy child-header group. */
+  get hasUnloadedChildren() {
+    return Boolean(this.header.implicitSubtree && (this.childrenState === "unloaded" || this.childrenState === "failed"));
+  }
+  /** Returns whether a lazy child-header request is currently in flight. */
+  get childrenLoading() {
+    return this.childrenState === "loading";
   }
   /**
    * Determines if the tile's content is ready. This is automatically `true` for
@@ -1961,13 +3742,23 @@ var Tile3D = class {
     }
     return this._boundingBox;
   }
-  /** Get the tile's screen space error. */
-  getScreenSpaceError(frameState, useParentLodMetric) {
+  /**
+   * Gets the tile's screen-space error for normal refinement or a reduced-height priority pass.
+   *
+   * I3S already supplies a screen-oriented LOD metric and intentionally ignores the optional 3D
+   * Tiles progressive-resolution height fraction.
+   *
+   * @param frameState - Current camera and viewport measurements.
+   * @param useParentLodMetric - Whether to substitute the parent LOD metric.
+   * @param viewportHeightFraction - Fraction of viewport height represented by the priority pass.
+   * @returns Screen-space LOD error for the current tileset format.
+   */
+  getScreenSpaceError(frameState, useParentLodMetric, viewportHeightFraction = 1) {
     switch (this.tileset.type) {
       case TILESET_TYPE.I3S:
         return getProjectedRadius(this, frameState);
       case TILESET_TYPE.TILES3D:
-        return getTiles3DScreenSpaceError(this, frameState, useParentLodMetric);
+        return getTiles3DScreenSpaceError(this, frameState, useParentLodMetric, viewportHeightFraction);
       default:
         throw new Error("Unsupported tileset type");
     }
@@ -1985,12 +3776,34 @@ var Tile3D = class {
   _getGpuMemoryUsageInBytes() {
     return this.content.gpuMemoryUsageInBytes || this.content.byteLength || 0;
   }
-  /*
-   * If skipLevelOfDetail is off try to load child tiles as soon as possible so that their parent can refine sooner.
-   * Tiles are prioritized by screen space error.
+  /**
+   * Returns scheduler priority for render-content requests.
+   *
+   * @returns Numeric priority, or a negative value when the queued request should be cancelled.
    */
-  // eslint-disable-next-line complexity
   _getPriority() {
+    return this._calculateRequestPriority(false);
+  }
+  /**
+   * Returns scheduler priority for lazy child-header requests.
+   *
+   * Contentless implicit placeholders intentionally retain `UNLOADED` content state, so metadata
+   * scheduling skips only that render-content cancellation check and preserves every visibility,
+   * recency, progressive, foveated, and motion-deferral rule.
+   *
+   * @returns Numeric priority, or a negative value when the queued request should be cancelled.
+   */
+  _getChildrenPriority() {
+    return this._calculateRequestPriority(true);
+  }
+  /**
+   * Calculates the common scheduler priority for content or hierarchy metadata.
+   *
+   * @param allowUnloadedContent - Whether an empty placeholder may request child metadata.
+   * @returns Numeric priority, or a negative value when the queued request should be cancelled.
+   */
+  // eslint-disable-next-line complexity
+  _calculateRequestPriority(allowUnloadedContent) {
     const traverser = this.tileset._traverser;
     const { skipLevelOfDetail } = traverser.options;
     const maySkipTile = this.refine === TILE_REFINEMENT.ADD || skipLevelOfDetail;
@@ -2000,14 +3813,23 @@ var Tile3D = class {
     if (this.tileset._frameNumber - this._touchedFrame >= 1) {
       return -1;
     }
-    if (this.contentState === TILE_CONTENT_STATE.UNLOADED) {
+    if (this.priorityDeferred) {
+      return -1;
+    }
+    if (!allowUnloadedContent && this.contentState === TILE_CONTENT_STATE.UNLOADED) {
       return -1;
     }
     const parent = this.parent;
     const useParentScreenSpaceError = parent && (!maySkipTile || this._screenSpaceError === 0 || parent.hasTilesetContent);
     const screenSpaceError = useParentScreenSpaceError ? parent._screenSpaceError : this._screenSpaceError;
     const rootScreenSpaceError = traverser.root ? traverser.root._screenSpaceError : 0;
-    return Math.max(rootScreenSpaceError - screenSpaceError, 0);
+    const reverseScreenSpaceError = Math.max(rootScreenSpaceError - screenSpaceError, 0);
+    return calculateTileRequestPriority({
+      priorityProgressiveResolution: this._priorityProgressiveResolution,
+      foveatedFactor: this._foveatedFactor,
+      reverseScreenSpaceError,
+      rootScreenSpaceError
+    });
   }
   /**
    *  Requests the tile's content.
@@ -2046,6 +3868,84 @@ var Tile3D = class {
       requestToken.done();
     }
   }
+  /**
+   * Requests and installs this tile's lazy child-header group through its source.
+   *
+   * The same request scheduler and SSE/foveated priority value used for render content are reused
+   * for subtree metadata. Repeated traversal frames share one promise, and scheduler cancellation
+   * restores the unloaded state so a later frame can retry.
+   *
+   * @param frameState - View state that made the subtree eligible for refinement.
+   * @returns Source load result, or an unloaded result if scheduling was cancelled.
+   */
+  async loadChildren(frameState) {
+    if (!this.header.implicitSubtree || this.childrenState === "ready") {
+      return { loaded: false, tileCount: 0, childSubtreeCount: 0 };
+    }
+    if (this._childrenPromise) {
+      return await this._childrenPromise;
+    }
+    if (!this.tileset.source.loadTileChildren) {
+      throw new Error("Tileset source does not support lazy tile children");
+    }
+    this.childrenState = "loading";
+    this._childrenPromise = this._loadChildrenWithScheduler(frameState);
+    try {
+      return await this._childrenPromise;
+    } finally {
+      this._childrenPromise = null;
+    }
+  }
+  /**
+   * Runs one lazy child-header load after obtaining a scheduler token.
+   *
+   * @param frameState - View state forwarded to the source implementation.
+   * @returns Source load result.
+   */
+  async _loadChildrenWithScheduler(frameState) {
+    const requestToken = await this.tileset._requestScheduler.scheduleRequest(`${this.id}:implicit-subtree`, this._getChildrenPriority.bind(this));
+    if (!requestToken) {
+      this.childrenState = "unloaded";
+      return { loaded: false, tileCount: 0, childSubtreeCount: 0 };
+    }
+    try {
+      const loadResult = await this.tileset.source.loadTileChildren(this, frameState);
+      this.childrenState = loadResult.loaded ? "ready" : "unloaded";
+      return loadResult;
+    } catch (error) {
+      this.childrenState = "failed";
+      throw error;
+    } finally {
+      requestToken.done();
+    }
+  }
+  /**
+   * Replaces a contentless implicit placeholder with its materialized subtree-root header.
+   *
+   * Transform state is intentionally preserved: the placeholder already owns the composed
+   * transform, and reapplying the root transform here would double-transform bounds and geometric
+   * error. Content and raw geometric error are reinitialized from the newly available header.
+   *
+   * @param materializedHeader - Available root header produced from one subtree resource.
+   */
+  applyImplicitSubtreeHeader(materializedHeader) {
+    const existingTransform = this.header.transform;
+    const existingTransformMatrix = this.header.transformMatrix;
+    this.header = {
+      ...this.header,
+      ...materializedHeader,
+      transform: existingTransform,
+      transformMatrix: existingTransformMatrix,
+      implicitSubtree: void 0
+    };
+    this.refine = this._getRefine(materializedHeader.refine);
+    this.type = materializedHeader.type;
+    this.contentUrl = materializedHeader.contentUrl;
+    this._initializeLodMetric(materializedHeader);
+    this._updateLodMetricScale();
+    this._initializeBoundingVolumes(this.header);
+    this._initializeContent(this.header);
+  }
   // Unloads the tile's content.
   unloadContent() {
     if (this.content && this.content.destroy) {
@@ -2071,19 +3971,64 @@ var Tile3D = class {
       return;
     }
     const parent = this.parent;
-    const parentVisibilityPlaneMask = parent ? parent._visibilityPlaneMask : import_culling3.CullingVolume.MASK_INDETERMINATE;
+    const parentVisibilityPlaneMask = parent ? parent._visibilityPlaneMask : import_culling4.CullingVolume.MASK_INDETERMINATE;
     if (this.tileset._traverser.options.updateTransforms) {
       const parentTransform = parent ? parent.computedTransform : this.tileset.modelMatrix;
       this._updateTransform(parentTransform);
     }
     this._distanceToCamera = this.distanceToTile(frameState);
     this._screenSpaceError = this.getScreenSpaceError(frameState, false);
+    this._updateRequestPriorityMetrics(frameState);
     this._visibilityPlaneMask = this.visibility(frameState, parentVisibilityPlaneMask);
-    this._visible = this._visibilityPlaneMask !== import_culling3.CullingVolume.MASK_OUTSIDE;
+    this._visible = this._visibilityPlaneMask !== import_culling4.CullingVolume.MASK_OUTSIDE;
     this._inRequestVolume = this.insideViewerRequestVolume(frameState);
     this._frameNumber = frameState.frameNumber;
     this.viewportIds = viewportIds;
   }
+  /**
+   * Updates progressive-resolution and foveated request metrics for a 3D Tiles traversal frame.
+   *
+   * I3S retains its format-specific screen-threshold ordering and is explicitly isolated from
+   * geometric-error scheduling. Orthographic viewports still receive progressive coverage, but
+   * angular foveation is disabled because an orthographic frustum has no perspective field of view.
+   *
+   * @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;
+      this._foveatedFactor = 0;
+      this.priorityDeferred = false;
+      return;
+    }
+    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._foveatedFactor = 0;
+      this.priorityDeferred = false;
+      return;
+    }
+    this._foveatedFactor = calculateFoveatedFactor(this.boundingVolume, frameState.camera);
+    const deferralEligible = isFoveatedRequestDeferred({
+      refinement: this.refine,
+      skipLevelOfDetail: this.tileset._traverser.options.skipLevelOfDetail,
+      foveatedScreenSpaceError: options.foveatedScreenSpaceError,
+      foveatedConeSize: options.foveatedConeSize,
+      minimumScreenSpaceErrorRelaxation: options.foveatedMinimumScreenSpaceErrorRelaxation,
+      interpolationCallback: options.foveatedInterpolationCallback,
+      foveatedFactor: this._foveatedFactor,
+      verticalFieldOfView: frameState.camera.verticalFieldOfView,
+      screenSpaceError: this._screenSpaceError,
+      parentScreenSpaceError: (_e = this.parent) == null ? void 0 : _e._screenSpaceError,
+      maximumScreenSpaceError: this.tileset.memoryAdjustedScreenSpaceError,
+      priorityProgressiveResolution: this._priorityProgressiveResolution
+    });
+    this.priorityDeferred = isFoveatedRequestDelayActive(deferralEligible, frameState.camera.timeSinceMovement, options.foveatedTimeDelay);
+  }
   // Determines whether the tile's bounding volume intersects the culling volume.
   // @param {FrameState} frameState The frame state.
   // @param {Number} parentVisibilityPlaneMask The parent's plane mask to speed up the visibility check.
@@ -2160,13 +4105,13 @@ var Tile3D = class {
     this.lodMetricValue = this._unscaledLodMetricValue;
   }
   _initializeTransforms(tileHeader) {
-    this.transform = tileHeader.transform ? new import_core7.Matrix4(tileHeader.transform) : new import_core7.Matrix4();
+    this.transform = tileHeader.transform ? new import_core8.Matrix4(tileHeader.transform) : new import_core8.Matrix4();
     const parent = this.parent;
     const tileset = this.tileset;
     const parentTransform = parent && parent.computedTransform ? parent.computedTransform.clone() : tileset.modelMatrix.clone();
-    this.computedTransform = new import_core7.Matrix4(parentTransform).multiplyRight(this.transform);
-    const parentInitialTransform = parent && parent._initialTransform ? parent._initialTransform.clone() : new import_core7.Matrix4();
-    this._initialTransform = new import_core7.Matrix4(parentInitialTransform).multiplyRight(this.transform);
+    this.computedTransform = new import_core8.Matrix4(parentTransform).multiplyRight(this.transform);
+    const parentInitialTransform = parent && parent._initialTransform ? parent._initialTransform.clone() : new import_core8.Matrix4();
+    this._initialTransform = new import_core8.Matrix4(parentInitialTransform).multiplyRight(this.transform);
   }
   /**
    * Updates the world-space LOD metric from the source metric and the complete tile transform.
@@ -2210,7 +4155,11 @@ var Tile3D = class {
     this._distanceToCamera = 0;
     this._centerZDepth = 0;
     this._screenSpaceError = 0;
-    this._visibilityPlaneMask = import_culling3.CullingVolume.MASK_INDETERMINATE;
+    this._screenSpaceErrorProgressiveResolution = 0;
+    this._priorityProgressiveResolution = false;
+    this._foveatedFactor = 0;
+    this.priorityDeferred = false;
+    this._visibilityPlaneMask = import_culling4.CullingVolume.MASK_INDETERMINATE;
     this._visible = void 0;
     this._inRequestVolume = false;
     this._stackLength = 0;
@@ -2225,8 +4174,16 @@ var Tile3D = class {
   _getRefine(refine) {
     return refine || this.parent && this.parent.refine || TILE_REFINEMENT.REPLACE;
   }
+  /**
+   * Returns whether loaded content is an external tileset.
+   *
+   * Parsed shape is authoritative because valid external resources may be extensionless, signed,
+   * or use a misleading filename. This method is called only after source loading has populated
+   * `content`.
+   */
   _isTileset() {
-    return this.contentUrl.indexOf(".json") !== -1;
+    var _a;
+    return ((_a = this.content) == null ? void 0 : _a.shape) === "tileset3d";
   }
   _onContentLoaded() {
     switch (this.content && this.content.type) {
@@ -2244,6 +4201,9 @@ var Tile3D = class {
   }
   _updateBoundingVolume(header) {
     this.boundingVolume = createBoundingVolume(header.boundingVolume, this.computedTransform, this.boundingVolume);
+    if (header.viewerRequestVolume) {
+      this._viewerRequestVolume = createBoundingVolume(header.viewerRequestVolume, this.computedTransform, this._viewerRequestVolume);
+    }
     const content = header.content;
     if (!content) {
       return;
@@ -2251,15 +4211,12 @@ var Tile3D = class {
     if (content.boundingVolume) {
       this._contentBoundingVolume = createBoundingVolume(content.boundingVolume, this.computedTransform, this._contentBoundingVolume);
     }
-    if (header.viewerRequestVolume) {
-      this._viewerRequestVolume = createBoundingVolume(header.viewerRequestVolume, this.computedTransform, this._viewerRequestVolume);
-    }
   }
   /**
    * Updates the tile's computed transform, world-space geometric error, and bounding volumes.
    * @param parentTransform - Current computed transform of the parent tile or tileset.
    */
-  _updateTransform(parentTransform = new import_core7.Matrix4()) {
+  _updateTransform(parentTransform = new import_core8.Matrix4()) {
     const computedTransform = parentTransform.clone().multiplyRight(this.transform);
     const didTransformChange = !computedTransform.equals(this.computedTransform);
     if (!didTransformChange) {
@@ -2272,15 +4229,77 @@ var Tile3D = class {
 };
 
 // dist/tileset-3d/format-3d-tiles/tiles-3d-source.js
-var import_loader_utils6 = require("@loaders.gl/loader-utils");
 var import_geospatial7 = require("@math.gl/geospatial");
-var import_core9 = require("@math.gl/core");
+var import_core10 = require("@math.gl/core");
 
 // dist/tileset-3d/format-3d-tiles/tileset-3d-traverser.js
 var Tileset3DTraverser = class extends TilesetTraverser {
+  /** Pending implicit subtree requests keyed by viewport and tile identity. */
+  pendingImplicitSubtrees = /* @__PURE__ */ new Map();
+  /**
+   * Reports whether every implicit subtree request started by this viewport traversal has settled.
+   *
+   * @param frameState - Traversal frame whose completion callback is being considered.
+   * @returns `true` when no matching subtree metadata request remains pending.
+   */
+  traversalFinished(frameState) {
+    const viewportPrefix = `${frameState.viewport.id}:`;
+    for (const [requestKey, frameNumber] of this.pendingImplicitSubtrees) {
+      if (requestKey.startsWith(viewportPrefix) && frameNumber === frameState.frameNumber) {
+        return false;
+      }
+    }
+    return true;
+  }
   compareDistanceToCamera(a, b) {
     return b._distanceToCamera === 0 && a._distanceToCamera === 0 ? b._centerZDepth - a._centerZDepth : b._distanceToCamera - a._distanceToCamera;
   }
+  /**
+   * Starts an implicit subtree request only after culling, request-volume, and SSE eligibility.
+   *
+   * The current parent remains the traversal boundary while metadata is loading, which preserves
+   * REPLACE coverage and ADD accumulation. Request scheduling reads the tile's existing
+   * progressive-resolution and foveated metrics, so subtree metadata follows the same priority
+   * policy as render content. A completion notification lets the owning tileset publish the newly
+   * materialized traversal result on the next update.
+   *
+   * @param tile - Tile whose existing or lazy children should be updated.
+   * @param frameState - Current culling and LOD state.
+   */
+  updateChildTiles(tile, frameState) {
+    if (tile.hasUnloadedChildren && tile.isVisibleAndInRequestVolume && this.shouldRefine(tile, frameState)) {
+      const requestKey = `${frameState.viewport.id}:${tile.id}`;
+      if (!this.pendingImplicitSubtrees.has(requestKey)) {
+        this.pendingImplicitSubtrees.set(requestKey, frameState.frameNumber);
+        void tile.tileset._loadTileChildren(tile, frameState).finally(() => {
+          this.handleImplicitSubtreeLoad(tile, frameState, requestKey);
+        });
+      }
+    }
+    super.updateChildTiles(tile, frameState);
+  }
+  /**
+   * Resumes the same traversal frame after one lazy subtree request settles.
+   *
+   * Successful materialization traverses the new headers immediately. Failed or scheduler-cancelled
+   * requests finish the current traversal without retrying in a tight loop; a later application
+   * update may retry them.
+   *
+   * @param tile - Subtree-root tile whose request settled.
+   * @param frameState - Frame that started the request.
+   * @param requestKey - Viewport-scoped pending-request identity.
+   */
+  handleImplicitSubtreeLoad(tile, frameState, requestKey) {
+    this.pendingImplicitSubtrees.delete(requestKey);
+    if (this._frameNumber !== frameState.frameNumber) {
+      return;
+    }
+    if (tile.childrenState === "ready") {
+      this.executeTraversal(tile, frameState);
+    } else if (this.traversalFinished(frameState)) {
+      this.options.onTraversalEnd(frameState);
+    }
+  }
   updateTileVisibility(tile, frameState) {
     super.updateTileVisibility(tile, frameState);
     if (!tile.isVisibleAndInRequestVolume) {
@@ -2316,19 +4335,19 @@ var Tileset3DTraverser = class extends TilesetTraverser {
 };
 
 // dist/tileset-3d/helpers/zoom.js
-var import_core8 = require("@math.gl/core");
-var import_culling4 = require("@math.gl/culling");
+var import_core9 = require("@math.gl/core");
+var import_culling5 = require("@math.gl/culling");
 var import_geospatial6 = require("@math.gl/geospatial");
 var WGS84_RADIUS_X = 6378137;
 var WGS84_RADIUS_Y = 6378137;
 var WGS84_RADIUS_Z = 6356752314245179e-9;
-var scratchVector3 = new import_core8.Vector3();
+var scratchVector3 = new import_core9.Vector3();
 function getZoomFromBoundingVolume(boundingVolume, cartorgraphicCenter) {
-  if (boundingVolume instanceof import_culling4.OrientedBoundingBox) {
+  if (boundingVolume instanceof import_culling5.OrientedBoundingBox) {
     const { halfAxes } = boundingVolume;
     const obbSize = getObbSize(halfAxes);
     return Math.log2(WGS84_RADIUS_Z / (obbSize + cartorgraphicCenter[2]));
-  } else if (boundingVolume instanceof import_culling4.BoundingSphere) {
+  } else if (boundingVolume instanceof import_culling5.BoundingSphere) {
     const { radius } = boundingVolume;
     return Math.log2(WGS84_RADIUS_Z / (radius + cartorgraphicCenter[2]));
   } else if (boundingVolume.width && boundingVolume.height) {
@@ -2357,6 +4376,220 @@ function getObbSize(halfAxes) {
   return size;
 }
 
+// dist/tileset-3d/format-3d-tiles/implicit-tiling.js
+var QUADTREE_CHILD_COUNT = 4;
+var OCTREE_CHILD_COUNT = 8;
+function createImplicitSubtreeReference(descriptor, coordinates) {
+  return {
+    coordinates,
+    subtreeUrl: replaceImplicitUrlTemplate(descriptor.subtreesUrlTemplate, coordinates),
+    descriptor
+  };
+}
+function materializeImplicitSubtree(subtree, reference) {
+  const { descriptor } = reference;
+  validateImplicitDescriptor(descriptor);
+  const counters = { tileCount: 0, childSubtreeCount: 0 };
+  const root = materializeAvailableTile(subtree, reference, { localLevel: 0, mortonIndex: 0 }, reference.coordinates, counters);
+  if (!root) {
+    throw new Error(`Invalid 3D Tiles subtree: root tile is unavailable at ${reference.subtreeUrl}`);
+  }
+  return { root, ...counters };
+}
+function replaceImplicitUrlTemplate(templateUrl, coordinates) {
+  const values = {
+    level: coordinates.level,
+    x: coordinates.x,
+    y: coordinates.y,
+    z: coordinates.z
+  };
+  return templateUrl.replace(/{(level|x|y|z)}/gi, (_match, coordinateName) => String(values[coordinateName.toLowerCase()]));
+}
+function materializeAvailableTile(subtree, reference, localCoordinates, globalCoordinates, counters) {
+  const { descriptor } = reference;
+  const childCount = getImplicitChildCount(descriptor.subdivisionScheme);
+  const availabilityIndex = getLevelOffset(childCount, localCoordinates.localLevel) + localCoordinates.mortonIndex;
+  if (!getAvailabilityValue(subtree.tileAvailability, availabilityIndex)) {
+    return null;
+  }
+  counters.tileCount++;
+  const contentAvailable = getAvailabilityValue(getPrimaryContentAvailability(subtree.contentAvailability), availabilityIndex);
+  const children = [];
+  if (globalCoordinates.level < descriptor.maximumLevel) {
+    if (localCoordinates.localLevel + 1 < descriptor.subtreeLevels) {
+      for (let childIndex = 0; childIndex < childCount; childIndex++) {
+        const childCoordinates = getChildCoordinates(globalCoordinates, childIndex, descriptor.subdivisionScheme);
+        const childHeader = materializeAvailableTile(subtree, reference, {
+          localLevel: localCoordinates.localLevel + 1,
+          mortonIndex: localCoordinates.mortonIndex * childCount + childIndex
+        }, childCoordinates, counters);
+        if (childHeader) {
+          children.push(childHeader);
+        }
+      }
+    } else {
+      for (let childIndex = 0; childIndex < childCount; childIndex++) {
+        const childSubtreeIndex = localCoordinates.mortonIndex * childCount + childIndex;
+        if (getAvailabilityValue(subtree.childSubtreeAvailability, childSubtreeIndex)) {
+          const childCoordinates = getChildCoordinates(globalCoordinates, childIndex, descriptor.subdivisionScheme);
+          children.push(createLazyImplicitTileHeader(descriptor, childCoordinates));
+          counters.childSubtreeCount++;
+        }
+      }
+    }
+  }
+  return formatImplicitTileHeader(descriptor, reference, globalCoordinates, contentAvailable, children);
+}
+function createLazyImplicitTileHeader(descriptor, coordinates) {
+  const reference = createImplicitSubtreeReference(descriptor, coordinates);
+  return {
+    id: getImplicitTileId(reference, coordinates),
+    children: [],
+    implicitSubtree: reference,
+    boundingVolume: calculateImplicitBoundingVolume(descriptor.rootBoundingVolume, coordinates, descriptor.subdivisionScheme),
+    geometricError: descriptor.rootLodMetricValue / 2 ** coordinates.level,
+    lodMetricType: descriptor.lodMetricType,
+    lodMetricValue: descriptor.rootLodMetricValue / 2 ** coordinates.level,
+    refine: descriptor.refine,
+    type: TILE_TYPE.EMPTY
+  };
+}
+function formatImplicitTileHeader(descriptor, reference, coordinates, contentAvailable, children) {
+  const contentUrl = contentAvailable && descriptor.contentUrlTemplate ? replaceImplicitUrlTemplate(descriptor.contentUrlTemplate, coordinates) : void 0;
+  const lodMetricValue = descriptor.rootLodMetricValue / 2 ** coordinates.level;
+  return {
+    id: getImplicitTileId(reference, coordinates),
+    children,
+    contentUrl,
+    content: contentUrl ? { ...descriptor.contentHeader, uri: contentUrl } : void 0,
+    refine: descriptor.refine,
+    type: getImplicitTileType(contentUrl),
+    lodMetricType: descriptor.lodMetricType,
+    lodMetricValue,
+    geometricError: lodMetricValue,
+    boundingVolume: calculateImplicitBoundingVolume(descriptor.rootBoundingVolume, coordinates, descriptor.subdivisionScheme)
+  };
+}
+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") {
+    return Boolean(availability.constant);
+  }
+  const bitstream = availability == null ? void 0 : availability.explicitBitstream;
+  if (!bitstream) {
+    return false;
+  }
+  const byteIndex = Math.floor(index / 8);
+  const bitIndex = index % 8;
+  return Boolean(bitstream[byteIndex] >> bitIndex & 1);
+}
+function getPrimaryContentAvailability(availability) {
+  return Array.isArray(availability) ? availability[0] || { constant: 0 } : availability || { constant: 0 };
+}
+function getLevelOffset(childCount, localLevel) {
+  return (childCount ** localLevel - 1) / (childCount - 1);
+}
+function getChildCoordinates(parent, childIndex, subdivisionScheme) {
+  return {
+    level: parent.level + 1,
+    x: parent.x * 2 + (childIndex & 1),
+    y: parent.y * 2 + (childIndex >> 1 & 1),
+    z: subdivisionScheme === "OCTREE" ? parent.z * 2 + (childIndex >> 2 & 1) : 0
+  };
+}
+function getImplicitChildCount(subdivisionScheme) {
+  return subdivisionScheme === "OCTREE" ? OCTREE_CHILD_COUNT : QUADTREE_CHILD_COUNT;
+}
+function calculateImplicitBoundingVolume(rootBoundingVolume, coordinates, subdivisionScheme) {
+  if (rootBoundingVolume.region) {
+    const [west, south, east, north, minimumHeight, maximumHeight] = rootBoundingVolume.region;
+    const divisionCount = 2 ** coordinates.level;
+    const longitudeSize = (east - west) / divisionCount;
+    const latitudeSize = (north - south) / divisionCount;
+    const childWest = west + longitudeSize * coordinates.x;
+    const childSouth = south + latitudeSize * coordinates.y;
+    let childMinimumHeight = minimumHeight;
+    let childMaximumHeight = maximumHeight;
+    if (subdivisionScheme === "OCTREE") {
+      const heightSize = (maximumHeight - minimumHeight) / divisionCount;
+      childMinimumHeight = minimumHeight + heightSize * coordinates.z;
+      childMaximumHeight = childMinimumHeight + heightSize;
+    }
+    return {
+      region: [
+        childWest,
+        childSouth,
+        childWest + longitudeSize,
+        childSouth + latitudeSize,
+        childMinimumHeight,
+        childMaximumHeight
+      ]
+    };
+  }
+  if (rootBoundingVolume.box) {
+    if (rootBoundingVolume.s2VolumeInfo) {
+      return { box: [...rootBoundingVolume.box], s2VolumeInfo: rootBoundingVolume.s2VolumeInfo };
+    }
+    const box = rootBoundingVolume.box;
+    const divisionCount = 2 ** coordinates.level;
+    const xOffset = -1 + (2 * coordinates.x + 1) / divisionCount;
+    const yOffset = -1 + (2 * coordinates.y + 1) / divisionCount;
+    const zOffset = -1 + (2 * coordinates.z + 1) / divisionCount;
+    const divideHeight = subdivisionScheme === "OCTREE";
+    const center = [
+      box[0] + box[3] * xOffset + box[6] * yOffset + (divideHeight ? box[9] * zOffset : 0),
+      box[1] + box[4] * xOffset + box[7] * yOffset + (divideHeight ? box[10] * zOffset : 0),
+      box[2] + box[5] * xOffset + box[8] * yOffset + (divideHeight ? box[11] * zOffset : 0)
+    ];
+    return {
+      box: [
+        ...center,
+        box[3] / divisionCount,
+        box[4] / divisionCount,
+        box[5] / divisionCount,
+        box[6] / divisionCount,
+        box[7] / divisionCount,
+        box[8] / divisionCount,
+        divideHeight ? box[9] / divisionCount : box[9],
+        divideHeight ? box[10] / divisionCount : box[10],
+        divideHeight ? box[11] / divisionCount : box[11]
+      ]
+    };
+  }
+  throw new Error(`Unsupported implicit 3D Tiles bounding volume: ${JSON.stringify(rootBoundingVolume)}`);
+}
+function getImplicitTileType(contentUrl) {
+  var _a;
+  if (!contentUrl) {
+    return TILE_TYPE.EMPTY;
+  }
+  const extension = (_a = contentUrl.split("?")[0].split(".").pop()) == null ? void 0 : _a.toLowerCase();
+  switch (extension) {
+    case "pnts":
+      return TILE_TYPE.POINTCLOUD;
+    case "i3dm":
+    case "b3dm":
+    case "glb":
+    case "gltf":
+      return TILE_TYPE.SCENEGRAPH;
+    default:
+      return extension || TILE_TYPE.EMPTY;
+  }
+}
+function validateImplicitDescriptor(descriptor) {
+  if (descriptor.subdivisionScheme !== "QUADTREE" && descriptor.subdivisionScheme !== "OCTREE") {
+    throw new Error(`Unsupported implicit subdivision scheme: ${descriptor.subdivisionScheme}`);
+  }
+  if (!Number.isInteger(descriptor.subtreeLevels) || descriptor.subtreeLevels < 1) {
+    throw new Error("Implicit subtreeLevels must be a positive integer");
+  }
+  if (!Number.isInteger(descriptor.maximumLevel) || descriptor.maximumLevel < 0) {
+    throw new Error("Implicit availableLevels must describe at least the root level");
+  }
+}
+
 // dist/tileset-3d/format-3d-tiles/tiles-3d-source.js
 var EMPTY_CONTENT_FORMATS = {
   draco: false,
@@ -2364,6 +4597,7 @@ var EMPTY_CONTENT_FORMATS = {
   dds: false,
   ktx2: false
 };
+var DEFAULT_MAXIMUM_CACHED_SUBTREES = 32;
 var Tiles3DSource = class {
   /** 3D Tiles format discriminator. */
   type = TILESET_TYPE.TILES3D;
@@ -2392,6 +4626,23 @@ var Tiles3DSource = class {
   /** Normalized source metadata after initialization. */
   metadata;
   queryParams = {};
+  /** Final request URLs cached by unmodified tile content URL. */
+  tileUrlCache = /* @__PURE__ */ new Map();
+  /** Parsed subtree promises keyed by final source URL for request deduplication and LRU reuse. */
+  implicitSubtreeCache = /* @__PURE__ */ new Map();
+  /** URLs whose subtree resource requests have not settled. */
+  pendingImplicitSubtreeUrls = /* @__PURE__ */ new Set();
+  /** Maximum number of settled parsed subtrees retained by this source. */
+  maximumCachedSubtrees;
+  /** Mutable counters exposed as a defensive snapshot through {@link getImplicitTilingStats}. */
+  implicitTilingStats = {
+    requestedSubtrees: 0,
+    loadedSubtrees: 0,
+    cacheHits: 0,
+    materializedTiles: 0
+  };
+  /** Whether the owning tileset has released this source. */
+  destroyed = false;
   extensionsUsed = [];
   resolver;
   rootTileset;
@@ -2401,15 +4652,30 @@ 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 || import_loader_utils6.path.dirname(request.url);
+    this.basePath = request.basePath || path_exports.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);
+    this.maximumCachedSubtrees = Number.isFinite(maximumCachedSubtrees) ? Math.max(0, Math.floor(maximumCachedSubtrees)) : DEFAULT_MAXIMUM_CACHED_SUBTREES;
+  }
+  /**
+   * Releases URL and parsed-subtree caches and blocks late subtree installation.
+   *
+   * The injected resolver or core API remains responsible for transport-level abort signals. A
+   * request that cannot be aborted may finish parsing, but it will not mutate destroyed tiles.
+   */
+  destroy() {
+    this.destroyed = true;
+    this.tileUrlCache.clear();
+    this.implicitSubtreeCache.clear();
+    this.pendingImplicitSubtreeUrls.clear();
   }
   /**
    * Fetches and validates top-level metadata, then normalizes common fields used by {@link Tileset3D}.
@@ -2429,7 +4695,9 @@ var Tiles3DSource = class {
     this.tileset = this.rootTileset;
     if (this.rootTileset.queryString) {
       const searchParams = new URLSearchParams(this.rootTileset.queryString);
-      Object.assign(this.queryParams, Object.fromEntries(searchParams.entries()));
+      for (const [parameterName, parameterValue] of searchParams.entries()) {
+        this.setQueryParameter(parameterName, parameterValue);
+      }
     }
     this.asset = this.rootTileset.asset;
     if (!this.asset) {
@@ -2439,7 +4707,7 @@ var Tiles3DSource = class {
       throw new Error("The tileset must be 3D Tiles version either 0.0 or 1.0 or 1.1.");
     }
     if ("tilesetVersion" in this.asset) {
-      this.queryParams.v = this.asset.tilesetVersion;
+      this.setQueryParameter("v", this.asset.tilesetVersion);
     }
     this.properties = this.rootTileset.properties;
     this.extras = this.rootTileset.extras;
@@ -2472,7 +4740,7 @@ var Tiles3DSource = class {
     return this.getMetadata().tileset;
   }
   /**
-   * Builds the eager runtime tile tree for a 3D Tiles subtree.
+   * Builds explicit runtime headers while leaving implicit subtree references lazy.
    */
   initializeTileHeaders(tileset, tilesetJson, parentTile) {
     var _a;
@@ -2492,7 +4760,7 @@ var Tiles3DSource = class {
           const url = new URL(childTile.contentUrl);
           const session = url.searchParams.get("session");
           if (session) {
-            this.queryParams.session = session;
+            this.setQueryParameter("session", session);
           }
         }
         tile.children.push(childTile);
@@ -2518,7 +4786,9 @@ var Tiles3DSource = class {
       ...this.loadOptions,
       [this.loader.id]: {
         ...tilesetLoaderOptions,
-        isTileset: tile.type === "json",
+        // Content bytes, rather than URL suffixes, distinguish external tilesets from renderable
+        // payloads. This is required for signed and extensionless resources.
+        isTileset: "auto",
         assetGltfUpAxis: this.asset && this.asset.gltfUpAxis || "Y"
       }
     };
@@ -2526,17 +4796,77 @@ var Tiles3DSource = class {
     tile.content = content;
     return {
       loaded: true,
-      nestedTileset: tile.contentUrl.includes(".json") ? content : void 0
+      nestedTileset: (content == null ? void 0 : content.shape) === "tileset3d" ? content : void 0
+    };
+  }
+  /**
+   * Loads, materializes, and installs exactly one implicit subtree.
+   *
+   * Final URLs pass through the same query inheritance and archive/custom resolver path as render
+   * content. Parsed resources are deduplicated by final URL, while the pure materializer creates
+   * lazy placeholders for every available child subtree instead of recursively fetching them.
+   *
+   * @param tile - Existing contentless subtree-root placeholder.
+   * @param frameState - View state that made this request eligible; priority is consumed earlier.
+   * @returns Counts describing the installed subtree.
+   */
+  async loadTileChildren(tile, frameState) {
+    void frameState;
+    const reference = tile.header.implicitSubtree;
+    if (!reference) {
+      return { loaded: false, tileCount: 0, childSubtreeCount: 0 };
+    }
+    const subtreeUrl = this.getTileUrl(reference.subtreeUrl);
+    const subtree = await this.loadImplicitSubtreeResource(subtreeUrl);
+    if (this.destroyed || tile.isDestroyed()) {
+      return { loaded: false, tileCount: 0, childSubtreeCount: 0 };
+    }
+    const materializedSubtree = materializeImplicitSubtree(subtree, {
+      ...reference,
+      subtreeUrl
+    });
+    tile.applyImplicitSubtreeHeader(materializedSubtree.root);
+    const materializedTileCount = this.initializeMaterializedChildren(tile.tileset, tile, materializedSubtree.root.children);
+    this.implicitTilingStats.loadedSubtrees++;
+    this.implicitTilingStats.materializedTiles += materializedTileCount;
+    return {
+      loaded: true,
+      tileCount: materializedSubtree.tileCount,
+      childSubtreeCount: materializedSubtree.childSubtreeCount
+    };
+  }
+  /**
+   * Returns a snapshot of implicit-subtree request, cache, and materialization counters.
+   *
+   * @returns Immutable-by-convention diagnostic values for runtime inspection.
+   */
+  getImplicitTilingStats() {
+    return {
+      ...this.implicitTilingStats,
+      cachedSubtrees: this.implicitSubtreeCache.size - this.pendingImplicitSubtreeUrls.size,
+      pendingSubtrees: this.pendingImplicitSubtreeUrls.size
     };
   }
   /**
    * Resolves a tile content URL with source-managed query parameters.
+   *
+   * Existing per-resource parameters take precedence over inherited root, version, and session
+   * values. Completed URLs are cached by the original tile path; {@link setQueryParameter}
+   * invalidates the cache before changed source state can be observed.
+   *
+   * @param tilePath - Unmodified absolute content URL or data URL from the tile header.
+   * @returns Content URL with any missing source parameters appended.
    */
   getTileUrl(tilePath) {
     if (tilePath.startsWith("data:")) {
       return tilePath;
     }
+    const cachedTileUrl = this.tileUrlCache.get(tilePath);
+    if (cachedTileUrl) {
+      return cachedTileUrl;
+    }
     if (!Object.keys(this.queryParams).length) {
+      this.tileUrlCache.set(tilePath, tilePath);
       return tilePath;
     }
     const [pathWithoutQuery, existingQuery = ""] = tilePath.split("?");
@@ -2547,7 +4877,26 @@ var Tiles3DSource = class {
       }
     }
     const queryParams = mergedQueryParams.toString();
-    return queryParams ? `${pathWithoutQuery}?${queryParams}` : pathWithoutQuery;
+    const tileUrl = queryParams ? `${pathWithoutQuery}?${queryParams}` : pathWithoutQuery;
+    this.tileUrlCache.set(tilePath, tileUrl);
+    return tileUrl;
+  }
+  /**
+   * Updates an inherited source query parameter and invalidates derived request URLs.
+   *
+   * Root tokens and tileset versions normally settle during initialization. Some providers expose
+   * a session parameter on a child URL, so invalidation is required to prevent URLs cached earlier
+   * in header construction from retaining stale authentication state.
+   *
+   * @param parameterName - Query parameter name.
+   * @param parameterValue - Query parameter value.
+   */
+  setQueryParameter(parameterName, parameterValue) {
+    if (this.queryParams[parameterName] === parameterValue) {
+      return;
+    }
+    this.queryParams[parameterName] = parameterValue;
+    this.tileUrlCache.clear();
   }
   /**
    * Derives the default view state from the root bounding volume.
@@ -2564,10 +4913,10 @@ var Tiles3DSource = class {
     const { center } = rootTile.boundingVolume;
     let cartographicCenter;
     if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) {
-      cartographicCenter = new import_core9.Vector3();
+      cartographicCenter = new import_core10.Vector3();
       import_geospatial7.Ellipsoid.WGS84.cartesianToCartographic(center, cartographicCenter);
     } else {
-      cartographicCenter = new import_core9.Vector3(0, 0, -import_geospatial7.Ellipsoid.WGS84.radii[0]);
+      cartographicCenter = new import_core10.Vector3(0, 0, -import_geospatial7.Ellipsoid.WGS84.radii[0]);
     }
     return {
       asset: this.asset,
@@ -2608,11 +4957,11 @@ var Tiles3DSource = class {
   /**
    * Loads data through injected core APIs so this module stays independent from `@loaders.gl/core`.
    */
-  async loadWithCoreApi(url, options) {
+  async loadWithCoreApi(url, options, loader = this.loader) {
     if (!this.coreApi) {
       throw new Error("Tiles3DSource requires an injected coreApi to load tileset data");
     }
-    return await this.coreApi.load(url, this.loader, options);
+    return await this.coreApi.load(url, loader, options);
   }
   /**
    * Loads data through an injected resolver when present, otherwise through the injected core API.
@@ -2624,13 +4973,92 @@ var Tiles3DSource = class {
     return await this.loadWithCoreApi(url, options);
   }
   /**
-   * Loads tile content through an injected resolver when present, otherwise through the injected core API.
+   * Loads an arbitrary source resource through an injected resolver or core API.
    */
-  async loadResourceData(url, options) {
+  async loadResourceData(url, options, loader = this.loader) {
     if (this.resolver) {
-      return await this.resolver.loadResource(url, this.loader, options);
+      return await this.resolver.loadResource(url, loader, options);
+    }
+    return await this.loadWithCoreApi(url, options, loader);
+  }
+  /**
+   * Returns a parsed subtree from the LRU cache or starts one source-managed request.
+   *
+   * @param subtreeUrl - Final subtree URL after query inheritance.
+   * @returns Parsed subtree availability data.
+   */
+  async loadImplicitSubtreeResource(subtreeUrl) {
+    const cachedSubtree = this.implicitSubtreeCache.get(subtreeUrl);
+    if (cachedSubtree) {
+      this.implicitTilingStats.cacheHits++;
+      this.implicitSubtreeCache.delete(subtreeUrl);
+      this.implicitSubtreeCache.set(subtreeUrl, cachedSubtree);
+      return await cachedSubtree;
+    }
+    this.implicitTilingStats.requestedSubtrees++;
+    this.pendingImplicitSubtreeUrls.add(subtreeUrl);
+    const loaderOptions = this.loadOptions[this.loader.id] || {};
+    const subtreePromise = this.loadResourceData(subtreeUrl, {
+      ...this.loadOptions,
+      [this.loader.id]: {
+        ...loaderOptions,
+        isTileset: false,
+        isSubtree: true
+      }
+    });
+    this.implicitSubtreeCache.set(subtreeUrl, subtreePromise);
+    try {
+      return await subtreePromise;
+    } catch (error) {
+      this.implicitSubtreeCache.delete(subtreeUrl);
+      throw error;
+    } finally {
+      this.pendingImplicitSubtreeUrls.delete(subtreeUrl);
+      this.trimImplicitSubtreeCache();
+    }
+  }
+  /**
+   * Instantiates every header represented by one materialized subtree.
+   *
+   * @param tileset - Owning runtime tileset.
+   * @param parentTile - Existing materialized parent.
+   * @param childHeaders - Headers to install below the parent.
+   * @returns Number of newly allocated runtime tile nodes.
+   */
+  initializeMaterializedChildren(tileset, parentTile, childHeaders) {
+    var _a;
+    let materializedTileCount = 0;
+    const stack = [
+      { parentTile, childHeaders }
+    ];
+    while (stack.length > 0) {
+      const entry = stack.pop();
+      for (const childHeader of entry.childHeaders) {
+        const childTile = new Tile3D(tileset, childHeader, entry.parentTile);
+        entry.parentTile.children.push(childTile);
+        childTile.depth = entry.parentTile.depth + 1;
+        tileset.stats.get("Tiles In Tileset(s)").incrementCount();
+        materializedTileCount++;
+        if ((_a = childHeader.children) == null ? void 0 : _a.length) {
+          stack.push({ parentTile: childTile, childHeaders: childHeader.children });
+        }
+      }
+    }
+    return materializedTileCount;
+  }
+  /** Evicts least-recently-used settled subtree entries until the configured bound is met. */
+  trimImplicitSubtreeCache() {
+    if (this.implicitSubtreeCache.size <= this.maximumCachedSubtrees) {
+      return;
+    }
+    for (const subtreeUrl of this.implicitSubtreeCache.keys()) {
+      if (!this.pendingImplicitSubtreeUrls.has(subtreeUrl)) {
+        this.implicitSubtreeCache.delete(subtreeUrl);
+      }
+      if (this.implicitSubtreeCache.size <= this.maximumCachedSubtrees) {
+        break;
+      }
     }
-    return await this.loadWithCoreApi(url, options);
   }
 };
 function isTilesetRequest(input) {
@@ -2640,22 +5068,21 @@ function normalizeTiles3DRequest(input) {
   if (isTilesetRequest(input)) {
     return {
       ...input,
-      basePath: input.basePath || import_loader_utils6.path.dirname(input.url)
+      basePath: input.basePath || path_exports.dirname(input.url)
     };
   }
   return {
     url: input.url,
     loader: input.loader,
-    basePath: input.basePath || import_loader_utils6.path.dirname(input.url),
+    basePath: input.basePath || path_exports.dirname(input.url),
     resolver: input.resolver,
     coreApi: input.coreApi
   };
 }
 
 // dist/tileset-3d/format-i3s/i3s-source.js
-var import_loader_utils7 = require("@loaders.gl/loader-utils");
 var import_geospatial8 = require("@math.gl/geospatial");
-var import_core10 = require("@math.gl/core");
+var import_core11 = require("@math.gl/core");
 
 // dist/tileset-3d/format-i3s/i3s-pending-tiles-register.js
 var I3SPendingTilesRegister = class {
@@ -2829,7 +5256,7 @@ var I3STilesetTraverser = class extends TilesetTraverser {
     tile.children.push(childTile);
     const frameState = this._tileManager.find(childTile.id).frameState;
     this.updateTile(childTile, frameState);
-    if (this._frameNumber === frameState.frameNumber && (this.traversalFinished(frameState) || new Date().getTime() - this.lastUpdate > this.updateDebounceTime)) {
+    if (this._frameNumber === frameState.frameNumber && (this.traversalFinished(frameState) || (/* @__PURE__ */ new Date()).getTime() - this.lastUpdate > this.updateDebounceTime)) {
       this.executeTraversal(childTile, frameState);
     }
   }
@@ -2878,7 +5305,7 @@ var I3SSource = class {
     this.tileset = this.rootTileset;
     this.loader = request.loader;
     this.url = request.url;
-    this.basePath = request.basePath || import_loader_utils7.path.dirname(request.url);
+    this.basePath = request.basePath || path_exports.dirname(request.url);
     this.resolver = request.resolver;
     this.coreApi = request.coreApi;
     this.loadOptions = loadOptions;
@@ -3019,8 +5446,8 @@ var I3SSource = class {
     const fullExtent = metadata.tileset.fullExtent;
     if (fullExtent) {
       const { xmin, xmax, ymin, ymax, zmin, zmax } = fullExtent;
-      const cartographicCenter = new import_core10.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, zmin + (zmax - zmin) / 2);
-      const cartesianCenter = new import_core10.Vector3();
+      const cartographicCenter = new import_core11.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, zmin + (zmax - zmin) / 2);
+      const cartesianCenter = new import_core11.Vector3();
       import_geospatial8.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
       return {
         cartographicCenter,
@@ -3031,8 +5458,8 @@ var I3SSource = class {
     const extent = (_a = metadata.tileset.store) == null ? void 0 : _a.extent;
     if (extent) {
       const [xmin, ymin, xmax, ymax] = extent;
-      const cartographicCenter = new import_core10.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, 0);
-      const cartesianCenter = new import_core10.Vector3();
+      const cartographicCenter = new import_core11.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, 0);
+      const cartesianCenter = new import_core11.Vector3();
       import_geospatial8.Ellipsoid.WGS84.cartographicToCartesian(cartographicCenter, cartesianCenter);
       return {
         cartographicCenter,
@@ -3042,7 +5469,7 @@ var I3SSource = class {
     }
     console.warn("Extent is not defined in the tileset header");
     return {
-      cartographicCenter: new import_core10.Vector3(),
+      cartographicCenter: new import_core11.Vector3(),
       zoom: 1
     };
   }
@@ -3106,13 +5533,13 @@ function normalizeI3SRequest(input) {
   if (isTilesetRequest2(input)) {
     return {
       ...input,
-      basePath: input.basePath || import_loader_utils7.path.dirname(input.url)
+      basePath: input.basePath || path_exports.dirname(input.url)
     };
   }
   return {
     url: input.url,
     loader: input.loader,
-    basePath: input.basePath || import_loader_utils7.path.dirname(input.url),
+    basePath: input.basePath || path_exports.dirname(input.url),
     resolver: input.resolver,
     coreApi: input.coreApi
   };
@@ -3294,8 +5721,7 @@ function normalizeTileError(error) {
 }
 
 // dist/tileset-2d/tileset-2d.js
-var import_loader_utils8 = require("@loaders.gl/loader-utils");
-var import_stats2 = require("@probe.gl/stats");
+var import_stats4 = require("@probe.gl/stats");
 var STRATEGY_NEVER = "never";
 var STRATEGY_REPLACE = "no-overlap";
 var STRATEGY_DEFAULT = "best-available";
@@ -3320,7 +5746,7 @@ var DEFAULT_TILESET2D_PROPS = {
   },
   tileSource: null
 };
-var Tileset2D = class {
+var Tileset2D = class _Tileset2D {
   /** Live counters describing shared tileset state. */
   stats;
   /** Cached metadata returned by the backing TileSource, if any. */
@@ -3342,7 +5768,7 @@ var Tileset2D = class {
   _lastTileContext = null;
   /** Creates a tileset from either `getTileData` or a loaders.gl `TileSource`. */
   constructor(opts) {
-    this.stats = new import_stats2.Stats({
+    this.stats = new import_stats4.Stats({
       id: "Tileset2D",
       stats: [
         { name: "Tiles In Cache" },
@@ -3360,7 +5786,7 @@ var Tileset2D = class {
       getTileData: opts.getTileData || (() => null),
       tileSource: opts.tileSource
     };
-    this._requestScheduler = new import_loader_utils8.RequestScheduler({
+    this._requestScheduler = new RequestScheduler({
       throttleRequests: this.opts.maxRequests > 0 || this.opts.debounceTime > 0,
       maxRequests: this.opts.maxRequests,
       debounceTime: this.opts.debounceTime
@@ -3382,7 +5808,7 @@ var Tileset2D = class {
   }
   /** Convenience factory for wrapping a loaders.gl `TileSource`. */
   static fromTileSource(tileSource, opts = {}) {
-    return new Tileset2D({ ...opts, tileSource });
+    return new _Tileset2D({ ...opts, tileSource });
   }
   /** All tiles currently present in the shared cache. */
   get tiles() {
@@ -3453,7 +5879,7 @@ var Tileset2D = class {
     const previousDebounceTime = this.opts.debounceTime;
     this._applyResolvedOptions();
     if (previousMaxRequests !== this.opts.maxRequests || previousDebounceTime !== this.opts.debounceTime) {
-      this._requestScheduler = new import_loader_utils8.RequestScheduler({
+      this._requestScheduler = new RequestScheduler({
         throttleRequests: this.opts.maxRequests > 0 || this.opts.debounceTime > 0,
         maxRequests: this.opts.maxRequests,
         debounceTime: this.opts.debounceTime
@@ -3823,7 +6249,7 @@ var DEFAULT_IMAGESET_PROPS = {
   getImage: async () => null,
   debounceTime: 0
 };
-var ImageSet = class {
+var ImageSet = class _ImageSet {
   /** Cached metadata returned by the backing source, if any. */
   metadata = null;
   _opts;
@@ -3844,7 +6270,7 @@ var ImageSet = class {
   }
   /** Convenience factory for wrapping a loaders.gl {@link ImageSource}. */
   static fromImageSource(imageSource, opts = {}) {
-    return new ImageSet({ ...opts, imageSource });
+    return new _ImageSet({ ...opts, imageSource });
   }
   /** Whether the manager has no requests in flight and a current image. */
   get isLoaded() {
@@ -3956,7 +6382,7 @@ var ImageSet = class {
       }
       this._emitUpdate();
     } catch (error) {
-      if (isAbortError(error)) {
+      if (isAbortError2(error)) {
         return;
       }
       const normalizedError = normalizeImageSetError(error, "Image request failed");
@@ -4040,7 +6466,7 @@ var ImageSet = class {
     this._abortController = null;
   }
 };
-function isAbortError(error) {
+function isAbortError2(error) {
   return error instanceof Error && error.name === "AbortError";
 }
 function normalizeImageSetError(error, message) {
@@ -4071,7 +6497,7 @@ var DEFAULT_RASTERSET_PROPS = {
   debounceTime: 0,
   shouldRefetch: () => true
 };
-var RasterSet = class {
+var RasterSet = class _RasterSet {
   /** Cached metadata returned by the backing source, if any. */
   metadata = null;
   _opts;
@@ -4092,7 +6518,7 @@ var RasterSet = class {
   }
   /** Convenience factory for wrapping a loaders.gl {@link RasterSource}. */
   static fromRasterSource(rasterSource, opts = {}) {
-    return new RasterSet({ ...opts, rasterSource });
+    return new _RasterSet({ ...opts, rasterSource });
   }
   /** Whether the manager has no requests in flight and a current raster. */
   get isLoaded() {
@@ -4215,7 +6641,7 @@ var RasterSet = class {
       }
       this._emitUpdate();
     } catch (error) {
-      if (isAbortError2(error)) {
+      if (isAbortError3(error)) {
         return;
       }
       const normalizedError = normalizeRasterSetError(error, "Raster request failed");
@@ -4307,13 +6733,13 @@ function normalizeRasterSetError(error, message) {
   }
   return new Error(message);
 }
-function isAbortError2(error) {
+function isAbortError3(error) {
   return error instanceof Error && error.name === "AbortError";
 }
 
 // dist/point-cloud/point-cloud-tileset.js
-var import_core11 = require("@math.gl/core");
-var import_culling5 = require("@math.gl/culling");
+var import_core12 = require("@math.gl/core");
+var import_culling6 = require("@math.gl/culling");
 
 // dist/point-cloud/point-cloud-tile.js
 var PointCloudTile = class {
@@ -4381,7 +6807,7 @@ var PointCloudTile = class {
 };
 
 // dist/point-cloud/point-cloud-tileset.js
-var DEFAULT_PROPS3 = {
+var DEFAULT_PROPS5 = {
   debounceTime: 0,
   minimumNodePixelSize: 150,
   maximumScreenSpaceError: 1,
@@ -4411,7 +6837,7 @@ var PointCloudTileset = class {
   tilesMap = /* @__PURE__ */ new Map();
   constructor(dataSource, options = {}) {
     this.dataSource = dataSource;
-    this.options = { ...DEFAULT_PROPS3, ...options };
+    this.options = { ...DEFAULT_PROPS5, ...options };
     this.tilesetInitializationPromise = this.initialize();
   }
   tilesetInitializationPromise;
@@ -4474,7 +6900,7 @@ var PointCloudTileset = class {
     const viewState = await ((_b = (_a = this.dataSource).getViewState) == null ? void 0 : _b.call(_a));
     this.boundingVolume = (viewState == null ? void 0 : viewState.boundingVolume) || this.root.boundingVolume;
     const center = (viewState == null ? void 0 : viewState.cartographicCenter) || this.root.boundingVolume.center;
-    this.cartographicCenter = new import_core11.Vector3(center);
+    this.cartographicCenter = new import_core12.Vector3(center);
     this.zoom = (viewState == null ? void 0 : viewState.zoom) || this.estimateZoom(this.boundingVolume);
   }
   /**
@@ -4486,9 +6912,9 @@ var PointCloudTileset = class {
       this.lastUpdatedViewports = viewports;
     }
     if (!this.updatePromise) {
-      this.updatePromise = new Promise((resolve, reject) => {
+      this.updatePromise = new Promise((resolve2, reject) => {
         setTimeout(() => {
-          this.doSelectTiles().then(() => resolve(this.frameNumberValue)).catch(reject).finally(() => {
+          this.doSelectTiles().then(() => resolve2(this.frameNumberValue)).catch(reject).finally(() => {
             this.updatePromise = null;
           });
         }, this.options.debounceTime);
@@ -4617,7 +7043,7 @@ var PointCloudTileset = class {
    * Checks whether a common-space bounding sphere intersects a culling volume.
    */
   isBoundingSphereInsideCullingVolume(boundingSphere, cullingVolume2) {
-    return cullingVolume2.computeVisibilityWithPlaneMask(boundingSphere, import_culling5.CullingVolume.MASK_INDETERMINATE) !== import_culling5.CullingVolume.MASK_OUTSIDE;
+    return cullingVolume2.computeVisibilityWithPlaneMask(boundingSphere, import_culling6.CullingVolume.MASK_INDETERMINATE) !== import_culling6.CullingVolume.MASK_OUTSIDE;
   }
   /**
    * Checks a projected screen-space footprint against the viewport rectangle.
@@ -4813,9 +7239,9 @@ var PointCloudTileset = class {
       if (!plane) {
         return null;
       }
-      planes.push(new import_culling5.Plane(plane.normal, -plane.distance));
+      planes.push(new import_culling6.Plane(plane.normal, -plane.distance));
     }
-    return new import_culling5.CullingVolume(planes);
+    return new import_culling6.CullingVolume(planes);
   }
   /**
    * Approximate a tile AABB by a common-space bounding sphere for frustum culling.
@@ -4852,7 +7278,7 @@ var PointCloudTileset = class {
     if (!Number.isFinite(minX) || !Number.isFinite(minY) || !Number.isFinite(minZ) || !Number.isFinite(maxX) || !Number.isFinite(maxY) || !Number.isFinite(maxZ)) {
       return null;
     }
-    return new import_culling5.BoundingSphere().fromCornerPoints([minX, minY, minZ], [maxX, maxY, maxZ]);
+    return new import_culling6.BoundingSphere().fromCornerPoints([minX, minY, minZ], [maxX, maxY, maxZ]);
   }
 };
 //# sourceMappingURL=index.cjs.map