@reearth/ezu 0.3.0 → 0.4.1

package/README.md

@@ -14,7 +14,7 @@ npm install @reearth/ezu
 
 ## Usage
 
-The package ships three builds and picks one automatically via the
+The package ships four builds and picks one automatically via the
 `exports` map:
 
 | Runtime              | Build used  |
@@ -22,7 +22,7 @@ The package ships three builds and picks one automatically via the
 | Vite / Webpack / Rollup | `bundler` |
 | Browser (native ESM) | `web`       |
 | Node.js              | `nodejs`    |
-| Cloudflare Workers   | `bundler` (via `workerd` condition) |
+| Cloudflare Workers   | `workerd` (via the `workerd` condition) |
 
 ### Bundler / Cloudflare Workers / Node.js
 
@@ -47,7 +47,18 @@ const renderer = new Renderer(styleJson);
 ### Explicit build selection
 
 If the auto-resolved entry doesn't fit your toolchain, import a build
-directly: `@reearth/ezu/web`, `@reearth/ezu/bundler`, or `@reearth/ezu/nodejs`.
+directly: `@reearth/ezu/web`, `@reearth/ezu/bundler`, `@reearth/ezu/nodejs`,
+or `@reearth/ezu/workerd`.
+
+`workerd` reuses the `bundler` glue but instantiates the wasm itself,
+because Cloudflare Workers resolve a `.wasm` import to an uninstantiated
+`WebAssembly.Module` rather than to live exports. Importing
+`@reearth/ezu/bundler` on Workers therefore fails with
+`__wbindgen_start is not a function`.
+
+The raw artifacts are exported too, for hosts that need to wire up
+instantiation themselves: `@reearth/ezu/bundler/ezu_bg.js`,
+`@reearth/ezu/bundler/ezu_bg.wasm`, and `@reearth/ezu/web/ezu_bg.wasm`.
 
 ## API
 

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;
     /**
@@ -61,11 +65,16 @@ export class Renderer {
      * Bind raw tile bytes under a `sources.<name>` entry from the style.
      * The renderer dispatches on the source's declared `type`:
      *
-     * - `mvt` / `pmtiles` → decode MVT layers eagerly; layers are bound
-     *   as `tile.<layer>` when [`render_tile`] runs.
-     * - `dem` → store the raw raster-DEM bytes per `(dx, dy)` neighbour
+     * - `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
@@ -83,6 +92,28 @@ export class Renderer {
      * Drop every pending source binding. Call between tile renders.
      */
     clearSources(): void;
+    /**
+     * Glyph ranges the currently bound features can require, as
+     * `{ [glyphsSourceName]: number[] }` where each number is a range
+     * start (`0`, `256`, `512`, …) — i.e. the `{range}` in a
+     * `…/{fontstack}/{range}.pbf` URL is `<start>-<start + 255>`.
+     *
+     * This host cannot fetch glyph ranges lazily, so every range a
+     * tile's labels touch must be bound before `renderTile`. Rather than
+     * scraping every string in the MVT, call this after binding the
+     * vector sources and bind exactly the listed ranges.
+     *
+     * It is an over-approximation, deliberately: a range is listed if
+     * *any* feature in a text layer carries the codepoint in a property
+     * the layer's `text` expression reads, without evaluating filters,
+     * zoom ranges, or the expression itself, and it is listed for every
+     * fontstack in that layer's fallback chain. So it never omits a
+     * range a label needs, and it may name a few that go unused. Text
+     * layers that build their string from something other than a `get`
+     * of a feature property (a literal, a `concat` of formatted values)
+     * contribute their literal text where it is a plain string.
+     */
+    neededGlyphRanges(): object;
     /**
      * Build a renderer from a style JSON document.
      */
@@ -97,11 +128,33 @@ export class Renderer {
      * - `png`: `{ compression?: "fast" | "default" | "best" }`
      */
     renderTile(z: number, x: number, y: number, opts?: object | null): Uint8Array;
+    /**
+     * Neighbour tile offsets the active style actually asks for from
+     * `source`, as an array of `[dx, dy]` pairs (never including the
+     * centre `[0, 0]`).
+     *
+     * Cross-tile label collision and edge-continuous DEM shading are the
+     * only things that read neighbours, and only for the sources they
+     * name. A host that fetches the full 3×3 window unconditionally
+     * therefore pays for up to eight tiles it will not look at; passing
+     * each offset from this list to `bindSource(name, bytes, { coord })`
+     * fetches exactly what the recipe needs. An empty array means the
+     * centre tile is enough.
+     *
+     * Throws `UnknownSource` if `name` is not declared in the style.
+     */
+    requestedNeighborOffsets(name: string): Array<any>;
     /**
      * Replace the active style. Returns the new node count. Invalidates
      * the intermediate cache and drops any pending source bindings.
      */
     setStyle(style_json: string): number;
+    /**
+     * 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.
+     */
+    readonly attribution: string | undefined;
     /**
      * `tile-size` declared by the current style.
      */
@@ -113,3 +166,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) {
@@ -108,15 +112,35 @@ export class Renderer {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_renderer_free(ptr, 0);
     }
+    /**
+     * 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}
+     */
+    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);
+        }
+        return v1;
+    }
     /**
      * Bind raw tile bytes under a `sources.<name>` entry from the style.
      * The renderer dispatches on the source's declared `type`:
      *
-     * - `mvt` / `pmtiles` → decode MVT layers eagerly; layers are bound
-     *   as `tile.<layer>` when [`render_tile`] runs.
-     * - `dem` → store the raw raster-DEM bytes per `(dx, dy)` neighbour
+     * - `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
@@ -154,6 +178,35 @@ export class Renderer {
     clearSources() {
         wasm.renderer_clearSources(this.__wbg_ptr);
     }
+    /**
+     * Glyph ranges the currently bound features can require, as
+     * `{ [glyphsSourceName]: number[] }` where each number is a range
+     * start (`0`, `256`, `512`, …) — i.e. the `{range}` in a
+     * `…/{fontstack}/{range}.pbf` URL is `<start>-<start + 255>`.
+     *
+     * This host cannot fetch glyph ranges lazily, so every range a
+     * tile's labels touch must be bound before `renderTile`. Rather than
+     * scraping every string in the MVT, call this after binding the
+     * vector sources and bind exactly the listed ranges.
+     *
+     * It is an over-approximation, deliberately: a range is listed if
+     * *any* feature in a text layer carries the codepoint in a property
+     * the layer's `text` expression reads, without evaluating filters,
+     * zoom ranges, or the expression itself, and it is listed for every
+     * fontstack in that layer's fallback chain. So it never omits a
+     * range a label needs, and it may name a few that go unused. Text
+     * layers that build their string from something other than a `get`
+     * of a feature property (a literal, a `concat` of formatted values)
+     * contribute their literal text where it is a plain string.
+     * @returns {object}
+     */
+    neededGlyphRanges() {
+        const ret = wasm.renderer_neededGlyphRanges(this.__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
@@ -192,6 +245,32 @@ export class Renderer {
         wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * Neighbour tile offsets the active style actually asks for from
+     * `source`, as an array of `[dx, dy]` pairs (never including the
+     * centre `[0, 0]`).
+     *
+     * Cross-tile label collision and edge-continuous DEM shading are the
+     * only things that read neighbours, and only for the sources they
+     * name. A host that fetches the full 3×3 window unconditionally
+     * therefore pays for up to eight tiles it will not look at; passing
+     * each offset from this list to `bindSource(name, bytes, { coord })`
+     * fetches exactly what the recipe needs. An empty array means the
+     * centre tile is enough.
+     *
+     * Throws `UnknownSource` if `name` is not declared in the style.
+     * @param {string} name
+     * @returns {Array<any>}
+     */
+    requestedNeighborOffsets(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.renderer_requestedNeighborOffsets(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Replace the active style. Returns the new node count. Invalidates
      * the intermediate cache and drops any pending source bindings.
@@ -227,6 +306,23 @@ 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;
@@ -241,6 +337,9 @@ export function __wbg___wbindgen_number_get_f73a1244370fcc2c(arg0, arg1) {
     getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
 }
+export function __wbg___wbindgen_rethrow_2b7cc655458909c2(arg0) {
+    throw arg0;
+}
 export function __wbg___wbindgen_string_get_d109740c0d18f4d7(arg0, arg1) {
     const obj = arg1;
     const ret = typeof(obj) === 'string' ? obj : undefined;

package/bundler/ezu_bg.wasm.d.ts

@@ -11,14 +11,18 @@ 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_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_neededGlyphRanges: (a: number) => [number, number, number];
 export const renderer_new: (a: number, b: 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_requestedNeighborOffsets: (a: number, b: number, c: 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 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;

package/nodejs/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;
     /**
@@ -61,11 +65,16 @@ export class Renderer {
      * Bind raw tile bytes under a `sources.<name>` entry from the style.
      * The renderer dispatches on the source's declared `type`:
      *
-     * - `mvt` / `pmtiles` → decode MVT layers eagerly; layers are bound
-     *   as `tile.<layer>` when [`render_tile`] runs.
-     * - `dem` → store the raw raster-DEM bytes per `(dx, dy)` neighbour
+     * - `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
@@ -83,6 +92,28 @@ export class Renderer {
      * Drop every pending source binding. Call between tile renders.
      */
     clearSources(): void;
+    /**
+     * Glyph ranges the currently bound features can require, as
+     * `{ [glyphsSourceName]: number[] }` where each number is a range
+     * start (`0`, `256`, `512`, …) — i.e. the `{range}` in a
+     * `…/{fontstack}/{range}.pbf` URL is `<start>-<start + 255>`.
+     *
+     * This host cannot fetch glyph ranges lazily, so every range a
+     * tile's labels touch must be bound before `renderTile`. Rather than
+     * scraping every string in the MVT, call this after binding the
+     * vector sources and bind exactly the listed ranges.
+     *
+     * It is an over-approximation, deliberately: a range is listed if
+     * *any* feature in a text layer carries the codepoint in a property
+     * the layer's `text` expression reads, without evaluating filters,
+     * zoom ranges, or the expression itself, and it is listed for every
+     * fontstack in that layer's fallback chain. So it never omits a
+     * range a label needs, and it may name a few that go unused. Text
+     * layers that build their string from something other than a `get`
+     * of a feature property (a literal, a `concat` of formatted values)
+     * contribute their literal text where it is a plain string.
+     */
+    neededGlyphRanges(): object;
     /**
      * Build a renderer from a style JSON document.
      */
@@ -97,11 +128,33 @@ export class Renderer {
      * - `png`: `{ compression?: "fast" | "default" | "best" }`
      */
     renderTile(z: number, x: number, y: number, opts?: object | null): Uint8Array;
+    /**
+     * Neighbour tile offsets the active style actually asks for from
+     * `source`, as an array of `[dx, dy]` pairs (never including the
+     * centre `[0, 0]`).
+     *
+     * Cross-tile label collision and edge-continuous DEM shading are the
+     * only things that read neighbours, and only for the sources they
+     * name. A host that fetches the full 3×3 window unconditionally
+     * therefore pays for up to eight tiles it will not look at; passing
+     * each offset from this list to `bindSource(name, bytes, { coord })`
+     * fetches exactly what the recipe needs. An empty array means the
+     * centre tile is enough.
+     *
+     * Throws `UnknownSource` if `name` is not declared in the style.
+     */
+    requestedNeighborOffsets(name: string): Array<any>;
     /**
      * Replace the active style. Returns the new node count. Invalidates
      * the intermediate cache and drops any pending source bindings.
      */
     setStyle(style_json: string): number;
+    /**
+     * 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.
+     */
+    readonly attribution: string | undefined;
     /**
      * `tile-size` declared by the current style.
      */
@@ -113,3 +166,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/nodejs/ezu.js

@@ -80,6 +80,10 @@ 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) {
@@ -111,15 +115,35 @@ class Renderer {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_renderer_free(ptr, 0);
     }
+    /**
+     * 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}
+     */
+    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);
+        }
+        return v1;
+    }
     /**
      * Bind raw tile bytes under a `sources.<name>` entry from the style.
      * The renderer dispatches on the source's declared `type`:
      *
-     * - `mvt` / `pmtiles` → decode MVT layers eagerly; layers are bound
-     *   as `tile.<layer>` when [`render_tile`] runs.
-     * - `dem` → store the raw raster-DEM bytes per `(dx, dy)` neighbour
+     * - `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
@@ -157,6 +181,35 @@ class Renderer {
     clearSources() {
         wasm.renderer_clearSources(this.__wbg_ptr);
     }
+    /**
+     * Glyph ranges the currently bound features can require, as
+     * `{ [glyphsSourceName]: number[] }` where each number is a range
+     * start (`0`, `256`, `512`, …) — i.e. the `{range}` in a
+     * `…/{fontstack}/{range}.pbf` URL is `<start>-<start + 255>`.
+     *
+     * This host cannot fetch glyph ranges lazily, so every range a
+     * tile's labels touch must be bound before `renderTile`. Rather than
+     * scraping every string in the MVT, call this after binding the
+     * vector sources and bind exactly the listed ranges.
+     *
+     * It is an over-approximation, deliberately: a range is listed if
+     * *any* feature in a text layer carries the codepoint in a property
+     * the layer's `text` expression reads, without evaluating filters,
+     * zoom ranges, or the expression itself, and it is listed for every
+     * fontstack in that layer's fallback chain. So it never omits a
+     * range a label needs, and it may name a few that go unused. Text
+     * layers that build their string from something other than a `get`
+     * of a feature property (a literal, a `concat` of formatted values)
+     * contribute their literal text where it is a plain string.
+     * @returns {object}
+     */
+    neededGlyphRanges() {
+        const ret = wasm.renderer_neededGlyphRanges(this.__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
@@ -195,6 +248,32 @@ class Renderer {
         wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * Neighbour tile offsets the active style actually asks for from
+     * `source`, as an array of `[dx, dy]` pairs (never including the
+     * centre `[0, 0]`).
+     *
+     * Cross-tile label collision and edge-continuous DEM shading are the
+     * only things that read neighbours, and only for the sources they
+     * name. A host that fetches the full 3×3 window unconditionally
+     * therefore pays for up to eight tiles it will not look at; passing
+     * each offset from this list to `bindSource(name, bytes, { coord })`
+     * fetches exactly what the recipe needs. An empty array means the
+     * centre tile is enough.
+     *
+     * Throws `UnknownSource` if `name` is not declared in the style.
+     * @param {string} name
+     * @returns {Array<any>}
+     */
+    requestedNeighborOffsets(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.renderer_requestedNeighborOffsets(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Replace the active style. Returns the new node count. Invalidates
      * the intermediate cache and drops any pending source bindings.
@@ -232,9 +311,27 @@ function simdEnabled() {
     return ret !== 0;
 }
 exports.simdEnabled = simdEnabled;
+
+/**
+ * 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}
+ */
+function threadsEnabled() {
+    const ret = wasm.threadsEnabled();
+    return ret !== 0;
+}
+exports.threadsEnabled = threadsEnabled;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg___wbindgen_boolean_get_2304fb8c853028c8: function(arg0) {
+            const v = arg0;
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
         __wbg___wbindgen_is_null_2042690d351e14f0: function(arg0) {
             const ret = arg0 === null;
             return ret;
@@ -249,6 +346,9 @@ function __wbg_get_imports() {
             getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
         },
+        __wbg___wbindgen_rethrow_2b7cc655458909c2: function(arg0) {
+            throw arg0;
+        },
         __wbg___wbindgen_string_get_d109740c0d18f4d7: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;

package/nodejs/ezu_bg.wasm.d.ts

@@ -11,14 +11,18 @@ 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_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_neededGlyphRanges: (a: number) => [number, number, number];
 export const renderer_new: (a: number, b: 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_requestedNeighborOffsets: (a: number, b: number, c: 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 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reearth/ezu",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Painterly map renderer — WebAssembly bindings",
   "license": "MIT OR Apache-2.0",
   "repository": {
@@ -24,8 +24,8 @@
   "exports": {
     ".": {
       "workerd": {
-        "types": "./bundler/ezu.d.ts",
-        "default": "./bundler/ezu.js"
+        "types": "./workerd/ezu.d.ts",
+        "default": "./workerd/ezu.js"
       },
       "browser": {
         "types": "./web/ezu.d.ts",
@@ -51,12 +51,22 @@
     "./nodejs": {
       "types": "./nodejs/ezu.d.ts",
       "default": "./nodejs/ezu.js"
-    }
+    },
+    "./workerd": {
+      "types": "./workerd/ezu.d.ts",
+      "default": "./workerd/ezu.js"
+    },
+    "./workerd/ezu.js": "./workerd/ezu.js",
+    "./bundler/ezu_bg.js": "./bundler/ezu_bg.js",
+    "./bundler/ezu_bg.wasm": "./bundler/ezu_bg.wasm",
+    "./web/ezu_bg.wasm": "./web/ezu_bg.wasm",
+    "./package.json": "./package.json"
   },
   "files": [
     "web",
     "bundler",
     "nodejs",
+    "workerd",
     "README.md",
     "LICENSE-MIT",
     "LICENSE-APACHE"
@@ -65,6 +75,7 @@
     "*.wasm",
     "./web/ezu.js",
     "./bundler/ezu.js",
-    "./nodejs/ezu.js"
+    "./nodejs/ezu.js",
+    "./workerd/ezu.js"
   ]
 }

package/web/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;
     /**
@@ -61,11 +65,16 @@ export class Renderer {
      * Bind raw tile bytes under a `sources.<name>` entry from the style.
      * The renderer dispatches on the source's declared `type`:
      *
-     * - `mvt` / `pmtiles` → decode MVT layers eagerly; layers are bound
-     *   as `tile.<layer>` when [`render_tile`] runs.
-     * - `dem` → store the raw raster-DEM bytes per `(dx, dy)` neighbour
+     * - `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
@@ -83,6 +92,28 @@ export class Renderer {
      * Drop every pending source binding. Call between tile renders.
      */
     clearSources(): void;
+    /**
+     * Glyph ranges the currently bound features can require, as
+     * `{ [glyphsSourceName]: number[] }` where each number is a range
+     * start (`0`, `256`, `512`, …) — i.e. the `{range}` in a
+     * `…/{fontstack}/{range}.pbf` URL is `<start>-<start + 255>`.
+     *
+     * This host cannot fetch glyph ranges lazily, so every range a
+     * tile's labels touch must be bound before `renderTile`. Rather than
+     * scraping every string in the MVT, call this after binding the
+     * vector sources and bind exactly the listed ranges.
+     *
+     * It is an over-approximation, deliberately: a range is listed if
+     * *any* feature in a text layer carries the codepoint in a property
+     * the layer's `text` expression reads, without evaluating filters,
+     * zoom ranges, or the expression itself, and it is listed for every
+     * fontstack in that layer's fallback chain. So it never omits a
+     * range a label needs, and it may name a few that go unused. Text
+     * layers that build their string from something other than a `get`
+     * of a feature property (a literal, a `concat` of formatted values)
+     * contribute their literal text where it is a plain string.
+     */
+    neededGlyphRanges(): object;
     /**
      * Build a renderer from a style JSON document.
      */
@@ -97,11 +128,33 @@ export class Renderer {
      * - `png`: `{ compression?: "fast" | "default" | "best" }`
      */
     renderTile(z: number, x: number, y: number, opts?: object | null): Uint8Array;
+    /**
+     * Neighbour tile offsets the active style actually asks for from
+     * `source`, as an array of `[dx, dy]` pairs (never including the
+     * centre `[0, 0]`).
+     *
+     * Cross-tile label collision and edge-continuous DEM shading are the
+     * only things that read neighbours, and only for the sources they
+     * name. A host that fetches the full 3×3 window unconditionally
+     * therefore pays for up to eight tiles it will not look at; passing
+     * each offset from this list to `bindSource(name, bytes, { coord })`
+     * fetches exactly what the recipe needs. An empty array means the
+     * centre tile is enough.
+     *
+     * Throws `UnknownSource` if `name` is not declared in the style.
+     */
+    requestedNeighborOffsets(name: string): Array<any>;
     /**
      * Replace the active style. Returns the new node count. Invalidates
      * the intermediate cache and drops any pending source bindings.
      */
     setStyle(style_json: string): number;
+    /**
+     * 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.
+     */
+    readonly attribution: string | undefined;
     /**
      * `tile-size` declared by the current style.
      */
@@ -114,6 +167,14 @@ export class Renderer {
  */
 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;
+
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
@@ -128,14 +189,18 @@ export interface InitOutput {
     readonly logsink_new: (a: number, b: number) => [number, number, number];
     readonly logsink_onEvent: (a: number, b: number) => void;
     readonly logsink_setCapacity: (a: number, b: number) => void;
+    readonly renderer_attribution: (a: number) => [number, number];
     readonly renderer_bindSource: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly renderer_boundSources: (a: number) => [number, number];
     readonly renderer_clearSources: (a: number) => void;
+    readonly renderer_neededGlyphRanges: (a: number) => [number, number, number];
     readonly renderer_new: (a: number, b: number) => [number, number, number];
     readonly renderer_renderTile: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+    readonly renderer_requestedNeighborOffsets: (a: number, b: number, c: number) => [number, number, number];
     readonly renderer_setStyle: (a: number, b: number, c: number) => [number, number, number];
     readonly renderer_tileSize: (a: number) => number;
     readonly simdEnabled: () => number;
+    readonly threadsEnabled: () => number;
     readonly __wbindgen_malloc_command_export: (a: number, b: number) => number;
     readonly __wbindgen_realloc_command_export: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store_command_export: (a: number) => void;

package/web/ezu.js

@@ -80,6 +80,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) {
@@ -110,15 +114,35 @@ export class Renderer {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_renderer_free(ptr, 0);
     }
+    /**
+     * 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}
+     */
+    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);
+        }
+        return v1;
+    }
     /**
      * Bind raw tile bytes under a `sources.<name>` entry from the style.
      * The renderer dispatches on the source's declared `type`:
      *
-     * - `mvt` / `pmtiles` → decode MVT layers eagerly; layers are bound
-     *   as `tile.<layer>` when [`render_tile`] runs.
-     * - `dem` → store the raw raster-DEM bytes per `(dx, dy)` neighbour
+     * - `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
@@ -156,6 +180,35 @@ export class Renderer {
     clearSources() {
         wasm.renderer_clearSources(this.__wbg_ptr);
     }
+    /**
+     * Glyph ranges the currently bound features can require, as
+     * `{ [glyphsSourceName]: number[] }` where each number is a range
+     * start (`0`, `256`, `512`, …) — i.e. the `{range}` in a
+     * `…/{fontstack}/{range}.pbf` URL is `<start>-<start + 255>`.
+     *
+     * This host cannot fetch glyph ranges lazily, so every range a
+     * tile's labels touch must be bound before `renderTile`. Rather than
+     * scraping every string in the MVT, call this after binding the
+     * vector sources and bind exactly the listed ranges.
+     *
+     * It is an over-approximation, deliberately: a range is listed if
+     * *any* feature in a text layer carries the codepoint in a property
+     * the layer's `text` expression reads, without evaluating filters,
+     * zoom ranges, or the expression itself, and it is listed for every
+     * fontstack in that layer's fallback chain. So it never omits a
+     * range a label needs, and it may name a few that go unused. Text
+     * layers that build their string from something other than a `get`
+     * of a feature property (a literal, a `concat` of formatted values)
+     * contribute their literal text where it is a plain string.
+     * @returns {object}
+     */
+    neededGlyphRanges() {
+        const ret = wasm.renderer_neededGlyphRanges(this.__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
@@ -194,6 +247,32 @@ export class Renderer {
         wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * Neighbour tile offsets the active style actually asks for from
+     * `source`, as an array of `[dx, dy]` pairs (never including the
+     * centre `[0, 0]`).
+     *
+     * Cross-tile label collision and edge-continuous DEM shading are the
+     * only things that read neighbours, and only for the sources they
+     * name. A host that fetches the full 3×3 window unconditionally
+     * therefore pays for up to eight tiles it will not look at; passing
+     * each offset from this list to `bindSource(name, bytes, { coord })`
+     * fetches exactly what the recipe needs. An empty array means the
+     * centre tile is enough.
+     *
+     * Throws `UnknownSource` if `name` is not declared in the style.
+     * @param {string} name
+     * @returns {Array<any>}
+     */
+    requestedNeighborOffsets(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.renderer_requestedNeighborOffsets(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Replace the active style. Returns the new node count. Invalidates
      * the intermediate cache and drops any pending source bindings.
@@ -229,9 +308,26 @@ 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;
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg___wbindgen_boolean_get_2304fb8c853028c8: function(arg0) {
+            const v = arg0;
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
         __wbg___wbindgen_is_null_2042690d351e14f0: function(arg0) {
             const ret = arg0 === null;
             return ret;
@@ -246,6 +342,9 @@ function __wbg_get_imports() {
             getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
         },
+        __wbg___wbindgen_rethrow_2b7cc655458909c2: function(arg0) {
+            throw arg0;
+        },
         __wbg___wbindgen_string_get_d109740c0d18f4d7: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;

package/web/ezu_bg.wasm.d.ts

@@ -11,14 +11,18 @@ 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_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_neededGlyphRanges: (a: number) => [number, number, number];
 export const renderer_new: (a: number, b: 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_requestedNeighborOffsets: (a: number, b: number, c: 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 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;

package/workerd/ezu.d.ts

@@ -0,0 +1,3 @@
+/* tslint:disable */
+/* eslint-disable */
+export * from "../bundler/ezu.js";

package/workerd/ezu.js

@@ -0,0 +1,13 @@
+/* @ts-self-types="./ezu.d.ts" */
+import * as glue from "../bundler/ezu_bg.js";
+import wasmModule from "../bundler/ezu_bg.wasm";
+
+// Synchronous instantiation is allowed at module scope on workerd; it
+// would be rejected inside a request handler.
+const instance = new WebAssembly.Instance(wasmModule, { "./ezu_bg.js": glue });
+glue.__wbg_set_wasm(instance.exports);
+instance.exports.__wbindgen_start();
+
+export {
+    LogSink, Renderer, simdEnabled, threadsEnabled
+} from "../bundler/ezu_bg.js";