@reearth/ezu 0.10.0 → 0.11.0

package/README.md

@@ -122,6 +122,24 @@ class Renderer {
   clearSources(): void;
   boundSources(): string[];     // names with at least one pending tile-scoped binding
 
+  // Every source the style declares, in declaration order — what to
+  // fetch, what kind it is, and whether the binding has to be repeated
+  // per tile. Walk this rather than parsing the style yourself; `url` is
+  // absent only for inline `geojson`, which needs no binding at all, and
+  // a `glyphs` url comes back with `{fontstack}` already substituted.
+  sources(): Array<{
+    name: string;
+    type: "mvt" | "pmtiles" | "dem" | "raster" | "geojson"
+        | "sprite" | "font" | "glyphs" | "brush" | "image";
+    tileScoped: boolean;
+    url?: string;
+    indexUrl?: string;          // a sprite index that is a URL, not inline
+  }>;
+
+  // Cap the resident glyph bytes per fontstack. 0xFFFFFFFF lifts the cap
+  // (and reads back as `Infinity` from `memoryUsage().glyphBudget`).
+  setGlyphBudget(bytes: number): void;
+
   // 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?: {

package/bundler/ezu.d.ts

@@ -273,6 +273,12 @@ export class Renderer {
      * before the next tile that needs it. `neededCodepoints()` already
      * 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
+     * `memoryUsage().glyphBudget` reports as `Infinity`. A number that
+     * big cannot be a real ceiling: it is every byte the module could
+     * ever address.
      */
     setGlyphBudget(bytes: number): void;
     /**
@@ -305,6 +311,30 @@ export class Renderer {
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
     sourceTile(name: string, z: number, x: number, y: number): any;
+    /**
+     * Every source the style declares, in declaration order, as an array
+     * of `{ name, type, tileScoped, url?, indexUrl? }`.
+     *
+     * This is what a host walks before it fetches anything: `type` is the
+     * style's own word for the kind (`"mvt"`, `"dem"`, `"glyphs"`, …) and
+     * says what `bindSource` will do with the bytes, and `url` is where
+     * they come from — an XYZ template for a tile pyramid, a document
+     * URL, or, for `glyphs`, the endpoint with `{fontstack}` already
+     * substituted and `{range}` left to fill in per block. `boundSources`
+     * answers the opposite question, what is already bound, and cannot
+     * start the loop.
+     *
+     * `tileScoped` says whether a binding of that kind is dropped by
+     * `clearSources` and has to be rebound for the next tile; the rest go
+     * into the persistent banks and are bound once.
+     *
+     * `url` is absent only for a `geojson` source with inline `data`: the
+     * style carries the payload, so there is nothing to fetch and nothing
+     * to bind. `indexUrl` appears on a `sprite` source whose index is a
+     * URL rather than inline — fetch it and pass the text as
+     * `bindSource(name, atlasBytes, { index })`.
+     */
+    sources(): Array<any>;
     /**
      * Effective attribution declared by the style (document +
      * sources), joined with ` | `. Upstream TileJSON / PMTiles

package/bundler/ezu_bg.js

@@ -438,6 +438,12 @@ export class Renderer {
      * before the next tile that needs it. `neededCodepoints()` already
      * 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
+     * `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) {
@@ -496,6 +502,37 @@ export class Renderer {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Every source the style declares, in declaration order, as an array
+     * of `{ name, type, tileScoped, url?, indexUrl? }`.
+     *
+     * This is what a host walks before it fetches anything: `type` is the
+     * style's own word for the kind (`"mvt"`, `"dem"`, `"glyphs"`, …) and
+     * says what `bindSource` will do with the bytes, and `url` is where
+     * they come from — an XYZ template for a tile pyramid, a document
+     * URL, or, for `glyphs`, the endpoint with `{fontstack}` already
+     * substituted and `{range}` left to fill in per block. `boundSources`
+     * answers the opposite question, what is already bound, and cannot
+     * start the loop.
+     *
+     * `tileScoped` says whether a binding of that kind is dropped by
+     * `clearSources` and has to be rebound for the next tile; the rest go
+     * into the persistent banks and are bound once.
+     *
+     * `url` is absent only for a `geojson` source with inline `data`: the
+     * style carries the payload, so there is nothing to fetch and nothing
+     * to bind. `indexUrl` appears on a `sprite` source whose index is a
+     * URL rather than inline — fetch it and pass the text as
+     * `bindSource(name, atlasBytes, { index })`.
+     * @returns {Array<any>}
+     */
+    sources() {
+        const ret = wasm.renderer_sources(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * `tile-size` declared by the current style.
      * @returns {number}

package/bundler/ezu_bg.wasm.d.ts

@@ -27,6 +27,7 @@ export const renderer_requestedNeighborOffsets: (a: number, b: number, c: number
 export const renderer_setGlyphBudget: (a: number, b: number) => void;
 export const renderer_setStyle: (a: number, b: number, c: number) => [number, number, number];
 export const renderer_sourceTile: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+export const renderer_sources: (a: number) => [number, number, number];
 export const renderer_tileSize: (a: number) => number;
 export const simdEnabled: () => number;
 export const threadsEnabled: () => number;

package/nodejs/ezu.d.ts

@@ -273,6 +273,12 @@ export class Renderer {
      * before the next tile that needs it. `neededCodepoints()` already
      * 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
+     * `memoryUsage().glyphBudget` reports as `Infinity`. A number that
+     * big cannot be a real ceiling: it is every byte the module could
+     * ever address.
      */
     setGlyphBudget(bytes: number): void;
     /**
@@ -305,6 +311,30 @@ export class Renderer {
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
     sourceTile(name: string, z: number, x: number, y: number): any;
+    /**
+     * Every source the style declares, in declaration order, as an array
+     * of `{ name, type, tileScoped, url?, indexUrl? }`.
+     *
+     * This is what a host walks before it fetches anything: `type` is the
+     * style's own word for the kind (`"mvt"`, `"dem"`, `"glyphs"`, …) and
+     * says what `bindSource` will do with the bytes, and `url` is where
+     * they come from — an XYZ template for a tile pyramid, a document
+     * URL, or, for `glyphs`, the endpoint with `{fontstack}` already
+     * substituted and `{range}` left to fill in per block. `boundSources`
+     * answers the opposite question, what is already bound, and cannot
+     * start the loop.
+     *
+     * `tileScoped` says whether a binding of that kind is dropped by
+     * `clearSources` and has to be rebound for the next tile; the rest go
+     * into the persistent banks and are bound once.
+     *
+     * `url` is absent only for a `geojson` source with inline `data`: the
+     * style carries the payload, so there is nothing to fetch and nothing
+     * to bind. `indexUrl` appears on a `sprite` source whose index is a
+     * URL rather than inline — fetch it and pass the text as
+     * `bindSource(name, atlasBytes, { index })`.
+     */
+    sources(): Array<any>;
     /**
      * Effective attribution declared by the style (document +
      * sources), joined with ` | `. Upstream TileJSON / PMTiles

package/nodejs/ezu.js

@@ -441,6 +441,12 @@ class Renderer {
      * before the next tile that needs it. `neededCodepoints()` already
      * 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
+     * `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) {
@@ -499,6 +505,37 @@ class Renderer {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Every source the style declares, in declaration order, as an array
+     * of `{ name, type, tileScoped, url?, indexUrl? }`.
+     *
+     * This is what a host walks before it fetches anything: `type` is the
+     * style's own word for the kind (`"mvt"`, `"dem"`, `"glyphs"`, …) and
+     * says what `bindSource` will do with the bytes, and `url` is where
+     * they come from — an XYZ template for a tile pyramid, a document
+     * URL, or, for `glyphs`, the endpoint with `{fontstack}` already
+     * substituted and `{range}` left to fill in per block. `boundSources`
+     * answers the opposite question, what is already bound, and cannot
+     * start the loop.
+     *
+     * `tileScoped` says whether a binding of that kind is dropped by
+     * `clearSources` and has to be rebound for the next tile; the rest go
+     * into the persistent banks and are bound once.
+     *
+     * `url` is absent only for a `geojson` source with inline `data`: the
+     * style carries the payload, so there is nothing to fetch and nothing
+     * to bind. `indexUrl` appears on a `sprite` source whose index is a
+     * URL rather than inline — fetch it and pass the text as
+     * `bindSource(name, atlasBytes, { index })`.
+     * @returns {Array<any>}
+     */
+    sources() {
+        const ret = wasm.renderer_sources(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * `tile-size` declared by the current style.
      * @returns {number}

package/nodejs/ezu_bg.wasm.d.ts

@@ -27,6 +27,7 @@ export const renderer_requestedNeighborOffsets: (a: number, b: number, c: number
 export const renderer_setGlyphBudget: (a: number, b: number) => void;
 export const renderer_setStyle: (a: number, b: number, c: number) => [number, number, number];
 export const renderer_sourceTile: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+export const renderer_sources: (a: number) => [number, number, number];
 export const renderer_tileSize: (a: number) => number;
 export const simdEnabled: () => number;
 export const threadsEnabled: () => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reearth/ezu",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Painterly map renderer — WebAssembly bindings",
   "license": "MIT OR Apache-2.0",
   "repository": {

package/simd/bundler/ezu.d.ts

@@ -273,6 +273,12 @@ export class Renderer {
      * before the next tile that needs it. `neededCodepoints()` already
      * 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
+     * `memoryUsage().glyphBudget` reports as `Infinity`. A number that
+     * big cannot be a real ceiling: it is every byte the module could
+     * ever address.
      */
     setGlyphBudget(bytes: number): void;
     /**
@@ -305,6 +311,30 @@ export class Renderer {
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
     sourceTile(name: string, z: number, x: number, y: number): any;
+    /**
+     * Every source the style declares, in declaration order, as an array
+     * of `{ name, type, tileScoped, url?, indexUrl? }`.
+     *
+     * This is what a host walks before it fetches anything: `type` is the
+     * style's own word for the kind (`"mvt"`, `"dem"`, `"glyphs"`, …) and
+     * says what `bindSource` will do with the bytes, and `url` is where
+     * they come from — an XYZ template for a tile pyramid, a document
+     * URL, or, for `glyphs`, the endpoint with `{fontstack}` already
+     * substituted and `{range}` left to fill in per block. `boundSources`
+     * answers the opposite question, what is already bound, and cannot
+     * start the loop.
+     *
+     * `tileScoped` says whether a binding of that kind is dropped by
+     * `clearSources` and has to be rebound for the next tile; the rest go
+     * into the persistent banks and are bound once.
+     *
+     * `url` is absent only for a `geojson` source with inline `data`: the
+     * style carries the payload, so there is nothing to fetch and nothing
+     * to bind. `indexUrl` appears on a `sprite` source whose index is a
+     * URL rather than inline — fetch it and pass the text as
+     * `bindSource(name, atlasBytes, { index })`.
+     */
+    sources(): Array<any>;
     /**
      * Effective attribution declared by the style (document +
      * sources), joined with ` | `. Upstream TileJSON / PMTiles

package/simd/bundler/ezu_bg.js

@@ -438,6 +438,12 @@ export class Renderer {
      * before the next tile that needs it. `neededCodepoints()` already
      * 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
+     * `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) {
@@ -496,6 +502,37 @@ export class Renderer {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Every source the style declares, in declaration order, as an array
+     * of `{ name, type, tileScoped, url?, indexUrl? }`.
+     *
+     * This is what a host walks before it fetches anything: `type` is the
+     * style's own word for the kind (`"mvt"`, `"dem"`, `"glyphs"`, …) and
+     * says what `bindSource` will do with the bytes, and `url` is where
+     * they come from — an XYZ template for a tile pyramid, a document
+     * URL, or, for `glyphs`, the endpoint with `{fontstack}` already
+     * substituted and `{range}` left to fill in per block. `boundSources`
+     * answers the opposite question, what is already bound, and cannot
+     * start the loop.
+     *
+     * `tileScoped` says whether a binding of that kind is dropped by
+     * `clearSources` and has to be rebound for the next tile; the rest go
+     * into the persistent banks and are bound once.
+     *
+     * `url` is absent only for a `geojson` source with inline `data`: the
+     * style carries the payload, so there is nothing to fetch and nothing
+     * to bind. `indexUrl` appears on a `sprite` source whose index is a
+     * URL rather than inline — fetch it and pass the text as
+     * `bindSource(name, atlasBytes, { index })`.
+     * @returns {Array<any>}
+     */
+    sources() {
+        const ret = wasm.renderer_sources(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * `tile-size` declared by the current style.
      * @returns {number}

package/simd/bundler/ezu_bg.wasm.d.ts

@@ -27,6 +27,7 @@ export const renderer_requestedNeighborOffsets: (a: number, b: number, c: number
 export const renderer_setGlyphBudget: (a: number, b: number) => void;
 export const renderer_setStyle: (a: number, b: number, c: number) => [number, number, number];
 export const renderer_sourceTile: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+export const renderer_sources: (a: number) => [number, number, number];
 export const renderer_tileSize: (a: number) => number;
 export const simdEnabled: () => number;
 export const threadsEnabled: () => number;

package/simd/nodejs/ezu.d.ts

@@ -273,6 +273,12 @@ export class Renderer {
      * before the next tile that needs it. `neededCodepoints()` already
      * 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
+     * `memoryUsage().glyphBudget` reports as `Infinity`. A number that
+     * big cannot be a real ceiling: it is every byte the module could
+     * ever address.
      */
     setGlyphBudget(bytes: number): void;
     /**
@@ -305,6 +311,30 @@ export class Renderer {
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
     sourceTile(name: string, z: number, x: number, y: number): any;
+    /**
+     * Every source the style declares, in declaration order, as an array
+     * of `{ name, type, tileScoped, url?, indexUrl? }`.
+     *
+     * This is what a host walks before it fetches anything: `type` is the
+     * style's own word for the kind (`"mvt"`, `"dem"`, `"glyphs"`, …) and
+     * says what `bindSource` will do with the bytes, and `url` is where
+     * they come from — an XYZ template for a tile pyramid, a document
+     * URL, or, for `glyphs`, the endpoint with `{fontstack}` already
+     * substituted and `{range}` left to fill in per block. `boundSources`
+     * answers the opposite question, what is already bound, and cannot
+     * start the loop.
+     *
+     * `tileScoped` says whether a binding of that kind is dropped by
+     * `clearSources` and has to be rebound for the next tile; the rest go
+     * into the persistent banks and are bound once.
+     *
+     * `url` is absent only for a `geojson` source with inline `data`: the
+     * style carries the payload, so there is nothing to fetch and nothing
+     * to bind. `indexUrl` appears on a `sprite` source whose index is a
+     * URL rather than inline — fetch it and pass the text as
+     * `bindSource(name, atlasBytes, { index })`.
+     */
+    sources(): Array<any>;
     /**
      * Effective attribution declared by the style (document +
      * sources), joined with ` | `. Upstream TileJSON / PMTiles

package/simd/nodejs/ezu.js

@@ -441,6 +441,12 @@ class Renderer {
      * before the next tile that needs it. `neededCodepoints()` already
      * 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
+     * `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) {
@@ -499,6 +505,37 @@ class Renderer {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Every source the style declares, in declaration order, as an array
+     * of `{ name, type, tileScoped, url?, indexUrl? }`.
+     *
+     * This is what a host walks before it fetches anything: `type` is the
+     * style's own word for the kind (`"mvt"`, `"dem"`, `"glyphs"`, …) and
+     * says what `bindSource` will do with the bytes, and `url` is where
+     * they come from — an XYZ template for a tile pyramid, a document
+     * URL, or, for `glyphs`, the endpoint with `{fontstack}` already
+     * substituted and `{range}` left to fill in per block. `boundSources`
+     * answers the opposite question, what is already bound, and cannot
+     * start the loop.
+     *
+     * `tileScoped` says whether a binding of that kind is dropped by
+     * `clearSources` and has to be rebound for the next tile; the rest go
+     * into the persistent banks and are bound once.
+     *
+     * `url` is absent only for a `geojson` source with inline `data`: the
+     * style carries the payload, so there is nothing to fetch and nothing
+     * to bind. `indexUrl` appears on a `sprite` source whose index is a
+     * URL rather than inline — fetch it and pass the text as
+     * `bindSource(name, atlasBytes, { index })`.
+     * @returns {Array<any>}
+     */
+    sources() {
+        const ret = wasm.renderer_sources(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * `tile-size` declared by the current style.
      * @returns {number}

package/simd/nodejs/ezu_bg.wasm.d.ts

@@ -27,6 +27,7 @@ export const renderer_requestedNeighborOffsets: (a: number, b: number, c: number
 export const renderer_setGlyphBudget: (a: number, b: number) => void;
 export const renderer_setStyle: (a: number, b: number, c: number) => [number, number, number];
 export const renderer_sourceTile: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+export const renderer_sources: (a: number) => [number, number, number];
 export const renderer_tileSize: (a: number) => number;
 export const simdEnabled: () => number;
 export const threadsEnabled: () => number;

package/simd/web/ezu.d.ts

@@ -273,6 +273,12 @@ export class Renderer {
      * before the next tile that needs it. `neededCodepoints()` already
      * 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
+     * `memoryUsage().glyphBudget` reports as `Infinity`. A number that
+     * big cannot be a real ceiling: it is every byte the module could
+     * ever address.
      */
     setGlyphBudget(bytes: number): void;
     /**
@@ -305,6 +311,30 @@ export class Renderer {
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
     sourceTile(name: string, z: number, x: number, y: number): any;
+    /**
+     * Every source the style declares, in declaration order, as an array
+     * of `{ name, type, tileScoped, url?, indexUrl? }`.
+     *
+     * This is what a host walks before it fetches anything: `type` is the
+     * style's own word for the kind (`"mvt"`, `"dem"`, `"glyphs"`, …) and
+     * says what `bindSource` will do with the bytes, and `url` is where
+     * they come from — an XYZ template for a tile pyramid, a document
+     * URL, or, for `glyphs`, the endpoint with `{fontstack}` already
+     * substituted and `{range}` left to fill in per block. `boundSources`
+     * answers the opposite question, what is already bound, and cannot
+     * start the loop.
+     *
+     * `tileScoped` says whether a binding of that kind is dropped by
+     * `clearSources` and has to be rebound for the next tile; the rest go
+     * into the persistent banks and are bound once.
+     *
+     * `url` is absent only for a `geojson` source with inline `data`: the
+     * style carries the payload, so there is nothing to fetch and nothing
+     * to bind. `indexUrl` appears on a `sprite` source whose index is a
+     * URL rather than inline — fetch it and pass the text as
+     * `bindSource(name, atlasBytes, { index })`.
+     */
+    sources(): Array<any>;
     /**
      * Effective attribution declared by the style (document +
      * sources), joined with ` | `. Upstream TileJSON / PMTiles
@@ -386,6 +416,7 @@ export interface InitOutput {
     readonly renderer_setGlyphBudget: (a: number, b: number) => void;
     readonly renderer_setStyle: (a: number, b: number, c: number) => [number, number, number];
     readonly renderer_sourceTile: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+    readonly renderer_sources: (a: number) => [number, number, number];
     readonly renderer_tileSize: (a: number) => number;
     readonly simdEnabled: () => number;
     readonly threadsEnabled: () => number;

package/simd/web/ezu.js

@@ -440,6 +440,12 @@ export class Renderer {
      * before the next tile that needs it. `neededCodepoints()` already
      * 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
+     * `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) {
@@ -498,6 +504,37 @@ export class Renderer {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Every source the style declares, in declaration order, as an array
+     * of `{ name, type, tileScoped, url?, indexUrl? }`.
+     *
+     * This is what a host walks before it fetches anything: `type` is the
+     * style's own word for the kind (`"mvt"`, `"dem"`, `"glyphs"`, …) and
+     * says what `bindSource` will do with the bytes, and `url` is where
+     * they come from — an XYZ template for a tile pyramid, a document
+     * URL, or, for `glyphs`, the endpoint with `{fontstack}` already
+     * substituted and `{range}` left to fill in per block. `boundSources`
+     * answers the opposite question, what is already bound, and cannot
+     * start the loop.
+     *
+     * `tileScoped` says whether a binding of that kind is dropped by
+     * `clearSources` and has to be rebound for the next tile; the rest go
+     * into the persistent banks and are bound once.
+     *
+     * `url` is absent only for a `geojson` source with inline `data`: the
+     * style carries the payload, so there is nothing to fetch and nothing
+     * to bind. `indexUrl` appears on a `sprite` source whose index is a
+     * URL rather than inline — fetch it and pass the text as
+     * `bindSource(name, atlasBytes, { index })`.
+     * @returns {Array<any>}
+     */
+    sources() {
+        const ret = wasm.renderer_sources(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * `tile-size` declared by the current style.
      * @returns {number}

package/simd/web/ezu_bg.wasm.d.ts

@@ -27,6 +27,7 @@ export const renderer_requestedNeighborOffsets: (a: number, b: number, c: number
 export const renderer_setGlyphBudget: (a: number, b: number) => void;
 export const renderer_setStyle: (a: number, b: number, c: number) => [number, number, number];
 export const renderer_sourceTile: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+export const renderer_sources: (a: number) => [number, number, number];
 export const renderer_tileSize: (a: number) => number;
 export const simdEnabled: () => number;
 export const threadsEnabled: () => number;

package/web/ezu.d.ts

@@ -273,6 +273,12 @@ export class Renderer {
      * before the next tile that needs it. `neededCodepoints()` already
      * 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
+     * `memoryUsage().glyphBudget` reports as `Infinity`. A number that
+     * big cannot be a real ceiling: it is every byte the module could
+     * ever address.
      */
     setGlyphBudget(bytes: number): void;
     /**
@@ -305,6 +311,30 @@ export class Renderer {
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
     sourceTile(name: string, z: number, x: number, y: number): any;
+    /**
+     * Every source the style declares, in declaration order, as an array
+     * of `{ name, type, tileScoped, url?, indexUrl? }`.
+     *
+     * This is what a host walks before it fetches anything: `type` is the
+     * style's own word for the kind (`"mvt"`, `"dem"`, `"glyphs"`, …) and
+     * says what `bindSource` will do with the bytes, and `url` is where
+     * they come from — an XYZ template for a tile pyramid, a document
+     * URL, or, for `glyphs`, the endpoint with `{fontstack}` already
+     * substituted and `{range}` left to fill in per block. `boundSources`
+     * answers the opposite question, what is already bound, and cannot
+     * start the loop.
+     *
+     * `tileScoped` says whether a binding of that kind is dropped by
+     * `clearSources` and has to be rebound for the next tile; the rest go
+     * into the persistent banks and are bound once.
+     *
+     * `url` is absent only for a `geojson` source with inline `data`: the
+     * style carries the payload, so there is nothing to fetch and nothing
+     * to bind. `indexUrl` appears on a `sprite` source whose index is a
+     * URL rather than inline — fetch it and pass the text as
+     * `bindSource(name, atlasBytes, { index })`.
+     */
+    sources(): Array<any>;
     /**
      * Effective attribution declared by the style (document +
      * sources), joined with ` | `. Upstream TileJSON / PMTiles
@@ -386,6 +416,7 @@ export interface InitOutput {
     readonly renderer_setGlyphBudget: (a: number, b: number) => void;
     readonly renderer_setStyle: (a: number, b: number, c: number) => [number, number, number];
     readonly renderer_sourceTile: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+    readonly renderer_sources: (a: number) => [number, number, number];
     readonly renderer_tileSize: (a: number) => number;
     readonly simdEnabled: () => number;
     readonly threadsEnabled: () => number;

package/web/ezu.js

@@ -440,6 +440,12 @@ export class Renderer {
      * before the next tile that needs it. `neededCodepoints()` already
      * 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
+     * `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) {
@@ -498,6 +504,37 @@ export class Renderer {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Every source the style declares, in declaration order, as an array
+     * of `{ name, type, tileScoped, url?, indexUrl? }`.
+     *
+     * This is what a host walks before it fetches anything: `type` is the
+     * style's own word for the kind (`"mvt"`, `"dem"`, `"glyphs"`, …) and
+     * says what `bindSource` will do with the bytes, and `url` is where
+     * they come from — an XYZ template for a tile pyramid, a document
+     * URL, or, for `glyphs`, the endpoint with `{fontstack}` already
+     * substituted and `{range}` left to fill in per block. `boundSources`
+     * answers the opposite question, what is already bound, and cannot
+     * start the loop.
+     *
+     * `tileScoped` says whether a binding of that kind is dropped by
+     * `clearSources` and has to be rebound for the next tile; the rest go
+     * into the persistent banks and are bound once.
+     *
+     * `url` is absent only for a `geojson` source with inline `data`: the
+     * style carries the payload, so there is nothing to fetch and nothing
+     * to bind. `indexUrl` appears on a `sprite` source whose index is a
+     * URL rather than inline — fetch it and pass the text as
+     * `bindSource(name, atlasBytes, { index })`.
+     * @returns {Array<any>}
+     */
+    sources() {
+        const ret = wasm.renderer_sources(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * `tile-size` declared by the current style.
      * @returns {number}

package/web/ezu_bg.wasm.d.ts

@@ -27,6 +27,7 @@ export const renderer_requestedNeighborOffsets: (a: number, b: number, c: number
 export const renderer_setGlyphBudget: (a: number, b: number) => void;
 export const renderer_setStyle: (a: number, b: number, c: number) => [number, number, number];
 export const renderer_sourceTile: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+export const renderer_sources: (a: number) => [number, number, number];
 export const renderer_tileSize: (a: number) => number;
 export const simdEnabled: () => number;
 export const threadsEnabled: () => number;