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

package/src/tileset-3d/common/tileset-cache.ts

@@ -71,24 +71,32 @@ export class TilesetCache {
     }
   }
 
-  unloadTiles(tileset, unloadCallback): void {
+  /**
+   * 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: Tileset3D,
+    unloadCallback?: (tileset: Tileset3D, tile: Tile3D) => void
+  ): void {
     const trimTiles = this._trimTiles;
     this._trimTiles = false;
 
     const list = this._list;
 
-    const maximumMemoryUsageInBytes = tileset.maximumMemoryUsage * 1024 * 1024;
-
     // Traverse the list only to the sentinel since tiles/nodes to the
     // right of the sentinel were used this frame.
     // The sub-list to the left of the sentinel is ordered from LRU to MRU.
     const sentinel = this._sentinel;
     let node = list.head;
 
-    while (
-      node !== sentinel &&
-      (tileset.gpuMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)
-    ) {
+    while (node !== sentinel && (tileset.gpuMemoryUsageInBytes > tileset.cacheBytes || trimTiles)) {
       // @ts-expect-error
       const tile = node.item;
       // @ts-expect-error

package/src/tileset-3d/common/tileset-content-traversal.ts

@@ -0,0 +1,114 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Tile3D} from './tile-3d';
+import type {Tileset3D} from './tileset-3d';
+import type {TileContentLoadResult} from './tileset-source';
+import type {Tile3DContent} from './tile-3d-contracts';
+import {TILESET_TYPE} from '../../constants';
+
+/** Options for complete camera-independent tileset content traversal. */
+export interface TraverseTilesetContentsOptions {
+  /** Cancel traversal and stop issuing further source requests. */
+  readonly signal?: AbortSignal;
+  /**
+   * Unload content loaded by this traversal when iteration advances or closes, including on error.
+   * Defaults to false. Preloaded content is retained. Use a runtime dedicated to this traversal;
+   * consume payloads before advancing and do not retain them or update the runtime concurrently.
+   */
+  readonly unloadContent?: boolean;
+}
+
+/** One tile placement and its ordered content entries from a completed source read. */
+export interface TilesetContentTraversalItem {
+  /** Runtime tile placement. Shared content resources are yielded once per placement. */
+  readonly tile: Tile3D;
+  /** Ordered content entries, including multiple contents declared by a single tile. */
+  readonly contents: readonly Tile3DContent[];
+}
+
+/**
+ * Walks every declared tile placement and its loaded content without a camera or visibility test.
+ *
+ * Source implementations remain responsible for lazy subtree and node-page resolution. Children
+ * are visited in declaration order, nested tilesets are installed by the source before descent,
+ * and repeated resource URLs are not deduplicated because each placement can have a distinct
+ * transform. Content stays attached unless `unloadContent` is enabled. In that mode, newly loaded
+ * payloads are valid until iteration advances or closes. Tile placements and children remain
+ * available; callers still own the tileset, source, and archive lifetime.
+ *
+ * @param tileset - Initialized or initializing source-backed tileset runtime.
+ * @param options - Cancellation and decoded-content lifetime options.
+ * @returns One item for each visited tile placement in deterministic depth-first order.
+ */
+export async function* traverseTilesetContents(
+  tileset: Tileset3D,
+  options: TraverseTilesetContentsOptions = {}
+): AsyncGenerator<TilesetContentTraversalItem> {
+  await tileset.tilesetInitializationPromise;
+  throwIfAborted(options.signal);
+  if (!tileset.root) {
+    throw new Error('Tileset initialization completed without a root tile');
+  }
+
+  const stack: Tile3D[] = [tileset.root];
+  const visitedTiles = new Set<Tile3D>();
+  while (stack.length > 0) {
+    throwIfAborted(options.signal);
+    const tile = stack.pop() as Tile3D;
+    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: TileContentLoadResult = await tile.loadContentForTraversal();
+        throwIfAborted(options.signal);
+        if (!loadResult.loaded) {
+          throw new Error(`Unable to load tile content for tile ${tile.id}`);
+        }
+        tileset.source.onTileLoaded?.(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]);
+    }
+  }
+}
+
+/** Throws the signal reason when traversal is cancelled. */
+function throwIfAborted(signal?: AbortSignal): void {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException('The operation was aborted', 'AbortError');
+  }
+}

package/src/tileset-3d/common/tileset-observability.ts

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Tileset3D} from './tileset-3d';
+import type {Tile3D} from './tile-3d';
+
+/**
+ * A deterministic, renderer-neutral snapshot of one {@link Tileset3D} traversal.
+ *
+ * Tile IDs are sorted so snapshots can be compared across runs even when child requests complete
+ * in a different order. Counts are reported for the completed traversal frame and cache values are
+ * expressed in bytes. This is an inspection contract; it does not alter traversal or request policy.
+ */
+export type Tileset3DTraversalSnapshot = {
+  /** Monotonically increasing traversal frame number. */
+  frameNumber: number;
+  /** IDs selected for rendering, sorted for stable comparisons. */
+  selectedTileIds: string[];
+  /** IDs whose content was requested, sorted for stable comparisons. */
+  requestedTileIds: string[];
+  /** IDs visited as hierarchy-only or empty tiles, sorted for stable comparisons. */
+  emptyTileIds: string[];
+  /** Number of selected tiles in the completed frame. */
+  visibleTileCount: number;
+  /** Number of selected tiles with renderable content. */
+  renderableTileCount: number;
+  /** Number of tile or subtree loads currently in flight. */
+  loadingTileCount: number;
+  /** Cumulative number of tiles loaded into the runtime cache. */
+  loadedTileCount: number;
+  /** Cumulative number of failed tile loads. */
+  failedTileCount: number;
+  /** Number of tiles currently retained in the runtime cache. */
+  cachedTileCount: number;
+  /** Estimated cached content bytes. */
+  cacheBytes: number;
+  /** Active memory-adjusted maximum SSE in logical/CSS pixels. */
+  maximumScreenSpaceError: number;
+  /** Source-specific implicit subtree counters, when the source exposes them. */
+  implicitTiling?: {
+    /** Number of subtree resources requested from the source. */
+    requestedSubtrees: number;
+    /** Number of subtree resources successfully materialized. */
+    loadedSubtrees: number;
+    /** Number of requests served by the parsed-subtree cache. */
+    cacheHits: number;
+    /** Number of parsed subtrees currently retained for reuse. */
+    cachedSubtrees: number;
+    /** Number of subtree requests currently in flight. */
+    pendingSubtrees: number;
+    /** Number of runtime tile headers created from materialized subtrees. */
+    materializedTiles: number;
+  };
+};
+
+/**
+ * Creates a stable observability snapshot from public {@link Tileset3D} state.
+ *
+ * The helper intentionally reads only public runtime fields and source diagnostics. It is safe to
+ * call from an instrumentation loop and does not retain tile or content references.
+ *
+ * @param tileset - Runtime whose most recent traversal should be inspected.
+ * @returns A serializable snapshot suitable for logs, regression fixtures, and benchmark output.
+ */
+export function getTileset3DTraversalSnapshot(tileset: Tileset3D): Tileset3DTraversalSnapshot {
+  const selectedTiles = tileset.selectedTiles.slice();
+  const requestedTiles = tileset.requestedTiles.slice();
+  const emptyTiles = tileset.emptyTiles.slice();
+
+  const getTileIds = (tiles: readonly Tile3D[]): string[] =>
+    tiles.map(tile => String(tile.id)).sort();
+
+  const getStatCount = (name: string): number => {
+    const count = tileset.stats.get(name).count;
+    return typeof count === 'number' && Number.isFinite(count) ? count : 0;
+  };
+
+  const implicitTilingSource = tileset.source as Tileset3D['source'] & {
+    getImplicitTilingStats?: () => Tileset3DTraversalSnapshot['implicitTiling'];
+  };
+  const implicitTiling = implicitTilingSource.getImplicitTilingStats?.();
+
+  return {
+    frameNumber: tileset.frameNumber,
+    selectedTileIds: getTileIds(selectedTiles),
+    requestedTileIds: getTileIds(requestedTiles),
+    emptyTileIds: getTileIds(emptyTiles),
+    visibleTileCount: selectedTiles.length,
+    renderableTileCount: selectedTiles.filter(
+      tile => tile.contentAvailable && Boolean(tile.content)
+    ).length,
+    loadingTileCount: getStatCount('Tiles Loading'),
+    loadedTileCount: getStatCount('Tiles Loaded'),
+    failedTileCount: getStatCount('Failed Tile Loads'),
+    cachedTileCount: getStatCount('Tiles In Memory'),
+    cacheBytes: tileset.gpuMemoryUsageInBytes,
+    maximumScreenSpaceError: tileset.memoryAdjustedScreenSpaceError,
+    ...(implicitTiling ? {implicitTiling} : {})
+  };
+}

package/src/tileset-3d/common/tileset-source.ts

@@ -2,13 +2,15 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {CoreAPI, LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {CoreAPI, Loader, LoaderOptions} from '@loaders.gl/loader-utils';
 import type {Vector3} from '@math.gl/core';
 import type {TilesetTraverser, TilesetTraverserProps} from './tileset-traverser';
 import type {Tile3D} from './tile-3d';
 import type {Tileset3D} from './tileset-3d';
 import type {FrameState} from '../helpers/frame-state';
 import type {TILESET_TYPE} from '../../constants';
+import type {TilesetSpatialReference} from '../../spatial/spatial-types';
+import type {Tile3DContent} from './tile-3d-contracts';
 
 /**
  * Parsed top-level tileset payload consumed by {@link Tileset3D} or a {@link Tileset3DSource}.
@@ -23,18 +25,14 @@ export type TilesetSourceResolver = {
   /**
    * Loads and parses the root metadata resource for a source.
    */
-  loadRoot<DataT>(
-    url: string,
-    loader: LoaderWithParser<DataT>,
-    loadOptions: LoaderOptions
-  ): Promise<DataT>;
+  loadRoot<DataT>(url: string, loader: Loader<DataT>, loadOptions: LoaderOptions): Promise<DataT>;
 
   /**
    * Loads and parses an arbitrary source-relative resource.
    */
   loadResource<DataT>(
     url: string,
-    loader: LoaderWithParser<DataT>,
+    loader: Loader<DataT>,
     loadOptions: LoaderOptions
   ): Promise<DataT>;
 };
@@ -46,7 +44,7 @@ export type TilesetSourceRequest = {
   /** Absolute root metadata URL. */
   url: string;
   /** Loader used to fetch and parse the root metadata. */
-  loader: LoaderWithParser;
+  loader: Loader;
   /** Optional base path override for relative resources. */
   basePath?: string;
   /** Optional resource-loading strategy used for archive-backed datasets. */
@@ -69,8 +67,24 @@ export type TilesetSourceInput = TilesetJSON | TilesetSourceRequest;
 export type TileContentLoadResult = {
   /** Whether the tile content request produced usable content. */
   loaded: boolean;
+  /** All payloads loaded for a tile, in source order. */
+  contents?: any[];
+  /** Optional normalized renderer-neutral descriptors for each content entry. */
+  contentEntries?: Tile3DContent[];
   /** Nested tileset metadata to install below the loaded tile, if any. */
   nestedTileset?: TilesetJSON;
+  /** Nested tilesets found among multiple content payloads. */
+  nestedTilesets?: TilesetJSON[];
+};
+
+/** Result of a source-managed lazy child-header request. */
+export type TileChildrenLoadResult = {
+  /** Whether a subtree resource was loaded and installed. */
+  loaded: boolean;
+  /** Number of available tiles described by the subtree, including its existing root placeholder. */
+  tileCount: number;
+  /** Number of lazy child-subtree references installed at the new boundary. */
+  childSubtreeCount: number;
 };
 
 /**
@@ -104,8 +118,8 @@ export type TilesetSourceViewState = {
 export type TilesetSourceMetadata = {
   /** Format discriminator. */
   type: TILESET_TYPE;
-  /** Loader used for metadata and content requests. */
-  loader: LoaderWithParser;
+  /** Primary format loader used for metadata and default content requests. */
+  loader: Loader;
   /** Absolute root metadata URL. */
   url: string;
   /** Base path used for relative resource resolution. */
@@ -118,6 +132,8 @@ export type TilesetSourceMetadata = {
   lodMetricValue: number;
   /** Root refinement mode used as fallback by runtime tiles. */
   refine: string;
+  /** Format-discovered coordinate reference system metadata. */
+  spatialReference?: TilesetSpatialReference;
 };
 
 /**
@@ -126,8 +142,8 @@ export type TilesetSourceMetadata = {
 export interface Tileset3DSource {
   /** Tileset format discriminator. */
   readonly type: TILESET_TYPE;
-  /** Loader used for content and metadata requests. */
-  readonly loader: LoaderWithParser;
+  /** Primary format loader used for metadata and default content requests. */
+  readonly loader: Loader;
   /** Absolute URL of the root tileset resource. */
   readonly url: string;
   /** Base directory used for relative resource resolution. */
@@ -157,6 +173,17 @@ export interface Tileset3DSource {
    */
   initialize(): Promise<void>;
 
+  /**
+   * Prepares option-dependent asynchronous source state before runtime headers are constructed.
+   *
+   * I3S uses this hook to sample elevation surfaces for its root bound after `Tileset3D` has
+   * applied spatial options. Sources without asynchronous header preparation omit the hook.
+   */
+  prepareTileset?(tileset: Tileset3D): Promise<void>;
+
+  /** Releases source-local caches and prevents late asynchronous work from mutating runtime tiles. */
+  destroy?(): void;
+
   /**
    * Returns normalized source metadata after initialization completes.
    */
@@ -186,6 +213,25 @@ export interface Tileset3DSource {
    */
   loadTileContent(tile: Tile3D): Promise<TileContentLoadResult>;
 
+  /**
+   * Loads and installs a complete lazy child-header group for a runtime tile.
+   *
+   * Sources that implement this hook retain ownership of resource parsing, caching, query
+   * inheritance, and archive resolution. Traversal calls it only after visibility and LOD checks.
+   */
+  loadTileChildren?(tile: Tile3D, frameState: FrameState): Promise<TileChildrenLoadResult>;
+
+  /**
+   * Loads all source-managed child headers without requiring camera or visibility state.
+   *
+   * This hook is used by complete dataset operations such as conversion. Implementations retain
+   * ownership of implicit subtrees, node pages, archive resolution, and query inheritance.
+   */
+  loadTileChildrenForTraversal?(
+    tile: Tile3D,
+    signal?: AbortSignal
+  ): Promise<TileChildrenLoadResult>;
+
   /**
    * Resolves a tile-relative path to the final request URL.
    */
@@ -204,7 +250,11 @@ export interface Tileset3DSource {
   /**
    * Loads child tile metadata on demand for formats that do not expose the full tree up front.
    */
-  loadChildTileHeader?(parentTile: Tile3D, childId: string, frameState: FrameState): Promise<any>;
+  loadChildTileHeader?(
+    parentTile: Tile3D,
+    childId: string,
+    frameState: FrameState | null
+  ): Promise<any>;
 
   /**
    * Updates source-managed bookkeeping after a tile finishes loading.

package/src/tileset-3d/common/tileset-traverser.ts

@@ -10,6 +10,14 @@ import {FrameState} from '../helpers/frame-state';
 export type TilesetTraverserProps = {
   loadSiblings?: boolean;
   skipLevelOfDetail?: boolean;
+  /** SSE above which tiles remain part of the non-skipping base traversal. */
+  baseScreenSpaceError?: number;
+  /** Required SSE reduction from the nearest requested or loaded ancestor before loading a tile. */
+  skipScreenSpaceErrorFactor?: number;
+  /** Minimum hierarchy levels between requested tiles during skip-LOD traversal. */
+  skipLevels?: number;
+  /** Requests only final tiles that meet the active SSE target when skip-LOD is enabled. */
+  immediatelyLoadDesiredLevelOfDetail?: boolean;
   updateTransforms?: boolean;
   onTraversalEnd?: (frameState) => any;
   viewportTraversersMap?: Record<string, any>;
@@ -19,6 +27,10 @@ export type TilesetTraverserProps = {
 export const DEFAULT_PROPS: Required<TilesetTraverserProps> = {
   loadSiblings: false,
   skipLevelOfDetail: false,
+  baseScreenSpaceError: 1024,
+  skipScreenSpaceErrorFactor: 16,
+  skipLevels: 1,
+  immediatelyLoadDesiredLevelOfDetail: false,
   updateTransforms: true,
   onTraversalEnd: () => {},
   viewportTraversersMap: {},
@@ -28,6 +40,9 @@ export const DEFAULT_PROPS: Required<TilesetTraverserProps> = {
 export class TilesetTraverser {
   options: Required<TilesetTraverserProps>;
 
+  /** Whether loaded content has disabled skip-LOD traversal for this tileset. */
+  disableSkipLevelOfDetail: boolean = false;
+
   // fulfill in traverse call
   root: any = null;
 
@@ -35,6 +50,8 @@ export class TilesetTraverser {
   selectedTiles: Record<string, Tile3D> = {};
   // tiles should be loaded from server
   requestedTiles: Record<string, Tile3D> = {};
+  /** Tiles intentionally held until the camera has remained still for the configured delay. */
+  deferredTiles: Record<string, Tile3D> = {};
   // tiles does not have render content
   emptyTiles: Record<string, Tile3D> = {};
 
@@ -56,6 +73,11 @@ export class TilesetTraverser {
     this.options = {...DEFAULT_PROPS, ...options};
   }
 
+  /** Returns whether skip-LOD traversal is enabled and supported by the loaded content. */
+  isSkipLevelOfDetailEnabled(): boolean {
+    return this.options.skipLevelOfDetail && !this.disableSkipLevelOfDetail;
+  }
+
   // tiles should be visible
   traverse(root, frameState, options) {
     this.root = root; // for root screen space error
@@ -73,6 +95,7 @@ export class TilesetTraverser {
 
   reset() {
     this.requestedTiles = {};
+    this.deferredTiles = {};
     this.selectedTiles = {};
     this.emptyTiles = {};
     this._traversalStack.reset();
@@ -137,7 +160,9 @@ export class TilesetTraverser {
         // Always load tiles in the base traversal
         // Select tiles that can't refine further
         this.loadTile(tile, frameState);
-        if (stoppedRefining) {
+        // Skip-LOD keeps a ready ancestor selected while descendants stream in. This prevents
+        // replacement holes when traversal jumps over one or more hierarchy levels.
+        if (stoppedRefining || this.isSkipLevelOfDetailEnabled()) {
           this.selectTile(tile, frameState);
         }
       }
@@ -149,6 +174,11 @@ export class TilesetTraverser {
       tile._shouldRefine = shouldRefine && parentRefines;
     }
 
+    this.completeTraversal(frameState);
+  }
+
+  /** Notifies the owning tileset when traversal is complete or its debounce interval expires. */
+  protected completeTraversal(frameState: FrameState): void {
     const newTime = new Date().getTime();
     if (this.traversalFinished(frameState) || newTime - this.lastUpdate > this.updateDebounceTime) {
       this.lastUpdate = newTime;
@@ -165,7 +195,8 @@ export class TilesetTraverser {
 
   /* eslint-disable complexity, max-statements */
   updateAndPushChildren(tile: Tile3D, frameState: FrameState, stack, depth): boolean {
-    const {loadSiblings, skipLevelOfDetail} = this.options;
+    const {loadSiblings} = this.options;
+    const skipLevelOfDetail = this.isSkipLevelOfDetailEnabled();
 
     const children = tile.children;
 
@@ -188,9 +219,10 @@ export class TilesetTraverser {
         }
         stack.push(child);
         hasVisibleChild = true;
-      } else if (checkRefines || loadSiblings) {
-        // Keep non-visible children loaded since they are still needed before the parent can refine.
-        // Or loadSiblings is true so always load tiles regardless of visibility.
+      } else if ((checkRefines || loadSiblings) && child._inRequestVolume) {
+        // Keep non-visible children loaded when they are inside their viewer request volume;
+        // they may still be needed before a replacement parent can refine. The request-volume
+        // check intentionally applies to sibling loading as well, preventing off-volume work.
         this.loadTile(child, frameState);
         this.touchTile(child, frameState);
       }
@@ -204,11 +236,9 @@ export class TilesetTraverser {
         } else {
           childRefines = child.contentAvailable;
         }
+        // Readiness controls replacement, not discovery. Visit every sibling so
+        // one unavailable child cannot serialize requests or hide ready siblings.
         refines = refines && childRefines;
-
-        if (!refines) {
-          return false;
-        }
       }
     }
 
@@ -225,7 +255,7 @@ export class TilesetTraverser {
 
   // tile to render in the browser
   selectTile(tile: Tile3D, frameState: FrameState): void {
-    if (this.shouldSelectTile(tile)) {
+    if (this.shouldSelectTile(tile, frameState)) {
       // The tile can be selected right away and does not require traverseAndSelect
       tile._selectedFrame = frameState.frameNumber;
       this.selectedTiles[tile.id] = tile;
@@ -235,12 +265,30 @@ export class TilesetTraverser {
   // tile to load from server
   loadTile(tile: Tile3D, frameState: FrameState): void {
     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: Tile3D): boolean {
+    return tile.priorityDeferred;
+  }
+
   // cache tile
   touchTile(tile: Tile3D, frameState: FrameState): void {
     tile.tileset._cache.touch(tile);
@@ -271,10 +319,13 @@ export class TilesetTraverser {
     return tile.hasUnloadedContent || tile.contentExpired;
   }
 
-  shouldSelectTile(tile: Tile3D): boolean {
-    // if select tile is in current frame
-    // and content available
-    return tile.contentAvailable && !this.options.skipLevelOfDetail;
+  /**
+   * Returns whether a tile's content is available and visible for rendering.
+   * @param tile Tile considered for rendering.
+   * @param frameState Current culling state.
+   */
+  shouldSelectTile(tile: Tile3D, frameState: FrameState): boolean {
+    return tile.contentAvailable && tile.contentVisibility(frameState) !== 'outside';
   }
 
   /** Decide if tile LoD (level of detail) is not sufficient under current viewport */
@@ -323,6 +374,7 @@ export class TilesetTraverser {
   // Ignores visibility.
   executeEmptyTraversal(root: Tile3D, frameState: FrameState): boolean {
     let allDescendantsLoaded = true;
+    let hasPendingLazyChildren = false;
     const stack = this._emptyTraversalStack;
     stack.push(root);
 
@@ -331,6 +383,12 @@ export class TilesetTraverser {
 
       const traverse = !tile.hasRenderContent && this.canTraverse(tile, frameState);
       const emptyLeaf = !tile.hasRenderContent && tile.children.length === 0;
+      if (tile.header.implicitSubtree) {
+        // An unresolved implicit boundary is not a proven empty leaf. Treating it as loaded would
+        // allow REPLACE traversal to drop its ancestor before availability and content are known.
+        hasPendingLazyChildren = true;
+        allDescendantsLoaded = false;
+      }
 
       // Traversal stops but the tile does not have content yet
       // There will be holes if the parent tries to refine to its children, so don't refine
@@ -353,6 +411,6 @@ export class TilesetTraverser {
         }
       }
     }
-    return root.hasEmptyContent || allDescendantsLoaded;
+    return (root.hasEmptyContent && !hasPendingLazyChildren) || allDescendantsLoaded;
   }
 }