@loaders.gl/tiles 4.5.3 → 5.0.0-alpha.10

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

@@ -0,0 +1,1310 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+
+import {Vector3, Matrix4} from '@math.gl/core';
+import {CullingVolume} from '@math.gl/culling';
+import type {CullingResult} from '@math.gl/culling';
+import {getTile3DFeatureIdSets} from './tile-3d-contracts';
+import type {Tile3DContent, Tile3DFeatureIdSet, Tile3DMetadataContext} from './tile-3d-contracts';
+
+// Note: circular dependency
+import type {Tileset3D} from './tileset-3d';
+import type {DoublyLinkedListNode} from '../../utils/doubly-linked-list-node';
+import {LOD_METRIC_TYPE, TILE_REFINEMENT, TILE_CONTENT_STATE, TILESET_TYPE} from '../../constants';
+import type {TileChildrenLoadResult, TileContentLoadResult} from './tileset-source';
+
+import {FrameState} from '../helpers/frame-state';
+import {
+  createBoundingVolume,
+  getCartographicBounds,
+  CartographicBounds
+} from '../helpers/bounding-volume';
+import {getTiles3DScreenSpaceError} from '../helpers/tiles-3d-lod';
+import {getProjectedRadius} from '../helpers/i3s-lod';
+import {TilesetTraverser} from './tileset-traverser';
+import {
+  calculateFoveatedFactor,
+  calculateTileRequestPriority,
+  isFoveatedRequestDelayActive,
+  isFoveatedRequestDeferred,
+  isProgressiveResolutionPriority
+} from '../helpers/tiles-3d-request-priority';
+
+const scratchVector = new Vector3();
+
+/**
+ * Classifies render-content visibility across all content volumes owned by a tile.
+ *
+ * Content volumes form a union: one visible content entry keeps the tile renderable even when
+ * another entry is outside the frustum or clipping planes. The traversal volume is intentionally
+ * not used here except as a fallback when a tile has no content-specific volume. This separation
+ * keeps clipping render-only and prevents a tight content volume from pruning descendants.
+ *
+ * @param contentVolumes - Transformed content volumes in source order.
+ * @param fallbackVolume - Tile volume used when content does not declare its own volume.
+ * @param cullingVolume - Current view frustum.
+ * @param visibilityPlaneMask - Parent visibility mask optimization.
+ * @param clippingPlanes - Optional world-space planes applied to render content only.
+ * @returns Union visibility classification for the renderable content.
+ */
+export function getContentVisibility(
+  contentVolumes: any[],
+  fallbackVolume: any,
+  cullingVolume: CullingVolume,
+  visibilityPlaneMask: number | undefined,
+  clippingPlanes: any[] = []
+): CullingResult {
+  const volumes = contentVolumes.length ? contentVolumes : [fallbackVolume];
+  let visibleVolume = false;
+  let intersectingVolume = false;
+  for (const contentVolume of volumes) {
+    let visibility: CullingResult = 'inside';
+    if (visibilityPlaneMask !== CullingVolume.MASK_INSIDE) {
+      visibility = cullingVolume.computeVisibility(contentVolume);
+      if (visibility === 'outside') {
+        continue;
+      }
+    }
+    let clipped = false;
+    for (const clippingPlane of clippingPlanes) {
+      if (contentVolume.intersectPlane(clippingPlane) === 'outside') {
+        clipped = true;
+        break;
+      }
+    }
+    if (!clipped) {
+      visibleVolume = true;
+      intersectingVolume = intersectingVolume || visibility === 'intersecting';
+    }
+  }
+  if (!visibleVolume) {
+    return 'outside';
+  }
+  return intersectingVolume ? 'intersecting' : 'inside';
+}
+
+function isNestedTilesetPayload(payload: unknown): boolean {
+  if (!payload || typeof payload !== 'object') {
+    return false;
+  }
+  const record = payload as Record<string, any>;
+  return record.shape === 'tileset3d' || record.type === 'tileset3d' || Boolean(record.tileset);
+}
+
+function defined(x) {
+  return x !== undefined && x !== null;
+}
+
+/**
+ * @param tileset - Tileset3D instance
+ * @param header - tile header - JSON loaded from a dataset
+ * @param parentHeader - parent Tile3D instance
+ * @param extendedId - optional ID to separate copies of a tile for different viewports.
+ *                              const extendedId = `${tile.id}-${frameState.viewport.id}`;
+ */
+export type Tile3DProps = {
+  tileset: Tileset3D;
+  header: Object;
+  parentHeader: Tile3D;
+  extendedId: string;
+};
+
+/** Lifecycle of a source-managed lazy child-header group. */
+export type TileChildrenState = 'unloaded' | 'loading' | 'ready' | 'failed';
+
+/**
+ * A Tile3DHeader represents a tile as Tileset3D. When a tile is first created, its content is not loaded;
+ * the content is loaded on-demand when needed based on the view.
+ * Do not construct this directly, instead access tiles through {@link Tileset3D#tileVisible}.
+ */
+export class Tile3D {
+  tileset: Tileset3D;
+  header: any;
+  id: string;
+  url: string;
+  parent: Tile3D;
+  /* Specifies the type of refine that is used when traversing this tile for rendering. */
+  refine: TILE_REFINEMENT;
+  type: string;
+  contentUrl: string;
+  /** Resolved render-content URLs in source order; empty for contentless tiles. */
+  contentUrls: string[] = [];
+  /** Different refinement algorithms used by I3S and 3D tiles */
+  lodMetricType = 'geometricError';
+  /**
+   * The world-space geometric error, in meters, introduced if this tile is rendered and its
+   * children are not. For I3S this stores the format's unscaled screen-threshold metric instead.
+   */
+  lodMetricValue: number = 0;
+
+  /**
+   * The source LOD metric before applying the tile's computed transform. Keeping the source value
+   * separate ensures transform updates never compound an already-scaled geometric error.
+   */
+  private _unscaledLodMetricValue: number = 0;
+
+  /** Whether the source format defines geometric error in transform-local units. */
+  private _scaleGeometricError: boolean = true;
+
+  /** @todo math.gl is not exporting BoundingVolume base type? */
+  boundingVolume: any = null;
+
+  /**
+   * The tile's content.  This represents the actual tile's payload,
+   * not the content's metadata in the tileset JSON file.
+   */
+  content: any = null;
+  /** Loaded payloads in the same order as {@link contentUrls}; `content` remains the primary payload. */
+  contents: any[] = [];
+  /** Ordered renderer-neutral descriptors for each source content entry. */
+  contentEntries: Tile3DContent[] = [];
+  /** Raw metadata references inherited by this tile and its content. */
+  metadataContext: Tile3DMetadataContext = {};
+  /** Feature-id declarations normalized from supported content extensions. */
+  featureIdSets: Tile3DFeatureIdSet[] = [];
+  /** Decoded 3D Tiles vector topology for the primary loaded content, when present. */
+  vectorContent: unknown = null;
+  /**
+   * Metadata entity attached to this tile in the source tileset, if present.
+   *
+   * This is the raw 3D Tiles metadata reference. The generic tiles runtime preserves it without
+   * decoding schema classes or binary property tables.
+   */
+  metadata: Record<string, any> | null = null;
+  /** Raw metadata entities attached to tile contents, in content source order. */
+  contentMetadata: Array<Record<string, any> | null> = [];
+  contentState: number = TILE_CONTENT_STATE.UNLOADED;
+  gpuMemoryUsageInBytes: number = 0;
+
+  /** The tile's children - an array of Tile3D objects. */
+  children: Tile3D[] = [];
+  /** Current lifecycle state for a lazy implicit subtree rooted at this tile. */
+  childrenState: TileChildrenState = 'ready';
+  depth: number = 0;
+  viewportIds: any[] = [];
+  transform = new Matrix4();
+  extensions: any = null;
+  /** TODO Cesium 3d tiles specific */
+  implicitTiling?: any = null;
+
+  /** Container to store application specific data */
+  userData: Record<string, any> = {};
+
+  computedTransform: any;
+  hasEmptyContent: boolean = false;
+  hasTilesetContent: boolean = false;
+
+  traverser = new TilesetTraverser({});
+
+  /** Used by TilesetCache */
+  _cacheNode: DoublyLinkedListNode | null = null;
+
+  private _frameNumber: any = null;
+
+  // TODO Cesium 3d tiles specific
+  private _expireDate: any = null;
+  private _expiredContent: any = null;
+
+  /** In-flight source request shared by repeated traversal frames. */
+  private _childrenPromise: Promise<TileChildrenLoadResult> | null = null;
+
+  private _boundingBox?: CartographicBounds = undefined;
+
+  /** updated every frame for tree traversal and rendering optimizations: */
+  public _distanceToCamera: number = 0;
+  _screenSpaceError: number = 0;
+  /** SSE calculated at the reduced viewport height used to prioritize coarse coverage. */
+  _screenSpaceErrorProgressiveResolution: number = 0;
+  /** Whether this tile should be promoted into the progressive-resolution request pass. */
+  _priorityProgressiveResolution: boolean = false;
+  /** Angular distance from the camera view axis used to prioritize center tiles. */
+  _foveatedFactor: number = 0;
+  /** Whether this peripheral request is currently inside the camera-motion deferral window. */
+  priorityDeferred: boolean = false;
+  private _visibilityPlaneMask: any;
+  private _visible: boolean | undefined = undefined;
+
+  private _contentBoundingVolume: any;
+  private _contentBoundingVolumes: any[] = [];
+  /** Source content-volume headers retained after render content is unloaded. */
+  private _contentBoundingVolumeHeaders: any[] = [];
+  private _viewerRequestVolume: any;
+
+  /** Bounding volume used to cull the tile's first renderable content entry. */
+  get contentBoundingVolume(): any {
+    return this._contentBoundingVolume;
+  }
+
+  /** All transformed render-content bounding volumes, including tile-volume fallbacks. */
+  get contentBoundingVolumes(): any[] {
+    return this._contentBoundingVolumes;
+  }
+
+  /** Bounding volume that limits when this tile may be requested, when declared. */
+  get viewerRequestVolume(): any {
+    return this._viewerRequestVolume;
+  }
+
+  /** Accumulated tile transforms from the source JSON, excluding the tileset model matrix. */
+  _initialTransform: Matrix4 = new Matrix4();
+
+  // Used by traverser, cannot be marked private
+  _priority: number = 0;
+  _selectedFrame: number = 0;
+  _requestedFrame: number = 0;
+  _selectionDepth: number = 0;
+  _touchedFrame: number = 0;
+  _centerZDepth: number = 0;
+  _shouldRefine: boolean = false;
+  _stackLength: number = 0;
+  _visitedFrame: number = 0;
+  _inRequestVolume: boolean = false;
+  _lodJudge: any = null; // TODO i3s specific, needs to remove
+
+  /**
+   * Indicates whether the tile has been drawn by the renderer.
+   * Defaults to true for backwards compatibility — renderers that support
+   * transition hold (e.g. deck.gl 9.3+) should set this to false on tile load,
+   * then back to true after first draw to avoid flashes (see deck.gl #7914).
+   */
+  tileDrawn: boolean = true;
+
+  /**
+   * @constructs
+   * Create a Tile3D instance
+   * @param tileset - Tileset3D instance
+   * @param header - tile header - JSON loaded from a dataset
+   * @param parentHeader - parent Tile3D instance
+   * @param extendedId - optional ID to separate copies of a tile for different viewports.
+   *    const extendedId = `${tile.id}-${frameState.viewport.id}`;
+   */
+  // eslint-disable-next-line max-statements
+  constructor(
+    tileset: Tileset3D,
+    header: {[key: string]: any},
+    parentHeader?: Tile3D,
+    extendedId = ''
+  ) {
+    // PUBLIC MEMBERS
+    // original tile data
+    this.header = header;
+
+    // The tileset containing this tile.
+    this.tileset = tileset;
+    this.id = extendedId || header.id;
+    this.url = header.url;
+
+    // This tile's parent or `undefined` if this tile is the root.
+    // @ts-ignore
+    this.parent = parentHeader;
+    this.refine = this._getRefine(header.refine);
+    this.type = header.type;
+    this.contentUrl = header.contentUrl;
+    this.contentUrls = header.contentUrls || (header.contentUrl ? [header.contentUrl] : []);
+    this._initializeMetadata(header);
+    this.childrenState = header.implicitSubtree ? 'unloaded' : 'ready';
+
+    this._initializeLodMetric(header);
+    this._initializeTransforms(header);
+    this._updateLodMetricScale();
+    this._initializeBoundingVolumes(header);
+    this._initializeContent(header);
+    this._initializeContentEntries(header);
+    this._initializeRenderingState(header);
+
+    Object.seal(this);
+  }
+
+  destroy() {
+    this.header = null;
+  }
+
+  isDestroyed() {
+    return this.header === null;
+  }
+
+  get selected() {
+    return this._selectedFrame === this.tileset._frameNumber;
+  }
+
+  get isVisible() {
+    return this._visible;
+  }
+
+  get isVisibleAndInRequestVolume() {
+    return this._visible && this._inRequestVolume;
+  }
+
+  /** Returns true if tile is not an empty tile and not an external tileset */
+  get hasRenderContent() {
+    return !this.hasEmptyContent && !this.hasTilesetContent;
+  }
+
+  /** Returns true if tile has children */
+  get hasChildren() {
+    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(): boolean {
+    return Boolean(
+      this.header.implicitSubtree &&
+        (this.childrenState === 'unloaded' || this.childrenState === 'failed')
+    );
+  }
+
+  /** Returns whether a lazy child-header request is currently in flight. */
+  get childrenLoading(): boolean {
+    return this.childrenState === 'loading';
+  }
+
+  /**
+   * Determines if the tile's content is ready. This is automatically `true` for
+   * tiles with empty content.
+   */
+  get contentReady() {
+    return this.contentState === TILE_CONTENT_STATE.READY || this.hasEmptyContent;
+  }
+
+  /**
+   * Determines if the tile has available content to render.  `true` if the tile's
+   * content is ready or if it has expired content this renders while new content loads; otherwise,
+   */
+  get contentAvailable() {
+    return Boolean(
+      (this.contentReady && this.hasRenderContent) || (this._expiredContent && !this.contentFailed)
+    );
+  }
+
+  /** Returns true if tile has renderable content but it's unloaded */
+  get hasUnloadedContent() {
+    return this.hasRenderContent && this.contentUnloaded;
+  }
+
+  /**
+   * Determines if the tile's content has not be requested. `true` if tile's
+   * content has not be requested; otherwise, `false`.
+   */
+  get contentUnloaded() {
+    return this.contentState === TILE_CONTENT_STATE.UNLOADED;
+  }
+
+  /**
+   * Determines if the tile's content is expired. `true` if tile's
+   * content is expired; otherwise, `false`.
+   */
+  get contentExpired() {
+    return this.contentState === TILE_CONTENT_STATE.EXPIRED;
+  }
+
+  // Determines if the tile's content failed to load.  `true` if the tile's
+  // content failed to load; otherwise, `false`.
+  get contentFailed() {
+    return this.contentState === TILE_CONTENT_STATE.FAILED;
+  }
+
+  /**
+   * Distance from the tile's bounding volume center to the camera
+   */
+  get distanceToCamera(): number {
+    return this._distanceToCamera;
+  }
+
+  /**
+   * Screen space error for LOD selection
+   */
+  get screenSpaceError(): number {
+    return this._screenSpaceError;
+  }
+
+  /**
+   * Get the current world-space bounding volume in cartographic coordinates.
+   * @returns [min, max] each in [longitude, latitude, altitude]
+   */
+  get boundingBox(): CartographicBounds {
+    if (!this._boundingBox) {
+      this._boundingBox = getCartographicBounds(
+        this.header.boundingVolume,
+        this.boundingVolume,
+        !this.computedTransform.equals(this._initialTransform)
+      );
+    }
+    return this._boundingBox;
+  }
+
+  /**
+   * Gets the tile's screen-space error for normal refinement or a reduced-height priority pass.
+   *
+   * I3S already supplies a screen-oriented LOD metric and intentionally ignores the optional 3D
+   * Tiles progressive-resolution height fraction.
+   *
+   * @param frameState - Current camera and viewport measurements.
+   * @param useParentLodMetric - Whether to substitute the parent LOD metric.
+   * @param viewportHeightFraction - Fraction of viewport height represented by the priority pass.
+   * @returns Screen-space LOD error for the current tileset format.
+   */
+  getScreenSpaceError(frameState, useParentLodMetric, viewportHeightFraction = 1) {
+    switch (this.tileset.type) {
+      case TILESET_TYPE.I3S:
+        return getProjectedRadius(this, frameState);
+      case TILESET_TYPE.TILES3D:
+        return getTiles3DScreenSpaceError(
+          this,
+          frameState,
+          useParentLodMetric,
+          viewportHeightFraction
+        );
+      default:
+        // eslint-disable-next-line
+        throw new Error('Unsupported tileset type');
+    }
+  }
+
+  /**
+   * Make tile unselected than means it won't be shown
+   * but it can be still loaded in memory
+   */
+  unselect(): void {
+    this._selectedFrame = 0;
+  }
+
+  /**
+   * Memory usage of tile on GPU
+   */
+  _getGpuMemoryUsageInBytes(): number {
+    const contents = this.contents.length ? this.contents : [this.content];
+    return contents.reduce(
+      (total, content) => total + (content?.gpuMemoryUsageInBytes || content?.byteLength || 0),
+      0
+    );
+  }
+
+  /**
+   * Returns scheduler priority for render-content requests.
+   *
+   * @returns Numeric priority, or a negative value when the queued request should be cancelled.
+   */
+  _getPriority(): number {
+    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.
+   */
+  private _getChildrenPriority(): number {
+    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
+  private _calculateRequestPriority(allowUnloadedContent: boolean): number {
+    const traverser = this.tileset._traverser;
+    const skipLevelOfDetail =
+      traverser.options.skipLevelOfDetail && !traverser.disableSkipLevelOfDetail;
+
+    /*
+     * Tiles that are outside of the camera's frustum could be skipped if we are in 'ADD' mode
+     * or if we are using 'Skip Traversal' in 'REPLACE' mode.
+     * Otherewise, all 'touched' child tiles have to be loaded and displayed,
+     * this may include tiles that are outide of the camera frustum (so that we can hide the parent tile).
+     */
+    const maySkipTile = this.refine === TILE_REFINEMENT.ADD || skipLevelOfDetail;
+
+    // Check if any reason to abort
+    if (maySkipTile && !this.isVisible && this._visible !== undefined) {
+      return -1;
+    }
+    // Condition used in `cancelOutOfViewRequests` function in CesiumJS/Cesium3DTileset.js
+    if (this.tileset._frameNumber - this._touchedFrame >= 1) {
+      return -1;
+    }
+    // RequestScheduler re-evaluates this callback before a queued request receives a slot. A
+    // negative priority cancels work that became deferred after it was queued; the scheduled
+    // follow-up traversal submits it again after the motion delay expires.
+    if (this.priorityDeferred) {
+      return -1;
+    }
+    if (!allowUnloadedContent && this.contentState === TILE_CONTENT_STATE.UNLOADED) {
+      return -1;
+    }
+
+    // Based on the priority function `getPriorityReverseScreenSpaceError` in CesiumJS. Scheduling priority is based on the parent's screen space error when possible.
+    const parent = this.parent;
+    const useParentScreenSpaceError =
+      parent && (!maySkipTile || this._screenSpaceError === 0.0 || parent.hasTilesetContent);
+    const screenSpaceError = useParentScreenSpaceError
+      ? parent._screenSpaceError
+      : this._screenSpaceError;
+
+    const rootScreenSpaceError = traverser.root ? traverser.root._screenSpaceError : 0.0;
+
+    // Map higher SSE to lower values (e.g. root tile is highest priority), then combine the
+    // existing order with independent progressive and foveated priority bands.
+    const reverseScreenSpaceError = Math.max(rootScreenSpaceError - screenSpaceError, 0);
+    return calculateTileRequestPriority({
+      priorityProgressiveResolution: this._priorityProgressiveResolution,
+      foveatedFactor: this._foveatedFactor,
+      reverseScreenSpaceError,
+      rootScreenSpaceError
+    });
+  }
+
+  /**
+   *  Requests the tile's content.
+   * The request may not be made if the Request Scheduler can't prioritize it.
+   */
+  // eslint-disable-next-line max-statements, complexity
+  async loadContent(): Promise<TileContentLoadResult> {
+    if (this.hasEmptyContent) {
+      return {loaded: false};
+    }
+
+    if (this.content) {
+      return {loaded: true};
+    }
+
+    const expired = this.contentExpired;
+
+    if (expired) {
+      this._expireDate = null;
+    }
+
+    this.contentState = TILE_CONTENT_STATE.LOADING;
+
+    const requestToken = await this.tileset._requestScheduler.scheduleRequest(
+      this.id,
+      this._getPriority.bind(this)
+    );
+
+    if (!requestToken) {
+      // cancelled
+      this.contentState = TILE_CONTENT_STATE.UNLOADED;
+      return {loaded: false};
+    }
+
+    try {
+      return await this._loadContentFromSource();
+    } catch (error) {
+      // Tile is unloaded before the content finishes loading
+      this.contentState = TILE_CONTENT_STATE.FAILED;
+      throw error;
+    } finally {
+      requestToken.done();
+    }
+  }
+
+  /** Loads content for complete dataset operations without viewport-based request priority. */
+  async loadContentForTraversal(): Promise<TileContentLoadResult> {
+    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. */
+  private async _loadContentFromSource(): Promise<TileContentLoadResult> {
+    const loadResult = await this.tileset.source.loadTileContent(this);
+    if (loadResult.contents) {
+      this.contents = loadResult.contents;
+      this.content = this.contents[0] || null;
+    }
+    this.vectorContent =
+      this.contents.find(content => Boolean(content?.vectorContent))?.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.
+   *
+   * 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: FrameState): Promise<TileChildrenLoadResult> {
+    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.
+   */
+  private async _loadChildrenWithScheduler(
+    frameState: FrameState
+  ): Promise<TileChildrenLoadResult> {
+    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.
+   *
+   * The placeholder transform is preserved when the subtree omits a root transform. An explicit
+   * subtree-root transform replaces it and is recomposed against the runtime parent. Content,
+   * metadata, bounds, and raw geometric error are reinitialized from the available header.
+   *
+   * @param materializedHeader - Available root header produced from one subtree resource.
+   */
+  applyImplicitSubtreeHeader(materializedHeader: Record<string, any>): void {
+    const existingTransform = this.header.transform;
+    const existingTransformMatrix = this.header.transformMatrix;
+    const hasMaterializedTransform = materializedHeader.transform !== undefined;
+    this.header = {
+      ...this.header,
+      ...materializedHeader,
+      transform: hasMaterializedTransform ? materializedHeader.transform : existingTransform,
+      transformMatrix: hasMaterializedTransform
+        ? materializedHeader.transformMatrix
+        : existingTransformMatrix,
+      implicitSubtree: undefined
+    };
+    if (hasMaterializedTransform) {
+      this._initializeTransforms(this.header);
+    }
+    this.refine = this._getRefine(materializedHeader.refine);
+    this.type = materializedHeader.type;
+    this.contentUrl = materializedHeader.contentUrl;
+    this.contentUrls =
+      materializedHeader.contentUrls ||
+      (materializedHeader.contentUrl ? [materializedHeader.contentUrl] : []);
+    this._initializeMetadata(this.header);
+    this._initializeLodMetric(materializedHeader);
+    this._updateLodMetricScale();
+    this._initializeBoundingVolumes(this.header);
+    this._boundingBox = undefined;
+    // Use the merged header so inherited viewer-request-volume metadata remains available when a
+    // materialized implicit tile has no render content of its own.
+    this._initializeContent(this.header);
+    this._initializeContentEntries(this.header);
+  }
+
+  /** Refreshes tile and content metadata from a source or materialized tile header. */
+  private _initializeMetadata(header: Record<string, any>): void {
+    this.metadata = header.metadata || null;
+    const contentHeaders = Array.isArray(header.content) ? header.content : [header.content];
+    this.contentMetadata = contentHeaders
+      .filter(Boolean)
+      .map(contentHeader => contentHeader.metadata || null);
+    const firstContentHeader = contentHeaders.find(Boolean) || {};
+    const groupReference = firstContentHeader.group;
+    const group =
+      typeof groupReference === 'number'
+        ? this.tileset.groups?.[groupReference] || null
+        : groupReference || null;
+    const metadataContext: Tile3DMetadataContext = {
+      tileset: this.tileset.metadata || null,
+      group,
+      tile: this.metadata,
+      content: this.contentMetadata[0] || null,
+      subtree: header.implicitMetadata || null
+    };
+    if (this.tileset.groups) {
+      metadataContext.groups = this.tileset.groups;
+    }
+    this.metadataContext = metadataContext;
+  }
+
+  /** Updates payload and renderability while retaining immutable metadata descriptors. */
+  private _updateContentEntriesAfterLoad(loadResult: TileContentLoadResult): void {
+    if (loadResult.contentEntries) {
+      this.contentEntries = loadResult.contentEntries.map((entry, index) => ({
+        ...entry,
+        index,
+        boundingVolume:
+          entry.boundingVolume || this._contentBoundingVolumes[index] || this.boundingVolume,
+        payload: entry.payload ?? this.contents[index] ?? null,
+        featureIds: entry.featureIds?.length
+          ? entry.featureIds
+          : getTile3DFeatureIdSets(entry.payload ?? this.contents[index]),
+        renderable: Boolean(
+          entry.renderable !== false &&
+            (entry.payload ?? this.contents[index]) &&
+            !isNestedTilesetPayload(entry.payload ?? this.contents[index])
+        )
+      }));
+      this.featureIdSets = this.contentEntries.flatMap(entry => entry.featureIds);
+      return;
+    }
+    this.contentEntries = this.contentEntries.map((entry, index) => ({
+      ...entry,
+      payload: this.contents[index] ?? null,
+      featureIds: getTile3DFeatureIdSets(this.contents[index]),
+      renderable: Boolean(this.contents[index]) && !isNestedTilesetPayload(this.contents[index])
+    }));
+    this.featureIdSets = this.contentEntries.flatMap(entry => entry.featureIds);
+  }
+
+  /** Returns one ordered content descriptor, or null when the index is out of range. */
+  getContentEntry(index: number): Tile3DContent | null {
+    return this.contentEntries[index] || null;
+  }
+
+  /** Returns whether an ordered content entry currently has renderable payload. */
+  isContentRenderable(index: number): boolean {
+    return Boolean(this.contentEntries[index]?.renderable);
+  }
+
+  /** Initializes additive renderer-neutral descriptors from a normalized tile header. */
+  private _initializeContentEntries(tileHeader: Record<string, any>): void {
+    const headers = Array.isArray(tileHeader.content)
+      ? tileHeader.content
+      : tileHeader.content
+        ? [tileHeader.content]
+        : [];
+    this.contentEntries = headers.map((contentHeader, index) => {
+      const normalizedContentHeader = contentHeader || {};
+      return {
+        index,
+        uri: this.contentUrls[index] || normalizedContentHeader.uri || normalizedContentHeader.url,
+        group: normalizedContentHeader.group,
+        type: normalizedContentHeader.type,
+        payload: null,
+        metadata: normalizedContentHeader.metadata || null,
+        boundingVolume: this._contentBoundingVolumes[index] || this.boundingVolume,
+        featureIds: this._getFeatureIdSets(normalizedContentHeader),
+        renderable: false
+      };
+    });
+  }
+
+  /** Extracts renderer-neutral feature-id declarations without decoding property values. */
+  private _getFeatureIdSets(contentHeader: Record<string, any>): Tile3DFeatureIdSet[] {
+    return getTile3DFeatureIdSets(contentHeader);
+  }
+
+  // Unloads the tile's content.
+  unloadContent() {
+    for (const content of this.contents.length ? this.contents : [this.content]) {
+      if (content && content.destroy) {
+        content.destroy();
+      }
+    }
+    this.contents = [];
+    this.content = null;
+    this.vectorContent = null;
+    this.contentEntries = this.contentEntries.map(entry => ({
+      ...entry,
+      payload: null,
+      renderable: false
+    }));
+    this.featureIdSets = this.contentEntries.flatMap(entry => entry.featureIds);
+    if (this.header.content && this.header.content.destroy) {
+      this.header.content.destroy();
+    }
+    this.header.content = null;
+    this.contentState = TILE_CONTENT_STATE.UNLOADED;
+    this.tileDrawn = true;
+    return true;
+  }
+
+  /**
+   * Update the tile's visibility
+   * @param {Object} frameState - frame state for tile culling
+   * @param {string[]} viewportIds - a list of viewport ids that show this tile
+   * @return {void}
+   */
+  updateVisibility(frameState, viewportIds) {
+    if (this._frameNumber === frameState.frameNumber) {
+      // Return early if visibility has already been checked during the traversal.
+      // The visibility may have already been checked if the cullWithChildrenBounds optimization is used.
+      return;
+    }
+
+    const parent = this.parent;
+    const parentVisibilityPlaneMask = parent
+      ? parent._visibilityPlaneMask
+      : CullingVolume.MASK_INDETERMINATE;
+
+    if (this.tileset._traverser.options.updateTransforms) {
+      const parentTransform = parent ? parent.computedTransform : this.tileset.modelMatrix;
+      this._updateTransform(parentTransform);
+    }
+
+    this._distanceToCamera = this.distanceToTile(frameState);
+    this._screenSpaceError = this.getScreenSpaceError(frameState, false);
+    this._updateRequestPriorityMetrics(frameState);
+    this._visibilityPlaneMask = this.visibility(frameState, parentVisibilityPlaneMask); // Use parent's plane mask to speed up visibility test
+    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: FrameState): void {
+    if (this.tileset.type !== TILESET_TYPE.TILES3D) {
+      this._screenSpaceErrorProgressiveResolution = this._screenSpaceError;
+      this._priorityProgressiveResolution = false;
+      this._foveatedFactor = 0;
+      this.priorityDeferred = false;
+      return;
+    }
+
+    const options = this.tileset.options;
+    const progressiveResolutionHeightFraction = options.progressiveResolutionHeightFraction;
+    this._screenSpaceErrorProgressiveResolution = this.getScreenSpaceError(
+      frameState,
+      false,
+      progressiveResolutionHeightFraction
+    );
+    this._priorityProgressiveResolution = isProgressiveResolutionPriority(
+      this._screenSpaceErrorProgressiveResolution,
+      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 traverser = this.tileset._traverser;
+    const skipLevelOfDetail =
+      traverser.options.skipLevelOfDetail && !traverser.disableSkipLevelOfDetail;
+    const deferralEligible = isFoveatedRequestDeferred({
+      refinement: this.refine,
+      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.
+  // @returns {Number} A plane mask as described above in {@link CullingVolume#computeVisibilityWithPlaneMask}.
+  visibility(frameState, parentVisibilityPlaneMask) {
+    const {cullingVolume} = frameState;
+    const {boundingVolume} = this;
+
+    // TODO Cesium specific - restore clippingPlanes
+    // const {clippingPlanes, clippingPlanesOriginMatrix} = tileset;
+    // if (clippingPlanes && clippingPlanes.enabled) {
+    //   const intersection = clippingPlanes.computeIntersectionWithBoundingVolume(
+    //     boundingVolume,
+    //     clippingPlanesOriginMatrix
+    //   );
+    //   this._isClipped = intersection !== Intersect.INSIDE;
+    //   if (intersection === Intersect.OUTSIDE) {
+    //     return CullingVolume.MASK_OUTSIDE;
+    //   }
+    // }
+
+    // return cullingVolume.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);
+    return cullingVolume.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);
+  }
+
+  /**
+   * Determines whether renderable content intersects the view and configured clipping planes.
+   *
+   * Clipping planes are render-only constraints; traversal continues to use the tile volume.
+   *
+   * @param frameState Current camera, culling, and optional clipping-plane state.
+   * @returns The content visibility classification.
+   */
+  contentVisibility(frameState: FrameState, contentIndex?: number): CullingResult {
+    const contentVolumes =
+      contentIndex === undefined
+        ? this._contentBoundingVolumes
+        : this._contentBoundingVolumes[contentIndex]
+          ? [this._contentBoundingVolumes[contentIndex]]
+          : [];
+    return getContentVisibility(
+      contentVolumes,
+      this.boundingVolume,
+      frameState.cullingVolume,
+      this._visibilityPlaneMask,
+      frameState.clippingPlanes
+    );
+  }
+
+  /**
+   * Computes the (potentially approximate) distance from the closest point of the tile's bounding volume to the camera.
+   * @param frameState The frame state.
+   * @returns {Number} The distance, in meters, or zero if the camera is inside the bounding volume.
+   */
+  distanceToTile(frameState: FrameState): number {
+    const boundingVolume = this.boundingVolume;
+    return Math.sqrt(Math.max(boundingVolume.distanceSquaredTo(frameState.camera.position), 0));
+  }
+
+  /**
+   * Computes the tile's camera-space z-depth.
+   * @param frameState The frame state.
+   * @returns The distance, in meters.
+   */
+  cameraSpaceZDepth({camera}): number {
+    const boundingVolume = this.boundingVolume; // Gets the underlying OrientedBoundingBox or BoundingSphere
+    scratchVector.subVectors(boundingVolume.center, camera.position);
+    return camera.direction.dot(scratchVector);
+  }
+
+  /**
+   * Checks if the camera is inside the viewer request volume.
+   * @param {FrameState} frameState The frame state.
+   * @returns {Boolean} Whether the camera is inside the volume.
+   */
+  insideViewerRequestVolume(frameState: FrameState) {
+    const viewerRequestVolume = this._viewerRequestVolume;
+    return (
+      !viewerRequestVolume || viewerRequestVolume.distanceSquaredTo(frameState.camera.position) <= 0
+    );
+  }
+
+  // TODO Cesium specific
+
+  // Update whether the tile has expired.
+  updateExpiration() {
+    if (defined(this._expireDate) && this.contentReady && !this.hasEmptyContent) {
+      const now = Date.now();
+      // @ts-ignore Date.lessThan - replace with ms compare?
+      if (Date.lessThan(this._expireDate, now)) {
+        this.contentState = TILE_CONTENT_STATE.EXPIRED;
+        this._expiredContent = this.content;
+      }
+    }
+  }
+
+  get extras() {
+    return this.header.extras;
+  }
+
+  // INTERNAL METHODS
+
+  /** Initializes the tile's LOD metric from its header or its nearest available ancestor. */
+  _initializeLodMetric(header: {[key: string]: any}): void {
+    this._scaleGeometricError =
+      typeof header._scaleGeometricError === 'boolean'
+        ? header._scaleGeometricError
+        : (this.parent?._scaleGeometricError ?? true);
+    if ('lodMetricType' in header) {
+      this.lodMetricType = header.lodMetricType;
+    } else {
+      this.lodMetricType = (this.parent && this.parent.lodMetricType) || this.tileset.lodMetricType;
+      // eslint-disable-next-line
+      console.warn(`3D Tile: Required prop lodMetricType is undefined. Using parent lodMetricType`);
+    }
+
+    // This is used to compute screen space error, i.e., the error measured in pixels.
+    if ('lodMetricValue' in header) {
+      this._unscaledLodMetricValue = header.lodMetricValue;
+    } else {
+      // Inherit the source value, not the parent's world-space value. The child's complete
+      // transform will be applied after transform initialization below.
+      this._unscaledLodMetricValue = this.parent
+        ? this.parent._unscaledLodMetricValue
+        : this.tileset.lodMetricValue;
+      // eslint-disable-next-line
+      console.warn(
+        '3D Tile: Required prop lodMetricValue is undefined. Using parent lodMetricValue'
+      );
+    }
+
+    this.lodMetricValue = this._unscaledLodMetricValue;
+  }
+
+  _initializeTransforms(tileHeader) {
+    // The local transform of this tile.
+    this.transform = tileHeader.transform ? new Matrix4(tileHeader.transform) : new Matrix4();
+
+    const parent = this.parent;
+    const tileset = this.tileset;
+
+    const parentTransform =
+      parent && parent.computedTransform
+        ? parent.computedTransform.clone()
+        : tileset.modelMatrix.clone();
+    this.computedTransform = new Matrix4(parentTransform).multiplyRight(this.transform);
+
+    const parentInitialTransform =
+      parent && parent._initialTransform ? parent._initialTransform.clone() : new Matrix4();
+    this._initialTransform = new Matrix4(parentInitialTransform).multiplyRight(this.transform);
+  }
+
+  /**
+   * Updates the world-space LOD metric from the source metric and the complete tile transform.
+   *
+   * 3D Tiles geometric error is a distance in the tile's local meters. Screen-space error (SSE)
+   * compares that distance with a world-space camera distance, so both quantities must use the
+   * same scale. For non-uniform transforms the largest axis scale is deliberately used: this is
+   * conservative and prevents refinement from stopping while any transformed dimension can still
+   * exceed the requested visual error. Rotation and translation do not affect the scale.
+   *
+   * I3S `maxScreenThreshold` is already a screen-space metric and must not be transform-scaled.
+   */
+  _updateLodMetricScale(): void {
+    if (this.lodMetricType !== LOD_METRIC_TYPE.GEOMETRIC_ERROR || !this._scaleGeometricError) {
+      this.lodMetricValue = this._unscaledLodMetricValue;
+      return;
+    }
+
+    const transformScale = this.computedTransform.getScale(scratchVector);
+    const maximumScale = Math.max(transformScale[0], transformScale[1], transformScale[2]);
+    this.lodMetricValue = this._unscaledLodMetricValue * maximumScale;
+  }
+
+  _initializeBoundingVolumes(tileHeader) {
+    this._contentBoundingVolume = null;
+    this._contentBoundingVolumeHeaders = [];
+    this._viewerRequestVolume = null;
+
+    this._updateBoundingVolume(tileHeader);
+  }
+
+  _initializeContent(tileHeader) {
+    // Empty tile by default
+    this.content = {_tileset: this.tileset, _tile: this};
+    this.contents = [];
+    this.hasEmptyContent = true;
+    this.contentState = TILE_CONTENT_STATE.UNLOADED;
+
+    // When `true`, the tile's content points to an external tileset.
+    // This is `false` until the tile's content is loaded.
+    this.hasTilesetContent = false;
+
+    if (tileHeader.contentUrl || tileHeader.contentUrls?.length) {
+      this.content = null;
+      this.hasEmptyContent = false;
+    }
+  }
+
+  // TODO - remove anything not related to basic visibility detection
+  _initializeRenderingState(header) {
+    this.depth = header.level || (this.parent ? this.parent.depth + 1 : 0);
+    this._shouldRefine = false;
+
+    // Members this are updated every frame for tree traversal and rendering optimizations:
+    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 = undefined;
+    this._inRequestVolume = false;
+
+    this._stackLength = 0;
+    this._selectionDepth = 0;
+
+    this._frameNumber = 0;
+    this._touchedFrame = 0;
+    this._visitedFrame = 0;
+    this._selectedFrame = 0;
+    this._requestedFrame = 0;
+
+    this._priority = 0.0;
+  }
+
+  _getRefine(refine) {
+    // Inherit from parent tile if omitted.
+    return refine || (this.parent && this.parent.refine) || TILE_REFINEMENT.REPLACE;
+  }
+
+  /**
+   * Returns whether loaded content is an external tileset.
+   *
+   * Parsed shape is authoritative because valid external resources may be extensionless, signed,
+   * or use a misleading filename. This method is called only after source loading has populated
+   * `content`.
+   */
+  _isTileset(): boolean {
+    return (this.contents.length ? this.contents : [this.content]).some(
+      content => content?.shape === 'tileset3d'
+    );
+  }
+
+  _onContentLoaded() {
+    // Vector and Geometry tile rendering do not support the skip LOD optimization.
+    const contents = this.contents.length ? this.contents : [this.content];
+    for (const content of contents) {
+      switch (content && content.type) {
+        case 'vctr':
+        case 'geom':
+          // @ts-ignore
+          this.tileset._traverser.disableSkipLevelOfDetail = true;
+          break;
+        default:
+      }
+    }
+
+    // The content may be tileset json
+    if (this._isTileset()) {
+      this.hasTilesetContent = true;
+    } else {
+      this.gpuMemoryUsageInBytes = this._getGpuMemoryUsageInBytes();
+    }
+  }
+
+  _updateBoundingVolume(header) {
+    this._boundingBox = undefined;
+    // Update the bounding volumes
+    this.boundingVolume = createBoundingVolume(
+      header.boundingVolume,
+      this.computedTransform,
+      this.boundingVolume,
+      this._initialTransform
+    );
+
+    // Viewer request volumes constrain traversal, not just render content. A contentless implicit
+    // connector can still own an inherited request volume, so initialize it before the
+    // content-specific early return below.
+    if (header.viewerRequestVolume) {
+      this._viewerRequestVolume = createBoundingVolume(
+        header.viewerRequestVolume,
+        this.computedTransform,
+        this._viewerRequestVolume,
+        this._initialTransform
+      );
+    }
+
+    const content = header.content;
+    if (content) {
+      this._contentBoundingVolumeHeaders = Array.isArray(content) ? content : [content];
+    }
+    const contentHeaders = content
+      ? Array.isArray(content)
+        ? content
+        : [content]
+      : this._contentBoundingVolumeHeaders;
+    // Preserve source order: an unbounded content entry uses the tile volume at its
+    // corresponding index rather than being appended after bounded sibling entries.
+    this._contentBoundingVolumes = contentHeaders.length
+      ? contentHeaders.map(headerEntry =>
+          headerEntry?.boundingVolume
+            ? createBoundingVolume(
+                headerEntry.boundingVolume,
+                this.computedTransform,
+                undefined,
+                this._initialTransform
+              )
+            : this.boundingVolume
+        )
+      : [this.boundingVolume];
+    this._contentBoundingVolume = this._contentBoundingVolumes[0] || null;
+  }
+
+  /**
+   * Updates the tile's computed transform, world-space geometric error, and bounding volumes.
+   * @param parentTransform - Current computed transform of the parent tile or tileset.
+   */
+  _updateTransform(parentTransform = new Matrix4()): void {
+    const computedTransform = parentTransform.clone().multiplyRight(this.transform);
+    const didTransformChange = !computedTransform.equals(this.computedTransform);
+
+    if (!didTransformChange) {
+      return;
+    }
+
+    this.computedTransform = computedTransform;
+
+    // Recalculate from the unscaled source metric so repeated model-matrix changes never compound.
+    this._updateLodMetricScale();
+    this._updateBoundingVolume(this.header);
+  }
+}