@reearth/ezu 0.11.0 → 0.13.0

package/simd/bundler/ezu_bg.js

@@ -1,9 +1,129 @@
+/**
+ * What `renderFrame` hands each tile's `sources`: `bindSource` into the
+ * renderer the frame has taken for itself, for what that tile's set needs
+ * bound there.
+ */
+export class FrameBinder {
+    static __wrap(ptr) {
+        const obj = Object.create(FrameBinder.prototype);
+        obj.__wbg_ptr = ptr;
+        FrameBinderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FrameBinderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_framebinder_free(ptr, 0);
+    }
+    /**
+     * `Renderer.bindSource`, for the sources bound into the renderer
+     * itself: the glyphs a tile turns out to need, or a font, sprite,
+     * brush or image. Throws `UnknownSource` for a tile-scoped source,
+     * which the frame renders from the returned set and would never read
+     * here, and `StaleBinder` once this tile's `sources` has returned (or
+     * its promise settled).
+     * @param {string} name
+     * @param {Uint8Array} bytes
+     * @param {object | null} [opts]
+     */
+    bindSource(name, bytes, opts) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc_command_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.framebinder_bindSource(this.__wbg_ptr, ptr0, len0, ptr1, len1, isLikeNone(opts) ? 0 : addToExternrefTable0(opts));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+if (Symbol.dispose) FrameBinder.prototype[Symbol.dispose] = FrameBinder.prototype.free;
+
+/**
+ * What `frameFeatures` returns: features nodes' values gathered over the
+ * tiles of a frame a host renders itself, assembled into the pages
+ * `renderFrameWithFeatures` hands back.
+ *
+ * The Rust renderer's collector is handed each tile's values after the
+ * render; here the tile renders through the collector, so the values stay
+ * in the module rather than crossing to JS and back. It keeps the
+ * renderer that made it alive until it is finished or freed.
+ */
+export class FrameFeatureCollector {
+    static __wrap(ptr) {
+        const obj = Object.create(FrameFeatureCollector.prototype);
+        obj.__wbg_ptr = ptr;
+        FrameFeatureCollectorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FrameFeatureCollectorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_framefeaturecollector_free(ptr, 0);
+    }
+    /**
+     * The pages: one `{ node, geojson }` per entry of the request's
+     * `nodes`, in that order, as `renderFrameWithFeatures` hands them
+     * back. Tiles are read rows top to bottom, then left to right,
+     * whatever order they rendered in. The collector is used up.
+     * @returns {PageFeatures[]}
+     */
+    finish() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.framefeaturecollector_finish(ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * `renderTileWith` for one of the frame's tiles, also keeping what the
+     * collector's nodes held. Pass `tileSize: frame.tileSize` in `opts` to
+     * draw the tile `renderFrame` draws. Like `renderTileWith` it works
+     * while a `renderFrame` holds the renderer, and leaves the glyph
+     * budget to `trimGlyphs()`.
+     * @param {number} z
+     * @param {number} x
+     * @param {number} y
+     * @param {SourceSet} set
+     * @param {object | null} [opts]
+     * @returns {Uint8Array}
+     */
+    renderTile(z, x, y, set, opts) {
+        _assertClass(set, SourceSet);
+        const ret = wasm.framefeaturecollector_renderTile(this.__wbg_ptr, z, x, y, set.__wbg_ptr, isLikeNone(opts) ? 0 : addToExternrefTable0(opts));
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) FrameFeatureCollector.prototype[Symbol.dispose] = FrameFeatureCollector.prototype.free;
+
 /**
  * Buffered log sink that captures `tracing` events from the renderer.
  *
  * Construct once near the top of your bootstrap, then either set a
  * callback for live forwarding (`onEvent(e => console.log(e))`) or
  * `drainLines()` periodically to flush into a UI panel.
+ *
+ * It is the Go package's `InitLog` and `DrainLogs` (the pull side) and
+ * `WithLogger` (the push side) in one object. A class rather than two
+ * free functions, because a browser host also wants the structured
+ * records and the callback, which a wasip1 module's line buffer has no
+ * room for; a Rust host installs its own `tracing` subscriber instead.
  */
 export class LogSink {
     __destroy_into_raw() {
@@ -100,6 +220,14 @@ if (Symbol.dispose) LogSink.prototype[Symbol.dispose] = LogSink.prototype.free;
 
 /**
  * Stateful WASM renderer.
+ *
+ * Every method takes `&self` and borrows the renderer inside, rather than
+ * letting wasm-bindgen hold a borrow for the length of the call:
+ * `renderFrame` awaits JS between its tiles, and the loads and read-only
+ * queries a tile's `sources` makes (`loadSource`, `sourceTile`, …) have to
+ * reach the same
+ * renderer while the frame is still rendering. The `Rc` is what the
+ * frame's promise keeps alive between tiles.
  */
 export class Renderer {
     __destroy_into_raw() {
@@ -134,7 +262,7 @@ export class Renderer {
      * - `mvt` / `pmtiles` → store raw MVT bytes per `(dx, dy)` neighbour
      *   offset (centre `coord: [0, 0]`, the default). Layers are bound as
      *   `<source>.<layer>` (centre) or `<source>.<layer>@dx,dy`
-     *   (neighbours) when [`render_tile`] runs. Binding only the centre
+     *   (neighbours) when [`render_tile`](Self::render_tile) runs. Binding only the centre
      *   degrades cross-tile label collision to centre-only at borders.
      * - `dem` / `raster` → store the raw bytes per `(dx, dy)` neighbour
      *   offset. The centre tile is `coord: [0, 0]` (default). Decoding
@@ -191,11 +319,105 @@ export class Renderer {
         wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * Go back to the render cache's default size. Throws
+     * `FrameInProgress` while a `renderFrame` holds the renderer.
+     */
+    clearCacheBudget() {
+        const ret = wasm.renderer_clearCacheBudget(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Lift the cap `setGlyphBudget` put on the glyph bank, back to where a
+     * fresh renderer starts. It frees nothing: what is resident stays
+     * resident, and stops being trimmed. Throws `FrameInProgress` while a
+     * `renderFrame` holds the renderer.
+     */
+    clearGlyphBudget() {
+        const ret = wasm.renderer_clearGlyphBudget(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Drop every pending source binding. Call between tile renders.
      */
     clearSources() {
-        wasm.renderer_clearSources(this.__wbg_ptr);
+        const ret = wasm.renderer_clearSources(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Go back to rendering at the style's own `tile-size`, undoing
+     * `setTileSize`.
+     */
+    clearTileSize() {
+        const ret = wasm.renderer_clearTileSize(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Where a print frame sits on the tile grid: the zoom and tile size
+     * that meet `req`'s scale, and the tiles that cover it — the
+     * arithmetic `ezu frame` does before it renders anything, done by the
+     * same code, so a frame computed here is the one the CLI would render.
+     *
+     * `req` is `{ centerLon, centerLat, scale, dpi, width, height, zoom?,
+     * styleTileSize? }`: `scale` is the denominator (1000 for 1:1000),
+     * `width` and `height` the output size in pixels. `zoom` fixes the
+     * zoom, as the CLI's `--zoom` does; left out, the zoom chosen keeps
+     * the tile size nearest `styleTileSize`, which defaults to this
+     * renderer's style.
+     *
+     * The answer is `{ zoom, tileSize, scale, width, height, left, top,
+     * shift: [x, y], tilesX: [start, end], tilesY: [start, end] }`. Hand
+     * it to `renderFrame`, or render tiles `tilesX × tilesY` (end
+     * exclusive) at `zoom` and `tileSize` yourself: tile `(x, y)` lands
+     * with its top-left at `(x · tileSize − left, y · tileSize − top)`,
+     * cropped to `width × height`. `scale` is the denominator actually
+     * met, and `shift` how far rounding the frame onto whole pixels moved
+     * it.
+     *
+     * It changes nothing on the renderer. A request out of its domain (a
+     * non-positive scale, a latitude past the Mercator edge, a zero-sized
+     * output), a frame across the antimeridian, and a scale that needs a
+     * tile size outside 16..8192 px all throw `InvalidStyle`.
+     * @param {FrameRequest} req
+     * @returns {Frame}
+     */
+    computeFrame(req) {
+        const ret = wasm.renderer_computeFrame(this.__wbg_ptr, req);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Start gathering what features nodes hold over `frame`'s page, for a
+     * host that renders the frame's tiles itself — with `tileSize` set to
+     * the frame's, say — rather than through `renderFrameWithFeatures`,
+     * which makes and drives one of its own. `request` is
+     * `renderFrameWithFeatures`'s `{ nodes: [{ node, key? }], coords? }`.
+     * Render each of the frame's tiles with the collector's `renderTile`,
+     * in any order, then `finish()`.
+     *
+     * It changes nothing about what the renderer draws, so it works while
+     * a `renderFrame` holds the renderer. Throws `InvalidStyle` for what
+     * `renderFrameWithFeatures` refuses, here, before anything renders.
+     * @param {Frame} frame
+     * @param {FrameFeatures} request
+     * @returns {FrameFeatureCollector}
+     */
+    frameFeatures(frame, request) {
+        const ret = wasm.renderer_frameFeatures(this.__wbg_ptr, frame, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return FrameFeatureCollector.__wrap(ret[0]);
     }
     /**
      * The style's declared `legend`, or `undefined` when it declares
@@ -215,6 +437,39 @@ export class Renderer {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Decode a tile-scoped source's bytes — `mvt`, `pmtiles`, `dem`,
+     * `raster`, or a remote `geojson` document — once, into a
+     * `SourceData` that any number of `SourceSet`s can hold without
+     * decoding it again.
+     *
+     * A host rendering a block of tiles loads each tile it fetched once
+     * and binds it into the set of every tile it borders, rather than
+     * decoding it as the centre of one tile and again as a neighbour of
+     * each of the others. Nothing about what the renderer draws changes,
+     * so this works while a `renderFrame` holds the renderer, which is
+     * where a frame's callback loads its tiles.
+     *
+     * Throws `UnknownSource` if `name` is not declared, or is a kind bound
+     * into the renderer itself with `bindSource` (brush, image, sprite,
+     * font, glyphs), and the matching decode kind if the bytes do not
+     * parse. Unlike `bindSource`, a DEM or imagery tile is decoded here,
+     * so its decode error is thrown here and not from the render.
+     * @param {string} name
+     * @param {Uint8Array} bytes
+     * @returns {SourceData}
+     */
+    loadSource(name, bytes) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc_command_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.renderer_loadSource(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SourceData.__wrap(ret[0]);
+    }
     /**
      * What this renderer is holding, in bytes, so a host can shed load
      * *before* an allocation fails rather than after.
@@ -280,6 +535,21 @@ export class Renderer {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * `neededCodepoints` for the features in `set` rather than the ones
+     * bound to the renderer: what to bind into the glyphs sources before
+     * rendering from it.
+     * @param {SourceSet} set
+     * @returns {object}
+     */
+    neededCodepointsIn(set) {
+        _assertClass(set, SourceSet);
+        const ret = wasm.renderer_neededCodepointsIn(this.__wbg_ptr, set.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Glyph ranges the currently bound features can require, as
      * `{ [glyphsSourceName]: number[] }` where each number is a range
@@ -319,6 +589,20 @@ export class Renderer {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * `neededGlyphRanges` for the features in `set` rather than the ones
+     * bound to the renderer.
+     * @param {SourceSet} set
+     * @returns {object}
+     */
+    neededGlyphRangesIn(set) {
+        _assertClass(set, SourceSet);
+        const ret = wasm.renderer_neededGlyphRangesIn(this.__wbg_ptr, set.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Build a renderer from a style JSON document.
      * @param {string} style_json
@@ -350,13 +634,110 @@ export class Renderer {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Render every tile `frame` covers and copy each one's share into one
+     * frame-sized buffer, which is what `ezu frame` does: the same tiles,
+     * at the same tile size, cropped the same way. Resolves to straight
+     * (un-premultiplied) RGBA, `width × height × 4` bytes, as
+     * `format: "rgba"` is.
+     *
+     * The tile data stays yours to fetch, tile by tile, but it is handed
+     * over as a value rather than bound: before each tile
+     * `sources({ z, x, y }, binder)` is called with the tile about to
+     * render, and the tile renders from the `SourceSet` it returns, as
+     * `renderTileWith` does — the tile itself, the neighbours
+     * `requestedNeighborOffsets` names, the ancestor `sourceTile` answers
+     * past a source's max-zoom. A frame's tiles border each other, so keep
+     * the `SourceData` `loadSource` gives you and put each one into the set
+     * of every tile that reads it: each fetched tile is then decoded once,
+     * not once per tile around it. The frame reads the set and leaves it
+     * yours; returning one set for several tiles is fine.
+     *
+     * `sources` may return a promise, which is awaited, so it can fetch.
+     * One that throws or rejects stops the frame with that error. It may
+     * be `null` for a style that needs no tile data. The binder binds into
+     * the renderer what a set turns out to need — the glyphs
+     * `neededCodepointsIn` lists for it — with `binder.bindSource`, which
+     * takes what `bindSource` does but refuses a tile-scoped source with
+     * `UnknownSource`, since the frame never reads bound tile data.
+     * Persistent sources (fonts, sprites, brushes, images) can equally be
+     * bound once, before the call. After each tile the glyph banks are
+     * trimmed to `setGlyphBudget`'s budget, as `renderTile` does.
+     *
+     * Until the promise settles the renderer is the frame's: everything
+     * that would change what it draws — `bindSource`, `clearSources`,
+     * `renderTile`, `trimGlyphs`, another `renderFrame` or
+     * `renderFrameWithFeatures`, `setStyle`, `setTileSize`,
+     * `clearTileSize`, `setGlyphBudget`, `clearGlyphBudget`,
+     * `setCacheBudget`, `clearCacheBudget` — throws `FrameInProgress`, so a request running while `sources` awaits
+     * cannot change the frame's tiles under it. `loadSource`,
+     * `renderTileWith` and the queries that only read (`sourceTile`,
+     * `requestedNeighborOffsets`, `neededCodepointsIn`, `boundSources`, …)
+     * still work. A binder binds only for its own tile and only while that
+     * tile's `sources` runs; kept and used later, it throws `StaleBinder`.
+     * The renderer is given back however the frame ends, and the frame
+     * binds no tile data, so it leaves none bound.
+     *
+     * The tiles render at `frame.tileSize` per render, so the renderer's
+     * own tile size is left as it was. `opts` takes `renderTile`'s
+     * `pad` and `params`; its `format` and `tileSize` must be left out
+     * (or match), since the frame fixes both.
+     *
+     * Tiles render one after another, row by row from the top.
+     * @param {Frame} frame
+     * @param {((tile: { z: number; x: number; y: number }, binder: FrameBinder) => SourceSet | Promise<SourceSet>) | null | undefined} sources
+     * @param {object | null} [opts]
+     * @returns {Promise<Uint8Array>}
+     */
+    renderFrame(frame, sources, opts) {
+        const ret = wasm.renderer_renderFrame(this.__wbg_ptr, frame, isLikeNone(sources) ? 0 : addToExternrefTable0(sources), isLikeNone(opts) ? 0 : addToExternrefTable0(opts));
+        return ret;
+    }
+    /**
+     * `renderFrame`, also handing back what features nodes held over the
+     * whole page: resolves to `{ image, features }`, where `image` is the
+     * buffer `renderFrame` resolves to and `features` holds one
+     * `{ node, geojson }` per entry of `request.nodes`, in that order.
+     * `geojson` is a FeatureCollection as text, byte for byte the file
+     * `ezu frame --features` writes for the same style, data and frame.
+     *
+     * `request` is `{ nodes: [{ node, key? }], coords? }`. `key` names the
+     * properties that identify a feature across tiles — `["label-id",
+     * "part"]` for `label-boxes`: features whose key properties are all
+     * equal are written once, the first in reading order (rows top to
+     * bottom, then left to right), and the page is sorted by the key.
+     * Without one, every tile's features are written, so a feature several
+     * tiles see appears once per tile. `coords` is `"lonlat"` (the
+     * default), WGS84 to seven decimal places, or `"px"`, page pixels to
+     * two. Features wholly off the page are left out; one that reaches
+     * into it is written whole.
+     *
+     * The values are the ones each tile's render computed on its way to
+     * the pixels, so this costs no second evaluation. A name that is not
+     * a node of the style, or names one that produces something other
+     * than features, and a key that names no property, reject with
+     * `InvalidStyle` before anything renders.
+     * @param {Frame} frame
+     * @param {((tile: { z: number; x: number; y: number }, binder: FrameBinder) => SourceSet | Promise<SourceSet>) | null | undefined} sources
+     * @param {FrameFeatures} request
+     * @param {object | null} [opts]
+     * @returns {Promise<FrameWithFeatures>}
+     */
+    renderFrameWithFeatures(frame, sources, request, opts) {
+        const ret = wasm.renderer_renderFrameWithFeatures(this.__wbg_ptr, frame, isLikeNone(sources) ? 0 : addToExternrefTable0(sources), request, isLikeNone(opts) ? 0 : addToExternrefTable0(opts));
+        return ret;
+    }
     /**
      * Render a single tile using whatever sources are currently bound.
      *
      * `opts` (JS object, all fields optional):
      * - `format`: `"png"` (default) / `"webp"` / `"rgba"`
      * - `tileSize`, `pad`: override the style's canvas size for this
-     *   call (hi-DPI / preview)
+     *   call, in style pixels (a larger tile draws finer)
+     * - `pixelRatio`: device pixels per style pixel, 1 to 4 (default 1).
+     *   `2` renders a retina tile: twice the size, with every width, text
+     *   size and blur doubled, the way `window.devicePixelRatio` scales
+     *   a MapLibre map
      * - `params`: `{ name: number | boolean | string }` — render-time
      *   overrides for the style's declared `params`, validated the same
      *   way the CLI's `--param` is. Omitted names keep their declared
@@ -377,6 +758,86 @@ export class Renderer {
         wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * The tile size renders use: the one `setTileSize` set, or else the
+     * style's `tile-size`. A `tileSize` in one render's options still wins
+     * over it.
+     * @returns {number}
+     */
+    get renderTileSize() {
+        const ret = wasm.renderer_renderTileSize(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Render a single tile from the tile data in `set`, as `renderTile`
+     * does from what is bound. Nothing tile-scoped that `bindSource` bound
+     * is read; the fonts, sprites, brushes, images and glyphs bound into
+     * the renderer are. `opts` is `renderTile`'s.
+     *
+     * It changes nothing a later render depends on, so it needs no
+     * `clearSources` and works while a `renderFrame` holds the renderer.
+     * It does not bring the glyph banks back under a budget set with
+     * `setGlyphBudget`, as `renderTile` does after each render; call
+     * `trimGlyphs()` when a batch of renders is done.
+     * @param {number} z
+     * @param {number} x
+     * @param {number} y
+     * @param {SourceSet} set
+     * @param {object | null} [opts]
+     * @returns {Uint8Array}
+     */
+    renderTileWith(z, x, y, set, opts) {
+        _assertClass(set, SourceSet);
+        const ret = wasm.renderer_renderTileWith(this.__wbg_ptr, z, x, y, set.__wbg_ptr, isLikeNone(opts) ? 0 : addToExternrefTable0(opts));
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * `renderTileWith`, also handing back what each of `nodes` — ids of
+     * nodes that produce features — held when the render finished, in the
+     * order given: `{ image, features }`, where `image` is the bytes
+     * `renderTileWith` returns and `features` holds one
+     * `{ node, extent, geojson }` per name, `geojson` being a GeoJSON
+     * FeatureCollection as text — the shape `renderFrameWithFeatures` and
+     * the Go package hand back too.
+     *
+     * Each entry carries the node's id as `node` and the tile's size
+     * in geometry units as `extent`: coordinates run `0..extent` across
+     * the tile, `x` right and `y` down from its top-left corner. A node the
+     * render never reached — a branch a `switch` did not take — has no
+     * `extent` and no features. The values are the ones the render
+     * computed on its way to the pixels, so this costs no second
+     * evaluation.
+     *
+     * `nodes` is an array of ids, or `{ nodes, coords }` to write the
+     * geometry in other coordinates: `coords` is `"tile"` (the default,
+     * tile units as above), `"lonlat"` (WGS84, seven decimals) or `"px"`
+     * (the rendered tile's pixels from its top-left corner, two decimals,
+     * at the tile size the render drew at).
+     *
+     * Throws `InvalidStyle` before anything renders when a name is not a
+     * node of the style, or names one that produces something other than
+     * features, and for a `coords` it does not know.
+     * @param {number} z
+     * @param {number} x
+     * @param {number} y
+     * @param {SourceSet} set
+     * @param {string[] | TileFeatures} nodes
+     * @param {object | null} [opts]
+     * @returns {TileWithFeatures}
+     */
+    renderTileWithFeatures(z, x, y, set, nodes, opts) {
+        _assertClass(set, SourceSet);
+        const ret = wasm.renderer_renderTileWithFeatures(this.__wbg_ptr, z, x, y, set.__wbg_ptr, nodes, isLikeNone(opts) ? 0 : addToExternrefTable0(opts));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Neighbour tile offsets the active style actually asks for from
      * `source`, as an array of `[dx, dy]` pairs (never including the
@@ -415,6 +876,26 @@ export class Renderer {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Let the render cache hold up to `bytes` of pixels instead of its
+     * default (8 MiB). The cache keeps intermediate results a later render
+     * can reuse — most of all what a world-anchored node computes, which
+     * every tile around it reads too — so a host rendering many
+     * neighbouring tiles with memory to spare renders them faster with
+     * more, and one in a memory-capped isolate can hold it to less.
+     * `memoryUsage().cacheBudget` reports it back.
+     *
+     * The cache starts empty at the new size, and keeps the size through
+     * `setStyle` and `setTileSize`. Throws `FrameInProgress` while a
+     * `renderFrame` holds the renderer.
+     * @param {number} bytes
+     */
+    setCacheBudget(bytes) {
+        const ret = wasm.renderer_setCacheBudget(this.__wbg_ptr, bytes);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Cap the glyph bytes each bound fontstack keeps resident, in
      * bytes. Unset, a fontstack keeps every range ever bound to it for
@@ -439,19 +920,24 @@ export class Renderer {
      * names exactly what to bind, and a host that re-binds every tile
      * (rather than tracking what it sent) needs no other change.
      *
-     * A budget of `0xFFFFFFFF` — the largest value this host can express,
-     * since an address here is 32 bits — lifts the cap again, and is what
+     * `clearGlyphBudget()` lifts the cap again. So does a budget of
+     * `0xFFFFFFFF` — the largest value this host can express, since an
+     * address here is 32 bits — which is what
      * `memoryUsage().glyphBudget` reports as `Infinity`. A number that
      * big cannot be a real ceiling: it is every byte the module could
      * ever address.
      * @param {number} bytes
      */
     setGlyphBudget(bytes) {
-        wasm.renderer_setGlyphBudget(this.__wbg_ptr, bytes);
+        const ret = wasm.renderer_setGlyphBudget(this.__wbg_ptr, bytes);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
      * Replace the active style. Returns the new node count. Invalidates
-     * the intermediate cache and drops any pending source bindings.
+     * the intermediate cache, drops any pending source bindings, and
+     * goes back to the new style's own tile size.
      * @param {string} style_json
      * @returns {number}
      */
@@ -464,6 +950,30 @@ export class Renderer {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Render every tile at `size` px instead of the style's `tile-size`,
+     * without editing the style. `clearTileSize()` goes back to the
+     * style's, and so does `setStyle`.
+     *
+     * A print frame needs it: `computeFrame` meets the scale by choosing
+     * the tile size, and the frame's tiles must be drawn at exactly that
+     * size. It renders what the style with its `tile-size` edited would.
+     * Nothing you bind depends on it — `requestedNeighborOffsets` and
+     * `sourceTile` answer as before — and the intermediate cache, which is
+     * sized by the tile, is dropped when the size changes. `tileSize`
+     * keeps reporting the style's own, and a `tileSize` in one
+     * `renderTile`'s options still wins over this.
+     *
+     * Throws `InvalidStyle` for a size below 1 px: `0` is not "the
+     * style's", that is `clearTileSize`.
+     * @param {number} size
+     */
+    setTileSize(size) {
+        const ret = wasm.renderer_setTileSize(this.__wbg_ptr, size);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * The tile a host should actually fetch from `name` in order to draw
      * `z/x/y`, as `{ z, x, y }`.
@@ -534,22 +1044,192 @@ export class Renderer {
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * `tile-size` declared by the current style.
+     * `tile-size` declared by the current style, whatever `setTileSize`
+     * renders at.
      * @returns {number}
      */
     get tileSize() {
         const ret = wasm.renderer_tileSize(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Bring every bound fontstack back under the budget `setGlyphBudget`
+     * set; a no-op without one. `renderTile` does this after each render;
+     * after `renderTileWith`, call it yourself once a batch is done.
+     * Trimming can drop glyphs a frame bound for its next tile, so it
+     * throws `FrameInProgress` while a `renderFrame` holds the renderer,
+     * which trims after each of its tiles itself.
+     */
+    trimGlyphs() {
+        const ret = wasm.renderer_trimGlyphs(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * What building the current style's graph warned about: each names a
+     * node that works but relies on something the style does not say out
+     * loud. They are also logged when the style is built; this is for
+     * reporting or checking them on your own terms. Follows `setStyle`.
+     * @returns {string[]}
+     */
+    get warnings() {
+        const ret = wasm.renderer_warnings(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
 }
 if (Symbol.dispose) Renderer.prototype[Symbol.dispose] = Renderer.prototype.free;
 
+/**
+ * One tile-scoped payload — a vector tile, a DEM or imagery tile, a
+ * GeoJSON document — decoded once by `Renderer.loadSource` and ready to
+ * sit in any number of `SourceSet`s.
+ *
+ * A set keeps what it holds alive, so `free()` once the sets that need it
+ * have it, or leave it to the garbage collector. It is not tied to the
+ * renderer that loaded it: renderers in one module share a heap, and a
+ * render checks that its style declares the source the way the data was
+ * loaded for.
+ */
+export class SourceData {
+    static __wrap(ptr) {
+        const obj = Object.create(SourceData.prototype);
+        obj.__wbg_ptr = ptr;
+        SourceDataFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SourceDataFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sourcedata_free(ptr, 0);
+    }
+    /**
+     * The `sources.<name>` entry the data was loaded for.
+     * @returns {string}
+     */
+    get source() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.sourcedata_source(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) SourceData.prototype[Symbol.dispose] = SourceData.prototype.free;
+
+/**
+ * Every tile-scoped payload one render reads, each at its place in the
+ * 3×3 neighbourhood: the binding table `bindSource` fills, as a value you
+ * build per tile and hand to `renderTileWith`.
+ *
+ * A set says nothing about the tile it is for — offsets are relative — so
+ * pairing each tile with its neighbourhood is yours to do. Fonts, sprites,
+ * brushes, images and glyphs are not here: they belong to the renderer,
+ * bound once with `bindSource` and read by every render.
+ */
+export class SourceSet {
+    static __wrap(ptr) {
+        const obj = Object.create(SourceSet.prototype);
+        obj.__wbg_ptr = ptr;
+        SourceSetFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof SourceSet)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SourceSetFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sourceset_free(ptr, 0);
+    }
+    /**
+     * Put `data` at `opts.coord` for its source, replacing what was
+     * there. `opts` is `bindSource`'s `{ coord?: [dx, dy], sourceZoom? }`:
+     * `sourceZoom` says the data is an ancestor's, to be resampled or
+     * reprojected into the tile. The set shares the data rather than
+     * copying it.
+     *
+     * Throws `UnknownSource` when the source already holds data of
+     * another kind, and for the `coord` and `sourceZoom` `bindSource`
+     * refuses.
+     * @param {SourceData} data
+     * @param {object | null} [opts]
+     */
+    bind(data, opts) {
+        _assertClass(data, SourceData);
+        const ret = wasm.sourceset_bind(this.__wbg_ptr, data.__wbg_ptr, isLikeNone(opts) ? 0 : addToExternrefTable0(opts));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * A copy of the set. It holds the same data, which is shared rather
+     * than copied, so this costs a few references per entry.
+     * @returns {SourceSet}
+     */
+    clone() {
+        const ret = wasm.sourceset_clone(this.__wbg_ptr);
+        return SourceSet.__wrap(ret);
+    }
+    /**
+     * Whether anything is bound for `source`.
+     * @param {string} source
+     * @returns {boolean}
+     */
+    contains(source) {
+        const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sourceset_contains(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Whether nothing is bound at all.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.sourceset_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * An empty set: a render from it draws what the style draws with no
+     * tile data at all.
+     */
+    constructor() {
+        const ret = wasm.sourceset_new();
+        this.__wbg_ptr = ret;
+        SourceSetFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) SourceSet.prototype[Symbol.dispose] = SourceSet.prototype.free;
+
 /**
  * Wasm linear memory currently committed to this module, in bytes.
  *
  * This is the figure an isolate's memory cap applies to, and the one
  * to watch to shed load before an allocation fails — a refused
- * `memory.grow` throws [`OutOfMemory`](oom) and ends the instance.
+ * `memory.grow` throws `OutOfMemory` (see the `oom` module) and ends the
+ * instance.
  * It never falls: freed Rust values return to the allocator for reuse,
  * but wasm cannot hand pages back to the host. So a drop in demand
  * leaves the number where its peak left it, and only a fresh instance
@@ -564,6 +1244,31 @@ export function heapBytes() {
     return ret >>> 0;
 }
 
+/**
+ * The number of node ops registered in this module. It is the smoke test
+ * for the module's life-before-main constructors: zero means they never
+ * ran, and every style is about to fail with "unknown op". The Go
+ * package's `OpCount`; a Rust host reads the registry itself, through
+ * `ezu::paint::nodes::default_registry()`.
+ * @returns {number}
+ */
+export function opCount() {
+    const ret = wasm.opCount();
+    return ret >>> 0;
+}
+
+/**
+ * Every registered node op, by name: which ops this build has, not just
+ * how many. The Go package's `OpNames`.
+ * @returns {string[]}
+ */
+export function opNames() {
+    const ret = wasm.opNames();
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
 /**
  * Whether the wasm binary was compiled with `+simd128`. Lets the demo
  * page label the renderer build accurately.
@@ -590,10 +1295,19 @@ export function __wbg___wbindgen_boolean_get_fa956cfa2d1bd751(arg0) {
     const ret = typeof(v) === 'boolean' ? v : undefined;
     return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
 }
+export function __wbg___wbindgen_is_function_1ff95bcc5517c252(arg0) {
+    const ret = typeof(arg0) === 'function';
+    return ret;
+}
 export function __wbg___wbindgen_is_null_ea9085d691f535d3(arg0) {
     const ret = arg0 === null;
     return ret;
 }
+export function __wbg___wbindgen_is_object_a27215656b807791(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+}
 export function __wbg___wbindgen_is_undefined_c05833b95a3cf397(arg0) {
     const ret = arg0 === undefined;
     return ret;
@@ -618,10 +1332,21 @@ export function __wbg___wbindgen_string_get_b0ca35b86a603356(arg0, arg1) {
 export function __wbg___wbindgen_throw_344f42d3211c4765(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
+export function __wbg__wbg_cb_unref_fffb441def202758(arg0) {
+    arg0._wbg_cb_unref();
+}
+export function __wbg_call_8a2dd23819f8a60a() { return handleError(function (arg0, arg1) {
+    const ret = arg0.call(arg1);
+    return ret;
+}, arguments); }
 export function __wbg_call_a6e5c5dce5018821() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.call(arg1, arg2);
     return ret;
 }, arguments); }
+export function __wbg_call_e3b662382210db98() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.call(arg1, arg2, arg3);
+    return ret;
+}, arguments); }
 export function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
     let deferred0_0;
     let deferred0_1;
@@ -633,6 +1358,10 @@ export function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
         wasm.__wbindgen_free_command_export(deferred0_0, deferred0_1, 1);
     }
 }
+export function __wbg_framebinder_new(arg0) {
+    const ret = FrameBinder.__wrap(arg0);
+    return ret;
+}
 export function __wbg_get_507a50627bffa49b(arg0, arg1) {
     const ret = arg0[arg1 >>> 0];
     return ret;
@@ -663,6 +1392,10 @@ export function __wbg_keys_58421f8f96795607(arg0) {
     const ret = Object.keys(arg0);
     return ret;
 }
+export function __wbg_length_1f0964f4a5e2c6d8(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
 export function __wbg_length_370319915dc99107(arg0) {
     const ret = arg0.length;
     return ret;
@@ -675,6 +1408,10 @@ export function __wbg_new_32b398fb48b6d94a() {
     const ret = new Array();
     return ret;
 }
+export function __wbg_new_5e245ef5857d7f33(arg0, arg1) {
+    const ret = new TypeError(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
 export function __wbg_new_b667d279fd5aa943(arg0, arg1) {
     const ret = new Error(getStringFromWasm0(arg0, arg1));
     return ret;
@@ -683,6 +1420,32 @@ export function __wbg_new_da52cf8fe3429cb2() {
     const ret = new Object();
     return ret;
 }
+export function __wbg_new_from_slice_77cdfb7977362f3c(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_new_typed_1824d93f294193e5(arg0, arg1) {
+    try {
+        var state0 = {a: arg0, b: arg1};
+        var cb0 = (arg0, arg1) => {
+            const a = state0.a;
+            state0.a = 0;
+            try {
+                return wasm_bindgen_40e41bdbc20eab45___convert__closures_____invoke___js_sys_d7d35d7b07b5c2c7___Function_fn_wasm_bindgen_40e41bdbc20eab45___JsValue_____wasm_bindgen_40e41bdbc20eab45___sys__Undefined___js_sys_d7d35d7b07b5c2c7___Function_fn_wasm_bindgen_40e41bdbc20eab45___JsValue_____wasm_bindgen_40e41bdbc20eab45___sys__Undefined_______true_(a, state0.b, arg0, arg1);
+            } finally {
+                state0.a = a;
+            }
+        };
+        const ret = new Promise(cb0);
+        return ret;
+    } finally {
+        state0.a = 0;
+    }
+}
+export function __wbg_new_with_length_e6785c33c8e4cce8(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return ret;
+}
 export function __wbg_now_86c0d4ba3fa605b8() {
     const ret = Date.now();
     return ret;
@@ -695,6 +1458,24 @@ export function __wbg_push_d2ae3af0c1217ae6(arg0, arg1) {
     const ret = arg0.push(arg1);
     return ret;
 }
+export function __wbg_queueMicrotask_0ab5b2d2393e99b9(arg0) {
+    const ret = arg0.queueMicrotask;
+    return ret;
+}
+export function __wbg_queueMicrotask_6a09b7bc46549209(arg0) {
+    queueMicrotask(arg0);
+}
+export function __wbg_reject_90df95b492dd8563(arg0) {
+    const ret = Promise.reject(arg0);
+    return ret;
+}
+export function __wbg_resolve_2191a4dfe481c25b(arg0) {
+    const ret = Promise.resolve(arg0);
+    return ret;
+}
+export function __wbg_set_4d7dd76f3dae2926(arg0, arg1, arg2) {
+    arg0.set(getArrayU8FromWasm0(arg1, arg2));
+}
 export function __wbg_set_8535240470bf2500() { return handleError(function (arg0, arg1, arg2) {
     const ret = Reflect.set(arg0, arg1, arg2);
     return ret;
@@ -702,6 +1483,10 @@ export function __wbg_set_8535240470bf2500() { return handleError(function (arg0
 export function __wbg_set_name_3bbc583faefa4193(arg0, arg1, arg2) {
     arg0.name = getStringFromWasm0(arg1, arg2);
 }
+export function __wbg_sourceset_unwrap(arg0) {
+    const ret = SourceSet.__unwrap(arg0);
+    return ret;
+}
 export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     const ret = arg1.stack;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
@@ -709,12 +1494,45 @@ export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbindgen_cast_0000000000000001(arg0) {
+export function __wbg_static_accessor_GLOBAL_4ef717fb391d88b7() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_GLOBAL_THIS_8d1badc68b5a74f4() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_SELF_146583524fe1469b() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_WINDOW_f2829a2234d7819e() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_subarray_3ed232c8a6baee09(arg0, arg1, arg2) {
+    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+    return ret;
+}
+export function __wbg_then_16d107c451e9905d(arg0, arg1, arg2) {
+    const ret = arg0.then(arg1, arg2);
+    return ret;
+}
+export function __wbg_then_6ec10ae38b3e92f7(arg0, arg1) {
+    const ret = arg0.then(arg1);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 72, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen_40e41bdbc20eab45___convert__closures_____invoke___wasm_bindgen_40e41bdbc20eab45___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_40e41bdbc20eab45___JsError___true_);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000002(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;
     return ret;
 }
-export function __wbindgen_cast_0000000000000002(arg0, arg1) {
+export function __wbindgen_cast_0000000000000003(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
@@ -728,12 +1546,35 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
+function wasm_bindgen_40e41bdbc20eab45___convert__closures_____invoke___wasm_bindgen_40e41bdbc20eab45___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_40e41bdbc20eab45___JsError___true_(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_40e41bdbc20eab45___convert__closures_____invoke___wasm_bindgen_40e41bdbc20eab45___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_40e41bdbc20eab45___JsError___true_(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+function wasm_bindgen_40e41bdbc20eab45___convert__closures_____invoke___js_sys_d7d35d7b07b5c2c7___Function_fn_wasm_bindgen_40e41bdbc20eab45___JsValue_____wasm_bindgen_40e41bdbc20eab45___sys__Undefined___js_sys_d7d35d7b07b5c2c7___Function_fn_wasm_bindgen_40e41bdbc20eab45___JsValue_____wasm_bindgen_40e41bdbc20eab45___sys__Undefined_______true_(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen_40e41bdbc20eab45___convert__closures_____invoke___js_sys_d7d35d7b07b5c2c7___Function_fn_wasm_bindgen_40e41bdbc20eab45___JsValue_____wasm_bindgen_40e41bdbc20eab45___sys__Undefined___js_sys_d7d35d7b07b5c2c7___Function_fn_wasm_bindgen_40e41bdbc20eab45___JsValue_____wasm_bindgen_40e41bdbc20eab45___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
+}
+
+const FrameBinderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_framebinder_free(ptr, 1));
+const FrameFeatureCollectorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_framefeaturecollector_free(ptr, 1));
 const LogSinkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_logsink_free(ptr, 1));
 const RendererFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_renderer_free(ptr, 1));
+const SourceDataFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sourcedata_free(ptr, 1));
+const SourceSetFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sourceset_free(ptr, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc_command_export();
@@ -741,6 +1582,16 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure_command_export(state.a, state.b));
+
 function getArrayJsValueFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     const mem = getDataViewMemory0();
@@ -790,6 +1641,34 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function makeMutClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            wasm.__wbindgen_destroy_closure_command_export(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);