@nika-js/onlymap 0.6.2 → 0.6.7

package/CHANGELOG.md

@@ -8,6 +8,87 @@ Note: npm collapsed a few closely-spaced releases — the GPX/FlatGeobuf (0.5.4)
 and GeoParquet (0.5.5) work shipped to npm together as **0.5.6**, so npm's
 version list jumps 0.5.3 → 0.5.6. Each logical version is listed here regardless.
 
+## 0.6.7 — 2026-08-17
+
+### Added
+- **Routing & tracking layer types** — `<om-layer type="Route" geometry='{"type":"LineString","coordinates":[...]}'>` draws a styled route (casing, colored line, origin/destination markers) from geometry you already have, resolving synchronously with no network call; `origin`/`destination` (+ `provider`, default `"nika"`, + optional `waypoints`/`profile`) resolve one asynchronously instead via a registered `RoutingProvider` (`OmMap.registerRoutingProvider`). `follow="fit-route"` auto-fits the camera once the route resolves. `<om-layer type="Tracking" get-position="[$lng,$lat]">` renders one moving entity with bearing-derived icon rotation (`bearing-field`, default `"bearing"`) that glides smoothly between position updates (`interpolate-ms`, default `1000`) instead of jumping; `follow="follow"` eases the camera along with it. Live position data arrives through the ordinary `data`/`source` mechanism — no separate tracking-subscription API. `Route`/`Tracking` expand into ordinary `PathLayer`/`IconLayer` instances internally, the same pattern `BIMLayer` already uses for `Tile3DLayer`.
+- The bundled `nika` routing provider is registered by default so `type="Route"` works out of the box once NIKA's routing service exists — its endpoint is currently an **unverified placeholder** (no such backend is live yet); register a working provider with `OmMap.registerRoutingProvider(name, provider)` for anything that needs to resolve routes today, or author `geometry` directly.
+- Two gallery examples: **Routing & Tracking** (direct-geometry route + a simulated live GPS feed gliding a tracking marker) and **Compute a Route** (click two points anywhere and a ~15-line page-script `RoutingProvider` adapter over OSRM's keyless public demo server computes the street-following drive — the click handler only writes `origin`/`destination` attributes; reconcile, the provider round-trip, and the camera re-fit are all library machinery). The OSRM adapter recipe also ships in the skill's syntax reference.
+
+## 0.6.6 — 2026-08-14
+
+### Added
+- **Multi-dimension categorical GPU filtering** — `filter-category-fields='[{"field":"fuel","categories":["Coal","Gas"]},{"field":"region","categories":["West"]}]'` filters on up to 4 categorical fields at once, AND'd together and combinable with an active numeric filter (a row must pass every dimension of both kinds). `filter-category`/`filter-categories` (single dimension) keep working unchanged. The built-in `<om-widget type="filter">` now auto-renders a checkbox list (one per distinct value present in the data, with its row count) instead of a slider when its `field` is declared categorically — the mode is inferred from the layer's own filter, never a separate widget attribute. The React/programmatic front-ends get the equivalent `filterCategoryFields` prop.
+
+### Fixed
+- `ctx.stats`/`ctx.dataInViewport` now respect an active categorical filter (`filter-category`/`filter-categories`) — previously only numeric filters were coherence-rule-aware, so a chart could silently disagree with a categorically-filtered map.
+- Story scrubbing and undo/redo now correctly restore an active categorical filter — previously `filter-category`/`filter-categories` weren't captured at all, so rewinding past a categorical `filter-layer` step silently dropped it.
+
+## 0.6.5 — 2026-08-13
+
+### Added
+- **Multi-dimension GPU filtering** — `filter-fields='[{"field":"magnitude","range":[4,10]},{"field":"time","range":[…]}]'` filters on up to 4 fields at once (`DataFilterExtension`'s own ceiling), AND'd together (a row must pass every dimension). `filter-field`/`filter-range` (single dimension) keep working unchanged — `filter-fields` is additive, not a replacement. Place one `<om-widget type="filter" layer="…" field="…">` per dimension; the `filter-layer` action merges range updates onto the matching dimension instead of replacing the whole filter, so independent widgets never clobber each other. `ctx.stats`/`ctx.dataInViewport`'s filter-aware coherence rule applies the same AND-across-dimensions test CPU-side. The React/programmatic front-ends get the equivalent `filterFields` prop.
+
+### Fixed
+- `populate` on a layer with more than one authored filter dimension now sweeps the first and holds the rest at their authored range, instead of a type error.
+
+## 0.6.4 — 2026-08-12
+
+React Native core prerequisites. 0.6.3 was already tagged for release when this
+work landed, so it carries its own version rather than redefining that one.
+
+### Added
+- **Descriptor-owned data transports**: fetches, polling loops, and WebSockets
+  are shared by transport identity and reference-counted across active map
+  owners. Layer removal or option changes release stale handles; map disposal
+  releases all handles; `MapController.suspend()` and `resume()` provide an
+  app-background lifecycle without discarding canonical descriptors. A release
+  the owner means to reverse — `suspend()`, removing or re-pointing a layer —
+  leaves its last rows as a cold snapshot, so resuming or re-adding repaints
+  immediately instead of flashing empty; a permanent teardown (`destroy()`, an
+  `<om-map>` leaving the document) keeps nothing.
+- `releaseDataOwner(owner, {retain})` plus an optional `owner` argument on
+  `descriptorToIR` — descriptor-owned transport lifetime for hosts that drive
+  the IR directly instead of through `MapController`.
+- **JSON-safe programmatic descriptors**: schema-declared accessor props may
+  use restricted OnlyMap expression strings, and
+  `snapshotDescriptorIR(descriptors)` produces deterministic, fetch-free IR
+  snapshots for native/cross-process parity tests. The React layer adapter now
+  exposes a pure descriptor conversion path and mirrors dashed-line options.
+- **App-scoped packaged licenses**: signed license tokens may now declare exact
+  native application identifiers in an `apps` claim, independently or together
+  with web domains. Native hosts pass platform-derived identity to
+  `configureLicense(key, {appId})`; page or bridge input must never supply it.
+  Only the `domains` claim is pinned by the browser — `apps` is asserted by the
+  host, so scope a native key by both where you can.
+
+### Changed
+- **Live transports no longer live for the page.** A `ws(s)://` socket, a
+  `refresh` poll loop, and an in-flight `data` fetch previously outlived the
+  layer that opened them; they are now stopped when their last descriptor owner
+  releases them — layer removal, a change to `data`/`source`/`key`/`flush`/
+  `refresh`, `MapController.destroy()`/`suspend()`, or an `<om-map>` leaving the
+  document. Pages that relied on a connection surviving layer removal must keep
+  the layer mounted (`visible="false"` does not release) or re-add it, which now
+  repaints from the retained cold snapshot. Re-parenting a live `<om-map>` in
+  the DOM does **not** drop its transports: the release is deferred a microtask,
+  so a synchronous disconnect→reconnect keeps the socket open.
+- The data cache is keyed by **transport identity** (URL plus live-source
+  options) rather than URL alone. Two layers on the same URL still share one
+  transport when their stream/poll options match, and now correctly get separate
+  ones when they do not.
+
+## 0.6.3 — 2026-08-12
+
+### Fixed
+- **Measure labels no longer render painted onto the terrain** (reported readability bug). The distance/area badges were `terrain="drape"`, and draping renders a layer INTO the terrain's own texture — so a badge came out flat on the ground, stretching and skewing with the slope and going edge-on to a pitched camera. They now use `terrain="offset"`, which keeps the badge a screen-facing billboard and only lifts its anchor to the surface, plus a 14px screen-space lift so a pill never reads as half-buried in a rise.
+- **`PopupLayer`'s default terrain mode is now `offset` rather than `drape`**, for the same reason and following the rule the library already applied to 3D models: billboarded content anchors ON the surface instead of being painted onto it. This affects any `PopupLayer` under an active `terrain` that did not set the attribute explicitly; `terrain="drape"` still does the old thing for anyone who genuinely wants text painted onto the ground like a road marking.
+
+### Added
+- **The elevation profile marks the footprint's own corners.** `profileSeries` samples that ARE a drawn vertex now carry `vertexIndex` (0-based, in draw order; the closing sample back at the start carries the last index), and interpolated samples omit the field entirely so a Vega-Lite spec separates them with `isValid(datum.vertexIndex)`. The measure widget's built-in profile chart uses this: a clean line, a distinct point on each real corner with a `Vertex / Distance / Elevation` tooltip, and vertex 0 labelled **"1 · Start"** (the exact badge text used on the map) — replacing the old `point: true`, which dotted all ~50 interpolated samples equally and so said nothing about which points were corners. New `ProfilePoint` type, exported.
+- **Direction badges on the map: `1 · Start` and `2`.** Two problems, one marker. The profile runs around a closed loop, so its chart has a leftmost point but the map had no cue for WHICH corner that was; and marking only the start is still ambiguous, because from that corner the ring could run either way and clockwise vs counter-clockwise produce mirror-image profiles. The first two vertices are badged in draw order — the minimum that fixes a direction, and a constant cost: one badge per vertex would grow the clutter precisely as a footprint got complicated enough to need the cue. Draw order IS the order the profile walks, so badge N and the chart's Vertex N are the same point by construction. The chart still marks every corner. Displayed 1-based; `ProfilePoint.vertexIndex` stays 0-based, being an array index. Shown only with `profile` on, and cleared with the footprint.
+- **`resamplePathWithVertices(points, count)`** in `geodesy.ts` — `resamplePath`'s evenly-spaced curve with the path's own vertices merged in by distance and tagged, coinciding samples replaced rather than duplicated. This is what makes a profile addressable back to the geometry that produced it.
+
 ## 0.6.2 — 2026-08-12
 
 ### Added

package/README.md

@@ -72,7 +72,7 @@ Or with no build step at all, straight from a CDN:
 
 The bare package URL serves `dist/onlymap.standalone.js`, a single-file bundle built for exactly this (jsDelivr too). Use a CDN that serves the package's raw files — **not** a rebundling CDN like esm.sh, which re-splits the bundle into duplicate copies of the deck.gl/luma.gl runtime and breaks every layer's shader compilation.
 
-Then `npx @nika-js/onlymap init` wires up VS Code IntelliSense and `!`-prefixed manifest snippets for your project. The library ships with 1,083 unit/behavioral tests and 62 Playwright GPU tests.
+Then `npx @nika-js/onlymap init` wires up VS Code IntelliSense and `!`-prefixed manifest snippets for your project. The library ships with 1,208 unit/behavioral tests and 64 Playwright GPU tests.
 
 The [examples](https://github.com/NikaGeospatial/onlymapjs/tree/main/examples) are the best tour: widgets, behaviors & overlays, basemaps, columnar/Arrow data, manual drawing, 3D models, scene lighting (with the native lighting widget), DEM terrain, a live WebSocket ship feed, and a polled driver fleet.
 
@@ -83,8 +83,8 @@ A handful of elements, one rule: **attributes are kebab-case versions of deck.gl
 | Element | Role |
 |---|---|
 | `<om-map>` | The map. `center`, `zoom`, `pitch`, `bearing`; `basemap` takes a free preset (`positron`, `liberty`, `dark-matter`, `osm`, …), a style URL, or `"none"` (standalone canvas) — and switches **live**; `validate` for a live on-page error panel. Give it a height: a custom element is `display:inline` by default, so the library injects a `display:block` default (fills a sized parent, else a 400px floor) to keep a bare map visible, but set an explicit height (`om-map { height: 100vh }`) for real layout — any height you set wins outright, including one below the floor. A map that still collapses warns in the console; `hidden` and `display:none` maps stay hidden and stay quiet. |
-| `<om-layer>` | Any of **37 layer types** by name — all of deck.gl's core, geo, aggregation, and mesh layers (Scatterplot, GeoJson, Arc, Path, Heatmap, Hexagon, Trips, Tile, Tile3D, Scenegraph, …) plus the built-in `PopupLayer` for WebGL badges/labels at scale, the native `COGLayer` for GeoTIFF rasters, `ZarrLayer` for chunked Zarr/GeoZarr rasters, `ImageOverlay` for georeferenced drone JPEGs, and `BIMLayer` for BIM source files (`.ifc` today) loaded straight in the browser, no pre-conversion step. `id` required; `label`/`color` feed the legend. |
-| `<om-widget>` | UI panels. Built-ins: `legend` (symbology-aware: color scales render as gradient ramps or class ranges, categorical ternaries as discrete palettes), `layer-switcher`, `basemap-switcher`, `lighting`, `clip-box`, `zoom-controls`, `undo-redo`, `scale-bar` (metric/imperial/nautical `units`), `attribution`, `filter`, `draw` (point/line/polygon sketch capture, GeoJSON save/autosave; `export-3d` adds an "Export 3D" button that clips loaded `Tile3DLayer`/`BIMLayer` content to the drawn footprint and downloads it as a portable GLB — re-framed to a local coordinate frame at the footprint's own centroid, each triangle carrying its own source color as vertex colors, no textures — or, with `export-3d="b3dm"`, the same mesh wrapped for Cesium/3D-Tiles pipelines; only currently-visible 3D Tiles/BIM layers are included — a layer hidden via `visible="false"` or the `toggle-layer` action is skipped, with a distinct console warning for "nothing loaded" vs. "everything hidden"), `measure` (geodesic distance + area + cut/fill volume — live labels, `units` toggle, an `om-measure` readout event; `modes="distance area volume"` adds a footprint-then-extrude tool: outline a polygon, double-click to close it — it turns solid teal, ready — then drag the double-headed arrow gizmo that appears at its centroid up to fill or down to cut, reading out Cut/Fill/Net (signed, fill−cut)/Total (unsigned, cut+fill) volume plus Area/Perimeter, each labelled with its own sign convention. The math is a REAL per-cell grid integration: closing a footprint bulk-loads its covering DEM tiles, lays a metric grid in a local tangent frame at the ring centroid (cell size = the DEM's ground-sample distance; scanline point-in-polygon; bilinear, tile-seam-correct sampling; worker-offloaded), and integrates terrain-vs-base per cell — mixed cut AND fill within one footprint on undulating ground, with a published ±error (per-cell cellArea × 1.5 × GSD, summed per side), the cell size used, and a no-data warning all carried on the `om-measure` readout (`cellSizeM`/`gsdM`/`cutErrorM3`/`fillErrorM3`/`nodataFraction`). A `base-surface` attribute picks the reference surface: `custom` (default — the gizmo's draggable target plane), or boundary-derived stockpile strategies with no gizmo (`triangulated` boundary TIN, `plane` least-squares fit, `lowest`/`highest`/`average`). On `custom`, the extruded prism's own boundary hugs each corner's real ground elevation by default (so it doesn't visibly float above or sink below sloped terrain) — a "Flat target plane" toggle button appears above the readout once a footprint closes, switching that rendering to a single level plane instead (a rendering choice only; the underlying cut/fill numbers were already computed against one flat target elevation either way). Requires `terrain` on `<om-map>` — validation warns if `volume` is in `modes` with none (without terrain a flat-plane fallback runs, with no error figures — nothing honest to quote). A `profile` attribute alongside `modes` — not a mode of its own — samples elevation around a volume footprint's own perimeter as it's drawn and closed, live, and dispatches it on `om-measure`'s `profileSeries` field for a `dynamic-chart` widget to plot. Also volume-only: `deadband` (m³) zeroes out a Cut/Fill figure below the threshold, filtering drag noise near zero height (Cut/Fill/Net/Total are always RAW geometric volumes — deliberately unaffected by `swell`/`shrink`, so they keep answering "does this reach target elevation" regardless of what material's configured); `density` (t/m³ metric, lb/yd³ imperial) and `swell`/`shrink` (multipliers, default 1×) instead populate a separate Material section, standard Bank/Loose/Compacted earthworks convention — Adjusted Cut = raw × swell (loose/haul volume, bigger — excavating adds air voids), Adjusted Fill = raw ÷ shrink (loose/borrow volume needed, also bigger — the raw fill is already the compacted target void), plus Cut/Fill tonnage computed from the raw (not adjusted) volume, since swell/shrink change volume, not mass; the section only appears once at least one of `density`/`swell`/`shrink` is actually configured, no separate toggle. A `stale` field on the `om-measure` readout flags the brief window between a footprint committing and its elevation sample resolving, so a consumer doesn't read numbers left over from a prior footprint as current), `vega-lite` (live charts bound to a layer's data), `dynamic-chart` (the same Vega-Lite rendering, but data-driven by a live DOM event instead of a layer — `on="<event-name>"` + `series-field="<name>"` reads `event.detail[seriesField]` as the chart's `values` on every matching event, redrawing at a fixed `width`; a feature "freezes" it for free by simply omitting that field the next time it fires, no separate pause API needed), and the BIM set `ifc-browser` / `feature-inspector` / `ifc-loader` / `ifc-clash`. Or write your own inline with HTML + a `<script type="om/widget">`. Adjacent compact button widgets (`zoom-controls`, `undo-redo`, `widgets-toggle`) **auto-cluster** into one control group (opt out per widget with `cluster="false"`), and `<om-map widgets-hidden>` / the `set-widgets-visible` action / `<om-widget type="widgets-toggle">` hide all authored chrome without destroying it — provider attribution and the license badge never hide. **Placement is managed**: `position` takes one of 8 logical, RTL-aware slots (`top-start`, `top-center`, `top-end`, `center-start`, `center-end`, `bottom-start`, `bottom-center`, `bottom-end`; legacy corner names alias) — same-slot widgets stack with flush edges and a shared gap, `order` sets in-slot ordering, and `position="manual"` opts out entirely (a plain block you style yourself, even outside the map). At map widths ≤640px, managed widgets automatically move into accessible top/end/bottom/start drawers; `fold="never"` keeps an essential control out, `widgets-fold="off"` disables folding, and `--om-widget-fold-breakpoint` changes the map-width threshold. Provider attribution is an in-flow member of `bottom-end` and the license badge of `bottom-start`, so neither covers a widget. A slot dims automatically while an open popup covers it (`widgets-dim="off"` to disable), except slots containing required chrome. Themeable from plain page CSS via custom properties: `om-map { --om-widget-bg: #111827; --om-widget-fg: #f9fafb; }` (also `-muted`, `-border`, `-hover-bg`, `-accent`), plus layout tokens (`--om-widget-inset-x/-y`, `--om-widget-gap-x/-y`, `--om-widget-opacity`, `--om-widget-radius`) or the no-CSS sugar `<om-map widget-style="gap:10 opacity:0.9">`. |
+| `<om-layer>` | Any of **39 layer types** by name — all of deck.gl's core, geo, aggregation, and mesh layers (Scatterplot, GeoJson, Arc, Path, Heatmap, Hexagon, Trips, Tile, Tile3D, Scenegraph, …) plus the built-in `PopupLayer` for WebGL badges/labels at scale, the native `COGLayer` for GeoTIFF rasters, `ZarrLayer` for chunked Zarr/GeoZarr rasters, `ImageOverlay` for georeferenced drone JPEGs, `BIMLayer` for BIM source files (`.ifc` today) loaded straight in the browser with no pre-conversion step, and `Route`/`Tracking` for styled routes and live position tracking. `id` required; `label`/`color` feed the legend. |
+| `<om-widget>` | UI panels. Built-ins: `legend` (symbology-aware: color scales render as gradient ramps or class ranges, categorical ternaries as discrete palettes), `layer-switcher`, `basemap-switcher`, `lighting`, `clip-box`, `zoom-controls`, `undo-redo`, `scale-bar` (metric/imperial/nautical `units`), `attribution`, `filter`, `draw` (point/line/polygon sketch capture, GeoJSON save/autosave; `export-3d` adds an "Export 3D" button that clips loaded `Tile3DLayer`/`BIMLayer` content to the drawn footprint and downloads it as a portable GLB — re-framed to a local coordinate frame at the footprint's own centroid, each triangle carrying its own source color as vertex colors, no textures — or, with `export-3d="b3dm"`, the same mesh wrapped for Cesium/3D-Tiles pipelines; only currently-visible 3D Tiles/BIM layers are included — a layer hidden via `visible="false"` or the `toggle-layer` action is skipped, with a distinct console warning for "nothing loaded" vs. "everything hidden"), `measure` (geodesic distance + area + cut/fill volume — live labels, `units` toggle, an `om-measure` readout event; `modes="distance area volume"` adds a footprint-then-extrude tool: outline a polygon, double-click to close it — it turns solid teal, ready — then drag the double-headed arrow gizmo that appears at its centroid up to fill or down to cut, reading out Cut/Fill/Net (signed, fill−cut)/Total (unsigned, cut+fill) volume plus Area/Perimeter, each labelled with its own sign convention. The math is a REAL per-cell grid integration: closing a footprint bulk-loads its covering DEM tiles, lays a metric grid in a local tangent frame at the ring centroid (cell size = the DEM's ground-sample distance; scanline point-in-polygon; bilinear, tile-seam-correct sampling; worker-offloaded), and integrates terrain-vs-base per cell — mixed cut AND fill within one footprint on undulating ground, with a published ±error (per-cell cellArea × 1.5 × GSD, summed per side), the cell size used, and a no-data warning all carried on the `om-measure` readout (`cellSizeM`/`gsdM`/`cutErrorM3`/`fillErrorM3`/`nodataFraction`). A `base-surface` attribute picks the reference surface: `custom` (default — the gizmo's draggable target plane), or boundary-derived stockpile strategies with no gizmo (`triangulated` boundary TIN, `plane` least-squares fit, `lowest`/`highest`/`average`). On `custom`, the extruded prism's own boundary hugs each corner's real ground elevation by default (so it doesn't visibly float above or sink below sloped terrain) — a "Flat target plane" toggle button appears above the readout once a footprint closes, switching that rendering to a single level plane instead (a rendering choice only; the underlying cut/fill numbers were already computed against one flat target elevation either way). Requires `terrain` on `<om-map>` — validation warns if `volume` is in `modes` with none (without terrain a flat-plane fallback runs, with no error figures — nothing honest to quote). A `profile` attribute alongside `modes` — not a mode of its own — samples elevation around a volume footprint's own perimeter as it's drawn and closed, live, and dispatches it on `om-measure`'s `profileSeries` field for a `dynamic-chart` widget to plot. Each sample is `{x: distance-from-start-m, y: elevation-m}`, and samples that ARE one of the drawn footprint's own corners additionally carry `vertexIndex` (0-based, in draw order) — so a chart can mark the real corners instead of every interpolated sample, and the widget's built-in profile chart marks each corner, labelling the first `1 · Start`. The map badges the first two vertices in draw order (`1 · Start`, `2`), which states the ring's direction outright — a start marker alone leaves clockwise vs counter-clockwise ambiguous, and the two wind to mirror-image profiles. Two badges is the minimum that fixes a direction and a constant cost regardless of how many corners the footprint has. Also volume-only: `deadband` (m³) zeroes out a Cut/Fill figure below the threshold, filtering drag noise near zero height (Cut/Fill/Net/Total are always RAW geometric volumes — deliberately unaffected by `swell`/`shrink`, so they keep answering "does this reach target elevation" regardless of what material's configured); `density` (t/m³ metric, lb/yd³ imperial) and `swell`/`shrink` (multipliers, default 1×) instead populate a separate Material section, standard Bank/Loose/Compacted earthworks convention — Adjusted Cut = raw × swell (loose/haul volume, bigger — excavating adds air voids), Adjusted Fill = raw ÷ shrink (loose/borrow volume needed, also bigger — the raw fill is already the compacted target void), plus Cut/Fill tonnage computed from the raw (not adjusted) volume, since swell/shrink change volume, not mass; the section only appears once at least one of `density`/`swell`/`shrink` is actually configured, no separate toggle. A `stale` field on the `om-measure` readout flags the brief window between a footprint committing and its elevation sample resolving, so a consumer doesn't read numbers left over from a prior footprint as current), `vega-lite` (live charts bound to a layer's data), `dynamic-chart` (the same Vega-Lite rendering, but data-driven by a live DOM event instead of a layer — `on="<event-name>"` + `series-field="<name>"` reads `event.detail[seriesField]` as the chart's `values` on every matching event, redrawing at a fixed `width`; a feature "freezes" it for free by simply omitting that field the next time it fires, no separate pause API needed), and the BIM set `ifc-browser` / `feature-inspector` / `ifc-loader` / `ifc-clash`. Or write your own inline with HTML + a `<script type="om/widget">`. Adjacent compact button widgets (`zoom-controls`, `undo-redo`, `widgets-toggle`) **auto-cluster** into one control group (opt out per widget with `cluster="false"`), and `<om-map widgets-hidden>` / the `set-widgets-visible` action / `<om-widget type="widgets-toggle">` hide all authored chrome without destroying it — provider attribution and the license badge never hide. **Placement is managed**: `position` takes one of 8 logical, RTL-aware slots (`top-start`, `top-center`, `top-end`, `center-start`, `center-end`, `bottom-start`, `bottom-center`, `bottom-end`; legacy corner names alias) — same-slot widgets stack with flush edges and a shared gap, `order` sets in-slot ordering, and `position="manual"` opts out entirely (a plain block you style yourself, even outside the map). At map widths ≤640px, managed widgets automatically move into accessible top/end/bottom/start drawers; `fold="never"` keeps an essential control out, `widgets-fold="off"` disables folding, and `--om-widget-fold-breakpoint` changes the map-width threshold. Provider attribution is an in-flow member of `bottom-end` and the license badge of `bottom-start`, so neither covers a widget. A slot dims automatically while an open popup covers it (`widgets-dim="off"` to disable), except slots containing required chrome. Themeable from plain page CSS via custom properties: `om-map { --om-widget-bg: #111827; --om-widget-fg: #f9fafb; }` (also `-muted`, `-border`, `-hover-bg`, `-accent`), plus layout tokens (`--om-widget-inset-x/-y`, `--om-widget-gap-x/-y`, `--om-widget-opacity`, `--om-widget-radius`) or the no-CSS sugar `<om-map widget-style="gap:10 opacity:0.9">`. |
 | `<om-overlay>` | Rich HTML anchored to a map location — a static `anchor="[lng, lat]"`, the current selection, or a feature's own geometry via `anchor-layer`/`anchor-feature-id`. Selection-anchored overlays scope with `layer` (one layer's picks) and `selection-type="click"`/`"hover"` (one pick type — give a click-opened popup `selection-type="click"` so hovering elsewhere doesn't drag it along). `{{field}}` interpolates the picked feature, HTML-escaped by default; `{{z}}` is a real depth-picked elevation when some layer under the cursor set `pickable="3d"` (terrain does this itself, so hovering the ground always has one) — empty otherwise, never a misleading 0. `clip-to-map` (opt-in) hides the overlay when its own box would spill past the map viewport, not just when its anchor leaves — for small transient tips that track the cursor, where an overhanging box would otherwise inflate the page's scroll overflow and cause visible view jitter. |
 | `<om-behavior>` | Declarative interactions: `on="click|hover|drag|load|data-loaded"` → a named action. |
 | `<om-story>` | A storyboard: `<om-step>` children fire actions on a timeline. Controlled by the `player` widget, behaviors, or `storyEl.play()/pause()/seek()`. |
@@ -149,10 +149,12 @@ Built-in actions wire to picks, widget buttons (`data-emit`), or script (`ctx.em
 
 **Map stories:** a guided tour as markup — `<om-story>` holds `<om-step>` children that fire the same actions behaviors use, on a timeline (`duration`, `delay`, `parallel`); the built-in `type="player"` widget gives play/pause/scrub, seeking restores the scene's captured initial state, one story is active per map, and grabbing the map pauses playback. Effect verbs — `fade`, `pulse`, `trace` (progressive TripsLayer draw-on; with `feature-id`, a single polygon draws itself on inside its own layer), and `populate` (rows drop in one by one via a GPU filter sweep) — work as step shorthands or plain actions. The story is a sibling that references layers by id — delete it and the map is unchanged. Guide: [docs/stories.md](docs/stories.md).
 
-GPU filtering is declarative — `filter-field="magnitude" filter-range="[4,10]"` — updates live from the built-in `filter` slider widget, and widget statistics stay coherent with what the map shows (`ctx.stats` respects the active filter unless you opt out).
+GPU filtering is declarative — `filter-field="magnitude" filter-range="[4,10]"` — updates live from the built-in `filter` widget (a slider), and widget statistics stay coherent with what the map shows (`ctx.stats` respects the active filter unless you opt out). Up to 4 numeric dimensions at once via `filter-fields='[{"field":"magnitude","range":[4,10]},{"field":"time","range":[…]}]'` — a widget per field, each moved independently; a row must pass every active dimension. Categorical filtering is the same shape, a separate mechanism — `filter-category="fuel" filter-categories="[...]"` (or `filter-category-fields` for up to 4) renders the same `filter` widget as a checkbox list instead of a slider, and combines with any active numeric filter (a row must pass both).
 
 Dashed lines are one attribute — `dash="[6, 3]"` (or `dash="6 3"`, plus optional `dash-justified`) on a `PathLayer`/`GeoJsonLayer`/`PolygonLayer`/`TripsLayer` — wired through deck's `PathStyleExtension` under the hood.
 
+**Routing & tracking:** `<om-layer type="Route" geometry='{"type":"LineString","coordinates":[...]}'>` draws a styled route (casing + line + origin/destination markers) from geometry you already have; `origin`/`destination` (+ `provider`, default `"nika"`) resolve one asynchronously instead via `OmMap.registerRoutingProvider`. `follow="fit-route"` auto-fits the camera once it resolves. `<om-layer type="Tracking" get-position="[$lng,$lat]">` renders one moving entity with bearing-derived rotation (`bearing-field`, default `"bearing"`) and glides smoothly between position updates (`interpolate-ms`, default `1000`) rather than jumping — `follow="follow"` eases the camera along with it. Live position data arrives through the ordinary `data`/`source` mechanism, same as any layer — no separate tracking subscription API to learn. Guide (incl. a keyless OSRM adapter recipe and per-engine notes): [docs/routing.md](docs/routing.md).
+
 ### Widgets get a real runtime API
 
 Custom widget scripts receive `ctx`: layer metadata, `viewport` (bounds/zoom/project), the current `selection`, `emit()`, and data access — `ctx.data(id)`, `ctx.dataInViewport(id)`, `ctx.stats(id, field)` (count/min/max/mean/stddev/percentiles/histogram, viewport-scoped on request). Declare `watch` tokens (`data:quakes viewport selection layers`) and the runtime re-renders you only when relevant state changes. `vegaEmbed` and `d3` are available as globals for charts.
@@ -317,7 +319,7 @@ Packaged native hosts can verify an app-scoped key by passing platform-derived i
 await OmMap.configureLicense("om_live_…", { appId: "com.example.riders" });
 ```
 
-The `appId` must come from trusted native build metadata, never page/bridge input. Keys are self-verifying signed tokens (no network round-trip, works offline and in CI) bound to declared domains and/or exact app identifiers. Licensing: https://www.nikaplanet.com/onlymap.
+The `appId` must come from trusted native build metadata, never page/bridge input — the library cannot verify where it came from. Unlike `domains`, which the browser pins, the `apps` claim is asserted by the caller, so prefer keys minted with **both** claims (include the packaged host's own origins) and treat app scoping as a deterrent rather than enforcement. Keys are self-verifying signed tokens (no network round-trip, works offline and in CI) bound to declared domains and/or exact app identifiers. Licensing: https://www.nikaplanet.com/onlymap.
 
 ## Telemetry
 
@@ -325,13 +327,13 @@ The library reports one **deployment-scoped** usage snapshot per map per page lo
 
 ## Not implemented yet (honestly)
 
-Mapbox GL basemaps, depth-interleaved 3D compositing, globe projection, SSE transport, multi-field filters, `dblclick` behaviors, the `transform` data pipeline, the typed fluent builder, and stories/draw as React components (both work via the HTML manifest). On `pick-features`: instanced (i3dm) tiles keep tile-granularity picking, and `feature-styles`' `opacity` below 1 is still being validated. On BIM: clash detection is bounding-box only (no mesh-level test, and it cannot tell a resolved penetration from a collision), there is no BCF export, no equivalent of Navisworks' Auto Reveal, and prepared tilesets converted before the `bbox*` columns existed cannot take part in a clash pass — `strength` tinting and `opacity: 0` (hide, a shader discard) work. On the measure widget's `volume` mode: the per-cell grid integration measures against the map's active terrain DEM only — measuring against an imported design surface or a previous survey (period-over-period reconciliation) and a cut/fill heat-map overlay are not implemented yet, and a snapped footprint vertex takes the matched feature's horizontal position only — its exact elevation is not threaded through (see **XY snapping** above).
+Mapbox GL basemaps, depth-interleaved 3D compositing, globe projection, SSE transport, `dblclick` behaviors, the `transform` data pipeline, the typed fluent builder, and stories/draw as React components (both work via the HTML manifest). On `pick-features`: instanced (i3dm) tiles keep tile-granularity picking, and `feature-styles`' `opacity` below 1 is still being validated. On BIM: clash detection is bounding-box only (no mesh-level test, and it cannot tell a resolved penetration from a collision), there is no BCF export, no equivalent of Navisworks' Auto Reveal, and prepared tilesets converted before the `bbox*` columns existed cannot take part in a clash pass — `strength` tinting and `opacity: 0` (hide, a shader discard) work. On the measure widget's `volume` mode: the per-cell grid integration measures against the map's active terrain DEM only — measuring against an imported design surface or a previous survey (period-over-period reconciliation) and a cut/fill heat-map overlay are not implemented yet, and a snapped footprint vertex takes the matched feature's horizontal position only — its exact elevation is not threaded through (see **XY snapping** above).
 
 ## Going deeper
 
 | | |
 |---|---|
-| [docs/react.md](docs/react.md) · [docs/basemaps.md](docs/basemaps.md) · [docs/testing.md](docs/testing.md) · [docs/live-data.md](docs/live-data.md) · [docs/image-overlays.md](docs/image-overlays.md) · [docs/3d-assets.md](docs/3d-assets.md) · [docs/stories.md](docs/stories.md) · [docs/telemetry.md](docs/telemetry.md) | Consumer guides |
+| [docs/react.md](docs/react.md) · [docs/basemaps.md](docs/basemaps.md) · [docs/testing.md](docs/testing.md) · [docs/live-data.md](docs/live-data.md) · [docs/image-overlays.md](docs/image-overlays.md) · [docs/3d-assets.md](docs/3d-assets.md) · [docs/stories.md](docs/stories.md) · [docs/routing.md](docs/routing.md) · [docs/telemetry.md](docs/telemetry.md) | Consumer guides |
 | [CHANGELOG.md](CHANGELOG.md) | Version-by-version release notes |
 | [llms.txt](llms.txt) | The agent-facing quick reference |
 | `skills/onlymapjs` | Installable LLM skill for OnlyMapJS authoring |

package/dist/{LercDecode.es-BOJJr6Gx.js → LercDecode.es-BzboSQ2U.js}

@@ -19,7 +19,7 @@ async function v(N = {}) {
   if (n) {
     const { createRequire: I } = await import(
       /*webpackIgnore:true*/
-      "./lerc-C6k7EzSN.js"
+      "./lerc-BgzbFAc7.js"
     ).then((g) => g._);
     var O = I(import.meta.url);
   }

package/dist/attribute-resolution.d.ts

@@ -1,4 +1,4 @@
-import type { LayerMeta, LayerFilter } from "./ir";
+import type { LayerMeta, LayerFilter, LayerCategoryFilter } from "./ir";
 import type { LayerSchema, PropDescriptor } from "./layer-registry";
 import type { Shape } from "./expr";
 /** Sweeps the shared caches down to exactly the keys still referenced by the current manifest (Q4). */
@@ -19,9 +19,12 @@ export declare const RESERVED_ATTRS: Set<string>;
  * Filtering (spec: "Filtering") is universal across every layer type — not
  * tied to one schema's props like `pickable` — so it's resolved directly
  * here rather than via `schema.props`, and excluded from the typo-check the
- * same way `RESERVED_ATTRS` is. Single-field only (`filterSize`/`categorySize`
- * fixed at 1); the spec's own example is single-field, and the "up to 4
- * dimensions" case is a documented future extension.
+ * same way `RESERVED_ATTRS` is. `filter-field`/`filter-range`/
+ * `filter-soft-range` are the single-dimension surface; `filter-fields` is
+ * the multi-dimension one (up to 4 — `DataFilterExtension`'s own ceiling),
+ * a JSON array of `{field, range, softRange?}` objects. Categorical
+ * filtering (`filter-category`/`filter-categories`) is a separate slot,
+ * unrelated to the numeric dimension count.
  */
 export declare const FILTER_ATTRS: Set<string>;
 /**
@@ -51,14 +54,51 @@ export interface LayerDashSpec {
  * ignore it otherwise — the invisible-attribute class of confusion).
  */
 export declare function applyDashWiring(props: Record<string, unknown>, spec: LayerDashSpec, layerType: string, warnLabel: string): void;
-/** Already-coerced filter declaration — attribute strings (DOM front-end) or typed values (programmatic front-end). */
+/** One numeric filter dimension, already-coerced (attribute strings or typed programmatic values). */
+export interface LayerFilterFieldSpec {
+    field: string;
+    range?: [number, number];
+    softRange?: [number, number];
+}
+/**
+ * Already-coerced filter declaration — attribute strings (DOM front-end) or
+ * typed values (programmatic front-end). `filterField`/`filterRange`/
+ * `filterSoftRange` are the original single-dimension surface (still fully
+ * supported, zero migration needed); `filterFields` is the multi-dimension
+ * one. If both are present `filterFields` wins outright (validation warns
+ * separately about the ambiguity) — `applyFilterWiring` never merges them
+ * into a combined set, since which slot the singular field would occupy is
+ * not a well-defined question.
+ */
 export interface LayerFilterSpec {
     filterField?: string;
     filterRange?: [number, number];
     filterSoftRange?: [number, number];
+    filterFields?: LayerFilterFieldSpec[];
     filterCategoryField?: string;
     filterCategories?: unknown[];
+    filterCategoryFields?: LayerCategoryFilterFieldSpec[];
 }
+/** One categorical filter dimension, already-coerced. `categories` absent = declared but not yet ranged, mirroring the numeric case — dropped from the active filter with a warning, since deck.gl's category mechanism has no "wide open" value to fall back to (unlike a numeric [-Infinity, Infinity] range). */
+export interface LayerCategoryFilterFieldSpec {
+    field: string;
+    categories?: (string | number)[];
+}
+/**
+ * Parses the DOM front-end's `filter-fields` JSON attribute — an array of
+ * `{field, range, softRange?}` objects — dropping (with a warning, never a
+ * throw) any entry that isn't shaped like one, so a single malformed entry
+ * degrades to "that dimension is missing" rather than breaking the whole
+ * layer's filter or crashing the reconcile.
+ */
+export declare function parseFilterFieldsAttr(raw: string, warnLabel: string): LayerFilterFieldSpec[] | undefined;
+/**
+ * Parses the DOM front-end's `filter-category-fields` JSON attribute — an
+ * array of `{field, categories}` objects — same defensive shape as
+ * `parseFilterFieldsAttr`: a malformed entry is dropped with a warning, never
+ * a throw.
+ */
+export declare function parseFilterCategoryFieldsAttr(raw: string, warnLabel: string): LayerCategoryFilterFieldSpec[] | undefined;
 /**
  * GPU filter wiring (spec: "Filtering"), shared by both front-ends (HU2).
  * `filterRange` is a plain prop (not an accessor): the filter-layer action
@@ -78,6 +118,23 @@ export interface LayerFilterSpec {
  * category filter re-mounts the extension — churn accepted for the rare
  * case, never for the common numeric one.
  *
+ * `filterSize` (1-4, the count of numeric dimensions) is a deck.gl
+ * *constructor* option that compiles straight into a GLSL define
+ * (`DATAFILTER_TYPE float|vec2|vec3|vec4` — verified against
+ * `@deck.gl/extensions`' own source, not assumed), the same category of
+ * shader-recompile-on-change as `categorySize` above — and empirically
+ * confirmed safe to change on an already-mounted layer the same way
+ * categorySize already is (a `DataFilterExtension` config-value change,
+ * NOT an `extensions` array composition change — the latter is the
+ * documented-elsewhere case that corrupts state, e.g. adding a
+ * `ClipBoxExtension` alongside an already-mounted one; this isn't that).
+ * So `filterSize` is simply `min(dims.length, 4)`, recomputed fresh every
+ * reconcile, no special remount handling needed. The one thing v1
+ * deliberately does NOT support is an author changing the number of
+ * *declared* dimensions through the `filter-layer` action's merge path —
+ * that's a `filter-layer` contract choice (see `actions.ts`), not a
+ * limitation of this function.
+ *
  * The unfiltered baseline is a FUNCTION accessor (a buffer of zeros, 4
  * bytes/row) plus a baseline trigger — never deck's constant-0 default.
  * Two empirically-found deck behaviors force this: trigger keys absent
@@ -88,8 +145,27 @@ export interface LayerFilterSpec {
  * one transition that recomputes reliably, so every state a layer can
  * reach — unfiltered, authored filter, runtime populate sweep — is
  * buffer-backed.
+ *
+ * `categorySize` (0-4) mirrors `filterSize` structurally — same packed
+ * single-value-at-1/array-at->1 accessor and prop shape, same truncate-past-4
+ * behavior — but is a GENUINELY different mechanism (deck.gl's discrete
+ * bitmask membership test, `FilterCategory = number | string`, NOT a range
+ * comparison), so it's wired independently and returned separately: a layer
+ * can have an active numeric filter, an active categorical filter, both, or
+ * neither, and `ctx`'s coherence rule ANDs whichever are present. Unlike
+ * `filterSize` there is no floor of 1 — 0 (unmounted) is category's true
+ * idle state, so introducing or clearing categorical filtering re-mounts the
+ * extension (see the doc comment above); a category dimension with no
+ * `categories` list is dropped from the active set entirely (warned), since
+ * there's no "wide open" value the way a numeric range has [-Infinity,
+ * Infinity] — an empty/absent keep-list has no honest non-excluding meaning
+ * in a membership test.
  */
-export declare function applyFilterWiring(props: Record<string, unknown>, updateTriggers: Record<string, string>, shape: Shape, spec: LayerFilterSpec, warnLabel: string): LayerFilter | undefined;
+export interface LayerFilterResult {
+    filter?: LayerFilter;
+    categoryFilter?: LayerCategoryFilter;
+}
+export declare function applyFilterWiring(props: Record<string, unknown>, updateTriggers: Record<string, string>, shape: Shape, spec: LayerFilterSpec, warnLabel: string): LayerFilterResult;
 /**
  * Standard global HTML attributes an author (or the library itself, e.g.
  * OmLayerElement setting `style.display = "none"`) may set for reasons
@@ -135,5 +211,7 @@ export interface ResolvedAttributes {
     liveKeys: Set<string>;
     /** The layer's active declarative filter, if `filter-field`/`filter-range` are present. */
     filter?: LayerFilter;
+    /** The layer's active categorical filter, if `filter-category`/`filter-category-fields` are present. */
+    categoryFilter?: LayerCategoryFilter;
 }
 export declare function resolveLayerAttributes(el: Element, schema: LayerSchema, shape: Shape): ResolvedAttributes;

package/dist/{basemap-BofXgXxy.js → basemap-pWXbFGjp.js}

@@ -1,4 +1,4 @@
-import { C as ny, L as sy, M as oy, m as ay, c as ka, z as oc, a as Sd, G as sm, V as ly, W as cy, b as uy, g as hy, d as Vu, f as Ed, e as dy, l as py, u as fy, D as Qf, h as my } from "./index-7B-6Cbzu.js";
+import { C as ny, L as sy, M as oy, m as ay, c as ka, z as oc, a as Sd, G as sm, V as ly, W as cy, b as uy, g as hy, d as Vu, f as Ed, e as dy, l as py, u as fy, D as Qf, h as my } from "./index-CAuq7wRs.js";
 const Cd = Math.PI / 180, gy = 180 / Math.PI;
 function em(Pe, Q = 0) {
   const me = Math.min(180, Pe) * Cd;

package/dist/ctx.d.ts

@@ -5,7 +5,7 @@
  * viewport (for projection) crosses that boundary, per the spec's own
  * rationale.
  */
-import type { LayerIR, LayerFilter } from "./ir";
+import type { LayerIR, LayerFilter, LayerCategoryFilter } from "./ir";
 import type { RuntimeCore } from "./runtime-core";
 import type { Selection } from "./selection";
 import { type Stats } from "./stats";
@@ -21,6 +21,8 @@ export interface LayerMetaSnapshot {
     dataUrl?: string;
     /** The layer's active declarative filter, if any (spec: "Filtering") — read by the built-in `filter` widget. */
     filter?: LayerFilter;
+    /** The layer's active categorical filter, if any — independent of `filter`, read by the built-in `filter` widget's categorical mode. */
+    categoryFilter?: LayerCategoryFilter;
 }
 export interface DataOpts {
     /** Set `false` to bypass the layer's active declarative filter (spec: "Filter-aware stats & data (the coherence rule)"). Default `true`. */

package/dist/data-layer.d.ts

@@ -94,10 +94,24 @@ export declare function registerFormat(format: DataFormat): void;
 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. */
+/**
+ * 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 (unmount, dispose, or suspend). */
-export declare function releaseDataOwner(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.
@@ -171,7 +185,15 @@ export declare function getDrawData(url: string): LayerData;
  * caller re-reconciles from there).
  */
 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). */
+/**
+ * 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

package/dist/declarative-filter.d.ts

@@ -1,12 +1,21 @@
 /**
  * CPU-side mirror of the GPU `DataFilterExtension` test (spec: "Filter-aware
  * stats & data (the coherence rule)") — `ctx.stats`/`ctx.dataInViewport`
- * apply the SAME field+range test by default, so a chart/stat reflects what
- * the map visibly shows. A row whose field isn't a finite number is treated
- * as filtered-out, matching the GPU path (a non-numeric `getFilterValue`
- * result can't land inside any finite `filterRange`).
+ * apply the SAME field+range/category test(s) by default, so a chart/stat
+ * reflects what the map visibly shows. A row whose field isn't a finite
+ * number (numeric) or isn't in the keep-list (categorical) is treated as
+ * filtered-out, matching the GPU path. With more than one dimension of
+ * EITHER kind a row passes only if every dimension's test passes (AND
+ * across dimensions) — the same semantics deck.gl's own packed
+ * `filterRange`/`filterCategories` arrays apply GPU-side. Numeric and
+ * categorical are independent mechanisms (see `applyFilterWiring`'s doc
+ * comment) but combine the same way: a row must pass BOTH kinds when both
+ * are active on a layer.
  */
-import type { Shape, LayerFilter } from "./ir";
+import type { Shape, LayerFilter, LayerCategoryFilter } from "./ir";
 export declare function applyDeclarativeFilter(rows: readonly unknown[], shape: Shape, filter: LayerFilter): unknown[];
 /** The same test as a reusable predicate — the columnar viewport filter runs it inside its index-aligned loop. */
 export declare function declarativeFilterPredicate(shape: Shape, filter: LayerFilter): (row: unknown) => boolean;
+export declare function applyDeclarativeCategoryFilter(rows: readonly unknown[], shape: Shape, categoryFilter: LayerCategoryFilter): unknown[];
+/** Categorical twin of `declarativeFilterPredicate` — set membership instead of a range test. */
+export declare function declarativeCategoryFilterPredicate(shape: Shape, categoryFilter: LayerCategoryFilter): (row: unknown) => boolean;

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

@@ -51,6 +51,7 @@ export declare class OmMapElement extends HTMLElementBase {
     private mount;
     private reconcilePending;
     private readonly dataOwner;
+    private dataReleasePending;
     /** Decoded property tables per pick-features layer — see RuntimeCoreCallbacks.onFeatureTable. */
     private featureTables;
     private layerIRs;

package/dist/geodesy.d.ts

@@ -27,6 +27,8 @@ 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
@@ -39,6 +41,7 @@ export interface PathSample {
  * 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).

package/dist/{geoparquet-DapHATA0.js → geoparquet-BPl1T2Or.js}

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

package/dist/{index-SPJVn_n_.js → index-B9a6f006.js}

@@ -1,4 +1,4 @@
-import { ae as _t, af as Ct } from "./index-7B-6Cbzu.js";
+import { ae as _t, af as Ct } from "./index-CAuq7wRs.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);

package/dist/{index-BF9iO8Tq.js → index-Bgx3CJru.js}

@@ -1,4 +1,4 @@
-import { ag as Be, ah as le, ai as ce, aj as De, ak as Oe, al as ke } from "./index-7B-6Cbzu.js";
+import { ag as Be, ah as le, ai as ce, aj as De, ak as Oe, al as ke } from "./index-CAuq7wRs.js";
 import { y as ve, a as he, z as G, R as J, A as ue, C as Fe, F as je, n as xe, S as Ie, E as Ne } from "./recordbatch-Bpc0uxFn.js";
 import { g as V, a as fe, b as Le, c as Ue, d as Me, e as qe, m as Ve } from "./table-accessors-CYWTzpQI.js";
 import { c as $e } from "./convert-arrow-schema-DrAihRf9.js";