isard 1.4.0 → 1.6.0

package/dist/wasm/isard.js

@@ -574,6 +574,14 @@ export class Engine {
         const ret = wasm.engine_project(this.__wbg_ptr, lon, lat, !isLikeNone(height), isLikeNone(height) ? 0 : height);
         return ret;
     }
+    /**
+     * A flow layer's second field becomes its field (the model's next hour reached): only the hour after it is then
+     * sent (`setFlowNext`)
+     * @param {number} id
+     */
+    promoteFlowNext(id) {
+        wasm.engine_promoteFlowNext(this.__wbg_ptr, id);
+    }
     /**
      * Removes batch `key` of an extrusion layer (nothing if there is none)
      * @param {number} id
@@ -729,7 +737,7 @@ 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)
+     * feature style gives each its height and base height as its two sizes, metres), each polygon's roof (`Roofs`)
      *
      * # Errors
      *
@@ -742,8 +750,11 @@ export class Engine {
      * @param {Uint32Array} polygon_start
      * @param {Uint32Array} feature
      * @param {number} feature_count
+     * @param {Uint8Array} roofs
+     * @param {Float32Array} roof_heights
+     * @param {number} metres
      */
-    setExtrusionBatch(id, key, points, ring_start, polygon_start, feature, feature_count) {
+    setExtrusionBatch(id, key, points, ring_start, polygon_start, feature, feature_count, roofs, roof_heights, metres) {
         const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray32ToWasm0(ring_start, wasm.__wbindgen_malloc);
@@ -752,11 +763,23 @@ export class Engine {
         const len2 = WASM_VECTOR_LEN;
         const ptr3 = passArray32ToWasm0(feature, wasm.__wbindgen_malloc);
         const len3 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_setExtrusionBatch(this.__wbg_ptr, id, key, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, feature_count);
+        const ptr4 = passArray8ToWasm0(roofs, wasm.__wbindgen_malloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passArrayF32ToWasm0(roof_heights, wasm.__wbindgen_malloc);
+        const len5 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_setExtrusionBatch(this.__wbg_ptr, id, key, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, feature_count, ptr4, len4, ptr5, len5, metres);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Whether the buildings of an extrusion layer, or of a vector tiles layer, show their windows on their walls
+     * @param {number} id
+     * @param {boolean} on
+     */
+    setFacades(id, on) {
+        wasm.engine_setFacades(this.__wbg_ptr, id, on);
+    }
     /**
      * Layer-wide style of a feature layer: opacity as zoom stops (four zooms then four values), the zoom range it
      * shows in (`min_zoom` included, `max_zoom` excluded), whether it shows at all
@@ -882,8 +905,8 @@ export class Engine {
         wasm.engine_setFlowField(this.__wbg_ptr, id, width, height, ptr0, len0, ptr1, len1, ptr2, len2);
     }
     /**
-     * The field a flow layer's goes towards, on its grid (the model's next hour: east and north components, row after
-     * row; empty: none), mixed in by `setFlowBlend`
+     * A flow layer's second field, on its grid (the model's next hour, or the flow of a wind towards the north: east
+     * and north components, row after row; empty: none), mixed in by `setFlowBlend` or `setFlowWeights`
      * @param {number} id
      * @param {Float32Array} u
      * @param {Float32Array} v
@@ -915,6 +938,16 @@ export class Engine {
         const len1 = WASM_VECTOR_LEN;
         wasm.engine_setFlowStyle(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, width, opacity, height, speed, density);
     }
+    /**
+     * A flow layer's velocity as `a` times its field plus `b` times its second one (a wind of `a` m/s towards the east
+     * and `b` towards the north, from the flows of 1 m/s each way): nothing sent again but two numbers
+     * @param {number} id
+     * @param {number} a
+     * @param {number} b
+     */
+    setFlowWeights(id, a, b) {
+        wasm.engine_setFlowWeights(this.__wbg_ptr, id, a, b);
+    }
     /**
      * Color of the globe under the tiles (polar caps)
      * @param {number} r
@@ -1104,6 +1137,30 @@ export class Engine {
     setMaxPitch(max) {
         wasm.engine_setMaxPitch(this.__wbg_ptr, max);
     }
+    /**
+     * 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
+     * @param {number} id
+     * @param {number} from
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     */
+    setModelGlow(id, from, r, g, b) {
+        wasm.engine_setModelGlow(this.__wbg_ptr, id, from, r, g, b);
+    }
+    /**
+     * Highlights the feature `feature` of a model layer's model (an IFC model's element) in `r, g, b`; `feature` not a
+     * number: none
+     * @param {number} id
+     * @param {number} feature
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     */
+    setModelHighlight(id, feature, r, g, b) {
+        wasm.engine_setModelHighlight(this.__wbg_ptr, id, feature, r, g, b);
+    }
     /**
      * Replaces the instances of a model layer (as for `addModels`) and the reference of their altitudes
      * @param {number} id
@@ -1297,25 +1354,27 @@ export class Engine {
     }
     /**
      * Layer-wide style of a symbol layer: size scale and opacity as zoom stops (four zooms then four values each),
-     * zoom range, visibility
+     * zoom range, visibility, hidden by the buildings
      * @param {number} id
      * @param {Float32Array} size
      * @param {Float32Array} opacity
      * @param {number} min_zoom
      * @param {number} max_zoom
      * @param {boolean} visible
+     * @param {boolean} occluded
      */
-    setSymbolLayer(id, size, opacity, min_zoom, max_zoom, visible) {
+    setSymbolLayer(id, size, opacity, min_zoom, max_zoom, visible, occluded) {
         const ptr0 = passArrayF32ToWasm0(size, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayF32ToWasm0(opacity, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        wasm.engine_setSymbolLayer(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, min_zoom, max_zoom, visible);
+        wasm.engine_setSymbolLayer(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, min_zoom, max_zoom, visible, occluded);
     }
     /**
      * 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`)
+     * max x, max y, CSS pixels from the anchor), styles (37 floats each, see `LABEL_FLOATS`), glyph and icon quads
+     * (11 floats each, see `QUAD_FLOATS`) and the lines their curved texts follow (`paths`: for each label, its number
+     * of points, the index of its anchor among them, then the points, Mercator; 0, 0 and none for the others)
      *
      * # Errors
      *
@@ -1326,8 +1385,9 @@ export class Engine {
      * @param {Float32Array} boxes
      * @param {Float32Array} styles
      * @param {Float32Array} quads
+     * @param {Float64Array} paths
      */
-    setSymbols(id, anchors, boxes, styles, quads) {
+    setSymbols(id, anchors, boxes, styles, quads, paths) {
         const ptr0 = passArrayF64ToWasm0(anchors, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayF32ToWasm0(boxes, wasm.__wbindgen_malloc);
@@ -1336,7 +1396,9 @@ export class Engine {
         const len2 = WASM_VECTOR_LEN;
         const ptr3 = passArrayF32ToWasm0(quads, wasm.__wbindgen_malloc);
         const len3 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_setSymbols(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        const ptr4 = passArrayF64ToWasm0(paths, wasm.__wbindgen_malloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_setSymbols(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -1392,11 +1454,15 @@ export class Engine {
         wasm.engine_setTiles3dStyle(this.__wbg_ptr, id, max_error, opacity, !isLikeNone(point_size), isLikeNone(point_size) ? 0 : point_size, ptr0, len0);
     }
     /**
-     * The style layers of a vector tile layer, in drawing order: per layer, its kind (0 fill, 1 line, 2 extrusion), its zoom range
+     * 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)
+     * 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)
      * @param {number} id
      * @param {Uint8Array} kinds
      * @param {Float64Array} zooms
@@ -1405,8 +1471,11 @@ export class Engine {
      * @param {Float32Array} opacities
      * @param {Uint8Array} caps
      * @param {Uint8Array} lit
+     * @param {Float32Array} joins
+     * @param {Float32Array} translates
+     * @param {Uint8Array} patterned
      */
-    setVectorSublayers(id, kinds, zooms, visible, dashes, opacities, caps, lit) {
+    setVectorSublayers(id, kinds, zooms, visible, dashes, opacities, caps, lit, joins, translates, patterned) {
         const ptr0 = passArray8ToWasm0(kinds, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayF64ToWasm0(zooms, wasm.__wbindgen_malloc);
@@ -1421,7 +1490,13 @@ export class Engine {
         const len5 = WASM_VECTOR_LEN;
         const ptr6 = passArray8ToWasm0(lit, wasm.__wbindgen_malloc);
         const len6 = WASM_VECTOR_LEN;
-        wasm.engine_setVectorSublayers(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6);
+        const ptr7 = passArrayF32ToWasm0(joins, wasm.__wbindgen_malloc);
+        const len7 = WASM_VECTOR_LEN;
+        const ptr8 = passArrayF32ToWasm0(translates, wasm.__wbindgen_malloc);
+        const len8 = WASM_VECTOR_LEN;
+        const ptr9 = passArray8ToWasm0(patterned, wasm.__wbindgen_malloc);
+        const len9 = WASM_VECTOR_LEN;
+        wasm.engine_setVectorSublayers(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9);
     }
     /**
      * Adds or replaces tile `key` of a vector tile layer ready for the GPU, as the basemap workers make it (the
@@ -1493,13 +1568,36 @@ export class Engine {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * The points of tile `key` of a vector tile layer, after the tile itself (`setVectorTile`, `setVectorTileMesh`):
+     * Mercator, interleaved, each with its feature (styled as a circle's: a color, a radius and a stroke width, then the
+     * stroke's color), `start` the first point of each sublayer and the end; the circle sublayers draw theirs
+     * @param {number} id
+     * @param {number} key
+     * @param {Float64Array} points
+     * @param {Uint32Array} feature
+     * @param {Uint32Array} start
+     */
+    setVectorTilePoints(id, key, points, feature, start) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(feature, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(start, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.engine_setVectorTilePoints(this.__wbg_ptr, id, key, ptr0, len0, ptr1, len1, ptr2, len2);
+    }
     /**
      * 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), `feature_count` features, 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
+     * 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
      *
      * # Errors
      *
@@ -1518,8 +1616,13 @@ export class Engine {
      * @param {Uint32Array} line_start
      * @param {number} feature_count
      * @param {Float64Array} tile
+     * @param {Uint8Array} roofs
+     * @param {Float32Array} roof_heights
+     * @param {Float64Array} roof_outlines
+     * @param {Uint32Array} roof_outline_start
+     * @param {number} roof_metres
      */
-    setVectorTile(id, key, points, ring_start, polygon_start, polygon_feature, fill_start, line_points, line_first, line_feature, line_start, feature_count, tile) {
+    setVectorTile(id, key, points, ring_start, polygon_start, polygon_feature, fill_start, line_points, line_first, line_feature, line_start, feature_count, tile, roofs, roof_heights, roof_outlines, roof_outline_start, roof_metres) {
         const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray32ToWasm0(ring_start, wasm.__wbindgen_malloc);
@@ -1540,7 +1643,15 @@ export class Engine {
         const len8 = WASM_VECTOR_LEN;
         const ptr9 = passArrayF64ToWasm0(tile, wasm.__wbindgen_malloc);
         const len9 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_setVectorTile(this.__wbg_ptr, id, key, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, feature_count, ptr9, len9);
+        const ptr10 = passArray8ToWasm0(roofs, wasm.__wbindgen_malloc);
+        const len10 = WASM_VECTOR_LEN;
+        const ptr11 = passArrayF32ToWasm0(roof_heights, wasm.__wbindgen_malloc);
+        const len11 = WASM_VECTOR_LEN;
+        const ptr12 = passArrayF64ToWasm0(roof_outlines, wasm.__wbindgen_malloc);
+        const len12 = WASM_VECTOR_LEN;
+        const ptr13 = passArray32ToWasm0(roof_outline_start, wasm.__wbindgen_malloc);
+        const len13 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_setVectorTile(this.__wbg_ptr, id, key, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, feature_count, ptr9, len9, ptr10, len10, ptr11, len11, ptr12, len12, ptr13, len13, roof_metres);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -1593,12 +1704,15 @@ export class Engine {
         return ret;
     }
     /**
-     * Moves a flow layer's particles by `seconds` of the page's time (one animation frame), in the current view
+     * Moves a flow layer's particles by `seconds` of the page's time (one animation frame), in the current view;
+     * whether they moved (none in view, or no field: the map need not be drawn again)
      * @param {number} id
      * @param {number} seconds
+     * @returns {boolean}
      */
     stepFlow(id, seconds) {
-        wasm.engine_stepFlow(this.__wbg_ptr, id, seconds);
+        const ret = wasm.engine_stepFlow(this.__wbg_ptr, id, seconds);
+        return ret !== 0;
     }
     /**
      * The height above the relief (metres) of the top of what stands at a position (degrees): a roof, a mesh, 0 on
@@ -1719,6 +1833,17 @@ export class Engine {
         const len0 = WASM_VECTOR_LEN;
         wasm.engine_updateIconAtlas(this.__wbg_ptr, x, y, width, height, ptr0, len0);
     }
+    /**
+     * 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
+     * @param {number} id
+     * @param {number} key
+     * @returns {boolean}
+     */
+    uploadVectorTile(id, key) {
+        const ret = wasm.engine_uploadVectorTile(this.__wbg_ptr, id, key);
+        return ret !== 0;
+    }
     /**
      * 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
@@ -1942,6 +2067,12 @@ function __wbg_get_imports() {
         __wbg_bufferData_bad7ce562b6a9eac: function(arg0, arg1, arg2, arg3) {
             arg0.bufferData(arg1 >>> 0, arg2, arg3 >>> 0);
         },
+        __wbg_bufferSubData_22c4c420e0f67cda: function(arg0, arg1, arg2, arg3) {
+            arg0.bufferSubData(arg1 >>> 0, arg2, arg3);
+        },
+        __wbg_bufferSubData_8609cd8a2c013181: function(arg0, arg1, arg2, arg3) {
+            arg0.bufferSubData(arg1 >>> 0, arg2, arg3);
+        },
         __wbg_byteLength_141bda7c7c28aa72: function(arg0) {
             const ret = arg0.byteLength;
             return ret;
@@ -2998,7 +3129,7 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 218, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 225, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___wasm_bindgen_2e566c63402fe7fa___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_2e566c63402fe7fa___JsError___true_);
             return ret;
         },

package/dist/wasm/isard_core.d.ts

@@ -267,6 +267,11 @@ 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;
+    /**
+     * A flow layer's second field becomes its field (the model's next hour reached): only the hour after it is then
+     * sent (`setFlowNext`)
+     */
+    promoteFlowNext(id: number): void;
     /**
      * Removes batch `key` of an extrusion layer (nothing if there is none)
      */
@@ -339,14 +344,18 @@ export class Engine {
     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)
+     * feature style gives each its height and base height as its two sizes, metres), each polygon's roof (`Roofs`)
      *
      * # 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;
+    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;
+    /**
+     * Whether the buildings of an extrusion layer, or of a vector tiles layer, show their windows on their walls
+     */
+    setFacades(id: number, on: boolean): void;
     /**
      * Layer-wide style of a feature layer: opacity as zoom stops (four zooms then four values), the zoom range it
      * shows in (`min_zoom` included, `max_zoom` excluded), whether it shows at all
@@ -393,8 +402,8 @@ export class Engine {
      */
     setFlowField(id: number, width: number, height: number, u: Float32Array, v: Float32Array, bounds: Float64Array): void;
     /**
-     * The field a flow layer's goes towards, on its grid (the model's next hour: east and north components, row after
-     * row; empty: none), mixed in by `setFlowBlend`
+     * A flow layer's second field, on its grid (the model's next hour, or the flow of a wind towards the north: east
+     * and north components, row after row; empty: none), mixed in by `setFlowBlend` or `setFlowWeights`
      */
     setFlowNext(id: number, u: Float32Array, v: Float32Array): void;
     /**
@@ -403,6 +412,11 @@ export class Engine {
      * particles moving for each 100 × 100 CSS pixels of the view (at most the layer's)
      */
     setFlowStyle(id: number, speeds: Float32Array, colors: Float32Array, width: number, opacity: number, height: number, speed: number, density: number): void;
+    /**
+     * A flow layer's velocity as `a` times its field plus `b` times its second one (a wind of `a` m/s towards the east
+     * and `b` towards the north, from the flows of 1 m/s each way): nothing sent again but two numbers
+     */
+    setFlowWeights(id: number, a: number, b: number): void;
     /**
      * Color of the globe under the tiles (polar caps)
      */
@@ -544,20 +558,21 @@ export class Engine {
     setSwipe(x: number, right: boolean, layers: Uint32Array, others: Uint32Array): void;
     /**
      * Layer-wide style of a symbol layer: size scale and opacity as zoom stops (four zooms then four values each),
-     * zoom range, visibility
+     * zoom range, visibility, hidden by the buildings
      */
-    setSymbolLayer(id: number, size: Float32Array, opacity: Float32Array, min_zoom: number, max_zoom: number, visible: boolean): void;
+    setSymbolLayer(id: number, size: Float32Array, opacity: Float32Array, min_zoom: number, max_zoom: number, visible: boolean, occluded: boolean): void;
     /**
      * 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`)
+     * max x, max y, CSS pixels from the anchor), styles (37 floats each, see `LABEL_FLOATS`), glyph and icon quads
+     * (11 floats each, see `QUAD_FLOATS`) and the lines their curved texts follow (`paths`: for each label, its number
+     * of points, the index of its anchor among them, then the points, Mercator; 0, 0 and none for the others)
      *
      * # 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;
+    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
@@ -574,13 +589,17 @@ export class Engine {
      */
     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;
     /**
-     * The style layers of a vector tile layer, in drawing order: per layer, its kind (0 fill, 1 line, 2 extrusion), its zoom range
+     * 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)
+     * 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): void;
+    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
@@ -597,20 +616,30 @@ export class Engine {
      * created, or when its features or lines need a table texture past the GPU's `MAX_TEXTURE_SIZE`
      */
     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_count: number): void;
+    /**
+     * The points of tile `key` of a vector tile layer, after the tile itself (`setVectorTile`, `setVectorTileMesh`):
+     * Mercator, interleaved, each with its feature (styled as a circle's: a color, a radius and a stroke width, then the
+     * stroke's color), `start` the first point of each sublayer and the end; the circle sublayers draw theirs
+     */
+    setVectorTilePoints(id: number, key: number, points: Float64Array, feature: Uint32Array, start: Uint32Array): void;
     /**
      * 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), `feature_count` features, 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
+     * 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
      *
      * # 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`
      */
-    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_count: number, tile: Float64Array): void;
+    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_count: number, tile: Float64Array, roofs: Uint8Array, roof_heights: Float32Array, roof_outlines: Float64Array, roof_outline_start: Uint32Array, roof_metres: number): void;
     /**
      * Shows what can be seen from points, each within its range: `observers` holds 8 numbers per observer
      * (16 at most): longitude, latitude (degrees), metres above the ground, range (metres), then to look one way
@@ -633,9 +662,10 @@ export class Engine {
      */
     stats(): RasterLayerStats[];
     /**
-     * Moves a flow layer's particles by `seconds` of the page's time (one animation frame), in the current view
+     * Moves a flow layer's particles by `seconds` of the page's time (one animation frame), in the current view;
+     * whether they moved (none in view, or no field: the map need not be drawn again)
      */
-    stepFlow(id: number, seconds: number): void;
+    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
@@ -669,6 +699,11 @@ export class Engine {
      * 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
@@ -720,6 +755,7 @@ export interface InitOutput {
     readonly engine_pollPick: (a: 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;
     readonly engine_removeExtrusionBatch: (a: number, b: number, c: number) => void;
     readonly engine_removeLayer: (a: number, b: number) => void;
     readonly engine_removeVectorTile: (a: number, b: number, c: number) => void;
@@ -734,7 +770,8 @@ export interface InitOutput {
     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_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) => [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;
     readonly engine_setFeatureLayer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly engine_setFeatureMask: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly engine_setFeatureRamp: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
@@ -746,6 +783,7 @@ export interface InitOutput {
     readonly engine_setFlowField: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
     readonly engine_setFlowNext: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly engine_setFlowStyle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+    readonly engine_setFlowWeights: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setGlobe: (a: number, b: number) => void;
     readonly engine_setGlobeColor: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setGlyphAtlas: (a: number, b: number, c: number, d: number, e: number) => [number, number];
@@ -769,22 +807,24 @@ export interface InitOutput {
     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_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) => void;
-    readonly engine_setSymbols: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    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_setVectorSublayers: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number) => void;
-    readonly engine_setVectorTile: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number) => [number, number];
+    readonly engine_setVectorSublayers: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number) => void;
+    readonly engine_setVectorTile: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number) => [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) => [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_setZoomRange: (a: number, b: number, c: number) => void;
     readonly engine_stats: (a: number) => any;
-    readonly engine_stepFlow: (a: number, b: number, c: number) => void;
+    readonly engine_stepFlow: (a: number, b: number, c: number) => number;
     readonly engine_surface: (a: number, b: number, c: number) => any;
     readonly engine_surfaceAt: (a: number, b: number, c: number) => any;
     readonly engine_updateGlyphAtlas: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly engine_updateGlyphPage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly engine_updateGroundTexture: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number];
     readonly engine_updateIconAtlas: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly engine_uploadVectorTile: (a: number, b: number, c: number) => number;
     readonly engine_vectorTilesInView: (a: number, b: number, c: number) => [number, number];
     readonly engine_wantedTiles: (a: number, b: number) => [number, number];
     readonly engine_zoomAt: (a: number, b: number, c: number, d: number) => void;