@sakuzu/maplibre-gl-draw 1.0.0 → 2.1.0

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 {

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

@@ -16,6 +16,7 @@
  * When it does not hold, the caller drops to the previous vertex displacement path (a
  * two-stage arrangement). The condition for dropping is decided here by `canDrape`.
  */
+import { coordinatesOf } from '../../../shared/utils/coordinates.js';
 import { getCreatedZoom } from '../../../shared/utils/property.js';
 import { getDisplayFeatures, isLocallyHidden } from '../../../store/local-visibility.js';
 import { layerDrawFactors } from '../../renderers/draw-factors.js';
@@ -229,7 +230,7 @@ function collectStoreFeature(context, feature, layer, source, bakedOpacity) {
  *
  * So that the retained batch side does not draw the same features that were put on, the caller
  * tells the dataset "the polygons and lines are drawn by the drape"
- * (`drapedDatasets`). The test here and `collectFeature` in `display/retained.ts` form a
+ * (`drapedDatasets`). The test here and `collectFeature` in `dataset/retained.ts` form a
  * pair, so the condition must never be changed on only one side.
  */
 function collectDataset(context, dataset, source) {
@@ -252,7 +253,7 @@ function collectDataset(context, dataset, source) {
             if (rings.length === 0)
                 continue;
             const width = widthOf(feature, strokeStyle.width, context.pixelRatio);
-            pushElement(context, feature.coordinates, 0, rings, {
+            pushElement(context, coordinatesOf(feature), 0, rings, {
                 fill: fillColor,
                 stroke: [
                     strokeStyle.color[0],
@@ -281,7 +282,7 @@ function collectDataset(context, dataset, source) {
         if (paths.length === 0)
             continue;
         const width = widthOf(feature, strokeStyle.width, context.pixelRatio);
-        pushElement(context, feature.coordinates, 1, paths, {
+        pushElement(context, coordinatesOf(feature), 1, paths, {
             fill: [0, 0, 0, 0],
             stroke: [
                 strokeStyle.color[0],
@@ -313,14 +314,14 @@ function widthOf(feature, width, pixelRatio) {
 /** The rings of a polygon (with the closing point dropped) */
 function polygonRings(feature) {
     return feature.type === 'Polygon'
-        ? openRings(feature.coordinates)
-        : feature.coordinates.flatMap((part) => openRings(part));
+        ? openRings(coordinatesOf(feature))
+        : coordinatesOf(feature).flatMap((part) => openRings(part));
 }
 /** The paths of a line */
 function linePaths(feature) {
     const paths = feature.type === 'LineString' || feature.type === 'Freehand'
-        ? [feature.coordinates]
-        : feature.coordinates;
+        ? [coordinatesOf(feature)]
+        : coordinatesOf(feature);
     return paths.filter((path) => path.length >= 2);
 }
 /** Pushes an element */

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

@@ -2,19 +2,23 @@
  * The injection point for terrain subdivision of polygons
  *
  * Called from the polygon renderers (polygon/sdf-polygon.ts and polygon/batch.ts). When the
- * terrain is disabled, `getTerrainTessellationStep(context)` returns null and the caller does
+ * terrain is disabled, `terrainStepOf(context)` returns null and the caller does
  * nothing. Rendering without terrain therefore does not change by a single byte.
  */
+import type { TerrainAnchors } from '../../api/extension/context.js';
+import type { RenderContext } from '../../api/extension/render.js';
 import type { Coordinate } from '../../store/types.js';
 import type { TerrainContext } from './context.js';
 import { type MercatorRect, type TessellationStep } from './tessellation.js';
 /**
- * Returns the subdivision step of the terrain mesh for the current frame.
+ * Returns the subdivision step of the terrain mesh for the current frame, to cut a shape so
+ * that it follows the terrain (pass it to `densifyPath`).
  *
- * @param context The terrain state of the draw instance
- * @returns The step, or `null` when the terrain is disabled
+ * @param terrain - The render context of the draw call, or its `terrain`
+ * @returns The step, or `null` when the terrain is disabled (or the object was not handed out
+ *   by the engine)
  */
-export declare function getTerrainTessellationStep(context: TerrainContext): TessellationStep | null;
+export declare function terrainTessellationStep(terrain: RenderContext | TerrainAnchors): TessellationStep | null;
 /**
  * Decides the effective step for a single feature
  *

package/dist/view/terrain/polygon.js

@@ -1,16 +1,30 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
+import { terrainStateOf } from './binding.js';
 import { TERRAIN_MAX_BATCH_SUBDIVISION_CELLS, TERRAIN_MAX_COARSEN_STEPS, TERRAIN_MAX_SUBDIVISION_POINTS, TERRAIN_MAX_TILED_SUBDIVISION_POINTS, } from './metrics.js';
 import { getTerrainRenderState } from './state.js';
 import { cellsInRegion, densifyRings, mercatorX, mercatorY, rectsIntersect, subdivideTriangles, } from './tessellation.js';
 import { tilingSignature } from './tiling.js';
 /**
- * Returns the subdivision step of the terrain mesh for the current frame.
+ * Returns the subdivision step of the terrain mesh for the current frame, to cut a shape so
+ * that it follows the terrain (pass it to `densifyPath`).
+ *
+ * @param terrain - The render context of the draw call, or its `terrain`
+ * @returns The step, or `null` when the terrain is disabled (or the object was not handed out
+ *   by the engine)
+ */
+export function terrainTessellationStep(terrain) {
+    const state = terrainStateOf(terrain);
+    return state ? terrainStepOf(state) : null;
+}
+/**
+ * {@link terrainTessellationStep} over the terrain state of an instance
  *
  * @param context The terrain state of the draw instance
  * @returns The step, or `null` when the terrain is disabled
+ * @internal
  */
-export function getTerrainTessellationStep(context) {
+export function terrainStepOf(context) {
     const terrain = getTerrainRenderState(context);
     if (!terrain.active || !(terrain.stepGrid > 0))
         return null;

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

@@ -6,7 +6,7 @@
  * (`context.ts`; how a shared global broke with several instances is written there). Every
  * accessor takes that context explicitly: the renderers of a CustomLayer receive their
  * instance's context at construction, and extension renderers receive it in the draw context
- * (`CustomRendererDrawContext.terrain`). Nothing here reads "the instance drawn last".
+ * (`FrameDrawContext.terrain`). Nothing here reads "the instance drawn last".
  *
  * When the terrain is disabled, `INACTIVE_TERRAIN_STATE` is held and the shader's
  * `u_terrain_on` becomes 0. The vertex computation when it is 0 is exactly identical to

package/dist/view/terrain/state.js

@@ -8,7 +8,7 @@
  * (`context.ts`; how a shared global broke with several instances is written there). Every
  * accessor takes that context explicitly: the renderers of a CustomLayer receive their
  * instance's context at construction, and extension renderers receive it in the draw context
- * (`CustomRendererDrawContext.terrain`). Nothing here reads "the instance drawn last".
+ * (`FrameDrawContext.terrain`). Nothing here reads "the instance drawn last".
  *
  * When the terrain is disabled, `INACTIVE_TERRAIN_STATE` is held and the shader's
  * `u_terrain_on` becomes 0. The vertex computation when it is 0 is exactly identical to

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

@@ -47,7 +47,7 @@ export interface MercatorRect {
 }
 /**
  * How finely a line or a fill is subdivided to follow the terrain mesh, as
- * {@link getTerrainTessellationStep} returns it.
+ * {@link terrainTessellationStep} returns it.
  */
 export interface TessellationStep {
     /**
@@ -193,7 +193,7 @@ export declare function latFromMercatorY(y: number): number;
  * on the original line).
  *
  * @param path The vertices `[lng, lat]` in degrees
- * @param step The step from {@link getTerrainTessellationStep}
+ * @param step The step from {@link terrainTessellationStep}
  * @returns The densified vertices. The input itself for fewer than 2 positions or a step of
  *   0; insertion stops when `step.maxPoints` is reached
  */

package/dist/view/terrain/tessellation.js

@@ -91,7 +91,7 @@ export function latFromMercatorY(y) {
  * on the original line).
  *
  * @param path The vertices `[lng, lat]` in degrees
- * @param step The step from {@link getTerrainTessellationStep}
+ * @param step The step from {@link terrainTessellationStep}
  * @returns The densified vertices. The input itself for fewer than 2 positions or a step of
  *   0; insertion stops when `step.maxPoints` is reached
  */

package/dist/view/ui/auxiliary-handles.d.ts

@@ -2,10 +2,10 @@
  * Extension point for the auxiliary handles
  *
  * A general-purpose hook for showing and grabbing handles on the selected feature that are
- * "neither a vertex nor a resize handle". All core holds is the hit testing and the drag
- * delegation; drawing the handles is the responsibility of the registering side (the plugin
- * of an extension implementation). core knows nothing at all about the meaning of a handle
- * (it only carries the position and the identifier).
+ * "neither a vertex nor a resize handle". Core draws them with the look of the vertex handles
+ * (the selection UI), hit tests them at the same size and delegates their drags. core knows
+ * nothing at all about the meaning of a handle (it only carries the position and the
+ * identifier).
  *
  * There are two ways to emit handles: those bound to the selected feature (getHandles) and
  * those that can always be emitted regardless of the selection (getGlobalHandles). The
@@ -72,31 +72,8 @@ export interface AuxiliaryHandleHit {
  * A source of handles on the selected feature that are neither vertices nor resize handles,
  * and the receiver of their drags.
  *
- * Register one with `draw.registerAuxiliaryHandleProvider(provider)`. The library hit tests
- * the handles and delegates their drags; drawing them is the provider's job (with an overlay
- * renderer, for example).
- *
- * @example
- * ```ts
- * import type { AuxiliaryHandleProvider } from '@sakuzu/maplibre-gl-draw';
- *
- * // A handle 20 px above the first vertex of the selected line, which logs its drag
- * const labelHandle: AuxiliaryHandleProvider = {
- *   id: 'label-handle',
- *   getHandles(feature, ctx) {
- *     if (feature.type !== 'LineString') return [];
- *     const first = (feature.coordinates as [number, number][])[0];
- *     const p = ctx.project(first);
- *     const { lng, lat } = ctx.unproject({ x: p.x, y: p.y - 20 });
- *     return [{ id: 'label', position: [lng, lat], cursor: 'move' }];
- *   },
- *   onHandleDragStart: () => true,
- *   onHandleDragMove: (event) => console.log(event.lngLat),
- *   onHandleDragEnd: () => {},
- * };
- *
- * const unregister = draw.registerAuxiliaryHandleProvider(labelHandle);
- * ```
+ * A `HandleProvider` of `draw.extensions.handleProviders` is installed as one. The engine draws
+ * the handles with the look of the vertex handles, hit tests them and delegates their drags.
  */
 export interface AuxiliaryHandleProvider {
     /** Identifier unique within the registry (re-registering with the same id overwrites) */

package/dist/view/ui/bounds.js

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
 import { applyMarginToBoundingBox } from '../../shared/math/index.js';
-import { computeBoundingBox, hasZeroArea, resolvePointFrameExtentWith, } from './selection-ui/index.js';
+import { computeBoundingBox, hasZeroArea, resolvePointFrameCornersWith, } from './selection-ui/index.js';
 /**
  * Compute the bounding box with a margin of a feature in geographic coordinates
  *
@@ -82,7 +82,8 @@ export function computeCombinedGeoBoundingBox(features, transform, config, exten
 /**
  * Compute the bounding box with a margin of a single-coordinate feature in geographic coordinates
  *
- * The extent of the frame of a point (registrable per type; 12px square when unregistered)
+ * The extent of the frame of a point (registrable per type; the marker of a built-in point, or
+ * a 12px square when unregistered)
  * plus the margin is computed in screen coordinates and converted into geographic ones.
  * The coordinate received is the center of the bbox (since features other than Point can
  * also be zero-area, e.g. a MultiPoint with a single point; coordinates must not be
@@ -90,17 +91,12 @@ export function computeCombinedGeoBoundingBox(features, transform, config, exten
  */
 function computeSingleCoordGeoBoundingBox(feature, coord, transform, margin, extensions) {
     const center = transform.project(coord);
-    // The half width and half height of the frame of the point + the margin
-    const extent = extensions
-        ? extensions.resolvePointFrameExtent(feature)
-        : resolvePointFrameExtentWith(undefined, feature);
-    const halfWidth = extent.halfWidth + margin;
-    const halfHeight = extent.halfHeight + margin;
+    // The corners of the frame of the point (its outline, or its extent) + the margin
+    const corners = extensions
+        ? extensions.resolvePointFrameCorners(feature, center, margin)
+        : resolvePointFrameCornersWith(undefined, undefined, feature, center, margin);
     // Convert the 4 corners in screen coordinates into geographic coordinates
-    const topLeft = transform.unproject({ x: center.x - halfWidth, y: center.y - halfHeight });
-    const topRight = transform.unproject({ x: center.x + halfWidth, y: center.y - halfHeight });
-    const bottomRight = transform.unproject({ x: center.x + halfWidth, y: center.y + halfHeight });
-    const bottomLeft = transform.unproject({ x: center.x - halfWidth, y: center.y + halfHeight });
+    const [topLeft, topRight, bottomRight, bottomLeft] = corners.map((corner) => transform.unproject(corner));
     return {
         topLeft: [topLeft.lng, topLeft.lat],
         topRight: [topRight.lng, topRight.lat],

package/dist/view/ui/handle-test.js

@@ -216,8 +216,8 @@ function hitTestCircleRadiusHandle(feature, config, params) {
  *
  * Enumerating the handles is left to the callback (the aggregation of the providers), while
  * the test is done with the same screen-px rectangle as the existing handles. To keep the
- * grab feel uniform, the test size is the same as for the vertex handles (rendering is the
- * provider's responsibility, so core knows only the positions).
+ * grab feel uniform, the test size is the same as for the vertex handles, which is also the
+ * size the selection UI draws them at.
  */
 function hitTestAuxiliaryHandles(feature, config, zoom, params, getAuxiliaryHandles) {
     const context = {

package/dist/view/ui/handle-thinning.js

@@ -14,7 +14,7 @@
  */
 import { HANDLE_THINNING_THRESHOLD, MIDPOINT_MIN_EDGE_PX, MIN_HANDLE_SPACING_PX, THINNING_REFRESH_DEBOUNCE_MS, } from '../../shared/config/selection.js';
 import { mercatorMidpoint } from '../../shared/math/globe-subdivision.js';
-import { supportsVertexEditing } from '../../shared/utils/coordinates.js';
+import { coordinatesOf, supportsVertexEditing } from '../../shared/utils/coordinates.js';
 import { isSameVertexRef } from '../../shared/utils/vertex-ref.js';
 /**
  * Decomposes a feature into scan units
@@ -26,15 +26,15 @@ import { isSameVertexRef } from '../../shared/utils/vertex-ref.js';
 function collectHandleRuns(feature) {
     const runs = [];
     if (feature.type === 'LineString') {
-        pushLineRun(runs, feature.coordinates);
+        pushLineRun(runs, coordinatesOf(feature));
     }
     else if (feature.type === 'Polygon') {
-        pushPolygonRuns(runs, feature.coordinates);
+        pushPolygonRuns(runs, coordinatesOf(feature));
     }
     else if (feature.type === 'MultiPoint') {
         // Splitting a MultiPoint per part would adopt every point and defeat the thinning, so
         // all parts are scanned as a single sequence
-        const points = feature.coordinates;
+        const points = coordinatesOf(feature);
         runs.push({
             coords: points,
             vertexCount: points.length,
@@ -44,13 +44,13 @@ function collectHandleRuns(feature) {
         });
     }
     else if (feature.type === 'MultiLineString') {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         for (let part = 0; part < parts.length; part++) {
             pushLineRun(runs, parts[part], part);
         }
     }
     else if (feature.type === 'MultiPolygon') {
-        const parts = feature.coordinates;
+        const parts = coordinatesOf(feature);
         for (let part = 0; part < parts.length; part++) {
             pushPolygonRuns(runs, parts[part], part);
         }
@@ -112,25 +112,25 @@ export function countPotentialHandles(feature) {
     if (feature.type === 'Point')
         return 1;
     if (feature.type === 'LineString') {
-        return countLineHandles(feature.coordinates.length);
+        return countLineHandles(coordinatesOf(feature).length);
     }
     if (feature.type === 'Polygon') {
-        return countPolygonHandles(feature.coordinates);
+        return countPolygonHandles(coordinatesOf(feature));
     }
     if (feature.type === 'MultiPoint') {
         // Each coordinate is the vertex handle of one part. There are no edges
-        return feature.coordinates.length;
+        return coordinatesOf(feature).length;
     }
     if (feature.type === 'MultiLineString') {
         let total = 0;
-        for (const part of feature.coordinates) {
+        for (const part of coordinatesOf(feature)) {
             total += countLineHandles(part.length);
         }
         return total;
     }
     if (feature.type === 'MultiPolygon') {
         let total = 0;
-        for (const part of feature.coordinates) {
+        for (const part of coordinatesOf(feature)) {
             total += countPolygonHandles(part);
         }
         return total;
@@ -254,23 +254,23 @@ export function includeRequiredVertexRefs(set, required) {
 function getRefCoords(feature, ref) {
     const part = ref.part ?? 0;
     if (feature.type === 'Point') {
-        return [feature.coordinates];
+        return [coordinatesOf(feature)];
     }
     if (feature.type === 'LineString') {
-        return feature.coordinates;
+        return coordinatesOf(feature);
     }
     if (feature.type === 'Polygon') {
-        return feature.coordinates[ref.ring] ?? null;
+        return coordinatesOf(feature)[ref.ring] ?? null;
     }
     if (feature.type === 'MultiPoint') {
-        const point = feature.coordinates[part];
+        const point = coordinatesOf(feature)[part];
         return point ? [point] : null;
     }
     if (feature.type === 'MultiLineString') {
-        return feature.coordinates[part] ?? null;
+        return coordinatesOf(feature)[part] ?? null;
     }
     if (feature.type === 'MultiPolygon') {
-        return feature.coordinates[part]?.[ref.ring] ?? null;
+        return coordinatesOf(feature)[part]?.[ref.ring] ?? null;
     }
     return null;
 }