@nika-js/onlymap 0.7.3 → 0.7.5

package/CHANGELOG.md

@@ -8,6 +8,19 @@ 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.7.5 — 2026-09-11
+
+### Added
+- **Share any map as one file: `npx @nika-js/onlymap export map.html`.** Writes a portable copy that opens on any computer — relative data is fetched and embedded with format detection preserved (GeoJSON, CSV, Arrow, FlatGeobuf, GeoParquet and friends), library references become pinned CDN tags, and a no-JS fallback is added if missing. Warns when embedded data is heavy, and says exactly which sources must stay network-hosted (tile streams, COGs, shapefiles) and why.
+
+## 0.7.4 — 2026-09-04
+
+### Changed
+- **A lone side widget no longer folds into the drawer so early.** Widgets fold based on what actually shares their row now: the 640px fold width applies when a row (top, middle, or bottom) has widgets on more than one side, and drops to 416px when every occupied row is one-sided — so a single legend or control panel survives narrower maps before tucking away. Adding an opposing widget re-applies the wider threshold immediately.
+
+### Fixed
+- **The "requires JavaScript" banner no longer flashes during a slow load.** On modern browsers the stylesheet now distinguishes "JavaScript is off" from "still loading": with scripting available the fallback never appears during a normal boot (and only surfaces, with load-failure wording, if the library genuinely cannot load), while genuinely script-free contexts — file previews, email attachments — see the fallback instantly instead of after a delay.
+
 ## 0.7.3 — 2026-09-03
 
 ### Added

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. `visible-zoom-range="[8, 14]"` gives any layer scale-dependent visibility (hidden outside min ≤ zoom < max, the standard minzoom/maxzoom convention) — the everyday GIS pattern for keeping a dense layer from swamping a zoomed-out view. |
-| `<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-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 narrow map widths, managed widgets automatically move into accessible top/end/bottom/start drawers — at ≤640px when a row has widgets on more than one of its slots, at ≤416px when every occupied row is one-sided; `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()`. |
@@ -192,6 +192,8 @@ npx @nika-js/onlymap init
 
 That opt-in command updates `.vscode/settings.json` and copies the `!`-prefixed manifest snippets into `.vscode/onlymap.code-snippets`. It never runs automatically during install.
 
+**Share a map as one file:** `npx @nika-js/onlymap export map.html` writes a portable copy that opens on any computer — every relative data URL is fetched and embedded (format detection preserved: GeoJSON, CSV, Arrow, FlatGeobuf, GeoParquet and friends keep working), relative library references become pinned CDN tags, and a no-JS `<om-fallback>` is added if missing. Heavy embedded data gets a size warning; basemaps, terrain, tile streams, COGs and shapefiles stay network-backed (the tool says which and why).
+
 ```jsonc
 // .vscode/settings.json
 { "html.customData": ["./node_modules/@nika-js/onlymap/onlymapjs.html-data.json"] }

package/bin/onlymapjs.mjs

@@ -13,10 +13,18 @@ function usage() {
   onlymapjs init [--force]
   onlymapjs check-layout <manifest.html>
   onlymapjs record <manifest.html> [options]
+  onlymapjs export <manifest.html> [options]
   onlymapjs --help
 
 Commands:
   init       Configure the current project for OnlyMapJS authoring in VS Code.
+  export     Write a portable copy of a map page that opens on any computer:
+             every relative data/src/scenegraph URL is fetched and embedded as
+             a data: URL (format detection preserved — CSV, GeoJSON, Arrow,
+             FlatGeobuf, GeoParquet all keep working), relative library
+             references become pinned CDN tags, and an <om-fallback> is added
+             if missing. Remote http(s) URLs, basemaps, terrain, and tile
+             streams are left as-is — those still need network access.
   check-layout
              Load a browser-runnable manifest in isolated headless Chromium,
              audit real widget geometry at 360/640/768/1024px, and exit 0/1.
@@ -30,6 +38,12 @@ Commands:
 Options (init):
   --force    Overwrite .vscode/${SNIPPET_FILE} if it already exists.
 
+Options (export):
+  --out <file>     Output path (default: <manifest>.export.html).
+  --root <dir>     Directory that root-absolute URLs ("/data/x.json") resolve
+                   against (default: the manifest's own directory).
+  --force          Overwrite an existing output file.
+
 Options (record):
   --story <id>     Which <om-story> to record (default: the first one).
   --out <file>     Output path; .mp4 (H.264) or .webm (VP9). Default <manifest>.mp4.
@@ -537,6 +551,226 @@ function writeJson(path, value) {
   writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
 }
 
+// --- export: portable single-file map pages --------------------------------
+
+/** Attributes that may carry a fetchable single-file URL worth embedding. */
+const EXPORT_URL_ATTRS = ["data", "src", "scenegraph"];
+
+/**
+ * Extension → data-URL MIME. The library's format detection reads the URL
+ * extension (which survives as a `#name.ext` suffix — base64 contains no
+ * dots, so the suffix is the first extension-shaped match) and, for some
+ * formats, the Content-Type; simple MIMEs only, since a dotted MIME like
+ * application/vnd.google-earth.kml could shadow the suffix.
+ */
+const EXPORT_MIME = {
+  json: "application/json",
+  geojson: "application/json",
+  jsonl: "application/json",
+  csv: "text/csv",
+  tsv: "text/tab-separated-values",
+  kml: "application/xml",
+  gpx: "application/xml",
+  fgb: "application/octet-stream",
+  parquet: "application/octet-stream",
+  geoparquet: "application/octet-stream",
+  arrow: "application/octet-stream",
+  feather: "application/octet-stream",
+  glb: "model/gltf-binary",
+  ifc: "application/octet-stream",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+};
+
+/** Single files that cannot be embedded: the reader needs more than these bytes. */
+const EXPORT_SKIP_EXTENSIONS = {
+  shp: "shapefiles fetch .dbf/.prj sidecars next to the .shp URL",
+  tif: "COGs stream by HTTP Range request",
+  tiff: "COGs stream by HTTP Range request",
+  zarr: "Zarr stores are directories of chunk files",
+};
+
+const EXPORT_WARN_FILE_BYTES = 1 * 1024 * 1024; // per-file "this is getting heavy"
+const EXPORT_WARN_TOTAL_BYTES = 5 * 1024 * 1024; // whole-page ceiling worth flagging
+
+const formatBytes = (n) => (n >= 1024 * 1024 ? `${(n / (1024 * 1024)).toFixed(1)} MB` : `${Math.ceil(n / 1024)} KB`);
+
+/**
+ * Attribute values legally contain ">" (accessor expressions like
+ * `$value > 100 ? …`), so tags are scanned with quote awareness instead of
+ * a `[^>]*` regex.
+ */
+function* scanTags(html, tagName) {
+  const open = new RegExp(`<${tagName}(?=[\\s/>])`, "gi");
+  let m;
+  while ((m = open.exec(html))) {
+    let i = m.index + m[0].length;
+    let quote = null;
+    while (i < html.length) {
+      const c = html[i];
+      if (quote) {
+        if (c === quote) quote = null;
+      } else if (c === '"' || c === "'") quote = c;
+      else if (c === ">") break;
+      i += 1;
+    }
+    yield { start: m.index, end: i + 1, text: html.slice(m.index, i + 1) };
+  }
+}
+
+function readTagAttr(tagText, attr) {
+  const m = new RegExp(`\\b${attr}\\s*=\\s*("([^"]*)"|'([^']*)')`, "i").exec(tagText);
+  return m ? { value: m[2] ?? m[3], start: m.index, length: m[0].length, raw: m[0] } : null;
+}
+
+function urlExtensionOf(url) {
+  return /\.(\w+)(?:\?|#|$)/.exec(url)?.[1]?.toLowerCase();
+}
+
+async function exportStandalone(rest) {
+  const valueFlags = new Set(["--out", "--root"]);
+  const positional = [];
+  for (let i = 0; i < rest.length; i += 1) {
+    if (valueFlags.has(rest[i])) i += 1; // skip the flag's value
+    else if (!rest[i].startsWith("--")) positional.push(rest[i]);
+  }
+  if (positional.length !== 1) throw new Error("Usage: onlymapjs export <manifest.html> [--out file] [--root dir] [--force]");
+  const flagValue = (flag) => {
+    const i = rest.indexOf(flag);
+    return i >= 0 ? rest[i + 1] : undefined;
+  };
+  const inputPath = resolve(positional[0]);
+  if (!existsSync(inputPath)) throw new Error(`No such file: ${inputPath}`);
+  const inputDir = dirname(inputPath);
+  const rootDir = resolve(flagValue("--root") ?? inputDir);
+  const outPath = resolve(flagValue("--out") ?? inputPath.replace(/\.html?$/i, "") + ".export.html");
+  if (resolve(outPath) === inputPath) throw new Error("--out must differ from the input file.");
+  if (existsSync(outPath) && !rest.includes("--force")) throw new Error(`${outPath} already exists; pass --force to overwrite it.`);
+
+  let html = readFileSync(inputPath, "utf8");
+  const warnings = [];
+  const notes = [];
+  const inlined = [];
+  let totalBytes = 0;
+
+  // 1. Embed relative data/src/scenegraph URLs on <om-layer> tags.
+  const edits = []; // { start, end, replacement } over the ORIGINAL html, applied back-to-front
+  for (const tag of scanTags(html, "om-layer")) {
+    for (const attr of EXPORT_URL_ATTRS) {
+      const found = readTagAttr(tag.text, attr);
+      if (!found || !found.value) continue;
+      const url = found.value;
+      if (/^(https?:|wss?:|data:|blob:|draw:)/i.test(url)) {
+        if (/^wss?:/i.test(url)) notes.push(`${attr}="${url}" is a live stream — it will need network access wherever the file opens.`);
+        continue; // remote/self-describing URLs travel as-is
+      }
+      if (/\{[zxy]\}/.test(url)) {
+        notes.push(`${attr}="${url}" is a tile template — tile streams cannot be embedded and stay network-backed.`);
+        continue;
+      }
+      const ext = urlExtensionOf(url);
+      if (ext && EXPORT_SKIP_EXTENSIONS[ext]) {
+        warnings.push(`${attr}="${url}" was NOT embedded (${EXPORT_SKIP_EXTENSIONS[ext]}). Host it at an absolute URL for the exported file to work elsewhere.`);
+        continue;
+      }
+      const cleanPath = decodeURIComponent(url.split(/[?#]/)[0]);
+      const filePath = cleanPath.startsWith("/") ? join(rootDir, cleanPath) : resolve(inputDir, cleanPath);
+      if (!existsSync(filePath)) {
+        warnings.push(`${attr}="${url}" resolves to ${filePath}, which does not exist — left untouched.`);
+        continue;
+      }
+      const bytes = readFileSync(filePath);
+      const mime = (ext && EXPORT_MIME[ext]) || "application/json";
+      const name = basename(cleanPath);
+      const dataUrl = `data:${mime};base64,${bytes.toString("base64")}#${encodeURIComponent(name)}`;
+      edits.push({
+        start: tag.start + found.start,
+        end: tag.start + found.start + found.length,
+        replacement: `${attr}="${dataUrl}"`,
+      });
+      totalBytes += bytes.length;
+      inlined.push({ url, bytes: bytes.length });
+      if (bytes.length > EXPORT_WARN_FILE_BYTES) {
+        warnings.push(
+          `${name} is ${formatBytes(bytes.length)} — heavy for an embedded page (base64 adds ~33%). ` +
+            `Consider hosting it at an absolute URL instead of embedding.`,
+        );
+      }
+    }
+  }
+  for (const edit of edits.sort((a, b) => b.start - a.start)) {
+    html = html.slice(0, edit.start) + edit.replacement + html.slice(edit.end);
+  }
+
+  // 2. Pin relative library references to the CDN at this package's version.
+  const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+  const version = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8")).version;
+  const cdnScript = `https://unpkg.com/@nika-js/onlymap@${version}`;
+  const cdnCss = `https://unpkg.com/@nika-js/onlymap@${version}/dist/onlymapjs.css`;
+  let sawLibScript = false;
+  let sawLibCss = false;
+  const libEdits = [];
+  for (const tag of scanTags(html, "script")) {
+    const src = readTagAttr(tag.text, "src");
+    if (!src?.value) continue;
+    const isLib = /@nika-js\/onlymap|onlymapjs?\.(m?js|ts)|onlymap\.standalone\.js|\/src\/index\.ts/.test(src.value);
+    if (!isLib) continue;
+    sawLibScript = true;
+    if (/^https?:/i.test(src.value)) continue; // already CDN/hosted
+    libEdits.push({ start: tag.start + src.start, end: tag.start + src.start + src.length, replacement: `src="${cdnScript}"` });
+  }
+  for (const tag of scanTags(html, "link")) {
+    const href = readTagAttr(tag.text, "href");
+    if (!href?.value || !/onlymapjs\.css/.test(href.value)) continue;
+    sawLibCss = true;
+    if (/^https?:/i.test(href.value)) continue;
+    libEdits.push({ start: tag.start + href.start, end: tag.start + href.start + href.length, replacement: `href="${cdnCss}"` });
+  }
+  for (const edit of libEdits.sort((a, b) => b.start - a.start)) {
+    html = html.slice(0, edit.start) + edit.replacement + html.slice(edit.end);
+  }
+  if (!sawLibScript || !sawLibCss) {
+    // A bare-manifest page (no library tags at all): inject the pinned pair
+    // so the file boots anywhere. Before </head> when one exists, else at top.
+    const inject =
+      (sawLibCss ? "" : `<link rel="stylesheet" href="${cdnCss}" />\n`) +
+      (sawLibScript ? "" : `<script type="module" src="${cdnScript}"></script>\n`);
+    const headClose = /<\/head>/i.exec(html);
+    html = headClose ? html.slice(0, headClose.index) + inject + html.slice(headClose.index) : inject + html;
+    notes.push("The page had no OnlyMapJS reference — pinned CDN tags were injected.");
+  }
+
+  // 3. A no-JS fallback for file-preview contexts (the export's whole audience).
+  if (!/<om-fallback[\s>]/i.test(html)) {
+    const mapOpen = [...scanTags(html, "om-map")][0];
+    if (mapOpen) {
+      const fallback =
+        `\n  <om-fallback><p><strong>This interactive map requires JavaScript.</strong><br/>` +
+        `If you are seeing this in a file preview, open the file in a web browser such as Chrome, Safari, or Firefox.</p></om-fallback>`;
+      html = html.slice(0, mapOpen.end) + fallback + html.slice(mapOpen.end);
+      notes.push("Added a generic <om-fallback> (none was authored).");
+    }
+  }
+
+  writeFileSync(outPath, html);
+
+  for (const { url, bytes } of inlined) console.log(`  embedded ${url} (${formatBytes(bytes)})`);
+  if (totalBytes > EXPORT_WARN_TOTAL_BYTES) {
+    warnings.push(
+      `Embedded data totals ${formatBytes(totalBytes)} (~${formatBytes(Math.ceil(totalBytes * 1.34))} as base64) — ` +
+        `the exported page will be slow to open and share. Host the heavy layers at absolute URLs instead.`,
+    );
+  }
+  for (const note of notes) console.log(`  note: ${note}`);
+  for (const warning of warnings) console.warn(`  WARNING: ${warning}`);
+  const outSize = statSync(outPath).size;
+  console.log(`\nWrote ${outPath} (${formatBytes(outSize)}). Library pinned to @nika-js/onlymap@${version} via CDN.`);
+  console.log("Basemaps, terrain, and any remote/tiled sources still need network access when the file is opened.");
+  return 0;
+}
+
 function init({ force = false } = {}) {
   const cwd = process.cwd();
   const vscodeDir = join(cwd, ".vscode");
@@ -583,6 +817,8 @@ try {
     process.exitCode = await checkLayout(rest[0]);
   } else if (command === "record") {
     process.exitCode = await recordStory(rest);
+  } else if (command === "export") {
+    process.exitCode = await exportStandalone(rest);
   } else {
     console.error(`Unknown command: ${command}\n`);
     usage();

package/dist/{LercDecode.es-DEucX1sB.js → LercDecode.es-DYwn8YTS.js}

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

package/dist/{basemap-CmEvmtwF.js → basemap-CtEc5BCi.js}

@@ -1,4 +1,4 @@
-import { C as ny, L as sy, M as oy, m as ay, c as ka, a as Sd, z as oc, 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-BRdaiH3a.js";
+import { C as ny, L as sy, M as oy, m as ay, c as ka, a as Sd, z as oc, 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-DkimKgOm.js";
 const Cd = Math.PI / 180, gy = 180 / Math.PI;
 function em(Pe, J = 0) {
   const me = Math.min(180, Pe) * Cd;

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

@@ -116,6 +116,14 @@ export declare class OmMapElement extends HTMLElementBase {
     /** Cached breakpoint resolution — re-probes only when the token string actually changes, not on every ResizeObserver tick. */
     private foldBreakpointPx;
     private measureWidgetFold;
+    /**
+     * Authored slot occupancy for the fold criterion — POSITION ATTRIBUTES,
+     * never live container membership: folding reparents widgets into drawer
+     * panels, and a criterion that read the containers would see them empty
+     * and immediately argue for unfolding. The attribute is authored state
+     * that survives every reparent.
+     */
+    private occupiedWidgetSlots;
     private updateWidgetFoldForWidth;
     /**
      * Lift the bottom-end row clear of the bottom-start row and the folded

package/dist/{geoparquet-DL58Htx5.js → geoparquet-RBC0ZJNm.js}

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

package/dist/{index-ec-8juRl.js → index-Bwu1DFHP.js}

@@ -1,4 +1,4 @@
-import { ae as _t, af as Ct } from "./index-BRdaiH3a.js";
+import { ae as _t, af as Ct } from "./index-DkimKgOm.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-CNili_G3.js → index-CJ0pib8I.js}

@@ -1,5 +1,5 @@
-import { i as E, j as S, k as R, o as N, p as h, q as w, s as O, t as W, v as x, w as I, x as B, y as _, A as P, B as k, E as $, F as z, H as v, I as F, J as C, K as U, N as p, O as M } from "./index-BRdaiH3a.js";
-import { P as $e, R as ze, _ as ve, Q as Ce, S as Ue, T as Me, U as je, X as De, Y as Je, Z as qe, $ as He, a0 as Ve, a1 as Ge, a2 as Ke, a3 as Qe, a4 as Xe, a5 as Ye, a6 as Ze, a7 as et, a8 as tt, a9 as nt, aa as rt, ab as at, ac as st, ad as ot } from "./index-BRdaiH3a.js";
+import { i as E, j as S, k as R, o as N, p as h, q as w, s as O, t as W, v as x, w as I, x as B, y as _, A as P, B as k, E as $, F as z, H as v, I as F, J as C, K as U, N as p, O as M } from "./index-DkimKgOm.js";
+import { P as $e, R as ze, _ as ve, Q as Ce, S as Ue, T as Me, U as je, X as De, Y as Je, Z as qe, $ as He, a0 as Ve, a1 as Ge, a2 as Ke, a3 as Qe, a4 as Xe, a5 as Ye, a6 as Ze, a7 as et, a8 as tt, a9 as nt, aa as rt, ab as at, ac as st, ad as ot } from "./index-DkimKgOm.js";
 import { g as j, i as D } from "./table-accessors-CYWTzpQI.js";
 async function J(t, e, n = {}, r = {}) {
   const a = E(t), s = S.getWorkerFarm(n), { source: o } = n, c = { name: a, source: o };

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