@nika-js/onlymap 0.6.1 → 0.6.4

package/dist/clip-box.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Clip box (spec: issue #34 §"Cutting / Clipping", tier 2 — the geometric
+ * complement to issue #26's clip PLANE). A real oriented... well, AXIS-
+ * ALIGNED (v1 scope, confirmed explicitly — rotation is a documented
+ * follow-up, not this) 3D box: geometry outside it is discarded (or, in
+ * `highlight` mode, dimmed rather than removed — "non-destructive"), so a
+ * dense scene (a BIM model, a point cloud, a city block) can be cut open to
+ * see what's inside.
+ *
+ * Map-level scene state (spec: `<om-map clip-box-min="..." clip-box-max="..."
+ * clip-box-invert clip-box-highlight>`), same architecture as `lighting`/
+ * `terrain`: attribute-backed, undoable, live-editable, applied to every
+ * layer by default with a per-layer `clip="off"` escape hatch — see
+ * `applyClipBox`'s own doc comment for why that default (not opt-in) is
+ * the right one here specifically.
+ *
+ * Three corrections from the original design review, all reflected below:
+ * 1. "Outside the box" is `!inside` (De Morgan's law on the AND of 6
+ *    half-spaces) — NOT a literal OR of 6 flipped half-space tests, which
+ *    would (incorrectly) require re-deriving 6 new inequalities; negating
+ *    the single boolean `inside` result is simpler and exactly equivalent.
+ * 2. Plane/box bounds are expressed in deck's COMMON SPACE (via
+ *    `Layer#projectPosition`, the SAME mechanism the built-in `ClipExtension`
+ *    uses for its own 2D bounds) — never raw lng/lat — so one authored box
+ *    clips layers in different coordinate systems (geographic, meter-offset
+ *    BIM placements, etc.) correctly.
+ * 3. Picking (including the `pickable:'3d'` depth pass) is covered for
+ *    free: `discard` inside `fs:DECKGL_FILTER_COLOR` is the SAME shader
+ *    stage deck's own picking pass reuses — no separate picking-specific
+ *    code needed, confirmed by the built-in `ClipExtension` doing nothing
+ *    extra for picking either.
+ */
+import { LayerExtension } from "@deck.gl/core";
+import type { Layer } from "@deck.gl/core";
+import type { LayerIR } from "./ir";
+export interface ClipBoxIR {
+    /** [lng, lat, elevationMeters] — one corner. Order vs. `max` doesn't matter; both get componentwise min/max'd after projecting. */
+    min: [number, number, number];
+    max: [number, number, number];
+    /** Show OUTSIDE the box instead of inside. */
+    invert: boolean;
+    /** Dim clipped-out geometry instead of discarding it — "non-destructive": nothing disappears, it just de-emphasizes. */
+    highlight: boolean;
+}
+/** `<om-map clip-box-min="[...]" clip-box-max="[...]" clip-box-invert clip-box-highlight>` → `ClipBoxIR`, or `null` when min/max aren't both present/valid (no box = no clipping, not a broken one). */
+export declare function parseClipBoxAttrs(getAttr: (name: string) => string | null): ClipBoxIR | null;
+export interface ClipBoxExtensionProps {
+    clipBoxMin?: [number, number, number];
+    clipBoxMax?: [number, number, number];
+    clipBoxInvert?: boolean;
+    clipBoxHighlight?: boolean;
+}
+/** Fragment-level box clip (targets extruded/mesh geometry — GeoJsonLayer extrusions, Tile3DLayer/BIMLayer triangles — not point/icon anchors, unlike the built-in ClipExtension's dual vertex/fragment modes; this library's clip-box use case is "cut into a 3D scene," not "hide points outside a rect"). */
+export declare class ClipBoxExtension extends LayerExtension {
+    static extensionName: string;
+    static defaultProps: {
+        clipBoxMin: number[];
+        clipBoxMax: number[];
+        clipBoxInvert: boolean;
+        clipBoxHighlight: boolean;
+    };
+    getShaders(): {
+        modules: {
+            readonly name: "clipBox";
+            readonly fs: "\nlayout(std140) uniform clipBoxUniforms {\n  vec3 boxMin;\n  vec3 boxMax;\n  float invert;\n  float highlight;\n  vec4 highlightTint;\n} clipBox;\n\nbool clipBox_isInside(vec3 commonPos) {\n  return commonPos.x >= clipBox.boxMin.x && commonPos.x <= clipBox.boxMax.x\n      && commonPos.y >= clipBox.boxMin.y && commonPos.y <= clipBox.boxMax.y\n      && commonPos.z >= clipBox.boxMin.z && commonPos.z <= clipBox.boxMax.z;\n}\n";
+            readonly uniformTypes: {
+                readonly boxMin: "vec3<f32>";
+                readonly boxMax: "vec3<f32>";
+                readonly invert: "f32";
+                readonly highlight: "f32";
+                readonly highlightTint: "vec4<f32>";
+            };
+        }[];
+        inject: {
+            "vs:#decl": string;
+            "vs:DECKGL_FILTER_GL_POSITION": string;
+            "fs:#decl": string;
+            "fs:DECKGL_FILTER_COLOR": string;
+        };
+    };
+    draw(this: Layer<Required<ClipBoxExtensionProps>>): void;
+}
+export interface ClipBoxLayerPatch {
+    /**
+     * The deck-layer id to construct with. Suffixed `#c<generation>` while a
+     * box is active and this layer is opted in: adding/removing an extension
+     * on a LIVE (already-mounted) layer corrupts DataFilterExtension's
+     * attribute state for some layer types (ColumnLayer, Tile3DLayer/BIMLayer
+     * sublayers — empirically verified: a box present from the FIRST render
+     * works fine, but toggling one on live on an already-mounted filtered
+     * layer silently blanks it, with no console error) — the exact same
+     * "birth-stable extension set" issue `applyTerrain`'s own `deckId`
+     * suffixing already works around. A fresh id forces clean teardown +
+     * rebuild instead of a live prop update.
+     */
+    deckId: string;
+    extraProps: Record<string, unknown>;
+}
+/**
+ * Per-layer clip-box patches, PURE — mirrors `applyTerrain`'s exact shape
+ * (same file this gets merged alongside in runtime-core.ts's `buildLayers`).
+ * Default is APPLIED (every layer gets clipped once a box is configured),
+ * unlike terrain's per-layer OPT-IN default — the clip box's whole point is
+ * cutting into "the scene," and requiring every single layer to opt in
+ * individually would make the common case ("cut through everything, show me
+ * what's inside") the awkward one; `clip="off"` is the escape hatch for the
+ * layers that shouldn't be touched (a basemap, most often).
+ */
+export declare function applyClipBox(irs: readonly LayerIR[], clipBox: ClipBoxIR | null, generation: number): Map<string, ClipBoxLayerPatch>;

package/dist/data-layer.d.ts

@@ -90,6 +90,28 @@ export interface DataFormat {
 export declare function rowsToColumnar(rows: Record<string, unknown>[]): ColumnarData | undefined;
 /** `OmMap.registerFormat(format)` — plug in a parser for a format the library doesn't ship (spec: "v0.2 / Tier 1"). */
 export declare function registerFormat(format: DataFormat): void;
+/** Opaque controller/element identity used to reference-count data transports. */
+export type DataTransportOwner = object;
+/** Start one descriptor reconciliation transaction for an owner. */
+export declare function beginDataOwnerUpdate(owner: DataTransportOwner): void;
+/**
+ * Release transports no longer named by the owner's complete descriptor
+ * document. Retains their rows: a layer removed or re-pointed is a routine
+ * edit, and re-adding it (or undoing the edit) should repaint, not blink.
+ */
+export declare function endDataOwnerUpdate(owner: DataTransportOwner): void;
+/**
+ * Release every fetch/poller/socket held by an owner.
+ *
+ * Defaults to a permanent teardown — dispose, unmount, an <om-map> leaving the
+ * document — which drops the rows too, because an owner that cannot come back
+ * has nothing to repaint. Pass `{ retain: true }` for a pause the owner intends
+ * to reverse (`MapController.suspend()`), and resuming repaints the last rows
+ * while the reopened transport catches up.
+ */
+export declare function releaseDataOwner(owner: DataTransportOwner, opts?: {
+    retain?: boolean;
+}): void;
 /**
  * A source plugin supplies domain decoding (and optionally a subscription
  * handshake); the transport (WebSocket, reconnect, flush) is generic.
@@ -128,7 +150,7 @@ export interface DataRequestConfig {
 }
 export declare function configureData(config: DataRequestConfig): void;
 /** @internal Shared request-policy chokepoint for non-row assets (ImageOverlay); not re-exported from the package root. */
-export declare function fetchConfiguredResource(url: string): Promise<Response>;
+export declare function fetchConfiguredResource(url: string, signal?: AbortSignal): Promise<Response>;
 /** @internal Shared Content-Length license backstop for row and non-row sources. */
 export declare function assertFetchSizeWithinEntitlement(response: Response): void;
 /** `data="draw:sketch"` — the reserved scheme for a widget-fed sketch layer (never collides with http/ws/inline). */
@@ -162,9 +184,17 @@ export declare function getDrawData(url: string): LayerData;
  * call for a given URL, and invokes `onLoaded` on every resolution/flush (the
  * caller re-reconciles from there).
  */
-export declare function getData(url: string, onLoaded: () => void, opts?: StreamOptions): LayerData;
-/** Is a fetch for this URL still in flight? Feeds the `om-map-ready` signal — errored fetches count as settled (readiness must not hang on a bad URL). */
-export declare function isPendingData(url: string): boolean;
+export declare function getData(url: string, onLoaded: () => void, opts?: StreamOptions, owner?: DataTransportOwner): LayerData;
+/**
+ * Is a fetch for this URL still in flight? Feeds the `om-map-ready` signal —
+ * errored fetches count as settled (readiness must not hang on a bad URL).
+ *
+ * With an owner this asks only about that owner's OWN transports: a map must
+ * never wait on — or be released by — a sibling map's fetch. An owner with no
+ * acquired identities has nothing pending by definition, so a missing state is
+ * an empty set, not "match anything".
+ */
+export declare function isPendingData(url: string, owner?: DataTransportOwner): boolean;
 /**
  * Minimal feature-shape detection (spec: "Feature Field Resolution & Data
  * Shape" — full per-layer caching/registry treatment is a later phase; this

package/dist/draw-controller.d.ts

@@ -22,6 +22,49 @@ export declare class DrawController {
     private readonly autosaveKeys;
     private readonly observers;
     private active;
+    /**
+     * rAF handle coalescing hover-driven preview updates (spec: "Cut/fill
+     * volume measurement" — found debugging click-reliability in standalone
+     * mode). `point()` used to call `renderPreview()` (which patches the
+     * per-frame channel and rebuilds every deck.gl layer) SYNCHRONOUSLY on
+     * every raw mousemove — far more often than the "per-frame" name implies,
+     * since mousemove fires at native pointer-event rate, not rAF rate. That
+     * rebuild storm intermittently corrupted deck.gl's own click/pick pipeline
+     * (mjolnir gesture recognition losing a click shortly after a hover-driven
+     * rebuild) — confirmed by disabling hover-triggered rebuilds entirely and
+     * watching the click-loss disappear. Coalescing to one rebuild per actual
+     * animation frame is what `patchAnimatedProps`'s own doc comment already
+     * describes as "the deck-idiomatic rAF pattern" — this was a gap between
+     * that intent and this call site, not a design change.
+     */
+    private hoverRaf;
+    /**
+     * The coordinate `commit()` just used to close a shape (its live cursor
+     * position at that moment), or null. The native `dblclick` DOM event
+     * (which drives `commit()`) fires as soon as the second tap's mouseup
+     * lands — but deck.gl's own click-gesture recognition is independently
+     * delayed (Hammer's Tap recognizer defers confirming a "click" until it's
+     * sure a second tap isn't coming, per its `requireFailure`/`interval`
+     * mechanics). One of the double-click's own two taps can therefore still
+     * arrive here as a late, ordinary "click" a few ms *after* commit() already
+     * ran, at ~that same coordinate — with pending now empty, session.click's
+     * own same-spot dedup (see `point()`'s click branch) has nothing to
+     * compare against, so it silently starts a fresh one-vertex shape at the
+     * spot the user just finished closing.
+     *
+     * Guarding on position (not a time window) is what keeps this from
+     * swallowing a genuinely new, deliberate click that happens to follow
+     * immediately after a commit — e.g. redrawing a second shape back-to-back
+     * in a test with no elapsed wall-clock time — since that click lands at a
+     * different coordinate and passes straight through. The match is a small
+     * PIXEL-radius tolerance (see `point()`), not exact equality: a real
+     * double-click's two taps are two independent physical presses and rarely
+     * land at the bit-identical screen pixel, let alone the bit-identical
+     * unprojected lng/lat — exact equality let real hand jitter slip past the
+     * guard even though a synthetic, pixel-perfect test wouldn't reveal that.
+     * Consumed (cleared) by the very next click regardless of whether it matched.
+     */
+    private lastClosePos;
     constructor(mapEl: Element, core: RuntimeCore);
     /** A draw tool is active — om-map routes points here and suppresses selection. */
     isCapturing(): boolean;
@@ -32,14 +75,45 @@ export declare class DrawController {
      * geodesic readouts + labels live off the shared draw stack. `null` unsubs.
      */
     setObserver(target: string, cb: ((session: DrawSession) => void) | null): void;
+    /** This map's own committed-feature count for `target` (spec: "Cut/fill volume measurement") — see DrawSession.count's doc comment for why this beats reading the shared getDrawData mirror. */
+    featureCount(target: string): number;
     private notify;
-    /** Enable localStorage autosave for a target and restore any saved sketch (draw-config action). */
+    /** Enable localStorage autosave for a target and restore any saved sketch, and/or an auto-styled committed-geometry layer (draw-config action). */
     configure(target: string, opts: {
         autosave?: string;
+        fillColor?: number[];
+        lineColor?: number[];
     }): void;
+    /**
+     * Opt-in committed-geometry visualization (spec: issue #34's region-export
+     * demo surfaced this — a closed shape with no author-added layer is
+     * indistinguishable from "double-click didn't work," since the ONLY
+     * built-in visual is the in-progress preview, which clears the instant a
+     * shape commits). Bound directly to the SAME reactive `draw:<target>` data
+     * URL an author's own manual layer would use — this is pure convenience
+     * layered on top, not a replacement; an author who wants custom styling
+     * (or a non-GeoJsonLayer rendering) still adds their own layer instead,
+     * and both can coexist. One committed layer per TARGET (not a singleton
+     * like `PREVIEW_ID`), since multiple draw targets can exist on one map.
+     *
+     * `depthTest: false` (patched, not attribute-expressible — same non-
+     * string-prop precedent as the volume gizmo's `mesh`): a flat 2D ring has
+     * no z of its own, so on a page with 3D content (the exact case this was
+     * built for — outlining a footprint over a BIM building to export) it can
+     * sit at an elevation UNDER opaque building geometry, fully occluded from
+     * a normal camera angle — the identical depth-occlusion class already
+     * fixed for the measure tool's cut-prism guides. This is a SELECTION
+     * indicator, not real in-world geometry, so it's correct for it to always
+     * read on top regardless of what 3D content surrounds it.
+     */
+    private ensureCommittedLayer;
     setMode(target: string, mode: DrawMode | null): void;
     private deactivate;
     point(coord: [number, number] | null, kind: "click" | "hover"): void;
+    /** Drop a queued hover-coalesced render (a following immediate render already supersedes it). */
+    private cancelHoverRaf;
+    /** `CLOSE_GUARD_PIXELS` converted to real meters at the current zoom/latitude (standard Web Mercator meters-per-pixel). */
+    private closeGuardMeters;
     /** Close the in-progress line/polygon — from the double-click DOM event or Enter. */
     commit(): void;
     cancel(): void;

package/dist/draw.d.ts

@@ -50,6 +50,7 @@ export interface DrawSessionOpts {
     /** Fired whenever the COMMITTED feature set changes (commit / delete / clear / seed) — D2 wires this to the store push. */
     onChange?: (fc: FeatureCollection) => void;
 }
+export declare function samePoint(a: Position, b: Position): boolean;
 /**
  * One sketch session. Owns the committed features and the single in-progress
  * shape. Every mutation that changes the committed set fires `onChange` once.
@@ -74,10 +75,16 @@ export declare class DrawSession {
     /** Cursor moved — updates the rubber-band target. No committed-set change. */
     move(pos: Position): void;
     /**
-     * Finalize the in-progress line/polygon (from double-click / Enter). A
-     * trailing duplicate vertex — the second click of a double-click — is
-     * dropped first. No-op (shape kept pending) if there aren't enough
-     * distinct vertices yet. Returns the committed feature or null.
+     * Finalize the in-progress line/polygon (from double-click / Enter). The
+     * two clicks that make up a double-click are individually unreliable —
+     * deck.gl's click/dblclick gesture disambiguation can drop either or both
+     * of them depending on exact timing — so rather than depend on them having
+     * landed in `pending`, the closing vertex is the live cursor position
+     * (already updated by the hover that preceded the double-click, via a
+     * separate, non-gesture-gated code path). A trailing duplicate — the
+     * cursor exactly repeating the last real vertex — is dropped. No-op (shape
+     * kept pending) if there aren't enough distinct vertices yet. Returns the
+     * committed feature or null.
      */
     commit(): DrawFeature | null;
     /** Esc — discard the in-progress shape, keep the tool active. */
@@ -93,6 +100,17 @@ export declare class DrawSession {
         features?: unknown;
     } | null | undefined): void;
     toFeatureCollection(): FeatureCollection;
+    /**
+     * Committed-feature count for THIS session object (spec: "Cut/fill volume
+     * measurement"). Distinct from reading the shared `getDrawData` store
+     * mirror: that mirror is a module-global `Map` keyed by URL string with no
+     * per-map/per-session isolation, so it can carry a PRIOR session's data
+     * (a different `<om-map>` sharing the same runtime-internal target id, or —
+     * the case that surfaced this — a freshly re-mounted map in a test) until
+     * this session's own first commit overwrites it. This reads `this.features`
+     * directly, which always starts empty for a genuinely new session.
+     */
+    count(): number;
     /** The in-progress shape for the preview layer, or null when nothing is pending. */
     preview(): DrawPreview | null;
     private finalize;

package/dist/elements/om-map.d.ts

@@ -20,6 +20,7 @@
 import { HTMLElementBase } from "../env";
 import { type RuntimeContext } from "../ctx";
 import { type LightingIR } from "../scene-lighting";
+import { type ClipBoxIR } from "../clip-box";
 import { type TerrainIR } from "../terrain";
 import { type WidgetSlot } from "../widget-layout";
 import { type SnapshotOptions } from "../snapshot";
@@ -44,10 +45,13 @@ export declare class OmMapElement extends HTMLElementBase {
     private observer;
     private history;
     private keydownHandler?;
+    private keyupHandler?;
     private dblclickHandler?;
     private contextmenuHandler?;
     private mount;
     private reconcilePending;
+    private readonly dataOwner;
+    private dataReleasePending;
     /** Decoded property tables per pick-features layer — see RuntimeCoreCallbacks.onFeatureTable. */
     private featureTables;
     private layerIRs;
@@ -257,6 +261,20 @@ export declare class OmMapElement extends HTMLElementBase {
      *  Fires at pointer rate on hover (no debounce — vertex capture needs
      *  every point); heavy listeners should throttle their own work. */
     private handleMapPoint;
+    /**
+     * XY snapping's snap-tip (spec: issue #34 Part A — "a snap tip shows
+     * which agent fired on which layer, otherwise users can't tell why a
+     * vertex jumped"). A SEPARATE runtime overlay from the shared
+     * `show-tooltip` singleton (`actions.ts`'s `getOrCreateTooltipOverlay`):
+     * that one is `anchor-from="selection"` (tied to `ctx.selection`) and
+     * shared across every `show-tooltip` behavior a page authors (this
+     * page's own z-tooltip, for one) — reusing it here would fight over the
+     * same element on every hover. This one anchors at a plain, static
+     * `anchor="[lng,lat]"` instead, since a snap position has nothing to do
+     * with whatever `ctx.selection` currently holds.
+     */
+    private ensureSnapTipOverlay;
+    private handleSnapPoint;
     /** Harness map-point injection (spec: "Consumer Testing Surface") — the
      *  same path a real deck click/hover coordinate takes, so the om-map-point
      *  event and custom capture tools are testable without a GPU. */
@@ -285,6 +303,8 @@ export declare class OmMapElement extends HTMLElementBase {
     getLightingInternal(): LightingIR | null;
     /** Resolved terrain IR (headless test inspection) — null = no surface. */
     getTerrainInternal(): TerrainIR | null;
+    /** Resolved clip-box IR (headless test inspection) — null = no active box. */
+    getClipBoxInternal(): ClipBoxIR | null;
     /**
      * Canvas-only scene snapshot (spec: "Snapshot API") — basemap + deck
      * composited at device pixels. DOM widgets/overlays/badge/attribution are

package/dist/elements/om-overlay.d.ts

@@ -36,7 +36,19 @@ export declare class OmOverlayElement extends HTMLElementBase {
      * simply doesn't update this remembered anchor; only a matching
      * selection moves it, and only an explicit `visible="false"` hides it.
      */
+    /**
+     * A 3rd (z) component survives here specifically for the projection at
+     * the bottom of `updatePosition` — a selection's real elevation (a depth
+     * pick against terrain/3D content, see `Selection.coordinate`'s own doc
+     * comment) matters for WHERE on screen the anchor lands under a pitched
+     * camera, even though this class only ever positions in 2D. Dropping it
+     * (projecting at an implied z=0) put a tooltip over an elevated pick tens
+     * to hundreds of pixels from the actual cursor — the anchor was correct
+     * in lng/lat, just projected as if the picked surface were at sea level.
+     */
     private lastAnchor;
+    /** Cached [w, h] for `clip-to-map` (offsetWidth forces layout; flushes run per pointer move) — invalidated by setContent. */
+    private clipSizeCache;
     /** Memoized feature anchor — recomputed only when the layer's data reference or the target id changes (live layers swap data). */
     private featureAnchorCache;
     connectedCallback(): void;

package/dist/geodesy.d.ts

@@ -23,6 +23,25 @@ export type LngLat = [number, number];
 export declare function distanceMeters(a: LngLat, b: LngLat, radius?: number): number;
 /** Total haversine length of a polyline in meters (0 for < 2 points). */
 export declare function pathLengthMeters(points: LngLat[], radius?: number): number;
+export interface PathSample {
+    position: LngLat;
+    /** Cumulative distance (m) from the path's start. */
+    distance: number;
+    /** Index into the ORIGINAL input points when this sample IS one of them (see `resamplePathWithVertices`); absent for interpolated samples. */
+    vertexIndex?: number;
+}
+/**
+ * `count` evenly-spaced points along a multi-segment polyline, by cumulative
+ * distance (spec item E — elevation-profile samples). Walks the segment
+ * lengths to find which segment each target distance falls in, then
+ * `intermediate()`s within it — a straight generalization of that function
+ * from "interpolate one segment" to "interpolate a whole path." `count=1`
+ * returns just the start point; `points.length < 2` returns each input point
+ * at distance 0 (nothing to interpolate); a zero-length path (every point
+ * coincident) returns `count` copies of the start point at distance 0.
+ */
+export declare function resamplePath(points: LngLat[], count: number): PathSample[];
+export declare function resamplePathWithVertices(points: LngLat[], count: number): PathSample[];
 /**
  * Spherical polygon area in m² via the Chamberlain–Duquette line integral (the
  * exact index form Turf's `ringArea` uses, so results match Turf's fixtures).
@@ -40,8 +59,18 @@ export declare function ringPerimeterMeters(ring: LngLat[], radius?: number): nu
  */
 export declare function ringEnclosesPole(ring: LngLat[]): boolean;
 /**
- * Great-circle midpoint of a segment — antimeridian-safe (converts to Cartesian
- * so a segment crossing ±180° gets its label on the shorter arc, not the middle
- * of the wrong way round). Returns [lng (normalized to (−180, 180]), lat].
+ * Point a `fraction` of the way from `a` to `b` along the great-circle path
+ * (spherical slerp) — spec item E's evenly-spaced elevation-profile samples
+ * need this; only the f=0.5 special case (`midpoint`) existed before.
+ * Antimeridian-safe (interpolates the Cartesian unit vectors, not lng/lat
+ * directly, so a segment crossing ±180° doesn't wrap the wrong way).
+ * `f=0` returns `a`, `f=1` returns `b`. Returns [lng (normalized to
+ * (−180, 180]), lat].
+ */
+export declare function intermediate(a: LngLat, b: LngLat, fraction: number): LngLat;
+/**
+ * Great-circle midpoint of a segment — `intermediate(a, b, 0.5)`, kept as its
+ * own name since "the point halfway along a segment" is the common case
+ * (badge label anchors) and reads better than a bare 0.5 at every call site.
  */
 export declare function midpoint(a: LngLat, b: LngLat): LngLat;

package/dist/{geoparquet-Dix4lTNy.js → geoparquet-By98JVB0.js}

@@ -1,4 +1,4 @@
-import { r as p, n as d } from "./index-1UgNlfGR.js";
+import { r as p, n as d } from "./index-Cxo9mCw_.js";
 function g(t) {
   if (t == null) return !0;
   const e = t, n = e.id?.code;

package/dist/html-data.d.ts

@@ -15,9 +15,9 @@ interface TagData {
     }[];
 }
 /** Hand-authored action list — validated against hasAction() in html-data.test.ts. */
-export declare const BUILTIN_ACTIONS: readonly ["toggle-layer", "zoom-in", "zoom-out", "filter-layer", "highlight-feature", "fade", "pulse", "populate", "trace", "story-play", "story-pause", "story-seek", "fly-to", "zoom-to-feature", "show-overlay", "hide-overlay", "show-tooltip", "hide-tooltip", "draw-mode", "draw-commit", "draw-cancel", "draw-delete", "draw-clear", "draw-config", "draw-save", "measure-mode", "measure-clear", "measure-units", "set-basemap", "set-lighting", "set-terrain", "set-widgets-visible", "undo", "redo"];
+export declare const BUILTIN_ACTIONS: readonly ["toggle-layer", "zoom-in", "zoom-out", "filter-layer", "highlight-feature", "fade", "pulse", "populate", "trace", "story-play", "story-pause", "story-seek", "fly-to", "zoom-to-feature", "show-overlay", "hide-overlay", "show-tooltip", "hide-tooltip", "draw-mode", "draw-commit", "draw-cancel", "draw-delete", "draw-clear", "draw-config", "draw-save", "export-region-3d", "measure-mode", "measure-clear", "measure-units", "set-basemap", "set-lighting", "set-terrain", "set-clip-box", "clip-box-edit", "set-widgets-visible", "undo", "redo"];
 /** Hand-authored widget types — validated against the widget registry in html-data.test.ts. */
-export declare const BUILTIN_WIDGETS: readonly ["legend", "layer-switcher", "zoom-controls", "scale-bar", "attribution", "filter", "vega-lite", "player", "draw", "measure", "basemap-switcher", "lighting", "undo-redo", "widgets-toggle", "ifc-browser", "ifc-legend", "feature-inspector", "ifc-inspector", "ifc-loader", "ifc-clash"];
+export declare const BUILTIN_WIDGETS: readonly ["legend", "layer-switcher", "zoom-controls", "scale-bar", "attribution", "filter", "vega-lite", "dynamic-chart", "player", "draw", "measure", "basemap-switcher", "lighting", "clip-box", "undo-redo", "widgets-toggle", "ifc-browser", "ifc-legend", "feature-inspector", "ifc-inspector", "ifc-loader", "ifc-clash"];
 export declare function buildHtmlCustomData(): {
     version: number;
     tags: TagData[];

package/dist/{index-BQMjW5w0.js → index-Bx9GFkrn.js}

@@ -1,4 +1,4 @@
-import { ak as Bt, ax as Xt, ay as Yt, az as Us } from "./index-1UgNlfGR.js";
+import { ak as Bt, ax as Xt, ay as Yt, az as Us } from "./index-Cxo9mCw_.js";
 import { w as gs, t as Hs, f as Ws, m as Qs } from "./mgrs-BY9bIvp4.js";
 import { c as Xs } from "./convert-arrow-schema-DrAihRf9.js";
 import { y as Ys, A as bt, a as Ks, z as Vs, R as Zs } from "./recordbatch-Bpc0uxFn.js";

package/dist/{index-CXPaeisL.js → index-CqC4sW_k.js}

@@ -1,4 +1,4 @@
-import { ae as _t, af as Ct } from "./index-1UgNlfGR.js";
+import { ae as _t, af as Ct } from "./index-Cxo9mCw_.js";
 function Yt(e, r, t = 2, i, o = "xy") {
   const s = r && r.length, l = s ? r[0] * t : e.length;
   let c = Ut(e, 0, l, t, !0, i && i[0], o);