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

package/dist/index.cjs

@@ -64,7 +64,8 @@ __export(index_exports, {
   registerGeoidModelFromPgm: () => registerGeoidModelFromPgm,
   registerSpatialCrs: () => registerSpatialCrs,
   registerSpatialDatumGrid: () => registerSpatialDatumGrid,
-  replaceImplicitUrlTemplate: () => replaceImplicitUrlTemplate
+  replaceImplicitUrlTemplate: () => replaceImplicitUrlTemplate,
+  traverseTilesetContents: () => traverseTilesetContents
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -113,6 +114,7 @@ var RequestScheduler = class {
   /** Tracks the number of active requests and prioritizes/cancels queued requests. */
   requestQueue = [];
   requestMap = /* @__PURE__ */ new Map();
+  /** Pending arrival debounce or next-tick refill; only new arrivals replace this timer. */
   updateTimer = null;
   constructor(props = {}) {
     this.props = { ...DEFAULT_PROPS, ...props };
@@ -180,20 +182,27 @@ var RequestScheduler = class {
         isDone = true;
         this.requestMap.delete(handle);
         this.activeRequestCount--;
-        this._issueNewRequests();
+        this.scheduleRefill();
       }
     };
     this.activeRequestCount++;
     return resolve2 ? resolve2({ done }) : Promise.resolve({ done });
   }
-  /** We check requests asynchronously, to prevent multiple updates */
+  /** Refills freed slots on the next tick while preserving any pending arrival debounce. */
+  scheduleRefill() {
+    if (this.updateTimer !== null) {
+      return;
+    }
+    this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), 0);
+  }
+  /** Restarts the quiet period when a new request enters the queue. */
   _issueNewRequests() {
     if (this.updateTimer !== null) {
       clearTimeout(this.updateTimer);
     }
     this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime);
   }
-  /** Refresh all requests  */
+  /** Clears timer ownership before updating priorities and dispatching queued requests. */
   _issueNewRequestsAsync() {
     if (this.updateTimer !== null) {
       clearTimeout(this.updateTimer);
@@ -495,6 +504,7 @@ var RangeRequestScheduler = class {
   /** Optional event callback for range batching diagnostics. */
   onEvent;
   pendingRequests = [];
+  /** Pending batch window, independent of in-flight transport requests. */
   flushTimer = null;
   /** Creates a scheduler for one group of byte-range-addressable resources. */
   constructor(props = {}) {
@@ -571,7 +581,7 @@ var RangeRequestScheduler = class {
   }
   /** Immediately starts loading the currently queued requests. */
   flush() {
-    if (this.flushTimer) {
+    if (this.flushTimer !== null) {
       clearTimeout(this.flushTimer);
       this.flushTimer = null;
     }
@@ -593,9 +603,9 @@ var RangeRequestScheduler = class {
       this.fetchMergedRequest(mergedRequest);
     }
   }
-  /** Schedules the next pending-request flush. */
+  /** Starts a fixed batch window only when no flush is already scheduled. */
   scheduleFlush() {
-    if (this.flushTimer) {
+    if (this.flushTimer !== null) {
       return;
     }
     this.flushTimer = setTimeout(() => this.flush(), this.props.batchDelayMs);
@@ -1921,13 +1931,14 @@ function getFrameState(viewport, frameNumber, options = {}) {
     position,
     pitch: 0
   });
+  const verticalFieldOfView = Number.isFinite(viewport.fovy) && Number(viewport.fovy) > 0 && Number(viewport.fovy) < 180 ? Number(viewport.fovy) * Math.PI / 180 : Math.PI / 3;
   return {
     camera: {
       position: cameraPositionCartesian2,
       direction: cameraDirectionCartesian,
       up: cameraUpCartesian,
       cartographicPosition: cameraPositionCartographic,
-      verticalFieldOfView: Number.isFinite(viewport.fovy) && Number(viewport.fovy) > 0 ? Number(viewport.fovy) * Math.PI / 180 : Math.PI / 3,
+      verticalFieldOfView,
       timeSinceMovement: options.timeSinceCameraMovement ?? Number.POSITIVE_INFINITY
     },
     viewport,
@@ -1937,8 +1948,7 @@ function getFrameState(viewport, frameNumber, options = {}) {
     clippingPlanes: viewport.clippingPlanes,
     frameNumber,
     // TODO: This can be the same between updates, what number is unique for between updates?
-    sseDenominator: 1.15,
-    // Assumes fovy = 60 degrees
+    sseDenominator: 2 * Math.tan(verticalFieldOfView / 2),
     // Tileset3D fills this immediately before traversal because it depends on the root volume.
     dynamicScreenSpaceErrorDensity: 0
   };
@@ -2543,11 +2553,11 @@ function validateCacheByteLength(value, optionName) {
   return value;
 }
 function resolveCacheBytes(options, fallbackCacheBytes) {
-  const cacheBytes = options.cacheBytes ?? (options.maximumMemoryUsage !== void 0 ? options.maximumMemoryUsage * BYTES_PER_MEBIBYTE : fallbackCacheBytes);
+  const cacheBytes = options.cacheBytes ?? fallbackCacheBytes;
   return validateCacheByteLength(cacheBytes, "cacheBytes");
 }
 function resolveMaximumCacheOverflowBytes(options, fallbackOverflowBytes) {
-  const maximumCacheOverflowBytes = options.maximumCacheOverflowBytes ?? (options.memoryCacheOverflow !== void 0 ? options.memoryCacheOverflow * BYTES_PER_MEBIBYTE : fallbackOverflowBytes);
+  const maximumCacheOverflowBytes = options.maximumCacheOverflowBytes ?? fallbackOverflowBytes;
   return validateCacheByteLength(maximumCacheOverflowBytes, "maximumCacheOverflowBytes");
 }
 var DEFAULT_PROPS3 = {
@@ -2558,8 +2568,6 @@ var DEFAULT_PROPS3 = {
   maxRequests: 64,
   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: () => {
@@ -2703,8 +2711,6 @@ var Tileset3D = class {
       ...suppliedOptions,
       cacheBytes,
       maximumCacheOverflowBytes,
-      maximumMemoryUsage: cacheBytes / BYTES_PER_MEBIBYTE,
-      memoryCacheOverflow: maximumCacheOverflowBytes / BYTES_PER_MEBIBYTE,
       memoryAdjustedScreenSpaceError: suppliedOptions.memoryAdjustedScreenSpaceError ?? usesTiles3DCacheDefaults
     };
     this.loadOptions = this.options.loadOptions || {};
@@ -2783,7 +2789,6 @@ var Tileset3D = class {
   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.
@@ -2798,17 +2803,6 @@ var Tileset3D = class {
   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);
@@ -2816,10 +2810,7 @@ var Tileset3D = class {
     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.
+   * Updates traversal and runtime options while retaining unspecified byte budgets.
    *
    * @param props - Partial runtime options to apply.
    */
@@ -2830,9 +2821,7 @@ var Tileset3D = class {
       ...this.options,
       ...props,
       cacheBytes,
-      maximumCacheOverflowBytes,
-      maximumMemoryUsage: cacheBytes / BYTES_PER_MEBIBYTE,
-      memoryCacheOverflow: maximumCacheOverflowBytes / BYTES_PER_MEBIBYTE
+      maximumCacheOverflowBytes
     };
     this._cacheBytes = cacheBytes;
     this._maximumCacheOverflowBytes = maximumCacheOverflowBytes;
@@ -3355,6 +3344,68 @@ function getTileset3DTraversalSnapshot(tileset) {
   };
 }
 
+// dist/tileset-3d/common/tileset-content-traversal.js
+async function* traverseTilesetContents(tileset, options = {}) {
+  var _a, _b;
+  await tileset.tilesetInitializationPromise;
+  throwIfAborted(options.signal);
+  if (!tileset.root) {
+    throw new Error("Tileset initialization completed without a root tile");
+  }
+  const stack = [tileset.root];
+  const visitedTiles = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    throwIfAborted(options.signal);
+    const tile = stack.pop();
+    if (visitedTiles.has(tile)) {
+      continue;
+    }
+    visitedTiles.add(tile);
+    if (tile.header.implicitSubtree && tile.childrenState !== "ready") {
+      const loadChildren = tileset.source.loadTileChildrenForTraversal;
+      if (!loadChildren) {
+        throw new Error("Tileset source does not support camera-independent subtree loading");
+      }
+      const result = await loadChildren.call(tileset.source, tile, options.signal);
+      if (!result.loaded) {
+        throw new Error(`Unable to load implicit subtree for tile ${tile.id}`);
+      }
+      tile.childrenState = "ready";
+    }
+    if (tileset.type === TILESET_TYPE.I3S && tileset.source.loadTileChildrenForTraversal) {
+      const result = await tileset.source.loadTileChildrenForTraversal(tile, options.signal);
+      if (!result.loaded) {
+        throw new Error(`Unable to load I3S child nodes for tile ${tile.id}`);
+      }
+    }
+    throwIfAborted(options.signal);
+    const loadsContent = tile.contentUrls.length > 0 && !tile.content;
+    try {
+      if (loadsContent) {
+        const loadResult = await tile.loadContentForTraversal();
+        throwIfAborted(options.signal);
+        if (!loadResult.loaded) {
+          throw new Error(`Unable to load tile content for tile ${tile.id}`);
+        }
+        (_b = (_a = tileset.source).onTileLoaded) == null ? void 0 : _b.call(_a, tileset, tile, loadResult);
+      }
+      yield { tile, contents: tile.contentEntries };
+    } finally {
+      if (options.unloadContent && loadsContent) {
+        tile.unloadContent();
+      }
+    }
+    for (let childIndex = tile.children.length - 1; childIndex >= 0; childIndex--) {
+      stack.push(tile.children[childIndex]);
+    }
+  }
+}
+function throwIfAborted(signal) {
+  if (signal == null ? void 0 : signal.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
+
 // dist/tileset-3d/common/indexed-archive-tileset-source.js
 var IndexedArchiveTilesetSource = class {
   /** URL exposed to the tileset source that owns this archive source. */
@@ -4564,7 +4615,6 @@ var Tile3D = class {
    */
   // eslint-disable-next-line max-statements, complexity
   async loadContent() {
-    var _a;
     if (this.hasEmptyContent) {
       return { loaded: false };
     }
@@ -4582,19 +4632,7 @@ var Tile3D = class {
       return { loaded: false };
     }
     try {
-      const loadResult = await this.tileset.source.loadTileContent(this);
-      if (loadResult.contents) {
-        this.contents = loadResult.contents;
-        this.content = this.contents[0] || null;
-      }
-      this.vectorContent = ((_a = this.contents.find((content) => Boolean(content == null ? void 0 : content.vectorContent))) == null ? void 0 : _a.vectorContent) || null;
-      if (this.tileset.options.contentLoader) {
-        await this.tileset.options.contentLoader(this);
-      }
-      this.contentState = TILE_CONTENT_STATE.READY;
-      this._onContentLoaded();
-      this._updateContentEntriesAfterLoad(loadResult);
-      return loadResult;
+      return await this._loadContentFromSource();
     } catch (error) {
       this.contentState = TILE_CONTENT_STATE.FAILED;
       throw error;
@@ -4602,6 +4640,39 @@ var Tile3D = class {
       requestToken.done();
     }
   }
+  /** Loads content for complete dataset operations without viewport-based request priority. */
+  async loadContentForTraversal() {
+    if (this.hasEmptyContent) {
+      return { loaded: false };
+    }
+    if (this.content) {
+      return { loaded: true, contents: this.contents };
+    }
+    this.contentState = TILE_CONTENT_STATE.LOADING;
+    try {
+      return await this._loadContentFromSource();
+    } catch (error) {
+      this.contentState = TILE_CONTENT_STATE.FAILED;
+      throw error;
+    }
+  }
+  /** Loads source content and updates the tile's renderer-neutral payload state. */
+  async _loadContentFromSource() {
+    var _a;
+    const loadResult = await this.tileset.source.loadTileContent(this);
+    if (loadResult.contents) {
+      this.contents = loadResult.contents;
+      this.content = this.contents[0] || null;
+    }
+    this.vectorContent = ((_a = this.contents.find((content) => Boolean(content == null ? void 0 : content.vectorContent))) == null ? void 0 : _a.vectorContent) || null;
+    if (this.tileset.options.contentLoader) {
+      await this.tileset.options.contentLoader(this);
+    }
+    this.contentState = TILE_CONTENT_STATE.READY;
+    this._onContentLoaded();
+    this._updateContentEntriesAfterLoad(loadResult);
+    return loadResult;
+  }
   /**
    * Requests and installs this tile's lazy child-header group through its source.
    *
@@ -5715,19 +5786,19 @@ function getTilesetSemanticValue(tileset, semantic) {
 // dist/spatial/spatial-coordinate-transformer.js
 var import_core10 = require("@math.gl/core");
 var import_geospatial7 = require("@math.gl/geospatial");
-var import_proj42 = require("@math.gl/proj4");
+var import_projection2 = require("@math.gl/projection");
 
 // dist/spatial/spatial-resource-registry.js
 var import_geoid = require("@math.gl/geoid");
-var import_proj4 = require("@math.gl/proj4");
+var import_projection = require("@math.gl/projection");
 var geoidModels = /* @__PURE__ */ new Map();
 function registerSpatialCrs(name, definition) {
   validateResourceName(name, "CRS");
-  import_proj4.Proj4Projection.defineProjectionAliases({ [name]: definition });
+  import_projection.Projection.defineProjectionAliases({ [name]: definition });
 }
 function registerSpatialDatumGrid(name, data) {
   validateResourceName(name, "datum grid");
-  import_proj4.Proj4Projection.registerDatumGrid(name, data);
+  import_projection.Projection.registerDatumGrid(name, data);
 }
 function registerGeoidModel(name, geoid) {
   validateResourceName(name, "geoid model");
@@ -5782,24 +5853,24 @@ var SpatialCoordinateTransformer = class {
     this.sourceIsGeographic = isWgs84Geographic(spatialReference.sourceCrs);
     this.outputIsGeographic = isWgs84Geographic(outputCrs);
     if (spatialReference.sourceCrs && spatialReference.targetCrs && !this.sourceIsGeocentric && !this.outputIsGeocentric) {
-      this.horizontalProjection = new import_proj42.Proj4Projection({
-        from: getHorizontalProj4Definition(spatialReference.sourceCrs),
-        to: getHorizontalProj4Definition(spatialReference.targetCrs),
+      this.horizontalProjection = new import_projection2.Projection({
+        from: getHorizontalProjectionDefinition(spatialReference.sourceCrs),
+        to: getHorizontalProjectionDefinition(spatialReference.targetCrs),
         enforceAxis: false
       });
     }
     if (requiresHeightTransformation(spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
       if (!this.sourceIsGeographic && !this.sourceIsGeocentric) {
-        this.geographicProjection = new import_proj42.Proj4Projection({
-          from: getHorizontalProj4Definition(spatialReference.sourceCrs),
+        this.geographicProjection = new import_projection2.Projection({
+          from: getHorizontalProjectionDefinition(spatialReference.sourceCrs),
           to: WGS84_GEOGRAPHIC_CRS,
           enforceAxis: false
         });
       }
       if (!this.outputIsGeographic && !this.outputIsGeocentric) {
-        this.heightOutputProjection = new import_proj42.Proj4Projection({
+        this.heightOutputProjection = new import_projection2.Projection({
           from: WGS84_GEOGRAPHIC_CRS,
-          to: getHorizontalProj4Definition(outputCrs),
+          to: getHorizontalProjectionDefinition(outputCrs),
           enforceAxis: false
         });
       }
@@ -5944,11 +6015,18 @@ function inverseTransposeMultiply(jacobianColumns, vector) {
   ];
   return inverseTranspose.map((row) => (row[0] * vector[0] + row[1] * vector[1] + row[2] * vector[2]) / determinant);
 }
-function getHorizontalProj4Definition(definition) {
+function getHorizontalProjectionDefinition(definition) {
   if (!definition) {
     throw new Error("Cannot construct a projection because the CRS is unknown");
   }
-  return (0, import_proj42.toProj4CRSDefinition)(definition, { mode: "horizontal" });
+  if (typeof definition !== "string" && definition.type === "CompoundCRS") {
+    const horizontalComponents = definition.components.filter((component) => component.type !== "VerticalCRS");
+    if (horizontalComponents.length !== 1) {
+      throw new Error("CompoundCRS requires exactly one horizontal component");
+    }
+    return getHorizontalProjectionDefinition(horizontalComponents[0]);
+  }
+  return definition;
 }
 function validateTransformRequest(spatialReference) {
   if (spatialReference.outputCoordinates === "local-enu") {
@@ -6700,6 +6778,8 @@ var Tiles3DSource = class {
   tileUrlCache = /* @__PURE__ */ new Map();
   /** Original content descriptors retained across {@link Tile3D.unloadContent} calls. */
   tileContentHeaders = /* @__PURE__ */ new WeakMap();
+  /** Installed nested roots by parent placement and ordered nested-content slot, across reloads. */
+  nestedTilesetRoots = /* @__PURE__ */ new WeakMap();
   /** Source-local namespaces assigned to distinct embedded glTF package file collections. */
   packageNamespaces = /* @__PURE__ */ new WeakMap();
   /** Next source-local package namespace. */
@@ -6985,6 +7065,13 @@ var Tiles3DSource = class {
       childSubtreeCount: materializedSubtree.childSubtreeCount
     };
   }
+  /** Loads an implicit subtree for dataset traversal without camera state. */
+  async loadTileChildrenForTraversal(tile, signal) {
+    throwIfTraversalAborted(signal);
+    const result = await this.loadTileChildren(tile, {});
+    throwIfTraversalAborted(signal);
+    return result;
+  }
   /**
    * Returns a snapshot of implicit-subtree request, cache, and materialization counters.
    *
@@ -7086,7 +7173,9 @@ var Tiles3DSource = class {
     return this.extensionsUsed.includes(extensionName);
   }
   /**
-   * Updates content-format flags and installs nested tileset subtrees.
+   * Updates content-format flags and installs nested tileset subtrees once per content slot.
+   * Reloading payloads retains attached roots and their descendants, including duplicate URLs
+   * declared in separate slots or parent placements. Detached roots are reinstalled in declaration order.
    */
   onTileLoaded(tileset, tile, loadResult) {
     const contents = tile.contents.length ? tile.contents : [tile.content];
@@ -7104,8 +7193,20 @@ var Tiles3DSource = class {
       this.contentFormats.ktx2 = true;
     }
     const nestedTilesets = loadResult.nestedTilesets || (loadResult.nestedTileset ? [loadResult.nestedTileset] : []);
-    for (const nestedTileset of nestedTilesets) {
-      tileset._initializeTileHeaders(this.prepareNestedTileset(tileset, nestedTileset), tile);
+    const installedRoots = this.nestedTilesetRoots.get(tile) || [];
+    for (const [nestedIndex, nestedTileset] of nestedTilesets.entries()) {
+      const installedRoot = installedRoots[nestedIndex];
+      if (installedRoot && tile.children.includes(installedRoot)) {
+        continue;
+      }
+      const nextRoot = installedRoots.slice(nestedIndex + 1).find((root) => tile.children.includes(root));
+      const nestedRoot = tileset._initializeTileHeaders(this.prepareNestedTileset(tileset, nestedTileset), tile);
+      if (nextRoot) {
+        tile.children.splice(tile.children.indexOf(nestedRoot), 1);
+        tile.children.splice(tile.children.indexOf(nextRoot), 0, nestedRoot);
+      }
+      installedRoots[nestedIndex] = nestedRoot;
+      this.nestedTilesetRoots.set(tile, installedRoots);
     }
   }
   /**
@@ -7312,6 +7413,11 @@ var Tiles3DSource = class {
     return materializedTileCount;
   }
 };
+function throwIfTraversalAborted(signal) {
+  if (signal == null ? void 0 : signal.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
 function isTilesetRequest(input) {
   return Boolean(input && typeof input === "object" && "url" in input && "loader" in input && !("type" in input));
 }
@@ -7481,7 +7587,10 @@ var I3STilesetTraverser = class extends TilesetTraverser {
     const childTiles = tile.children;
     for (const child of children) {
       const extendedId = `${child.id}-${frameState.viewport.id}`;
-      const childTile = childTiles && childTiles.find((t) => t.id === extendedId);
+      const childTile = childTiles && childTiles.find((t) => {
+        var _a;
+        return t.id === extendedId || ((_a = t.header) == null ? void 0 : _a.id) === child.id;
+      });
       if (!childTile) {
         const request = () => this._loadTile(tile, child.id, frameState);
         const cachedRequest = this._tileManager.find(extendedId);
@@ -8305,7 +8414,17 @@ var I3SSource = class {
       }
     };
     tile.content = await this.loadResourceData(contentUrl, options, this.contentLoader);
-    return { loaded: true };
+    const contentEntry = {
+      index: 0,
+      uri: tile.contentUrl,
+      type: tile.header.layerType,
+      payload: tile.content,
+      metadata: tile.header.metadata || null,
+      boundingVolume: tile.boundingVolume,
+      featureIds: tile.featureIdSets,
+      renderable: Boolean(tile.content)
+    };
+    return { loaded: true, contents: [tile.content], contentEntries: [contentEntry] };
   }
   /**
    * Loads child tile metadata on demand from node pages or `/nodes/{id}` resources.
@@ -8328,6 +8447,38 @@ var I3SSource = class {
     const header = await this.loadResourceData(nodeUrl, options);
     return await this.transformTileHeader(header);
   }
+  /** Loads all declared I3S child headers without camera or visibility state. */
+  async loadTileChildrenForTraversal(parentTile, signal) {
+    const childHeaders = parentTile.header.children || [];
+    let loadedChildren = 0;
+    const orderedChildren = [];
+    for (const childHeader of childHeaders) {
+      throwIfTraversalAborted2(signal);
+      const childId = childHeader.id;
+      if (typeof childId !== "string" && typeof childId !== "number") {
+        throw new Error("I3S child header is missing its node ID");
+      }
+      const existingChild = parentTile.children.find((tile) => {
+        var _a;
+        return tile.id === String(childId) || ((_a = tile.header) == null ? void 0 : _a.id) === childId;
+      });
+      if (existingChild) {
+        orderedChildren.push(existingChild);
+        continue;
+      }
+      const childTileHeader = await this.loadChildTileHeader(parentTile, String(childId), null);
+      throwIfTraversalAborted2(signal);
+      const childTile = new Tile3D(parentTile.tileset, childTileHeader, parentTile, String(childId));
+      orderedChildren.push(childTile);
+      loadedChildren++;
+    }
+    const orderedChildSet = new Set(orderedChildren);
+    parentTile.children = [
+      ...orderedChildren,
+      ...parentTile.children.filter((childTile) => !orderedChildSet.has(childTile))
+    ];
+    return { loaded: true, tileCount: loadedChildren, childSubtreeCount: 0 };
+  }
   /**
    * Resolves an I3S request URL with source-managed query parameters.
    */
@@ -8338,20 +8489,21 @@ var I3SSource = class {
     if (!Object.keys(this.queryParams).length) {
       return tilePath;
     }
-    const queryDelimiterIndex = tilePath.indexOf("?");
-    if (queryDelimiterIndex === -1) {
-      return `${tilePath}?${new URLSearchParams(this.queryParams).toString()}`;
-    }
-    const existingQuery = tilePath.slice(queryDelimiterIndex + 1);
-    const existingQueryKeys = new Set(existingQuery.split("&").map((parameter) => parameter.split("=", 1)[0]));
+    const hashIndex = tilePath.indexOf("#");
+    const hash = hashIndex >= 0 ? tilePath.slice(hashIndex) : "";
+    const tilePathWithoutHash = hashIndex >= 0 ? tilePath.slice(0, hashIndex) : tilePath;
+    const queryDelimiterIndex = tilePathWithoutHash.indexOf("?");
+    const path = queryDelimiterIndex === -1 ? tilePathWithoutHash : tilePathWithoutHash.slice(0, queryDelimiterIndex);
+    const existingQuery = queryDelimiterIndex === -1 ? "" : tilePathWithoutHash.slice(queryDelimiterIndex + 1);
+    const existingQueryParams = new URLSearchParams(existingQuery);
     const queryParams = new URLSearchParams();
     for (const [key, value] of Object.entries(this.queryParams)) {
-      if (!existingQueryKeys.has(key)) {
+      if (!existingQueryParams.has(key)) {
         queryParams.set(key, value);
       }
     }
     const queryString = queryParams.toString();
-    return queryString ? `${tilePath}${existingQuery ? "&" : ""}${queryString}` : tilePath;
+    return `${path}${existingQuery ? `?${existingQuery}` : ""}${queryString ? `${existingQuery ? "&" : "?"}${queryString}` : ""}${hash}`;
   }
   /**
    * Derives the default view state from full extent or store extent metadata.
@@ -8455,6 +8607,9 @@ var I3SSource = class {
    * @param loadOptions Loader options that may contain an ArcGIS token.
    */
   initializeQueryParams(loadOptions) {
+    for (const [key, value] of Object.entries(loadOptions.searchParams || {})) {
+      this.queryParams[key] = String(value);
+    }
     const i3sOptions = loadOptions.i3s;
     if (i3sOptions && typeof i3sOptions === "object" && "token" in i3sOptions) {
       const token = i3sOptions.token;
@@ -8494,6 +8649,11 @@ var I3SSource = class {
     };
   }
 };
+function throwIfTraversalAborted2(signal) {
+  if (signal == null ? void 0 : signal.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
 function getI3SContentLoader(loader) {
   return loader.contentLoader || loader;
 }