@reearth/ezu 0.8.0 → 0.8.2

package/bundler/ezu.d.ts

@@ -222,18 +222,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 +289,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

@@ -377,18 +377,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 +467,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

@@ -222,18 +222,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 +289,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

@@ -380,18 +380,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 +470,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.0",
+  "version": "0.8.2",
   "description": "Painterly map renderer — WebAssembly bindings",
   "license": "MIT OR Apache-2.0",
   "repository": {

package/simd/bundler/ezu.d.ts

@@ -222,18 +222,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 +289,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

@@ -377,18 +377,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 +467,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

@@ -222,18 +222,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 +289,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

@@ -380,18 +380,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 +470,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

@@ -222,18 +222,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 +289,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

@@ -379,18 +379,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 +469,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

@@ -222,18 +222,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 +289,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

@@ -379,18 +379,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 +469,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