isard 1.16.0 → 2.1.0

package/dist/wasm/{isard.d.ts → isard_webgpu.d.ts}

@@ -1,131 +1,21 @@
 /* tslint:disable */
 /* eslint-disable */
 
-/**
- * A primitive of a tile decoded by `decodeTile`: vertices x, y, z, u, v around the anchor; the image still encoded,
- * the same array for the primitives sharing it
- */
-export interface EncodedPrimitive {
-    vertices: Float32Array<ArrayBuffer>;
-    indices: Uint32Array<ArrayBuffer>;
-    image?: Uint8Array<ArrayBuffer>;
-    mime?: string;
-    /** Base color factor of its material (RGBA 0-1), when not white */
-    color?: Float32Array<ArrayBuffer>;
-    /** The feature of each vertex (`EncodedTile.properties` index them), when the tile has features */
-    features?: Float32Array<ArrayBuffer>;
-}
-
-/** A tile decoded by `decodeTile` */
-export interface EncodedTile {
-    /** ECEF origin of the vertices (metres) */
-    anchor: Float64Array<ArrayBuffer>;
-    primitives: EncodedPrimitive[];
-    /** Its points (`.pnts`, glTF points), 20 bytes a vertex: x, y, z (f32) around the anchor, RGB, a normal */
-    points: Uint8Array<ArrayBuffer>[];
-    /** The properties of its features, one object per feature */
-    properties?: Record<string, unknown>[];
-}
-
-/** A texture transcoded for the GPU (KTX2 / Basis Universal): a WebGL internal format and its mip levels */
-export interface CompressedTexture {
-    /** WebGL internal format (compressed, or RGBA8 when the GPU supports none of the targets) */
-    format: number;
-    levels: { width: number; height: number; data: Uint8Array<ArrayBuffer> }[];
-}
-
-/**
- * A primitive ready for the GPU: its image decoded (bitmap) or transcoded (texture); primitives given the same bitmap
- * or texture object share one GPU texture
- */
-export interface DecodedPrimitive {
-    vertices: Float32Array<ArrayBuffer>;
-    indices: Uint32Array<ArrayBuffer>;
-    bitmap: ImageBitmap | null;
-    texture?: CompressedTexture;
-    /** Base color factor of its material (RGBA 0-1), when not white */
-    color?: Float32Array<ArrayBuffer>;
-    /** The feature of each vertex, when the tile has features */
-    features?: Float32Array<ArrayBuffer>;
-}
-
-/**
- * A Draco-compressed primitive of a tile (`KHR_draco_mesh_compression`), or its points
- * (`3DTILES_draco_point_compression`), to decode with the Draco module
- */
-export interface DracoRequest {
-    mesh: number;
-    primitive: number;
-    data: Uint8Array<ArrayBuffer>;
-    /** Draco attribute ids */
-    position: number;
-    uv?: number;
-    color?: number;
-    normal?: number;
-    /** A point cloud: no triangles */
-    points?: boolean;
-}
-
-/** The Draco module's output for a request: positions, uv, colors and normals as stored, triangles (not for points) */
-export interface DracoGeometry {
-    mesh: number;
-    primitive: number;
-    positions: Float32Array;
-    uvs?: Float32Array;
-    indices?: Uint32Array;
-    colors?: Float32Array;
-    normals?: Float32Array;
-}
-
-/** Compressed texture formats supported by the GPU */
-export interface TextureFormats {
-    astc: boolean;
-    bptc: boolean;
-    etc: boolean;
-    s3tc: boolean;
-}
-
-/** A tile ready for the GPU, as the decoding workers deliver it */
-export interface DecodedTile {
-    anchor: Float64Array<ArrayBuffer>;
-    primitives: DecodedPrimitive[];
-    /** Its points' vertices (`EncodedTile.points`) */
-    points?: Uint8Array<ArrayBuffer>[];
-    /** The properties of its features (`EncodedTile.properties`) */
-    properties?: Record<string, unknown>[];
+/** 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;
 }
 
-/** What the engine expects from a pool of decoding workers (`Engine.setTileLoader`) */
-export interface TileLoaderLike {
-    /**
-     * `reload`: bypass the HTTP cache (the tile failed before: the cache may hold the error); `priority`: the Fetch
-     * Priority for the download (the first tiles in view of a frame are urgent)
-     */
-    load(
-    id: number,
-    url: string,
-    transform: Float64Array,
-    yUp: boolean,
-    reload: boolean,
-    priority?: 'high' | 'low',
-    ): Promise<DecodedTile>;
-    abort(id: number): void;
-    /**
-     * The points of a COPC node: its LAZ chunk (`size` bytes at `offset` of the file at `url`, a range request), the
-     * data of the file's LAZ VLR, its layout (format, record length, scale, offset), the grid positioning its points
-     * and its point count; resolves with its vertices (20 bytes each, see `EncodedTile.points`)
-     */
-    loadPoints?(
-    id: number,
-    url: string,
-    offset: number,
-    size: number,
-    laz: Uint8Array,
-    layout: Float64Array,
-    grid: Float64Array,
-    count: number,
-    priority?: 'high' | 'low',
-    ): Promise<Uint8Array<ArrayBuffer>>;
+/** 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];
 }
 
 
@@ -140,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;
@@ -253,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;
     /**
@@ -303,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;
     /**
@@ -313,74 +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`
-     * (`INSTANCE_NUMBERS` numbers each: longitude, latitude, altitude, heading, pitch, roll in degrees, scale);
-     * `ground`: altitudes above the relief, else above the ellipsoid
-     *
-     * # Errors
-     *
-     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
-     * info log). A model that fails to load or decode does not throw: the layer stays empty
+     * (`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
-     *
-     * # Errors
-     *
-     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
-     * info log). The file itself is read later: a bad file, or a `resolve` that throws, leaves the layer 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;
     /**
@@ -388,8 +256,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)
+     * Never in practice: its tables start empty
      */
     addSymbols(): number;
     /**
@@ -397,21 +264,22 @@ export class Engine {
      * 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.
      *
-     * # Errors
-     *
-     * Throws (to JavaScript) when one of the layer's programs fails to compile or link (the error carries
-     * its info log). The tileset itself is read later: a bad one leaves the layer empty, it does not throw
+     * 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
@@ -438,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
      */
@@ -454,23 +331,34 @@ 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;
+    /**
+     * The GPU memory of the layers the budget counts (`setMemoryBudget`): two numbers a layer, its id and its bytes
+     * (a raster's pool, the tiles of a 3D Tiles layer or a point cloud), the relief last with id 0
+     */
+    memory(): Float64Array;
     /**
      * Moves a layer to a drawing position (0 = bottom)
      */
@@ -479,35 +367,18 @@ 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
-     */
-    pick(x: number, y: number, radius?: number | null, only?: Uint32Array | null): PickHit | undefined;
     /**
      * 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 `pick` or `pollPick` (its index there), read back from the GPU; undefined
-     * once it is no longer drawn
+     * 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;
     /**
@@ -515,10 +386,10 @@ export class Engine {
      */
     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
      */
@@ -537,7 +408,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;
     /**
@@ -545,16 +416,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
      */
@@ -576,8 +448,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;
     /**
@@ -593,13 +464,17 @@ export class Engine {
      * New points for a circle layer (same features)
      */
     setCircles(id: number, points: Float64Array, feature: Uint32Array): void;
+    /**
+     * A raster layer draped on the roofs, or all the faces, of a 3D Tiles layer, an extrusion layer, a vector tiles
+     * layer's buildings or a model layer (`raster` undefined: none)
+     */
+    setDrape(id: number, raster: number | null | undefined, all_faces: boolean, opacity: number): void;
     /**
      * Anchors of batch `key` on the linked network: per feature, node A, node B, cost from A, cost from B
      *
      * # 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;
     /**
@@ -608,8 +483,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;
     /**
@@ -691,7 +565,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;
     /**
@@ -701,8 +575,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;
     /**
@@ -710,23 +584,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;
     /**
@@ -739,8 +612,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;
     /**
@@ -757,14 +629,20 @@ 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;
+    /**
+     * The GPU memory the layers' tiles (3D Tiles, point clouds) and the rasters' pools may hold all together (bytes):
+     * past it the tiles drawn least recently are unloaded, whichever their layer. A raster's pool takes its memory
+     * when it is made: one made later takes the budget as it is then
+     */
+    setMemoryBudget(bytes: 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
@@ -802,11 +680,8 @@ export class Engine {
      */
     setNetworkValues(id: number, values: Float32Array): void;
     /**
-     * The image of camera `index` of the panorama (the images sharing the size of the first)
-     *
-     * # Errors
-     *
-     * Throws (to JavaScript) when WebGL refuses the upload of `image` into the panorama's texture
+     * 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;
     /**
@@ -818,14 +693,12 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when `rotation` holds fewer than 9 numbers, or when a WebGL object cannot be created or a
-     * shader fails to compile (the error carries its info log)
+     * 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;
     /**
@@ -850,16 +723,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;
     /**
@@ -875,23 +743,18 @@ 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;
     /**
@@ -899,11 +762,7 @@ export class Engine {
      * `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: 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;
+    setTileLoader(loader: import('./isard_tiles3d.js').TileLoaderLike | null): void;
     /**
      * Whether the walls of a 3D Tiles layer's untextured meshes show their windows: glass by day, some lit at night
      */
@@ -919,30 +778,29 @@ export class Engine {
     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;
     /**
@@ -955,19 +813,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;
     /**
@@ -976,11 +831,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;
     /**
@@ -998,20 +848,21 @@ 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 (their WebGL extensions get enabled), for the KTX2 transcoding
+     * Compressed texture formats of the GPU, for the KTX2 transcoding
      */
-    textureFormats(): TextureFormats;
+    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
@@ -1035,24 +886,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;
     /**
@@ -1066,62 +912,49 @@ export class Engine {
     zoomAt(delta: number, x: number, y: number): void;
 }
 
-/**
- * Decodes a `.b3dm` / `.pnts` / `.glb` tile: `{ anchor: Float64Array(3), primitives: [{ vertices: Float32Array (x,
- * y, z, u, v per vertex, relative to the anchor), indices: Uint32Array, image?: Uint8Array, mime?: string, color?:
- * Float32Array (the material's base color, when not white) }], points: [Uint8Array] (the points' vertices) }`.
- * `transform`: the tile's world transform (16 numbers, column-major).
- * `draco`: the decoded geometries of its Draco primitives (`dracoRequests`), if any.
- */
-export function decodeTile(bytes: Uint8Array, transform: Float64Array, y_up: boolean, draco: DracoGeometry[] | undefined): EncodedTile;
-
-/**
- * The Draco-compressed primitives of a tile, to decode before `decodeTile`
- */
-export function dracoRequests(bytes: Uint8Array): DracoRequest[];
-
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_engine_free: (a: number, b: number) => void;
-    readonly decodeTile: (a: number, b: number, c: number, d: number, e: number, f: any) => [number, number, number];
-    readonly dracoRequests: (a: number, b: number) => [number, number, number];
     readonly engine_addCircles: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
     readonly engine_addCustomLayer: (a: number, b: any, c: number) => number;
     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, 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_addPointCloud: (a: number, b: number, c: number, d: any) => [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, 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_memory: (a: number) => [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_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) => 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;
@@ -1138,6 +971,7 @@ export interface InitOutput {
     readonly engine_setCamera: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly engine_setCircleAlignment: (a: number, b: number, c: number) => void;
     readonly engine_setCircles: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly engine_setDrape: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly engine_setExtrusionAnchors: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly engine_setExtrusionBatch: (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) => [number, number];
     readonly engine_setFacades: (a: number, b: number, c: number) => void;
@@ -1158,7 +992,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];
@@ -1166,6 +1000,7 @@ 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_setMemoryBudget: (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;
@@ -1175,19 +1010,18 @@ export interface InitOutput {
     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) => [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;
@@ -1195,7 +1029,7 @@ export interface InitOutput {
     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;
@@ -1208,12 +1042,15 @@ export interface InitOutput {
     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_2e566c63402fe7fa___convert__closures_____invoke___wasm_bindgen_2e566c63402fe7fa___sys__JsNullable_wgpu_79b597b3111bcbe9___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_2e566c63402fe7fa___JsError___true_: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___wasm_bindgen_2e566c63402fe7fa___sys__JsNullable_wgpu_79b597b3111bcbe9___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_2e566c63402fe7fa___JsError___true__132: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___wasm_bindgen_2e566c63402fe7fa___sys__JsNullable_wgpu_79b597b3111bcbe9___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_2e566c63402fe7fa___JsError___true__133: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___wgpu_79b597b3111bcbe9___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;