isard 1.0.0 → 1.2.0

package/dist/wasm/isard_core.d.ts

@@ -62,10 +62,19 @@ export interface PickResult {
 
 
 
+/**
+ * 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)
+ */
 export class Engine {
     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`
      */
     addCircles(points: Float64Array, feature: Uint32Array, feature_count: number): number;
     /**
@@ -76,23 +85,42 @@ export class Engine {
     addCustomLayer(render: () => 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)
      */
     addExtrusions(): number;
     /**
      * Fill layer of `feature_count` features: polygons given by their points (Mercator [0, 1], interleaved), the first
      * point of each ring (`ring_start`, one more entry than rings), the first ring of each polygon (`polygon_start`,
      * one more entry than polygons; the first ring is the outer one, the others holes) and the feature of each polygon
+     *
+     * # 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`
      */
     addFills(points: Float64Array, ring_start: Uint32Array, polygon_start: Uint32Array, feature: Uint32Array, feature_count: 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`)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when `code` does not compile or link, with the shader's info log
      */
     addGround(code: 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`
      */
     addLines(points: Float64Array, start: Uint32Array, feature: Uint32Array, feature_count: number): number;
     /**
@@ -101,16 +129,31 @@ export class Engine {
      * 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)
      */
     addNetwork(mercator: Float64Array, edges: Uint32Array, line_start: Uint32Array | null | undefined, line_points: Float64Array | null | undefined, costs: Float32Array | null | undefined, style: Float32Array): 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)
+     *
+     * # 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): number;
     /**
      * An empty symbol layer
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
+     * info log)
      */
     addSymbols(): number;
     /**
@@ -118,7 +161,13 @@ export class Engine {
      * border cast on the ground, or on the far plane where it passes the horizon
      */
     bounds(): Float64Array;
+    /**
+     * The camera as set or moved: center (degrees), zoom, pitch and bearing (degrees)
+     */
     camera(): Camera;
+    /**
+     * Stops loading the tiles of the flight's destination (`preload`)
+     */
     clearPreload(): void;
     /**
      * Removes the viewshed
@@ -166,6 +215,11 @@ export class Engine {
     networkStats(id: number): NetworkStats | undefined;
     /**
      * `redraw` is called when the engine needs a new frame (a tile arrived)
+     *
+     * # 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);
     /**
@@ -194,8 +248,18 @@ export class Engine {
      * Screen point (CSS pixels) of a ground position, or `height` metres above it, undefined behind the camera
      */
     project(lon: number, lat: number, height?: number | null): [x: number, y: number] | undefined;
+    /**
+     * Removes batch `key` of an extrusion layer (nothing if there is none)
+     */
     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)
+     */
     removeLayer(id: 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`)
+     */
     render(): boolean;
     /**
      * Asks what is under a screen point without waiting for the GPU (as `pick`, with the position there): the
@@ -216,6 +280,9 @@ export class Engine {
      * then the sky-horizon, horizon-fog and fog-ground blends; `undefined` for none (the background color shows)
      */
     setAtmosphere(settings?: Float32Array | null): void;
+    /**
+     * Color the canvas is cleared to (RGB 0-1), where neither ground nor sky is drawn
+     */
     setBackground(r: number, g: number, b: number): void;
     /**
      * The body the map is drawn on: its equatorial radius (metres) and flattening (0 for a sphere), the halo of its
@@ -225,6 +292,10 @@ export class Engine {
      * relief, whose shaders may take its size (`ISARD_CIRCUMFERENCE` of the ground layers)
      */
     setBody(radius: number, flattening: number, halo: Float32Array | null | undefined, lowest: number, highest: number): void;
+    /**
+     * Sets the camera (degrees, the conventions of `MapLibre`): leaves a street-level view, and the camera keeps this
+     * center as the relief comes in
+     */
     setCamera(lon: number, lat: number, zoom: number, pitch: number, bearing: number): void;
     /**
      * Circles lying on the ground (true) or facing the screen
@@ -236,11 +307,21 @@ export class Engine {
     setCircles(id: number, points: Float64Array, feature: Uint32Array): 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
      */
     setExtrusionAnchors(id: number, key: number, anchors: Float32Array): void;
     /**
      * Adds or replaces batch `key` of an extrusion layer: polygons as for `addFills`, `feature_count` features (the
      * feature style gives each its height and base height as its two sizes, metres)
+     *
+     * # 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`
      */
     setExtrusionBatch(id: number, key: number, points: Float64Array, ring_start: Uint32Array, polygon_start: Uint32Array, feature: Uint32Array, feature_count: number): void;
     /**
@@ -288,29 +369,59 @@ export class Engine {
     /**
      * The glyph atlas shared by the symbol layers, one page: `width` × `height` bytes of signed distances
      * (allocated again, filled with `data` if given)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) as `setGlyphPages` does: a size that is not positive, or the texture not created
      */
     setGlyphAtlas(width: number, height: number, data?: Uint8Array | null): void;
     /**
      * The glyph atlas shared by the symbol layers, `pages` pages of `width` × `height` bytes of signed distances,
      * allocated again and empty (`updateGlyphPage` fills them). A glyph on page `p` at row `v` has the atlas
      * coordinate `v + p × height`
+     *
+     * # 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
      */
     setGlyphPages(width: number, height: number, pages: number): void;
+    /**
+     * Moves the Mercator box (0-1) a ground layer shows in
+     */
     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
+     *
+     * # 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
      */
     setGroundTexture(id: number, name: string, format: string, width: number, height: number, depth: number, linear: boolean, data?: Uint8Array | null): void;
     /**
      * A uniform of a ground layer's code, as numbers
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the shader has no uniform `name` (one its code does not use is removed
+     * by the compiler)
      */
     setGroundUniform(id: number, name: string, values: Float64Array): void;
+    /**
+     * Shows or hides a ground layer (kept, with its uniforms and textures)
+     */
     setGroundVisible(id: number, visible: boolean): void;
     /**
      * The icon atlas shared by the symbol layers: `width` × `height` RGBA texels, premultiplied, allocated again
      * and empty (`updateIconAtlas` fills it)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when `width` or `height` is not positive (or their product overflows), or the
+     * atlas texture cannot be created
      */
     setIconAtlas(width: number, height: number): void;
     /**
@@ -324,6 +435,11 @@ export class Engine {
     setLineDash(id: number, dash: number, gap: number): void;
     /**
      * New lines for a line layer (same arguments as `addLines`, the same features)
+     *
+     * # 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
      */
     setLines(id: number, points: Float64Array, start: Uint32Array, feature: Uint32Array): void;
     /**
@@ -352,6 +468,9 @@ export class Engine {
      * One value per node; negative = unreached
      */
     setNetworkValues(id: number, values: Float32Array): void;
+    /**
+     * Opacity and saturation (0-1) of a raster layer; nothing for another id
+     */
     setRasterStyle(id: number, opacity: number, saturation: number): void;
     /**
      * The headers added to the engine's requests by URL prefix (`setRequestHeaders`, the same for every map of the
@@ -376,6 +495,11 @@ export class Engine {
      * Labels of a symbol layer, shaped by the page: anchors (Mercator, interleaved), their texts' boxes (min x, min y,
      * max x, max y, CSS pixels from the anchor), styles (36 floats each, see `LABEL_FLOATS`) and glyph and icon quads
      * (11 floats each, see `QUAD_FLOATS`)
+     *
+     * # 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
      */
     setSymbols(id: number, anchors: Float64Array, boxes: Float32Array, styles: Float32Array, quads: Float32Array): void;
     /**
@@ -387,6 +511,10 @@ export class Engine {
      * 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
      */
     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;
     /**
@@ -395,8 +523,16 @@ 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;
+    /**
+     * Lowest and highest zoom levels the camera accepts
+     */
     setZoomRange(min: number, max: number): void;
     /**
      * Tile counters of the raster layers, for diagnostics
@@ -424,6 +560,11 @@ export class Engine {
     updateGlyphPage(page: number, x: number, y: number, width: number, height: number, data: Uint8Array): void;
     /**
      * Replaces a region of a ground layer's texture (one layer of a 2D array)
+     *
+     * # 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
      */
     updateGroundTexture(id: number, name: string, x: number, y: number, layer: number, width: number, height: number, data: Uint8Array): void;
     /**
@@ -435,6 +576,9 @@ export class Engine {
      * the eye first: the level each area of the ground is drawn at, for the labels of a vector style to follow it
      */
     wantedTiles(id: number): Uint32Array;
+    /**
+     * Zooms by `delta` levels around a screen point (CSS pixels), which keeps the same ground point under it
+     */
     zoomAt(delta: number, x: number, y: number): void;
 }
 

package/dist/wasm/isard_core.js

@@ -1,5 +1,9 @@
 /* @ts-self-types="./isard_core.d.ts" */
 
+/**
+ * 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)
+ */
 export class Engine {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -13,6 +17,11 @@ export class Engine {
     }
     /**
      * 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`
      * @param {Float64Array} points
      * @param {Uint32Array} feature
      * @param {number} feature_count
@@ -43,6 +52,11 @@ export class Engine {
     }
     /**
      * 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)
      * @returns {number}
      */
     addExtrusions() {
@@ -56,6 +70,11 @@ export class Engine {
      * Fill layer of `feature_count` features: polygons given by their points (Mercator [0, 1], interleaved), the first
      * point of each ring (`ring_start`, one more entry than rings), the first ring of each polygon (`polygon_start`,
      * one more entry than polygons; the first ring is the outer one, the others holes) and the feature of each polygon
+     *
+     * # 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`
      * @param {Float64Array} points
      * @param {Uint32Array} ring_start
      * @param {Uint32Array} polygon_start
@@ -82,6 +101,10 @@ export class Engine {
      * 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`)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when `code` does not compile or link, with the shader's info log
      * @param {string} code
      * @param {number} anchor_x
      * @param {number} anchor_y
@@ -103,6 +126,11 @@ export class Engine {
     /**
      * 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`
      * @param {Float64Array} points
      * @param {Uint32Array} start
      * @param {Uint32Array} feature
@@ -128,6 +156,12 @@ export class Engine {
      * 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)
      * @param {Float64Array} mercator
      * @param {Uint32Array} edges
      * @param {Uint32Array | null | undefined} line_start
@@ -159,6 +193,10 @@ export class Engine {
      * 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)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the texture holding the layer's tiles cannot be created
      * @param {string} url
      * @param {number} min_z
      * @param {number} max_z
@@ -179,6 +217,11 @@ export class Engine {
     }
     /**
      * An empty symbol layer
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
+     * info log)
      * @returns {number}
      */
     addSymbols() {
@@ -200,12 +243,16 @@ export class Engine {
         return v1;
     }
     /**
+     * The camera as set or moved: center (degrees), zoom, pitch and bearing (degrees)
      * @returns {Camera}
      */
     camera() {
         const ret = wasm.engine_camera(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Stops loading the tiles of the flight's destination (`preload`)
+     */
     clearPreload() {
         wasm.engine_clearPreload(this.__wbg_ptr);
     }
@@ -310,6 +357,11 @@ export class Engine {
     }
     /**
      * `redraw` is called when the engine needs a new frame (a tile arrived)
+     *
+     * # 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
      * @param {HTMLCanvasElement} canvas
      * @param {() => void} redraw
      */
@@ -383,6 +435,7 @@ export class Engine {
         return ret;
     }
     /**
+     * Removes batch `key` of an extrusion layer (nothing if there is none)
      * @param {number} id
      * @param {number} key
      */
@@ -390,12 +443,15 @@ export class Engine {
         wasm.engine_removeExtrusionBatch(this.__wbg_ptr, id, key);
     }
     /**
+     * Removes a layer and frees its GPU objects; the other layers forget it (a layer that referred to it)
      * @param {number} id
      */
     removeLayer(id) {
         wasm.engine_removeLayer(this.__wbg_ptr, id);
     }
     /**
+     * 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`)
      * @returns {boolean}
      */
     render() {
@@ -446,6 +502,7 @@ export class Engine {
         wasm.engine_setAtmosphere(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * Color the canvas is cleared to (RGB 0-1), where neither ground nor sky is drawn
      * @param {number} r
      * @param {number} g
      * @param {number} b
@@ -471,6 +528,8 @@ export class Engine {
         wasm.engine_setBody(this.__wbg_ptr, radius, flattening, ptr0, len0, lowest, highest);
     }
     /**
+     * Sets the camera (degrees, the conventions of `MapLibre`): leaves a street-level view, and the camera keeps this
+     * center as the relief comes in
      * @param {number} lon
      * @param {number} lat
      * @param {number} zoom
@@ -503,6 +562,11 @@ export class Engine {
     }
     /**
      * 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
      * @param {number} id
      * @param {number} key
      * @param {Float32Array} anchors
@@ -518,6 +582,11 @@ export class Engine {
     /**
      * Adds or replaces batch `key` of an extrusion layer: polygons as for `addFills`, `feature_count` features (the
      * feature style gives each its height and base height as its two sizes, metres)
+     *
+     * # 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`
      * @param {number} id
      * @param {number} key
      * @param {Float64Array} points
@@ -654,6 +723,10 @@ export class Engine {
     /**
      * The glyph atlas shared by the symbol layers, one page: `width` × `height` bytes of signed distances
      * (allocated again, filled with `data` if given)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) as `setGlyphPages` does: a size that is not positive, or the texture not created
      * @param {number} width
      * @param {number} height
      * @param {Uint8Array | null} [data]
@@ -670,6 +743,11 @@ export class Engine {
      * The glyph atlas shared by the symbol layers, `pages` pages of `width` × `height` bytes of signed distances,
      * allocated again and empty (`updateGlyphPage` fills them). A glyph on page `p` at row `v` has the atlas
      * coordinate `v + p × height`
+     *
+     * # 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
      * @param {number} width
      * @param {number} height
      * @param {number} pages
@@ -681,6 +759,7 @@ export class Engine {
         }
     }
     /**
+     * Moves the Mercator box (0-1) a ground layer shows in
      * @param {number} id
      * @param {number} min_x
      * @param {number} min_y
@@ -694,6 +773,11 @@ export class Engine {
      * 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
+     *
+     * # 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
      * @param {number} id
      * @param {string} name
      * @param {string} format
@@ -717,6 +801,11 @@ export class Engine {
     }
     /**
      * A uniform of a ground layer's code, as numbers
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the shader has no uniform `name` (one its code does not use is removed
+     * by the compiler)
      * @param {number} id
      * @param {string} name
      * @param {Float64Array} values
@@ -732,6 +821,7 @@ export class Engine {
         }
     }
     /**
+     * Shows or hides a ground layer (kept, with its uniforms and textures)
      * @param {number} id
      * @param {boolean} visible
      */
@@ -741,6 +831,11 @@ export class Engine {
     /**
      * The icon atlas shared by the symbol layers: `width` × `height` RGBA texels, premultiplied, allocated again
      * and empty (`updateIconAtlas` fills it)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when `width` or `height` is not positive (or their product overflows), or the
+     * atlas texture cannot be created
      * @param {number} width
      * @param {number} height
      */
@@ -769,6 +864,11 @@ export class Engine {
     }
     /**
      * New lines for a line layer (same arguments as `addLines`, the same features)
+     *
+     * # 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
      * @param {number} id
      * @param {Float64Array} points
      * @param {Uint32Array} start
@@ -846,6 +946,7 @@ export class Engine {
         wasm.engine_setNetworkValues(this.__wbg_ptr, id, ptr0, len0);
     }
     /**
+     * Opacity and saturation (0-1) of a raster layer; nothing for another id
      * @param {number} id
      * @param {number} opacity
      * @param {number} saturation
@@ -909,6 +1010,11 @@ export class Engine {
      * Labels of a symbol layer, shaped by the page: anchors (Mercator, interleaved), their texts' boxes (min x, min y,
      * max x, max y, CSS pixels from the anchor), styles (36 floats each, see `LABEL_FLOATS`) and glyph and icon quads
      * (11 floats each, see `QUAD_FLOATS`)
+     *
+     * # 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
      * @param {number} id
      * @param {Float64Array} anchors
      * @param {Float32Array} boxes
@@ -938,6 +1044,10 @@ export class Engine {
      * 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
      * @param {string | null | undefined} url
      * @param {number} exaggeration
      * @param {number | null | undefined} max_z
@@ -958,6 +1068,11 @@ 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)
      * @param {Float64Array} observers
      * @param {Float32Array} visible
      * @param {Float32Array} hidden
@@ -979,6 +1094,7 @@ export class Engine {
         }
     }
     /**
+     * Lowest and highest zoom levels the camera accepts
      * @param {number} min
      * @param {number} max
      */
@@ -1046,6 +1162,11 @@ export class Engine {
     }
     /**
      * Replaces a region of a ground layer's texture (one layer of a 2D array)
+     *
+     * # 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
      * @param {number} id
      * @param {string} name
      * @param {number} x
@@ -1091,6 +1212,7 @@ export class Engine {
         return v1;
     }
     /**
+     * Zooms by `delta` levels around a screen point (CSS pixels), which keeps the same ground point under it
      * @param {number} delta
      * @param {number} x
      * @param {number} y