@nika-js/onlymap 0.6.0 → 0.6.2

package/dist/crs.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Bundled coordinate reference systems, shared by every decoder that has to
+ * turn projected coordinates into lon/lat.
+ *
+ * Extracted from cityjson.ts so the IFC path can reuse it. An IFC file's
+ * `IfcMapConversion` states its position in a projected CRS named by
+ * `IfcProjectedCRS`, exactly as CityJSON states one in
+ * `metadata.referenceSystem`, so both need the same table and the same lazy
+ * proj4 import. Duplicating it would have meant a Dutch model georeferencing
+ * correctly as CityJSON and 108 m out as IFC.
+ *
+ * proj4 is imported LAZILY at the point of use, never at module scope: most
+ * files need no projection at all, and the ones that do are already paying for
+ * a parse.
+ */
+export interface CrsEntry {
+    def: string;
+    /** Source stores [northing, easting] / [lat, lon] — swap before handing to proj4. */
+    swapXY?: boolean;
+    /** Already angular: no reprojection, but horizontal metrics need a local metric frame. */
+    geographic?: boolean;
+}
+/** Compound (horizontal + vertical) codes → the horizontal component that actually projects. */
+export declare const COMPOUND_TO_HORIZONTAL: Record<number, number>;
+export declare const CRS_DEFS: Record<number, CrsEntry>;
+/** The EPSG codes this build can convert without help. */
+export declare function bundledCrsCodes(): number[];
+/**
+ * Projected (or geographic) coordinates in EPSG:`code` -> `[lon, lat]`.
+ *
+ * Returns null when the code is not bundled, which callers must treat as "I
+ * cannot place this" rather than silently substituting something else — a
+ * wrong position looks exactly like a right one.
+ *
+ * `x`/`y` are given easting-first; entries flagged `swapXY` (Japan's plane
+ * systems, RD's formal axis order) are swapped here so callers never have to
+ * know which convention a CRS uses.
+ */
+export declare function projectedToLonLat(code: number, x: number, y: number): Promise<[number, number] | null>;
+/**
+ * Bearing of the projection's GRID north at a point, in degrees clockwise from
+ * true north — the grid convergence.
+ *
+ * Measured rather than derived: unproject the point and a second one a short
+ * step further north IN GRID SPACE, then take the true bearing between them.
+ * That works for any projection in the table without per-CRS formulae, and it
+ * matters because a model aligned to a national grid is NOT aligned to true
+ * north. Dutch RD at Rotterdam is off by -0.735 degrees.
+ */
+export declare function gridConvergence(code: number, x: number, y: number, step?: number): Promise<number | null>;

package/dist/ctx.d.ts

@@ -35,6 +35,12 @@ export interface RuntimeContext {
         project(lngLat: [number, number]): [number, number];
     };
     selection: Selection | null;
+    /**
+     * The decoded EXT_structural_metadata property table for a `pick-features`
+     * layer, indexed BY feature ID, or null before its first tile has loaded.
+     * Watch the `features` token to re-render when it arrives.
+     */
+    features(layerId: string): Record<string, unknown>[] | null;
     /** Manifest undo/redo state (spec: "Undo / Redo — Manifest History") — drive it via emit("undo"/"redo"). Always false on the programmatic/React path (the app owns state there). */
     history: {
         canUndo: boolean;
@@ -49,6 +55,7 @@ export interface RuntimeContext {
 }
 export interface BuildCtxDeps {
     layerIRs: ReadonlyMap<string, LayerIR>;
+    featureTables?: ReadonlyMap<string, Record<string, unknown>[]>;
     core: RuntimeCore;
     mapEl: Element;
     selection: Selection | null;
@@ -62,4 +69,4 @@ export declare function viewportBounds(viewport: ReturnType<RuntimeCore["getView
 /** `ctx.layers` / the `layers` external store — one builder for both (spec: "External-Store Contract"). */
 export declare function buildLayerMetas(layerIRs: ReadonlyMap<string, LayerIR>): LayerMetaSnapshot[];
 /** Built fresh on every widget-render invocation — never mutated, never reused. */
-export declare function buildCtx({ layerIRs, core, mapEl, selection, history }: BuildCtxDeps): RuntimeContext;
+export declare function buildCtx({ layerIRs, core, mapEl, selection, history, featureTables }: BuildCtxDeps): RuntimeContext;

package/dist/data-layer.d.ts

@@ -90,6 +90,14 @@ 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. */
+export declare function endDataOwnerUpdate(owner: DataTransportOwner): void;
+/** Release every fetch/poller/socket held by an owner (unmount, dispose, or suspend). */
+export declare function releaseDataOwner(owner: DataTransportOwner): void;
 /**
  * A source plugin supplies domain decoding (and optionally a subscription
  * handshake); the transport (WebSocket, reconnect, flush) is generic.
@@ -128,7 +136,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 +170,9 @@ 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;
+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). */
-export declare function isPendingData(url: string): boolean;
+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,14 +20,16 @@
 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";
+import { type ValidationEntry } from "../validation";
 import type { LayerIR } from "../ir";
 import type { Selection } from "../selection";
 import type { MapViewport } from "../basemap";
 interface OverlayHost {
-    updatePosition(viewport: MapViewport | undefined, selection: Selection | null): void;
+    updatePosition(viewport: MapViewport | undefined, selection: Selection | null, pickType?: "hover" | "click"): void;
     /**
      * Screen rect for collision-dim (spec: "Overlap avoidance") — non-null
      * only when the overlay is VISIBLE and participates in dimming. Returns
@@ -43,17 +45,32 @@ 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;
+    /** Decoded property tables per pick-features layer — see RuntimeCoreCallbacks.onFeatureTable. */
+    private featureTables;
     private layerIRs;
     private selection;
+    /**
+     * The pointer event behind the most recent pick — kept SEPARATELY from
+     * `selection` because empty picks store `selection = null`, losing their
+     * type, yet `selection-type`-scoped overlays must tell a click on empty
+     * space (dismisses a click popup) from a hover over empty space (inert).
+     */
+    private lastPickType;
     private widgets;
     private overlays;
     private overlayFlushPending;
     private errorPanel;
     private runtimeErrors;
+    /** Dedup guard for the approximate-BIM-georeferencing warning — same shape as applyLicenseGates' own `warned` set, keyed per layer id. */
+    private warnedApproximatePlacement;
+    /** Dedup guard for the no-terrain-for-elevation error — same shape as `warnedApproximatePlacement`. */
+    private erroredNoTerrainForElevation;
     private readyFired;
     private visibleSizeChecked;
     /** Custom-state holder for the `om-collapsed` height-floor marker — see applyHeightFloor. */
@@ -231,7 +248,7 @@ export declare class OmMapElement extends HTMLElementBase {
      * by mountForTest's pick()/clearSelection(), not part of the public
      * authoring surface.
      */
-    injectPickInternal(selection: Selection | null): void;
+    injectPickInternal(selection: Selection | null, pickType?: "hover" | "click"): void;
     injectDragPickInternal(selection: Selection): void;
     /** Every click/hover map coordinate (spec: "Manual Drawing"): drives the
      *  internal draw controller AND fires the public `om-map-point` event, so
@@ -243,6 +260,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. */
@@ -271,6 +302,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
@@ -341,6 +374,16 @@ export declare class OmMapElement extends HTMLElementBase {
      * still runs validation and fires the event, just skips the on-page panel
      * (spec: "for teams building their own error UI").
      */
+    /**
+     * Reports a runtime-discovered validation entry — deck.gl crashes and
+     * license-limit violations already flow through this (via `onRuntimeError`
+     * below); this is also the entry point for facts a WIDGET discovers
+     * directly (no round trip through RuntimeCore) since it already holds an
+     * `<om-map>` reference — see `ifc-loader`'s approximate-georeferencing
+     * warning. Same access-pattern precedent as `registerWidgetInternal`
+     * above: real and callable, not part of the documented public API.
+     */
+    reportRuntimeErrorInternal(entry: ValidationEntry): void;
     private publishValidation;
 }
 declare global {

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;
@@ -86,5 +98,5 @@ export declare class OmOverlayElement extends HTMLElementBase {
      * must not flicker widgets). Only stable author popups drive dimming.
      */
     getVisibleRect(): DOMRect | null;
-    updatePosition(viewport: MapViewport | undefined, selection: Selection | null): void;
+    updatePosition(viewport: MapViewport | undefined, selection: Selection | null, pickType?: "hover" | "click"): void;
 }

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

@@ -22,6 +22,10 @@ export declare class OmWidgetElement extends HTMLElementBase implements WidgetHo
     private renderFn?;
     private watchTokens;
     private hostStyle;
+    /** The registered implementation behind `type="…"` — kept so real removal can call its optional destroy() hook. */
+    private impl;
+    /** One pending real-removal check at a time — a remove→insert→remove within a single task must not run destroy twice. */
+    private destroyCheckPending;
     /** Live placement attributes (spec: "Widget Layout Manager") — position/order edits (incl. undo replays) re-slot without a remount. */
     static readonly observedAttributes: string[];
     connectedCallback(): void;

package/dist/feature-colors.d.ts

@@ -0,0 +1,41 @@
+/** Colour-blind-safe categorical default, cycled when a field has more values than entries. */
+export declare const FEATURE_PALETTE: string[];
+export declare const FEATURE_RAMP: string[];
+export declare function resolveFeatureColor(entry: unknown): [number, number, number];
+/**
+ * The GLOBAL half of feature colouring — everything derived from the WHOLE
+ * accumulated table, none of it indexed by feature ID. Serializable on
+ * purpose (`order` is entries, not a Map): its identity is the memo key that
+ * keeps per-tile style tables (and their GPU textures) stable across
+ * reconciles and animation frames.
+ */
+export interface FeatureColorMapping {
+    kind: "categorical" | "graduated";
+    field: string;
+    /** graduated: the max across every loaded tile (colours stay comparable as tiles stream in). */
+    max?: number;
+    /** categorical: global value → first-seen order (assigns each value a stable palette slot). */
+    order?: [string, number][];
+    /** Resolved palette/ramp — author `feature-palette` or the built-in defaults. */
+    colors: unknown[];
+    strength: number;
+}
+/**
+ * Builds the mapping from the layer's ACCUMULATED rows (all tiles).
+ * Returns null when neither colouring attribute is asked for — the model then
+ * renders in its own IFC surface colours. Authored `feature-styles` always
+ * wins upstream: the declarative attributes are sugar over the same table,
+ * never an override of it.
+ */
+export declare function buildFeatureColorMapping(rows: Record<string, unknown>[], categorical: string | undefined, graduated: string | undefined, palette: unknown[] | undefined, strength: number): FeatureColorMapping | null;
+/**
+ * Applies the mapping to ONE tile's own rows — the per-tile style table, index
+ * = that tile's local feature ID. A category unseen in the global order (a
+ * race while tiles stream; the next accumulate pass rebuilds the mapping)
+ * falls back to slot 0 rather than being unstyled, matching the pre-split
+ * behavior for unknown values.
+ */
+export declare function applyFeatureColorMapping(rows: Record<string, unknown>[], mapping: FeatureColorMapping): {
+    color: [number, number, number];
+    strength: number;
+}[];

package/dist/geodesy.d.ts

@@ -23,6 +23,22 @@ 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;
+}
+/**
+ * `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[];
 /**
  * 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 +56,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-Bm8pfxyo.js → geoparquet-DapHATA0.js}

@@ -1,4 +1,4 @@
-import { r as p, n as d } from "./index-Bz-rbmhj.js";
+import { r as p, n as d } from "./index-7B-6Cbzu.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"];
+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[];