@nika-js/onlymap 0.3.0 → 0.3.2

package/dist/{table-accessors-DBjWgN0C.js → table-accessors-CYWTzpQI.js}

@@ -1,6 +1,5 @@
-function w(e) {
-  var a;
-  switch (typeof e == "object" && (e == null ? void 0 : e.shape)) {
+function d(e) {
+  switch (typeof e == "object" && e?.shape) {
     case "array-row-table":
     case "object-row-table":
       return Array.isArray(e.data);
@@ -9,12 +8,12 @@ function w(e) {
     case "columnar-table":
       return e.data && typeof e.data == "object";
     case "arrow-table":
-      return ((a = e == null ? void 0 : e.data) == null ? void 0 : a.numRows) !== void 0;
+      return e?.data?.numRows !== void 0;
     default:
       return !1;
   }
 }
-function l(e) {
+function i(e) {
   switch (e.shape) {
     case "array-row-table":
     case "object-row-table":
@@ -24,8 +23,8 @@ function l(e) {
     case "arrow-table":
       return e.data.numRows;
     case "columnar-table":
-      for (const a of Object.values(e.data))
-        return a.length || 0;
+      for (const t of Object.values(e.data))
+        return t.length || 0;
       return 0;
     default:
       throw new Error("table");
@@ -34,7 +33,7 @@ function l(e) {
 function g(e) {
   if (e.schema)
     return e.schema.fields.length;
-  if (l(e) === 0)
+  if (i(e) === 0)
     throw new Error("empty table");
   switch (e.shape) {
     case "array-row-table":
@@ -51,154 +50,150 @@ function g(e) {
       throw new Error("table");
   }
 }
-function j(e, r, a) {
-  var o;
+function j(e, r, t) {
   switch (e.shape) {
     case "array-row-table":
-      const n = m(e, a);
-      return e.data[r][n];
+      const o = m(e, t);
+      return e.data[r][o];
     case "object-row-table":
-      return e.data[r][a];
+      return e.data[r][t];
     case "geojson-table":
-      return e.features[r][a];
+      return e.features[r][t];
     case "columnar-table":
-      return e.data[a][r];
+      return e.data[t][r];
     case "arrow-table":
-      const c = e.data, u = c.schema.fields.findIndex((s) => s.name === a);
-      return (o = c.getChildAt(u)) == null ? void 0 : o.get(r);
+      const n = e.data, f = n.schema.fields.findIndex((c) => c.name === t);
+      return n.getChildAt(f)?.get(r);
     default:
       throw new Error("todo");
   }
 }
-function y(e, r, a) {
-  var o;
+function y(e, r, t) {
   switch (e.shape) {
     case "array-row-table":
-      return e.data[r][a];
+      return e.data[r][t];
     case "object-row-table":
-      const n = i(e, a);
-      return e.data[r][n];
+      const o = l(e, t);
+      return e.data[r][o];
     case "geojson-table":
-      const f = i(e, a);
-      return e.features[r][f];
+      const u = l(e, t);
+      return e.features[r][u];
     case "columnar-table":
-      const c = i(e, a);
-      return e.data[c][r];
+      const n = l(e, t);
+      return e.data[n][r];
     case "arrow-table":
-      return (o = e.data.getChildAt(a)) == null ? void 0 : o.get(r);
+      return e.data.getChildAt(t)?.get(r);
     default:
       throw new Error("todo");
   }
 }
 function m(e, r) {
-  var o;
-  const a = (o = e.schema) == null ? void 0 : o.fields.findIndex((n) => n.name === r);
-  if (a === void 0)
+  const t = e.schema?.fields.findIndex((o) => o.name === r);
+  if (t === void 0)
     throw new Error(r);
-  return a;
+  return t;
 }
-function i(e, r) {
-  var o, n;
-  const a = (n = (o = e.schema) == null ? void 0 : o.fields[r]) == null ? void 0 : n.name;
-  if (!a)
+function l(e, r) {
+  const t = e.schema?.fields[r]?.name;
+  if (!t)
     throw new Error(`${r}`);
-  return a;
+  return t;
 }
-function T(e, r, a, o) {
+function T(e, r, t, o) {
   switch (e.shape) {
     case "object-row-table":
       return o ? Object.fromEntries(Object.entries(e.data[r])) : e.data[r];
     case "array-row-table":
       if (e.schema) {
-        const s = a || {};
-        for (let t = 0; t < e.schema.fields.length; t++)
-          s[e.schema.fields[t].name] = e.data[r][t];
+        const s = t || {};
+        for (let a = 0; a < e.schema.fields.length; a++)
+          s[e.schema.fields[a].name] = e.data[r][a];
         return s;
       }
       throw new Error("no schema");
     case "geojson-table":
       if (e.schema) {
-        const s = a || {};
-        for (let t = 0; t < e.schema.fields.length; t++)
-          s[e.schema.fields[t].name] = e.features[r][t];
+        const s = t || {};
+        for (let a = 0; a < e.schema.fields.length; a++)
+          s[e.schema.fields[a].name] = e.features[r][a];
         return s;
       }
       throw new Error("no schema");
     case "columnar-table":
       if (e.schema) {
-        const s = a || {};
-        for (let t = 0; t < e.schema.fields.length; t++)
-          s[e.schema.fields[t].name] = e.data[e.schema.fields[t].name][r];
+        const s = t || {};
+        for (let a = 0; a < e.schema.fields.length; a++)
+          s[e.schema.fields[a].name] = e.data[e.schema.fields[a].name][r];
         return s;
       } else {
-        const s = a || {};
-        for (const [t, h] of Object.entries(e.data))
-          s[t] = h[r];
+        const s = t || {};
+        for (const [a, h] of Object.entries(e.data))
+          s[a] = h[r];
         return s;
       }
     case "arrow-table":
-      const n = e.data, f = a || {}, c = n.get(r), u = n.schema;
-      for (let s = 0; s < u.fields.length; s++)
-        f[u.fields[s].name] = c == null ? void 0 : c[u.fields[s].name];
-      return f;
+      const u = e.data, n = t || {}, f = u.get(r), c = u.schema;
+      for (let s = 0; s < c.fields.length; s++)
+        n[c.fields[s].name] = f?.[c.fields[s].name];
+      return n;
     default:
       throw new Error("shape");
   }
 }
-function d(e, r, a, o) {
+function w(e, r, t, o) {
   switch (e.shape) {
     case "array-row-table":
       return o ? Array.from(e.data[r]) : e.data[r];
     case "object-row-table":
       if (e.schema) {
-        const s = a || [];
-        for (let t = 0; t < e.schema.fields.length; t++)
-          s[t] = e.data[r][e.schema.fields[t].name];
+        const s = t || [];
+        for (let a = 0; a < e.schema.fields.length; a++)
+          s[a] = e.data[r][e.schema.fields[a].name];
         return s;
       }
       return Object.values(e.data[r]);
     case "geojson-table":
       if (e.schema) {
-        const s = a || [];
-        for (let t = 0; t < e.schema.fields.length; t++)
-          s[t] = e.features[r][e.schema.fields[t].name];
+        const s = t || [];
+        for (let a = 0; a < e.schema.fields.length; a++)
+          s[a] = e.features[r][e.schema.fields[a].name];
         return s;
       }
       return Object.values(e.features[r]);
     case "columnar-table":
       if (e.schema) {
-        const s = a || [];
-        for (let t = 0; t < e.schema.fields.length; t++)
-          s[t] = e.data[e.schema.fields[t].name][r];
+        const s = t || [];
+        for (let a = 0; a < e.schema.fields.length; a++)
+          s[a] = e.data[e.schema.fields[a].name][r];
         return s;
       } else {
-        const s = a || [];
-        let t = 0;
+        const s = t || [];
+        let a = 0;
         for (const h of Object.values(e.data))
-          s[t] = h[r], t++;
+          s[a] = h[r], a++;
         return s;
       }
     case "arrow-table":
-      const n = e.data, f = a || [], c = n.get(r), u = n.schema;
-      for (let s = 0; s < u.fields.length; s++)
-        f[s] = c == null ? void 0 : c[u.fields[s].name];
-      return f;
+      const u = e.data, n = t || [], f = u.get(r), c = u.schema;
+      for (let s = 0; s < c.fields.length; s++)
+        n[s] = f?.[c.fields[s].name];
+      return n;
     default:
       throw new Error("shape");
   }
 }
 function* p(e, r = []) {
-  const a = l(e);
-  for (let o = 0; o < a; o++)
-    yield d(e, o, r);
+  const t = i(e);
+  for (let o = 0; o < t; o++)
+    yield w(e, o, r);
 }
 export {
   g as a,
   y as b,
   j as c,
-  d,
+  w as d,
   T as e,
-  l as g,
-  w as i,
+  i as g,
+  d as i,
   p as m
 };

package/dist/version.d.ts

@@ -5,4 +5,4 @@
  * the build rootDir, and a `define` would need repeating across vite/vitest/
  * vite-node configs.
  */
-export declare const LIBRARY_VERSION = "0.3.0";
+export declare const LIBRARY_VERSION = "0.3.2";

package/dist/zstd-jXobGRcq.js

@@ -0,0 +1,14 @@
+import { decompress as r } from "./index-2v2NXF_n.js";
+async function o(t) {
+  const e = r(new Uint8Array(t));
+  return n(e);
+}
+function n(t) {
+  if (t.byteOffset === 0 && t.byteLength === t.buffer.byteLength)
+    return t.buffer;
+  const e = new Uint8Array(t.byteLength);
+  return e.set(t), e.buffer;
+}
+export {
+  o as decode
+};

package/llms.txt

@@ -4,21 +4,28 @@
 
 OnlyMapJS is NOT raw deck.gl and NOT generic HTML/JSX. The rules below are the delta from what you already assume — following them produces correct manifests on the first pass. Validate with `OmMap.validate(htmlString)` (structured errors, each with a `fix` instruction) and inspect resolved output with `OmMap.snapshotIR(htmlString)` before finalizing.
 
+## Loading the library
+
+- npm projects: `import "@nika-js/onlymap"` + `import "@nika-js/onlymap/onlymapjs.css"`.
+- No-build/CDN pages (any HTML file that travels as an artifact): load the single-file standalone bundle from a raw-file CDN — `<script type="module" src="https://unpkg.com/@nika-js/onlymap"></script>` (resolves to `dist/onlymap.standalone.js`; pin `@<version>` in files meant to be shared) — plus `<link rel="stylesheet" href="https://unpkg.com/@nika-js/onlymap/dist/onlymapjs.css">`. The stylesheet is `dist/onlymapjs.css`, NOT `dist/style.css` (an alias ships for that guess, but write the canonical path).
+- NEVER load from a rebundling CDN (esm.sh, skypack, jspm): re-bundling the code-split dist duplicates the deck.gl/luma.gl runtime across lazy chunks, and every layer then fails shader compilation (`DECKGL_FILTER_*: no matching overloaded function`) while the basemap still renders. Raw-file CDNs (unpkg, jsDelivr) are fine, for the code-split `dist/onlymapjs.js` too.
+
 ## Rules that differ from your training priors
 
 - Always write explicit closing tags: `<om-layer ...></om-layer>`. NEVER self-close (`<om-layer ... />`) — HTML5 ignores the slash on custom elements and every following sibling silently becomes a child.
 - Attributes are kebab-case, not camelCase: `get-fill-color`, `radius-units`, `line-width-min-pixels`. Every hyphenated attribute maps to the camelCase deck.gl prop.
 - Accessors are expressions in attributes, not JS functions: `get-position="[$lon, $lat]"`, `get-radius="$population * 0.001"`. `$field` reads a datum field; the library resolves flat vs. GeoJSON shape for you — never write `d.properties.x`.
+- A literal color inside a `get-*` accessor is a string IN the expression — quote it: `get-line-color="'#ffffff'"` or an RGBA array `get-line-color="[255,255,255,200]"`. Bare `get-line-color="#ffffff"` is an expression parse error (plain attributes like `color="#dc2626"` take bare hex, accessors do not).
 - Inline event handlers (`onclick="..."`) are rejected. Use `data-emit` attributes (`<span data-emit="hide-overlay" data-target="popup1">`) or `addEventListener` inside a `<script type="om/widget">` block where `ctx` is in scope.
 - `scale()` requires an explicit `domain=`: `get-fill-color="scale($depth, sequential, ['#ffffcc','#800026'], domain=[0,700])"`. A missing domain is a validation error.
-- `id` is required on every `<om-layer>`. `label` and `color` feed the legend; an explicit `get-fill-color` overrides `color` for rendering (both together is valid and common).
+- `id` is required on every `<om-layer>`. `label` and `color` feed the legend; an explicit `get-fill-color` overrides `color` for rendering (both together is valid and common). The legend widget also reads `get-fill-color` itself: a `sequential`/`diverging` scale renders as a gradient ramp with domain labels, a `threshold` scale as discrete class ranges, and an equality ternary chain (`$f == 'a' ? '#c1' : '#c2'`) as a category palette — write those canonical shapes and the legend describes the symbology automatically.
 - Full JavaScript in accessor blocks needs the `js` attribute on the layer (`<om-layer js>` + `<script type="om/accessors">`). Without it, blocks are restricted to `export const name = d => <expression>` — no statements, no loops, no nested functions.
 
 ## Element vocabulary
 
 - `<om-map center="[lng, lat]" zoom="11" pitch="55" bearing="20" basemap="positron">` — the root. `basemap` accepts a free preset (`liberty`, `bright`, `positron`, `dark-matter`, `voyager`, `osm` — no keys; or `maptiler-streets`/`maptiler-dataviz`/`maptiler-satellite` with `basemap-key="…"` or `OmMap.configureBasemap({ maptilerKey })`), `maplibre` (bare demo style), a style URL (e.g. a MapTiler-customized style; any scheme fetch supports, including desktop asset protocols like Tauri's, query strings fine), or `none` (standalone canvas). The attribute is LIVE — writing it switches the basemap in place (camera + layers survive); the `set-basemap {basemap}` action and `<om-widget type="basemap-switcher" options="positron dark-matter osm">` do the same. Register more via `OmMap.registerBasemap(name, { style })`. Required provider attribution renders automatically (`attribution="false"` opts out). `pitch`/`bearing` tilt the initial camera (use for 3D content). Terrain: `terrain="terrarium"` (keyless AWS DEM; also `maptiler-terrain` with a key, a raw `{z}/{x}/{y}` DEM URL + `terrain-decoder="terrarium|mapbox-rgb|<JSON>"`, or `off`) raises a 3D surface — geographic layers DRAPE onto it automatically (per-layer `terrain="drape|offset|off"` overrides; 3D-model layers sit ON it), `terrain-exaggeration` scales relief, `terrain-texture` drapes imagery; terrain REPLACES an active basemap while on (restored when off); `set-terrain` action, `terrain` watch token, `OmMap.registerTerrain(name, {...})` for more sources. Scene lighting for 3D content: `lighting="daylight|studio|flat|custom"` (absent = deck defaults) with `lighting-ambient`/`lighting-sun`/`lighting-sun-azimuth`/`lighting-sun-elevation`/`lighting-camera` overrides and `lighting-sun-date` (ISO/epoch — solar-position sun computed at the map center, wins over azimuth/elevation); attribute-backed (undoable, live-editable), story-steppable via the `set-lighting {lighting, sunAzimuth, ...}` action (`lighting="default"` removes the attribute set; a bare preset is a clean reset — stale overrides clear), native UI via `<om-widget type="lighting">` (preset radios + tuning sliders), widget watch token `lighting`. GeoJsonLayer extrudes polygons declaratively: `extruded get-elevation="$height"` (+ `wireframe`). `validate` attribute enables live validation + on-page error panel. Include a `map-id="<random UUID>"` on complete pages (identifies the map artifact for usage telemetry — not a visitor id; the page author deletes it to opt out); `telemetry="off"` disables usage telemetry + library-error reporting for the map (global: `OmMap.configureTelemetry({ disabled: true })`; schema: docs/telemetry.md). Free plan limits: 5 layers, 25k rows per layer — layers past a limit don't render and validation says why; a `license-key="om_live_…"` attribute (publishable, origin-restricted) or `OmMap.configureLicense(key)` lifts limits and removes the corner badge. When a user's map exceeds free limits, say so and point at the validation message rather than silently restructuring their data. Events on the element: `om-map-ready` (boot complete; `await mapEl.ready` is the promise twin), `om-validation-error`, `om-view-changed` (camera settled after a move, debounced; `detail = {longitude, latitude, zoom, pitch, bearing}` — the camera-persistence hook). `await mapEl.snapshot()` returns a canvas-only PNG dataURL of the scene (basemap + layers at device pixels; `{as:"blob"}` for files) — DOM widgets/overlays/attribution are NOT captured, so exports must render provider credits themselves.
-- `<om-layer id="..." type="ScatterplotLayer" data="./points.json">` — any deck.gl layer class by `type` (all 33 bundled), plus `PopupLayer` (WebGL badges/labels at scale: `layout="badge|pin-label|card"`, `min-zoom`/`max-zoom`). External layer classes register via `OmMap.registerLayer({type, deckClass, props})` — build them on `@nika-js/onlymap/deck` (the bundled `CompositeLayer`/`TileLayer`/… re-exports), never a separately-installed deck.gl (different class hierarchy, breaks in the renderer); function-valued props ride the subclass's `static defaultProps`; register at module top level BEFORE the manifest mounts (see docs/custom-layers.md). Data: `data` URL (JSON, GeoJSON, CSV/TSV `.csv` — parsed to typed columns — Shapefile `.shp` (+`.dbf` attributes) and KML `.kml` as GeoJSON features, or Arrow IPC `.arrow`/`.feather` — large point datasets stay columnar, GeoArrow line/polygon geometry becomes GeoJSON features, zstd-compressed IPC is handled; other formats plug in via `OmMap.registerFormat({match, parse})`; data URLs accept any scheme the runtime's fetch supports — desktop webviews (Tauri, Electron) pass asset-protocol URLs straight in), inline `<script type="application/json">` (row arrays or column-oriented `{"columns": {"lon": [...], "lat": [...]}}`), or `wss://` streaming (`key="mmsi"` upserts entities in place, `flush="250ms"` coalesces bursts, `source="name"` selects a `OmMap.registerSource` decoder plugin), or a polled REST snapshot (`refresh="5s"` re-fetches and replaces — for live endpoints that return the full current state). Authenticated endpoints: call `OmMap.configureData({ headers: {...} })` in a script — never put tokens in attributes. `$field` accessors work identically on all of them — never write column-index code yourself. One columnar restriction: the `js` full-JS opt-in is not allowed on Arrow/columnar layers (validation will tell you; use `$field` accessors instead). For 3D models use `type="ScenegraphLayer"` with `scenegraph="./model.glb"` (required) and `get-orientation="[0, $heading, 90]"` — the roll of 90 stands Y-up glTF models upright; see docs/3d-assets.md.
-- `<om-widget type="legend|layer-switcher|basemap-switcher|lighting|zoom-controls|undo-redo|scale-bar|attribution|filter|vega-lite" position="bottom-right">` — static UI panels. No `type` + HTML + `<script type="om/widget">` = custom widget with `ctx` (`ctx.layers`, `ctx.data(id)`, `ctx.dataInViewport(id)`, `ctx.stats(id, field)`, `ctx.viewport`, `ctx.selection`, `ctx.emit(action, payload)`), `this.watch = ['data:<layerId>', 'viewport', 'selection', 'layers', 'history', 'basemap']` (`layers` also fires on visibility/filter changes; `basemap` on basemap switches; `history` on undo/redo availability), `this.$(sel)`, `vegaEmbed`/`d3` as globals.
+- `<om-layer id="..." type="ScatterplotLayer" data="./points.json">` — any deck.gl layer class by `type` (all 33 bundled, plus the native `COGLayer` raster type), plus `PopupLayer` (WebGL badges/labels at scale: `layout="badge|pin-label|card"`, `min-zoom`/`max-zoom`). External layer classes register via `OmMap.registerLayer({type, deckClass, props})` — build them on `@nika-js/onlymap/deck` (the bundled `CompositeLayer`/`TileLayer`/… re-exports), never a separately-installed deck.gl (different class hierarchy, breaks in the renderer); function-valued props ride the subclass's `static defaultProps`; register at module top level BEFORE the manifest mounts (see docs/custom-layers.md). Data: `data` URL (JSON, GeoJSON, CSV/TSV `.csv` — parsed to typed columns — Shapefile `.shp` (+`.dbf` attributes) and KML `.kml` as GeoJSON features, or Arrow IPC `.arrow`/`.feather` — large point datasets stay columnar, GeoArrow line/polygon geometry becomes GeoJSON features, zstd-compressed IPC is handled; other formats plug in via `OmMap.registerFormat({match, parse})`; data URLs accept any scheme the runtime's fetch supports — desktop webviews (Tauri, Electron) pass asset-protocol URLs straight in), inline `<script type="application/json">` (row arrays or column-oriented `{"columns": {"lon": [...], "lat": [...]}}`), or `wss://` streaming (`key="mmsi"` upserts entities in place, `flush="250ms"` coalesces bursts, `source="name"` selects a `OmMap.registerSource` decoder plugin), or a polled REST snapshot (`refresh="5s"` re-fetches and replaces — for live endpoints that return the full current state). Authenticated endpoints: call `OmMap.configureData({ headers: {...} })` in a script — never put tokens in attributes. `$field` accessors work identically on all of them — never write column-index code yourself. One columnar restriction: the `js` full-JS opt-in is not allowed on Arrow/columnar layers (validation will tell you; use `$field` accessors instead). For 3D models use `type="ScenegraphLayer"` with `scenegraph="./model.glb"` (required) and `get-orientation="[0, $heading, 90]"` — the roll of 90 stands Y-up glTF models upright; see docs/3d-assets.md. GeoTIFF/COG rasters use `type="COGLayer"` with `src="./dem.tif"` (NOT `data` — rasters stream tiles by Range request, they are not parsed rows): `min`/`max` set the rescale window (default 0–255; ALWAYS set them for float/16-bit data like DEMs), `colormap` picks a bundled ramp for single-band sources (gray, viridis, plasma, inferno, magma, cividis, rdylgn, rdbu, spectral, terrain, jet, turbo), `nodata` overrides the source sentinel (renders transparent); plain 8-bit RGB COGs need no styling attributes; restretch/recolor are GPU uniforms (no refetch) and the legend ramp derives from colormap+min/max automatically. Sources must be Cloud-Optimized (`gdal_translate -of COG` otherwise).
+- `<om-widget type="legend|layer-switcher|basemap-switcher|lighting|zoom-controls|undo-redo|scale-bar|attribution|filter|vega-lite" position="bottom-right">` — static UI panels. Built-ins are themeable from page CSS via custom properties (they inherit through the shadow root): `om-map { --om-widget-bg: #111827; --om-widget-fg: #f9fafb; }` — full set: `--om-widget-bg/-fg/-muted/-border/-hover-bg/-accent`; scope to a single widget with an `om-widget[type=legend]` selector instead. No `type` + HTML + `<script type="om/widget">` = custom widget with `ctx` (`ctx.layers`, `ctx.data(id)`, `ctx.dataInViewport(id)`, `ctx.stats(id, field)`, `ctx.viewport`, `ctx.selection`, `ctx.emit(action, payload)`), `this.watch = ['data:<layerId>', 'viewport', 'selection', 'layers', 'history', 'basemap']` (`layers` also fires on visibility/filter changes; `basemap` on basemap switches; `history` on undo/redo availability), `this.$(sel)`, `vegaEmbed`/`d3` as globals.
 - `<om-overlay id="..." anchor-from="selection">` — rich geo-anchored HTML (≤ ~20 per map). Anchors: `anchor="[lng, lat]"` (static), `anchor-from="selection"` (follows picks), or `anchor-layer="regions" anchor-feature-id="mission"` (anchored to a feature's own geometry — bbox center — no coordinates in markup; `{{field}}` interpolates that feature's attributes). `{{field}}` interpolates the picked feature HTML-escaped; `{{{field}}}` is raw (avoid). For labels on many features use `PopupLayer`, not overlays.
 - `<om-behavior on="click|hover|drag|load|data-loaded" layer="..." action="...">` — declarative interaction. Built-in actions: `show-overlay`, `hide-overlay`, `show-tooltip`, `hide-tooltip`, `toggle-layer`, `filter-layer`, `highlight-feature`, `zoom-to-feature`, `set-basemap`, `undo`, `redo`. One payload contract everywhere: `{ layer, target, feature, featureId, coordinate }`.
 - Undo/redo is built in: user-facing manifest changes (layer toggles, filter changes, basemap switches, element add/remove, drawn sketches) are recorded automatically — the manifest is the state. `<om-widget type="undo-redo">` renders the buttons; Cmd/Ctrl-Z, Shift-Cmd/Ctrl-Z, and Ctrl-Y work on any map (text inputs keep their native undo). Camera moves, hover effects, and story playback are deliberately NOT undo steps. Widget scripts: `ctx.history.canUndo/canRedo` with watch token `history`; `ctx.emit("undo")`/`ctx.emit("redo")`.

package/onlymapjs.html-data.json

@@ -216,6 +216,9 @@
             {
               "name": "BitmapLayer"
             },
+            {
+              "name": "COGLayer"
+            },
             {
               "name": "ColumnLayer"
             },
@@ -559,6 +562,26 @@
           "name": "point-size",
           "description": "deck.gl pointSize."
         },
+        {
+          "name": "src",
+          "description": "deck.gl geotiff."
+        },
+        {
+          "name": "min",
+          "description": "deck.gl rescaleMin."
+        },
+        {
+          "name": "max",
+          "description": "deck.gl rescaleMax."
+        },
+        {
+          "name": "colormap",
+          "description": "deck.gl colormap."
+        },
+        {
+          "name": "nodata",
+          "description": "deck.gl nodataOverride."
+        },
         {
           "name": "operation",
           "description": "deck.gl operation."

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nika-js/onlymap",
-  "version": "0.3.0",
-  "description": "Declarative deck.gl maps for HTML and React — interactive WebGL mapping with GeoJSON/CSV/Arrow data, MapLibre basemaps, widgets, popups, and live streams from a custom-element manifest or typed React components. TypeScript, no build step.",
+  "version": "0.3.2",
+  "description": "Declarative deck.gl maps for HTML and React \u2014 interactive WebGL mapping with GeoJSON/CSV/Arrow data, MapLibre basemaps, widgets, popups, and live streams from a custom-element manifest or typed React components. TypeScript, no build step.",
   "license": "SEE LICENSE IN LICENSE.md",
   "publishConfig": {
     "access": "public"
@@ -47,6 +47,9 @@
   "module": "./dist/onlymapjs.js",
   "types": "./dist/index.d.ts",
   "style": "./dist/onlymapjs.css",
+  "comment:cdn-fields": "Bare CDN URLs (https://unpkg.com/@nika-js/onlymap) must serve the single-file standalone bundle, never the code-split entry: rebundling CDNs duplicate the deck.gl/luma.gl runtime across lazy chunks and break shader compilation (see vite.standalone.config.ts).",
+  "unpkg": "./dist/onlymap.standalone.js",
+  "jsdelivr": "./dist/onlymap.standalone.js",
   "bin": {
     "onlymapjs": "bin/onlymapjs.mjs"
   },
@@ -54,7 +57,6 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/onlymapjs.js",
-      "require": "./dist/onlymapjs.umd.cjs",
       "default": "./dist/onlymapjs.js"
     },
     "./react": {
@@ -67,7 +69,13 @@
       "import": "./dist/deck.js",
       "default": "./dist/deck.js"
     },
+    "./standalone": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/onlymap.standalone.js",
+      "default": "./dist/onlymap.standalone.js"
+    },
     "./onlymapjs.css": "./dist/onlymapjs.css",
+    "./style.css": "./dist/style.css",
     "./onlymapjs.html-data.json": "./onlymapjs.html-data.json",
     "./onlymap.code-snippets": "./.vscode/onlymap.code-snippets",
     "./package.json": "./package.json"
@@ -90,6 +98,7 @@
     "dist",
     "README.md",
     "LICENSE.md",
+    "THIRD-PARTY-LICENSES.md",
     "docs",
     "llms.txt",
     "onlymapjs.html-data.json",
@@ -97,7 +106,7 @@
   ],
   "scripts": {
     "dev": "vite",
-    "build": "npm run typecheck && vite build && vite build --config vite.react.config.ts && vite build --config vite.deck.config.ts && npm run build:types",
+    "build": "npm run typecheck && npm run gen:licenses && vite build && vite build --config vite.react.config.ts && vite build --config vite.deck.config.ts && vite build --config vite.standalone.config.ts && npm run build:types",
     "build:types": "tsc -p tsconfig.build.json --emitDeclarationOnly",
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.e2e.json --noEmit && tsc -p cloud/workers/telemetry/tsconfig.json",
     "test": "vitest run",
@@ -108,17 +117,19 @@
     "gen:public": "npm run gen:html-data && vite-node dev/build-public.ts",
     "test:public": "npm run gen:public -- --dry-run --strict",
     "deploy:telemetry": "wrangler deploy --config cloud/workers/telemetry/wrangler.toml",
-    "dev:telemetry": "wrangler dev --config cloud/workers/telemetry/wrangler.toml"
+    "dev:telemetry": "wrangler dev --config cloud/workers/telemetry/wrangler.toml",
+    "gen:licenses": "node dev/gen-third-party-licenses.mjs"
   },
-  "comment:deps": "This library ships a fully self-contained bundle in dist/ (verified: zero external bare imports), so it has NO runtime dependencies — deck.gl, loaders.gl, MapLibre, Arrow, d3, acorn, etc. are build-time-only and get bundled by Vite. Keeping them here (not in dependencies) is what stops every consumer install from pulling ~250 MB it never uses.",
+  "comment:deps": "This library ships a fully self-contained bundle in dist/ (verified: zero external bare imports), so it has NO runtime dependencies \u2014 deck.gl, loaders.gl, MapLibre, Arrow, d3, acorn, etc. are build-time-only and get bundled by Vite. Keeping them here (not in dependencies) is what stops every consumer install from pulling ~250 MB it never uses.",
   "devDependencies": {
-    "@deck.gl/aggregation-layers": "^9.3.5",
-    "@deck.gl/core": "^9.3.5",
-    "@deck.gl/extensions": "^9.3.5",
-    "@deck.gl/geo-layers": "^9.3.5",
-    "@deck.gl/layers": "^9.3.5",
-    "@deck.gl/mapbox": "^9.3.5",
-    "@deck.gl/mesh-layers": "^9.3.5",
+    "@deck.gl/aggregation-layers": "9.3.5",
+    "@deck.gl/core": "9.3.5",
+    "@deck.gl/extensions": "9.3.5",
+    "@deck.gl/geo-layers": "9.3.5",
+    "@deck.gl/layers": "9.3.5",
+    "@deck.gl/mapbox": "9.3.5",
+    "@deck.gl/mesh-layers": "9.3.5",
+    "@developmentseed/deck.gl-geotiff": "^0.7.0",
     "@loaders.gl/csv": "^4.4.3",
     "@loaders.gl/kml": "^4.4.3",
     "@loaders.gl/shapefile": "^4.4.3",
@@ -149,5 +160,6 @@
     "vitest": "^4.1.9",
     "wrangler": "^4.110.0",
     "ws": "^8.21.0"
-  }
-}
+  },
+  "comment:deck-pin": "deck.gl/luma.gl devDeps are EXACT pins: they get BUNDLED into dist, and both libraries hard-throw on duplicate-version detection \u2014 consumers that also ship their own deck.gl (nika-agent) must match these versions exactly, so bumps are breaking-coordination events, never side effects of a reinstall."
+}

package/skills/onlymapjs/SKILL.md

@@ -23,7 +23,7 @@ Use OnlyMapJS as a declarative HTML map library. Write custom elements such as `
 </script>
 ```
 
-For no-build CDN examples, use a published module URL such as `https://esm.sh/@nika-js/onlymap@0.3.0`.
+For no-build CDN pages, use the single-file standalone bundle from a raw-file CDN — `https://unpkg.com/@nika-js/onlymap@0.3.2` (the bare package URL serves `dist/onlymap.standalone.js`) — plus `<link rel="stylesheet" href="https://unpkg.com/@nika-js/onlymap@0.3.2/dist/onlymapjs.css">`. Never a rebundling CDN (esm.sh, skypack): re-bundling duplicates the deck.gl/luma.gl runtime and every layer fails shader compilation.
 
 ## React Projects
 
@@ -51,6 +51,7 @@ Load the smallest reference needed for the task:
 - Attribute names are kebab-case: `get-fill-color`, `radius-units`, `line-width-min-pixels`.
 - Accessor values are expressions: `get-position="[$lon, $lat]"`.
 - `scale()` always needs an explicit `domain=`.
+- Prefer canonical color expressions — a `sequential`/`diverging`/`threshold` `scale()` or an equality ternary chain — over hand-rolled arithmetic: the legend widget parses these shapes and renders a matching gradient ramp / class ranges / category palette automatically.
 - Inline handlers such as `onclick` are wrong. Use `data-emit`, `<om-behavior>`, or widget scripts.
 - Full JavaScript accessor blocks require the `js` attribute on `<om-layer>`.
 - Do not put secrets in markup. Use `OmMap.configureData({ headers, credentials, fetch })`.
@@ -63,6 +64,7 @@ Load the smallest reference needed for the task:
 - Guided tour or narrative sequence -> `<om-story>` with `<om-step>` siblings that reference existing layers/overlays by id.
 - Basemap choice or user-switchable basemaps -> `basemap` presets (`positron`, `liberty`, `dark-matter`, `osm`, ...) + `<om-widget type="basemap-switcher">`; MapTiler custom styles via a style URL or `basemap-key`.
 - Undoable UI (step back after layer toggles, filter changes, basemap switches, sketch edits) -> `<om-widget type="undo-redo">`; Cmd/Ctrl-Z works even without the widget. Camera moves and story playback are not undo steps.
+- GeoTIFF/COG raster (DEM, satellite imagery, NDVI) -> `<om-layer type="COGLayer" src="…tif">` with `min`/`max`/`colormap` for single-band data (see syntax.md — `src`, not `data`).
 - Live entity updates -> `wss://` stream with `key` and optional `source` decoder.
 - REST snapshot that changes over time -> `refresh="5s"`.
 - User sketching -> `data="draw:sketch"` layer plus `<om-widget type="draw" target="sketch">`.

package/skills/onlymapjs/references/syntax.md

@@ -13,10 +13,11 @@ Vite/npm project:
 </script>
 ```
 
-Static CDN page:
+Static CDN page (raw-file CDNs only — unpkg/jsDelivr; never esm.sh or another rebundling CDN, which duplicates the WebGL runtime and breaks layer shaders):
 
 ```html
-<script type="module" src="https://esm.sh/@nika-js/onlymap@0.1.0"></script>
+<link rel="stylesheet" href="https://unpkg.com/@nika-js/onlymap@0.3.2/dist/onlymapjs.css">
+<script type="module" src="https://unpkg.com/@nika-js/onlymap@0.3.2"></script>
 ```
 
 Always include `onlymapjs.css` — it carries the MapLibre basemap styles and the no-JS fallback rules (`<om-fallback>` / default banner). For the fallback to work in script-disabled previews it must load without JavaScript: a real `<link rel="stylesheet">` or inlined `<style>` on no-build pages (a bundler-emitted stylesheet is fine in npm projects).
@@ -100,7 +101,7 @@ filter-field="magnitude" filter-range="[4, 10]"
 
 Use the `type` value exactly:
 
-`A5Layer`, `ArcLayer`, `BitmapLayer`, `ColumnLayer`, `ContourLayer`, `GeoJsonLayer`, `GeohashLayer`, `GreatCircleLayer`, `GridCellLayer`, `GridLayer`, `H3ClusterLayer`, `H3HexagonLayer`, `HeatmapLayer`, `HexagonLayer`, `IconLayer`, `LineLayer`, `MVTLayer`, `PathLayer`, `PointCloudLayer`, `PolygonLayer`, `PopupLayer`, `QuadkeyLayer`, `S2Layer`, `ScatterplotLayer`, `ScenegraphLayer`, `ScreenGridLayer`, `SimpleMeshLayer`, `SolidPolygonLayer`, `TerrainLayer`, `TextLayer`, `Tile3DLayer`, `TileLayer`, `TripsLayer`.
+`A5Layer`, `ArcLayer`, `BitmapLayer`, `COGLayer`, `ColumnLayer`, `ContourLayer`, `GeoJsonLayer`, `GeohashLayer`, `GreatCircleLayer`, `GridCellLayer`, `GridLayer`, `H3ClusterLayer`, `H3HexagonLayer`, `HeatmapLayer`, `HexagonLayer`, `IconLayer`, `LineLayer`, `MVTLayer`, `PathLayer`, `PointCloudLayer`, `PolygonLayer`, `PopupLayer`, `QuadkeyLayer`, `S2Layer`, `ScatterplotLayer`, `ScenegraphLayer`, `ScreenGridLayer`, `SimpleMeshLayer`, `SolidPolygonLayer`, `TerrainLayer`, `TextLayer`, `Tile3DLayer`, `TileLayer`, `TripsLayer`.
 
 Common choices:
 
@@ -110,6 +111,22 @@ Common choices:
 - Aggregation: `HeatmapLayer`, `HexagonLayer`, `GridLayer`, `ScreenGridLayer`.
 - Tiles: `TileLayer`, `MVTLayer`, `Tile3DLayer`.
 - 3D models: `ScenegraphLayer`, `SimpleMeshLayer`, `PointCloudLayer`, `Tile3DLayer`.
+- GeoTIFF/COG rasters: `COGLayer`.
+
+### COGLayer (GeoTIFF / COG rasters)
+
+```html
+<om-layer id="dem" type="COGLayer" label="Elevation"
+          src="./elevation.tif" min="0" max="1900" colormap="viridis" nodata="-9999"></om-layer>
+```
+
+- `src` (required) — the GeoTIFF URL. NOT `data`: rasters stream tiles by HTTP Range request through the layer's own reader; they are never parsed rows (`$field`, `ctx.data()`, `ctx.stats()`, filters do not apply).
+- Sources must be Cloud-Optimized GeoTIFFs (`gdal_translate -of COG` otherwise).
+- `min`/`max` — the rescale window mapped onto the colormap. Defaults to 0–255, so ALWAYS set them for float or 16-bit data (DEMs, NDVI, temperature).
+- `colormap` — single-band ramps from the bundled sprite: `gray` (default), `viridis`, `plasma`, `inferno`, `magma`, `cividis`, `rdylgn`, `rdbu`, `spectral`, `terrain`, `jet`, `turbo`. Sources with 3+ bands composite as RGB and ignore it.
+- `nodata` — overrides the source's nodata sentinel; nodata pixels render transparent.
+- Plain 8-bit RGB COGs (satellite truecolor) need no styling attributes at all.
+- Restretch/recolor (min/max/colormap edits) are GPU uniform updates — tiles are not refetched. The legend widget renders the colormap ramp automatically when `colormap` + `min`/`max` are authored.
 
 External layer classes become manifest types via `OmMap.registerLayer({type, deckClass, props})`. Build them on `@nika-js/onlymap/deck` (the bundled `CompositeLayer`/`TileLayer`/… re-exports — a separately-installed deck.gl is a different class hierarchy and breaks in the renderer); function-valued props ride the subclass's `static defaultProps`; register at module top level before the manifest mounts. Full recipe: docs/custom-layers.md.
 
@@ -183,7 +200,7 @@ Do not use full-JS blocks on columnar/Arrow layers.
 
 Built-ins:
 
-- `legend`
+- `legend` — symbology-aware by default: it parses each layer's `get-fill-color`. A `sequential`/`diverging` `scale()` renders as a gradient ramp with the domain ends labeled; a `threshold` scale as discrete class ranges (`< b1`, `b1 – b2`, `≥ bN`); an equality ternary chain (`$f == 'a' ? '#c1' : $f == 'b' ? '#c2' : '#fallback'`) as a category palette with an "other" row. Any other expression falls back to the single `color` swatch — so writing the canonical shapes buys a self-describing legend for free.
 - `layer-switcher`
 - `zoom-controls`
 - `scale-bar`
@@ -198,6 +215,17 @@ Built-ins:
 
 Positions: `top-left`, `top-right`, `bottom-left`, `bottom-right`.
 
+Theming: built-in widgets read `--om-widget-*` CSS custom properties, which inherit through their shadow roots — so plain page CSS themes them, no JS:
+
+```css
+/* map-wide (every widget) */
+om-map { --om-widget-bg: #111827; --om-widget-fg: #f9fafb; }
+/* or one widget */
+om-widget[type="legend"] { --om-widget-bg: #111827; --om-widget-fg: #f9fafb; }
+```
+
+The full set: `--om-widget-bg` (panel/button background), `--om-widget-fg` (text), `--om-widget-muted` (secondary text: legend field/domain labels, disabled buttons, clocks), `--om-widget-border` (separators, button outlines), `--om-widget-hover-bg` (button hover), `--om-widget-accent` (player transport buttons). Unset properties fall back to the stock light palette.
+
 Examples:
 
 ```html