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

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

@@ -7,14 +7,26 @@
 import {Matrix4, Vector3} from '@math.gl/core';
 import {Ellipsoid} from '@math.gl/geospatial';
 import {Stats} from '@probe.gl/stats';
-import {RequestScheduler, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+import {RequestScheduler, Loader, LoaderOptions} from '@loaders.gl/loader-utils';
 import {TilesetCache} from './tileset-cache';
 import {calculateTransformProps} from '../helpers/transform-utils';
-import {FrameState, getFrameState, limitSelectedTiles} from '../helpers/frame-state';
+import {getFrameState, limitSelectedTiles, updateCameraMotionState} from '../helpers/frame-state';
+import type {CameraMotionState, FrameState} from '../helpers/frame-state';
+import {
+  calculateDynamicScreenSpaceErrorDensity,
+  updateRootTransformForDynamicScreenSpaceError
+} from '../helpers/tiles-3d-lod';
+import {interpolateLinearly} from '../helpers/tiles-3d-request-priority';
+import type {FoveatedInterpolationCallback} from '../helpers/tiles-3d-request-priority';
 
 import type {GeospatialViewport, Viewport} from '../../types';
 import {Tile3D} from './tile-3d';
 import {TILESET_TYPE} from '../../constants';
+import type {TilesetSpatialOptions, TilesetSpatialReference} from '../../spatial/spatial-types';
+import {
+  applyTilesetSpatialOptions,
+  createTilesetSpatialReference
+} from '../../spatial/spatial-types';
 
 import {TilesetTraverser} from './tileset-traverser';
 import {
@@ -34,8 +46,18 @@ export type Tileset3DProps = {
   loadOptions?: LoaderOptions;
   loadTiles?: boolean;
   basePath?: string;
-  maximumMemoryUsage?: number;
-  memoryCacheOverflow?: number;
+  /**
+   * Soft target, in bytes, for cached tile content that is not required by the current frame.
+   * The listed default applies to 3D Tiles; I3S retains its existing 32 MiB default.
+   * @default 536870912
+   */
+  cacheBytes?: number;
+  /**
+   * Additional bytes that the current-frame working set may use before memory-adjusted SSE rises.
+   * The listed default applies to 3D Tiles; I3S retains its existing 1 MiB default.
+   * @default 536870912
+   */
+  maximumCacheOverflowBytes?: number;
   maximumTilesSelected?: number;
   debounceTime?: number;
 
@@ -44,12 +66,64 @@ export type Tileset3DProps = {
 
   ellipsoid?: object;
   modelMatrix?: Matrix4;
+  /** Automatic CRS output options and expert source-metadata recovery overrides. */
+  spatial?: TilesetSpatialOptions;
 
   maximumScreenSpaceError?: number;
+  /**
+   * Enables replacement traversal that may skip hierarchy levels while retaining ready ancestors
+   * as coverage. This trades temporary overdraw for faster refinement on deep trees.
+   * Defaults to `true` for 3D Tiles and `false` for I3S. Set to `false` to request every level.
+   */
+  skipLevelOfDetail?: boolean;
+  /**
+   * SSE above which tiles remain part of the non-skipping base traversal.
+   * @default 1024
+   */
+  baseScreenSpaceError?: number;
+  /**
+   * Required SSE reduction from the nearest requested or loaded ancestor before loading a tile.
+   * @default 16
+   */
+  skipScreenSpaceErrorFactor?: number;
+  /**
+   * Minimum hierarchy levels between requested tiles during skip-LOD traversal.
+   * @default 1
+   */
+  skipLevels?: number;
+  /**
+   * Requests only final tiles that meet the active SSE target when skip-LOD is enabled.
+   * @default false
+   */
+  immediatelyLoadDesiredLevelOfDetail?: boolean;
+  /** Enables perspective dynamic SSE to reduce distant, horizon-facing refinement. */
+  dynamicScreenSpaceError?: boolean;
+  /** Base dynamic SSE fog density in inverse meters. */
+  dynamicScreenSpaceErrorDensity?: number;
+  /** Maximum dynamic SSE reduction in logical/CSS pixels. */
+  dynamicScreenSpaceErrorFactor?: number;
+  /** Fraction of tileset height at which dynamic SSE begins to fade, clamped to `[0, 1]`. */
+  dynamicScreenSpaceErrorHeightFalloff?: number;
+  /**
+   * Enables adaptive LOD reduction when estimated tile memory exceeds the overflow ceiling.
+   * Defaults to `true` for 3D Tiles and retains the existing `false` default for I3S.
+   */
   memoryAdjustedScreenSpaceError?: boolean;
   viewportTraversersMap?: any;
   updateTransforms?: boolean;
   viewDistanceScale?: number;
+  /** Reduced viewport-height fraction used to prioritize coarse initial coverage; `0` disables it. */
+  progressiveResolutionHeightFraction?: number;
+  /** Whether requests nearer the center of a perspective viewport receive higher priority. */
+  foveatedScreenSpaceError?: boolean;
+  /** Fraction of the perspective field of view that receives no foveated SSE relaxation. */
+  foveatedConeSize?: number;
+  /** Minimum logical-pixel SSE relaxation immediately outside the foveated cone. */
+  foveatedMinimumScreenSpaceErrorRelaxation?: number;
+  /** Function that increases SSE relaxation from the foveated cone toward the viewport edge. */
+  foveatedInterpolationCallback?: FoveatedInterpolationCallback;
+  /** Seconds peripheral requests may wait after the camera moves. */
+  foveatedTimeDelay?: number;
 
   onTileLoad?: (tile: Tile3D) => any;
   onTileUnload?: (tile: Tile3D) => any;
@@ -69,8 +143,10 @@ type Props = {
   modelMatrix: Matrix4;
   throttleRequests: boolean;
   maxRequests: number;
-  maximumMemoryUsage: number;
-  memoryCacheOverflow: number;
+  /** Soft target, in bytes, for evictable cached tile content. */
+  cacheBytes: number;
+  /** Current-frame headroom, in bytes, before memory-adjusted SSE rises. */
+  maximumCacheOverflowBytes: number;
   maximumTilesSelected: number;
   debounceTime: number;
   onTileLoad: (tile: Tile3D) => void;
@@ -81,6 +157,25 @@ type Props = {
   onTraversalComplete: (selectedTiles: Tile3D[]) => Tile3D[];
   onUpdate: () => void;
   maximumScreenSpaceError: number;
+  /** Whether replacement traversal may skip levels while retaining ancestor coverage. */
+  skipLevelOfDetail: boolean;
+  /** SSE above which tiles remain part of the non-skipping base traversal. */
+  baseScreenSpaceError: number;
+  /** Required SSE reduction between requested skip-LOD tiles. */
+  skipScreenSpaceErrorFactor: number;
+  /** Minimum hierarchy levels between requested skip-LOD tiles. */
+  skipLevels: number;
+  /** Whether skip-LOD requests only the final desired tiles. */
+  immediatelyLoadDesiredLevelOfDetail: boolean;
+  /** Whether perspective dynamic SSE is enabled. */
+  dynamicScreenSpaceError: boolean;
+  /** Base dynamic SSE fog density in inverse meters. */
+  dynamicScreenSpaceErrorDensity: number;
+  /** Maximum dynamic SSE reduction in logical/CSS pixels. */
+  dynamicScreenSpaceErrorFactor: number;
+  /** Fraction of tileset height at which dynamic SSE begins to fade. */
+  dynamicScreenSpaceErrorHeightFalloff: number;
+  /** Whether cache pressure may adapt the active SSE threshold. */
   memoryAdjustedScreenSpaceError: boolean;
   viewportTraversersMap: Record<string, any> | null;
   attributions: string[];
@@ -88,19 +183,83 @@ type Props = {
   loadOptions: LoaderOptions;
   updateTransforms: boolean;
   viewDistanceScale: number;
+  /** Reduced viewport-height fraction used to prioritize coarse initial coverage. */
+  progressiveResolutionHeightFraction: number;
+  /** Whether perspective requests are prioritized around the viewport center. */
+  foveatedScreenSpaceError: boolean;
+  /** Fraction of the perspective field of view with no foveated SSE relaxation. */
+  foveatedConeSize: number;
+  /** Minimum logical-pixel SSE relaxation outside the foveated cone. */
+  foveatedMinimumScreenSpaceErrorRelaxation: number;
+  /** Function used to interpolate foveated SSE relaxation. */
+  foveatedInterpolationCallback: FoveatedInterpolationCallback;
+  /** Seconds eligible peripheral requests wait after camera movement. */
+  foveatedTimeDelay: number;
   basePath: string;
   contentLoader?: (tile: Tile3D) => Promise<void>;
   i3s: Record<string, any>;
+  /** Automatic CRS output options and expert source-metadata recovery overrides. */
+  spatial: TilesetSpatialOptions;
 };
 
+const BYTES_PER_MEBIBYTE = 1024 * 1024;
+const DEFAULT_CACHE_BYTES = 512 * BYTES_PER_MEBIBYTE;
+const DEFAULT_MAXIMUM_CACHE_OVERFLOW_BYTES = 512 * BYTES_PER_MEBIBYTE;
+const DEFAULT_I3S_CACHE_BYTES = 32 * BYTES_PER_MEBIBYTE;
+const DEFAULT_I3S_MAXIMUM_CACHE_OVERFLOW_BYTES = BYTES_PER_MEBIBYTE;
+
+/**
+ * Validates a byte-based tile-cache budget.
+ *
+ * Fractions are accepted because JavaScript memory estimates are numbers, but negative, infinite,
+ * and `NaN` values cannot define a stable cache threshold.
+ *
+ * @param value - Proposed cache budget in bytes.
+ * @param optionName - Public option name used in an actionable error message.
+ * @returns The validated byte budget.
+ */
+function validateCacheByteLength(value: number, optionName: string): number {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`${optionName} must be a finite number greater than or equal to 0`);
+  }
+  return value;
+}
+
+/**
+ * Resolves the base cache target from the byte-native option or its fallback.
+ *
+ * @param options - Options that may contain a byte-native cache value.
+ * @param fallbackCacheBytes - Existing or default cache target in bytes.
+ * @returns The resolved and validated cache target in bytes.
+ */
+function resolveCacheBytes(options: Tileset3DProps, fallbackCacheBytes: number): number {
+  const cacheBytes = options.cacheBytes ?? fallbackCacheBytes;
+  return validateCacheByteLength(cacheBytes, 'cacheBytes');
+}
+
+/**
+ * Resolves cache overflow headroom from the byte-native option or its fallback.
+ *
+ * @param options - Options that may contain a byte-native overflow value.
+ * @param fallbackOverflowBytes - Existing or default overflow headroom in bytes.
+ * @returns The resolved and validated overflow headroom in bytes.
+ */
+function resolveMaximumCacheOverflowBytes(
+  options: Tileset3DProps,
+  fallbackOverflowBytes: number
+): number {
+  const maximumCacheOverflowBytes = options.maximumCacheOverflowBytes ?? fallbackOverflowBytes;
+  return validateCacheByteLength(maximumCacheOverflowBytes, 'maximumCacheOverflowBytes');
+}
+
 const DEFAULT_PROPS: Props = {
   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,
   maximumTilesSelected: 0,
   debounceTime: 0,
   onTileLoad: () => {},
@@ -112,15 +271,31 @@ const DEFAULT_PROPS: Props = {
   onUpdate: () => {},
   contentLoader: undefined,
   viewDistanceScale: 1.0,
+  progressiveResolutionHeightFraction: 0.3,
+  foveatedScreenSpaceError: true,
+  foveatedConeSize: 0.1,
+  foveatedMinimumScreenSpaceErrorRelaxation: 0,
+  foveatedInterpolationCallback: interpolateLinearly,
+  foveatedTimeDelay: 0.2,
   maximumScreenSpaceError: 8,
-  memoryAdjustedScreenSpaceError: false,
+  skipLevelOfDetail: false,
+  baseScreenSpaceError: 1024,
+  skipScreenSpaceErrorFactor: 16,
+  skipLevels: 1,
+  immediatelyLoadDesiredLevelOfDetail: false,
+  dynamicScreenSpaceError: true,
+  dynamicScreenSpaceErrorDensity: 2.0e-4,
+  dynamicScreenSpaceErrorFactor: 24,
+  dynamicScreenSpaceErrorHeightFalloff: 0.25,
+  memoryAdjustedScreenSpaceError: true,
   loadTiles: true,
   updateTransforms: true,
   viewportTraversersMap: null,
   loadOptions: {fetch: {}},
   attributions: [],
   basePath: '',
-  i3s: {}
+  i3s: {},
+  spatial: {}
 };
 
 const TILES_TOTAL = 'Tiles In Tileset(s)';
@@ -148,7 +323,7 @@ export class Tileset3D {
 
   type: TILESET_TYPE;
   tileset: TilesetJSON | null;
-  loader: LoaderWithParser;
+  loader: Loader;
   url: string;
   basePath: string;
   modelMatrix: Matrix4;
@@ -159,6 +334,18 @@ export class Tileset3D {
   root: Tile3D | null = null;
   roots: Record<string, Tile3D> = {};
   asset: Record<string, any> = {};
+  /** Inline metadata schema declared by the source tileset, when present. */
+  schema: Record<string, any> | null = null;
+  /** External metadata schema URI declared by the source tileset, when present. */
+  schemaUri: string | null = null;
+  /** Metadata groups declared by the source tileset, in source order. */
+  groups: Array<Record<string, any>> = [];
+  /** Tileset-wide metadata entity, preserved without property-table decoding. */
+  metadata: Record<string, any> | null = null;
+  /** Tileset statistics metadata, preserved for application-level inspection. */
+  statistics: unknown = null;
+  /** Normalized source and target coordinate reference system metadata. */
+  spatialReference: TilesetSpatialReference = createTilesetSpatialReference({});
 
   description = '';
   properties: any;
@@ -174,14 +361,16 @@ export class Tileset3D {
   zoom = 1;
   boundingVolume: any = null;
 
-  dynamicScreenSpaceErrorComputedDensity = 0.0;
+  /** 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.0;
 
-  private _cacheBytes = 0;
-  private _cacheOverflowBytes = 0;
+  private _cacheBytes = DEFAULT_CACHE_BYTES;
+  private _maximumCacheOverflowBytes = DEFAULT_MAXIMUM_CACHE_OVERFLOW_BYTES;
 
   _frameNumber = 0;
   private _tiles: Record<string, Tile3D> = {};
@@ -195,12 +384,17 @@ export class Tileset3D {
   private _requestedTiles: Tile3D[] = [];
   private _emptyTiles: Tile3D[] = [];
   private frameStateData: any = {};
+  /** Last camera pose retained independently for each viewport. */
+  private _cameraMotionStates: Record<string, CameraMotionState> = {};
+  /** Pending traversal that releases requests after camera motion settles. */
+  private _deferredTraversalTimeout: ReturnType<typeof setTimeout> | null = null;
 
   _traverser: TilesetTraverser;
   _cache = new TilesetCache();
   _requestScheduler: RequestScheduler;
 
-  private _heldTiles: Set<string> = new Set();
+  /** Drawn fallback instances retained independently for each viewport tree. */
+  private _heldTiles: Set<Tile3D> = new Set();
   private updatePromise: Promise<number> | null = null;
   tilesetInitializationPromise: Promise<void>;
 
@@ -210,12 +404,33 @@ export class Tileset3D {
    * @param options Traversal and runtime options.
    */
   constructor(source: Tileset3DSource, options?: Tileset3DProps) {
-    this.options = {...DEFAULT_PROPS, ...options};
-    this.loadOptions = this.options.loadOptions || {};
-
     if (!isTileset3DSource(source)) {
       throw new Error('Tileset3D requires a Tileset3DSource instance');
     }
+
+    const suppliedOptions = options || {};
+    const usesTiles3DCacheDefaults = source.type === TILESET_TYPE.TILES3D;
+    const defaultCacheBytes = usesTiles3DCacheDefaults
+      ? DEFAULT_PROPS.cacheBytes
+      : DEFAULT_I3S_CACHE_BYTES;
+    const defaultMaximumCacheOverflowBytes = usesTiles3DCacheDefaults
+      ? DEFAULT_PROPS.maximumCacheOverflowBytes
+      : DEFAULT_I3S_MAXIMUM_CACHE_OVERFLOW_BYTES;
+    const cacheBytes = resolveCacheBytes(suppliedOptions, defaultCacheBytes);
+    const maximumCacheOverflowBytes = resolveMaximumCacheOverflowBytes(
+      suppliedOptions,
+      defaultMaximumCacheOverflowBytes
+    );
+    this.options = {
+      ...DEFAULT_PROPS,
+      ...suppliedOptions,
+      cacheBytes,
+      maximumCacheOverflowBytes,
+      skipLevelOfDetail: suppliedOptions.skipLevelOfDetail ?? source.type === TILESET_TYPE.TILES3D,
+      memoryAdjustedScreenSpaceError:
+        suppliedOptions.memoryAdjustedScreenSpaceError ?? usesTiles3DCacheDefaults
+    };
+    this.loadOptions = this.options.loadOptions || {};
     this.source = source;
 
     this.tileset = null;
@@ -237,8 +452,15 @@ export class Tileset3D {
     });
 
     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;
+    const metadata = this._getSourceMetadata();
+    if (metadata) {
+      this.spatialReference = applyTilesetSpatialOptions(
+        metadata.spatialReference,
+        this.options.spatial
+      );
+    }
 
     this.stats = new Stats({id: this.url});
     this._initializeStats();
@@ -247,6 +469,8 @@ export class Tileset3D {
   }
 
   destroy(): void {
+    this._clearDeferredTraversal();
+    this.source.destroy?.();
     this._destroy();
   }
 
@@ -262,14 +486,84 @@ export class Tileset3D {
     return this._frameNumber;
   }
 
+  /**
+   * Returns the tiles requested during the most recent completed traversal.
+   *
+   * A defensive copy makes request ordering deterministic for diagnostics and prevents callers
+   * from mutating the scheduler's working set.
+   */
+  get requestedTiles(): readonly Tile3D[] {
+    return this._requestedTiles.slice();
+  }
+
+  /**
+   * Returns empty tiles considered during the most recent completed traversal.
+   *
+   * Empty tiles can still be useful hierarchy placeholders, but their IDs are included in
+   * observability snapshots so applications can distinguish traversal work from render content.
+   */
+  get emptyTiles(): readonly Tile3D[] {
+    return this._emptyTiles.slice();
+  }
+
+  /**
+   * 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(): number {
+    return this._cacheBytes;
+  }
+
+  set cacheBytes(value: number) {
+    this._cacheBytes = validateCacheByteLength(value, 'cacheBytes');
+    this.options.cacheBytes = this._cacheBytes;
+  }
+
+  /**
+   * 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(): number {
+    return this._maximumCacheOverflowBytes;
+  }
+
+  set maximumCacheOverflowBytes(value: number) {
+    this._maximumCacheOverflowBytes = validateCacheByteLength(value, 'maximumCacheOverflowBytes');
+    this.options.maximumCacheOverflowBytes = this._maximumCacheOverflowBytes;
+  }
+
   get queryParams(): string {
     const rootUrl = this.source.getTileUrl(this.url);
     const queryIndex = rootUrl.indexOf('?');
     return queryIndex >= 0 ? rootUrl.slice(queryIndex + 1) : '';
   }
 
+  /**
+   * Updates traversal and runtime options while retaining unspecified byte budgets.
+   *
+   * @param props - Partial runtime options to apply.
+   */
   setProps(props: Tileset3DProps): void {
-    this.options = {...this.options, ...props};
+    const cacheBytes = resolveCacheBytes(props, this.cacheBytes);
+    const maximumCacheOverflowBytes = resolveMaximumCacheOverflowBytes(
+      props,
+      this.maximumCacheOverflowBytes
+    );
+    this.options = {
+      ...this.options,
+      ...props,
+      cacheBytes,
+      maximumCacheOverflowBytes
+    };
+    this._cacheBytes = cacheBytes;
+    this._maximumCacheOverflowBytes = maximumCacheOverflowBytes;
   }
 
   getTileUrl(tilePath: string): string {
@@ -312,13 +606,20 @@ export class Tileset3D {
     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(): void {
-    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;
     }
   }
@@ -331,10 +632,20 @@ export class Tileset3D {
       return;
     }
     const preparedViewports = viewports instanceof Array ? viewports : [viewports];
+    const activeViewportIds = new Set(preparedViewports.map(viewport => viewport.id));
+    // A viewport may be removed between frames. Discard its completed state before aggregating
+    // requested and selected tiles so observability reflects only the current traversal inputs.
+    for (const frameStateId of Object.keys(this.frameStateData)) {
+      if (!activeViewportIds.has(frameStateId)) {
+        delete this.frameStateData[frameStateId];
+      }
+    }
 
     this._cache.reset();
     this._frameNumber++;
     this.traverseCounter = preparedViewports.length;
+    const currentTime = Date.now();
+    let minimumDeferredTraversalDelay = Number.POSITIVE_INFINITY;
     const viewportsToTraverse: string[] = [];
     for (const viewport of preparedViewports) {
       const id = viewport.id;
@@ -355,7 +666,70 @@ export class Tileset3D {
         continue;
       }
       const frameState = getFrameState(viewport as GeospatialViewport, 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;
+      // Dynamic SSE reads the root's inverse computed transform before traversal updates tile
+      // visibility. Refresh it from the current tileset model matrix here so animated local
+      // box/sphere tilesets never calculate their height falloff one transform behind the frame.
+      updateRootTransformForDynamicScreenSpaceError(root, this.modelMatrix);
+      frameState.dynamicScreenSpaceErrorDensity =
+        this.type === TILESET_TYPE.TILES3D &&
+        this.options.dynamicScreenSpaceError &&
+        !frameState.viewport.orthographic
+          ? calculateDynamicScreenSpaceErrorDensity(root, frameState, this.options)
+          : 0;
+      // Keep the legacy diagnostic field, but traversal reads the per-viewport frame value above.
+      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.
+   */
+  private _scheduleDeferredTraversal(delayInSeconds: number): void {
+    this._clearDeferredTraversal();
+    this._deferredTraversalTimeout = setTimeout(
+      () => {
+        this._deferredTraversalTimeout = null;
+        this.selectTiles().catch((error: unknown) => {
+          const traversalError = error instanceof Error ? error : new Error(String(error));
+          this._onTilesetError(traversalError);
+        });
+      },
+      Math.max(delayInSeconds * 1000, 0)
+    );
+  }
+
+  /** Clears a pending moving-camera follow-up traversal. */
+  private _clearDeferredTraversal(): void {
+    if (this._deferredTraversalTimeout !== null) {
+      clearTimeout(this._deferredTraversalTimeout);
+      this._deferredTraversalTimeout = null;
     }
   }
 
@@ -410,28 +784,50 @@ export class Tileset3D {
 
     this.selectedTiles = this.options.onTraversalComplete(this.selectedTiles);
 
-    const selectedIds = new Set(this.selectedTiles.map(tile => tile.id));
+    const selectedTiles = new Set(this.selectedTiles);
     const hasUndrawnTiles = this.selectedTiles.some(tile => !tile.tileDrawn);
 
     let heldBackCount = 0;
     if (hasUndrawnTiles) {
-      for (const tileId of selectedIds) {
-        this._heldTiles.add(tileId);
+      const activeRoots = new Set(
+        Object.keys(this.frameStateData).map(viewportId => this.roots[viewportId])
+      );
+      const descendantReadiness = new Map<Tile3D, boolean>();
+      for (const tile of this.selectedTiles) {
+        for (let ancestor = tile.parent; ancestor; ancestor = ancestor.parent) {
+          descendantReadiness.set(
+            ancestor,
+            (descendantReadiness.get(ancestor) ?? true) && tile.tileDrawn
+          );
+        }
       }
-      for (const tileId of this._heldTiles) {
-        if (selectedIds.has(tileId)) continue;
-
-        const tile = this._tiles[tileId];
-        if (tile && tile.contentAvailable) {
+      // Drawing can finish between traversals. Promote only previously selected
+      // geometry that actually drew; pending tiles cannot provide visible fallback.
+      for (const tile of previousSelectedTiles) {
+        if (tile.tileDrawn) this._heldTiles.add(tile);
+      }
+      for (const tile of this._heldTiles) {
+        let root = tile;
+        while (root.parent) root = root.parent;
+        // Removed viewport trees cannot contribute fallback to the remaining views.
+        if (!activeRoots.has(root)) {
+          this._heldTiles.delete(tile);
+          continue;
+        }
+        if (selectedTiles.has(tile)) continue;
+        if (
+          tile.contentAvailable &&
+          !this._hasDrawnReplacement(tile, selectedTiles, descendantReadiness)
+        ) {
           tile._selectedFrame = this._frameNumber;
           this.selectedTiles.push(tile);
           heldBackCount++;
         } else {
-          this._heldTiles.delete(tileId);
+          this._heldTiles.delete(tile);
         }
       }
     } else {
-      this._heldTiles = selectedIds;
+      this._heldTiles = selectedTiles;
     }
 
     if (heldBackCount > 0) {
@@ -453,6 +849,24 @@ export class Tileset3D {
     }
   }
 
+  /**
+   * Releases fallback geometry once its own selected replacement has drawn.
+   * Unrelated pending branches must not delay this region's handoff. When no related
+   * replacement is selected, retain the fallback until the complete selection has drawn.
+   */
+  private _hasDrawnReplacement(
+    tile: Tile3D,
+    selectedTiles: Set<Tile3D>,
+    descendantReadiness: Map<Tile3D, boolean>
+  ): boolean {
+    for (let ancestor = tile.parent; ancestor; ancestor = ancestor.parent) {
+      if (selectedTiles.has(ancestor)) {
+        return ancestor.tileDrawn;
+      }
+    }
+    return descendantReadiness.get(tile) === true;
+  }
+
   _tilesChanged(oldSelectedTiles: Tile3D[], selectedTiles: Tile3D[]): boolean {
     if (oldSelectedTiles.length !== selectedTiles.length) {
       return true;
@@ -475,6 +889,9 @@ export class Tileset3D {
 
   _unloadTiles(): void {
     this._cache.unloadTiles(this, (tileset, tile) => tileset._unloadTile(tile));
+    if (this.options.memoryAdjustedScreenSpaceError) {
+      this.adjustScreenSpaceError();
+    }
   }
 
   _updateStats(): void {
@@ -483,10 +900,13 @@ export class Tileset3D {
     for (const tile of this.selectedTiles) {
       if (tile.contentAvailable && tile.content) {
         tilesRenderable++;
-        if (tile.content.pointCount) {
-          pointsRenderable += tile.content.pointCount;
-        } else {
-          pointsRenderable += tile.content.vertexCount;
+        const contents = tile.contents.length ? tile.contents : [tile.content];
+        for (const content of contents) {
+          if (content.pointCount) {
+            pointsRenderable += content.pointCount;
+          } else {
+            pointsRenderable += content.vertexCount || 0;
+          }
         }
       }
     }
@@ -506,7 +926,8 @@ export class Tileset3D {
       }
       if (
         initialMetadata?.tileset?.root &&
-        typeof initialMetadata.tileset.root.then !== 'function'
+        typeof initialMetadata.tileset.root.then !== 'function' &&
+        (!this.source.prepareTileset || this.spatialReference?.status === 'native')
       ) {
         this.root = this._initializeTileHeaders(initialMetadata.tileset, null);
         this._applyViewState();
@@ -515,6 +936,7 @@ export class Tileset3D {
       await initializePromise;
       const metadata = this.source.getMetadata();
       this._syncSourceState(metadata);
+      await this.source.prepareTileset?.(this);
       if (!this.root) {
         this.root = this._initializeTileHeaders(metadata.tileset, null);
       }
@@ -571,6 +993,28 @@ export class Tileset3D {
     }
   }
 
+  /**
+   * 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: Tile3D, frameState: FrameState): Promise<void> {
+    try {
+      this._onStartTileLoading();
+      await tile.loadChildren(frameState);
+    } catch (error: unknown) {
+      const tileError = error instanceof Error ? error : new Error('subtree load failed');
+      this._onSourceError(tileError, tile);
+      this._onTileLoadError(tile, tileError);
+    } finally {
+      this._onEndTileLoading();
+    }
+  }
+
   _onTileLoadError(tile: Tile3D, error: Error): void {
     this.stats.get(TILES_LOAD_FAILED).incrementCount();
 
@@ -698,6 +1142,20 @@ export class Tileset3D {
     this.refine = metadata.refine;
     this.contentFormats = this.source.contentFormats;
     this.asset = this.source.asset || this.asset;
+    const tileset = metadata.tileset as Record<string, any>;
+    this.schema = tileset.schema || null;
+    this.schemaUri = tileset.schemaUri || null;
+    this.groups = tileset.groups || [];
+    this.metadata = tileset.metadata || null;
+    this.statistics = tileset.statistics ?? null;
+    const spatialReference = applyTilesetSpatialOptions(
+      metadata.spatialReference,
+      this.options.spatial
+    );
+    this.spatialReference = preserveTransformedSpatialReference(
+      this.spatialReference,
+      spatialReference
+    );
     this.properties = this.source.properties ?? this.properties;
     this.extras = this.source.extras ?? this.extras;
     if (this.options.attributions?.length) {
@@ -734,3 +1192,17 @@ export class Tileset3D {
     }
   }
 }
+
+/** Preserve a completed runtime operation when asynchronous source metadata describes the same request. */
+function preserveTransformedSpatialReference(
+  current: TilesetSpatialReference,
+  next: TilesetSpatialReference
+): TilesetSpatialReference {
+  return current?.status === 'transformed' &&
+    current.sourceCrs === next.sourceCrs &&
+    current.targetCrs === next.targetCrs &&
+    current.targetHeightReference === next.targetHeightReference &&
+    current.outputCoordinates === next.outputCoordinates
+    ? current
+    : next;
+}