@nika-js/onlymap 0.6.11 → 0.6.14

package/CHANGELOG.md

@@ -8,6 +8,29 @@ 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.14 — 2026-08-21
+
+### Fixed
+- **Dashed lines render again.** `dash="[4, 2]"` had been drawing solid lines since 0.6.2 — the terrain patch merge was unintentionally stripping every layer's extensions on flat maps (issue #36).
+- **Filters visibly apply again on maps without terrain** — same underlying cause as the dash fix. Filter widgets and statistics were always correct; the map itself just wasn't hiding filtered-out features.
+- **Maps built in code now match maps built in HTML.** Built-in defaults apply (e.g. BIM models are clickable by default), `{z}/{x}/{y}` tile URLs load as tiles instead of failing, legends generate automatically, and `classifyBy` now works in React.
+- **`snap="false"` and `clip="false"` now opt a layer out**, matching what validation already accepted; `snap="off"` / `clip="off"` unchanged.
+
+## 0.6.13 — 2026-08-20
+
+### Fixed
+- **Line/polygon completion now works on iOS WebViews** (issue #17) — iOS never synthesizes `dblclick` from a double-tap while touch handlers are active, so double-tap added two more vertices instead of committing (Android committed fine — platform-inconsistent). The draw controller now detects the tap pair itself (two touch/pen taps within 350ms and ~12px) and completes the shape; mouse input keeps the native `dblclick` path, and synthetic/programmatic picks (no `pointerType`) opt into nothing. Applies wherever the draw stack runs, including the measure widget's footprints.
+
+### Added
+- **Finish button on the draw toolbar** — an explicit, discoverable completion affordance (double-click/double-tap/Enter are conventions the user must already know); harmless no-op when nothing is pending.
+- **`mapPoint(coord, kind, pointerType?)`** on the test harness — simulate a specific input modality (`"touch"`/`"pen"`/`"mouse"`) through the real pick path.
+
+## 0.6.12 — 2026-08-19
+
+### Added
+- **Classified symbology** (issue #12) — `classify-by="magnitude" classify-scale="quantile|equal-interval|jenks" classify-classes="5" classify-ramp="viridis"` computes class breaks *from the data* at reconcile time, installs the fill-color accessor, and auto-generates the classes legend. Fourteen named ramps (matplotlib + ColorBrewer). An authored `get-fill-color`/`color` always wins (validation names the conflict); URL-backed layers classify when their data arrives; results are memoized per data reference so deck recomputes exactly when the classification genuinely changes. Mirrored on the programmatic front-end as `classifyBy`/`classifyScale`/`classifyClasses`/`classifyRamp`.
+- **`time-slider` widget** (issue #18) — play/pause/scrub playback over a layer's numeric/epoch-ms time field: `<om-widget type="time-slider" layer="quakes" field="time" duration="20s" window="86400000" loop format="date">`. Drives the ordinary `filter-layer` action (cumulative from the domain start, or a sliding `window` in field units), so widget statistics stay coherent and undo/stories/external filter edits re-sync the thumb; date labels reuse the filter widget's `format`/`date-style`/`time-zone` contract.
+
 ## 0.6.11 — 2026-08-18
 
 ### Fixed

package/README.md

@@ -84,7 +84,7 @@ A handful of elements, one rule: **attributes are kebab-case versions of deck.gl
 |---|---|
 | `<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 **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-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; lines/polygons complete via double-click, touch double-tap — detected by the library itself, since iOS WebViews never synthesize `dblclick` from taps — Enter, or the toolbar's Finish button; `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 (double-tap on touch) 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,6 +149,8 @@ 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).
 
+**Classified symbology:** `classify-by="magnitude" classify-scale="jenks" classify-classes="5" classify-ramp="viridis"` computes class breaks *from the data* (quantile, equal-interval, or Jenks natural breaks), styles the layer with a named ramp, and auto-generates the classes legend — no domains or colors to hand-author; an explicit `get-fill-color`/`color` always wins. **Temporal playback:** `<om-widget type="time-slider" layer="…" field="time" duration="20s" window="86400000" format="date">` is a play/pause/scrub control over a layer's time field, driving the same `filter-layer` mechanics as the filter widget (stats stay coherent; `loop` restarts the sweep).
+
 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.
@@ -195,6 +197,18 @@ That opt-in command updates `.vscode/settings.json` and copies the `!`-prefixed
 
 The package also ships `!`-prefixed manifest snippets (`node_modules/@nika-js/onlymap/.vscode/onlymap.code-snippets`) — type `!starter`, `!map`, `!layer`, `!draw`, etc. to scaffold a well-formed element.
 
+## React Native / mobile
+
+The same runtime ships as an Expo React Native adapter,
+[`@nika-js/onlymap-native`](https://github.com/NikaGeospatial/onlymap-native)
+— the complete library hosted in a secure WebView and driven from JSX over a
+JSON bridge. The native surface keeps OnlyMap's vocabulary with two rule
+changes: accessors are **expression strings** (`getPosition="[$lon, $lat]"` —
+functions cannot cross the bridge) and everything on a descriptor is plain
+JSON. A 20-fixture parity gate keeps the native lane byte-identical to this
+repo's React adapter at the IR level. Guide:
+[docs.nikaplanet.com → OnlyMap JS → React Native](https://docs.nikaplanet.com/onlymap/react-native).
+
 ## Quick-start guide
 
 ### Use OnlyMapJS with Claude Code and Codex
@@ -327,7 +341,7 @@ 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, `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 React Native (`@nika-js/onlymap-native`): stories, draw, widgets, and overlays as native components (build native UI beside the map instead), and bare (non-Expo) React Native until its `0.2.0`. 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
 

package/dist/{LercDecode.es-C331HMjV.js → LercDecode.es-Bqk5xyNu.js}

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

package/dist/attribute-resolution.d.ts

@@ -34,7 +34,11 @@ export declare const FILTER_ATTRS: Set<string>;
  * `PathStyleExtension` (already bundled for DataFilterExtension), which only
  * applies to layers that stroke a path.
  */
+/** `data-emit`-style attribute name → camelCase (shared by om-map's payload reads and om-story's step parsing — both DOM-lane, one regex). */
+export declare function kebabToCamel(name: string): string;
 export declare const DASH_ATTRS: Set<string>;
+/** Classified symbology (spec: issue #12; src/classify.ts) — universal layer attributes like `filter-*`, resolved where the data is in hand (parse-manifest / descriptorToIR), never per-schema deck props. */
+export declare const CLASSIFY_ATTRS: Set<string>;
 /** Layer types whose deck class strokes a path, so PathStyleExtension's dash takes effect (GeoJsonLayer/PolygonLayer dash their line/stroke sublayers). */
 export declare const DASH_CAPABLE_LAYERS: Set<string>;
 /** A dash pattern authored as a JSON array (`[6, 3]`) OR an SVG-style token list (`6 3`, `6,3`) → `[dashLength, gapLength]`; undefined if it isn't two finite positive numbers. */

package/dist/{basemap-NN5SYEaS.js → basemap-KDsE62YN.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-BUp4hR6r.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-ESUJidEA.js";
 const Cd = Math.PI / 180, gy = 180 / Math.PI;
 function em(Pe, Q = 0) {
   const me = Math.min(180, Pe) * Cd;

package/dist/classify.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Classified symbology (issue #12 — "categorized/graduated styling, named
+ * ramps + auto-generated legend"). The half `scale()` deliberately does NOT
+ * cover: class breaks computed FROM THE DATA. An auto-domain expression was
+ * rejected long ago as impure ("an auto-domain scale() broke the cache"), so
+ * classification lives at the layer level instead, resolved where the rows
+ * are already in hand (parse-manifest / descriptorToIR — the same "resolved
+ * once data is present" seam `highlighted-id` and the CityJSON defaults
+ * use). URL-backed layers classify on the reparse their data arrival
+ * triggers; until then the layer renders unclassified, not blank.
+ *
+ * Authoring surface (universal layer attributes, like filter-*):
+ *   classify-by="magnitude"            the numeric field
+ *   classify-scale="quantile"          quantile (default) | equal-interval | jenks
+ *   classify-classes="5"               2–12, default 5
+ *   classify-ramp="viridis"            a named ramp below, default viridis
+ *
+ * An authored fill-color source (get-fill-color, a color shorthand, or a
+ * script-block export) always wins — classification silently defers at
+ * runtime and validation names the conflict at author time. The generated
+ * accessor is a plain function with an updateTriggers key derived from the
+ * actual computed breaks, so deck recomputes exactly when the classification
+ * genuinely changes and never otherwise; results are memoized per data
+ * reference (inline data is reference-stable since 0.6.11).
+ */
+import type { LayerData, LayerMeta } from "./ir";
+import type { Shape } from "./expr";
+/**
+ * Named ramps — standard matplotlib / ColorBrewer stop sets, the same
+ * vocabulary COGLayer's raster colormaps use where the names overlap.
+ */
+export declare const CLASSIFY_RAMPS: Record<string, string[]>;
+export declare const CLASSIFY_SCALES: readonly ["quantile", "equal-interval", "jenks"];
+export type ClassifyScale = (typeof CLASSIFY_SCALES)[number];
+/** k colors sampled evenly along a ramp's stops (linear RGB interpolation). */
+export declare function rampColors(name: string, k: number): string[];
+/** k-1 ascending upper boundaries for k classes: value < b[0] → class 0, …, ≥ b[k-2] → class k-1. */
+export declare function quantileBreaks(sorted: readonly number[], k: number): number[];
+export declare function equalIntervalBreaks(sorted: readonly number[], k: number): number[];
+/**
+ * Jenks natural breaks via the classic Fisher–Jenks dynamic program. O(k·n²),
+ * so inputs above 600 values are evenly strided down to 600 first — the
+ * breaks of a stride-sampled sorted vector are statistically
+ * indistinguishable for styling purposes, and this keeps a 25k-row layer's
+ * reconcile pass flat.
+ */
+export declare function jenksBreaks(sortedInput: readonly number[], k: number): number[];
+export interface ClassifySpec {
+    classifyBy?: string;
+    classifyScale?: string;
+    classifyClasses?: number;
+    classifyRamp?: string;
+}
+/**
+ * Computes the classification for a layer and installs it as `getFillColor`
+ * + updateTrigger + legend, shared verbatim by both front-ends. No-ops (and
+ * leaves everything untouched) when: no `classifyBy`; a fill-color source is
+ * already authored (it wins — validation names the conflict); the data
+ * hasn't arrived yet or has under two distinct numeric values (the URL case
+ * — the data-arrival reparse re-enters here with real rows).
+ */
+export declare function applyClassification(props: Record<string, unknown>, meta: LayerMeta, updateTriggers: Record<string, string>, spec: ClassifySpec, data: LayerData, shape: Shape, warnLabel: string): void;

package/dist/clip-box.d.ts

@@ -1,35 +1,3 @@
-/**
- * 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";

package/dist/data-layer.d.ts

@@ -1,20 +1,3 @@
-/**
- * Data Layer (spec: "Module Breakdown / Data Layer").
- * Fetches the `data` attribute URL and caches the parsed response by URL, or
- * (Phase 3) reads inline JSON from a child `<script type="application/json">`
- * synchronously with no fetch/cache involved. Full request-generation/
- * AbortController handling (Q6: "Async data loading & the reconcile race") is
- * still a minimal, safe subset here — a per-URL fetch generation so a
- * superseded request can't clobber a newer one — not the full machinery.
- *
- * Columnar (spec: "Columnar / GeoArrow Ingestion"): the Data Layer is where
- * columnar sources become `ColumnarData` — Arrow IPC files (`.arrow`,
- * lazy-importing apache-arrow so it never weighs on the eager bundle) and
- * column-oriented JSON (`{ columns: { field: [...] } }`, inline or fetched).
- * Columnar data is handed to deck.gl as-is (zero row materialization on the
- * render path); row objects are materialized lazily and memoized only when
- * a row-consuming surface (ctx.data, picking, highlight-by-id) asks.
- */
 import type { Shape, ColumnarData, LayerData } from "./ir";
 export declare function isColumnar(data: LayerData): data is ColumnarData;
 /** `Array` as-is, or a FeatureCollection's `.features`, or a lone object wrapped in an array. */

package/dist/draw-controller.d.ts

@@ -65,6 +65,9 @@ export declare class DrawController {
      * Consumed (cleared) by the very next click regardless of whether it matched.
      */
     private lastClosePos;
+    /** The previous click's coordinate + timestamp — the first half of a possible double-tap (see DOUBLE_TAP_MS). */
+    private lastTapPos;
+    private lastTapTime;
     constructor(mapEl: Element, core: RuntimeCore);
     /** A draw tool is active — om-map routes points here and suppresses selection. */
     isCapturing(): boolean;
@@ -109,7 +112,7 @@ export declare class DrawController {
     private ensureCommittedLayer;
     setMode(target: string, mode: DrawMode | null): void;
     private deactivate;
-    point(coord: [number, number] | null, kind: "click" | "hover"): void;
+    point(coord: [number, number] | null, kind: "click" | "hover", pointerType?: string): 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). */

package/dist/effects.d.ts

@@ -13,6 +13,7 @@ import type { RuntimeCore } from "./runtime-core";
 export declare function traceProgress(t01: number, t0: number, t1: number): number;
 /** Oscillates 1 → low → 1 per cycle (cosine), ending exactly at 1 for whole cycles. */
 export declare function pulseOpacity(t01: number, cycles: number, low?: number): number;
+export declare function prefersReducedMotion(): boolean;
 export interface LayerEffect {
     /** t01 ∈ [0, 1] → the plain-prop patch for this frame. */
     frame(t01: number): Record<string, unknown>;

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

@@ -1,22 +1,3 @@
-/**
- * <om-map> — spec: "Manifest Format / Core elements", "Architecture Layers",
- * "Runtime Context API", "Reactivity — the watch declaration".
- * Light DOM (spec: "DOM Model — Shadow vs. Light"): hosts the deck.gl canvas
- * (inside an internal mount div) and the <om-layer>/<om-widget> children
- * as normal siblings.
- *
- * Reconciler: full reparse per reconcile (still no diff-skipping of unchanged
- * DOM — accessor-level memoization/fingerprinting does the real work, see
- * attribute-resolution.ts / runtime-core.ts), microtask-batched (spec:
- * "MutationObserver burst batching") so N mutations in one synchronous burst
- * collapse into a single reconcile. No basemap adapter yet (Phase 6).
- *
- * Phase 4: also the widget pub-sub hub — maintains the live layer-IR
- * registry (for ctx.layers/data/stats), the current selection, and notifies
- * registered widgets per their `watch` tokens (spec: "Reactivity"). This
- * internal registration API (registerWidgetInternal/unregisterWidgetInternal/
- * emit) is consumed by OmWidgetElement, not part of the public package API.
- */
 import { HTMLElementBase } from "../env";
 import { type RuntimeContext } from "../ctx";
 import { type LightingIR } from "../scene-lighting";
@@ -73,7 +54,6 @@ export declare class OmMapElement extends HTMLElementBase {
     /** 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. */
     private internals;
     private resolveReady;
@@ -278,7 +258,7 @@ export declare class OmMapElement extends HTMLElementBase {
     /** 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. */
-    injectMapPointInternal(coordinate: [number, number] | null, kind?: "click" | "hover"): void;
+    injectMapPointInternal(coordinate: [number, number] | null, kind?: "click" | "hover", pointerType?: string): void;
     /** Harness setView (spec: "Consumer Testing Surface") — the one path that reaches pitch/bearing. */
     setViewInternal(partial: {
         longitude?: number;

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

@@ -1,21 +1,3 @@
-/**
- * <om-story> — the storyboard element (spec: "Map Stories"). A story is a
- * time-sequenced action dispatcher: where <om-behavior> maps event →
- * action, a story maps time → action, through the exact same action-payload
- * contract (mapEl.emit). It owns the clock; nothing owns the story — the
- * player widget is optional chrome that emits story-play/pause/seek.
- *
- * Composability guarantee (spec): steps reference layers/overlays by id and
- * never contain them; delete the story and the map is byte-for-byte the
- * same map.
- *
- * Scrub model (spec, v1): seek(T) = restore captured initial state, then
- * re-fire the FINAL state of every step starting ≤ T (instant — payload
- * duration overridden to 0). Step-granularity; mid-step interpolation is
- * deferred. Initial state is captured on first play from the attributes the
- * built-in-action steps will touch (statically computable from payloads)
- * plus the camera; custom-action steps are replay-only (warned once).
- */
 import { HTMLElementBase } from "../env";
 export type StoryState = "idle" | "playing" | "paused" | "ended";
 export declare class OmStoryElement extends HTMLElementBase {

package/dist/expr/errors.d.ts

@@ -8,3 +8,6 @@ export declare class CompileError extends Error {
     readonly fix: string;
     constructor(message: string, fix: string);
 }
+import type { Program } from "estree";
+/** Shared acorn container parse for both accessor-block flavors — one grammar, one error shape; only the fix hint names the block. */
+export declare function parseProgram(blockText: string, blockLabel: string): Program;

package/dist/field-access.d.ts

@@ -22,3 +22,13 @@ export declare function matchesFeatureId(row: unknown, featureId: string, shape:
  * asRows view — the Tier-2 rule, stated once here instead of at each caller.
  */
 export declare function findRowIndexById(data: LayerData, featureId: string, shape: Shape): number;
+/**
+ * Shape-less named-field read: a GeoJSON Feature's field lives under
+ * `properties`, a flat row carries it directly — probe both, `in`-checked so
+ * an explicit null/undefined stored under properties still wins. For callers
+ * that have no `Shape` in hand (the Tracking layer pair); everything with a
+ * shape should use `getField`.
+ */
+export declare function readNamedField(row: unknown, field: string): unknown;
+/** Recursively walks GeoJSON `coordinates` (Point/LineString/Polygon/Multi*) collecting every [lng, lat] vertex. */
+export declare function collectCoordinates(coordinates: unknown, out: [number, number][]): void;

package/dist/geodesy.d.ts

@@ -23,6 +23,15 @@ 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;
+/**
+ * Web Mercator ground resolution — meters per screen pixel at a latitude and
+ * zoom. The one formula four controllers used to carry inline (draw close
+ * guard, clip-box handle radius, measure hover tolerance, filter histogram).
+ * `minCosLat` clamps the cosine near the poles (the clip-box gizmo needs a
+ * floor so handle hit radii stay finite above ~84°); the default 0 keeps the
+ * exact classic formula.
+ */
+export declare function metersPerPixel(latitude: number, zoom: number, minCosLat?: number): number;
 export interface PathSample {
     position: LngLat;
     /** Cumulative distance (m) from the path's start. */
@@ -42,6 +51,8 @@ export interface PathSample {
  */
 export declare function resamplePath(points: LngLat[], count: number): PathSample[];
 export declare function resamplePathWithVertices(points: LngLat[], count: number): PathSample[];
+/** Drop a trailing vertex that duplicates the first (a closed ring → open list). */
+export declare function openRing(ring: LngLat[]): LngLat[];
 /**
  * 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-Dmyu5Oou.js → geoparquet-DOexUItM.js}

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

package/dist/html-data.d.ts

@@ -17,7 +17,7 @@ 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", "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", "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 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", "time-slider", "ifc-browser", "ifc-legend", "feature-inspector", "ifc-inspector", "ifc-loader", "ifc-clash"];
 export declare function buildHtmlCustomData(): {
     version: number;
     tags: TagData[];

package/dist/{index-D28RTVKt.js → index-BFNjPrc2.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-BUp4hR6r.js";
+import { ag as Be, ah as le, ai as ce, aj as De, ak as Oe, al as ke } from "./index-ESUJidEA.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";

package/dist/{index-CSVtCpQL.js → index-D_EyImRx.js}

@@ -1,4 +1,4 @@
-import { ae as _t, af as Ct } from "./index-BUp4hR6r.js";
+import { ae as _t, af as Ct } from "./index-ESUJidEA.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-_vNbcONa.js → index-DnsWPk6e.js}

@@ -1,4 +1,4 @@
-import { ak as Bt, ax as Xt, ay as Yt, az as Us } from "./index-BUp4hR6r.js";
+import { ak as Bt, ax as Xt, ay as Yt, az as Us } from "./index-ESUJidEA.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";