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

package/dist/tileset-3d/common/tileset-3d.js

@@ -8,16 +8,63 @@ import { Stats } from '@probe.gl/stats';
 import { RequestScheduler } from '@loaders.gl/loader-utils';
 import { TilesetCache } from "./tileset-cache.js";
 import { calculateTransformProps } from "../helpers/transform-utils.js";
-import { getFrameState, limitSelectedTiles } from "../helpers/frame-state.js";
+import { getFrameState, limitSelectedTiles, updateCameraMotionState } from "../helpers/frame-state.js";
+import { calculateDynamicScreenSpaceErrorDensity, updateRootTransformForDynamicScreenSpaceError } from "../helpers/tiles-3d-lod.js";
+import { interpolateLinearly } from "../helpers/tiles-3d-request-priority.js";
+import { TILESET_TYPE } from "../../constants.js";
+import { applyTilesetSpatialOptions, createTilesetSpatialReference } from "../../spatial/spatial-types.js";
 import { isTileset3DSource } from "./tileset-source.js";
+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, optionName) {
+    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, fallbackCacheBytes) {
+    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, fallbackOverflowBytes) {
+    const maximumCacheOverflowBytes = options.maximumCacheOverflowBytes ?? fallbackOverflowBytes;
+    return validateCacheByteLength(maximumCacheOverflowBytes, 'maximumCacheOverflowBytes');
+}
 const DEFAULT_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: () => { },
@@ -29,15 +76,31 @@ const DEFAULT_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)';
 const TILES_IN_MEMORY = 'Tiles In Memory';
@@ -73,6 +136,18 @@ export class Tileset3D {
     root = null;
     roots = {};
     asset = {};
+    /** Inline metadata schema declared by the source tileset, when present. */
+    schema = null;
+    /** External metadata schema URI declared by the source tileset, when present. */
+    schemaUri = null;
+    /** Metadata groups declared by the source tileset, in source order. */
+    groups = [];
+    /** Tileset-wide metadata entity, preserved without property-table decoding. */
+    metadata = null;
+    /** Tileset statistics metadata, preserved for application-level inspection. */
+    statistics = null;
+    /** Normalized source and target coordinate reference system metadata. */
+    spatialReference = createTilesetSpatialReference({});
     description = '';
     properties;
     extras = null;
@@ -84,12 +159,14 @@ export class Tileset3D {
     cartesianCenter = null;
     zoom = 1;
     boundingVolume = null;
-    dynamicScreenSpaceErrorComputedDensity = 0.0;
-    maximumMemoryUsage = 32;
+    /** Effective dynamic SSE density calculated for the most recently traversed viewport. */
+    dynamicScreenSpaceErrorComputedDensity = 0;
+    /** 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;
-    _cacheBytes = 0;
-    _cacheOverflowBytes = 0;
+    _cacheBytes = DEFAULT_CACHE_BYTES;
+    _maximumCacheOverflowBytes = DEFAULT_MAXIMUM_CACHE_OVERFLOW_BYTES;
     _frameNumber = 0;
     _tiles = {};
     _pendingCount = 0;
@@ -100,9 +177,14 @@ export class Tileset3D {
     _requestedTiles = [];
     _emptyTiles = [];
     frameStateData = {};
+    /** Last camera pose retained independently for each viewport. */
+    _cameraMotionStates = {};
+    /** Pending traversal that releases requests after camera motion settles. */
+    _deferredTraversalTimeout = null;
     _traverser;
     _cache = new TilesetCache();
     _requestScheduler;
+    /** Drawn fallback instances retained independently for each viewport tree. */
     _heldTiles = new Set();
     updatePromise = null;
     tilesetInitializationPromise;
@@ -112,11 +194,28 @@ export class Tileset3D {
      * @param options Traversal and runtime options.
      */
     constructor(source, options) {
-        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;
         this.loader = this.source.loader;
@@ -135,13 +234,19 @@ export class Tileset3D {
             maxRequests: this.options.maxRequests
         });
         this.memoryAdjustedScreenSpaceError = this.options.maximumScreenSpaceError;
-        this._cacheBytes = this.options.maximumMemoryUsage * 1024 * 1024;
-        this._cacheOverflowBytes = this.options.memoryCacheOverflow * 1024 * 1024;
+        this._cacheBytes = cacheBytes;
+        this._maximumCacheOverflowBytes = maximumCacheOverflowBytes;
+        const metadata = this._getSourceMetadata();
+        if (metadata) {
+            this.spatialReference = applyTilesetSpatialOptions(metadata.spatialReference, this.options.spatial);
+        }
         this.stats = new Stats({ id: this.url });
         this._initializeStats();
         this.tilesetInitializationPromise = this._initializeTileSet();
     }
     destroy() {
+        this._clearDeferredTraversal();
+        this.source.destroy?.();
         this._destroy();
     }
     isLoaded() {
@@ -153,13 +258,74 @@ export class Tileset3D {
     get frameNumber() {
         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() {
+        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() {
+        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() {
+        return this._cacheBytes;
+    }
+    set cacheBytes(value) {
+        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() {
+        return this._maximumCacheOverflowBytes;
+    }
+    set maximumCacheOverflowBytes(value) {
+        this._maximumCacheOverflowBytes = validateCacheByteLength(value, 'maximumCacheOverflowBytes');
+        this.options.maximumCacheOverflowBytes = this._maximumCacheOverflowBytes;
+    }
     get queryParams() {
         const rootUrl = this.source.getTileUrl(this.url);
         const queryIndex = rootUrl.indexOf('?');
         return queryIndex >= 0 ? rootUrl.slice(queryIndex + 1) : '';
     }
+    /**
+     * Updates traversal and runtime options while retaining unspecified byte budgets.
+     *
+     * @param props - Partial runtime options to apply.
+     */
     setProps(props) {
-        this.options = { ...this.options, ...props };
+        const cacheBytes = resolveCacheBytes(props, this.cacheBytes);
+        const maximumCacheOverflowBytes = resolveMaximumCacheOverflowBytes(props, this.maximumCacheOverflowBytes);
+        this.options = {
+            ...this.options,
+            ...props,
+            cacheBytes,
+            maximumCacheOverflowBytes
+        };
+        this._cacheBytes = cacheBytes;
+        this._maximumCacheOverflowBytes = maximumCacheOverflowBytes;
     }
     getTileUrl(tilePath) {
         return this.source.getTileUrl(tilePath);
@@ -198,11 +364,18 @@ 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() {
-        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;
         }
     }
@@ -214,9 +387,19 @@ 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 = [];
         for (const viewport of preparedViewports) {
             const id = viewport.id;
@@ -236,7 +419,57 @@ export class Tileset3D {
                 continue;
             }
             const frameState = getFrameState(viewport, this._frameNumber);
-            this._traverser.traverse(this.roots[id], frameState, this.options);
+            const root = this.roots[id];
+            const cameraMotionUpdate = updateCameraMotionState(this._cameraMotionStates[id], frameState.camera.position, frameState.camera.direction, currentTime);
+            this._cameraMotionStates[id] = cameraMotionUpdate.state;
+            frameState.camera.timeSinceMovement = cameraMotionUpdate.timeSinceMovement;
+            // 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.
+     */
+    _scheduleDeferredTraversal(delayInSeconds) {
+        this._clearDeferredTraversal();
+        this._deferredTraversalTimeout = setTimeout(() => {
+            this._deferredTraversalTimeout = null;
+            this.selectTiles().catch((error) => {
+                const traversalError = error instanceof Error ? error : new Error(String(error));
+                this._onTilesetError(traversalError);
+            });
+        }, Math.max(delayInSeconds * 1000, 0));
+    }
+    /** Clears a pending moving-camera follow-up traversal. */
+    _clearDeferredTraversal() {
+        if (this._deferredTraversalTimeout !== null) {
+            clearTimeout(this._deferredTraversalTimeout);
+            this._deferredTraversalTimeout = null;
         }
     }
     _needTraverse(viewportId) {
@@ -278,29 +511,47 @@ export class Tileset3D {
             this._emptyTiles = this._emptyTiles.concat(frameStateDataValue._emptyTiles);
         }
         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();
+            for (const tile of this.selectedTiles) {
+                for (let ancestor = tile.parent; ancestor; ancestor = ancestor.parent) {
+                    descendantReadiness.set(ancestor, (descendantReadiness.get(ancestor) ?? true) && tile.tileDrawn);
+                }
+            }
+            // 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 tileId of this._heldTiles) {
-                if (selectedIds.has(tileId))
+            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;
-                const tile = this._tiles[tileId];
-                if (tile && tile.contentAvailable) {
+                }
+                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) {
             setTimeout(() => {
@@ -317,6 +568,19 @@ export class Tileset3D {
             this.options.onUpdate();
         }
     }
+    /**
+     * 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.
+     */
+    _hasDrawnReplacement(tile, selectedTiles, descendantReadiness) {
+        for (let ancestor = tile.parent; ancestor; ancestor = ancestor.parent) {
+            if (selectedTiles.has(ancestor)) {
+                return ancestor.tileDrawn;
+            }
+        }
+        return descendantReadiness.get(tile) === true;
+    }
     _tilesChanged(oldSelectedTiles, selectedTiles) {
         if (oldSelectedTiles.length !== selectedTiles.length) {
             return true;
@@ -337,6 +601,9 @@ export class Tileset3D {
     }
     _unloadTiles() {
         this._cache.unloadTiles(this, (tileset, tile) => tileset._unloadTile(tile));
+        if (this.options.memoryAdjustedScreenSpaceError) {
+            this.adjustScreenSpaceError();
+        }
     }
     _updateStats() {
         let tilesRenderable = 0;
@@ -344,11 +611,14 @@ 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;
+                    }
                 }
             }
         }
@@ -365,13 +635,15 @@ export class Tileset3D {
                 this._syncSourceState(initialMetadata);
             }
             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();
             }
             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);
             }
@@ -425,6 +697,29 @@ export class Tileset3D {
             this._onTileLoad(tile, loadResult);
         }
     }
+    /**
+     * Loads a source-managed lazy child-header group and reports failures through tile callbacks.
+     *
+     * Subtree metadata shares the normal loading counters but is not reported as render content and
+     * is not added to the GPU cache. Traversal is notified separately after the promise settles.
+     *
+     * @param tile - Runtime tile that owns the lazy subtree reference.
+     * @param frameState - View state that made the subtree eligible for refinement.
+     */
+    async _loadTileChildren(tile, frameState) {
+        try {
+            this._onStartTileLoading();
+            await tile.loadChildren(frameState);
+        }
+        catch (error) {
+            const tileError = error instanceof Error ? error : new Error('subtree load failed');
+            this._onSourceError(tileError, tile);
+            this._onTileLoadError(tile, tileError);
+        }
+        finally {
+            this._onEndTileLoading();
+        }
+    }
     _onTileLoadError(tile, error) {
         this.stats.get(TILES_LOAD_FAILED).incrementCount();
         const message = error.message || error.toString();
@@ -527,6 +822,14 @@ export class Tileset3D {
         this.refine = metadata.refine;
         this.contentFormats = this.source.contentFormats;
         this.asset = this.source.asset || this.asset;
+        const tileset = metadata.tileset;
+        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) {
@@ -563,4 +866,14 @@ export class Tileset3D {
         }
     }
 }
+/** Preserve a completed runtime operation when asynchronous source metadata describes the same request. */
+function preserveTransformedSpatialReference(current, next) {
+    return current?.status === 'transformed' &&
+        current.sourceCrs === next.sourceCrs &&
+        current.targetCrs === next.targetCrs &&
+        current.targetHeightReference === next.targetHeightReference &&
+        current.outputCoordinates === next.outputCoordinates
+        ? current
+        : next;
+}
 //# sourceMappingURL=tileset-3d.js.map