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

package/dist/dist.dev.js

@@ -13,7 +13,11 @@ var __exports__ = (() => {
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    try {
+      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    } catch (e) {
+      throw mod = 0, e;
+    }
   };
   var __export = (target, all) => {
     for (var name in all)
@@ -71,9 +75,12 @@ var __exports__ = (() => {
     TilesetTraverser: () => TilesetTraverser,
     calculateTransformProps: () => calculateTransformProps,
     createBoundingVolume: () => createBoundingVolume,
+    createImplicitSubtreeReference: () => createImplicitSubtreeReference,
     getFrameState: () => getFrameState,
     getLodStatus: () => getLodStatus,
-    isTileset3DSource: () => isTileset3DSource
+    isTileset3DSource: () => isTileset3DSource,
+    materializeImplicitSubtree: () => materializeImplicitSubtree,
+    replaceImplicitUrlTemplate: () => replaceImplicitUrlTemplate
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
@@ -110,6 +117,9 @@ var __exports__ = (() => {
   function degrees(radians2, result) {
     return map(radians2, (radians3) => radians3 * RADIANS_TO_DEGREES, result);
   }
+  function clamp(value, min2, max2) {
+    return map(value, (value2) => Math.max(min2, Math.min(max2, value2)));
+  }
   function equals(a, b, epsilon) {
     const oldEpsilon = config.EPSILON;
     if (epsilon) {
@@ -569,7 +579,7 @@ var __exports__ = (() => {
     out[1] = m[1] * x + m[5] * y + m[13];
     return out;
   }
-  var forEach = function() {
+  var forEach = (function() {
     const vec = create();
     return function(a, stride, offset, count, fn, arg) {
       let i;
@@ -594,7 +604,7 @@ var __exports__ = (() => {
       }
       return a;
     };
-  }();
+  })();
 
   // ../../node_modules/@math.gl/core/dist/lib/gl-matrix-extras.js
   function vec2_transformMat4AsVector(out, a, m) {
@@ -1041,7 +1051,7 @@ var __exports__ = (() => {
   var sqrDist = squaredDistance;
   var len = length;
   var sqrLen = squaredLength;
-  var forEach2 = function() {
+  var forEach2 = (function() {
     const vec = create2();
     return function(a, stride, offset, count, fn, arg) {
       let i;
@@ -1068,15 +1078,15 @@ var __exports__ = (() => {
       }
       return a;
     };
-  }();
+  })();
 
   // ../../node_modules/@math.gl/core/dist/classes/vector3.js
   var ORIGIN = [0, 0, 0];
   var ZERO;
-  var Vector3 = class extends Vector {
+  var Vector3 = class _Vector3 extends Vector {
     static get ZERO() {
       if (!ZERO) {
-        ZERO = new Vector3(0, 0, 0);
+        ZERO = new _Vector3(0, 0, 0);
         Object.freeze(ZERO);
       }
       return ZERO;
@@ -1193,10 +1203,10 @@ var __exports__ = (() => {
 
   // ../../node_modules/@math.gl/core/dist/classes/vector4.js
   var ZERO2;
-  var Vector4 = class extends Vector {
+  var Vector4 = class _Vector4 extends Vector {
     static get ZERO() {
       if (!ZERO2) {
-        ZERO2 = new Vector4(0, 0, 0, 0);
+        ZERO2 = new _Vector4(0, 0, 0, 0);
         Object.freeze(ZERO2);
       }
       return ZERO2;
@@ -3310,7 +3320,7 @@ var __exports__ = (() => {
     out[3] = a[3];
     return out;
   }
-  var forEach3 = function() {
+  var forEach3 = (function() {
     const vec = create5();
     return function(a, stride, offset, count, fn, arg) {
       let i;
@@ -3339,7 +3349,7 @@ var __exports__ = (() => {
       }
       return a;
     };
-  }();
+  })();
 
   // ../../node_modules/@math.gl/core/dist/classes/matrix4.js
   var INDICES2;
@@ -4045,7 +4055,7 @@ var __exports__ = (() => {
   var length3 = length2;
   var squaredLength3 = squaredLength2;
   var normalize3 = normalize2;
-  var rotationTo = function() {
+  var rotationTo = (function() {
     const tmpvec3 = create2();
     const xUnitVec3 = fromValues(1, 0, 0);
     const yUnitVec3 = fromValues(0, 1, 0);
@@ -4072,8 +4082,8 @@ var __exports__ = (() => {
       out[3] = 1 + dot4;
       return normalize3(out, out);
     };
-  }();
-  var sqlerp = function() {
+  })();
+  var sqlerp = (function() {
     const temp1 = create6();
     const temp2 = create6();
     return function(out, a, b, c, d, t) {
@@ -4082,8 +4092,8 @@ var __exports__ = (() => {
       slerp2(out, temp1, temp2, 2 * t * (1 - t));
       return out;
     };
-  }();
-  var setAxes = function() {
+  })();
+  var setAxes = (function() {
     const matr = create3();
     return function(out, view, right, up) {
       matr[0] = right[0];
@@ -4097,7 +4107,7 @@ var __exports__ = (() => {
       matr[8] = -view[2];
       return normalize3(out, fromMat3(out, matr));
     };
-  }();
+  })();
 
   // ../../node_modules/@math.gl/core/dist/classes/quaternion.js
   var IDENTITY_QUATERNION = [0, 0, 0, 1];
@@ -5106,6 +5116,506 @@ var __exports__ = (() => {
     }
   };
 
+  // ../loader-utils/src/lib/request-utils/range-request-scheduler.ts
+  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) {
+      if (request.length < 0) {
+        return Promise.reject(new Error("Byte range length cannot be negative"));
+      }
+      if (request.signal?.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 = () => {
+            this.abortRequest(pendingRequest);
+            pendingRequest.onAbort?.();
+          };
+          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, length4, signal) => fetchHttpRange({
+          url: request.url,
+          offset,
+          length: length4,
+          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) => {
+        if (request.settled || request.signal?.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) {
+      const { offset, endOffset, fetchRange, requests } = mergedRequest;
+      const abortController = new AbortController();
+      const requestStartTime = getTimestamp();
+      const abortTransportIfUnused = () => {
+        if (requests.every((request) => request.signal?.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 length4 = endOffset - offset;
+        this.trackEvent({
+          type: "request",
+          sourceId: mergedRequest.sourceId,
+          offset,
+          length: length4,
+          logicalRequestCount: requests.length,
+          logicalBytes,
+          transportBytes: length4,
+          overfetchBytes: Math.max(length4 - logicalBytes, 0)
+        });
+        const transportResult = normalizeTransportResult(
+          await fetchRange(offset, length4, abortController.signal)
+        );
+        const { arrayBuffer } = transportResult;
+        const isClampedFullResponse = transportResult.fullResponse && offset === 0 && arrayBuffer.byteLength < length4;
+        const isClampedEndOfFile = arrayBuffer.byteLength < length4 && Number.isSafeInteger(transportResult.sourceByteLength) && offset + arrayBuffer.byteLength === transportResult.sourceByteLength;
+        if (arrayBuffer.byteLength !== length4 && !isClampedFullResponse && !isClampedEndOfFile) {
+          throw new Error(
+            `Byte-range transport returned ${arrayBuffer.byteLength} bytes; expected ${length4}`
+          );
+        }
+        const networkTimeMs = transportResult.networkTimeMs ?? getTimestamp() - requestStartTime;
+        this.trackEvent({
+          type: "response",
+          sourceId: mergedRequest.sourceId,
+          offset,
+          length: length4,
+          logicalRequestCount: requests.length,
+          logicalBytes,
+          transportBytes: length4,
+          responseBytes: transportResult.transportBytes ?? arrayBuffer.byteLength,
+          networkTimeMs,
+          overfetchBytes: Math.max(length4 - 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 (request.signal?.aborted) {
+            this.abortRequest(request);
+          } else {
+            request.settled = true;
+            request.reject(error);
+          }
+        }
+      } finally {
+        for (const request of requests) {
+          if (request.abortListener) {
+            request.signal?.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) {
+      trackStatsEvent(this.stats, event);
+      try {
+        this.onEvent?.(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 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?.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, length4, signal) {
+    return {
+      ...fetchOptions,
+      signal,
+      headers: {
+        ...getHeadersObject(fetchOptions?.headers),
+        Range: `bytes=${offset}-${offset + length4 - 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?.match(/^bytes \*\/(\d+)$/);
+    return match ? Number(match[1]) : null;
+  }
+  function parseSatisfiedContentRange(contentRange) {
+    const match = 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?.aborted) {
+      abortController.abort();
+    } else {
+      parentSignal?.addEventListener("abort", abortListener, { once: true });
+    }
+    return {
+      signal: abortController.signal,
+      abort: () => abortController.abort(),
+      removeAbortListener: () => parentSignal?.removeEventListener("abort", abortListener)
+    };
+  }
+  async function cancelIgnoredRangeResponse(response) {
+    await response.body?.cancel().catch(() => {
+    });
+  }
+  function getTimestamp() {
+    return globalThis.performance?.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, {
@@ -5270,97 +5780,513 @@ var __exports__ = (() => {
         isDirectory: false
       };
     }
-    async read(start, length4) {
+    async read(start, length4, signal) {
+      if (signal?.aborted) {
+        throw new Error("Request aborted");
+      }
       const arrayBuffer = await this.handle.slice(Number(start), Number(start) + Number(length4)).arrayBuffer();
+      if (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, length4, signal, expectedIdentity) {
+      const requestStartTime = getTimestamp2();
+      const abortContext = createCombinedAbortContext(signal, this.fetchOptions?.signal);
+      this.telemetry.requestCount++;
+      this.telemetry.requestedBytes += length4;
+      try {
+        const response = await this.fetchFunction(
+          this.url,
+          createFetchOptions(this.fetchOptions, offset, length4, abortContext.signal)
+        );
+        if (isEmptyIdentityProbeResponse(response, offset, length4, 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, length4);
+        if (responseError) {
+          await cancelResponse(response);
+          throw new Error(responseError);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        this.telemetry.downloadedBytes += arrayBuffer.byteLength;
+        if (arrayBuffer.byteLength !== length4) {
+          throw new Error(
+            `HTTP byte-range response contained ${arrayBuffer.byteLength} bytes; expected ${length4}`
+          );
+        }
+        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, length4, signal) {
+    const headers = new Headers(fetchOptions?.headers);
+    headers.set("Range", `bytes=${offset}-${offset + length4 - 1}`);
+    return {
+      ...fetchOptions,
+      method: "GET",
+      body: void 0,
+      headers,
+      signal
+    };
+  }
+  function isEmptyIdentityProbeResponse(response, offset, length4, expectedIdentity) {
+    return response.status === 416 && expectedIdentity === null && offset === 0 && length4 === 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?.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, length4) {
+    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 + length4 - 1) {
+      return "HTTP byte-range response does not match the requested range";
+    }
+    return null;
+  }
+  function getIdentityError(expectedIdentity, responseIdentity, identityHints, consistency) {
+    const expectedByteLength = expectedIdentity?.byteLength ?? identityHints.byteLength;
+    if (expectedByteLength !== void 0 && responseIdentity.byteLength !== expectedByteLength) {
+      return "HTTP file length changed while the file was open";
+    }
+    const expectedEtag = expectedIdentity?.etag ?? identityHints.etag;
+    const expectedLastModified = 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) {
+    await response.body?.cancel().catch(() => {
+    });
+  }
+  function normalizeHeaderValue(value) {
+    return value || void 0;
+  }
+  function getTimestamp2() {
+    return globalThis.performance?.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 {
+  var HttpFile = class _HttpFile {
+    /** URL used as the ReadableFile handle. */
     handle;
-    size = 0;
-    bigsize = 0n;
+    /** Remote object URL. */
     url;
-    constructor(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?.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() {
+      return this.identity?.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() {
-      const response = await fetch(this.handle, { method: "HEAD" });
-      if (!response.ok) {
-        throw new Error(`Failed to fetch HEAD ${this.handle}`);
-      }
-      const size = parseInt(response.headers.get("Content-Length") || "0");
+      this.assertOpen();
+      const identity4 = await this.getIdentity();
       return {
-        size,
-        bigsize: BigInt(size),
+        size: identity4.byteLength,
+        bigsize: BigInt(identity4.byteLength),
         isDirectory: false
       };
     }
-    async read(offset = 0, length4 = 0) {
-      const response = await this.fetchRange(offset, length4);
-      const arrayBuffer = await response.arrayBuffer();
-      return arrayBuffer;
+    /** Reads exactly one byte range, with optional cancellation. */
+    async read(offset = 0, length4 = 0, signal) {
+      this.assertOpen();
+      if (signal?.aborted) {
+        const error = createAbortError2();
+        this.transport.trackFailure(error);
+        throw error;
+      }
+      const identity4 = await this.getIdentity(signal);
+      const numericOffset = normalizeOffset(offset);
+      validateRange(numericOffset, length4, identity4.byteLength);
+      if (length4 === 0) {
+        return new ArrayBuffer(0);
+      }
+      try {
+        return await this.rangeScheduler.scheduleRequest({
+          sourceId: this.url,
+          isolationKey: this.schedulerIsolationKey,
+          offset: numericOffset,
+          length: length4,
+          signal,
+          fetchRange: this.fetchScheduledRange
+        });
+      } catch (error) {
+        this.transport.trackFailure(error);
+        throw error;
+      }
     }
-    /**
-     *
-     * @param offset
-     * @param length
-     * @param signal
-     * @returns
-     * @see https://github.com/protomaps/PMTiles
-     */
-    // eslint-disable-next-line complexity
+    /** Reads a range and returns a Response for legacy ReadableFile consumers. */
     async fetchRange(offset, length4, signal) {
-      const nOffset = Number(offset);
-      const nLength = Number(length4);
-      let controller;
-      if (!signal) {
-        controller = new AbortController();
-        signal = controller.signal;
-      }
-      const url = this.handle;
-      let response = await fetch(url, {
-        signal,
-        headers: { Range: `bytes=${nOffset}-${nOffset + nLength - 1}` }
-      });
-      switch (response.status) {
-        case 206:
-          break;
-        case 200:
-          const contentLength = response.headers.get("Content-Length");
-          if (!contentLength || Number(contentLength) > length4) {
-            if (controller) {
-              controller.abort();
-            }
-            throw Error(
-              "content-length header missing or exceeding request. Server must support HTTP Byte Serving."
-            );
-          }
-        case 416:
-          if (offset === 0) {
-            const contentRange = response.headers.get("Content-Range");
-            if (!contentRange || !contentRange.startsWith("bytes *")) {
-              throw Error("Missing content-length on 416 response");
-            }
-            const actualLength = Number(contentRange.substr(8));
-            response = await fetch(this.url, {
-              signal,
-              headers: { Range: `bytes=0-${actualLength - 1}` }
-            });
-          }
-          break;
-        default:
-          if (response.status >= 300) {
-            throw Error(`Bad response code: ${response.status}`);
+      const numericOffset = normalizeOffset(offset);
+      const arrayBuffer = await this.read(numericOffset, length4, signal);
+      const headers = createIdentityHeaders(this.identity, numericOffset, length4);
+      return new Response(arrayBuffer, { status: 206, headers });
+    }
+    /** Stable scheduler callback used by every read from this file. */
+    fetchScheduledRange = async (offset, length4, signal) => {
+      const identity4 = await this.getIdentity(signal);
+      const result = await this.transport.requestRange(offset, length4, signal, identity4);
+      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");
       }
-      return response;
     }
   };
+  function createIdentityHeaders(identity4, offset, length4) {
+    const headers = new Headers();
+    if (length4 > 0 && identity4) {
+      headers.set("Content-Range", `bytes ${offset}-${offset + length4 - 1}/${identity4.byteLength}`);
+    }
+    if (identity4?.etag) {
+      headers.set("ETag", identity4.etag);
+    }
+    if (identity4?.lastModified) {
+      headers.set("Last-Modified", identity4.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, length4, byteLength) {
+    if (!Number.isSafeInteger(length4) || length4 < 0) {
+      throw new Error("HTTP byte-range length must be a non-negative safe integer");
+    }
+    if (offset + length4 > 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);
+        }
+      );
+    });
+  }
 
   // src/utils/doubly-linked-list-node.ts
   var DoublyLinkedListNode = class {
@@ -5488,14 +6414,23 @@ var __exports__ = (() => {
         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);
@@ -5566,12 +6501,10 @@ var __exports__ = (() => {
     const sceneIndex = typeof gltf.scene === "number" ? gltf.scene : 0;
     const scene = gltf.scenes?.[sceneIndex];
     const rootNode = scene?.nodes?.[0];
-    if (!rootNode?.matrix)
-      return null;
+    if (!rootNode?.matrix) return null;
     const m = rootNode.matrix;
     const translationMagnitude = m[12] * m[12] + m[13] * m[13] + m[14] * m[14];
-    if (translationMagnitude <= TRANSLATION_LIMIT_SQUARED)
-      return null;
+    if (translationMagnitude <= TRANSLATION_LIMIT_SQUARED) return null;
     return rootNode;
   }
 
@@ -5592,7 +6525,7 @@ var __exports__ = (() => {
   // ../../node_modules/@math.gl/culling/dist/lib/bounding-volumes/bounding-sphere.js
   var scratchVector7 = new Vector3();
   var scratchVector22 = new Vector3();
-  var BoundingSphere = class {
+  var BoundingSphere = class _BoundingSphere {
     /** Creates a bounding sphere */
     constructor(center = [0, 0, 0], radius = 0) {
       this.radius = -0;
@@ -5621,7 +6554,7 @@ var __exports__ = (() => {
     }
     /** Duplicates a BoundingSphere instance. */
     clone() {
-      return new BoundingSphere(this.center, this.radius);
+      return new _BoundingSphere(this.center, this.radius);
     }
     /** Computes a bounding sphere that contains both the left and right bounding spheres. */
     union(boundingSphere) {
@@ -5711,7 +6644,7 @@ var __exports__ = (() => {
     COLUMN2ROW1: 7,
     COLUMN2ROW2: 8
   };
-  var OrientedBoundingBox = class {
+  var OrientedBoundingBox = class _OrientedBoundingBox {
     constructor(center = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {
       this.center = new Vector3().from(center);
       this.halfAxes = new Matrix3(halfAxes);
@@ -5754,7 +6687,7 @@ var __exports__ = (() => {
     }
     /** Duplicates a OrientedBoundingBox instance. */
     clone() {
-      return new OrientedBoundingBox(this.center, this.halfAxes);
+      return new _OrientedBoundingBox(this.center, this.halfAxes);
     }
     /** Compares the provided OrientedBoundingBox component wise and returns */
     equals(right) {
@@ -5916,7 +6849,7 @@ var __exports__ = (() => {
   // ../../node_modules/@math.gl/culling/dist/lib/plane.js
   var scratchPosition2 = new Vector3();
   var scratchNormal3 = new Vector3();
-  var Plane = class {
+  var Plane = class _Plane {
     constructor(normal = [0, 0, 1], distance2 = 0) {
       this.normal = new Vector3();
       this.distance = -0;
@@ -5946,7 +6879,7 @@ var __exports__ = (() => {
     }
     /** Duplicates a Plane instance. */
     clone() {
-      return new Plane(this.normal, this.distance);
+      return new _Plane(this.normal, this.distance);
     }
     /** Compares the provided Planes by normal and distance */
     equals(right) {
@@ -5976,7 +6909,7 @@ var __exports__ = (() => {
   var faces = [new Vector3([1, 0, 0]), new Vector3([0, 1, 0]), new Vector3([0, 0, 1])];
   var scratchPlaneCenter = new Vector3();
   var scratchPlaneNormal = new Vector3();
-  var CullingVolume = class {
+  var CullingVolume = class _CullingVolume {
     /**
      * Create a new `CullingVolume` bounded by an array of clipping planed
      * @param planes Array of clipping planes.
@@ -6037,10 +6970,10 @@ var __exports__ = (() => {
      */
     computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) {
       assert(Number.isFinite(parentPlaneMask), "parentPlaneMask is required.");
-      if (parentPlaneMask === CullingVolume.MASK_OUTSIDE || parentPlaneMask === CullingVolume.MASK_INSIDE) {
+      if (parentPlaneMask === _CullingVolume.MASK_OUTSIDE || parentPlaneMask === _CullingVolume.MASK_INSIDE) {
         return parentPlaneMask;
       }
-      let mask = CullingVolume.MASK_INSIDE;
+      let mask = _CullingVolume.MASK_INSIDE;
       const planes = this.planes;
       for (let k = 0; k < this.planes.length; ++k) {
         const flag = k < 31 ? 1 << k : 0;
@@ -6050,7 +6983,7 @@ var __exports__ = (() => {
         const plane = planes[k];
         const result = boundingVolume.intersectPlane(plane);
         if (result === INTERSECTION.OUTSIDE) {
-          return CullingVolume.MASK_OUTSIDE;
+          return _CullingVolume.MASK_OUTSIDE;
         } else if (result === INTERSECTION.INTERSECTING) {
           mask |= flag;
         }
@@ -6105,6 +7038,8 @@ var __exports__ = (() => {
   // src/tileset-3d/helpers/frame-state.ts
   var scratchVector8 = new Vector3();
   var scratchPosition3 = new Vector3();
+  var CAMERA_POSITION_EPSILON = 1e-5;
+  var CAMERA_DIRECTION_EPSILON = 1e-7;
   var cullingVolume = new CullingVolume([
     new Plane(),
     new Plane(),
@@ -6113,8 +7048,9 @@ var __exports__ = (() => {
     new Plane(),
     new 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 = Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);
@@ -6123,10 +7059,18 @@ var __exports__ = (() => {
       cameraPositionCartographic,
       new Vector3()
     );
-    const cameraDirectionCartesian = new Vector3(
-      // @ts-ignore
-      enuToFixedTransform.transformAsVector(new Vector3(cameraDirection).scale(metersPerUnit))
-    ).normalize();
+    let cameraDirectionCartesian;
+    if (cameraDirection) {
+      cameraDirectionCartesian = new Vector3(
+        // @ts-ignore
+        enuToFixedTransform.transformAsVector(new Vector3(cameraDirection).scale(metersPerUnit))
+      ).normalize();
+    } else {
+      const nearPlane = viewport.getFrustumPlanes().near;
+      const nearCenterCommon = closestPointOnPlane(nearPlane, viewport.cameraPosition);
+      const nearCenterCartesian = worldToCartesian(viewport, nearCenterCommon);
+      cameraDirectionCartesian = new Vector3(nearCenterCartesian).subtract(cameraPositionCartesian2).normalize();
+    }
     const cameraUpCartesian = new Vector3(
       // @ts-ignore
       enuToFixedTransform.transformAsVector(new Vector3(cameraUp).scale(metersPerUnit))
@@ -6147,7 +7091,10 @@ var __exports__ = (() => {
       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,
@@ -6155,8 +7102,29 @@ var __exports__ = (() => {
       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?.lastMovementTime ?? Number.NEGATIVE_INFINITY;
+    return {
+      state: {
+        position: positionArray,
+        direction: directionArray,
+        lastMovementTime
+      },
+      timeSinceMovement: Math.max((currentTime - lastMovementTime) / 1e3, 0)
     };
   }
   function limitSelectedTiles(tiles, frameState, maximumTilesSelected) {
@@ -6217,6 +7185,290 @@ var __exports__ = (() => {
     return Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, out);
   }
 
+  // src/tileset-3d/helpers/tiles-3d-lod.ts
+  var scratchPositionNormal = new Vector3();
+  var scratchCartographic = new Vector3();
+  var scratchCenter = new Vector3();
+  var scratchPosition4 = new Vector3();
+  var scratchDirection = new Vector3();
+  var scratchBoxXAxis = new Vector3();
+  var scratchBoxYAxis = new Vector3();
+  var scratchBoxZAxis = new Vector3();
+  var scratchBoxQuaternion = new Quaternion();
+  var unitZDirection = new 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 = clamp(options.dynamicScreenSpaceErrorHeightFalloff, 0, 1);
+    const heightClose = heightRange.minimumHeight + (heightRange.maximumHeight - heightRange.minimumHeight) * heightFalloff;
+    const heightSpan = heightRange.maximumHeight - heightClose;
+    const heightPercentage = heightSpan > 0 ? clamp((heightRange.cameraHeight - heightClose) / heightSpan, 0, 1) : heightRange.cameraHeight >= heightRange.maximumHeight ? 1 : 0;
+    const verticalAlignment = 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?.orthographic) {
+      return null;
+    }
+    const metersPerPixel = viewport.metersPerPixel;
+    if (!Number.isFinite(metersPerPixel) || !metersPerPixel || metersPerPixel <= 0) {
+      return null;
+    }
+    return lodMetricValue * lodScale * viewportHeightFraction / metersPerPixel;
+  }
+  function getContentBoundingVolumeHeader(root) {
+    return root.header.content?.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 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, scratchPosition4);
+    localTransform.transformAsVector(frameState.camera.direction, scratchDirection);
+    scratchDirection.normalize();
+    return {
+      cameraHeight: scratchPosition4[2],
+      minimumHeight: scratchCenter[2] - halfHeight,
+      maximumHeight: scratchCenter[2] + halfHeight,
+      cameraDirection: scratchDirection,
+      upDirection: unitZDirection
+    };
+  }
+  function getBoundingVolumeCenterAndHalfHeight(boundingVolumeHeader, result) {
+    if (boundingVolumeHeader.box) {
+      const box = boundingVolumeHeader.box;
+      result.set(box[0], box[1], box[2]);
+      return getBoxHalfHeight(box);
+    }
+    if (boundingVolumeHeader.sphere) {
+      const sphere = boundingVolumeHeader.sphere;
+      result.set(sphere[0], sphere[1], sphere[2]);
+      return sphere[3];
+    }
+    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]);
+    }
+    return Math.abs(box[5]) + Math.abs(box[8]) + Math.abs(box[11]);
+  }
+
+  // src/constants.ts
+  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 = /* @__PURE__ */ ((TILE_REFINEMENT2) => {
+    TILE_REFINEMENT2[TILE_REFINEMENT2["ADD"] = 1] = "ADD";
+    TILE_REFINEMENT2[TILE_REFINEMENT2["REPLACE"] = 2] = "REPLACE";
+    return TILE_REFINEMENT2;
+  })(TILE_REFINEMENT || {});
+  var TILE_TYPE = /* @__PURE__ */ ((TILE_TYPE2) => {
+    TILE_TYPE2["EMPTY"] = "empty";
+    TILE_TYPE2["SCENEGRAPH"] = "scenegraph";
+    TILE_TYPE2["POINTCLOUD"] = "pointcloud";
+    TILE_TYPE2["MESH"] = "mesh";
+    return TILE_TYPE2;
+  })(TILE_TYPE || {});
+  var TILESET_TYPE = /* @__PURE__ */ ((TILESET_TYPE2) => {
+    TILESET_TYPE2["I3S"] = "I3S";
+    TILESET_TYPE2["TILES3D"] = "TILES3D";
+    return TILESET_TYPE2;
+  })(TILESET_TYPE || {});
+  var LOD_METRIC_TYPE = /* @__PURE__ */ ((LOD_METRIC_TYPE2) => {
+    LOD_METRIC_TYPE2["GEOMETRIC_ERROR"] = "geometricError";
+    LOD_METRIC_TYPE2["MAX_SCREEN_THRESHOLD"] = "maxScreenThreshold";
+    return LOD_METRIC_TYPE2;
+  })(LOD_METRIC_TYPE || {});
+  var TILE3D_OPTIMIZATION_HINT = {
+    NOT_COMPUTED: -1,
+    USE_OPTIMIZATION: 1,
+    SKIP_OPTIMIZATION: 0
+  };
+
+  // src/tileset-3d/helpers/tiles-3d-request-priority.ts
+  var PREFERRED_SORTING_DIGITS = 1e4;
+  var FOVEATED_SORTING_SCALE = 1e4;
+  var PROGRESSIVE_RESOLUTION_PENALTY = 1e8;
+  var scratchBoundingSphere = new BoundingSphere();
+  var scratchCenterOffset = new Vector3();
+  var scratchClosestPointOnLine = new Vector3();
+  var scratchVectorToLine = new Vector3();
+  var scratchClosestPointOnSphere = new Vector3();
+  function interpolateLinearly(minimumValue, maximumValue, interpolationAmount) {
+    return minimumValue + (maximumValue - minimumValue) * interpolationAmount;
+  }
+  function calculateFoveatedFactor(boundingVolume, camera) {
+    const boundingSphere = boundingVolume instanceof 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;
+    }
+    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 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 isFoveatedRequestDeferred(parameters) {
+    const coneSize = Number.isFinite(parameters.foveatedConeSize) ? Math.min(Math.max(parameters.foveatedConeSize, 0), 1) : 1;
+    const replacementRefinement = parameters.refinement === 2 /* 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 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;
+  }
+
   // src/tileset-3d/common/tileset-source.ts
   function isTileset3DSource(value) {
     return Boolean(
@@ -6225,14 +7477,35 @@ var __exports__ = (() => {
   }
 
   // src/tileset-3d/common/tileset-3d.ts
-  var DEFAULT_PROPS2 = {
+  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: Ellipsoid.WGS84,
     modelMatrix: new 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: () => {
@@ -6250,8 +7523,18 @@ var __exports__ = (() => {
     },
     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,
@@ -6300,12 +7583,14 @@ var __exports__ = (() => {
     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;
@@ -6316,6 +7601,10 @@ var __exports__ = (() => {
     _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;
@@ -6328,11 +7617,28 @@ var __exports__ = (() => {
      * @param options Traversal and runtime options.
      */
     constructor(source, options) {
-      this.options = { ...DEFAULT_PROPS2, ...options };
-      this.loadOptions = this.options.loadOptions || {};
       if (!isTileset3DSource(source)) {
         throw new Error("Tileset3D requires a Tileset3DSource instance");
       }
+      const suppliedOptions = options || {};
+      const usesTiles3DCacheDefaults = source.type === "TILES3D" /* 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;
@@ -6351,13 +7657,15 @@ var __exports__ = (() => {
         maxRequests: this.options.maxRequests
       });
       this.memoryAdjustedScreenSpaceError = this.options.maximumScreenSpaceError;
-      this._cacheBytes = this.options.maximumMemoryUsage * 1024 * 1024;
-      this._cacheOverflowBytes = this.options.memoryCacheOverflow * 1024 * 1024;
+      this._cacheBytes = cacheBytes;
+      this._maximumCacheOverflowBytes = maximumCacheOverflowBytes;
       this.stats = new Stats({ id: this.url });
       this._initializeStats();
       this.tilesetInitializationPromise = this._initializeTileSet();
     }
     destroy() {
+      this._clearDeferredTraversal();
+      this.source.destroy?.();
       this._destroy();
     }
     isLoaded() {
@@ -6369,13 +7677,76 @@ var __exports__ = (() => {
     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);
@@ -6413,13 +7784,20 @@ var __exports__ = (() => {
       }
       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;
       }
     }
@@ -6434,6 +7812,8 @@ var __exports__ = (() => {
       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;
@@ -6452,7 +7832,58 @@ var __exports__ = (() => {
           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 === "TILES3D" /* 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) {
@@ -6506,8 +7937,7 @@ var __exports__ = (() => {
           this._heldTiles.add(tileId);
         }
         for (const tileId of this._heldTiles) {
-          if (selectedIds.has(tileId))
-            continue;
+          if (selectedIds.has(tileId)) continue;
           const tile = this._tiles[tileId];
           if (tile && tile.contentAvailable) {
             tile._selectedFrame = this._frameNumber;
@@ -6555,6 +7985,9 @@ var __exports__ = (() => {
     }
     _unloadTiles() {
       this._cache.unloadTiles(this, (tileset, tile) => tileset._unloadTile(tile));
+      if (this.options.memoryAdjustedScreenSpaceError) {
+        this.adjustScreenSpaceError();
+      }
     }
     _updateStats() {
       let tilesRenderable = 0;
@@ -6638,6 +8071,27 @@ var __exports__ = (() => {
         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();
@@ -6898,49 +8352,6 @@ var __exports__ = (() => {
     return queryIndex >= 0 ? url.slice(0, queryIndex) : url;
   }
 
-  // src/constants.ts
-  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 = /* @__PURE__ */ ((TILE_REFINEMENT2) => {
-    TILE_REFINEMENT2[TILE_REFINEMENT2["ADD"] = 1] = "ADD";
-    TILE_REFINEMENT2[TILE_REFINEMENT2["REPLACE"] = 2] = "REPLACE";
-    return TILE_REFINEMENT2;
-  })(TILE_REFINEMENT || {});
-  var TILE_TYPE = /* @__PURE__ */ ((TILE_TYPE2) => {
-    TILE_TYPE2["EMPTY"] = "empty";
-    TILE_TYPE2["SCENEGRAPH"] = "scenegraph";
-    TILE_TYPE2["POINTCLOUD"] = "pointcloud";
-    TILE_TYPE2["MESH"] = "mesh";
-    return TILE_TYPE2;
-  })(TILE_TYPE || {});
-  var TILESET_TYPE = /* @__PURE__ */ ((TILESET_TYPE2) => {
-    TILESET_TYPE2["I3S"] = "I3S";
-    TILESET_TYPE2["TILES3D"] = "TILES3D";
-    return TILESET_TYPE2;
-  })(TILESET_TYPE || {});
-  var LOD_METRIC_TYPE = /* @__PURE__ */ ((LOD_METRIC_TYPE2) => {
-    LOD_METRIC_TYPE2["GEOMETRIC_ERROR"] = "geometricError";
-    LOD_METRIC_TYPE2["MAX_SCREEN_THRESHOLD"] = "maxScreenThreshold";
-    return LOD_METRIC_TYPE2;
-  })(LOD_METRIC_TYPE || {});
-  var TILE3D_OPTIMIZATION_HINT = {
-    NOT_COMPUTED: -1,
-    USE_OPTIMIZATION: 1,
-    SKIP_OPTIMIZATION: 0
-  };
-
   // src/tileset-3d/helpers/bounding-volume.ts
   function defined(x) {
     return x !== void 0 && x !== null;
@@ -6949,7 +8360,7 @@ var __exports__ = (() => {
   var scratchScale = new Vector3();
   var scratchNorthWest = new Vector3();
   var scratchSouthEast = new Vector3();
-  var scratchCenter = new Vector3();
+  var scratchCenter2 = new Vector3();
   var scratchXAxis = new Vector3();
   var scratchYAxis = new Vector3();
   var scratchZAxis = new Vector3();
@@ -7048,17 +8459,17 @@ var __exports__ = (() => {
       scratchSouthEast
     );
     const centerInCartesian = new Vector3().addVectors(northWest, southEast).multiplyByScalar(0.5);
-    Ellipsoid.WGS84.cartesianToCartographic(centerInCartesian, scratchCenter);
+    Ellipsoid.WGS84.cartesianToCartographic(centerInCartesian, scratchCenter2);
     Ellipsoid.WGS84.cartographicToCartesian(
-      [degrees(east), scratchCenter[1], scratchCenter[2]],
+      [degrees(east), scratchCenter2[1], scratchCenter2[2]],
       scratchXAxis
     );
     Ellipsoid.WGS84.cartographicToCartesian(
-      [scratchCenter[0], degrees(north), scratchCenter[2]],
+      [scratchCenter2[0], degrees(north), scratchCenter2[2]],
       scratchYAxis
     );
     Ellipsoid.WGS84.cartographicToCartesian(
-      [scratchCenter[0], scratchCenter[1], maxHeight],
+      [scratchCenter2[0], scratchCenter2[1], maxHeight],
       scratchZAxis
     );
     return createBox(
@@ -7137,57 +8548,6 @@ var __exports__ = (() => {
     target[1][2] = Math.max(target[1][2], scratchPoint[2]);
   }
 
-  // src/tileset-3d/helpers/tiles-3d-lod.ts
-  var scratchPositionNormal = new Vector3();
-  var scratchCartographic = new Vector3();
-  var scratchMatrix2 = new Matrix4();
-  var scratchCenter2 = new Vector3();
-  var scratchPosition4 = new Vector3();
-  var scratchDirection = new 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 distance2 = Math.max(tile._distanceToCamera, 1e-7);
-    const { height, sseDenominator } = frameState;
-    let error = lodMetricValue * height * lodScale / (distance2 * sseDenominator);
-    error -= getDynamicScreenSpaceError(tileset, distance2);
-    return error;
-  }
-  function getOrthographicScreenSpaceError(lodMetricValue, frameState, lodScale) {
-    const viewport = frameState.viewport;
-    if (!viewport?.orthographic) {
-      return null;
-    }
-    const metersPerPixel = viewport.metersPerPixel;
-    if (!Number.isFinite(metersPerPixel) || metersPerPixel <= 0) {
-      return null;
-    }
-    return lodMetricValue * lodScale / metersPerPixel;
-  }
-
   // src/tileset-3d/helpers/i3s-lod.ts
   var cameraPositionCartesian = new Vector3();
   var toEye = new Vector3();
@@ -7385,7 +8745,7 @@ var __exports__ = (() => {
   };
 
   // src/tileset-3d/common/tileset-traverser.ts
-  var DEFAULT_PROPS3 = {
+  var DEFAULT_PROPS4 = {
     loadSiblings: false,
     skipLevelOfDetail: false,
     updateTransforms: true,
@@ -7402,9 +8762,11 @@ var __exports__ = (() => {
     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();
@@ -7417,7 +8779,7 @@ var __exports__ = (() => {
     }
     // TODO nested props
     constructor(options) {
-      this.options = { ...DEFAULT_PROPS3, ...options };
+      this.options = { ...DEFAULT_PROPS4, ...options };
     }
     // tiles should be visible
     traverse(root, frameState, options) {
@@ -7430,6 +8792,7 @@ var __exports__ = (() => {
     }
     reset() {
       this.requestedTiles = {};
+      this.deferredTiles = {};
       this.selectedTiles = {};
       this.emptyTiles = {};
       this._traversalStack.reset();
@@ -7482,7 +8845,7 @@ var __exports__ = (() => {
         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);
@@ -7548,11 +8911,28 @@ var __exports__ = (() => {
     // 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);
@@ -7614,12 +8994,17 @@ var __exports__ = (() => {
     // 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;
         }
@@ -7635,7 +9020,7 @@ var __exports__ = (() => {
           }
         }
       }
-      return root.hasEmptyContent || allDescendantsLoaded;
+      return root.hasEmptyContent && !hasPendingLazyChildren || allDescendantsLoaded;
     }
   };
 
@@ -7677,6 +9062,8 @@ var __exports__ = (() => {
     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 Matrix4();
@@ -7695,10 +9082,20 @@ var __exports__ = (() => {
     // 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;
@@ -7743,6 +9140,7 @@ var __exports__ = (() => {
       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();
@@ -7772,7 +9170,17 @@ var __exports__ = (() => {
     }
     /** 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
@@ -7835,13 +9243,28 @@ var __exports__ = (() => {
       }
       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 "I3S" /* I3S */:
           return getProjectedRadius(this, frameState);
         case "TILES3D" /* TILES3D */:
-          return getTiles3DScreenSpaceError(this, frameState, useParentLodMetric);
+          return getTiles3DScreenSpaceError(
+            this,
+            frameState,
+            useParentLodMetric,
+            viewportHeightFraction
+          );
         default:
           throw new Error("Unsupported tileset type");
       }
@@ -7859,12 +9282,34 @@ var __exports__ = (() => {
     _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 === 1 /* ADD */ || skipLevelOfDetail;
@@ -7874,14 +9319,23 @@ var __exports__ = (() => {
       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.
@@ -7923,6 +9377,87 @@ var __exports__ = (() => {
         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) {
@@ -7955,12 +9490,69 @@ var __exports__ = (() => {
       }
       this._distanceToCamera = this.distanceToTile(frameState);
       this._screenSpaceError = this.getScreenSpaceError(frameState, false);
+      this._updateRequestPriorityMetrics(frameState);
       this._visibilityPlaneMask = this.visibility(frameState, parentVisibilityPlaneMask);
       this._visible = this._visibilityPlaneMask !== 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) {
+      if (this.tileset.type !== "TILES3D" /* 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,
+        this.parent?._screenSpaceErrorProgressiveResolution,
+        this.tileset.memoryAdjustedScreenSpaceError,
+        progressiveResolutionHeightFraction
+      );
+      if (!options.foveatedScreenSpaceError || frameState.viewport?.orthographic || !frameState.camera?.position || !frameState.camera?.direction) {
+        this._foveatedFactor = 0;
+        this.priorityDeferred = false;
+        return;
+      }
+      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: this.parent?._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.
@@ -8089,6 +9681,10 @@ var __exports__ = (() => {
       this._distanceToCamera = 0;
       this._centerZDepth = 0;
       this._screenSpaceError = 0;
+      this._screenSpaceErrorProgressiveResolution = 0;
+      this._priorityProgressiveResolution = false;
+      this._foveatedFactor = 0;
+      this.priorityDeferred = false;
       this._visibilityPlaneMask = CullingVolume.MASK_INDETERMINATE;
       this._visible = void 0;
       this._inRequestVolume = false;
@@ -8104,8 +9700,15 @@ var __exports__ = (() => {
     _getRefine(refine) {
       return refine || this.parent && this.parent.refine || 2 /* 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;
+      return this.content?.shape === "tileset3d";
     }
     _onContentLoaded() {
       switch (this.content && this.content.type) {
@@ -8127,6 +9730,13 @@ var __exports__ = (() => {
         this.computedTransform,
         this.boundingVolume
       );
+      if (header.viewerRequestVolume) {
+        this._viewerRequestVolume = createBoundingVolume(
+          header.viewerRequestVolume,
+          this.computedTransform,
+          this._viewerRequestVolume
+        );
+      }
       const content = header.content;
       if (!content) {
         return;
@@ -8138,13 +9748,6 @@ var __exports__ = (() => {
           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.
@@ -8164,9 +9767,72 @@ var __exports__ = (() => {
 
   // src/tileset-3d/format-3d-tiles/tileset-3d-traverser.ts
   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) {
@@ -8249,6 +9915,263 @@ var __exports__ = (() => {
     return size;
   }
 
+  // src/tileset-3d/format-3d-tiles/implicit-tiling.ts
+  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: "empty" /* 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?.constant === "number") {
+      return Boolean(availability.constant);
+    }
+    const bitstream = 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) {
+    if (!contentUrl) {
+      return "empty" /* EMPTY */;
+    }
+    const extension = contentUrl.split("?")[0].split(".").pop()?.toLowerCase();
+    switch (extension) {
+      case "pnts":
+        return "pointcloud" /* POINTCLOUD */;
+      case "i3dm":
+      case "b3dm":
+      case "glb":
+      case "gltf":
+        return "scenegraph" /* SCENEGRAPH */;
+      default:
+        return extension || "empty" /* 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");
+    }
+  }
+
   // src/tileset-3d/format-3d-tiles/tiles-3d-source.ts
   var EMPTY_CONTENT_FORMATS = {
     draco: false,
@@ -8256,6 +10179,7 @@ var __exports__ = (() => {
     dds: false,
     ktx2: false
   };
+  var DEFAULT_MAXIMUM_CACHED_SUBTREES = 32;
   var Tiles3DSource = class {
     /** 3D Tiles format discriminator. */
     type = "TILES3D" /* TILES3D */;
@@ -8284,6 +10208,23 @@ var __exports__ = (() => {
     /** 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;
@@ -8302,6 +10243,22 @@ var __exports__ = (() => {
       this.resolver = request.resolver;
       this.coreApi = request.coreApi;
       this.loadOptions = loadOptions;
+      const maximumCachedSubtrees = Number(
+        loadOptions["3d-tiles"]?.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}.
@@ -8320,7 +10277,9 @@ var __exports__ = (() => {
       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) {
@@ -8330,7 +10289,7 @@ var __exports__ = (() => {
         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;
@@ -8367,7 +10326,7 @@ var __exports__ = (() => {
       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) {
       const rootTile = new Tile3D(tileset, tilesetJson.root, parentTile || void 0);
@@ -8386,7 +10345,7 @@ var __exports__ = (() => {
             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);
@@ -8412,7 +10371,9 @@ var __exports__ = (() => {
         ...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"
         }
       };
@@ -8420,17 +10381,81 @@ var __exports__ = (() => {
       tile.content = content;
       return {
         loaded: true,
-        nestedTileset: tile.contentUrl.includes(".json") ? content : void 0
+        nestedTileset: 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("?");
@@ -8441,7 +10466,26 @@ var __exports__ = (() => {
         }
       }
       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.
@@ -8501,11 +10545,11 @@ var __exports__ = (() => {
     /**
      * 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.
@@ -8517,13 +10561,91 @@ var __exports__ = (() => {
       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) {
+      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 (childHeader.children?.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) {
@@ -8738,7 +10860,7 @@ var __exports__ = (() => {
       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);
       }
     }
@@ -9234,7 +11356,7 @@ var __exports__ = (() => {
     },
     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. */
@@ -9296,7 +11418,7 @@ var __exports__ = (() => {
     }
     /** 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() {
@@ -9738,7 +11860,7 @@ var __exports__ = (() => {
     getImage: async () => null,
     debounceTime: 0
   };
-  var ImageSet = class {
+  var ImageSet = class _ImageSet {
     /** Cached metadata returned by the backing source, if any. */
     metadata = null;
     _opts;
@@ -9761,7 +11883,7 @@ var __exports__ = (() => {
     }
     /** 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() {
@@ -9870,7 +11992,7 @@ var __exports__ = (() => {
         }
         this._emitUpdate();
       } catch (error) {
-        if (isAbortError(error)) {
+        if (isAbortError2(error)) {
           return;
         }
         const normalizedError = normalizeImageSetError(error, "Image request failed");
@@ -9951,7 +12073,7 @@ var __exports__ = (() => {
       this._abortController = null;
     }
   };
-  function isAbortError(error) {
+  function isAbortError2(error) {
     return error instanceof Error && error.name === "AbortError";
   }
   function normalizeImageSetError(error, message) {
@@ -9982,7 +12104,7 @@ var __exports__ = (() => {
     debounceTime: 0,
     shouldRefetch: () => true
   };
-  var RasterSet = class {
+  var RasterSet = class _RasterSet {
     /** Cached metadata returned by the backing source, if any. */
     metadata = null;
     _opts;
@@ -10005,7 +12127,7 @@ var __exports__ = (() => {
     }
     /** 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() {
@@ -10124,7 +12246,7 @@ var __exports__ = (() => {
         }
         this._emitUpdate();
       } catch (error) {
-        if (isAbortError2(error)) {
+        if (isAbortError3(error)) {
           return;
         }
         const normalizedError = normalizeRasterSetError(error, "Raster request failed");
@@ -10213,7 +12335,7 @@ var __exports__ = (() => {
     }
     return new Error(message);
   }
-  function isAbortError2(error) {
+  function isAbortError3(error) {
     return error instanceof Error && error.name === "AbortError";
   }
 
@@ -10283,7 +12405,7 @@ var __exports__ = (() => {
   };
 
   // src/point-cloud/point-cloud-tileset.ts
-  var DEFAULT_PROPS4 = {
+  var DEFAULT_PROPS5 = {
     debounceTime: 0,
     minimumNodePixelSize: 150,
     maximumScreenSpaceError: 1,
@@ -10313,7 +12435,7 @@ var __exports__ = (() => {
     tilesMap = /* @__PURE__ */ new Map();
     constructor(dataSource, options = {}) {
       this.dataSource = dataSource;
-      this.options = { ...DEFAULT_PROPS4, ...options };
+      this.options = { ...DEFAULT_PROPS5, ...options };
       this.tilesetInitializationPromise = this.initialize();
     }
     tilesetInitializationPromise;