@navaramap/engine 0.1.1 → 0.2.0

package/navara_wasm.js

@@ -162,6 +162,32 @@ export class BillboardMaterial {
         const ret = wasm.__wbg_get_billboardmaterial_alphaTest(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Whether faces seen from behind are culled. Default is false, so a
+     * quad frozen in its anchor's frame (`rotateWithCamera: false`) stays
+     * visible from behind. Turn it on to hide a flat quad's parts that wrap
+     * over the horizon, which face away from the camera.
+     * @returns {boolean | undefined}
+     */
+    get backfaceCulling() {
+        const ret = wasm.__wbg_get_billboardmaterial_backfaceCulling(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * Whether the sprite stands up (`"upright"`, the default) or lies on the
+     * globe surface around its anchor (`"flat"`). Pair with
+     * `rotateWithCamera`.
+     * @returns {string | undefined}
+     */
+    get billboardFacing() {
+        const ret = wasm.__wbg_get_billboardmaterial_billboardFacing(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
     /**
      * anchor point of the sprite, range is (-0.5, -0.5) to (0.5, 0.5).
      * Default is (0.0, 0.0) which means the center of the sprite.
@@ -233,7 +259,7 @@ export class BillboardMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Emissive glow intensity (default: 0.3 when Bloom enabled)
+     * Emissive glow intensity (omitted = 0, no emissive output)
      * @returns {number | undefined}
      */
     get emissiveIntensity() {
@@ -277,6 +303,26 @@ export class BillboardMaterial {
         const ret = wasm.__wbg_get_billboardmaterial_opacity(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Whether the sprite turns to follow the camera. `true` (the default)
+     * keeps it facing the viewer. `false` freezes it in the anchor's local
+     * east-north-up frame, so moving the camera never reorients it.
+     * @returns {boolean | undefined}
+     */
+    get rotateWithCamera() {
+        const ret = wasm.__wbg_get_billboardmaterial_rotateWithCamera(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * Rotation of the sprite within its own plane, about its anchor point,
+     * in degrees, clockwise seen from the front. `center` decides where
+     * inside the sprite the pivot sits. Defaults to `0.0`.
+     * @returns {number | undefined}
+     */
+    get rotation() {
+        const ret = wasm.__wbg_get_billboardmaterial_rotation(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * @returns {boolean | undefined}
      */
@@ -325,6 +371,27 @@ export class BillboardMaterial {
     set alphaTest(arg0) {
         wasm.__wbg_set_billboardmaterial_alphaTest(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Whether faces seen from behind are culled. Default is false, so a
+     * quad frozen in its anchor's frame (`rotateWithCamera: false`) stays
+     * visible from behind. Turn it on to hide a flat quad's parts that wrap
+     * over the horizon, which face away from the camera.
+     * @param {boolean | null} [arg0]
+     */
+    set backfaceCulling(arg0) {
+        wasm.__wbg_set_billboardmaterial_backfaceCulling(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+    /**
+     * Whether the sprite stands up (`"upright"`, the default) or lies on the
+     * globe surface around its anchor (`"flat"`). Pair with
+     * `rotateWithCamera`.
+     * @param {string | null} [arg0]
+     */
+    set billboardFacing(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_billboardmaterial_billboardFacing(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * anchor point of the sprite, range is (-0.5, -0.5) to (0.5, 0.5).
      * Default is (0.0, 0.0) which means the center of the sprite.
@@ -390,7 +457,7 @@ export class BillboardMaterial {
         wasm.__wbg_set_billboardmaterial_emissiveColor(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0);
     }
     /**
-     * Emissive glow intensity (default: 0.3 when Bloom enabled)
+     * Emissive glow intensity (omitted = 0, no emissive output)
      * @param {number | null} [arg0]
      */
     set emissiveIntensity(arg0) {
@@ -426,6 +493,24 @@ export class BillboardMaterial {
     set opacity(arg0) {
         wasm.__wbg_set_billboardmaterial_opacity(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Whether the sprite turns to follow the camera. `true` (the default)
+     * keeps it facing the viewer. `false` freezes it in the anchor's local
+     * east-north-up frame, so moving the camera never reorients it.
+     * @param {boolean | null} [arg0]
+     */
+    set rotateWithCamera(arg0) {
+        wasm.__wbg_set_billboardmaterial_rotateWithCamera(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+    /**
+     * Rotation of the sprite within its own plane, about its anchor point,
+     * in degrees, clockwise seen from the front. `center` decides where
+     * inside the sprite the pivot sits. Defaults to `0.0`.
+     * @param {number | null} [arg0]
+     */
+    set rotation(arg0) {
+        wasm.__wbg_set_billboardmaterial_rotation(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
     /**
      * @param {boolean | null} [arg0]
      */
@@ -1726,6 +1811,20 @@ export class ConstructTerrainMeshParameters {
         const ret = wasm.__wbg_get_constructterrainmeshparameters_isQuantizedMesh(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * @returns {boolean}
+     */
+    get poleNorth() {
+        const ret = wasm.__wbg_get_constructterrainmeshparameters_poleNorth(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get poleSouth() {
+        const ret = wasm.__wbg_get_constructterrainmeshparameters_poleSouth(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * Multiplier for the automatically calculated skirt height.
      * @returns {number}
@@ -1781,6 +1880,18 @@ export class ConstructTerrainMeshParameters {
     set isQuantizedMesh(arg0) {
         wasm.__wbg_set_constructterrainmeshparameters_isQuantizedMesh(this.__wbg_ptr, arg0);
     }
+    /**
+     * @param {boolean} arg0
+     */
+    set poleNorth(arg0) {
+        wasm.__wbg_set_constructterrainmeshparameters_poleNorth(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set poleSouth(arg0) {
+        wasm.__wbg_set_constructterrainmeshparameters_poleSouth(this.__wbg_ptr, arg0);
+    }
     /**
      * Multiplier for the automatically calculated skirt height.
      * @param {number} arg0
@@ -2764,14 +2875,6 @@ export class Core {
         const ret = wasm.core_getMemoryStats(this.__wbg_ptr);
         return ret === 0 ? undefined : MemoryStats.__wrap(ret);
     }
-    /**
-     * @param {bigint} handle
-     * @returns {TransferableTile | undefined}
-     */
-    getParentTile(handle) {
-        const ret = wasm.core_getParentTile(this.__wbg_ptr, handle);
-        return ret === 0 ? undefined : TransferableTile.__wrap(ret);
-    }
     /**
      * The WebMercator raster tiles to bake into per-layer drape render targets for a
      * terrain tile (baked layers only; empty on WebMercator terrain, which drapes 1:1
@@ -2800,6 +2903,16 @@ export class Core {
         const ret = wasm.core_getSourceDescription(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * Buffer handle of a tile's loaded raw DEM bytes (the data a raster-DEM
+     * upsample of a descendant resamples from), `undefined` until it landed.
+     * @param {bigint} handle
+     * @returns {number | undefined}
+     */
+    getTerrainDemBytes(handle) {
+        const ret = wasm.core_getTerrainDemBytes(this.__wbg_ptr, handle);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * @param {bigint} handle
      * @returns {TransferableTile | undefined}
@@ -3050,6 +3163,16 @@ export class Core {
         const ret = wasm.core_registerSampleTerrainHeightEvent(this.__wbg_ptr, ptr0);
         return BigInt.asUintN(64, ret);
     }
+    /**
+     * @param {ExtentRadianF32} extent
+     * @returns {bigint}
+     */
+    registerTerrainHeightRangeEvent(extent) {
+        _assertClass(extent, ExtentRadianF32);
+        var ptr0 = extent.__destroy_into_raw();
+        const ret = wasm.core_registerTerrainHeightRangeEvent(this.__wbg_ptr, ptr0);
+        return BigInt.asUintN(64, ret);
+    }
     /**
      * @param {number} handle
      */
@@ -3140,6 +3263,22 @@ export class Core {
         const ret = wasm.core_sampleTerrainHeight(this.__wbg_ptr, ptr0);
         return ret[0] === 0 ? undefined : ret[1];
     }
+    /**
+     * `[min, max]` height of the ground rendered over `extent` (radians).
+     * @param {ExtentRadianF32} extent
+     * @returns {Float64Array | undefined}
+     */
+    sampleTerrainHeightRange(extent) {
+        _assertClass(extent, ExtentRadianF32);
+        var ptr0 = extent.__destroy_into_raw();
+        const ret = wasm.core_sampleTerrainHeightRange(this.__wbg_ptr, ptr0);
+        let v2;
+        if (ret[0] !== 0) {
+            v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        }
+        return v2;
+    }
     /**
      * @param {number} handle
      * @param {bigint} bits
@@ -3351,6 +3490,12 @@ export class Core {
     unregisterSampleTerrainHeightEvent(bits) {
         wasm.core_unregisterSampleTerrainHeightEvent(this.__wbg_ptr, bits);
     }
+    /**
+     * @param {bigint} bits
+     */
+    unregisterTerrainHeightRangeEvent(bits) {
+        wasm.core_unregisterTerrainHeightRangeEvent(this.__wbg_ptr, bits);
+    }
     /**
      * @param {number} updated_at
      */
@@ -3487,6 +3632,18 @@ export class DataRequestEvent {
         const ret = wasm.__wbg_get_datarequestevent_offset(this.__wbg_ptr);
         return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
     }
+    /**
+     * Fetch urgency: 0 is the most urgent (see `Priority::rank`). The web
+     * side keeps its pending fetch queue sorted by this. Requests without an
+     * ECS `Priority` (tileset / PMTiles bootstrap reads, 3D Tiles content)
+     * rank as `Extreme`, matching the engine sender that dispatches them
+     * ahead of the prioritized ones.
+     * @returns {number}
+     */
+    get priority() {
+        const ret = wasm.__wbg_get_datarequestevent_priority(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Quantized-mesh only: server should return the oct-encoded normals extension.
      * @returns {boolean}
@@ -3578,6 +3735,17 @@ export class DataRequestEvent {
     set offset(arg0) {
         wasm.__wbg_set_datarequestevent_offset(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
     }
+    /**
+     * Fetch urgency: 0 is the most urgent (see `Priority::rank`). The web
+     * side keeps its pending fetch queue sorted by this. Requests without an
+     * ECS `Priority` (tileset / PMTiles bootstrap reads, 3D Tiles content)
+     * rank as `Extreme`, matching the engine sender that dispatches them
+     * ahead of the prioritized ones.
+     * @param {number} arg0
+     */
+    set priority(arg0) {
+        wasm.__wbg_set_datarequestevent_priority(this.__wbg_ptr, arg0);
+    }
     /**
      * Quantized-mesh only: server should return the oct-encoded normals extension.
      * @param {boolean} arg0
@@ -4015,6 +4183,72 @@ export class DelegatedWorkerTasksResult {
 }
 if (Symbol.dispose) DelegatedWorkerTasksResult.prototype[Symbol.dispose] = DelegatedWorkerTasksResult.prototype.free;
 
+/**
+ * Maps a 3D Tiles feature table semantic (`POSITION`, `RGB`, ...) to its
+ * Draco unique attribute id.
+ */
+export class DracoAttributeId {
+    static __wrap(ptr) {
+        const obj = Object.create(DracoAttributeId.prototype);
+        obj.__wbg_ptr = ptr;
+        DracoAttributeIdFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof DracoAttributeId)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DracoAttributeIdFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dracoattributeid_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get semantic() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_dracoattributeid_semantic(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get uniqueId() {
+        const ret = wasm.__wbg_get_dracoattributeid_uniqueId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {string} arg0
+     */
+    set semantic(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_dracoattributeid_semantic(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set uniqueId(arg0) {
+        wasm.__wbg_set_dracoattributeid_uniqueId(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) DracoAttributeId.prototype[Symbol.dispose] = DracoAttributeId.prototype.free;
+
 /**
  * Dynamic screen-space-error settings (CesiumJS `dynamicScreenSpaceError`
  * equivalent): tilted, street-level horizon views tolerate a larger error
@@ -4088,7 +4322,10 @@ export class DynamicSse {
         return ret;
     }
     /**
-     * Maximum SSE relaxation (in pixels) at full tilt and saturation.
+     * Maximum SSE relaxation (in pixels) at full tilt and saturation for a
+     * layer with the reference max SSE of 16 (the CesiumJS 3D Tiles default);
+     * each layer scales it by its own max SSE, so terrain and imagery
+     * (max SSE 2) relax by at most `sseFactor / 8` pixels.
      * @returns {number}
      */
     get sseFactor() {
@@ -4129,7 +4366,10 @@ export class DynamicSse {
         wasm.__wbg_set_dynamicsse_minHeight(this.__wbg_ptr, arg0);
     }
     /**
-     * Maximum SSE relaxation (in pixels) at full tilt and saturation.
+     * Maximum SSE relaxation (in pixels) at full tilt and saturation for a
+     * layer with the reference max SSE of 16 (the CesiumJS 3D Tiles default);
+     * each layer scales it by its own max SSE, so terrain and imagery
+     * (max SSE 2) relax by at most `sseFactor / 8` pixels.
      * @param {number} arg0
      */
     set sseFactor(arg0) {
@@ -4700,6 +4940,15 @@ export class Events {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * @returns {MeshGeometryReplaced[]}
+     */
+    take_mesh_geometry_replaced() {
+        const ret = wasm.events_take_mesh_geometry_replaced(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * @returns {EntityEvent[]}
      */
@@ -4781,6 +5030,15 @@ export class Events {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * @returns {TerrainHeightRangeUpdatedEvent[]}
+     */
+    take_update_terrain_height_range() {
+        const ret = wasm.events_take_update_terrain_height_range(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * @returns {WorkerTaskDelegatedEvent[]}
      */
@@ -5754,6 +6012,14 @@ export class Mesh {
         const ret = wasm.__wbg_get_mesh_active(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Quadrant bitmask to draw (`0` = whole tile); see `navara_mesh::Mesh`.
+     * @returns {number}
+     */
+    get fill_quadrants() {
+        const ret = wasm.__wbg_get_mesh_fill_quadrants(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {number}
      */
@@ -5844,6 +6110,13 @@ export class Mesh {
     set active(arg0) {
         wasm.__wbg_set_mesh_active(this.__wbg_ptr, arg0);
     }
+    /**
+     * Quadrant bitmask to draw (`0` = whole tile); see `navara_mesh::Mesh`.
+     * @param {number} arg0
+     */
+    set fill_quadrants(arg0) {
+        wasm.__wbg_set_mesh_fill_quadrants(this.__wbg_ptr, arg0);
+    }
     /**
      * @param {number} arg0
      */
@@ -6149,6 +6422,71 @@ export class MeshChanged {
 }
 if (Symbol.dispose) MeshChanged.prototype[Symbol.dispose] = MeshChanged.prototype.free;
 
+/**
+ * A live tile mesh whose geometry buffers were rewritten in place (see
+ * `EventStore::mesh_geometry_replaced`): only the geometry changes.
+ */
+export class MeshGeometryReplaced {
+    static __wrap(ptr) {
+        const obj = Object.create(MeshGeometryReplaced.prototype);
+        obj.__wbg_ptr = ptr;
+        MeshGeometryReplacedFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MeshGeometryReplacedFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_meshgeometryreplaced_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get gen() {
+        const ret = wasm.__wbg_get_meshgeometryreplaced_gen(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get ind() {
+        const ret = wasm.__wbg_get_meshgeometryreplaced_ind(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {Mesh}
+     */
+    get mesh() {
+        const ret = wasm.__wbg_get_meshgeometryreplaced_mesh(this.__wbg_ptr);
+        return Mesh.__wrap(ret);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set gen(arg0) {
+        wasm.__wbg_set_meshgeometryreplaced_gen(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set ind(arg0) {
+        wasm.__wbg_set_meshgeometryreplaced_ind(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {Mesh} arg0
+     */
+    set mesh(arg0) {
+        _assertClass(arg0, Mesh);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_meshgeometryreplaced_mesh(this.__wbg_ptr, ptr0);
+    }
+}
+if (Symbol.dispose) MeshGeometryReplaced.prototype[Symbol.dispose] = MeshGeometryReplaced.prototype.free;
+
 export class ModelInternalMaterial {
     static __wrap(ptr) {
         const obj = Object.create(ModelInternalMaterial.prototype);
@@ -6167,11 +6505,16 @@ export class ModelInternalMaterial {
         wasm.__wbg_modelinternalmaterial_free(ptr, 0);
     }
     /**
-     * @returns {boolean}
+     * @returns {DracoAttributeId[] | undefined}
      */
-    get dracoCompressed() {
-        const ret = wasm.__wbg_get_modelinternalmaterial_dracoCompressed(this.__wbg_ptr);
-        return ret !== 0;
+    get dracoAttributes() {
+        const ret = wasm.__wbg_get_modelinternalmaterial_dracoAttributes(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
     }
     /**
      * @returns {Vec3}
@@ -6188,10 +6531,12 @@ export class ModelInternalMaterial {
         return ret !== 0;
     }
     /**
-     * @param {boolean} arg0
+     * @param {DracoAttributeId[] | null} [arg0]
      */
-    set dracoCompressed(arg0) {
-        wasm.__wbg_set_modelinternalmaterial_dracoCompressed(this.__wbg_ptr, arg0);
+    set dracoAttributes(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_modelinternalmaterial_dracoAttributes(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {Vec3} arg0
@@ -6313,7 +6658,7 @@ export class ModelMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Emissive glow intensity (default: 0.3 when Bloom enabled)
+     * Emissive glow intensity (omitted = 0, no emissive output)
      * @returns {number | undefined}
      */
     get emissiveIntensity() {
@@ -6575,7 +6920,7 @@ export class ModelMaterial {
         wasm.__wbg_set_modelmaterial_emissiveColor(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0);
     }
     /**
-     * Emissive glow intensity (default: 0.3 when Bloom enabled)
+     * Emissive glow intensity (omitted = 0, no emissive output)
      * @param {number | null} [arg0]
      */
     set emissiveIntensity(arg0) {
@@ -7328,6 +7673,17 @@ export class PointMaterial {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_pointmaterial_free(ptr, 0);
     }
+    /**
+     * Whether faces seen from behind are culled. Default is false, so a
+     * quad frozen in its anchor's frame (`rotateWithCamera: false`) stays
+     * visible from behind. Turn it on to hide a flat quad's parts that wrap
+     * over the horizon, which face away from the camera.
+     * @returns {boolean | undefined}
+     */
+    get backfaceCulling() {
+        const ret = wasm.__wbg_get_pointmaterial_backfaceCulling(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
     /**
      * anchor point of the sprite, range is (-0.5, -0.5) to (0.5, 0.5).
      * Default is (0.0, 0.0) which means the center of the sprite.
@@ -7399,7 +7755,7 @@ export class PointMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Emissive glow intensity (default: 0.3 when Bloom enabled)
+     * Emissive glow intensity (omitted = 0, no emissive output)
      * @returns {number | undefined}
      */
     get emissiveIntensity() {
@@ -7443,6 +7799,41 @@ export class PointMaterial {
         const ret = wasm.__wbg_get_pointmaterial_opacity(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Whether the point stands up (`"upright"`, the default) or lies on the
+     * globe surface around its anchor (`"flat"`). Pair with
+     * `rotateWithCamera`.
+     * @returns {string | undefined}
+     */
+    get pointFacing() {
+        const ret = wasm.__wbg_get_pointmaterial_pointFacing(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Whether the point turns to follow the camera. `true` (the default)
+     * keeps it facing the viewer. `false` freezes it in the anchor's local
+     * east-north-up frame, so moving the camera never reorients it.
+     * @returns {boolean | undefined}
+     */
+    get rotateWithCamera() {
+        const ret = wasm.__wbg_get_pointmaterial_rotateWithCamera(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * Rotation of the point within its own plane, about its anchor point, in
+     * degrees, clockwise seen from the front. `center` decides where inside
+     * the quad the pivot sits. Defaults to `0.0`.
+     * @returns {number | undefined}
+     */
+    get rotation() {
+        const ret = wasm.__wbg_get_pointmaterial_rotation(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * @returns {boolean | undefined}
      */
@@ -7473,6 +7864,16 @@ export class PointMaterial {
         const ret = wasm.__wbg_get_pointmaterial_transparent(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
+    /**
+     * Whether faces seen from behind are culled. Default is false, so a
+     * quad frozen in its anchor's frame (`rotateWithCamera: false`) stays
+     * visible from behind. Turn it on to hide a flat quad's parts that wrap
+     * over the horizon, which face away from the camera.
+     * @param {boolean | null} [arg0]
+     */
+    set backfaceCulling(arg0) {
+        wasm.__wbg_set_pointmaterial_backfaceCulling(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
     /**
      * anchor point of the sprite, range is (-0.5, -0.5) to (0.5, 0.5).
      * Default is (0.0, 0.0) which means the center of the sprite.
@@ -7538,7 +7939,7 @@ export class PointMaterial {
         wasm.__wbg_set_pointmaterial_emissiveColor(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0);
     }
     /**
-     * Emissive glow intensity (default: 0.3 when Bloom enabled)
+     * Emissive glow intensity (omitted = 0, no emissive output)
      * @param {number | null} [arg0]
      */
     set emissiveIntensity(arg0) {
@@ -7574,6 +7975,35 @@ export class PointMaterial {
     set opacity(arg0) {
         wasm.__wbg_set_pointmaterial_opacity(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Whether the point stands up (`"upright"`, the default) or lies on the
+     * globe surface around its anchor (`"flat"`). Pair with
+     * `rotateWithCamera`.
+     * @param {string | null} [arg0]
+     */
+    set pointFacing(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_pointmaterial_pointFacing(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Whether the point turns to follow the camera. `true` (the default)
+     * keeps it facing the viewer. `false` freezes it in the anchor's local
+     * east-north-up frame, so moving the camera never reorients it.
+     * @param {boolean | null} [arg0]
+     */
+    set rotateWithCamera(arg0) {
+        wasm.__wbg_set_pointmaterial_rotateWithCamera(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+    /**
+     * Rotation of the point within its own plane, about its anchor point, in
+     * degrees, clockwise seen from the front. `center` decides where inside
+     * the quad the pivot sits. Defaults to `0.0`.
+     * @param {number | null} [arg0]
+     */
+    set rotation(arg0) {
+        wasm.__wbg_set_pointmaterial_rotation(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
     /**
      * @param {boolean | null} [arg0]
      */
@@ -8036,7 +8466,7 @@ export class PolygonMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Emissive glow intensity (default: 0.3 when Bloom enabled)
+     * Emissive glow intensity (omitted = 0, no emissive output)
      * @returns {number | undefined}
      */
     get emissiveIntensity() {
@@ -8312,7 +8742,7 @@ export class PolygonMaterial {
         wasm.__wbg_set_polygonmaterial_emissiveColor(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0);
     }
     /**
-     * Emissive glow intensity (default: 0.3 when Bloom enabled)
+     * Emissive glow intensity (omitted = 0, no emissive output)
      * @param {number | null} [arg0]
      */
     set emissiveIntensity(arg0) {
@@ -9155,7 +9585,7 @@ export class PolylineMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Emissive glow intensity (default: 0.3 when Bloom enabled)
+     * Emissive glow intensity (omitted = 0, no emissive output)
      * @returns {number | undefined}
      */
     get emissiveIntensity() {
@@ -9330,7 +9760,7 @@ export class PolylineMaterial {
         wasm.__wbg_set_polylinematerial_emissiveColor(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0);
     }
     /**
-     * Emissive glow intensity (default: 0.3 when Bloom enabled)
+     * Emissive glow intensity (omitted = 0, no emissive output)
      * @param {number | null} [arg0]
      */
     set emissiveIntensity(arg0) {
@@ -11630,6 +12060,13 @@ export class ReturnedTransferablePolylineBatchedFeature {
         const ret = wasm.returnedtransferablepolylinebatchedfeature_transferPointsSizes(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @returns {Uint8Array}
+     */
+    transferRingFlags() {
+        const ret = wasm.returnedtransferablepolylinebatchedfeature_transferRingFlags(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @param {PolylineMaterial} arg0
      */
@@ -11735,6 +12172,65 @@ export class SourceDescription {
 }
 if (Symbol.dispose) SourceDescription.prototype[Symbol.dispose] = SourceDescription.prototype.free;
 
+export class TerrainHeightRangeUpdatedEvent {
+    static __wrap(ptr) {
+        const obj = Object.create(TerrainHeightRangeUpdatedEvent.prototype);
+        obj.__wbg_ptr = ptr;
+        TerrainHeightRangeUpdatedEventFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TerrainHeightRangeUpdatedEventFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_terrainheightrangeupdatedevent_free(ptr, 0);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get bits() {
+        const ret = wasm.__wbg_get_terrainheightrangeupdatedevent_bits(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {number}
+     */
+    get max() {
+        const ret = wasm.__wbg_get_terrainheightrangeupdatedevent_max(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get min() {
+        const ret = wasm.__wbg_get_terrainheightrangeupdatedevent_min(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {bigint} arg0
+     */
+    set bits(arg0) {
+        wasm.__wbg_set_terrainheightrangeupdatedevent_bits(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set max(arg0) {
+        wasm.__wbg_set_terrainheightrangeupdatedevent_max(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set min(arg0) {
+        wasm.__wbg_set_terrainheightrangeupdatedevent_min(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) TerrainHeightRangeUpdatedEvent.prototype[Symbol.dispose] = TerrainHeightRangeUpdatedEvent.prototype.free;
+
 export class TerrainHeightUpdatedEvent {
     static __wrap(ptr) {
         const obj = Object.create(TerrainHeightUpdatedEvent.prototype);
@@ -12055,6 +12551,17 @@ export class TextMaterial {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_textmaterial_free(ptr, 0);
     }
+    /**
+     * Whether faces seen from behind are culled. Default is false, so a
+     * quad frozen in its anchor's frame (`rotateWithCamera: false`) stays
+     * visible from behind. Turn it on to hide a flat quad's parts that wrap
+     * over the horizon, which face away from the camera.
+     * @returns {boolean | undefined}
+     */
+    get backfaceCulling() {
+        const ret = wasm.__wbg_get_textmaterial_backfaceCulling(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
     /**
      * @returns {number | undefined}
      */
@@ -12123,6 +12630,35 @@ export class TextMaterial {
         const ret = wasm.__wbg_get_textmaterial_depthTest(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
+    /**
+     * IDs of selective effects to apply (e.g., "bloom", "outline")
+     * @returns {string[] | undefined}
+     */
+    get effectIds() {
+        const ret = wasm.__wbg_get_textmaterial_effectIds(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
+    /**
+     * Emissive glow color in 0xRRGGBB format
+     * @returns {number | undefined}
+     */
+    get emissiveColor() {
+        const ret = wasm.__wbg_get_textmaterial_emissiveColor(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * Emissive glow intensity (omitted = 0, no emissive output)
+     * @returns {number | undefined}
+     */
+    get emissiveIntensity() {
+        const ret = wasm.__wbg_get_textmaterial_emissiveIntensity(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * Specifies either the URL of a single font file or the `family` name of a font family
      * previously registered with `view.addFontFamily()`. Supported file formats are ttf, otf,
@@ -12254,6 +12790,31 @@ export class TextMaterial {
         const ret = wasm.__wbg_get_textmaterial_outlineWidth(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Whether the label turns to follow the camera. `true` (the default)
+     * keeps it facing the viewer. `false` freezes it in the anchor's local
+     * east-north-up frame, so moving the camera never reorients it: with
+     * `textFacing: "upright"` it becomes a signboard standing on the
+     * surface, with `"flat"` a north-up label painted on it.
+     * @returns {boolean | undefined}
+     */
+    get rotateWithCamera() {
+        const ret = wasm.__wbg_get_textmaterial_rotateWithCamera(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * Rotation of the label within its own plane, about its anchor point, in
+     * degrees, clockwise seen from the front. Applied on top of whatever
+     * orientation `textFacing` and `rotateWithCamera` resolve to: it spins a
+     * billboard on screen and turns a surface label like a compass bearing.
+     * `center` decides where inside the text the pivot sits. Defaults to
+     * `0.0`.
+     * @returns {number | undefined}
+     */
+    get rotation() {
+        const ret = wasm.__wbg_get_textmaterial_rotation(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * @returns {boolean | undefined}
      */
@@ -12291,6 +12852,21 @@ export class TextMaterial {
         }
         return v1;
     }
+    /**
+     * Whether the label stands up (`"upright"`, the default) or lies on the
+     * globe surface around its anchor (`"flat"`), following its curvature so
+     * it reads as painted on the surface. Pair with `rotateWithCamera`.
+     * @returns {string | undefined}
+     */
+    get textFacing() {
+        const ret = wasm.__wbg_get_textmaterial_textFacing(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
     /**
      * @returns {string | undefined}
      */
@@ -12311,6 +12887,16 @@ export class TextMaterial {
         const ret = wasm.__wbg_get_textmaterial_transparent(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
+    /**
+     * Whether faces seen from behind are culled. Default is false, so a
+     * quad frozen in its anchor's frame (`rotateWithCamera: false`) stays
+     * visible from behind. Turn it on to hide a flat quad's parts that wrap
+     * over the horizon, which face away from the camera.
+     * @param {boolean | null} [arg0]
+     */
+    set backfaceCulling(arg0) {
+        wasm.__wbg_set_textmaterial_backfaceCulling(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
     /**
      * @param {number | null} [arg0]
      */
@@ -12375,6 +12961,29 @@ export class TextMaterial {
     set depthTest(arg0) {
         wasm.__wbg_set_textmaterial_depthTest(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
+    /**
+     * IDs of selective effects to apply (e.g., "bloom", "outline")
+     * @param {string[] | null} [arg0]
+     */
+    set effectIds(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_textmaterial_effectIds(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Emissive glow color in 0xRRGGBB format
+     * @param {number | null} [arg0]
+     */
+    set emissiveColor(arg0) {
+        wasm.__wbg_set_textmaterial_emissiveColor(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0);
+    }
+    /**
+     * Emissive glow intensity (omitted = 0, no emissive output)
+     * @param {number | null} [arg0]
+     */
+    set emissiveIntensity(arg0) {
+        wasm.__wbg_set_textmaterial_emissiveIntensity(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
     /**
      * Specifies either the URL of a single font file or the `family` name of a font family
      * previously registered with `view.addFontFamily()`. Supported file formats are ttf, otf,
@@ -12485,6 +13094,29 @@ export class TextMaterial {
     set outlineWidth(arg0) {
         wasm.__wbg_set_textmaterial_outlineWidth(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Whether the label turns to follow the camera. `true` (the default)
+     * keeps it facing the viewer. `false` freezes it in the anchor's local
+     * east-north-up frame, so moving the camera never reorients it: with
+     * `textFacing: "upright"` it becomes a signboard standing on the
+     * surface, with `"flat"` a north-up label painted on it.
+     * @param {boolean | null} [arg0]
+     */
+    set rotateWithCamera(arg0) {
+        wasm.__wbg_set_textmaterial_rotateWithCamera(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+    /**
+     * Rotation of the label within its own plane, about its anchor point, in
+     * degrees, clockwise seen from the front. Applied on top of whatever
+     * orientation `textFacing` and `rotateWithCamera` resolve to: it spins a
+     * billboard on screen and turns a surface label like a compass bearing.
+     * `center` decides where inside the text the pivot sits. Defaults to
+     * `0.0`.
+     * @param {number | null} [arg0]
+     */
+    set rotation(arg0) {
+        wasm.__wbg_set_textmaterial_rotation(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
     /**
      * @param {boolean | null} [arg0]
      */
@@ -12515,6 +13147,17 @@ export class TextMaterial {
         var len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_textmaterial_textAlign(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * Whether the label stands up (`"upright"`, the default) or lies on the
+     * globe surface around its anchor (`"flat"`), following its curvature so
+     * it reads as painted on the surface. Pair with `rotateWithCamera`.
+     * @param {string | null} [arg0]
+     */
+    set textFacing(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_textmaterial_textFacing(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * @param {string | null} [arg0]
      */
@@ -14170,6 +14813,13 @@ export class TransferablePolylineBatchedFeature {
     setPointsSizes(byte_length, f) {
         wasm.transferablepolylinebatchedfeature_setPointsSizes(this.__wbg_ptr, byte_length, f);
     }
+    /**
+     * @param {number} byte_length
+     * @param {Function} f
+     */
+    setRingFlags(byte_length, f) {
+        wasm.transferablepolylinebatchedfeature_setRingFlags(this.__wbg_ptr, byte_length, f);
+    }
     /**
      * @returns {Uint32Array}
      */
@@ -14198,6 +14848,13 @@ export class TransferablePolylineBatchedFeature {
         const ret = wasm.transferablepolylinebatchedfeature_transferPointsSizes(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @returns {Uint8Array}
+     */
+    transferRingFlags() {
+        const ret = wasm.transferablepolylinebatchedfeature_transferRingFlags(this.__wbg_ptr);
+        return ret;
+    }
 }
 if (Symbol.dispose) TransferablePolylineBatchedFeature.prototype[Symbol.dispose] = TransferablePolylineBatchedFeature.prototype.free;
 
@@ -15043,6 +15700,20 @@ export class UpsampleTerrainMeshParameters {
         const ret = wasm.__wbg_get_upsampleterrainmeshparameters_isQuantizedMesh(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * @returns {boolean}
+     */
+    get poleNorth() {
+        const ret = wasm.__wbg_get_upsampleterrainmeshparameters_poleNorth(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get poleSouth() {
+        const ret = wasm.__wbg_get_upsampleterrainmeshparameters_poleSouth(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * Multiplier for the automatically calculated skirt height.
      * @returns {number}
@@ -15059,6 +15730,14 @@ export class UpsampleTerrainMeshParameters {
         const ret = wasm.__wbg_get_upsampleterrainmeshparameters_skirt(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * The ancestor tile whose mesh is clipped down to `tile_handle`.
+     * @returns {bigint}
+     */
+    get source_tile_handle() {
+        const ret = wasm.__wbg_get_upsampleterrainmeshparameters_source_tile_handle(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
     /**
      * @returns {bigint}
      */
@@ -15066,6 +15745,14 @@ export class UpsampleTerrainMeshParameters {
         const ret = wasm.__wbg_get_upsampleterrainmeshparameters_tile_handle(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
+    /**
+     * DEM tile width in pixels (raster DEM only).
+     * @returns {number}
+     */
+    get tile_size() {
+        const ret = wasm.__wbg_get_upsampleterrainmeshparameters_tile_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * @returns {boolean}
      */
@@ -15085,6 +15772,18 @@ export class UpsampleTerrainMeshParameters {
     set isQuantizedMesh(arg0) {
         wasm.__wbg_set_upsampleterrainmeshparameters_isQuantizedMesh(this.__wbg_ptr, arg0);
     }
+    /**
+     * @param {boolean} arg0
+     */
+    set poleNorth(arg0) {
+        wasm.__wbg_set_upsampleterrainmeshparameters_poleNorth(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set poleSouth(arg0) {
+        wasm.__wbg_set_upsampleterrainmeshparameters_poleSouth(this.__wbg_ptr, arg0);
+    }
     /**
      * Multiplier for the automatically calculated skirt height.
      * @param {number} arg0
@@ -15099,12 +15798,26 @@ export class UpsampleTerrainMeshParameters {
     set skirt(arg0) {
         wasm.__wbg_set_upsampleterrainmeshparameters_skirt(this.__wbg_ptr, arg0);
     }
+    /**
+     * The ancestor tile whose mesh is clipped down to `tile_handle`.
+     * @param {bigint} arg0
+     */
+    set source_tile_handle(arg0) {
+        wasm.__wbg_set_upsampleterrainmeshparameters_source_tile_handle(this.__wbg_ptr, arg0);
+    }
     /**
      * @param {bigint} arg0
      */
     set tile_handle(arg0) {
         wasm.__wbg_set_upsampleterrainmeshparameters_tile_handle(this.__wbg_ptr, arg0);
     }
+    /**
+     * DEM tile width in pixels (raster DEM only).
+     * @param {number} arg0
+     */
+    set tile_size(arg0) {
+        wasm.__wbg_set_upsampleterrainmeshparameters_tile_size(this.__wbg_ptr, arg0);
+    }
     /**
      * @param {boolean} arg0
      */
@@ -15113,11 +15826,13 @@ export class UpsampleTerrainMeshParameters {
     }
     /**
      * @param {bigint} tile_handle
+     * @param {bigint} source_tile_handle
+     * @param {number} tile_size
      * @param {boolean} skirt
      * @param {number} skirt_exaggeration
      */
-    constructor(tile_handle, skirt, skirt_exaggeration) {
-        const ret = wasm.upsampleterrainmeshparameters_new(tile_handle, skirt, skirt_exaggeration);
+    constructor(tile_handle, source_tile_handle, tile_size, skirt, skirt_exaggeration) {
+        const ret = wasm.upsampleterrainmeshparameters_new(tile_handle, source_tile_handle, tile_size, skirt, skirt_exaggeration);
         this.__wbg_ptr = ret;
         UpsampleTerrainMeshParametersFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -15936,6 +16651,16 @@ export class WorkerTaskDelegatedEvent {
         const ret = wasm.__wbg_get_workertaskdelegatedevent_ind(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Dispatch urgency: 0 is the most urgent (see `Priority::rank`). The
+     * platform keeps its pending stack sorted by this so a terrain mesh task
+     * overtakes older, less urgent work waiting for a worker.
+     * @returns {number}
+     */
+    get priority() {
+        const ret = wasm.__wbg_get_workertaskdelegatedevent_priority(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {DelegatedWorkerTasksParameters}
      */
@@ -15961,6 +16686,15 @@ export class WorkerTaskDelegatedEvent {
     set ind(arg0) {
         wasm.__wbg_set_workertaskdelegatedevent_ind(this.__wbg_ptr, arg0);
     }
+    /**
+     * Dispatch urgency: 0 is the most urgent (see `Priority::rank`). The
+     * platform keeps its pending stack sorted by this so a terrain mesh task
+     * overtakes older, less urgent work waiting for a worker.
+     * @param {number} arg0
+     */
+    set priority(arg0) {
+        wasm.__wbg_set_workertaskdelegatedevent_priority(this.__wbg_ptr, arg0);
+    }
     /**
      * @param {DelegatedWorkerTasksParameters} arg0
      */
@@ -16022,11 +16756,11 @@ export function start() {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_92b29b0548f8b746: function(arg0, arg1) {
+        __wbg_Error_408e67f47ca7b58b: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_Number_9a4e0ecb0fa16705: function(arg0) {
+        __wbg_Number_3890faa6d3ff057d: function(arg0) {
             const ret = Number(arg0);
             return ret;
         },
@@ -16037,72 +16771,72 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_bigint_get_as_i64_d968e41184ae354f: function(arg0, arg1) {
+        __wbg___wbindgen_bigint_get_as_i64_c4ecf48528083721: function(arg0, arg1) {
             const v = arg1;
             const ret = typeof(v) === 'bigint' ? v : undefined;
             getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
         },
-        __wbg___wbindgen_boolean_get_fa956cfa2d1bd751: function(arg0) {
+        __wbg___wbindgen_boolean_get_c9c83ebd41b34df3: function(arg0) {
             const v = arg0;
             const ret = typeof(v) === 'boolean' ? v : undefined;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
-        __wbg___wbindgen_debug_string_c25d447a39f5578f: function(arg0, arg1) {
+        __wbg___wbindgen_debug_string_a57024b9c6e4a48b: function(arg0, arg1) {
             const ret = debugString(arg1);
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_in_aca499c5de7ff5e5: function(arg0, arg1) {
+        __wbg___wbindgen_in_ac983077f137f2e6: function(arg0, arg1) {
             const ret = arg0 in arg1;
             return ret;
         },
-        __wbg___wbindgen_is_bigint_2f76dc55065b4273: function(arg0) {
+        __wbg___wbindgen_is_bigint_8ffbbef442139384: function(arg0) {
             const ret = typeof(arg0) === 'bigint';
             return ret;
         },
-        __wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
+        __wbg___wbindgen_is_function_5e4570eb24ffa122: function(arg0) {
             const ret = typeof(arg0) === 'function';
             return ret;
         },
-        __wbg___wbindgen_is_null_ea9085d691f535d3: function(arg0) {
+        __wbg___wbindgen_is_null_7d13f41e1a2d5140: function(arg0) {
             const ret = arg0 === null;
             return ret;
         },
-        __wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
+        __wbg___wbindgen_is_object_a2790eb24c211ea0: function(arg0) {
             const val = arg0;
             const ret = typeof(val) === 'object' && val !== null;
             return ret;
         },
-        __wbg___wbindgen_is_string_ea5e6cc2e4141dfe: function(arg0) {
+        __wbg___wbindgen_is_string_e6f02f0ea5f20a32: function(arg0) {
             const ret = typeof(arg0) === 'string';
             return ret;
         },
-        __wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
+        __wbg___wbindgen_is_undefined_6cff064c44e0d823: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
         },
-        __wbg___wbindgen_jsval_eq_e659fcf7b0e32763: function(arg0, arg1) {
+        __wbg___wbindgen_jsval_eq_0a18949a61670320: function(arg0, arg1) {
             const ret = arg0 === arg1;
             return ret;
         },
-        __wbg___wbindgen_jsval_loose_eq_db4c3b15f63fc170: function(arg0, arg1) {
+        __wbg___wbindgen_jsval_loose_eq_acf2776254a8d832: function(arg0, arg1) {
             const ret = arg0 == arg1;
             return ret;
         },
-        __wbg___wbindgen_memory_de265df8aadd6273: function() {
+        __wbg___wbindgen_memory_5dc2a138835b0f8e: function() {
             const ret = wasm.memory;
             return ret;
         },
-        __wbg___wbindgen_number_get_394265ed1e1b84ee: function(arg0, arg1) {
+        __wbg___wbindgen_number_get_136b9679cab35cfb: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'number' ? obj : undefined;
             getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
         },
-        __wbg___wbindgen_string_get_b0ca35b86a603356: function(arg0, arg1) {
+        __wbg___wbindgen_string_get_d154f1e671052120: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;
             var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -16110,27 +16844,27 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
+        __wbg___wbindgen_throw_bb96b2010945f0bc: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_buffer_0f212447ac64c53b: function(arg0) {
+        __wbg_buffer_8117fe4dab119813: function(arg0) {
             const ret = arg0.buffer;
             return ret;
         },
-        __wbg_call_44b7209e1e252e6a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-            const ret = arg0.call(arg1, arg2, arg3, arg4);
+        __wbg_call_0f2a9af232c18fd2: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg0.call(arg1, arg2, arg3);
             return ret;
         }, arguments); },
-        __wbg_call_8a2dd23819f8a60a: function() { return handleError(function (arg0, arg1) {
+        __wbg_call_1c5886ab9c57d1c7: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.call(arg1);
             return ret;
         }, arguments); },
-        __wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_call_35dba3c747ad7521: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_call_e3b662382210db98: function() { return handleError(function (arg0, arg1, arg2, arg3) {
-            const ret = arg0.call(arg1, arg2, arg3);
+        __wbg_call_39f824e18d9d2414: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = arg0.call(arg1, arg2, arg3, arg4);
             return ret;
         }, arguments); },
         __wbg_cameraflightendedevent_new: function(arg0) {
@@ -16145,30 +16879,38 @@ function __wbg_get_imports() {
             const ret = DataRequestEvent.__wrap(arg0);
             return ret;
         },
-        __wbg_done_89b2b13e91a60321: function(arg0) {
+        __wbg_done_669171204c3dcae2: function(arg0) {
             const ret = arg0.done;
             return ret;
         },
+        __wbg_dracoattributeid_new: function(arg0) {
+            const ret = DracoAttributeId.__wrap(arg0);
+            return ret;
+        },
+        __wbg_dracoattributeid_unwrap: function(arg0) {
+            const ret = DracoAttributeId.__unwrap(arg0);
+            return ret;
+        },
         __wbg_entityevent_new: function(arg0) {
             const ret = EntityEvent.__wrap(arg0);
             return ret;
         },
-        __wbg_entries_015dc610cd81ede0: function(arg0) {
+        __wbg_entries_7774d489e1da5f4f: function(arg0) {
             const ret = Object.entries(arg0);
             return ret;
         },
-        __wbg_getRandomValues_cc7f052a444bb2ce: function() { return handleError(function (arg0, arg1) {
+        __wbg_getRandomValues_436a51d0629d84e1: function() { return handleError(function (arg0, arg1) {
             globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
         }, arguments); },
-        __wbg_get_507a50627bffa49b: function(arg0, arg1) {
+        __wbg_get_c0c8f8d7da0c03dd: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
-        __wbg_get_c7eb1f358a7654df: function() { return handleError(function (arg0, arg1) {
+        __wbg_get_d173c0308df22d37: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(arg0, arg1);
             return ret;
         }, arguments); },
-        __wbg_get_unchecked_6e0ad6d2a41b06f6: function(arg0, arg1) {
+        __wbg_get_unchecked_e20b893aeafc3fca: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
@@ -16180,7 +16922,7 @@ function __wbg_get_imports() {
             const ret = HillshadeBackfilledEvent.__wrap(arg0);
             return ret;
         },
-        __wbg_instanceof_ArrayBuffer_4480b9e0068a8adb: function(arg0) {
+        __wbg_instanceof_ArrayBuffer_993d02d2d254cad1: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof ArrayBuffer;
@@ -16190,7 +16932,7 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_Map_e5b5e3db98422fcc: function(arg0) {
+        __wbg_instanceof_Map_9a4d6ead180ae3a9: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof Map;
@@ -16200,7 +16942,7 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_Uint8Array_309b927aaf7a3fc7: function(arg0) {
+        __wbg_instanceof_Uint8Array_f935dbb0aa7cdeed: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof Uint8Array;
@@ -16210,35 +16952,35 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_isArray_0677c962b281d01a: function(arg0) {
+        __wbg_isArray_6339f732981044bf: function(arg0) {
             const ret = Array.isArray(arg0);
             return ret;
         },
-        __wbg_isSafeInteger_04f36e4056f1b851: function(arg0) {
+        __wbg_isSafeInteger_f3d6cd19ccfe4512: function(arg0) {
             const ret = Number.isSafeInteger(arg0);
             return ret;
         },
-        __wbg_iterator_6f722e4a93058b71: function() {
+        __wbg_iterator_5cebbb86e33c6dd6: function() {
             const ret = Symbol.iterator;
             return ret;
         },
-        __wbg_length_0133fa10e3234c57: function(arg0) {
+        __wbg_length_1009454859bb3e03: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_length_1f0964f4a5e2c6d8: function(arg0) {
+        __wbg_length_36bd29c6848c2144: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_length_370319915dc99107: function(arg0) {
+        __wbg_length_46f80504ebb6ebb4: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_length_381d540857ec99e8: function(arg0) {
+        __wbg_length_7528cf2a241bef97: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_length_98f10d1e2f4ea968: function(arg0) {
+        __wbg_length_ecfa2c63d3d0d82c: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
@@ -16246,7 +16988,7 @@ function __wbg_get_imports() {
             const ret = LLE.__wrap(arg0);
             return ret;
         },
-        __wbg_log_4b4c9fd369267eb9: function(arg0, arg1) {
+        __wbg_log_d65e71c48ae3cbbb: function(arg0, arg1) {
             console.log(getStringFromWasm0(arg0, arg1));
         },
         __wbg_meshadded_new: function(arg0) {
@@ -16257,66 +16999,70 @@ function __wbg_get_imports() {
             const ret = MeshChanged.__wrap(arg0);
             return ret;
         },
-        __wbg_new_32b398fb48b6d94a: function() {
+        __wbg_meshgeometryreplaced_new: function(arg0) {
+            const ret = MeshGeometryReplaced.__wrap(arg0);
+            return ret;
+        },
+        __wbg_new_078f4f4b1eaabdec: function(arg0) {
+            const ret = new Float32Array(arg0);
+            return ret;
+        },
+        __wbg_new_116be93542d39019: function() {
             const ret = new Array();
             return ret;
         },
-        __wbg_new_80efd62ef570c5de: function(arg0) {
+        __wbg_new_2aa179ec5b1fefa8: function(arg0) {
             const ret = new Float64Array(arg0);
             return ret;
         },
-        __wbg_new_92a08b12c30e98e8: function(arg0) {
-            const ret = new Float32Array(arg0);
+        __wbg_new_68c044c0b3877148: function(arg0) {
+            const ret = new Uint32Array(arg0);
             return ret;
         },
-        __wbg_new_cd45aabdf6073e84: function(arg0) {
+        __wbg_new_77cc4f4f472aeb81: function(arg0) {
             const ret = new Uint8Array(arg0);
             return ret;
         },
-        __wbg_new_da52cf8fe3429cb2: function() {
+        __wbg_new_ebe3e0f6837f0879: function() {
             const ret = new Object();
             return ret;
         },
-        __wbg_new_dfd44b7151fab657: function(arg0) {
-            const ret = new Uint32Array(arg0);
+        __wbg_new_with_byte_offset_and_length_042855770b1f0cf5: function(arg0, arg1, arg2) {
+            const ret = new Uint32Array(arg0, arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
-        __wbg_new_with_byte_offset_and_length_1fdfe3033ce1dccd: function(arg0, arg1, arg2) {
+        __wbg_new_with_byte_offset_and_length_1aca16330a3ebb0a: function(arg0, arg1, arg2) {
             const ret = new Float32Array(arg0, arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
-        __wbg_new_with_byte_offset_and_length_54c7724ee3ec7d82: function(arg0, arg1, arg2) {
-            const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
-            return ret;
-        },
-        __wbg_new_with_byte_offset_and_length_5784416b97d45088: function(arg0, arg1, arg2) {
+        __wbg_new_with_byte_offset_and_length_8a19fd6506a908ea: function(arg0, arg1, arg2) {
             const ret = new Float64Array(arg0, arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
-        __wbg_new_with_byte_offset_and_length_c6e1a1aae380b2ff: function(arg0, arg1, arg2) {
-            const ret = new Uint32Array(arg0, arg1 >>> 0, arg2 >>> 0);
+        __wbg_new_with_byte_offset_and_length_ff6e927f8d72f0c3: function(arg0, arg1, arg2) {
+            const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
-        __wbg_new_with_length_f8cbc3a5b9ff9368: function(arg0) {
+        __wbg_new_with_length_2ccc5dbfb4541247: function(arg0) {
             const ret = new Array(arg0 >>> 0);
             return ret;
         },
-        __wbg_next_6dbf2c0ac8cde20f: function(arg0) {
-            const ret = arg0.next;
-            return ret;
-        },
-        __wbg_next_71f2aa1cb3d1e37e: function() { return handleError(function (arg0) {
+        __wbg_next_42cf16ee0dafc9e2: function() { return handleError(function (arg0) {
             const ret = arg0.next();
             return ret;
         }, arguments); },
+        __wbg_next_8f26b64fa5e9f64b: function(arg0) {
+            const ret = arg0.next;
+            return ret;
+        },
         __wbg_objecttransformevent_new: function(arg0) {
             const ret = ObjectTransformEvent.__wrap(arg0);
             return ret;
         },
-        __wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
+        __wbg_prototypesetcall_de8e0d9553586985: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
-        __wbg_push_d2ae3af0c1217ae6: function(arg0, arg1) {
+        __wbg_push_adb0107829f02d75: function(arg0, arg1) {
             const ret = arg0.push(arg1);
             return ret;
         },
@@ -16336,28 +17082,32 @@ function __wbg_get_imports() {
             const ret = RenderableFeatureRemovedEvent.__wrap(arg0);
             return ret;
         },
-        __wbg_set_1e016b6a1b5f7cb3: function(arg0, arg1, arg2) {
-            arg0.set(getArrayF32FromWasm0(arg1, arg2));
-        },
-        __wbg_set_29967298e530d279: function(arg0, arg1, arg2) {
+        __wbg_set_22c3e3730946c809: function(arg0, arg1, arg2) {
             arg0.set(getArrayF64FromWasm0(arg1, arg2));
         },
-        __wbg_set_4d7dd76f3dae2926: function(arg0, arg1, arg2) {
-            arg0.set(getArrayU8FromWasm0(arg1, arg2));
+        __wbg_set_577f5f7485b6744e: function(arg0, arg1, arg2) {
+            arg0.set(getArrayF32FromWasm0(arg1, arg2));
         },
         __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
             arg0[arg1] = arg2;
         },
-        __wbg_set_8535240470bf2500: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_set_8155bb79a948541b: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_set_8a16b38e4805b298: function(arg0, arg1, arg2) {
+        __wbg_set_a80955eb93b145c6: function(arg0, arg1, arg2) {
             arg0[arg1 >>> 0] = arg2;
         },
-        __wbg_set_b5e6b338281ca6ff: function(arg0, arg1, arg2) {
+        __wbg_set_b9b5b5cb7b495037: function(arg0, arg1, arg2) {
+            arg0.set(getArrayU8FromWasm0(arg1, arg2));
+        },
+        __wbg_set_e575799cdfbae72f: function(arg0, arg1, arg2) {
             arg0.set(getArrayU32FromWasm0(arg1, arg2));
         },
+        __wbg_terrainheightrangeupdatedevent_new: function(arg0) {
+            const ret = TerrainHeightRangeUpdatedEvent.__wrap(arg0);
+            return ret;
+        },
         __wbg_terrainheightupdatedevent_new: function(arg0) {
             const ret = TerrainHeightUpdatedEvent.__wrap(arg0);
             return ret;
@@ -16374,7 +17124,7 @@ function __wbg_get_imports() {
             const ret = TileUvTransform.__wrap(arg0);
             return ret;
         },
-        __wbg_value_a5d5488a9589444a: function(arg0) {
+        __wbg_value_1e2369fab29b420e: function(arg0) {
             const ret = arg0.value;
             return ret;
         },
@@ -16503,6 +17253,9 @@ const DelegatedWorkerTasksParametersFinalization = (typeof FinalizationRegistry
 const DelegatedWorkerTasksResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_delegatedworkertasksresult_free(ptr, 1));
+const DracoAttributeIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_dracoattributeid_free(ptr, 1));
 const DynamicSseFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_dynamicsse_free(ptr, 1));
@@ -16563,6 +17316,9 @@ const MeshAddedFinalization = (typeof FinalizationRegistry === 'undefined')
 const MeshChangedFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_meshchanged_free(ptr, 1));
+const MeshGeometryReplacedFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_meshgeometryreplaced_free(ptr, 1));
 const ModelInternalMaterialFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_modelinternalmaterial_free(ptr, 1));
@@ -16683,6 +17439,9 @@ const SourceDataFinalization = (typeof FinalizationRegistry === 'undefined')
 const SourceDescriptionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sourcedescription_free(ptr, 1));
+const TerrainHeightRangeUpdatedEventFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_terrainheightrangeupdatedevent_free(ptr, 1));
 const TerrainHeightUpdatedEventFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_terrainheightupdatedevent_free(ptr, 1));