isard 1.16.0 → 2.0.0

package/dist/wasm/{isard_core.d.ts → isard_webgl2.d.ts}

@@ -1,6 +1,25 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/** A feature picked: its layer and its index there (the edge of a network, the feature of a layer) */
+export interface PickHit {
+    layer: number;
+    index: number;
+}
+
+/** The answer to `requestPick`, from `pollPick` */
+export interface PickResult {
+    /** The screen point asked about (CSS pixels) */
+    x: number;
+    y: number;
+    /** The feature there, if any */
+    hit?: PickHit;
+    /** The position there, on the relief; undefined above the horizon */
+    lonLat?: [lon: number, lat: number];
+}
+
+
+
 /** Camera, with the conventions of MapLibre */
 export interface Camera {
     center: [lon: number, lat: number];
@@ -11,14 +30,6 @@ export interface Camera {
     bearing: number;
 }
 
-/** The feature under a screen point */
-export interface PickHit {
-    /** Id of the layer */
-    layer: number;
-    /** Index of the feature in the layer (the edge of a network) */
-    index: number;
-}
-
 /** Tile counters of a raster layer */
 export interface RasterLayerStats {
     id: number;
@@ -40,6 +51,81 @@ export interface RasterLayerStats {
 
 
 
+/** Counters of a 3D Tiles layer */
+export interface Tiles3dStats {
+    /** Tiles drawn in the last frame */
+    drawn: number;
+    /** Meshes held on the GPU */
+    loaded: number;
+    /** Downloads of tiles in view */
+    inFlight: number;
+    /** Downloads of tiles just out of view (siblings of refined tiles), in the background */
+    prefetching: number;
+    /** GPU memory of the meshes, MB */
+    gpuMb: number;
+    /** Tiles known in the tree (external tilesets included once loaded) */
+    tiles: number;
+}
+
+
+
+/** Counters of a point cloud layer */
+export interface PointCloudStats {
+    /** Points drawn in the last frame */
+    points: number;
+    /** Nodes drawn in the last frame */
+    nodes: number;
+    /** Nodes held on the GPU */
+    loaded: number;
+    /** Downloads under way */
+    inFlight: number;
+    /** GPU memory of the points, MB */
+    gpuMb: number;
+    /** Nodes known in the hierarchy (its pages loaded so far) */
+    known: number;
+}
+
+/** What a point cloud says of itself once its head is read */
+export interface PointCloudInfo {
+    /** Points in the file */
+    points: number;
+    /** LAS point format (6 to 8: 7 and 8 with colors) */
+    format: number;
+    /** The WKT of its CRS, if the file has one */
+    wkt?: string;
+    /** The center of its cube: longitude, latitude */
+    center: [lon: number, lat: number];
+    /** Its altitudes, lowest and highest (metres) */
+    altitudes: [min: number, max: number];
+}
+
+/** A point picked in a point cloud */
+export interface PointCloudPoint {
+    lonLat: [lon: number, lat: number];
+    /** Metres above the ellipsoid */
+    height: number;
+    /** Its z in the file's vertical datum (metres) */
+    altitude: number;
+    classification: number;
+    intensity: number;
+    returnNumber: number;
+    numberOfReturns: number;
+    /** 8-bit color, files with colors only */
+    rgb?: [r: number, g: number, b: number];
+}
+
+/** The CRS of a point cloud, as the page resolves it from the file's WKT (`addPointCloud`) */
+export interface PointCloudCrs {
+    /** x, y pairs of the CRS to longitudes, latitudes (degrees) */
+    inverse(xy: Float64Array): Float64Array;
+    /** The altitudes are above the geoid (IGN69): raised by the RAF20 geoid height */
+    geoid: boolean;
+    /** Metres of a unit of z */
+    verticalScale: number;
+}
+
+
+
 /** Pieces of a network layer: its edges cut along their lines, sorted by square; only the squares in view are drawn */
 export interface NetworkStats {
     pieces: number;
@@ -49,47 +135,47 @@ export interface NetworkStats {
 
 
 
-/** The answer to `requestPick`, from `pollPick` */
-export interface PickResult {
-    /** The screen point asked about (CSS pixels) */
-    x: number;
-    y: number;
-    /** The feature there, if any */
-    hit?: PickHit;
-    /** The position there, on the relief; undefined above the horizon */
-    lonLat?: [lon: number, lat: number];
+/** What a custom layer draws into before the frame's pass: the engine's device, the layer's color (cleared, at the
+ * canvas's size; premultiplied alpha) and in the '3d' mode its depth (the solid scene's, to test against) */
+export interface CustomTarget {
+    device: GPUDevice;
+    color: GPUTexture;
+    format: 'rgba8unorm';
+    depth?: GPUTexture;
+    depthFormat: 'depth32float';
+    width: number;
+    height: number;
 }
 
 
 
 /**
- * A map on one canvas: its WebGL2 context, camera, ground (raster layers over the relief) and the layers over it.
- * Draws only when `render` is called (the JavaScript side calls it after `redraw` asks for a frame)
+ * A map on one canvas: its device, its camera, what it draws. Draws only when `render` is called (the JavaScript
+ * side calls it after `redraw` asks for a frame)
  */
 export class Engine {
+    private constructor();
     free(): void;
     /**
      * Circle layer of `feature_count` features: points (Mercator [0, 1], interleaved) and the feature of each
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
-     * info log), or when `feature_count` features need a table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when `feature_count` features need a table past the GPU's largest texture
      */
     addCircles(points: Float64Array, feature: Uint32Array, feature_count: number): number;
     /**
-     * A layer drawn by the page: `render()` is called at its place in every frame (`customMatrix` gives the
-     * matrices of that frame meanwhile); `depth`: with the depth buffer of the 3D layers (`3d` mode), else over
-     * what is drawn before it
+     * A layer drawn by the page: `render(target)` is called before every frame's pass with its targets (the device,
+     * the color, the depth in `'3d'`: `customMatrix` gives the matrices of that frame meanwhile), what it drew laid over
+     * the frame at the layer's place; `depth`: with the depth of the solid scene (`'3d'` mode)
      */
-    addCustomLayer(render: () => void, depth: boolean): number;
+    addCustomLayer(render: (target: CustomTarget) => void, depth: boolean): number;
     /**
      * An empty extrusion layer: its blocks come in batches (`setExtrusionBatch`)
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
-     * info log)
+     * Never in practice: the layer starts empty
      */
     addExtrusions(): number;
     /**
@@ -99,8 +185,7 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
-     * info log), or when `feature_count` features need a table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when `feature_count` features need a table past the GPU's largest texture
      */
     addFills(points: Float64Array, ring_start: Uint32Array, polygon_start: Uint32Array, feature: Uint32Array, feature_count: number): number;
     /**
@@ -109,52 +194,61 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL object cannot be created, a shader fails to compile or the trails need a
-     * table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when the trails need a table past the GPU's largest texture
      */
     addFlow(particles: number, trail: number): number;
     /**
-     * Ground layer running `code` (GLSL ES 3.0 defining `vec4 ground(vec2 offset)`, see `render::ground`) over the
-     * ground; `anchor`: Mercator point the offsets are taken from; bounds: Mercator box it shows in. Compilation errors
-     * come back with the shader's info log (line numbers of `code`)
+     * Ground layer running `code` (WGSL defining `fn ground(offset: vec2f) -> vec4f`, see `render::ground`) over the
+     * ground; `names` and `types`: its uniforms (`f32`, `vec2f`, `vec4<u32>`, `mat4x4f`…), read as `u.<name>`;
+     * `anchor`: Mercator point the offsets are taken from; bounds: Mercator box it shows in. Compilation errors are
+     * reported in the console when the layer is first drawn
      *
      * # Errors
      *
-     * Throws (to JavaScript) when `code` does not compile or link, with the shader's info log
+     * Throws (to JavaScript) on a uniform's name or type WGSL does not take
      */
-    addGround(code: string, anchor_x: number, anchor_y: number, min_x: number, min_y: number, max_x: number, max_y: number): number;
+    addGround(code: string, names: string[], types: string[], anchor_x: number, anchor_y: number, min_x: number, min_y: number, max_x: number, max_y: number): number;
     /**
      * Line layer of `feature_count` features: polylines given by their points (Mercator [0, 1], interleaved), the
      * first point of each (`start`, one more entry than lines) and the feature each one belongs to
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
-     * info log), or when the features or the lines need a table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when the features or the lines need a table past the GPU's largest texture
      */
     addLines(points: Float64Array, start: Uint32Array, feature: Uint32Array, feature_count: number, heights?: Float64Array | null, sea?: boolean | null): number;
+    /**
+     * A glTF / GLB model (its URL, a `blob:` one for data of the page) drawn at each instance of `instances`
+     * (`geo::models::INSTANCE_NUMBERS` numbers each: longitude, latitude, altitude, heading, pitch, roll in degrees,
+     * scale); `ground`: altitudes above the relief, else above the ellipsoid. A model that fails to load or decode
+     * leaves the layer empty
+     */
+    addModels(url: string, instances: Float64Array, ground: boolean): number;
     /**
      * Network of `mercator.length / 2` nodes (Mercator [0, 1], y towards the south, interleaved: converted by the
      * JavaScript side, where `Math.tan` and `Math.log` are much faster than in WebAssembly) and `edges.length / 2`
-     * edges (node index pairs, interleaved). `line_start` and `line_points`: the line of each edge from A to B, points
-     * `line_start[e] .. line_start[e + 1]` of `line_points` (Mercator, interleaved; straight if fewer than two). `costs`: per edge, the
-     * cost of travelling it from A to B then from B to A; without, values are interpolated along the edges.
+     * edges (node index pairs, interleaved). `line_start` and `line_points`: the line of each edge from A to B,
+     * points `line_start[e] .. line_start[e + 1]` of `line_points` (Mercator, interleaved; straight if fewer than
+     * two). `costs`: per edge, the cost of travelling it from A to B then from B to A; without, values are
+     * interpolated along the edges.
      *
      * # Errors
      *
-     * Throws (to JavaScript) when `style` is not 25 numbers, `edges` is not node pairs or names a node past
-     * those of `mercator`, the nodes or edges need a table texture past the GPU's `MAX_TEXTURE_SIZE`, or when
-     * a WebGL object cannot be created or a shader fails to compile (the error carries its info log)
+     * Throws (to JavaScript) when `style` is not 25 numbers, `edges` is not node pairs or names a node past those of
+     * `mercator`, or the nodes or edges need a table past the GPU's largest texture
      */
     addNetwork(mercator: Float64Array, edges: Uint32Array, line_start: Uint32Array | null | undefined, line_points: Float64Array | null | undefined, costs: Float32Array | null | undefined, style: Float32Array): number;
+    /**
+     * A COPC point cloud from its URL (HTTP range requests). `resolve(wkt)` gives the CRS of the file from its WKT
+     * (undefined if it has none): its inverse projection, whether its altitudes are above the geoid, the metres of
+     * a unit of z; it may throw (an unknown CRS), the layer then stays empty
+     * The file is read later: a bad file, or a `resolve` that throws, leaves the layer empty
+     */
+    addPointCloud(url: string, resolve: (wkt: string | undefined) => PointCloudCrs): number;
     /**
      * Raster tiles in Web Mercator; `url` holds {z}, {x} and {y}. `size`: side of the tiles' textures (256 by
      * default); `loader`: draws each tile instead of fetching `url`, `(z, x, y, signal) => Promise<ImageBitmap |
      * null>`, an image of `size` × `size` (null: nothing there); `ground: false`: draped on 3D layers only
-     *
-     * # Errors
-     *
-     * Throws (to JavaScript) when the texture holding the layer's tiles cannot be created
      */
     addRaster(url: string, min_z: number, max_z: number, opacity: number, saturation: number, size: number | null | undefined, loader: ((z: number, x: number, y: number, signal: AbortSignal) => Promise<ImageBitmap | null>) | undefined, ground?: boolean | null): number;
     /**
@@ -162,19 +256,30 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
-     * info log)
+     * Never in practice: its tables start empty
      */
     addSymbols(): number;
+    /**
+     * 3D Tiles (b3dm / glb textured meshes, external tilesets) from the URL of a `tileset.json`. `max_error`:
+     * screen-space error (CSS pixels) above which a tile is refined; 16 is the usual value, lower is finer.
+     * `geoid`: its heights are altitudes (NGF-IGN69), each tile raised by the RAF20 geoid onto the relief.
+     *
+     * The tileset is read later: a bad one leaves the layer empty
+     */
+    addTiles3d(url: string, max_error: number, geoid?: boolean | null): number;
     /**
      * An empty layer of vector tiles drawn as geometry: its style layers come with `setVectorSublayers`, its tiles
-     * with `setVectorTile`
+     * with `setVectorTile` or `setVectorTileMesh`
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a shader fails to compile (the error carries its info log)
+     * Never in practice: the layer starts empty
      */
     addVectorTiles(): number;
+    /**
+     * The backend drawing: "browserwebgpu" or "gl"
+     */
+    backend(): string;
     /**
      * Longitudes and latitudes the view covers on the ground, `[west, south, east, north]` (degrees): the screen's
      * border cast on the ground, or on the far plane where it passes the horizon
@@ -184,6 +289,10 @@ export class Engine {
      * The camera as set or moved: center (degrees), zoom, pitch and bearing (degrees)
      */
     camera(): Camera;
+    /**
+     * Removes the panorama
+     */
+    clearPanorama(): void;
     /**
      * The turns go around the screen center again
      */
@@ -197,7 +306,16 @@ export class Engine {
      */
     clearViewshed(): void;
     /**
-     * Model-view-projection matrix (16 numbers, column-major, for `uniformMatrix4fv`) of the local frame at a
+     * The engine of `canvas`, `redraw` called when it needs a new frame; `antialias`: the 3D multisampled (default
+     * true). Asynchronous: the device is asked for
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the canvas gives no device ("WebGPU is not available" through WebGPU)
+     */
+    static create(canvas: HTMLCanvasElement, redraw: () => void, antialias?: boolean | null): Promise<Engine>;
+    /**
+     * Model-view-projection matrix (16 numbers, column-major, WebGPU's clip depth from 0 to 1) of the local frame at a
      * longitude, latitude (degrees) and altitude (metres): x east, y north, z up, in metres. Undefined outside the
      * callback of a custom layer. Static: the engine is borrowed while it draws
      */
@@ -213,23 +331,29 @@ export class Engine {
      */
     static geoidHeight(lon: number, lat: number): number;
     /**
-     * Position under a screen point (CSS pixels), undefined above the horizon; on the relief itself: from the copy of
-     * its tiles kept on the CPU, the drawn ground read back from the GPU only where none is there (a read back waits
-     * for the frame: called during a move, it stalls it)
+     * The `GPUDevice` the engine draws with, for the custom layers' objects; undefined on the WebGL2 fallback
+     */
+    gpuDevice(): GPUDevice | undefined;
+    /**
+     * Position under a screen point (CSS pixels), undefined above the horizon
      */
     ground(x: number, y: number): [lon: number, lat: number] | undefined;
     /**
-     * Colors an extrusion layer by the node values of network layer `network` (undefined: by its own values):
-     * each block takes min(value(A) + cost from A, value(B) + cost from B) from its anchors (`setExtrusionAnchors`),
+     * Colors an extrusion layer by the node values of network layer `network` (undefined: by its own values): each
+     * block takes min(value(A) + cost from A, value(B) + cost from B) from its anchors (`setExtrusionAnchors`),
      * through the layer's ramp, up to `max` (above: its own color)
      */
     linkExtrusionNetwork(id: number, network: number | null | undefined, max: number): void;
     /**
-     * Model-view-projection matrix (16 numbers, column-major) of the local frame at a longitude, latitude (degrees)
-     * and altitude (metres), x east, y north, z up, in metres, for the last frame drawn (else the camera): the 3D
-     * overlays of the page (`Panel`) placed with it after each frame
+     * Model-view-projection matrix (16 numbers, column-major, WebGL's clip depth) of the local frame at a longitude,
+     * latitude (degrees) and altitude (metres), x east, y north, z up, in metres, for the last frame drawn (else the
+     * camera): the 3D overlays of the page (`Panel`) placed with it after each frame
      */
     localMatrix(lon: number, lat: number, altitude: number): Float32Array;
+    /**
+     * The largest texture the device takes (pixels a side): the symbol layers' atlases stay within it
+     */
+    maxTextureSize(): number;
     /**
      * Moves a layer to a drawing position (0 = bottom)
      */
@@ -238,33 +362,29 @@ export class Engine {
      * Pieces of a network in all and drawn in the last frame (only the squares in view are)
      */
     networkStats(id: number): NetworkStats | undefined;
-    /**
-     * `redraw` is called when the engine needs a new frame (a tile arrived); `antialias`: multisampled (default true)
-     *
-     * # Errors
-     *
-     * Throws (to JavaScript) when the canvas gives no WebGL2 context ("WebGL2 is not available"), or when a WebGL
-     * object of the globe, the sky or the raster pass cannot be created or one of their shaders fails to compile
-     */
-    constructor(canvas: HTMLCanvasElement, redraw: () => void, antialias?: boolean | null);
     /**
      * Drags the ground from one screen point to another (CSS pixels); in relief, the ground point grabbed stays
      * under the cursor
      */
     pan(x0: number, y0: number, x1: number, y1: number): void;
     /**
-     * Feature under a screen point (CSS pixels), or the nearest one within `radius` CSS pixels: its layer and its
-     * index there (the edge of a network, the feature of a line, circle or fill layer), undefined if none. The
-     * pickable layers are drawn with each feature colored by its number; then the fills are tested on the ground.
-     * `only`: the ids of the layers to look in (all if undefined): the others are not drawn and hide nothing.
-     * Reads the pixels back at once (the GPU finishes its work first): for clicks; `requestPick` for the hover
+     * What a point cloud says of itself, undefined before its head is read
+     */
+    pointCloudInfo(id: number): PointCloudInfo | undefined;
+    /**
+     * The point of a point cloud picked by `pollPick` (its index there): read back with the answer; undefined for
+     * another
+     */
+    pointCloudPoint(id: number, index: number): PointCloudPoint | undefined;
+    /**
+     * Counters of a point cloud layer, undefined if there is none with this id
      */
-    pick(x: number, y: number, radius?: number | null, only?: Uint32Array | null): PickHit | undefined;
+    pointCloudStats(id: number): PointCloudStats | undefined;
     /**
-     * The answer to the last `requestPick` once the GPU has delivered it (then forgotten), undefined while it is not
-     * there yet (or nothing was asked, or the context was lost)
+     * The answer to request `id` once the GPU has delivered it (then forgotten), undefined while it is not there yet
+     * (or for a request given up)
      */
-    pollPick(): PickResult | undefined;
+    pollPick(id: number): PickResult | undefined;
     /**
      * Loads in advance the tiles of a camera flight's destination; `clearPreload` when the flight ends
      */
@@ -283,7 +403,7 @@ export class Engine {
      */
     removeExtrusionBatch(id: number, key: number): void;
     /**
-     * Removes a layer and frees its GPU objects; the other layers forget it (a layer that referred to it)
+     * Removes a layer and frees its GPU objects (as it drops)
      */
     removeLayer(id: number): void;
     /**
@@ -291,16 +411,17 @@ export class Engine {
      */
     removeVectorTile(id: number, key: number): void;
     /**
-     * Draws a frame: the backdrop, the ground and the layers over it bottom to top, then the panorama and the
-     * viewshed; returns true while tiles are still loading (a new frame will be asked through `redraw`)
+     * Draws a frame: the backdrop, the ground; returns true while tiles are still loading (a new frame will be asked
+     * through `redraw`)
      */
     render(): boolean;
     /**
-     * Asks what is under a screen point without waiting for the GPU (as `pick`, with the position there): the
-     * picking pass is drawn now and read back into a buffer; `pollPick` gives the answer on a later frame. A new
-     * request replaces the one in flight. Returns false if nothing could be asked (no WebGL2 fence)
+     * Asks what is under a screen point (CSS pixels), or nearest to it within `radius` CSS pixels, without waiting
+     * for the GPU: the picking pass is drawn now, its pixels read back later; `pollPick` gives the answer. `only`: the
+     * ids of the layers to look in (all if undefined): the others are not drawn and hide nothing. The request's
+     * number, never 0
      */
-    requestPick(x: number, y: number, radius?: number | null, only?: Uint32Array | null): boolean;
+    requestPick(x: number, y: number, radius?: number | null, only?: Uint32Array | null): number;
     /**
      * Viewport in CSS pixels and device pixel ratio
      */
@@ -322,8 +443,7 @@ export class Engine {
      * The body the map is drawn on: its equatorial radius (metres) and flattening (0 for a sphere), the halo of its
      * atmosphere around the globe (RGB 0-1 and its strength, 4 numbers; `undefined` for an airless body), and the
      * lowest and highest altitudes of its ground (metres: what its relief may raise into view). WGS 84, the Earth's
-     * blue halo and the range of its relief worldwide (-450 m to 8900 m) by default; set before the layers and the
-     * relief, whose shaders may take its size (`ISARD_CIRCUMFERENCE` of the ground layers)
+     * blue halo and the range of its relief worldwide (-450 m to 8900 m) by default
      */
     setBody(radius: number, flattening: number, halo: Float32Array | null | undefined, lowest: number, highest: number): void;
     /**
@@ -344,8 +464,7 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when the batch's features need an anchor texture past the GPU's
-     * `MAX_TEXTURE_SIZE`, or when it cannot be created
+     * Throws (to JavaScript) when the batch's features need a table past the GPU's largest texture
      */
     setExtrusionAnchors(id: number, key: number, anchors: Float32Array): void;
     /**
@@ -354,8 +473,7 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL buffer or vertex array of the batch cannot be created, or when
-     * `feature_count` features need a table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when `feature_count` features need a table past the GPU's largest texture
      */
     setExtrusionBatch(id: number, key: number, points: Float64Array, ring_start: Uint32Array, polygon_start: Uint32Array, feature: Uint32Array, feature_count: number, roofs: Uint8Array, roof_heights: Float32Array, metres: number): void;
     /**
@@ -437,7 +555,7 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) as `setGlyphPages` does: a size that is not positive, or the texture not created
+     * Throws (to JavaScript) as `setGlyphPages` does
      */
     setGlyphAtlas(width: number, height: number, data?: Uint8Array | null): void;
     /**
@@ -447,8 +565,8 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when `width` or `height` is not positive (or their product overflows), `pages`
-     * is not 1 to 256, or the atlas texture cannot be created
+     * Throws (to JavaScript) when `width` or `height` is not positive or past the GPU's largest texture, or `pages`
+     * is not 1 to 256
      */
     setGlyphPages(width: number, height: number, pages: number): void;
     /**
@@ -456,23 +574,22 @@ export class Engine {
      */
     setGroundBounds(id: number, min_x: number, min_y: number, max_x: number, max_y: number): void;
     /**
-     * Creates the texture of sampler `name` (`format`: r8, r8ui, r16ui, r16i, r32ui, r32f, rg16ui, rg32f, rgba8,
-     * rgba8ui, rgba16ui, rgba32f; `depth` 0 for 2D, else a 2D array of that many layers; `linear` filtering for the
-     * non-integer formats); `data`: its texels as bytes, or undefined for an empty texture
+     * Creates the texture `name` of a ground layer (`format`: r8, r8ui, r16ui, r16i, r32ui, r32f, rg16ui, rg32f,
+     * rgba8, rgba8ui, rgba16ui, rgba32f; `depth` 0 for 2D, else a 2D array of that many layers); `data`: its texels
+     * as bytes, or undefined for an empty texture
      *
      * # Errors
      *
-     * Throws (to JavaScript) on an unknown `format`, a size not positive (or overflowing), `data` shorter
-     * than the texels, more textures than the layer takes, or a texture WebGL cannot create
+     * Throws (to JavaScript) on an unknown `format`, a size of 0, `data` shorter than the texels, a name WGSL does not
+     * take, or more textures than the layer takes
      */
-    setGroundTexture(id: number, name: string, format: string, width: number, height: number, depth: number, linear: boolean, data?: Uint8Array | null): void;
+    setGroundTexture(id: number, name: string, format: string, width: number, height: number, depth: number, data?: Uint8Array | null): void;
     /**
-     * A uniform of a ground layer's code, as numbers
+     * A uniform of a ground layer's code, as numbers (column major for a matrix)
      *
      * # Errors
      *
-     * Throws (to JavaScript) when the shader has no uniform `name` (one its code does not use is removed
-     * by the compiler)
+     * Throws (to JavaScript) when no uniform `name` was declared, or for a count of numbers not its type's
      */
     setGroundUniform(id: number, name: string, values: Float64Array): void;
     /**
@@ -485,8 +602,7 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when `width` or `height` is not positive (or their product overflows), or the
-     * atlas texture cannot be created
+     * Throws (to JavaScript) when `width` or `height` is not positive or past the GPU's largest texture
      */
     setIconAtlas(width: number, height: number): void;
     /**
@@ -503,14 +619,28 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when the lines need a table texture past the GPU's `MAX_TEXTURE_SIZE`, or
-     * when it cannot be created; the layer then keeps its lines
+     * Throws (to JavaScript) when the lines need a table past the GPU's largest texture; the layer then keeps its
+     * lines
      */
     setLines(id: number, points: Float64Array, start: Uint32Array, feature: Uint32Array, heights?: Float64Array | null, sea?: boolean | null): void;
     /**
      * Highest pitch the camera accepts, degrees (up to 85)
      */
     setMaxPitch(max: number): void;
+    /**
+     * Lights at night the part of a model layer's model from `from` metres up (a street lamp's head) in `r, g, b`;
+     * `from` not a number: none
+     */
+    setModelGlow(id: number, from: number, r: number, g: number, b: number): void;
+    /**
+     * Highlights the feature `feature` of a model layer's model (an IFC model's element) in `r, g, b`; `feature` not a
+     * number: none
+     */
+    setModelHighlight(id: number, feature: number, r: number, g: number, b: number): void;
+    /**
+     * Replaces the instances of a model layer (as for `addModels`) and the reference of their altitudes
+     */
+    setModelInstances(id: number, instances: Float64Array, ground: boolean): void;
     /**
      * Costs of a network's edges (see `addNetwork`), when the way it is travelled changes; null: interpolated values
      */
@@ -533,12 +663,33 @@ export class Engine {
      * One value per node; negative = unreached
      */
     setNetworkValues(id: number, values: Float32Array): void;
+    /**
+     * The image of camera `index` of the panorama (the images sharing the size of the first), which the engine takes
+     * (closes once copied)
+     */
+    setPanoramaImage(index: number, image: ImageBitmap): void;
+    /**
+     * Shows a panorama: at `lon`, `lat` (degrees) and `height` (metres above the ellipsoid), turned by `rotation`
+     * (9 numbers, row-major: its frame to east, north, up), its `cameras` (25 numbers each: rotation from the panorama
+     * frame, row-major, 9; position in it, 3; focal x, y; center x, y; skew; image width, height; principal point of
+     * the distortion x, y; its coefficients r³, r⁵, r⁷; its limit, pixels), a backdrop sphere of `radius` metres, at
+     * `opacity`. Its images come after (`setPanoramaImage`)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when `rotation` holds fewer than 9 numbers
+     */
+    setPanorama(lon: number, lat: number, height: number, rotation: Float64Array, cameras: Float64Array, radius: number, opacity: number): void;
     /**
      * Sets the point the next turns and tilts go around (`rotate`): what is drawn under a screen point (CSS
-     * pixels), a roof or a mesh as the relief. Read back from the last frame (a stall): once, where a drag starts.
-     * Returns whether something was drawn there; over nothing, the turns go around the center
+     * pixels). Returns whether something was drawn there; over nothing, the turns go around the center
      */
     setPivot(x: number, y: number): boolean;
+    /**
+     * The style of a point cloud: 14 numbers (see `Style::parse`), the colors of the 256 classes (RGBA,
+     * alpha 0 hides a class) and the ramp of the altitudes (256 RGBA texels)
+     */
+    setPointCloudStyle(id: number, style: Float64Array, palette: Uint8Array, ramp: Uint8Array): void;
     /**
      * Opacity and saturation (0-1) of a raster layer; nothing for another id
      */
@@ -556,16 +707,11 @@ export class Engine {
      * The sun casting shadows and the night: its azimuth (degrees clockwise from north) and altitude (degrees above
      * the horizon), the shadows' opacity (0 to 1; none under the horizon or not a number), how dark the night is (0 to
      * 1: the frame tinted, the lights of the layers on). Neither shadows nor night: nothing drawn
-     *
-     * # Errors
-     *
-     * Throws (to JavaScript) when a WebGL object cannot be created or the pass fails to compile
      */
     setSun(azimuth: number, altitude: number, opacity: number, night: number): void;
     /**
-     * Shows `layers` on one side of a vertical line only, the others beneath on the other side (comparing two states
-     * of a place): left of `x` (CSS pixels from the left of the canvas), or right of it; `others` on the other side
-     * only (two meshes of the same place, each on its side, never drawn over each other); a non-finite `x` stops
+     * Shows `layers` left of `x` (CSS pixels from the left of the canvas; right of it if `right`), `others` on the
+     * other side only; `x` not a number, or no layer: no swipe
      */
     setSwipe(x: number, right: boolean, layers: Uint32Array, others: Uint32Array): void;
     /**
@@ -581,51 +727,68 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when the labels need a table texture past the GPU's `MAX_TEXTURE_SIZE`, or
-     * when it cannot be created; the layer then keeps its labels
+     * Throws (to JavaScript) when the labels need a table past the GPU's largest texture; the layer then keeps its
+     * labels
      */
     setSymbols(id: number, anchors: Float64Array, boxes: Float32Array, styles: Float32Array, quads: Float32Array, paths: Float64Array): void;
     /**
      * Relief under the raster layers, from raw altitudes (`image/x-bil;bits=32`, 256 × 256, or the same followed by
      * the validity mask of an `ArcGIS` raw grid): `url` is a template with `{bbox}` (WMS `GetMap` in EPSG:3857, or in
      * the Mercator metres of another body) or `{z}/{x}/{y}`; `undefined` turns it off. `exaggeration` scales the
-     * heights (1: true relief); `max_z`: finest level loaded (up to 15, from 6 on the Earth, coarser on bodies of a
-     * larger relief for their size: `terrain_levels`); `geoid`: altitudes raised by the RAF20 geoid height (heights
-     * above the ellipsoid, those of 3D Tiles; over France, on the Earth only), else left as served (the default);
-     * `loader`: gives the
-     * altitudes of each tile instead of fetching `url` (an encoding decoded by the page: Terrarium, Terrain-RGB)
-     *
-     * # Errors
-     *
-     * Throws (to JavaScript) when the texture holding the relief's tiles cannot be created
+     * heights (1: true relief); `max_z`: finest level loaded; `geoid`: altitudes raised by the RAF20 geoid height
+     * (heights above the ellipsoid, those of 3D Tiles; over France, on the Earth only), else left as served (the
+     * default); `loader`: gives the altitudes of each tile instead of fetching `url` (an encoding decoded by the
+     * page: Terrarium, Terrain-RGB)
      */
     setTerrain(url: string | null | undefined, exaggeration: number, max_z: number | null | undefined, geoid: boolean | null | undefined, loader: ((z: number, x: number, y: number, signal: AbortSignal) => Promise<Float32Array | null>) | undefined): void;
+    /**
+     * Pool of workers that fetch and decode 3D Tiles content off the main thread: an object with
+     * `load(id, url, transform, yUp, reload, priority) → Promise<{ anchor, primitives }>` and `abort(id)`. Without
+     * it, tiles are decoded on the main thread. Set it before adding 3D Tiles layers.
+     */
+    setTileLoader(loader: import('./isard_tiles3d.js').TileLoaderLike | null): void;
+    /**
+     * A raster layer draped on a 3D Tiles layer's roofs, or all its faces (`raster` undefined: none)
+     */
+    setTiles3dDrape(id: number, raster: number | null | undefined, all_faces: boolean, opacity: number): void;
+    /**
+     * Whether the walls of a 3D Tiles layer's untextured meshes show their windows: glass by day, some lit at night
+     */
+    setTiles3dFacades(id: number, facades: boolean): void;
+    /**
+     * Each feature of a 3D Tiles layer its color (null: the layer's)
+     */
+    setTiles3dFeatureColors(id: number, colors: ((properties: Record<string, unknown>[] | undefined, count: number) => Uint8Array) | null): void;
+    /**
+     * Screen-space error threshold, opacity, size of the points (CSS pixels, 2 if not given) and color (RGB 0-1, empty
+     * for none: it tints the textures and colors the untextured meshes) of a 3D Tiles layer
+     */
+    setTiles3dStyle(id: number, max_error: number, opacity: number, point_size: number | null | undefined, color: Float32Array): void;
     /**
      * The style layers of a vector tile layer, in drawing order: per layer, its kind (0 fill, 1 line, 2 extrusion, 3
-     * circle), its zoom range
-     * (two numbers: shown from the first, included, to the second, excluded), whether it shows (0 or 1), its dashes
-     * (four numbers: dash, gap, dash, gap, in line widths; 0: solid), its opacity as zoom stops (four zooms then four
-     * values; missing: opaque), the caps of its lines' ends (0 butt, 1 round, 2 square; missing: round), whether its
-     * lines glow at night (streets; 0 or 1), the joins of its lines (two numbers: 0 round, 1 miter, 2 bevel, then the
-     * miter limit in line widths; missing: round), the translation of its fills or lines (three numbers: x and y in CSS
-     * pixels, x right and y down, then 0 if it turns with the map, 1 if it stays on the screen; missing: none), whether its
-     * fills have patterns (0 or 1)
+     * circle), its zoom range (two numbers: shown from the first, included, to the second, excluded), whether it shows
+     * (0 or 1), its dashes (four numbers: dash, gap, dash, gap, in line widths; 0: solid), its opacity as zoom stops
+     * (four zooms then four values; missing: opaque), the caps of its lines' ends (0 butt, 1 round, 2 square; missing:
+     * round), whether its lines glow at night (streets; 0 or 1), the joins of its lines (two numbers: 0 round, 1
+     * miter, 2 bevel, then the miter limit in line widths; missing: round), the translation of its fills or lines
+     * (three numbers: x and y in CSS pixels, x right and y down, then 0 if it turns with the map, 1 if it stays on the
+     * screen; missing: none), whether its fills have patterns (0 or 1)
      */
     setVectorSublayers(id: number, kinds: Uint8Array, zooms: Float64Array, visible: Uint8Array, dashes: Float32Array, opacities: Float32Array, caps: Uint8Array, lit: Uint8Array, joins: Float32Array, translates: Float32Array, patterned: Uint8Array): void;
     /**
      * Adds or replaces tile `key` of a vector tile layer ready for the GPU, as the basemap workers make it (the
-     * tessellation module): its polygons as for `setVectorTile` (picked here; their prisms built here if drawn in
-     * relief while `prism` is false), the vertices of its fills (`shapes::Vertex` as bytes, each with its feature),
-     * their triangles, per sublayer its top cap and the rest of its prism (`fill_ranges`: four numbers, first and
-     * end of each), its line pieces (`pieces::Piece` as bytes), the line table (feature and length of each line),
+     * tessellation module): its polygons as for `setVectorTile` (their prisms built here if drawn in relief while
+     * `prism` is false), the vertices of its fills (`shapes::Vertex` as bytes, each with its feature), their
+     * triangles, per sublayer its top cap and the rest of its prism (`fill_ranges`: four numbers, first and end of
+     * each), its line pieces (`vector_tiles::TilePiece` as bytes), the line table (feature and length of each line),
      * per sublayer its pieces (`line_ranges`: first, end), the blocks of its extrusion sublayers (`shapes::Block` as
      * bytes), their triangles, per sublayer its blocks' triangles (`block_ranges`: first, end), the extent of its
      * points (`bounds`: min x, min y, max x, max y), its features' sublayers (one each, as for `setVectorTile`)
      *
      * # Errors
      *
-     * Throws (to JavaScript) when the vertices, pieces or blocks are cut short, when a WebGL object of the tile cannot be
-     * created, or when its features or lines need a table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when the vertices, pieces or blocks are cut short, or when its features or lines need a
+     * table past the GPU's largest texture
      */
     setVectorTileMesh(id: number, key: number, points: Float64Array, ring_start: Uint32Array, polygon_start: Uint32Array, polygon_feature: Uint32Array, fill_start: Uint32Array, vertices: Uint8Array, indices: Uint32Array, fill_ranges: Uint32Array, prism: boolean, pieces: Uint8Array, line_table: Float32Array, line_ranges: Uint32Array, blocks: Uint8Array, block_indices: Uint32Array, block_ranges: Uint32Array, bounds: Float64Array, feature_sublayer: Uint16Array): void;
     /**
@@ -638,19 +801,16 @@ export class Engine {
      * Adds or replaces tile `key` of a vector tile layer: its polygons as for `addFills` (`fill_start`: the first
      * polygon of each sublayer, and the end; those of an extrusion sublayer raised into blocks), its lines as for
      * `addLines` (`line_start`: the first line of each sublayer, and the end), its features' sublayers (one each, the
-     * features of a sublayer after those of the one before), styled as an
-     * extrusion layer's (`setFeatureStyle` with the key: a color, then a line's width or a block's height and base);
-     * `tile`: the corners of the tile they are cut to (west, north, east, south; empty: none), along whose edges no
-     * wall of a block rises; `roofs` and `roof_heights`: per polygon, the shape and height of its block's roof
-     * (`shapes::Roofs`: 0 flat, 1 to 5 `RoofShape::number`, 255 generated from its outline; metres, not a number: as
-     * its slopes make it; empty: flat), the whole outlines of the buildings the tile cuts (`roof_outlines`, interleaved
-     * Mercator points, `roof_outline_start`: where each polygon's starts, and the end), `roof_metres` the metres per
-     * Mercator unit at the tile
+     * features of a sublayer after those of the one before), styled as an extrusion layer's (`setFeatureStyle` with
+     * the key); `tile`: the corners of the tile they are cut to (west, north, east, south; empty: none), along whose
+     * edges no wall of a block rises; `roofs` and `roof_heights`: per polygon, the shape and height of its block's
+     * roof (`shapes::Roofs`), the whole outlines of the buildings the tile cuts (`roof_outlines`, interleaved Mercator
+     * points, `roof_outline_start`: where each polygon's starts, and the end), `roof_metres` the metres per Mercator
+     * unit at the tile
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL object of the tile cannot be created, or when its features or lines need a
-     * table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when its features or lines need a table past the GPU's largest texture
      */
     setVectorTile(id: number, key: number, points: Float64Array, ring_start: Uint32Array, polygon_start: Uint32Array, polygon_feature: Uint32Array, fill_start: Uint32Array, line_points: Float64Array, line_first: Uint32Array, line_feature: Uint32Array, line_start: Uint32Array, feature_sublayer: Uint16Array, tile: Float64Array, roofs: Uint8Array, roof_heights: Float32Array, roof_outlines: Float64Array, roof_outline_start: Uint32Array, roof_metres: number): void;
     /**
@@ -659,11 +819,6 @@ export class Engine {
      * only heading, tilt, angles of view across and up (degrees), the heading NaN to look all around. What some
      * observer sees is tinted with `visible`, what is hidden from all those that reach it with `hidden` (RGB 0-1),
      * at `opacity`; `outline` (RGB 0-1, or empty) the color of the cones' edges drawn in 3D
-     *
-     * # Errors
-     *
-     * Throws (to JavaScript) when, on the first call, a WebGL object cannot be created or a shader fails to compile
-     * (the error carries its info log)
      */
     setViewshed(observers: Float64Array, visible: Float32Array, hidden: Float32Array, opacity: number, outline: Float32Array): void;
     /**
@@ -681,16 +836,31 @@ export class Engine {
     stepFlow(id: number, seconds: number): boolean;
     /**
      * The height above the relief (metres) of the top of what stands at a position (degrees): a roof, a mesh, 0 on
-     * the bare ground; undefined where nothing of the last frame is there. The scene is drawn from above into a single
-     * pixel and read back (a stall, cheap: one pixel to fill)
+     * the bare ground; undefined where nothing of the last frame is there, or until measured: the scene is drawn
+     * looking down at it after a frame and read back a frame or two later (a frame is asked for), the answer kept and
+     * measured again every 250 ms at most
      */
     surfaceAt(lon: number, lat: number): any;
     /**
      * What is drawn under a screen point (CSS pixels): longitude, latitude and its height above the relief (metres),
-     * on a roof, a wall or a mesh as on the ground; undefined where nothing was drawn. The scene is drawn again and
-     * read back (a stall): for clicks and drags
+     * on a roof, a wall or a mesh as on the ground; undefined where nothing was drawn. From the last copy of the
+     * scene's depth (a frame or two old, one pixel in 4 CSS pixels): at once, without waiting for the GPU
      */
     surface(x: number, y: number): [lon: number, lat: number, height: number] | undefined;
+    /**
+     * Compressed texture formats of the GPU, for the KTX2 transcoding
+     */
+    textureFormats(): import('./isard_tiles3d.js').TextureFormats;
+    /**
+     * The feature of a picked handle (`pick`'s index on a 3D Tiles layer): `[properties, feature]`, its properties
+     * (undefined when its tile has none) and its index in its tile; undefined if the handle is not of the last picking
+     * pass
+     */
+    tiles3dFeature(id: number, index: number): [properties: Record<string, unknown> | undefined, feature: number] | undefined;
+    /**
+     * Counters of a 3D Tiles layer, undefined if there is none with this id
+     */
+    tiles3dStats(id: number): Tiles3dStats | undefined;
     /**
      * A region of the first page of the glyph atlas: `width` × `height` bytes at (`x`, `y`)
      */
@@ -704,24 +874,19 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when there is no texture `name`, or when the region is out of its bounds or
-     * `data` holds too few bytes
+     * Throws (to JavaScript) when there is no texture `name`, or when the region is out of its bounds or `data` holds
+     * too few bytes
      */
     updateGroundTexture(id: number, name: string, x: number, y: number, layer: number, width: number, height: number, data: Uint8Array): void;
     /**
      * A region of the icon atlas: `width` × `height` RGBA texels (premultiplied) at (`x`, `y`)
      */
     updateIconAtlas(x: number, y: number, width: number, height: number, data: Uint8Array): void;
-    /**
-     * Uploads a part more of the blocks of tile `key` of a vector tile layer (a large tile's, a part at a time over
-     * several frames); whether some are left. Its blocks are drawn once they are all there
-     */
-    uploadVectorTile(id: number, key: number): boolean;
     /**
      * Vector tiles (512 CSS pixels across at their level, as `MapLibre`'s) for the view of the last frame (else the
      * camera's), levels `min_z` to `max_z`, three numbers per tile (z, x, y), the nearest to the eye first: what a
-     * vector tile layer draws (`addVectorTiles`), coarser far away in a tilted view as the raster layers, and no
-     * farther than `reach` times the screen center's distance (infinite: to the horizon)
+     * vector tile layer draws, coarser far away in a tilted view as the raster layers, and no farther than `reach`
+     * times the screen center's distance (infinite: to the horizon)
      */
     vectorTilesInView(min_z: number, max_z: number, reach: number): Uint32Array;
     /**
@@ -745,29 +910,38 @@ export interface InitOutput {
     readonly engine_addExtrusions: (a: number) => [number, number, number];
     readonly engine_addFills: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number, number];
     readonly engine_addFlow: (a: number, b: number, c: number) => [number, number, number];
-    readonly engine_addGround: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
+    readonly engine_addGround: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => [number, number, number];
     readonly engine_addLines: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number, number];
+    readonly engine_addModels: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
     readonly engine_addNetwork: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => [number, number, number];
-    readonly engine_addRaster: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number, number];
+    readonly engine_addPointCloud: (a: number, b: number, c: number, d: any) => number;
+    readonly engine_addRaster: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => number;
     readonly engine_addSymbols: (a: number) => [number, number, number];
+    readonly engine_addTiles3d: (a: number, b: number, c: number, d: number, e: number) => number;
     readonly engine_addVectorTiles: (a: number) => [number, number, number];
+    readonly engine_backend: (a: number) => [number, number];
     readonly engine_bounds: (a: number) => [number, number];
     readonly engine_camera: (a: number) => any;
+    readonly engine_clearPanorama: (a: number) => void;
     readonly engine_clearPivot: (a: number) => void;
     readonly engine_clearPreload: (a: number) => void;
     readonly engine_clearViewshed: (a: number) => void;
+    readonly engine_create: (a: any, b: any, c: number) => any;
     readonly engine_customMatrix: (a: number, b: number, c: number) => [number, number];
     readonly engine_elevationAt: (a: number, b: number, c: number) => [number, number];
     readonly engine_geoidHeight: (a: number, b: number) => number;
+    readonly engine_gpuDevice: (a: number) => any;
     readonly engine_ground: (a: number, b: number, c: number) => any;
     readonly engine_linkExtrusionNetwork: (a: number, b: number, c: number, d: number) => void;
     readonly engine_localMatrix: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly engine_maxTextureSize: (a: number) => number;
     readonly engine_moveLayer: (a: number, b: number, c: number) => void;
     readonly engine_networkStats: (a: number, b: number) => any;
-    readonly engine_new: (a: any, b: any, c: number) => [number, number, number];
     readonly engine_pan: (a: number, b: number, c: number, d: number, e: number) => void;
-    readonly engine_pick: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
-    readonly engine_pollPick: (a: number) => any;
+    readonly engine_pointCloudInfo: (a: number, b: number) => any;
+    readonly engine_pointCloudPoint: (a: number, b: number, c: number) => any;
+    readonly engine_pointCloudStats: (a: number, b: number) => any;
+    readonly engine_pollPick: (a: number, b: number) => any;
     readonly engine_preload: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly engine_project: (a: number, b: number, c: number, d: number, e: number) => any;
     readonly engine_promoteFlowNext: (a: number, b: number) => void;
@@ -804,7 +978,7 @@ export interface InitOutput {
     readonly engine_setGlyphAtlas: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly engine_setGlyphPages: (a: number, b: number, c: number, d: number) => [number, number];
     readonly engine_setGroundBounds: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-    readonly engine_setGroundTexture: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => [number, number];
+    readonly engine_setGroundTexture: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number];
     readonly engine_setGroundUniform: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly engine_setGroundVisible: (a: number, b: number, c: number) => void;
     readonly engine_setIconAtlas: (a: number, b: number, c: number) => [number, number];
@@ -812,40 +986,57 @@ export interface InitOutput {
     readonly engine_setLineDash: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setLines: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number];
     readonly engine_setMaxPitch: (a: number, b: number) => void;
+    readonly engine_setModelGlow: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly engine_setModelHighlight: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly engine_setModelInstances: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly engine_setNetworkCosts: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setNetworkRamp: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setNetworkScales: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setNetworkStyle: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setNetworkValues: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setPanorama: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    readonly engine_setPanoramaImage: (a: number, b: number, c: any) => void;
     readonly engine_setPivot: (a: number, b: number, c: number) => number;
+    readonly engine_setPointCloudStyle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly engine_setRasterStyle: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setRequestHeaders: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly engine_setSky: (a: number, b: number) => void;
-    readonly engine_setSun: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly engine_setSun: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly engine_setSwipe: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly engine_setSymbolLayer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
     readonly engine_setSymbols: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => [number, number];
-    readonly engine_setTerrain: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+    readonly engine_setTerrain: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly engine_setTileLoader: (a: number, b: any) => void;
+    readonly engine_setTiles3dDrape: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly engine_setTiles3dFacades: (a: number, b: number, c: number) => void;
+    readonly engine_setTiles3dFeatureColors: (a: number, b: number, c: any) => void;
+    readonly engine_setTiles3dStyle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly engine_setVectorSublayers: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number) => void;
     readonly engine_setVectorTile: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number, h1: number) => [number, number];
     readonly engine_setVectorTileMesh: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number, h1: number, i1: number, j1: number) => [number, number];
     readonly engine_setVectorTilePoints: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
-    readonly engine_setViewshed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    readonly engine_setViewshed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
     readonly engine_setZoomRange: (a: number, b: number, c: number) => void;
     readonly engine_stats: (a: number) => any;
     readonly engine_stepFlow: (a: number, b: number, c: number) => number;
     readonly engine_surface: (a: number, b: number, c: number) => any;
     readonly engine_surfaceAt: (a: number, b: number, c: number) => any;
+    readonly engine_textureFormats: (a: number) => any;
+    readonly engine_tiles3dFeature: (a: number, b: number, c: number) => any;
+    readonly engine_tiles3dStats: (a: number, b: number) => any;
     readonly engine_updateGlyphAtlas: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly engine_updateGlyphPage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly engine_updateGroundTexture: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number];
     readonly engine_updateIconAtlas: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
-    readonly engine_uploadVectorTile: (a: number, b: number, c: number) => number;
     readonly engine_vectorTilesInView: (a: number, b: number, c: number, d: number) => [number, number];
     readonly engine_wantedTiles: (a: number, b: number) => [number, number];
     readonly engine_zoomAt: (a: number, b: number, c: number, d: number) => void;
-    readonly wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___js_sys_b1e1c29ba6b0e6b3___Function_fn_wasm_bindgen_2e566c63402fe7fa___JsValue_____wasm_bindgen_2e566c63402fe7fa___sys__Undefined___js_sys_b1e1c29ba6b0e6b3___Function_fn_wasm_bindgen_2e566c63402fe7fa___JsValue_____wasm_bindgen_2e566c63402fe7fa___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
-    readonly wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___wasm_bindgen_2e566c63402fe7fa___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_2e566c63402fe7fa___JsError___true_: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___js_sys_5e75a17f0680aa0e___Function_fn_wasm_bindgen_4346cdda5a9d72ac___JsValue_____wasm_bindgen_4346cdda5a9d72ac___sys__Undefined___js_sys_5e75a17f0680aa0e___Function_fn_wasm_bindgen_4346cdda5a9d72ac___JsValue_____wasm_bindgen_4346cdda5a9d72ac___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true_: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___sys__JsNullable_wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true_: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___sys__JsNullable_wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true__130: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___sys__JsNullable_wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true__131: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuDeviceLostInfo__GpuDeviceLostInfo______true_: (a: number, b: number, c: any) => void;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;