@reearth/ezu 0.8.1 → 0.9.0

package/bundler/ezu.d.ts

@@ -197,6 +197,11 @@ export class Renderer {
      * 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.
+     *
+     * An Arabic letter contributes the presentation-form ranges as
+     * well as its own: it is drawn as whichever of its joined shapes
+     * the letters around it call for, and those shapes live in
+     * U+FB50‥U+FDFF and U+FE70‥U+FEFF.
      */
     neededGlyphRanges(): object;
     /**
@@ -222,18 +227,25 @@ export class Renderer {
      * `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.
+     * Cross-tile label collision and edge-continuous DEM/raster shading
+     * are the only things that read neighbours, and only for the sources
+     * they name. Pass each offset from this list to
+     * `bindSource(name, bytes, { coord })` and the render gets exactly
+     * what the recipe needs — neither a blind 3×3 per source nor, more
+     * costly, a window short of what a stitched source wanted. An empty
+     * array means the centre tile is enough.
      *
-     * A `dem` or `raster` source that declares `neighbor-fetch: false`
-     * reports no offsets whatever the graph asks for: the style has said
-     * not to stitch a neighbourhood for it, and this list is what a host
-     * fetches from.
+     * What comes back depends on the source's kind. A vector source
+     * answers from the graph: a node that wants a neighbour names it,
+     * and cross-tile label collision is usually the only thing that
+     * does, so the list is often empty. A `dem` or `raster` source
+     * answers from its own `neighbor-fetch`, which defaults to on and
+     * means the whole 3×3 — those bind as one stitched canvas, and a
+     * neighbour left unbound is not a missing collision candidate but a
+     * pad filled by clamping the tile's own edge, which shows up as a
+     * seam in whatever samples it. `neighbor-fetch: false` reports
+     * nothing whatever the graph asks for; so does a source no node in
+     * the graph reads.
      *
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
@@ -282,6 +294,14 @@ export class Renderer {
      * the maxzoom of each source keeps a second copy of something the style
      * already states, and the two drift.
      *
+     * `x` and `y` may be off the tile grid, which is what a host walking
+     * a neighbourhood hands in: `x` wraps around the antimeridian, so
+     * the western neighbour of `z/0/y` is the real tile at the far side
+     * of the world. `y` does not wrap — there is no tile above the north
+     * pole — and an out-of-range row comes back unchanged, so the fetch
+     * for it misses and the stitch clamps that edge, which is what the
+     * pole should look like.
+     *
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
     sourceTile(name: string, z: number, x: number, y: number): any;

package/bundler/ezu_bg.js

@@ -305,6 +305,11 @@ export class Renderer {
      * 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.
+     *
+     * An Arabic letter contributes the presentation-form ranges as
+     * well as its own: it is drawn as whichever of its joined shapes
+     * the letters around it call for, and those shapes live in
+     * U+FB50‥U+FDFF and U+FE70‥U+FEFF.
      * @returns {object}
      */
     neededGlyphRanges() {
@@ -377,18 +382,25 @@ export class Renderer {
      * `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.
+     * Cross-tile label collision and edge-continuous DEM/raster shading
+     * are the only things that read neighbours, and only for the sources
+     * they name. Pass each offset from this list to
+     * `bindSource(name, bytes, { coord })` and the render gets exactly
+     * what the recipe needs — neither a blind 3×3 per source nor, more
+     * costly, a window short of what a stitched source wanted. An empty
+     * array means the centre tile is enough.
      *
-     * A `dem` or `raster` source that declares `neighbor-fetch: false`
-     * reports no offsets whatever the graph asks for: the style has said
-     * not to stitch a neighbourhood for it, and this list is what a host
-     * fetches from.
+     * What comes back depends on the source's kind. A vector source
+     * answers from the graph: a node that wants a neighbour names it,
+     * and cross-tile label collision is usually the only thing that
+     * does, so the list is often empty. A `dem` or `raster` source
+     * answers from its own `neighbor-fetch`, which defaults to on and
+     * means the whole 3×3 — those bind as one stitched canvas, and a
+     * neighbour left unbound is not a missing collision candidate but a
+     * pad filled by clamping the tile's own edge, which shows up as a
+     * seam in whatever samples it. `neighbor-fetch: false` reports
+     * nothing whatever the graph asks for; so does a source no node in
+     * the graph reads.
      *
      * Throws `UnknownSource` if `name` is not declared in the style.
      * @param {string} name
@@ -460,6 +472,14 @@ export class Renderer {
      * the maxzoom of each source keeps a second copy of something the style
      * already states, and the two drift.
      *
+     * `x` and `y` may be off the tile grid, which is what a host walking
+     * a neighbourhood hands in: `x` wraps around the antimeridian, so
+     * the western neighbour of `z/0/y` is the real tile at the far side
+     * of the world. `y` does not wrap — there is no tile above the north
+     * pole — and an out-of-range row comes back unchanged, so the fetch
+     * for it misses and the stitch clamps that edge, which is what the
+     * pole should look like.
+     *
      * Throws `UnknownSource` if `name` is not declared in the style.
      * @param {string} name
      * @param {number} z

package/nodejs/ezu.d.ts

@@ -197,6 +197,11 @@ export class Renderer {
      * 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.
+     *
+     * An Arabic letter contributes the presentation-form ranges as
+     * well as its own: it is drawn as whichever of its joined shapes
+     * the letters around it call for, and those shapes live in
+     * U+FB50‥U+FDFF and U+FE70‥U+FEFF.
      */
     neededGlyphRanges(): object;
     /**
@@ -222,18 +227,25 @@ export class Renderer {
      * `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.
+     * Cross-tile label collision and edge-continuous DEM/raster shading
+     * are the only things that read neighbours, and only for the sources
+     * they name. Pass each offset from this list to
+     * `bindSource(name, bytes, { coord })` and the render gets exactly
+     * what the recipe needs — neither a blind 3×3 per source nor, more
+     * costly, a window short of what a stitched source wanted. An empty
+     * array means the centre tile is enough.
      *
-     * A `dem` or `raster` source that declares `neighbor-fetch: false`
-     * reports no offsets whatever the graph asks for: the style has said
-     * not to stitch a neighbourhood for it, and this list is what a host
-     * fetches from.
+     * What comes back depends on the source's kind. A vector source
+     * answers from the graph: a node that wants a neighbour names it,
+     * and cross-tile label collision is usually the only thing that
+     * does, so the list is often empty. A `dem` or `raster` source
+     * answers from its own `neighbor-fetch`, which defaults to on and
+     * means the whole 3×3 — those bind as one stitched canvas, and a
+     * neighbour left unbound is not a missing collision candidate but a
+     * pad filled by clamping the tile's own edge, which shows up as a
+     * seam in whatever samples it. `neighbor-fetch: false` reports
+     * nothing whatever the graph asks for; so does a source no node in
+     * the graph reads.
      *
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
@@ -282,6 +294,14 @@ export class Renderer {
      * the maxzoom of each source keeps a second copy of something the style
      * already states, and the two drift.
      *
+     * `x` and `y` may be off the tile grid, which is what a host walking
+     * a neighbourhood hands in: `x` wraps around the antimeridian, so
+     * the western neighbour of `z/0/y` is the real tile at the far side
+     * of the world. `y` does not wrap — there is no tile above the north
+     * pole — and an out-of-range row comes back unchanged, so the fetch
+     * for it misses and the stitch clamps that edge, which is what the
+     * pole should look like.
+     *
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
     sourceTile(name: string, z: number, x: number, y: number): any;

package/nodejs/ezu.js

@@ -308,6 +308,11 @@ class Renderer {
      * 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.
+     *
+     * An Arabic letter contributes the presentation-form ranges as
+     * well as its own: it is drawn as whichever of its joined shapes
+     * the letters around it call for, and those shapes live in
+     * U+FB50‥U+FDFF and U+FE70‥U+FEFF.
      * @returns {object}
      */
     neededGlyphRanges() {
@@ -380,18 +385,25 @@ class Renderer {
      * `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.
+     * Cross-tile label collision and edge-continuous DEM/raster shading
+     * are the only things that read neighbours, and only for the sources
+     * they name. Pass each offset from this list to
+     * `bindSource(name, bytes, { coord })` and the render gets exactly
+     * what the recipe needs — neither a blind 3×3 per source nor, more
+     * costly, a window short of what a stitched source wanted. An empty
+     * array means the centre tile is enough.
      *
-     * A `dem` or `raster` source that declares `neighbor-fetch: false`
-     * reports no offsets whatever the graph asks for: the style has said
-     * not to stitch a neighbourhood for it, and this list is what a host
-     * fetches from.
+     * What comes back depends on the source's kind. A vector source
+     * answers from the graph: a node that wants a neighbour names it,
+     * and cross-tile label collision is usually the only thing that
+     * does, so the list is often empty. A `dem` or `raster` source
+     * answers from its own `neighbor-fetch`, which defaults to on and
+     * means the whole 3×3 — those bind as one stitched canvas, and a
+     * neighbour left unbound is not a missing collision candidate but a
+     * pad filled by clamping the tile's own edge, which shows up as a
+     * seam in whatever samples it. `neighbor-fetch: false` reports
+     * nothing whatever the graph asks for; so does a source no node in
+     * the graph reads.
      *
      * Throws `UnknownSource` if `name` is not declared in the style.
      * @param {string} name
@@ -463,6 +475,14 @@ class Renderer {
      * the maxzoom of each source keeps a second copy of something the style
      * already states, and the two drift.
      *
+     * `x` and `y` may be off the tile grid, which is what a host walking
+     * a neighbourhood hands in: `x` wraps around the antimeridian, so
+     * the western neighbour of `z/0/y` is the real tile at the far side
+     * of the world. `y` does not wrap — there is no tile above the north
+     * pole — and an out-of-range row comes back unchanged, so the fetch
+     * for it misses and the stitch clamps that edge, which is what the
+     * pole should look like.
+     *
      * Throws `UnknownSource` if `name` is not declared in the style.
      * @param {string} name
      * @param {number} z

package/package.json

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

package/simd/bundler/ezu.d.ts

@@ -197,6 +197,11 @@ export class Renderer {
      * 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.
+     *
+     * An Arabic letter contributes the presentation-form ranges as
+     * well as its own: it is drawn as whichever of its joined shapes
+     * the letters around it call for, and those shapes live in
+     * U+FB50‥U+FDFF and U+FE70‥U+FEFF.
      */
     neededGlyphRanges(): object;
     /**
@@ -222,18 +227,25 @@ export class Renderer {
      * `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.
+     * Cross-tile label collision and edge-continuous DEM/raster shading
+     * are the only things that read neighbours, and only for the sources
+     * they name. Pass each offset from this list to
+     * `bindSource(name, bytes, { coord })` and the render gets exactly
+     * what the recipe needs — neither a blind 3×3 per source nor, more
+     * costly, a window short of what a stitched source wanted. An empty
+     * array means the centre tile is enough.
      *
-     * A `dem` or `raster` source that declares `neighbor-fetch: false`
-     * reports no offsets whatever the graph asks for: the style has said
-     * not to stitch a neighbourhood for it, and this list is what a host
-     * fetches from.
+     * What comes back depends on the source's kind. A vector source
+     * answers from the graph: a node that wants a neighbour names it,
+     * and cross-tile label collision is usually the only thing that
+     * does, so the list is often empty. A `dem` or `raster` source
+     * answers from its own `neighbor-fetch`, which defaults to on and
+     * means the whole 3×3 — those bind as one stitched canvas, and a
+     * neighbour left unbound is not a missing collision candidate but a
+     * pad filled by clamping the tile's own edge, which shows up as a
+     * seam in whatever samples it. `neighbor-fetch: false` reports
+     * nothing whatever the graph asks for; so does a source no node in
+     * the graph reads.
      *
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
@@ -282,6 +294,14 @@ export class Renderer {
      * the maxzoom of each source keeps a second copy of something the style
      * already states, and the two drift.
      *
+     * `x` and `y` may be off the tile grid, which is what a host walking
+     * a neighbourhood hands in: `x` wraps around the antimeridian, so
+     * the western neighbour of `z/0/y` is the real tile at the far side
+     * of the world. `y` does not wrap — there is no tile above the north
+     * pole — and an out-of-range row comes back unchanged, so the fetch
+     * for it misses and the stitch clamps that edge, which is what the
+     * pole should look like.
+     *
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
     sourceTile(name: string, z: number, x: number, y: number): any;

package/simd/bundler/ezu_bg.js

@@ -305,6 +305,11 @@ export class Renderer {
      * 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.
+     *
+     * An Arabic letter contributes the presentation-form ranges as
+     * well as its own: it is drawn as whichever of its joined shapes
+     * the letters around it call for, and those shapes live in
+     * U+FB50‥U+FDFF and U+FE70‥U+FEFF.
      * @returns {object}
      */
     neededGlyphRanges() {
@@ -377,18 +382,25 @@ export class Renderer {
      * `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.
+     * Cross-tile label collision and edge-continuous DEM/raster shading
+     * are the only things that read neighbours, and only for the sources
+     * they name. Pass each offset from this list to
+     * `bindSource(name, bytes, { coord })` and the render gets exactly
+     * what the recipe needs — neither a blind 3×3 per source nor, more
+     * costly, a window short of what a stitched source wanted. An empty
+     * array means the centre tile is enough.
      *
-     * A `dem` or `raster` source that declares `neighbor-fetch: false`
-     * reports no offsets whatever the graph asks for: the style has said
-     * not to stitch a neighbourhood for it, and this list is what a host
-     * fetches from.
+     * What comes back depends on the source's kind. A vector source
+     * answers from the graph: a node that wants a neighbour names it,
+     * and cross-tile label collision is usually the only thing that
+     * does, so the list is often empty. A `dem` or `raster` source
+     * answers from its own `neighbor-fetch`, which defaults to on and
+     * means the whole 3×3 — those bind as one stitched canvas, and a
+     * neighbour left unbound is not a missing collision candidate but a
+     * pad filled by clamping the tile's own edge, which shows up as a
+     * seam in whatever samples it. `neighbor-fetch: false` reports
+     * nothing whatever the graph asks for; so does a source no node in
+     * the graph reads.
      *
      * Throws `UnknownSource` if `name` is not declared in the style.
      * @param {string} name
@@ -460,6 +472,14 @@ export class Renderer {
      * the maxzoom of each source keeps a second copy of something the style
      * already states, and the two drift.
      *
+     * `x` and `y` may be off the tile grid, which is what a host walking
+     * a neighbourhood hands in: `x` wraps around the antimeridian, so
+     * the western neighbour of `z/0/y` is the real tile at the far side
+     * of the world. `y` does not wrap — there is no tile above the north
+     * pole — and an out-of-range row comes back unchanged, so the fetch
+     * for it misses and the stitch clamps that edge, which is what the
+     * pole should look like.
+     *
      * Throws `UnknownSource` if `name` is not declared in the style.
      * @param {string} name
      * @param {number} z

package/simd/nodejs/ezu.d.ts

@@ -197,6 +197,11 @@ export class Renderer {
      * 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.
+     *
+     * An Arabic letter contributes the presentation-form ranges as
+     * well as its own: it is drawn as whichever of its joined shapes
+     * the letters around it call for, and those shapes live in
+     * U+FB50‥U+FDFF and U+FE70‥U+FEFF.
      */
     neededGlyphRanges(): object;
     /**
@@ -222,18 +227,25 @@ export class Renderer {
      * `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.
+     * Cross-tile label collision and edge-continuous DEM/raster shading
+     * are the only things that read neighbours, and only for the sources
+     * they name. Pass each offset from this list to
+     * `bindSource(name, bytes, { coord })` and the render gets exactly
+     * what the recipe needs — neither a blind 3×3 per source nor, more
+     * costly, a window short of what a stitched source wanted. An empty
+     * array means the centre tile is enough.
      *
-     * A `dem` or `raster` source that declares `neighbor-fetch: false`
-     * reports no offsets whatever the graph asks for: the style has said
-     * not to stitch a neighbourhood for it, and this list is what a host
-     * fetches from.
+     * What comes back depends on the source's kind. A vector source
+     * answers from the graph: a node that wants a neighbour names it,
+     * and cross-tile label collision is usually the only thing that
+     * does, so the list is often empty. A `dem` or `raster` source
+     * answers from its own `neighbor-fetch`, which defaults to on and
+     * means the whole 3×3 — those bind as one stitched canvas, and a
+     * neighbour left unbound is not a missing collision candidate but a
+     * pad filled by clamping the tile's own edge, which shows up as a
+     * seam in whatever samples it. `neighbor-fetch: false` reports
+     * nothing whatever the graph asks for; so does a source no node in
+     * the graph reads.
      *
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
@@ -282,6 +294,14 @@ export class Renderer {
      * the maxzoom of each source keeps a second copy of something the style
      * already states, and the two drift.
      *
+     * `x` and `y` may be off the tile grid, which is what a host walking
+     * a neighbourhood hands in: `x` wraps around the antimeridian, so
+     * the western neighbour of `z/0/y` is the real tile at the far side
+     * of the world. `y` does not wrap — there is no tile above the north
+     * pole — and an out-of-range row comes back unchanged, so the fetch
+     * for it misses and the stitch clamps that edge, which is what the
+     * pole should look like.
+     *
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
     sourceTile(name: string, z: number, x: number, y: number): any;

package/simd/nodejs/ezu.js

@@ -308,6 +308,11 @@ class Renderer {
      * 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.
+     *
+     * An Arabic letter contributes the presentation-form ranges as
+     * well as its own: it is drawn as whichever of its joined shapes
+     * the letters around it call for, and those shapes live in
+     * U+FB50‥U+FDFF and U+FE70‥U+FEFF.
      * @returns {object}
      */
     neededGlyphRanges() {
@@ -380,18 +385,25 @@ class Renderer {
      * `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.
+     * Cross-tile label collision and edge-continuous DEM/raster shading
+     * are the only things that read neighbours, and only for the sources
+     * they name. Pass each offset from this list to
+     * `bindSource(name, bytes, { coord })` and the render gets exactly
+     * what the recipe needs — neither a blind 3×3 per source nor, more
+     * costly, a window short of what a stitched source wanted. An empty
+     * array means the centre tile is enough.
      *
-     * A `dem` or `raster` source that declares `neighbor-fetch: false`
-     * reports no offsets whatever the graph asks for: the style has said
-     * not to stitch a neighbourhood for it, and this list is what a host
-     * fetches from.
+     * What comes back depends on the source's kind. A vector source
+     * answers from the graph: a node that wants a neighbour names it,
+     * and cross-tile label collision is usually the only thing that
+     * does, so the list is often empty. A `dem` or `raster` source
+     * answers from its own `neighbor-fetch`, which defaults to on and
+     * means the whole 3×3 — those bind as one stitched canvas, and a
+     * neighbour left unbound is not a missing collision candidate but a
+     * pad filled by clamping the tile's own edge, which shows up as a
+     * seam in whatever samples it. `neighbor-fetch: false` reports
+     * nothing whatever the graph asks for; so does a source no node in
+     * the graph reads.
      *
      * Throws `UnknownSource` if `name` is not declared in the style.
      * @param {string} name
@@ -463,6 +475,14 @@ class Renderer {
      * the maxzoom of each source keeps a second copy of something the style
      * already states, and the two drift.
      *
+     * `x` and `y` may be off the tile grid, which is what a host walking
+     * a neighbourhood hands in: `x` wraps around the antimeridian, so
+     * the western neighbour of `z/0/y` is the real tile at the far side
+     * of the world. `y` does not wrap — there is no tile above the north
+     * pole — and an out-of-range row comes back unchanged, so the fetch
+     * for it misses and the stitch clamps that edge, which is what the
+     * pole should look like.
+     *
      * Throws `UnknownSource` if `name` is not declared in the style.
      * @param {string} name
      * @param {number} z

package/simd/web/ezu.d.ts

@@ -197,6 +197,11 @@ export class Renderer {
      * 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.
+     *
+     * An Arabic letter contributes the presentation-form ranges as
+     * well as its own: it is drawn as whichever of its joined shapes
+     * the letters around it call for, and those shapes live in
+     * U+FB50‥U+FDFF and U+FE70‥U+FEFF.
      */
     neededGlyphRanges(): object;
     /**
@@ -222,18 +227,25 @@ export class Renderer {
      * `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.
+     * Cross-tile label collision and edge-continuous DEM/raster shading
+     * are the only things that read neighbours, and only for the sources
+     * they name. Pass each offset from this list to
+     * `bindSource(name, bytes, { coord })` and the render gets exactly
+     * what the recipe needs — neither a blind 3×3 per source nor, more
+     * costly, a window short of what a stitched source wanted. An empty
+     * array means the centre tile is enough.
      *
-     * A `dem` or `raster` source that declares `neighbor-fetch: false`
-     * reports no offsets whatever the graph asks for: the style has said
-     * not to stitch a neighbourhood for it, and this list is what a host
-     * fetches from.
+     * What comes back depends on the source's kind. A vector source
+     * answers from the graph: a node that wants a neighbour names it,
+     * and cross-tile label collision is usually the only thing that
+     * does, so the list is often empty. A `dem` or `raster` source
+     * answers from its own `neighbor-fetch`, which defaults to on and
+     * means the whole 3×3 — those bind as one stitched canvas, and a
+     * neighbour left unbound is not a missing collision candidate but a
+     * pad filled by clamping the tile's own edge, which shows up as a
+     * seam in whatever samples it. `neighbor-fetch: false` reports
+     * nothing whatever the graph asks for; so does a source no node in
+     * the graph reads.
      *
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
@@ -282,6 +294,14 @@ export class Renderer {
      * the maxzoom of each source keeps a second copy of something the style
      * already states, and the two drift.
      *
+     * `x` and `y` may be off the tile grid, which is what a host walking
+     * a neighbourhood hands in: `x` wraps around the antimeridian, so
+     * the western neighbour of `z/0/y` is the real tile at the far side
+     * of the world. `y` does not wrap — there is no tile above the north
+     * pole — and an out-of-range row comes back unchanged, so the fetch
+     * for it misses and the stitch clamps that edge, which is what the
+     * pole should look like.
+     *
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
     sourceTile(name: string, z: number, x: number, y: number): any;

package/simd/web/ezu.js

@@ -307,6 +307,11 @@ export class Renderer {
      * 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.
+     *
+     * An Arabic letter contributes the presentation-form ranges as
+     * well as its own: it is drawn as whichever of its joined shapes
+     * the letters around it call for, and those shapes live in
+     * U+FB50‥U+FDFF and U+FE70‥U+FEFF.
      * @returns {object}
      */
     neededGlyphRanges() {
@@ -379,18 +384,25 @@ export class Renderer {
      * `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.
+     * Cross-tile label collision and edge-continuous DEM/raster shading
+     * are the only things that read neighbours, and only for the sources
+     * they name. Pass each offset from this list to
+     * `bindSource(name, bytes, { coord })` and the render gets exactly
+     * what the recipe needs — neither a blind 3×3 per source nor, more
+     * costly, a window short of what a stitched source wanted. An empty
+     * array means the centre tile is enough.
      *
-     * A `dem` or `raster` source that declares `neighbor-fetch: false`
-     * reports no offsets whatever the graph asks for: the style has said
-     * not to stitch a neighbourhood for it, and this list is what a host
-     * fetches from.
+     * What comes back depends on the source's kind. A vector source
+     * answers from the graph: a node that wants a neighbour names it,
+     * and cross-tile label collision is usually the only thing that
+     * does, so the list is often empty. A `dem` or `raster` source
+     * answers from its own `neighbor-fetch`, which defaults to on and
+     * means the whole 3×3 — those bind as one stitched canvas, and a
+     * neighbour left unbound is not a missing collision candidate but a
+     * pad filled by clamping the tile's own edge, which shows up as a
+     * seam in whatever samples it. `neighbor-fetch: false` reports
+     * nothing whatever the graph asks for; so does a source no node in
+     * the graph reads.
      *
      * Throws `UnknownSource` if `name` is not declared in the style.
      * @param {string} name
@@ -462,6 +474,14 @@ export class Renderer {
      * the maxzoom of each source keeps a second copy of something the style
      * already states, and the two drift.
      *
+     * `x` and `y` may be off the tile grid, which is what a host walking
+     * a neighbourhood hands in: `x` wraps around the antimeridian, so
+     * the western neighbour of `z/0/y` is the real tile at the far side
+     * of the world. `y` does not wrap — there is no tile above the north
+     * pole — and an out-of-range row comes back unchanged, so the fetch
+     * for it misses and the stitch clamps that edge, which is what the
+     * pole should look like.
+     *
      * Throws `UnknownSource` if `name` is not declared in the style.
      * @param {string} name
      * @param {number} z

package/web/ezu.d.ts

@@ -197,6 +197,11 @@ export class Renderer {
      * 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.
+     *
+     * An Arabic letter contributes the presentation-form ranges as
+     * well as its own: it is drawn as whichever of its joined shapes
+     * the letters around it call for, and those shapes live in
+     * U+FB50‥U+FDFF and U+FE70‥U+FEFF.
      */
     neededGlyphRanges(): object;
     /**
@@ -222,18 +227,25 @@ export class Renderer {
      * `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.
+     * Cross-tile label collision and edge-continuous DEM/raster shading
+     * are the only things that read neighbours, and only for the sources
+     * they name. Pass each offset from this list to
+     * `bindSource(name, bytes, { coord })` and the render gets exactly
+     * what the recipe needs — neither a blind 3×3 per source nor, more
+     * costly, a window short of what a stitched source wanted. An empty
+     * array means the centre tile is enough.
      *
-     * A `dem` or `raster` source that declares `neighbor-fetch: false`
-     * reports no offsets whatever the graph asks for: the style has said
-     * not to stitch a neighbourhood for it, and this list is what a host
-     * fetches from.
+     * What comes back depends on the source's kind. A vector source
+     * answers from the graph: a node that wants a neighbour names it,
+     * and cross-tile label collision is usually the only thing that
+     * does, so the list is often empty. A `dem` or `raster` source
+     * answers from its own `neighbor-fetch`, which defaults to on and
+     * means the whole 3×3 — those bind as one stitched canvas, and a
+     * neighbour left unbound is not a missing collision candidate but a
+     * pad filled by clamping the tile's own edge, which shows up as a
+     * seam in whatever samples it. `neighbor-fetch: false` reports
+     * nothing whatever the graph asks for; so does a source no node in
+     * the graph reads.
      *
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
@@ -282,6 +294,14 @@ export class Renderer {
      * the maxzoom of each source keeps a second copy of something the style
      * already states, and the two drift.
      *
+     * `x` and `y` may be off the tile grid, which is what a host walking
+     * a neighbourhood hands in: `x` wraps around the antimeridian, so
+     * the western neighbour of `z/0/y` is the real tile at the far side
+     * of the world. `y` does not wrap — there is no tile above the north
+     * pole — and an out-of-range row comes back unchanged, so the fetch
+     * for it misses and the stitch clamps that edge, which is what the
+     * pole should look like.
+     *
      * Throws `UnknownSource` if `name` is not declared in the style.
      */
     sourceTile(name: string, z: number, x: number, y: number): any;

package/web/ezu.js

@@ -307,6 +307,11 @@ export class Renderer {
      * 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.
+     *
+     * An Arabic letter contributes the presentation-form ranges as
+     * well as its own: it is drawn as whichever of its joined shapes
+     * the letters around it call for, and those shapes live in
+     * U+FB50‥U+FDFF and U+FE70‥U+FEFF.
      * @returns {object}
      */
     neededGlyphRanges() {
@@ -379,18 +384,25 @@ export class Renderer {
      * `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.
+     * Cross-tile label collision and edge-continuous DEM/raster shading
+     * are the only things that read neighbours, and only for the sources
+     * they name. Pass each offset from this list to
+     * `bindSource(name, bytes, { coord })` and the render gets exactly
+     * what the recipe needs — neither a blind 3×3 per source nor, more
+     * costly, a window short of what a stitched source wanted. An empty
+     * array means the centre tile is enough.
      *
-     * A `dem` or `raster` source that declares `neighbor-fetch: false`
-     * reports no offsets whatever the graph asks for: the style has said
-     * not to stitch a neighbourhood for it, and this list is what a host
-     * fetches from.
+     * What comes back depends on the source's kind. A vector source
+     * answers from the graph: a node that wants a neighbour names it,
+     * and cross-tile label collision is usually the only thing that
+     * does, so the list is often empty. A `dem` or `raster` source
+     * answers from its own `neighbor-fetch`, which defaults to on and
+     * means the whole 3×3 — those bind as one stitched canvas, and a
+     * neighbour left unbound is not a missing collision candidate but a
+     * pad filled by clamping the tile's own edge, which shows up as a
+     * seam in whatever samples it. `neighbor-fetch: false` reports
+     * nothing whatever the graph asks for; so does a source no node in
+     * the graph reads.
      *
      * Throws `UnknownSource` if `name` is not declared in the style.
      * @param {string} name
@@ -462,6 +474,14 @@ export class Renderer {
      * the maxzoom of each source keeps a second copy of something the style
      * already states, and the two drift.
      *
+     * `x` and `y` may be off the tile grid, which is what a host walking
+     * a neighbourhood hands in: `x` wraps around the antimeridian, so
+     * the western neighbour of `z/0/y` is the real tile at the far side
+     * of the world. `y` does not wrap — there is no tile above the north
+     * pole — and an out-of-range row comes back unchanged, so the fetch
+     * for it misses and the stitch clamps that edge, which is what the
+     * pole should look like.
+     *
      * Throws `UnknownSource` if `name` is not declared in the style.
      * @param {string} name
      * @param {number} z