@loaders.gl/3d-tiles 4.3.0-alpha.6 → 4.3.0-alpha.8

package/dist/lib/classes/helpers/tile-3d-accessor-utils.d.ts

@@ -1,5 +1,5 @@
 export declare function createTypedArrayFromAccessor(tile3DAccessor: any, buffer: any, byteOffset: any, length: any): {
-    values: import("@math.gl/core").TypedArray;
+    values: import("@math.gl/types").TypedArray;
     type: any;
     size: any;
     unpacker: any;

package/dist/lib/classes/tile-3d-batch-table.d.ts

@@ -21,7 +21,7 @@ export default class Tile3DBatchTableParser {
     _setBinaryProperty(binaryProperty: any, index: any, value: any): void;
     _initializeBinaryProperties(): Record<string, any> | null;
     _initializeBinaryProperty(name: any, property: any): {
-        typedArray: import("@math.gl/core").TypedArray;
+        typedArray: import("@math.gl/types").TypedArray;
         componentCount: any;
         unpack: any;
         pack: any;

package/dist/lib/parsers/helpers/parse-3d-implicit-tiles.d.ts

@@ -1,4 +1,4 @@
-import type { Subtree } from "../../../types.js";
+import type { Tile3DBoundingVolume, Subtree } from "../../../types.js";
 import type { S2VolumeInfo } from "../../utils/obb/s2-corners-to-obb.js";
 import { Tiles3DLoaderOptions } from "../../../tiles-3d-loader.js";
 import { ImplicitOptions } from "../parse-3d-tile-header.js";
@@ -15,38 +15,54 @@ export type S2VolumeBox = {
  * Recursively parse implicit tiles tree
  * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling
  * TODO Check out do we able to use Tile3D class as return type here.
- * @param subtree
- * @param lodMetricValue
- * @param options
- * @param parentData
- * @param childIndex
- * @param level
- * @param globalData
+ *
+ * @param subtree - the current subtree. Subtrees contain availability data for <implicitOptions.subtreeLevels>.
+ *     Once we go deeper than that many levels, we will need load a child subtree to get further availability data.
+ * @param subtreeData - the coordinates of the current subtree, relative to the root of this implicit tiles tree.
+ * @param parentData - the coordinates of the parent tile, relative to the current subtree.
+ *     The overall coordinates of the current tile can be found by combining the coordinates of the current subtree, the parent tile,
+ *     and tje single-bit coordinates that can be calculated from the childIndex.
+ * @param childIndex - which child the current tile is of its parent. In the range 0-7 for OCTREE, 0-3 for QUADTREE.
+ * @param implicitOptions - options specified at the root of this implicit tile tree - numbers of levels, URL templates.
+ * @param loaderOptions - see Tiles3DLoaderOptions.
  */
 export declare function parseImplicitTiles(params: {
     subtree: Subtree;
-    implicitOptions: ImplicitOptions;
-    parentData?: {
-        mortonIndex: number;
+    subtreeData?: {
+        level: number;
         x: number;
         y: number;
         z: number;
     };
-    childIndex?: number;
-    level?: number;
-    globalData?: {
-        level: number;
+    parentData?: {
         mortonIndex: number;
-        x: number;
-        y: number;
-        z: number;
+        localLevel: number;
+        localX: number;
+        localY: number;
+        localZ: number;
     };
-    s2VolumeBox?: S2VolumeBox;
+    childIndex?: number;
+    implicitOptions: ImplicitOptions;
     loaderOptions: Tiles3DLoaderOptions;
+    s2VolumeBox?: S2VolumeBox;
 }): Promise<{
     children: never[];
     lodMetricValue: number;
     contentUrl: string;
+} | {
+    children: any;
+    contentUrl: any;
+    content: {
+        uri: any;
+    };
+    id: any;
+    refine: string | import("@loaders.gl/tiles").TILE_REFINEMENT | undefined;
+    type: string;
+    lodMetricType: import("@loaders.gl/tiles").LOD_METRIC_TYPE.GEOMETRIC_ERROR;
+    lodMetricValue: number;
+    geometricError: number;
+    transform: any;
+    boundingVolume: Tile3DBoundingVolume;
 }>;
 /**
  * Replace implicit tile content url with real coordinates.

package/dist/lib/parsers/helpers/parse-3d-implicit-tiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-3d-implicit-tiles.d.ts","sourceRoot":"","sources":["../../../../src/lib/parsers/helpers/parse-3d-implicit-tiles.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAqC,OAAO,EAAC,0BAAuB;AAMhF,OAAO,KAAK,EAAC,YAAY,EAAC,6CAA0C;AAGpE,OAAO,EAAC,oBAAoB,EAAC,oCAAiC;AAC9D,OAAO,EAAC,eAAe,EAAC,mCAAgC;AAUxD;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,yFAAyF;IACzF,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,uGAAuG;IACvG,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AA6CF;;;;;;;;;;;GAWG;AAEH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,eAAe,EAAE,eAAe,CAAC;IACjC,UAAU,CAAC,EAAE;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;IACpE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;IACnF,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,aAAa,EAAE,oBAAoB,CAAC;CACrC;;;;GAwJA;AAmJD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,CAGR"}
+{"version":3,"file":"parse-3d-implicit-tiles.d.ts","sourceRoot":"","sources":["../../../../src/lib/parsers/helpers/parse-3d-implicit-tiles.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAe,oBAAoB,EAAE,OAAO,EAAC,0BAAuB;AAMhF,OAAO,KAAK,EAAC,YAAY,EAAC,6CAA0C;AAGpE,OAAO,EAAC,oBAAoB,EAAC,oCAAiC;AAC9D,OAAO,EAAC,eAAe,EAAC,mCAAgC;AAUxD;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,yFAAyF;IACzF,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,uGAAuG;IACvG,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AA6CF;;;;;;;;;;;;;;GAcG;AAEH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;IAC/D,UAAU,CAAC,EAAE;QACX,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,eAAe,CAAC;IACjC,aAAa,EAAE,oBAAoB,CAAC;IACpC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;;;;;;;;;;;;;;;;;;GAuJA;AA0JD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,CAGR"}

package/dist/lib/parsers/helpers/parse-3d-implicit-tiles.js

@@ -52,109 +52,122 @@ function getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme) {
  * Recursively parse implicit tiles tree
  * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling
  * TODO Check out do we able to use Tile3D class as return type here.
- * @param subtree
- * @param lodMetricValue
- * @param options
- * @param parentData
- * @param childIndex
- * @param level
- * @param globalData
+ *
+ * @param subtree - the current subtree. Subtrees contain availability data for <implicitOptions.subtreeLevels>.
+ *     Once we go deeper than that many levels, we will need load a child subtree to get further availability data.
+ * @param subtreeData - the coordinates of the current subtree, relative to the root of this implicit tiles tree.
+ * @param parentData - the coordinates of the parent tile, relative to the current subtree.
+ *     The overall coordinates of the current tile can be found by combining the coordinates of the current subtree, the parent tile,
+ *     and tje single-bit coordinates that can be calculated from the childIndex.
+ * @param childIndex - which child the current tile is of its parent. In the range 0-7 for OCTREE, 0-3 for QUADTREE.
+ * @param implicitOptions - options specified at the root of this implicit tile tree - numbers of levels, URL templates.
+ * @param loaderOptions - see Tiles3DLoaderOptions.
  */
 // eslint-disable-next-line max-statements
 export async function parseImplicitTiles(params) {
-    const { implicitOptions, parentData = {
-        mortonIndex: 0,
-        x: 0,
-        y: 0,
-        z: 0
-    }, childIndex = 0, s2VolumeBox, loaderOptions } = params;
-    let { subtree, level = 0, globalData = {
+    const { subtree, subtreeData = {
         level: 0,
-        mortonIndex: 0,
         x: 0,
         y: 0,
         z: 0
-    } } = params;
+    }, parentData = {
+        mortonIndex: 0,
+        localLevel: -1,
+        localX: 0,
+        localY: 0,
+        localZ: 0
+    }, childIndex = 0, implicitOptions, loaderOptions, s2VolumeBox } = params;
     const { subdivisionScheme, subtreeLevels, maximumLevel, contentUrlTemplate, subtreesUriTemplate, basePath } = implicitOptions;
     const tile = { children: [], lodMetricValue: 0, contentUrl: '' };
     if (!maximumLevel) {
         log.once(`Missing 'maximumLevel' or 'availableLevels' property. The subtree ${contentUrlTemplate} won't be loaded...`);
         return tile;
     }
-    const lev = level + globalData.level;
-    if (lev > maximumLevel) {
+    // Local tile level - relative to the current subtree.
+    const localLevel = parentData.localLevel + 1;
+    // Global tile level - relative to the root tile of this implicit subdivision scheme.
+    const level = subtreeData.level + localLevel;
+    if (level > maximumLevel) {
         return tile;
     }
     const childrenPerTile = SUBDIVISION_COUNT_MAP[subdivisionScheme];
     const bitsPerTile = Math.log2(childrenPerTile);
-    // childIndex is in range [0,4] for quadtrees and [0, 7] for octrees
-    const childX = childIndex & 0b01; // Get first bit for X
-    const childY = (childIndex >> 1) & 0b01; // Get second bit for Y
-    const childZ = (childIndex >> 2) & 0b01; // Get third bit for Z
-    const levelOffset = (childrenPerTile ** level - 1) / (childrenPerTile - 1);
-    let childTileMortonIndex = concatBits(parentData.mortonIndex, childIndex, bitsPerTile);
-    let tileAvailabilityIndex = levelOffset + childTileMortonIndex;
-    // Local tile coordinates
-    let childTileX = concatBits(parentData.x, childX, 1);
-    let childTileY = concatBits(parentData.y, childY, 1);
-    let childTileZ = concatBits(parentData.z, childZ, 1);
-    let isChildSubtreeAvailable = false;
-    if (level >= subtreeLevels) {
-        isChildSubtreeAvailable = getAvailabilityResult(subtree.childSubtreeAvailability, childTileMortonIndex);
-    }
-    const x = concatBits(globalData.x, childTileX, level);
-    const y = concatBits(globalData.y, childTileY, level);
-    const z = concatBits(globalData.z, childTileZ, level);
+    // childIndex is in range 0...3 for quadtrees and 0...7 for octrees
+    const lastBitX = childIndex & 0b01; // Get first bit for X
+    const lastBitY = (childIndex >> 1) & 0b01; // Get second bit for Y
+    const lastBitZ = (childIndex >> 2) & 0b01; // Get third bit for Z
+    // Local tile coordinates - relative to the current subtree root.
+    const localX = concatBits(parentData.localX, lastBitX, 1);
+    const localY = concatBits(parentData.localY, lastBitY, 1);
+    const localZ = concatBits(parentData.localZ, lastBitZ, 1);
+    // Global tile coordinates - relative to the implicit-tile-tree root.
+    // Found by combining the local coordinates which are relative to the current subtree, with the subtree coordinates.
+    const x = concatBits(subtreeData.x, localX, localLevel);
+    const y = concatBits(subtreeData.y, localY, localLevel);
+    const z = concatBits(subtreeData.z, localZ, localLevel);
+    const mortonIndex = concatBits(parentData.mortonIndex, childIndex, bitsPerTile);
+    const isChildSubtreeAvailable = localLevel === subtreeLevels &&
+        getAvailabilityResult(subtree.childSubtreeAvailability, mortonIndex);
+    // Context to provide the next recursive call.
+    // This context is set up differently depending on whether its time to start a new subtree or not.
+    let nextSubtree;
+    let nextSubtreeData;
+    let nextParentData;
+    let tileAvailabilityIndex;
     if (isChildSubtreeAvailable) {
         const subtreePath = `${basePath}/${subtreesUriTemplate}`;
-        const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, lev, x, y, z);
+        const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, level, x, y, z);
         const childSubtree = await load(childSubtreeUrl, Tile3DSubtreeLoader, loaderOptions);
-        subtree = childSubtree;
-        globalData = {
-            mortonIndex: childTileMortonIndex,
-            x: childTileX,
-            y: childTileY,
-            z: childTileZ,
-            level
-        };
-        childTileMortonIndex = 0;
+        // The next subtree is the newly-loaded child subtree.
+        nextSubtree = childSubtree;
+        // The current tile is actually the root tile in the next subtree, so it has a tileAvailabilityIndex of 0.
         tileAvailabilityIndex = 0;
-        childTileX = 0;
-        childTileY = 0;
-        childTileZ = 0;
-        level = 0;
+        // The next subtree starts HERE - at the current tile.
+        nextSubtreeData = { level, x, y, z };
+        // The next parent is also the current tile - so it has local coordinates of 0 relative to the next subtree.
+        nextParentData = { mortonIndex: 0, localLevel: 0, localX: 0, localY: 0, localZ: 0 };
+    }
+    else {
+        // Continue on with the same subtree as we're using currently.
+        nextSubtree = subtree;
+        // Calculate a tileAvailabilityIndex for the current tile within the current subtree.
+        const levelOffset = (childrenPerTile ** localLevel - 1) / (childrenPerTile - 1);
+        tileAvailabilityIndex = levelOffset + mortonIndex;
+        // The next subtree is the same as the current subtree.
+        nextSubtreeData = subtreeData;
+        // The next parent is the current tile: it has the local coordinates we already calculated.
+        nextParentData = { mortonIndex, localLevel, localX, localY, localZ };
     }
-    const isTileAvailable = getAvailabilityResult(subtree.tileAvailability, tileAvailabilityIndex);
+    const isTileAvailable = getAvailabilityResult(nextSubtree.tileAvailability, tileAvailabilityIndex);
     if (!isTileAvailable) {
         return tile;
     }
-    const isContentAvailable = getAvailabilityResult(subtree.contentAvailability, tileAvailabilityIndex);
+    const isContentAvailable = getAvailabilityResult(nextSubtree.contentAvailability, tileAvailabilityIndex);
     if (isContentAvailable) {
-        tile.contentUrl = replaceContentUrlTemplate(contentUrlTemplate, lev, x, y, z);
+        tile.contentUrl = replaceContentUrlTemplate(contentUrlTemplate, level, x, y, z);
     }
-    const childTileLevel = level + 1;
-    const pData = { mortonIndex: childTileMortonIndex, x: childTileX, y: childTileY, z: childTileZ };
     for (let index = 0; index < childrenPerTile; index++) {
         const childS2VolumeBox = getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme);
         // Recursive calling...
-        const childTileParsed = await parseImplicitTiles({
-            subtree,
+        const childTile = await parseImplicitTiles({
+            subtree: nextSubtree,
+            subtreeData: nextSubtreeData,
+            parentData: nextParentData,
+            childIndex: index,
             implicitOptions,
             loaderOptions,
-            parentData: pData,
-            childIndex: index,
-            level: childTileLevel,
-            globalData: { ...globalData },
             s2VolumeBox: childS2VolumeBox
         });
-        if (childTileParsed.contentUrl || childTileParsed.children.length) {
-            const globalLevel = lev + 1;
-            const childCoordinates = { childTileX, childTileY, childTileZ };
-            const formattedTile = formatTileData(childTileParsed, globalLevel, childCoordinates, implicitOptions, s2VolumeBox);
+        if (childTile.contentUrl || childTile.children.length) {
             // @ts-ignore
-            tile.children.push(formattedTile);
+            tile.children.push(childTile);
         }
     }
+    if (tile.contentUrl || tile.children.length) {
+        const coordinates = { level, x, y, z };
+        const formattedTile = formatTileData(tile, coordinates, implicitOptions, s2VolumeBox);
+        return formattedTile;
+    }
     return tile;
 }
 /**
@@ -190,19 +203,21 @@ function getAvailabilityResult(availabilityData, index) {
 /**
  * Do formatting of implicit tile data.
  * TODO Check out do we able to use Tile3D class as type here.
- * @param tile
- * @param lodMetricValue
- * @param options
+ *
+ * @param tile - tile data to format.
+ * @param coordinates - global tile coordinates (relative to the root of the implicit tile tree).
+ * @param options - options specified at the root of this implicit tile tree - numbers of levels, URL templates.
+ * @param s2VolumeBox - the S2VolumeBox for this particular child, if available.
  * @returns
  */
-function formatTileData(tile, level, childCoordinates, options, s2VolumeBox) {
+function formatTileData(tile, coordinates, options, s2VolumeBox) {
     const { basePath, refine, getRefine, lodMetricType, getTileType, rootLodMetricValue, rootBoundingVolume } = options;
     const uri = tile.contentUrl && tile.contentUrl.replace(`${basePath}/`, '');
-    const lodMetricValue = rootLodMetricValue / 2 ** level;
+    const lodMetricValue = rootLodMetricValue / 2 ** coordinates.level;
     const boundingVolume = s2VolumeBox?.box
         ? { box: s2VolumeBox.box }
         : rootBoundingVolume;
-    const boundingVolumeForChildTile = calculateBoundingVolumeForChildTile(level, boundingVolume, childCoordinates);
+    const boundingVolumeForChildTile = calculateBoundingVolumeForChildTile(boundingVolume, coordinates, options.subdivisionScheme);
     return {
         children: tile.children,
         contentUrl: tile.contentUrl,
@@ -220,28 +235,36 @@ function formatTileData(tile, level, childCoordinates, options, s2VolumeBox) {
 /**
  * Calculate child bounding volume.
  * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling#subdivision-rules
- * @param level
  * @param rootBoundingVolume
- * @param childCoordinates
+ * @param coordinates
+ * @param subdivisionScheme
  */
-function calculateBoundingVolumeForChildTile(level, rootBoundingVolume, childCoordinates) {
+function calculateBoundingVolumeForChildTile(rootBoundingVolume, coordinates, subdivisionScheme) {
     if (rootBoundingVolume.region) {
-        const { childTileX, childTileY, childTileZ } = childCoordinates;
+        const { level, x, y, z } = coordinates;
         const [west, south, east, north, minimumHeight, maximumHeight] = rootBoundingVolume.region;
         const boundingVolumesCount = 2 ** level;
         const sizeX = (east - west) / boundingVolumesCount;
+        const [childWest, childEast] = [west + sizeX * x, west + sizeX * (x + 1)];
         const sizeY = (north - south) / boundingVolumesCount;
-        // TODO : Why is the subdivisionScheme not being checked here?
+        const [childSouth, childNorth] = [south + sizeY * y, south + sizeY * (y + 1)];
         // In case of QUADTREE the sizeZ should NOT be changed!
         // https://portal.ogc.org/files/102132
-        // A quadtree divides space only on the x and y dimensions. It divides each tile into 4 smaller tiles where the x and y dimensions are halved. The quadtree z minimum and maximum remain unchanged.
-        const sizeZ = (maximumHeight - minimumHeight) / boundingVolumesCount;
-        const [childWest, childEast] = [west + sizeX * childTileX, west + sizeX * (childTileX + 1)];
-        const [childSouth, childNorth] = [south + sizeY * childTileY, south + sizeY * (childTileY + 1)];
-        const [childMinimumHeight, childMaximumHeight] = [
-            minimumHeight + sizeZ * childTileZ,
-            minimumHeight + sizeZ * (childTileZ + 1)
-        ];
+        // A quadtree divides space only on the x and y dimensions.
+        // It divides each tile into 4 smaller tiles where the x and y dimensions are halved.
+        // The quadtree z minimum and maximum remain unchanged.
+        let childMinimumHeight;
+        let childMaximumHeight;
+        if (subdivisionScheme === 'OCTREE') {
+            const sizeZ = (maximumHeight - minimumHeight) / boundingVolumesCount;
+            [childMinimumHeight, childMaximumHeight] = [
+                minimumHeight + sizeZ * z,
+                minimumHeight + sizeZ * (z + 1)
+            ];
+        }
+        else {
+            [childMinimumHeight, childMaximumHeight] = [minimumHeight, maximumHeight];
+        }
         return {
             region: [childWest, childSouth, childEast, childNorth, childMinimumHeight, childMaximumHeight]
         };

package/dist/lib/utils/version.js

@@ -1,4 +1,4 @@
 // Version constant cannot be imported, it needs to correspond to the build version of **this** module.
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-export const VERSION = typeof "4.3.0-alpha.5" !== 'undefined' ? "4.3.0-alpha.5" : 'latest';
+export const VERSION = typeof "4.3.0-alpha.7" !== 'undefined' ? "4.3.0-alpha.7" : 'latest';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/3d-tiles",
-  "version": "4.3.0-alpha.6",
+  "version": "4.3.0-alpha.8",
   "description": "3D Tiles, an open standard for streaming massive heterogeneous 3D geospatial datasets.",
   "license": "MIT",
   "type": "module",
@@ -46,23 +46,23 @@
     "build-bundle-dev": "ocular-bundle ./bundle.ts --env=dev --output=dist/dist.dev.js"
   },
   "dependencies": {
-    "@loaders.gl/compression": "4.3.0-alpha.6",
-    "@loaders.gl/crypto": "4.3.0-alpha.6",
-    "@loaders.gl/draco": "4.3.0-alpha.6",
-    "@loaders.gl/gltf": "4.3.0-alpha.6",
-    "@loaders.gl/images": "4.3.0-alpha.6",
-    "@loaders.gl/loader-utils": "4.3.0-alpha.6",
-    "@loaders.gl/math": "4.3.0-alpha.6",
-    "@loaders.gl/tiles": "4.3.0-alpha.6",
-    "@loaders.gl/zip": "4.3.0-alpha.6",
-    "@math.gl/core": "^4.0.1",
-    "@math.gl/culling": "^4.0.1",
-    "@math.gl/geospatial": "^4.0.1",
+    "@loaders.gl/compression": "4.3.0-alpha.8",
+    "@loaders.gl/crypto": "4.3.0-alpha.8",
+    "@loaders.gl/draco": "4.3.0-alpha.8",
+    "@loaders.gl/gltf": "4.3.0-alpha.8",
+    "@loaders.gl/images": "4.3.0-alpha.8",
+    "@loaders.gl/loader-utils": "4.3.0-alpha.8",
+    "@loaders.gl/math": "4.3.0-alpha.8",
+    "@loaders.gl/tiles": "4.3.0-alpha.8",
+    "@loaders.gl/zip": "4.3.0-alpha.8",
+    "@math.gl/core": "^4.1.0",
+    "@math.gl/culling": "^4.1.0",
+    "@math.gl/geospatial": "^4.1.0",
     "@probe.gl/log": "^4.0.4",
     "long": "^5.2.1"
   },
   "peerDependencies": {
     "@loaders.gl/core": "^4.0.0"
   },
-  "gitHead": "315f2e232fc4e6a477c41de800a54d3e3d957e8c"
+  "gitHead": "c458e0c3a09543cd7c4a293d3c3f08c12acf78c0"
 }