@reearth/ezu 0.2.0 → 0.4.0

package/README.md

@@ -1,9 +1,10 @@
-# ezu
+# @reearth/ezu
 
 Painterly map renderer compiled to WebAssembly. The JS side owns all I/O
 (HTTP, PMTiles, asset fetching); this package exposes a stateful
-`Renderer` that holds a parsed style document, its built graph, and an
-in-memory brush bank — it renders one tile at a time from raw MVT bytes.
+`Renderer` that holds a parsed style document, its built graph, an
+in-memory brush bank, and a per-tile binding buffer that mirrors the
+style's `sources` block.
 
 ## Install
 
@@ -29,7 +30,9 @@ The package ships three builds and picks one automatically via the
 import { Renderer } from "@reearth/ezu";
 
 const renderer = new Renderer(styleJson);
-const png = renderer.render(mvtBytes, z, x, y);
+renderer.bindSource("basemap", mvtBytes);
+const png = renderer.renderTile(z, x, y);
+renderer.clearSources();
 ```
 
 ### Browser (native ESM, no bundler)
@@ -54,34 +57,81 @@ function simdEnabled(): boolean;
 class Renderer {
   constructor(styleJson: string);
 
-  setStyle(styleJson: string): number;
-  registerBrush(name: string, mybJson: string): void;
-  unregisterBrush(name: string): boolean;
-  clearBrushes(): void;
-  brushCount(): number;
+  setStyle(styleJson: string): number;            // → new node count
   readonly tileSize: number;
 
-  render(mvtBytes: Uint8Array | null, z: number, x: number, y: number): Uint8Array;        // PNG
-  renderWebp(mvtBytes: Uint8Array | null, z: number, x: number, y: number): Uint8Array;    // lossless WebP
-  renderRgba(mvtBytes: Uint8Array | null, z: number, x: number, y: number): Uint8Array;    // straight RGBA
-
-  renderAt(mvtBytes: Uint8Array | null, z: number, x: number, y: number,
-           tileSize: number, pad: number): Uint8Array;
-  renderWebpAt(mvtBytes: Uint8Array | null, z: number, x: number, y: number,
-               tileSize: number, pad: number): Uint8Array;
-  renderRgbaAt(mvtBytes: Uint8Array | null, z: number, x: number, y: number,
-               tileSize: number, pad: number): Uint8Array;
+  // Bind tile bytes under a `sources.<name>` entry from the style.
+  // The renderer dispatches on the source's declared `type`:
+  //   - brush  → parse `.myb` JSON, persistent
+  //   - image  → decode PNG/WebP, persistent
+  //   - mvt/pmtiles → decode at render time, cleared by `clearSources`
+  //   - dem    → decode + stitch at render time. Pass each neighbour
+  //              tile with `{ coord: [dx, dy] }` (dx, dy ∈ {-1, 0, 1}).
+  bindSource(name: string, bytes: Uint8Array,
+             opts?: { coord?: [number, number] }): void;
+  clearSources(): void;
+  boundSources(): string[];     // names with at least one pending tile-scoped binding
+
+  // Single unified render. `opts.format` picks the encoder; `tileSize`
+  // / `pad` override the canvas for hi-DPI / preview.
+  renderTile(z: number, x: number, y: number, opts?: {
+    format?: "png" | "webp" | "rgba";      // default "png"
+    tileSize?: number;
+    pad?: number;
+    png?: { compression?: "fast" | "default" | "best" };
+  }): Uint8Array;
 
   free(): void;
 }
 ```
 
-Pass `null` for `mvtBytes` to render the style's paper background only
-(out-of-range tiles, archive misses, etc.).
+## Output formats
+
+- **`format: "png"`** (default) returns PNG bytes — feed to `<img>`
+  via `URL.createObjectURL(new Blob([buf], { type: "image/png" }))`.
+- **`format: "webp"`** returns lossless WebP bytes (~15 % smaller
+  than PNG on painterly tiles). Pure-Rust encoder, no native deps.
+- **`format: "rgba"`** returns straight (un-premultiplied) 8-bit
+  RGBA bytes (`tile_size * tile_size * 4`) — feed directly to
+  `ctx.putImageData(new ImageData(new Uint8ClampedArray(buf.buffer), w, h), 0, 0)`
+  and skip the PNG decode round trip.
+
+WebP is lossless via `image-webp` and has no quality knob — for
+lossy WebP without C deps, render as `"rgba"` then call
+`OffscreenCanvas.convertToBlob({ type: "image/webp", quality })`.
+
+## Missing tiles
+
+Don't bind any MVT source for that tile — `renderTile` returns the
+style's paper background. `features` source nodes see no
+`tile.<layer>` binding and emit an empty layer, so downstream paint
+nodes short-circuit.
+
+## Errors
 
-Errors are thrown as JavaScript `Error` instances whose `.name`
-discriminates the kind: `InvalidStyle`, `BrushParse`, `MvtDecode`,
-`RenderFailed`, `PngEncode`, `WebpEncode`.
+Every fallible method throws a JavaScript `Error` whose `.name`
+discriminates the kind:
+
+| `.name` | When |
+|---|---|
+| `InvalidStyle` | `new Renderer(...)` / `setStyle(...)` rejected the JSON |
+| `BrushParse`   | `registerBrush(...)` or `bindSource` on a brush source couldn't parse the `.myb` JSON |
+| `MvtDecode`    | `bindSource` (mvt/pmtiles) or render couldn't decode the MVT bytes |
+| `DemDecode`    | `bindSource` (dem) couldn't decode the raster-DEM tile |
+| `UnknownSource`| `bindSource` was given a name not in the style's `sources` block, or `coord` was malformed |
+| `RenderFailed` | A node `eval` failed (e.g. missing brush, downcast mismatch) |
+| `PngEncode`    | PNG encoding failed |
+| `WebpEncode`   | WebP encoding failed |
+
+```js
+try {
+  await loadAndRender();
+} catch (e) {
+  if (e.name === "InvalidStyle") showStyleError(e.message);
+  else if (e.name === "MvtDecode") showFetchError(e.message);
+  else throw e;
+}
+```
 
 ## License
 

package/bundler/ezu.d.ts

@@ -38,6 +38,10 @@ export class LogSink {
     /**
      * Set (or clear with `null` / `undefined`) the per-event JS
      * callback. The callback receives a structured record object.
+     *
+     * No-op in multithreaded (`threads`) builds — events can originate
+     * on rayon worker threads, so live forwarding to a main-thread JS
+     * callback isn't available. Use `drain` / `drainLines` instead.
      */
     onEvent(callback?: Function | null): void;
     /**
@@ -58,64 +62,61 @@ export class Renderer {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Number of brushes currently registered.
-     */
-    brushCount(): number;
-    /**
-     * Drop every registered brush.
-     */
-    clearBrushes(): void;
-    /**
-     * Build a renderer from a style JSON document.
-     */
-    constructor(style_json: string);
-    /**
-     * Register a `.myb` brush under `name` so a `brush-file` node with
-     * `src: "@name"` (via the style's `assets` map) resolves to it.
-     * Re-registering the same name replaces the previous entry.
-     */
-    registerBrush(name: string, myb_json: string): void;
-    /**
-     * Render a single tile to PNG bytes using the style's `tile-size` / `pad`.
-     * Pass `null` for `mvtBytes` to get a paper-only tile.
+     * Bind raw tile bytes under a `sources.<name>` entry from the style.
+     * The renderer dispatches on the source's declared `type`:
      *
-     * Optional `options`: `{ png: { compression: 'fast' | 'default' | 'best' } }`.
-     */
-    render(mvt_bytes: Uint8Array | null | undefined, z: number, x: number, y: number, options?: object | null): Uint8Array;
-    /**
-     * Like `render` but with `tile_size` / `pad` overridden — useful for
-     * hi-DPI / preview rendering without mutating the style.
+     * - `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
+     *   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
+     *   and 3×3 stitching happen at render time once the tile id is known.
+     * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
+     *   projected per tile (and neighbour) at render time.
+     *
+     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
+     * `UnknownSource` if `name` doesn't match any entry in the style's
+     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `DemDecode` for non-image DEM bytes (the decode itself runs at
+     * render time, but obvious cases are caught here).
      */
-    renderAt(mvt_bytes: Uint8Array | null | undefined, z: number, x: number, y: number, tile_size: number, pad: number, options?: object | null): Uint8Array;
+    bindSource(name: string, bytes: Uint8Array, opts?: object | null): void;
     /**
-     * Render a single tile to straight RGBA8 bytes (`tile_w * tile_h * 4`).
+     * Names of every source with at least one pending binding.
+     * Order matches the style's `sources` declaration order.
      */
-    renderRgba(mvt_bytes: Uint8Array | null | undefined, z: number, x: number, y: number): Uint8Array;
+    boundSources(): string[];
     /**
-     * Like `renderRgba` but with `tile_size` / `pad` overridden.
+     * Drop every pending source binding. Call between tile renders.
      */
-    renderRgbaAt(mvt_bytes: Uint8Array | null | undefined, z: number, x: number, y: number, tile_size: number, pad: number): Uint8Array;
+    clearSources(): void;
     /**
-     * Render a single tile to lossless WebP bytes. Smaller than PNG
-     * for the same painterly content and decoded natively by every
-     * modern browser. WebP is lossless-only via the pure-Rust
-     * `image-webp` codec; for lossy WebP, see the
-     * `OffscreenCanvas.convertToBlob` recipe in the crate README.
+     * Build a renderer from a style JSON document.
      */
-    renderWebp(mvt_bytes: Uint8Array | null | undefined, z: number, x: number, y: number, options?: object | null): Uint8Array;
+    constructor(style_json: string);
     /**
-     * Like `renderWebp` but with `tile_size` / `pad` overridden.
+     * 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)
+     * - `png`: `{ compression?: "fast" | "default" | "best" }`
      */
-    renderWebpAt(mvt_bytes: Uint8Array | null | undefined, z: number, x: number, y: number, tile_size: number, pad: number, options?: object | null): Uint8Array;
+    renderTile(z: number, x: number, y: number, opts?: object | null): Uint8Array;
     /**
      * Replace the active style. Returns the new node count. Invalidates
-     * the intermediate cache.
+     * the intermediate cache and drops any pending source bindings.
      */
     setStyle(style_json: string): number;
     /**
-     * Remove a brush by name. Returns `true` if the brush existed.
+     * Effective attribution declared by the style (document +
+     * sources), joined with ` | `. Upstream TileJSON / PMTiles
+     * metadata is the JS host's concern — merge it on that side.
      */
-    unregisterBrush(name: string): boolean;
+    readonly attribution: string | undefined;
     /**
      * `tile-size` declared by the current style.
      */
@@ -127,3 +128,11 @@ export class Renderer {
  * page label the renderer build accurately.
  */
 export function simdEnabled(): boolean;
+
+/**
+ * Whether this build supports multithreaded rendering (compiled with
+ * the `threads` feature). When `false`, `initThreadPool` is absent and
+ * `renderTile`'s `parallel` option is a no-op. Mirrors `simdEnabled` so
+ * the host can label the build.
+ */
+export function threadsEnabled(): boolean;

package/bundler/ezu.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./ezu_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    LogSink, Renderer, simdEnabled
+    LogSink, Renderer, simdEnabled, threadsEnabled
 } from "./ezu_bg.js";

package/bundler/ezu_bg.js

@@ -78,6 +78,10 @@ export class LogSink {
     /**
      * Set (or clear with `null` / `undefined`) the per-event JS
      * callback. The callback receives a structured record object.
+     *
+     * No-op in multithreaded (`threads`) builds — events can originate
+     * on rayon worker threads, so live forwarding to a main-thread JS
+     * callback isn't available. Use `drain` / `drainLines` instead.
      * @param {Function | null} [callback]
      */
     onEvent(callback) {
@@ -109,186 +113,112 @@ export class Renderer {
         wasm.__wbg_renderer_free(ptr, 0);
     }
     /**
-     * Number of brushes currently registered.
-     * @returns {number}
-     */
-    brushCount() {
-        const ret = wasm.renderer_brushCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Drop every registered brush.
+     * Effective attribution declared by the style (document +
+     * sources), joined with ` | `. Upstream TileJSON / PMTiles
+     * metadata is the JS host's concern — merge it on that side.
+     * @returns {string | undefined}
      */
-    clearBrushes() {
-        wasm.renderer_clearBrushes(this.__wbg_ptr);
-    }
-    /**
-     * Build a renderer from a style JSON document.
-     * @param {string} style_json
-     */
-    constructor(style_json) {
-        const ptr0 = passStringToWasm0(style_json, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.renderer_new(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    get attribution() {
+        const ret = wasm.renderer_attribution(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
         }
-        this.__wbg_ptr = ret[0];
-        RendererFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+        return v1;
     }
     /**
-     * Register a `.myb` brush under `name` so a `brush-file` node with
-     * `src: "@name"` (via the style's `assets` map) resolves to it.
-     * Re-registering the same name replaces the previous entry.
+     * Bind raw tile bytes under a `sources.<name>` entry from the style.
+     * The renderer dispatches on the source's declared `type`:
+     *
+     * - `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
+     *   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
+     *   and 3×3 stitching happen at render time once the tile id is known.
+     * - `geojson` (remote) → store raw bytes per `(dx, dy)` offset;
+     *   projected per tile (and neighbour) at render time.
+     *
+     * `opts` is a JS object: `{ coord?: [dx, dy] }`. Throws
+     * `UnknownSource` if `name` doesn't match any entry in the style's
+     * `sources` block, `MvtDecode` if MVT bytes don't parse, and
+     * `DemDecode` for non-image DEM bytes (the decode itself runs at
+     * render time, but obvious cases are caught here).
      * @param {string} name
-     * @param {string} myb_json
+     * @param {Uint8Array} bytes
+     * @param {object | null} [opts]
      */
-    registerBrush(name, myb_json) {
+    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 = passStringToWasm0(myb_json, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const ptr1 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc_command_export);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.renderer_registerBrush(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm.renderer_bindSource(this.__wbg_ptr, ptr0, len0, ptr1, len1, isLikeNone(opts) ? 0 : addToExternrefTable0(opts));
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * Render a single tile to PNG bytes using the style's `tile-size` / `pad`.
-     * Pass `null` for `mvtBytes` to get a paper-only tile.
-     *
-     * Optional `options`: `{ png: { compression: 'fast' | 'default' | 'best' } }`.
-     * @param {Uint8Array | null | undefined} mvt_bytes
-     * @param {number} z
-     * @param {number} x
-     * @param {number} y
-     * @param {object | null} [options]
-     * @returns {Uint8Array}
-     */
-    render(mvt_bytes, z, x, y, options) {
-        var ptr0 = isLikeNone(mvt_bytes) ? 0 : passArray8ToWasm0(mvt_bytes, wasm.__wbindgen_malloc_command_export);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.renderer_render(this.__wbg_ptr, ptr0, len0, z, x, y, isLikeNone(options) ? 0 : addToExternrefTable0(options));
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
-        return v2;
-    }
-    /**
-     * Like `render` but with `tile_size` / `pad` overridden — useful for
-     * hi-DPI / preview rendering without mutating the style.
-     * @param {Uint8Array | null | undefined} mvt_bytes
-     * @param {number} z
-     * @param {number} x
-     * @param {number} y
-     * @param {number} tile_size
-     * @param {number} pad
-     * @param {object | null} [options]
-     * @returns {Uint8Array}
-     */
-    renderAt(mvt_bytes, z, x, y, tile_size, pad, options) {
-        var ptr0 = isLikeNone(mvt_bytes) ? 0 : passArray8ToWasm0(mvt_bytes, wasm.__wbindgen_malloc_command_export);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.renderer_renderAt(this.__wbg_ptr, ptr0, len0, z, x, y, tile_size, pad, isLikeNone(options) ? 0 : addToExternrefTable0(options));
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
-        return v2;
-    }
-    /**
-     * Render a single tile to straight RGBA8 bytes (`tile_w * tile_h * 4`).
-     * @param {Uint8Array | null | undefined} mvt_bytes
-     * @param {number} z
-     * @param {number} x
-     * @param {number} y
-     * @returns {Uint8Array}
+     * Names of every source with at least one pending binding.
+     * Order matches the style's `sources` declaration order.
+     * @returns {string[]}
      */
-    renderRgba(mvt_bytes, z, x, y) {
-        var ptr0 = isLikeNone(mvt_bytes) ? 0 : passArray8ToWasm0(mvt_bytes, wasm.__wbindgen_malloc_command_export);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.renderer_renderRgba(this.__wbg_ptr, ptr0, len0, z, x, y);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
-        return v2;
+    boundSources() {
+        const ret = wasm.renderer_boundSources(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
-     * Like `renderRgba` but with `tile_size` / `pad` overridden.
-     * @param {Uint8Array | null | undefined} mvt_bytes
-     * @param {number} z
-     * @param {number} x
-     * @param {number} y
-     * @param {number} tile_size
-     * @param {number} pad
-     * @returns {Uint8Array}
+     * Drop every pending source binding. Call between tile renders.
      */
-    renderRgbaAt(mvt_bytes, z, x, y, tile_size, pad) {
-        var ptr0 = isLikeNone(mvt_bytes) ? 0 : passArray8ToWasm0(mvt_bytes, wasm.__wbindgen_malloc_command_export);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.renderer_renderRgbaAt(this.__wbg_ptr, ptr0, len0, z, x, y, tile_size, pad);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
-        return v2;
+    clearSources() {
+        wasm.renderer_clearSources(this.__wbg_ptr);
     }
     /**
-     * Render a single tile to lossless WebP bytes. Smaller than PNG
-     * for the same painterly content and decoded natively by every
-     * modern browser. WebP is lossless-only via the pure-Rust
-     * `image-webp` codec; for lossy WebP, see the
-     * `OffscreenCanvas.convertToBlob` recipe in the crate README.
-     * @param {Uint8Array | null | undefined} mvt_bytes
-     * @param {number} z
-     * @param {number} x
-     * @param {number} y
-     * @param {object | null} [options]
-     * @returns {Uint8Array}
+     * Build a renderer from a style JSON document.
+     * @param {string} style_json
      */
-    renderWebp(mvt_bytes, z, x, y, options) {
-        var ptr0 = isLikeNone(mvt_bytes) ? 0 : passArray8ToWasm0(mvt_bytes, wasm.__wbindgen_malloc_command_export);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.renderer_renderWebp(this.__wbg_ptr, ptr0, len0, z, x, y, isLikeNone(options) ? 0 : addToExternrefTable0(options));
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
+    constructor(style_json) {
+        const ptr0 = passStringToWasm0(style_json, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.renderer_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
-        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
-        return v2;
+        this.__wbg_ptr = ret[0];
+        RendererFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * Like `renderWebp` but with `tile_size` / `pad` overridden.
-     * @param {Uint8Array | null | undefined} mvt_bytes
+     * 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)
+     * - `png`: `{ compression?: "fast" | "default" | "best" }`
      * @param {number} z
      * @param {number} x
      * @param {number} y
-     * @param {number} tile_size
-     * @param {number} pad
-     * @param {object | null} [options]
+     * @param {object | null} [opts]
      * @returns {Uint8Array}
      */
-    renderWebpAt(mvt_bytes, z, x, y, tile_size, pad, options) {
-        var ptr0 = isLikeNone(mvt_bytes) ? 0 : passArray8ToWasm0(mvt_bytes, wasm.__wbindgen_malloc_command_export);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.renderer_renderWebpAt(this.__wbg_ptr, ptr0, len0, z, x, y, tile_size, pad, isLikeNone(options) ? 0 : addToExternrefTable0(options));
+    renderTile(z, x, y, opts) {
+        const ret = wasm.renderer_renderTile(this.__wbg_ptr, z, x, y, isLikeNone(opts) ? 0 : addToExternrefTable0(opts));
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
-        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
-        return v2;
+        return v1;
     }
     /**
      * Replace the active style. Returns the new node count. Invalidates
-     * the intermediate cache.
+     * the intermediate cache and drops any pending source bindings.
      * @param {string} style_json
      * @returns {number}
      */
@@ -309,17 +239,6 @@ export class Renderer {
         const ret = wasm.renderer_tileSize(this.__wbg_ptr);
         return ret >>> 0;
     }
-    /**
-     * Remove a brush by name. Returns `true` if the brush existed.
-     * @param {string} name
-     * @returns {boolean}
-     */
-    unregisterBrush(name) {
-        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.renderer_unregisterBrush(this.__wbg_ptr, ptr0, len0);
-        return ret !== 0;
-    }
 }
 if (Symbol.dispose) Renderer.prototype[Symbol.dispose] = Renderer.prototype.free;
 
@@ -332,6 +251,37 @@ export function simdEnabled() {
     const ret = wasm.simdEnabled();
     return ret !== 0;
 }
+
+/**
+ * Whether this build supports multithreaded rendering (compiled with
+ * the `threads` feature). When `false`, `initThreadPool` is absent and
+ * `renderTile`'s `parallel` option is a no-op. Mirrors `simdEnabled` so
+ * the host can label the build.
+ * @returns {boolean}
+ */
+export function threadsEnabled() {
+    const ret = wasm.threadsEnabled();
+    return ret !== 0;
+}
+export function __wbg___wbindgen_boolean_get_2304fb8c853028c8(arg0) {
+    const v = arg0;
+    const ret = typeof(v) === 'boolean' ? v : undefined;
+    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+}
+export function __wbg___wbindgen_is_null_2042690d351e14f0(arg0) {
+    const ret = arg0 === null;
+    return ret;
+}
+export function __wbg___wbindgen_is_undefined_35bb9f4c7fd651d5(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+}
+export function __wbg___wbindgen_number_get_f73a1244370fcc2c(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'number' ? obj : undefined;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+}
 export function __wbg___wbindgen_string_get_d109740c0d18f4d7(arg0, arg1) {
     const obj = arg1;
     const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -358,6 +308,10 @@ export function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
         wasm.__wbindgen_free_command_export(deferred0_0, deferred0_1, 1);
     }
 }
+export function __wbg_get_98fdf51d029a75eb(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+}
 export function __wbg_get_dcf82ab8aad1a593() { return handleError(function (arg0, arg1) {
     const ret = Reflect.get(arg0, arg1);
     return ret;
@@ -372,6 +326,14 @@ export function __wbg_instanceof_Object_03924e0dbda74bd8(arg0) {
     const ret = result;
     return ret;
 }
+export function __wbg_isArray_94898ed3aad6947b(arg0) {
+    const ret = Array.isArray(arg0);
+    return ret;
+}
+export function __wbg_length_2591a0f4f659a55c(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
 export function __wbg_new_02d162bc6cf02f60() {
     const ret = new Object();
     return ret;

package/bundler/ezu_bg.wasm.d.ts

@@ -11,20 +11,16 @@ export const logsink_len: (a: number) => number;
 export const logsink_new: (a: number, b: number) => [number, number, number];
 export const logsink_onEvent: (a: number, b: number) => void;
 export const logsink_setCapacity: (a: number, b: number) => void;
-export const renderer_brushCount: (a: number) => number;
-export const renderer_clearBrushes: (a: number) => void;
+export const renderer_attribution: (a: number) => [number, number];
+export const renderer_bindSource: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+export const renderer_boundSources: (a: number) => [number, number];
+export const renderer_clearSources: (a: number) => void;
 export const renderer_new: (a: number, b: number) => [number, number, number];
-export const renderer_registerBrush: (a: number, b: number, c: number, d: number, e: number) => [number, number];
-export const renderer_render: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
-export const renderer_renderAt: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number, number];
-export const renderer_renderRgba: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
-export const renderer_renderRgbaAt: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
-export const renderer_renderWebp: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
-export const renderer_renderWebpAt: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number, number];
+export const renderer_renderTile: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
 export const renderer_setStyle: (a: number, b: number, c: number) => [number, number, number];
 export const renderer_tileSize: (a: number) => number;
-export const renderer_unregisterBrush: (a: number, b: number, c: number) => number;
 export const simdEnabled: () => number;
+export const threadsEnabled: () => number;
 export const __wbindgen_malloc_command_export: (a: number, b: number) => number;
 export const __wbindgen_realloc_command_export: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store_command_export: (a: number) => void;