@sakuzu/maplibre-gl-draw 1.0.0

package/dist/view/layer/renderers.js

@@ -0,0 +1,142 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { TextureCache } from '../cache/texture.js';
+import { BatchManager } from '../renderers/batch-manager.js';
+import { FeatureDrawer } from '../renderers/drawer.js';
+import { ImageRenderer } from '../renderers/image.js';
+import { SDFLineRenderer } from '../renderers/line/sdf-line.js';
+import { PointInstanceRenderer } from '../renderers/point/point-instance.js';
+import { PointShapeRenderer } from '../renderers/point/point-shape.js';
+import { PolygonBatchRenderer } from '../renderers/polygon/batch.js';
+import { FillShaderManager } from '../renderers/polygon/fill.js';
+import { SDFPolygonRenderer } from '../renderers/polygon/sdf-polygon.js';
+import { StrokeRenderer } from '../renderers/stroke.js';
+import { ShaderInitializer } from '../shaders/initializer.js';
+import { QuadShader } from '../shaders/quad.js';
+import { BoxSelectionRenderer } from '../ui/box-selection.js';
+import { SelectionHandlesRenderer, SelectionUIRenderer } from '../ui/index.js';
+import { TentativeRenderer } from '../ui/tentative.js';
+import { ViewportFilter } from '../viewport.js';
+/**
+ * Initialize the renderers
+ */
+export function initRenderers(deps) {
+    const { gl, map: mapInstance, store, spatialIndex, featureStyle, selectionConfig, renderingConfig, customFeatureHandlers, pixelRatio, scope, onImageError, } = deps;
+    const textureCache = new TextureCache(gl);
+    const terrain = scope.terrain;
+    const quadShader = new QuadShader(gl, terrain);
+    const imageRenderer = new ImageRenderer(mapInstance, gl, textureCache, quadShader, (fileId) => store.getFile(fileId), onImageError);
+    const strokeRenderer = new StrokeRenderer(mapInstance, gl, pixelRatio, terrain);
+    const sdfLineRenderer = new SDFLineRenderer(mapInstance, gl, pixelRatio, terrain);
+    const pointShapeRenderer = new PointShapeRenderer(mapInstance, gl, pixelRatio, terrain);
+    const pointInstanceRenderer = new PointInstanceRenderer(mapInstance, gl, pixelRatio, terrain);
+    const polygonScope = { terrain, earcut: scope.earcut };
+    const polygonBatchRenderer = new PolygonBatchRenderer(gl, polygonScope);
+    const sdfPolygonRenderer = new SDFPolygonRenderer(gl, pixelRatio, polygonScope);
+    const fillShaderManager = new FillShaderManager(gl, terrain);
+    const selectionExtensions = scope.selection.extensions;
+    const selectionUIRenderer = new SelectionUIRenderer(strokeRenderer, selectionConfig, selectionExtensions);
+    // The tile size of this instance's map (read by the custom bounding box calculators)
+    const tileSize = mapInstance.transform?.tileSize ?? 512;
+    selectionExtensions.setTileSize(tileSize);
+    // Register the bounding box functions used by the selection UI for custom feature handlers
+    if (customFeatureHandlers) {
+        for (const handler of customFeatureHandlers) {
+            if (handler.getSelectionBoundingBox) {
+                selectionExtensions.registerBoundingBox(handler.type, handler.getSelectionBoundingBox);
+            }
+        }
+    }
+    const selectionHandlesRenderer = new SelectionHandlesRenderer(strokeRenderer, pointShapeRenderer, selectionConfig);
+    selectionHandlesRenderer.setPointInstanceRenderer(pointInstanceRenderer);
+    const featureDrawer = new FeatureDrawer({
+        gl,
+        map: mapInstance,
+        sdfLineRenderer,
+        pointShapeRenderer,
+        imageRenderer,
+        featureStyle,
+        styleRules: scope.styleRules,
+        terrain,
+    });
+    const tentativeRenderer = new TentativeRenderer({
+        gl,
+        map: mapInstance,
+        sdfLineRenderer,
+        pointShapeRenderer,
+        tentativeStyle: featureStyle.tentative,
+        terrain,
+    });
+    const boxSelectionRenderer = new BoxSelectionRenderer(mapInstance, gl, renderingConfig.boxSelectionStyle, pixelRatio);
+    const viewportFilter = new ViewportFilter({ map: mapInstance, spatialIndex });
+    const shaderInitializer = new ShaderInitializer({
+        featureDrawer,
+        tentativeRenderer,
+        quadShader,
+        strokeRenderer,
+        pointShapeRenderer,
+        pointInstanceRenderer,
+        sdfLineRenderer,
+        polygonBatchRenderer,
+        sdfPolygonRenderer,
+    });
+    const batchManager = new BatchManager({
+        gl,
+        featureDrawer,
+        pointInstanceRenderer,
+        sdfLineRenderer,
+        polygonBatchRenderer,
+        sdfPolygonRenderer,
+        terrain,
+    });
+    return {
+        textureCache,
+        quadShader,
+        imageRenderer,
+        strokeRenderer,
+        sdfLineRenderer,
+        pointShapeRenderer,
+        pointInstanceRenderer,
+        polygonBatchRenderer,
+        sdfPolygonRenderer,
+        fillShaderManager,
+        selectionUIRenderer,
+        selectionHandlesRenderer,
+        featureDrawer,
+        tentativeRenderer,
+        boxSelectionRenderer,
+        viewportFilter,
+        shaderInitializer,
+        batchManager,
+    };
+}
+/**
+ * Every member that owns GPU resources, in the order they are released
+ *
+ * The list is checked against the type: a member with a dispose() that is missing here is a
+ * compile error (see `UNRELEASED` below), so a renderer added to Renderers cannot leak its
+ * programs, buffers and textures when the layer is removed and added again.
+ */
+const GPU_OWNERS = [
+    'featureDrawer',
+    'tentativeRenderer',
+    'boxSelectionRenderer',
+    'textureCache',
+    'quadShader',
+    'strokeRenderer',
+    'pointShapeRenderer',
+    'pointInstanceRenderer',
+    'sdfLineRenderer',
+    'polygonBatchRenderer',
+    'sdfPolygonRenderer',
+    'fillShaderManager',
+];
+const UNRELEASED = true;
+void UNRELEASED;
+/**
+ * Dispose the renderers
+ */
+export function disposeRenderers(r) {
+    for (const key of GPU_OWNERS)
+        r[key].dispose();
+}

package/dist/view/layer/slot-manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * SlotManager
+ *
+ * Keeps the slots (one CustomLayer per segment of the stacking order) in step with the stacking
+ * order, and counts how many of them are on the maplibre map. The engine behind the slots is
+ * built when the first slot goes onto the map and torn down when the last one leaves; the
+ * manager only answers "first" and "last", and the layer builds and tears down. How the order is
+ * cut into segments is in slots.ts, and the design is chapter 5 of
+ * docs/internals/rendering.md ("Slots and separators").
+ */
+import type { CustomLayerInterface, Map as MapLibreMap } from 'maplibre-gl';
+import { type RenderSlot } from './slots.js';
+/** What the manager needs */
+export interface SlotManagerDeps {
+    map: Pick<MapLibreMap, 'getLayer' | 'addLayer' | 'removeLayer'> & {
+        triggerRepaint?: () => void;
+    };
+    /** The current stacking order */
+    getLayerOrder: () => readonly string[];
+    /** Predicate that identifies the separators (always false when omitted = a single slot) */
+    isExternalEntry?: (entryId: string) => boolean;
+    /** Where the changes of the slots and of the segments are notified */
+    onSlotsChange?: (slots: RenderSlot[]) => void;
+    /** Creates the CustomLayer of the slot at `index` (index 1 onwards) */
+    createSlotLayer: (index: number) => CustomLayerInterface;
+}

package/dist/view/layer/slot-manager.js

@@ -0,0 +1,133 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { partitionLayerOrder, renderSlotLayerId, sameSegments, } from './slots.js';
+/**
+ * The slots of one draw instance
+ *
+ * @internal
+ */
+export class SlotManager {
+    constructor(deps) {
+        Object.defineProperty(this, "deps", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The current list of segments (layerOrder cut at the separators) */
+        Object.defineProperty(this, "currentSegments", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The CustomLayers of the slots (first = backmost; the first is the primary layer) */
+        Object.defineProperty(this, "slotLayers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        /** Number of slots added to maplibre (0 → 1 builds the engine, 1 → 0 tears it down) */
+        Object.defineProperty(this, "added", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.deps = deps;
+        this.currentSegments = partitionLayerOrder(deps.getLayerOrder(), deps.isExternalEntry);
+    }
+    /** The current list of segments */
+    get segments() {
+        return this.currentSegments;
+    }
+    /** Number of slots currently on the map */
+    get addedCount() {
+        return this.added;
+    }
+    /**
+     * Registers the primary layer as the first slot and prepares the following slots
+     *
+     * When there are separators, the following slots are prepared here (the host adds them to the
+     * map in order from the first).
+     */
+    init(primary) {
+        this.slotLayers.push(primary);
+        for (let index = 1; index < this.currentSegments.length; index++) {
+            this.slotLayers.push(this.deps.createSlotLayer(index));
+        }
+    }
+    /**
+     * Records that a slot went onto the map
+     *
+     * @returns true when it is the first one (the engine is to be built)
+     */
+    attach() {
+        this.added++;
+        return this.added === 1;
+    }
+    /**
+     * Records that a slot left the map
+     *
+     * @returns true when none is left (the engine is to be torn down)
+     */
+    detach() {
+        this.added = Math.max(0, this.added - 1);
+        return this.added === 0;
+    }
+    /** The list of slots (public form) */
+    getRenderSlots() {
+        return this.currentSegments.map((segment, index) => ({
+            layerId: this.slotLayers[index]?.id ?? renderSlotLayerId(index),
+            from: segment.from,
+            to: segment.to,
+        }));
+    }
+    /** The CustomLayers of the slots (first = backmost) */
+    getSlotLayers() {
+        return this.slotLayers.slice();
+    }
+    /**
+     * Makes the slots follow the changes of the stacking order
+     *
+     * Nothing happens when the list of segments has not changed. A new slot is added to the front
+     * of the maplibre order (which is consistent with the slots added from the first one onwards;
+     * placing the native layers of the separators again is the responsibility of the host and is
+     * prompted by the notification). When a slot is removed, it is removed from the last one.
+     */
+    sync() {
+        const { map, isExternalEntry, onSlotsChange } = this.deps;
+        const next = partitionLayerOrder(this.deps.getLayerOrder(), isExternalEntry);
+        if (sameSegments(next, this.currentSegments))
+            return;
+        this.currentSegments = next;
+        const slotLayers = this.slotLayers;
+        while (slotLayers.length < next.length) {
+            const slot = this.deps.createSlotLayer(slotLayers.length);
+            slotLayers.push(slot);
+            // The following slots are added to the map only while the first slot is on it (when it is
+            // not, the host adds them later in order from the first)
+            if (this.hasMapLayer(slotLayers[0].id) && !this.hasMapLayer(slot.id)) {
+                map.addLayer(slot);
+            }
+        }
+        while (slotLayers.length > next.length) {
+            const slot = slotLayers.pop();
+            if (slot && this.hasMapLayer(slot.id)) {
+                map.removeLayer(slot.id);
+            }
+        }
+        onSlotsChange?.(this.getRenderSlots());
+        map.triggerRepaint?.();
+    }
+    /** Whether the map has that layer (always false while the style is not loaded) */
+    hasMapLayer(id) {
+        try {
+            return !!this.deps.map.getLayer(id);
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/view/layer/slots.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Separators and slots of the stacking order
+ *
+ * Entries of the stacking order (layerOrder) that the host declares as "external entries"
+ * (entries we do not draw ourselves, which the host places as native maplibre layers) are treated
+ * as separators, and every segment between separators gets its own CustomLayer (a slot).
+ * A maplibre style is a single ordered list and nothing can be inserted inside a CustomLayer, so
+ * a native layer can be placed in between our own rendering only once the slots are split per
+ * segment. The design is in docs/internals/rendering.md, "Slots and separators".
+ */
+export type { RenderSlot } from '../../shared/types/events.js';
+/** A segment ([from, to) in layerOrder) */
+export interface RenderSegment {
+    readonly from: number;
+    readonly to: number;
+}
+/** Layer id of the first slot (keeps the same id as the single layer used before) */
+export declare const PRIMARY_RENDER_LAYER_ID = "maplibre-gl-draw-layer";
+/** Layer id of the slot at `index` */
+export declare function renderSlotLayerId(index: number): string;
+/**
+ * Split the stacking order into segments at the separators
+ *
+ * A separator is an entry for which the predicate returns true, and the separator itself belongs
+ * to no segment. No segment is created for an empty run between separators (where separators are
+ * adjacent) because there is nothing to draw. If there is no separator at all, the whole list
+ * becomes a single segment and the behaviour is the same as the single CustomLayer used before.
+ * Even for a list with no entry drawn by us, a slot is needed to draw the foreground pass
+ * (selection UI and overlays), so one empty segment is returned.
+ */
+export declare function partitionLayerOrder(order: readonly string[], isExternalEntry?: (entryId: string) => boolean): RenderSegment[];
+/** Whether two lists of segments are the same */
+export declare function sameSegments(a: readonly RenderSegment[], b: readonly RenderSegment[]): boolean;

package/dist/view/layer/slots.js

@@ -0,0 +1,50 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/** Layer id of the first slot (keeps the same id as the single layer used before) */
+export const PRIMARY_RENDER_LAYER_ID = 'maplibre-gl-draw-layer';
+/** Layer id of the slot at `index` */
+export function renderSlotLayerId(index) {
+    return index === 0 ? PRIMARY_RENDER_LAYER_ID : `${PRIMARY_RENDER_LAYER_ID}:${index}`;
+}
+/**
+ * Split the stacking order into segments at the separators
+ *
+ * A separator is an entry for which the predicate returns true, and the separator itself belongs
+ * to no segment. No segment is created for an empty run between separators (where separators are
+ * adjacent) because there is nothing to draw. If there is no separator at all, the whole list
+ * becomes a single segment and the behaviour is the same as the single CustomLayer used before.
+ * Even for a list with no entry drawn by us, a slot is needed to draw the foreground pass
+ * (selection UI and overlays), so one empty segment is returned.
+ */
+export function partitionLayerOrder(order, isExternalEntry) {
+    if (!isExternalEntry)
+        return [{ from: 0, to: order.length }];
+    const segments = [];
+    let start = -1;
+    for (let i = 0; i < order.length; i++) {
+        if (isExternalEntry(order[i])) {
+            if (start >= 0) {
+                segments.push({ from: start, to: i });
+                start = -1;
+            }
+        }
+        else if (start < 0) {
+            start = i;
+        }
+    }
+    if (start >= 0)
+        segments.push({ from: start, to: order.length });
+    if (segments.length === 0)
+        segments.push({ from: 0, to: 0 });
+    return segments;
+}
+/** Whether two lists of segments are the same */
+export function sameSegments(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i].from !== b[i].from || a[i].to !== b[i].to)
+            return false;
+    }
+    return true;
+}

package/dist/view/layer/store-retained-bbox.d.ts

@@ -0,0 +1,36 @@
+import type { BoundingBox, Coordinate, Feature } from '../../store/types.js';
+import type { SelectionExtensionRegistry } from '../ui/selection-ui/index.js';
+/**
+ * Longitude/latitude bounding box of a chunk `[minLng, minLat, maxLng, maxLat]`
+ */
+export type ChunkBBox = [number, number, number, number];
+/**
+ * Whether the chunk bbox intersects the expanded viewport
+ *
+ * Both are treated as longitude/latitude rectangles (touching edges count as intersecting).
+ */
+export declare function bboxIntersects(bbox: ChunkBBox, viewport: BoundingBox): boolean;
+/**
+ * The chunk bbox as a BoundingBox
+ */
+export declare function chunkBBoxToBounds(bbox: ChunkBBox): BoundingBox;
+/**
+ * Expands the chunk bbox by one point (it never shrinks it)
+ *
+ * The incremental update of vertices only looks at the vertices that moved, so the bbox cannot be
+ * recomputed exactly. As long as it only grows, "retained mode ⊇ immediate mode" holds: thinning
+ * simply misses and the rendering result stays correct. The exact bbox comes back with the next
+ * rebuild.
+ *
+ * @param bbox The current bbox. null (= always drawn without thinning) is returned as it is
+ */
+export declare function expandBBox(bbox: ChunkBBox | null, coord: Coordinate): ChunkBBox | null;
+/**
+ * Computes the longitude/latitude bbox of a list of features
+ *
+ * min/max are taken on the raw longitude values without normalization. Data crossing ±180 ends up
+ * with a huge bbox, so the thinning misses and it is always drawn (erring on the safe side).
+ *
+ * @returns null when there is not a single coordinate (= no thinning)
+ */
+export declare function computeFeaturesBBox(features: readonly Feature[], extensions: SelectionExtensionRegistry | undefined): ChunkBBox | null;

package/dist/view/layer/store-retained-bbox.js

@@ -0,0 +1,188 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Longitude/latitude extents of the retained chunks
+ *
+ * A retained batch does not depend on the camera, so each chunk keeps the bbox of its features
+ * and a frame skips the chunks that do not intersect the expanded viewport. The functions here
+ * compute that bbox, grow it during an incremental update and test it against the viewport.
+ */
+import { circleBoundingBox } from '../../geometry/circle.js';
+import { DEFAULT_TILE_SIZE } from '../../shared/math/index.js';
+import { getCircleRadius } from '../../shared/utils/property.js';
+import { getBoundingBox } from '../../store/spatial/index.js';
+/**
+ * Whether the chunk bbox intersects the expanded viewport
+ *
+ * Both are treated as longitude/latitude rectangles (touching edges count as intersecting).
+ */
+export function bboxIntersects(bbox, viewport) {
+    return (bbox[0] <= viewport.maxX &&
+        bbox[2] >= viewport.minX &&
+        bbox[1] <= viewport.maxY &&
+        bbox[3] >= viewport.minY);
+}
+/**
+ * The chunk bbox as a BoundingBox
+ */
+export function chunkBBoxToBounds(bbox) {
+    return { minX: bbox[0], minY: bbox[1], maxX: bbox[2], maxY: bbox[3] };
+}
+/**
+ * Expands the chunk bbox by one point (it never shrinks it)
+ *
+ * The incremental update of vertices only looks at the vertices that moved, so the bbox cannot be
+ * recomputed exactly. As long as it only grows, "retained mode ⊇ immediate mode" holds: thinning
+ * simply misses and the rendering result stays correct. The exact bbox comes back with the next
+ * rebuild.
+ *
+ * @param bbox The current bbox. null (= always drawn without thinning) is returned as it is
+ */
+export function expandBBox(bbox, coord) {
+    if (!bbox)
+        return null;
+    const [lng, lat] = coord;
+    if (!Number.isFinite(lng) || !Number.isFinite(lat))
+        return bbox;
+    return [
+        Math.min(bbox[0], lng),
+        Math.min(bbox[1], lat),
+        Math.max(bbox[2], lng),
+        Math.max(bbox[3], lat),
+    ];
+}
+/**
+ * Walks the nesting of coordinates (Coordinate / Coordinate[] / Coordinate[][] / ...)
+ *
+ * To avoid having a branch per feature type, it recurses until it reaches a pair of numbers. It
+ * also withstands the unknown nesting of a custom type.
+ */
+function walkCoordinates(value, visit) {
+    if (!Array.isArray(value))
+        return;
+    if (typeof value[0] === 'number' && typeof value[1] === 'number') {
+        visit(value[0], value[1]);
+        return;
+    }
+    for (const item of value)
+        walkCoordinates(item, visit);
+}
+/**
+ * Computes the rectangle occupied by a feature that spreads around its anchor
+ *
+ * A kind where "coordinates is a single anchor point and the body spreads around it", such as
+ * Note / Text, degenerates into a point of zero area when only the coordinates are walked. The
+ * whole chunk would then be thinned away the moment the center of the map enters it (= the moment
+ * the anchor leaves the expanded viewport), and a feature that should cover the whole screen
+ * would disappear entirely.
+ *
+ * The rectangle it actually occupies is already known to the calculator registered by the
+ * extension (for Note, the selection box including the rotation) and to the size computation of
+ * Image. That is folded into an AABB and used.
+ *
+ * @returns null for a kind where walking the raw coordinates is enough (Point / LineString /
+ *   Polygon and so on) and when the computation did not produce finite values (the caller then
+ *   walks them as before)
+ */
+function computeAnchoredExtent(feature, extensions) {
+    const tileSize = extensions?.getTileSize() ?? DEFAULT_TILE_SIZE;
+    // A custom type folds its registered rectangle (the 4 corners)
+    const calculator = extensions?.getBoundingBoxCalculator(feature.type);
+    if (calculator) {
+        const box = calculator(feature, tileSize);
+        if (!box)
+            return null;
+        return cornersToBBox([box.topLeft, box.topRight, box.bottomRight, box.bottomLeft]);
+    }
+    // Image is a standard kind of core, but its size is determined by the style and createdZoom
+    if (feature.type === 'Image') {
+        const box = getBoundingBox(feature, tileSize);
+        return isFiniteBBox([box.minX, box.minY, box.maxX, box.maxY])
+            ? [box.minX, box.minY, box.maxX, box.maxY]
+            : null;
+    }
+    return null;
+}
+/**
+ * Folds a sequence of coordinates into an AABB (null when a non-finite value is mixed in)
+ */
+function cornersToBBox(corners) {
+    let minLng = Number.POSITIVE_INFINITY;
+    let minLat = Number.POSITIVE_INFINITY;
+    let maxLng = Number.NEGATIVE_INFINITY;
+    let maxLat = Number.NEGATIVE_INFINITY;
+    for (const corner of corners) {
+        const lng = corner?.[0];
+        const lat = corner?.[1];
+        if (!Number.isFinite(lng) || !Number.isFinite(lat))
+            return null;
+        if (lng < minLng)
+            minLng = lng;
+        if (lng > maxLng)
+            maxLng = lng;
+        if (lat < minLat)
+            minLat = lat;
+        if (lat > maxLat)
+            maxLat = lat;
+    }
+    return corners.length > 0 ? [minLng, minLat, maxLng, maxLat] : null;
+}
+/** Whether all 4 values of the bbox are finite */
+function isFiniteBBox(bbox) {
+    return bbox.every((value) => Number.isFinite(value));
+}
+/**
+ * Computes the longitude/latitude bbox of a list of features
+ *
+ * min/max are taken on the raw longitude values without normalization. Data crossing ±180 ends up
+ * with a huge bbox, so the thinning misses and it is always drawn (erring on the safe side).
+ *
+ * @returns null when there is not a single coordinate (= no thinning)
+ */
+export function computeFeaturesBBox(features, extensions) {
+    let minLng = Number.POSITIVE_INFINITY;
+    let minLat = Number.POSITIVE_INFINITY;
+    let maxLng = Number.NEGATIVE_INFINITY;
+    let maxLat = Number.NEGATIVE_INFINITY;
+    let found = false;
+    const visit = (lng, lat) => {
+        if (!Number.isFinite(lng) || !Number.isFinite(lat))
+            return;
+        found = true;
+        if (lng < minLng)
+            minLng = lng;
+        if (lng > maxLng)
+            maxLng = lng;
+        if (lat < minLat)
+            minLat = lat;
+        if (lat > maxLat)
+            maxLat = lat;
+    };
+    for (const feature of features) {
+        // A kind that spreads around its anchor (a custom type, Image) uses the rectangle it really
+        // occupies. For a standard kind that falls back to walking the raw coordinates this only adds
+        // one registry lookup, and the cost per chunk build does not change.
+        const extent = computeAnchoredExtent(feature, extensions);
+        if (extent) {
+            visit(extent[0], extent[1]);
+            visit(extent[2], extent[3]);
+            continue;
+        }
+        if (feature.type === 'Circle') {
+            const radiusMeters = getCircleRadius(feature);
+            const center = feature.coordinates;
+            if (radiusMeters && radiusMeters > 0 && typeof center?.[0] === 'number') {
+                // The box of the geodesic circle, whose east and west extremes lie poleward of due
+                // east and west; it contains the polygon used for drawing (generateCirclePolygon).
+                const box = circleBoundingBox(center, radiusMeters);
+                if (box) {
+                    visit(box[0], box[1]);
+                    visit(box[2], box[3]);
+                    continue;
+                }
+            }
+        }
+        walkCoordinates(feature.coordinates, visit);
+    }
+    return found ? [minLng, minLat, maxLng, maxLat] : null;
+}