@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/view/renderers/polygon/triangulator.d.ts

@@ -7,7 +7,7 @@
  *
  * Triangulating a huge polygon (a water body on the order of a million vertices)
  * takes more than ten seconds in one go, so the dataset path injects
- * an implementation that slices the work over time (display/triangulation.ts) here.
+ * an implementation that slices the work over time (dataset/triangulation.ts) here.
  * For a polygon whose triangulation has not finished yet, null is returned, and the
  * caller omits the fill of that polygon and puts it into the batch with the outline
  * only. Once the triangulation finishes, the injecting side prompts a rebuild.

package/dist/view/renderers/stroke.js

@@ -159,7 +159,9 @@ export class StrokeRenderer {
         this.gl = gl;
         this.pixelRatio = pixelRatio;
         this.terrain = terrain;
-        this.projectionUniformManager = new ProjectionUniformManager(gl, { surface: true, terrain });
+        this.projectionUniformManager = new ProjectionUniformManager(gl, {
+            surface: true,
+        }).useTerrainState(terrain);
         this.vertexBuffer = gl.createBuffer();
         this.vao = gl.createVertexArray();
         this.setupVAO();

package/dist/view/shaders/helpers.d.ts

@@ -4,23 +4,13 @@
  * Utilities for creating and managing WebGL2 shaders
  * Performs the WGS84 -> Mercator -> clip coordinate conversion on the GPU
  */
+import type { OffsetUniforms, ShaderData } from '../../api/extension/render.js';
+export type { OffsetUniforms, ShaderData };
 /**
  * Converts WGS84 coordinates to Mercator coordinates (high precision
  * computation on the CPU side)
  */
 export declare function lngLatToMercator(lng: number, lat: number): [number, number];
-/**
- * The shader prelude maplibre passes to the `prerender` / `render` of a custom layer, which
- * the renderers of this library take to compile their programs for the current projection.
- */
-export interface ShaderData {
-    /** The GLSL maplibre prepends to a vertex shader (its projection functions) */
-    vertexShaderPrelude: string;
-    /** The `#define` lines of the current projection */
-    define: string;
-    /** The name of the projection variant; a program is recompiled when it changes */
-    variantName: string;
-}
 /**
  * The precision every sampler of the engine is read with
  *
@@ -153,36 +143,6 @@ export declare function calculateOffsetUniforms(centerLngLat: [number, number],
  * @returns The translated matrix (64-bit values)
  */
 export declare function translateMatrixByLongitude(matrix: ArrayLike<number>, lngShift: number): number[];
-/**
- * The uniform values for offset mode
- *
- * The uniforms for globe mode are obtained directly from ProjectionData, so
- * this interface contains only the values needed for the offset computation of
- * the Mercator projection.
- */
-export interface OffsetUniforms {
-    /** The center coordinates (rounded to Float32, for sending to the shader) */
-    centerLngLat: [number, number];
-    /** The center coordinates (64-bit precision, for the offset computation on the CPU side) */
-    centerLngLat64: [number, number];
-    /**
-     * The Mercator coordinates of the center (a value computed at 64-bit
-     * precision)
-     *
-     * Used to restore the Mercator relative coordinates of a vertex to absolute
-     * coordinates when looking up the terrain DEM atlas. So that everything can
-     * be handled relatively, the atlas origin is also handed over relative to
-     * this value (absolute Mercator coordinates do not have enough digits in
-     * Float32).
-     */
-    centerMercator: [number, number];
-    /** The view center in clip space, computed at 64-bit precision */
-    projectionCenter: [number, number, number, number];
-    /** The Mercator units per degree of longitude and latitude at the center */
-    unitsPerDegree: [number, number, number];
-    /** The second-order correction of `unitsPerDegree` for the change with latitude */
-    unitsPerDegree2: [number, number, number];
-}
 /**
  * Returns a position relative to the view center in degrees, computed at 64-bit precision
  * so that it survives Float32.

package/dist/view/shaders/helpers.js

@@ -1,11 +1,5 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only AND MIT
-/**
- * Shader helpers
- *
- * Utilities for creating and managing WebGL2 shaders
- * Performs the WGS84 -> Mercator -> clip coordinate conversion on the GPU
- */
 /**
  * Converts WGS84 coordinates to Mercator coordinates (high precision
  * computation on the CPU side)

package/dist/view/shaders/projection.d.ts

@@ -6,7 +6,8 @@
  * each renderer.
  */
 import type { ProjectionData } from 'maplibre-gl';
-import type { TerrainContext } from '../terrain/context.js';
+import type { TerrainAnchors } from '../../api/extension/context.js';
+import type { RenderContext } from '../../api/extension/render.js';
 import type { OffsetUniforms } from './helpers.js';
 /**
  * The locations of the projection and terrain uniforms of one program, as
@@ -81,19 +82,26 @@ export declare class ProjectionUniformManager {
     /**
      * The terrain state of the draw instance being drawn (null draws without terrain)
      *
-     * The renderers of a CustomLayer pass their instance's context at construction. A renderer
-     * of an extension implementation, which may be shared between draw instances, calls
-     * `setTerrain(context.terrain)` with the context it receives in each draw call.
+     * The renderers of a CustomLayer bind their instance's state after construction. A renderer
+     * of an extension, which may be shared between draw instances, calls `setTerrain(ctx)` with
+     * the render context it receives in each draw call.
      */
     private terrain;
+    /**
+     * @param gl - The WebGL context of the map
+     * @param options - `surface`: whether the renderer draws things stuck to the ground (areas
+     *   and lines), which lie flat on the frames that draw them flat
+     */
     constructor(gl: WebGL2RenderingContext, options?: {
         surface?: boolean;
-        terrain?: TerrainContext | null;
     });
     /**
-     * Sets the terrain state the next uniforms are taken from (null draws without terrain)
+     * Sets the terrain the next uniforms are taken from.
+     *
+     * @param terrain - The render context of the draw call, or its `terrain`; `null` (or an
+     *   object the engine did not hand out) draws without terrain
      */
-    setTerrain(terrain: TerrainContext | null): void;
+    setTerrain(terrain: RenderContext | TerrainAnchors | null): void;
     /**
      * Obtains the uniform locations from a program
      *

package/dist/view/shaders/projection.js

@@ -1,5 +1,6 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
+import { terrainStateOf } from '../terrain/binding.js';
 import { INACTIVE_TERRAIN_STATE, TERRAIN_ATLAS_TEXTURE_UNIT, } from '../terrain/state.js';
 import { getRenderFrame } from './frame.js';
 /**
@@ -29,6 +30,11 @@ function createMemo() {
  * A class that manages the projection-related uniforms in one place
  */
 export class ProjectionUniformManager {
+    /**
+     * @param gl - The WebGL context of the map
+     * @param options - `surface`: whether the renderer draws things stuck to the ground (areas
+     *   and lines), which lie flat on the frames that draw them flat
+     */
     constructor(gl, options = {}) {
         Object.defineProperty(this, "gl", {
             enumerable: true,
@@ -68,25 +74,36 @@ export class ProjectionUniformManager {
         /**
          * The terrain state of the draw instance being drawn (null draws without terrain)
          *
-         * The renderers of a CustomLayer pass their instance's context at construction. A renderer
-         * of an extension implementation, which may be shared between draw instances, calls
-         * `setTerrain(context.terrain)` with the context it receives in each draw call.
+         * The renderers of a CustomLayer bind their instance's state after construction. A renderer
+         * of an extension, which may be shared between draw instances, calls `setTerrain(ctx)` with
+         * the render context it receives in each draw call.
          */
         Object.defineProperty(this, "terrain", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: null
         });
         this.gl = gl;
         this.surface = options.surface === true;
-        this.terrain = options.terrain ?? null;
     }
     /**
-     * Sets the terrain state the next uniforms are taken from (null draws without terrain)
+     * Sets the terrain the next uniforms are taken from.
+     *
+     * @param terrain - The render context of the draw call, or its `terrain`; `null` (or an
+     *   object the engine did not hand out) draws without terrain
      */
     setTerrain(terrain) {
+        this.terrain = terrainStateOf(terrain);
+    }
+    /**
+     * Sets the terrain state of an instance directly
+     *
+     * @internal
+     */
+    useTerrainState(terrain) {
         this.terrain = terrain;
+        return this;
     }
     /**
      * Obtains the uniform locations from a program

package/dist/view/shaders/quad.d.ts

@@ -22,7 +22,8 @@
  *    quad follows the sphere the way maplibre's layers do
  */
 import type { ProjectionData } from 'maplibre-gl';
-import type { TerrainContext } from '../terrain/context.js';
+import type { TerrainAnchors } from '../../api/extension/context.js';
+import type { RenderContext } from '../../api/extension/render.js';
 import type { DrapeQuadCorners, QuadDrapeSurface } from '../terrain/drape/quad.js';
 import type { OffsetUniforms } from './helpers.js';
 /**
@@ -72,15 +73,19 @@ export declare class QuadShader {
     /**
      * The terrain state of the draw instance being drawn (null draws without terrain)
      *
-     * The CustomLayer passes its instance's context at construction. An extension renderer that
-     * owns a QuadShader calls `setTerrain(context.terrain)` with the draw context it receives.
+     * The CustomLayer binds its instance's state after construction. An extension renderer that
+     * owns a QuadShader calls `setTerrain(ctx)` with the render context it receives.
      */
     private terrain;
-    constructor(gl: WebGL2RenderingContext, terrain?: TerrainContext | null);
+    /** @param gl - The WebGL context of the map */
+    constructor(gl: WebGL2RenderingContext);
     /**
-     * Sets the terrain state the next draws use (null draws without terrain)
+     * Sets the terrain the next draws use.
+     *
+     * @param terrain - The render context of the draw call, or its `terrain`; `null` (or an
+     *   object the engine did not hand out) draws without terrain
      */
-    setTerrain(terrain: TerrainContext | null): void;
+    setTerrain(terrain: RenderContext | TerrainAnchors | null): void;
     /**
      * Initializes the buffers
      */
@@ -164,14 +169,13 @@ export declare class QuadShader {
  * cannot be built). The caller falls back to the conventional way of drawing
  * (the fill texture + a separate draw of the text).
  *
- * @param terrain The terrain state of the draw instance being drawn
- *   (`CustomRendererDrawContext.terrain`)
- * @param corners The corners of the quad in degrees
- * @param surface The fill and the text
- * @param opacity The opacity, 0..1
+ * @param terrain - The render context of the draw call, or its `terrain`
+ * @param corners - The corners of the quad in degrees
+ * @param surface - The fill and the text
+ * @param opacity - The opacity, 0..1
  * @returns true if it was painted; false when the caller must draw it another way
  */
-export declare function drawQuadSurfaceOnTerrain(terrain: TerrainContext, corners: DrapeQuadCorners, surface: QuadDrapeSurface, opacity: number): boolean;
+export declare function drawQuadSurfaceOnTerrain(terrain: RenderContext | TerrainAnchors, corners: DrapeQuadCorners, surface: QuadDrapeSurface, opacity: number): boolean;
 /**
  * Returns the corners of a rectangle of a size in degrees, rotated about its center.
  *

package/dist/view/shaders/quad.js

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
 import { globeGridOf } from '../globe-subdivision.js';
+import { terrainStateOf } from '../terrain/binding.js';
 import { quadMercatorCorners } from '../terrain/drape/quad.js';
 import { getQuadDrapeFrame, isTerrainElevationActive, reportTerrainCoarsening, } from '../terrain/state.js';
 import { calculateLngLatOffset, createProgram, getProjectionTransitionUniform, OFFSET_MODE_GLSL, } from './helpers.js';
@@ -15,7 +16,8 @@ import { buildQuadGrid, computeQuadGridSize, } from './quad-grid.js';
  * subdivided to the terrain mesh.
  */
 export class QuadShader {
-    constructor(gl, terrain = null) {
+    /** @param gl - The WebGL context of the map */
+    constructor(gl) {
         Object.defineProperty(this, "gl", {
             enumerable: true,
             configurable: true,
@@ -134,26 +136,37 @@ export class QuadShader {
         /**
          * The terrain state of the draw instance being drawn (null draws without terrain)
          *
-         * The CustomLayer passes its instance's context at construction. An extension renderer that
-         * owns a QuadShader calls `setTerrain(context.terrain)` with the draw context it receives.
+         * The CustomLayer binds its instance's state after construction. An extension renderer that
+         * owns a QuadShader calls `setTerrain(ctx)` with the render context it receives.
          */
         Object.defineProperty(this, "terrain", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: null
         });
         this.gl = gl;
-        this.terrain = terrain;
-        this.projectionUniformManager = new ProjectionUniformManager(gl, { terrain });
+        this.projectionUniformManager = new ProjectionUniformManager(gl);
         this.setupBuffers();
     }
     /**
-     * Sets the terrain state the next draws use (null draws without terrain)
+     * Sets the terrain the next draws use.
+     *
+     * @param terrain - The render context of the draw call, or its `terrain`; `null` (or an
+     *   object the engine did not hand out) draws without terrain
      */
     setTerrain(terrain) {
+        this.useTerrainState(terrainStateOf(terrain));
+    }
+    /**
+     * Sets the terrain state of an instance directly
+     *
+     * @internal
+     */
+    useTerrainState(terrain) {
         this.terrain = terrain;
-        this.projectionUniformManager.setTerrain(terrain);
+        this.projectionUniformManager.useTerrainState(terrain);
+        return this;
     }
     /**
      * Initializes the buffers
@@ -491,14 +504,22 @@ void main() {
  * cannot be built). The caller falls back to the conventional way of drawing
  * (the fill texture + a separate draw of the text).
  *
- * @param terrain The terrain state of the draw instance being drawn
- *   (`CustomRendererDrawContext.terrain`)
- * @param corners The corners of the quad in degrees
- * @param surface The fill and the text
- * @param opacity The opacity, 0..1
+ * @param terrain - The render context of the draw call, or its `terrain`
+ * @param corners - The corners of the quad in degrees
+ * @param surface - The fill and the text
+ * @param opacity - The opacity, 0..1
  * @returns true if it was painted; false when the caller must draw it another way
  */
 export function drawQuadSurfaceOnTerrain(terrain, corners, surface, opacity) {
+    const state = terrainStateOf(terrain);
+    return state !== null && drawQuadSurfaceOnTerrainState(state, corners, surface, opacity);
+}
+/**
+ * {@link drawQuadSurfaceOnTerrain} over the terrain state of an instance
+ *
+ * @internal
+ */
+export function drawQuadSurfaceOnTerrainState(terrain, corners, surface, opacity) {
     if (!isTerrainElevationActive(terrain))
         return false;
     const frame = getQuadDrapeFrame(terrain);

package/dist/view/style-rule.d.ts

@@ -27,7 +27,7 @@ import type { Feature, FeatureStyle, FeatureType, StyleRule } from '../store/typ
 export interface LegendEntry {
     /** The displayed label */
     label: string;
-    /** The color (in #RRGGBB form) */
+    /** The color, as `#rrggbb` */
     color: string;
 }
 /**
@@ -57,27 +57,12 @@ export declare function getStyleRuleChannel(type: FeatureType): StyleRuleChannel
  * `categorical` matches strings, numbers and booleans by `String(value)`; `graduated` and
  * `continuous` take finite numbers only (a numeric string gives `other`). `continuous`
  * clamps values outside `min`..`max` and returns the first ramp color when `max <= min`. It
- * is a pure function.
+ * is a pure function. The colors of the rule may be any CSS color; the result is normalized
+ * to `#rrggbb`.
  *
  * @param rule The style rule
  * @param properties The attributes of the feature
- * @returns The color in `#RRGGBB` form
- *
- * @example
- * ```ts
- * import { evaluateStyleRule, type StyleRule } from '@sakuzu/maplibre-gl-draw';
- *
- * const rule: StyleRule = {
- *   kind: 'graduated',
- *   property: 'population',
- *   breaks: [1000, 10000],
- *   colors: ['#fee8c8', '#fdbb84', '#e34a33'],
- *   other: '#cccccc',
- * };
- * evaluateStyleRule(rule, { population: 5000 }); // '#fdbb84'
- * evaluateStyleRule(rule, { population: '5000' }); // '#cccccc' (not a number)
- * evaluateStyleRule(rule, {}); // '#cccccc'
- * ```
+ * @returns The color in `#rrggbb` form
  */
 export declare function evaluateStyleRule(rule: StyleRule, properties: Record<string, unknown> | undefined): string;
 /**
@@ -134,33 +119,11 @@ export declare function resolveFeatureStyle(feature: Feature, rule: StyleRule |
  *   `legendOther` is appended at the end
  *
  * Numbers are turned into strings with `String()`. Locale formatting is up to the caller.
+ * The colors are normalized to `#rrggbb`, as {@link evaluateStyleRule} returns them.
  *
  * @param rule The style rule
  * @param messages The entries of the messages table to use (default: `MESSAGES_EN`;
  *   missing entries fall back to it)
  * @returns The legend rows, in the order to show them
- *
- * @example
- * ```ts
- * import { deriveLegend, type StyleRule } from '@sakuzu/maplibre-gl-draw';
- *
- * const rule: StyleRule = {
- *   kind: 'graduated',
- *   property: 'population',
- *   breaks: [1000, 10000],
- *   colors: ['#fee8c8', '#fdbb84', '#e34a33'],
- *   other: '#cccccc',
- * };
- * deriveLegend(rule);
- * // [
- * //   { label: 'Below 1000', color: '#fee8c8' },
- * //   { label: '1000 to below 10000', color: '#fdbb84' },
- * //   { label: '10000 or more', color: '#e34a33' },
- * //   { label: 'Other', color: '#cccccc' },
- * // ]
- *
- * // In the language of the host application
- * deriveLegend(rule, { legendOther: 'Autres', legendBelow: (upper) => `Moins de ${upper}` });
- * ```
  */
 export declare function deriveLegend(rule: StyleRule, messages?: Partial<Messages>): LegendEntry[];

package/dist/view/style-rule.js

@@ -20,6 +20,7 @@
  * "the rule is not taking effect" apart from "there is no value".
  */
 import { MESSAGES_EN, resolveMessages } from '../messages.js';
+import { toHexColor } from '../shared/color.js';
 import { interpolateHexColor } from '../shared/utils/color.js';
 /** The name of the FeatureStyle color property corresponding to each channel */
 const CHANNEL_COLOR_PROPERTY = {
@@ -95,31 +96,16 @@ function graduatedIndex(breaks, value) {
  * `categorical` matches strings, numbers and booleans by `String(value)`; `graduated` and
  * `continuous` take finite numbers only (a numeric string gives `other`). `continuous`
  * clamps values outside `min`..`max` and returns the first ramp color when `max <= min`. It
- * is a pure function.
+ * is a pure function. The colors of the rule may be any CSS color; the result is normalized
+ * to `#rrggbb`.
  *
  * @param rule The style rule
  * @param properties The attributes of the feature
- * @returns The color in `#RRGGBB` form
- *
- * @example
- * ```ts
- * import { evaluateStyleRule, type StyleRule } from '@sakuzu/maplibre-gl-draw';
- *
- * const rule: StyleRule = {
- *   kind: 'graduated',
- *   property: 'population',
- *   breaks: [1000, 10000],
- *   colors: ['#fee8c8', '#fdbb84', '#e34a33'],
- *   other: '#cccccc',
- * };
- * evaluateStyleRule(rule, { population: 5000 }); // '#fdbb84'
- * evaluateStyleRule(rule, { population: '5000' }); // '#cccccc' (not a number)
- * evaluateStyleRule(rule, {}); // '#cccccc'
- * ```
+ * @returns The color in `#rrggbb` form
  */
 export function evaluateStyleRule(rule, properties) {
     if (rule.kind === 'single') {
-        return rule.color;
+        return toHexColor(rule.color);
     }
     return evaluateStyleRuleValue(rule, properties?.[rule.property]);
 }
@@ -132,6 +118,10 @@ export function evaluateStyleRule(rule, properties) {
  * @internal
  */
 export function evaluateStyleRuleValue(rule, value) {
+    return toHexColor(ruleColorOf(rule, value));
+}
+/** The color of the rule for a value, as the rule writes it */
+function ruleColorOf(rule, value) {
     if (rule.kind === 'single') {
         return rule.color;
     }
@@ -150,12 +140,16 @@ export function evaluateStyleRuleValue(rule, value) {
         // An invalid rule whose colors count falls short of breaks + 1 falls back to other
         return color ?? rule.other;
     }
-    // continuous: linearly interpolates the 2 colors of the ramp over min..max
-    // (out-of-range values are clamped)
+    // continuous: linearly interpolates the 2 colors of the ramp over min..max in OKLab
+    // (out-of-range values are clamped; the end points are the colors of the ramp)
     const [from, to] = rule.ramp;
     if (!(rule.max > rule.min))
         return from;
     const t = Math.min(1, Math.max(0, (numeric - rule.min) / (rule.max - rule.min)));
+    if (t === 0)
+        return from;
+    if (t === 1)
+        return to;
     return interpolateHexColor(from, to, t);
 }
 /**
@@ -241,36 +235,18 @@ function graduatedLabel(breaks, index, messages) {
  *   `legendOther` is appended at the end
  *
  * Numbers are turned into strings with `String()`. Locale formatting is up to the caller.
+ * The colors are normalized to `#rrggbb`, as {@link evaluateStyleRule} returns them.
  *
  * @param rule The style rule
  * @param messages The entries of the messages table to use (default: `MESSAGES_EN`;
  *   missing entries fall back to it)
  * @returns The legend rows, in the order to show them
- *
- * @example
- * ```ts
- * import { deriveLegend, type StyleRule } from '@sakuzu/maplibre-gl-draw';
- *
- * const rule: StyleRule = {
- *   kind: 'graduated',
- *   property: 'population',
- *   breaks: [1000, 10000],
- *   colors: ['#fee8c8', '#fdbb84', '#e34a33'],
- *   other: '#cccccc',
- * };
- * deriveLegend(rule);
- * // [
- * //   { label: 'Below 1000', color: '#fee8c8' },
- * //   { label: '1000 to below 10000', color: '#fdbb84' },
- * //   { label: '10000 or more', color: '#e34a33' },
- * //   { label: 'Other', color: '#cccccc' },
- * // ]
- *
- * // In the language of the host application
- * deriveLegend(rule, { legendOther: 'Autres', legendBelow: (upper) => `Moins de ${upper}` });
- * ```
  */
 export function deriveLegend(rule, messages) {
+    return legendOf(rule, messages).map(({ label, color }) => ({ label, color: toHexColor(color) }));
+}
+/** The legend rows with the colors as the rule writes them */
+function legendOf(rule, messages) {
     const table = messages ? resolveMessages(messages) : MESSAGES_EN;
     if (rule.kind === 'single') {
         return [{ label: table.legendAll, color: rule.color }];

package/dist/view/terrain/binding.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/view/terrain/binding.js

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/** The terrain state behind each render context and each set of anchors */
+const terrainByHandle = new WeakMap();
+/**
+ * Binds a render context or a set of anchors to the terrain state it stands for
+ *
+ * @internal
+ */
+export function bindTerrainState(handle, terrain) {
+    terrainByHandle.set(handle, terrain);
+}
+/**
+ * The terrain state behind a render context or its `terrain`
+ *
+ * @returns The state, or `null` for `null` and for an object the engine did not hand out
+ * @internal
+ */
+export function terrainStateOf(source) {
+    if (!source)
+        return null;
+    return terrainByHandle.get(source) ?? terrainByHandle.get(renderTerrainOf(source)) ?? null;
+}
+/** The `terrain` of a render context, or the object itself */
+function renderTerrainOf(source) {
+    return 'terrain' in source && typeof source.terrain === 'object' && source.terrain !== null
+        ? source.terrain
+        : source;
+}

package/dist/view/terrain/context.d.ts

@@ -117,10 +117,9 @@ export declare const INACTIVE_ANCHOR_FRAME: AnchorFrame;
 /**
  * The terrain state of one draw instance.
  *
- * Treat it as an opaque handle: a custom renderer receives it as
- * `CustomRendererDrawContext.terrain` and passes it to the renderers and to the terrain
- * functions (such as {@link anchorElevationMeters} and {@link drawQuadSurfaceOnTerrain}).
- * Constructing one gives a state with no terrain.
+ * It stays inside the engine: the renderers of a CustomLayer receive it at construction, and
+ * the public building blocks of the second entry reach it through the render context an
+ * extension receives (`terrain/binding.ts`). Constructing one gives a state with no terrain.
  */
 export declare class TerrainContext {
     /** This frame's terrain state (read by the shaders' projection uniforms) */

package/dist/view/terrain/context.js

@@ -22,7 +22,7 @@
  * module-level "current" context: every reader (state.ts / anchor.ts / occlusion.ts /
  * polygon.ts) takes the context explicitly. The renderers of a CustomLayer receive their
  * instance's context at construction, extension renderers receive it in the draw context
- * (`CustomRendererDrawContext.terrain`), hit testing uses the anchor projection bound per map
+ * (`FrameDrawContext.terrain`), hit testing uses the anchor projection bound per map
  * (`installAnchorProjector`), and plugins use the projection bound to their instance
  * (`PluginContext.projectAnchor`). A read from outside rendering therefore always sees its own
  * instance, never "the instance drawn last".
@@ -75,10 +75,9 @@ export const INACTIVE_ANCHOR_FRAME = {
 /**
  * The terrain state of one draw instance.
  *
- * Treat it as an opaque handle: a custom renderer receives it as
- * `CustomRendererDrawContext.terrain` and passes it to the renderers and to the terrain
- * functions (such as {@link anchorElevationMeters} and {@link drawQuadSurfaceOnTerrain}).
- * Constructing one gives a state with no terrain.
+ * It stays inside the engine: the renderers of a CustomLayer receive it at construction, and
+ * the public building blocks of the second entry reach it through the render context an
+ * extension receives (`terrain/binding.ts`). Constructing one gives a state with no terrain.
  */
 export class TerrainContext {
     constructor() {

package/dist/view/terrain/drape/geometry.js

@@ -16,7 +16,7 @@ export function drapeMercatorY(lat) {
  *
  * The key is decided by the caller. For a feature in the Store the instance is replaced on
  * every edit, so the feature itself is the key; for a dataset the replacement
- * happens per `setFeatures` and the coordinate arrays are not reused, so the coordinate array
+ * happens per `setRows` and the coordinate arrays are not reused, so the coordinate array
  * is the key (when applying a style rule rebuilds only the feature instances, the same
  * coordinate arrays remain, so merely changing a color does not require converting a million
  * vertices again).

package/dist/view/terrain/drape/pass.d.ts

@@ -71,7 +71,7 @@ export declare function drapeLayerSource(layerIndex: number, datasetCount: numbe
 /**
  * The view of a dataset restricted to the part the drape needs
  *
- * The implementation in `display/dataset.ts` satisfies this shape. To keep the type
+ * The implementation in `dataset/dataset.ts` satisfies this shape. To keep the type
  * dependency one-directional, only the structure is declared here.
  */
 export interface DrapeDatasetSource {