@nika-js/onlymap 0.7.4 → 0.7.5

package/CHANGELOG.md

@@ -8,6 +8,11 @@ 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

package/README.md

@@ -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-5mg89-0f.js → LercDecode.es-DYwn8YTS.js}

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

package/dist/{basemap-2L7QA0ic.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-BirHZYjb.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/{geoparquet-BoPBi8wO.js → geoparquet-RBC0ZJNm.js}

@@ -1,4 +1,4 @@
-import { r as p, n as d } from "./index-BirHZYjb.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-BpEYiuZn.js → index-Bwu1DFHP.js}

@@ -1,4 +1,4 @@
-import { ae as _t, af as Ct } from "./index-BirHZYjb.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-D3prxKma.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-BirHZYjb.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-BirHZYjb.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-Dw5kfjba.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-BirHZYjb.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";

package/dist/{index-BirHZYjb.js → index-DkimKgOm.js}

@@ -30692,7 +30692,7 @@ const bee = {
 }, vee = {
   match: (t, e) => ["csv", "tsv"].includes(po(t) ?? "") || /text\/(csv|tab-separated-values)/i.test(e ?? ""),
   parse: async (t) => {
-    const [e, i, n] = await Promise.all([t.text(), import("./index-Dw5kfjba.js"), import("./index-D3prxKma.js")]), r = await n.parse(e, i.CSVLoader, { csv: { shape: "object-row-table" } });
+    const [e, i, n] = await Promise.all([t.text(), import("./index-CiGUw6GD.js"), import("./index-CJ0pib8I.js")]), r = await n.parse(e, i.CSVLoader, { csv: { shape: "object-row-table" } });
     return _ee(r.data) ?? r.data;
   }
 };
@@ -30714,7 +30714,7 @@ const xee = {
   parse: async (t, e) => {
     t.body?.cancel().catch(() => {
     });
-    const [i, n] = await Promise.all([import("./index-D3prxKma.js"), import("./index-Cgi3Rxih.js")]), r = t.url || e, s = /* @__PURE__ */ new Map(), o = (y) => {
+    const [i, n] = await Promise.all([import("./index-CJ0pib8I.js"), import("./index-HrEJtZoQ.js")]), r = t.url || e, s = /* @__PURE__ */ new Map(), o = (y) => {
       const v = String(y);
       let x = s.get(v);
       return x || (x = FN(v), s.set(v, x)), x.then((C) => C.clone());
@@ -30727,13 +30727,13 @@ const xee = {
 }, wee = {
   match: (t, e) => po(t) === "kml" || /application\/vnd\.google-earth\.kml/i.test(e ?? ""),
   parse: async (t) => {
-    const [e, i, n] = await Promise.all([t.text(), import("./index-D3prxKma.js"), import("./index-BpEYiuZn.js")]);
+    const [e, i, n] = await Promise.all([t.text(), import("./index-CJ0pib8I.js"), import("./index-Bwu1DFHP.js")]);
     return Vl(await i.parse(e, n.KMLLoader));
   }
 }, Cee = /* @__PURE__ */ new Set(["waypoint", "track", "route"]), See = {
   match: (t, e) => po(t) === "gpx" || /application\/gpx\+xml/i.test(e ?? ""),
   parse: async (t, e) => {
-    const [i, n, r] = await Promise.all([t.text(), import("./index-D3prxKma.js"), import("./index-BpEYiuZn.js")]), o = ((await n.parse(i, r.GPXLoader)).features ?? []).map((l) => {
+    const [i, n, r] = await Promise.all([t.text(), import("./index-CJ0pib8I.js"), import("./index-Bwu1DFHP.js")]), o = ((await n.parse(i, r.GPXLoader)).features ?? []).map((l) => {
       const u = l.properties?._gpxType, d = u === "trk" ? "track" : u === "rte" ? "route" : "waypoint";
       return { ...l, properties: { ...l.properties, _gpxKind: d } };
     }), a = e.split("#")[1]?.toLowerCase().replace(/s$/, "");
@@ -30766,7 +30766,7 @@ const xee = {
       t.arrayBuffer(),
       import("./index-BYbMtNVH.js"),
       import("./index-CgPV7QlM.js"),
-      import("./geoparquet-BoPBi8wO.js")
+      import("./geoparquet-RBC0ZJNm.js")
     ]), o = new Uint8Array(i);
     if (o.length < 8 || o[0] !== 80 || o[1] !== 65 || o[2] !== 82 || o[3] !== 49)
       throw new Error(`data="${e}": not a Parquet file (missing PAR1 magic bytes).`);
@@ -68656,7 +68656,7 @@ Un({
   type: "COGLayer",
   carriesRasterWindow: !0,
   carriesRasterIdentify: !0,
-  loadClass: () => import("./raster-B_pyNdlk.js").then((t) => t.r).then((t) => t.OmCOGLayer),
+  loadClass: () => import("./raster-Dsugvobw.js").then((t) => t.r).then((t) => t.OmCOGLayer),
   props: [
     { attr: "src", kind: "scalar", deckProp: "geotiff", type: "string", required: !0 },
     // COG v2 (issue #13): 1-based band selection — a single band (colormap-
@@ -68684,7 +68684,7 @@ Un({
 });
 Un({
   type: "ZarrLayer",
-  loadClass: () => import("./zarr-_lE_wpg2.js").then((t) => t.OmZarrLayer),
+  loadClass: () => import("./zarr-CRysSFhD.js").then((t) => t.OmZarrLayer),
   props: [
     { attr: "src", kind: "scalar", deckProp: "src", type: "string", required: !0 },
     { attr: "variable", kind: "scalar", deckProp: "variable", type: "string" },
@@ -81256,7 +81256,7 @@ class NU {
           `[onlymapjs] basemap="${e}" (Mapbox GL) is not implemented yet in this version — falling back to standalone (no basemap). Use a maplibre-* basemap instead (no token required).`
         );
       else {
-        this.mode = "basemap", this.basemapAttr = e, import("./basemap-2L7QA0ic.js").then(({ MapLibreBasemapAdapter: s }) => {
+        this.mode = "basemap", this.basemapAttr = e, import("./basemap-CtEc5BCi.js").then(({ MapLibreBasemapAdapter: s }) => {
           this.destroyed || i !== this.rendererGeneration || (this.basemap = new s(
             this.parent,
             // this.basemapAttr, not the captured param: a style switch that
@@ -82775,7 +82775,7 @@ function WU({ layerIRs: t, core: e, mapEl: i, selection: n, history: r, featureT
     }
   };
 }
-const jU = "0.7.4", t3e = "https://om-api.nika.eco/v1/t", to = { endpoint: t3e };
+const jU = "0.7.5", t3e = "https://om-api.nika.eco/v1/t", to = { endpoint: t3e };
 function i3e(t) {
   for (const e of Object.keys(t))
     to[e] = t[e];
@@ -87181,7 +87181,7 @@ async function IRe(t) {
   e(t);
 }
 async function ZMe() {
-  return import("./raster-B_pyNdlk.js").then((t) => t.r);
+  return import("./raster-Dsugvobw.js").then((t) => t.r);
 }
 const PRe = {
   registerLayer: Un,

package/dist/{index-Cgi3Rxih.js → index-HrEJtZoQ.js}

@@ -1,4 +1,4 @@
-import { ak as Bt, az as Xt, aA as Yt, aB as Us } from "./index-BirHZYjb.js";
+import { ak as Bt, az as Xt, aA as Yt, aB as Us } from "./index-DkimKgOm.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";

package/dist/{lerc-C1z6aAA4.js → lerc-BIQMg0FV.js}

@@ -1,4 +1,4 @@
-import { C as a, D as s } from "./raster-B_pyNdlk.js";
+import { C as a, D as s } from "./raster-Dsugvobw.js";
 const D = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null
 }, Symbol.toStringTag, { value: "Module" }));
@@ -8,7 +8,7 @@ var t;
 })(t || (t = {}));
 let l = !1;
 async function d() {
-  const e = await import("./LercDecode.es-5mg89-0f.js");
+  const e = await import("./LercDecode.es-DYwn8YTS.js");
   return l || (await e.load(), l = !0), e;
 }
 async function i(e, r) {

package/dist/onlymap.standalone.js

@@ -95155,7 +95155,7 @@ function OfA({ layerIRs: e, core: A, mapEl: t, selection: i, history: r, feature
     }
   };
 }
-const qfA = "0.7.4", xue = "https://om-api.nika.eco/v1/t", JE = { endpoint: xue };
+const qfA = "0.7.5", xue = "https://om-api.nika.eco/v1/t", JE = { endpoint: xue };
 function Lue(e) {
   for (const A of Object.keys(e))
     JE[A] = e[A];

package/dist/onlymapjs.js

@@ -1,4 +1,4 @@
-import { aC as e, aD as r, aE as t, aF as o, aG as b, aH as i, ap as l, aI as n, aJ as S, aK as c, aL as E, aM as L, aN as g, aO as T, aP as _, aQ as A, aR as d, aS as p, aT as I, aU as m, aV as D, aW as M, aX as u, aY as y, aZ as O, a_ as f, ao as R, a$ as N, aw as P, b0 as F, b1 as h, b2 as C, W as B, b3 as v, b4 as x, b5 as G, b6 as U, b7 as W, b8 as w, b9 as Y, ba as X, bb as H, bc as k, bd as J, be as K, bf as V, bg as z, bh as Q, bi as Z, bj as $, bk as j, bl as q, bm as aa, bn as sa, bo as ea, bp as ra, bq as ta, br as oa, bs as ba, bt as ia, bu as la, bv as na, bw as Sa, bx as ca, by as Ea, bz as La, bA as ga, bB as Ta, bC as _a, bD as Aa, bE as da, bF as pa, bG as Ia, bH as ma, bI as Da, bJ as Ma, bK as ua, bL as ya, bM as Oa, bN as fa, bO as Ra, bP as Na, bQ as Pa, bR as Fa, bS as ha, bT as Ca, bU as Ba, bV as va, bW as xa, bX as Ga, bY as Ua, bZ as Wa, b_ as wa, b$ as Ya, c0 as Xa, c1 as Ha, c2 as ka, c3 as Ja, c4 as Ka, c5 as Va, c6 as za, c7 as Qa, c8 as Za, c9 as $a, ca as ja, cb as qa, cc as as } from "./index-BirHZYjb.js";
+import { aC as e, aD as r, aE as t, aF as o, aG as b, aH as i, ap as l, aI as n, aJ as S, aK as c, aL as E, aM as L, aN as g, aO as T, aP as _, aQ as A, aR as d, aS as p, aT as I, aU as m, aV as D, aW as M, aX as u, aY as y, aZ as O, a_ as f, ao as R, a$ as N, aw as P, b0 as F, b1 as h, b2 as C, W as B, b3 as v, b4 as x, b5 as G, b6 as U, b7 as W, b8 as w, b9 as Y, ba as X, bb as H, bc as k, bd as J, be as K, bf as V, bg as z, bh as Q, bi as Z, bj as $, bk as j, bl as q, bm as aa, bn as sa, bo as ea, bp as ra, bq as ta, br as oa, bs as ba, bt as ia, bu as la, bv as na, bw as Sa, bx as ca, by as Ea, bz as La, bA as ga, bB as Ta, bC as _a, bD as Aa, bE as da, bF as pa, bG as Ia, bH as ma, bI as Da, bJ as Ma, bK as ua, bL as ya, bM as Oa, bN as fa, bO as Ra, bP as Na, bQ as Pa, bR as Fa, bS as ha, bT as Ca, bU as Ba, bV as va, bW as xa, bX as Ga, bY as Ua, bZ as Wa, b_ as wa, b$ as Ya, c0 as Xa, c1 as Ha, c2 as ka, c3 as Ja, c4 as Ka, c5 as Va, c6 as za, c7 as Qa, c8 as Za, c9 as $a, ca as ja, cb as qa, cc as as } from "./index-DkimKgOm.js";
 export {
   e as ALL_POSITION_VALUES,
   r as AUDIT_EXEMPTIONS,

package/dist/{raster-B_pyNdlk.js → raster-Dsugvobw.js}

@@ -1,5 +1,5 @@
-import { c as se, t as ze, i as wt, a as Be, s as St, C as Pt, b as bt, F as Ct, A as Lt, d as It, R as fe, e as Gt, p as vt, m as Et, f as Ft, g as At, r as _e, h as jt, j as Rt, k as Ut, l as Mt, n as Ot } from "./raster-pipeline-CJCRg21V.js";
-import { ax as Kt, ay as xt } from "./index-BirHZYjb.js";
+import { c as se, t as ze, i as wt, a as Be, s as St, C as Pt, b as bt, F as Ct, A as Lt, d as It, R as fe, e as Gt, p as vt, m as Et, f as Ft, g as At, r as _e, h as jt, j as Rt, k as Ut, l as Mt, n as Ot } from "./raster-pipeline-rqJJRCEo.js";
+import { ax as Kt, ay as xt } from "./index-DkimKgOm.js";
 import ye from "./index-CW1n5LdO.js";
 function Dt(e, t) {
   const n = e.length / 3, r = new Uint8ClampedArray(n * 4), o = 0, i = n, a = n * 2;
@@ -1070,7 +1070,7 @@ j.set(f.Zstd, () => import("./zstd-jXobGRcq.js").then((e) => e.decode));
 j.set(f.Jpeg, () => Promise.resolve(le));
 j.set(f.Jpeg6, () => Promise.resolve(le));
 j.set(f.Webp, () => Promise.resolve(le));
-j.set(f.Lerc, () => import("./lerc-C1z6aAA4.js").then((e) => e.l).then((e) => e.decode));
+j.set(f.Lerc, () => import("./lerc-BIQMg0FV.js").then((e) => e.l).then((e) => e.decode));
 async function ce(e, t, n) {
   const r = j.get(t);
   if (!r)

package/dist/{raster-pipeline-CJCRg21V.js → raster-pipeline-rqJJRCEo.js}

@@ -1,5 +1,5 @@
 import { w as de } from "./mgrs-BY9bIvp4.js";
-import { am as he, an as fe, ao as se, ap as oe, aq as me, b as pe, ar as ge, l as Z, as as ve, d as be, at as xe, au as Pe, av as ye, aw as ie } from "./index-BirHZYjb.js";
+import { am as he, an as fe, ao as se, ap as oe, aq as me, b as pe, ar as ge, l as Z, as as ve, d as be, at as xe, au as Pe, av as ye, aw as ie } from "./index-DkimKgOm.js";
 function Te(r, e, t) {
   const { projectedCorners: n } = e, { topLeft: s, topRight: o, bottomRight: i, bottomLeft: a } = n, c = t(s[0], s[1]), u = t(o[0], o[1]), l = t(i[0], i[1]), h = t(a[0], a[1]), f = [
     c,

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.7.4";
+export declare const LIBRARY_VERSION = "0.7.5";

package/dist/{zarr-_lE_wpg2.js → zarr-CRysSFhD.js}

@@ -1,5 +1,5 @@
-import { A as ur, d as lr, R as zt, e as fr, m as dr, p as St, f as hr, j as pr, k as mr } from "./raster-pipeline-CJCRg21V.js";
-import { ap as gr } from "./index-BirHZYjb.js";
+import { A as ur, d as lr, R as zt, e as fr, m as dr, p as St, f as hr, j as pr, k as mr } from "./raster-pipeline-rqJJRCEo.js";
+import { ap as gr } from "./index-DkimKgOm.js";
 import $t from "./index-CW1n5LdO.js";
 var Et;
 function h(e, t, n) {

package/llms.txt

@@ -42,9 +42,9 @@ Programmatic/native bridge rule: `MapController.setLayers()` accepts normal func
 - `<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). Selection-anchored overlays scope with `layer="…"` (one layer's picks only) and `selection-type="click"|"hover"` (one pick type only) — a click-opened popup should ALWAYS set `selection-type="click"`, else merely hovering any pickable feature drags it there and re-templates it against the hovered object; with it, hover is inert and a click on empty space still dismisses. `{{field}}` interpolates the picked feature HTML-escaped; `{{{field}}}` is raw (avoid); `{{z}}` is the pick's ELEVATION in meters, present only when a `pickable="3d"` layer ran deck's depth pass for that pick (absent — not `0` — otherwise, so "no elevation" is distinguishable from sea level). `clip-to-map` (opt-in) hides the overlay when its own BOX would spill past the map viewport rather than only when its anchor leaves — for small transient tips that track the cursor; an overhanging absolutely-positioned box inflates the page's scrollable overflow and the scrollbar -> map resize -> reprojection loop shows as view jitter. For labels on many features use `PopupLayer`, not overlays. STYLING: overlay content renders inside a shadow root (style isolation, like widgets) — page stylesheets/classes do NOT reach it; use inline `style="…"` on the content or a `<style>` element INSIDE the overlay (children move into the shadow root wholesale, so it applies there); inheritable props + CSS custom properties pierce.
 - `<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`, `set-pickable` (`{layer, pickable: true|false|"3d"}` — runtime picking/popup toggle, story-capturable; the per-layer popup on/off switch a viewer-facing export needs), `filter-layer`, `highlight-feature`, `zoom-to-feature`, `set-basemap`, `undo`, `redo`; scene/tool actions `set-lighting`, `set-terrain`, `set-clip-box` (`{min,max,invert?,highlight?}` / `{clear:true}`), `clip-box-edit` (`{editing}`), `export-region-3d` (`{target?, format?:"glb"|"b3dm"}` — what the draw widget's `export-3d` button emits), the draw actions `draw-mode` (`{target?:"sketch", mode:"point"|"line"|"polygon"|null}` — null exits drawing), `draw-commit`, `draw-cancel`, `draw-delete` (removes the last shape), `draw-clear`, `draw-config` (`{target?, autosave?, fillColor?, lineColor?}`) and `draw-save` (`{target?, format?:"download"|"file-system"|"both"}`) — every one of these drives the same store a `data="draw:<target>"` layer reads, so a custom toolbar can replace `<om-widget type="draw">` entirely; and the measure actions `measure-mode` (`{mode:"distance"|"area"|"volume"|null}`), `measure-units`, `measure-clear`, `measure-config` (`{profile?, baseSurface?, density?, swell?, shrink?, deadband?}`), `measure-flat-target-plane` (`{flat}`). 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")`.
-- `<om-fallback>` — static no-JS fallback, direct child of `<om-map>` (one per map, no attributes, plain HTML content — links allowed). Shown ONLY where scripts never run (chat-app/email file previews — iOS QuickLook renders HTML attachments with JS off — file managers, sandboxed webviews); hidden automatically once the map boots. GOOD PRACTICE: include one on every complete page, especially pages that may be shared as a file ("This interactive map requires JavaScript — open this file in a web browser", plus a hosted-version link when one exists). Without one, the stylesheet shows a generic text-only banner. The gate is pure CSS (`om-map:not(:defined)` in onlymapjs.css) refined by the `scripting` media feature on 2023+ engines: with scripting DISABLED the fallback shows instantly; with scripting ENABLED it never flashes during a slow load and only surfaces after a ~4s grace with load-failure wording (blocked/unreachable bundle). The CSS must load without JS — a real `<link rel="stylesheet">` or inlined `<style>` on no-build pages; a bundler-emitted stylesheet is fine in npm projects.
+- `<om-fallback>` — static no-JS fallback, direct child of `<om-map>` (one per map, no attributes, plain HTML content — links allowed). Shown ONLY where scripts never run (chat-app/email file previews — iOS QuickLook renders HTML attachments with JS off — file managers, sandboxed webviews); hidden automatically once the map boots. GOOD PRACTICE: include one on every complete page, especially pages that may be shared as a file. To PRODUCE a shareable single file, `npx @nika-js/onlymap export map.html` embeds every relative data/src/scenegraph URL as a data: URL (format detection preserved — the original extension rides a #name.ext fragment), pins relative library refs to the CDN, adds a generic om-fallback when missing, and warns when embedded data is heavy (>1 MB per file / >5 MB total) or when a source cannot be embedded (shapefile sidecars, COG Range streams, Zarr directories, {z}/{x}/{y} templates — those need hosting) ("This interactive map requires JavaScript — open this file in a web browser", plus a hosted-version link when one exists). Without one, the stylesheet shows a generic text-only banner. The gate is pure CSS (`om-map:not(:defined)` in onlymapjs.css) refined by the `scripting` media feature on 2023+ engines: with scripting DISABLED the fallback shows instantly; with scripting ENABLED it never flashes during a slow load and only surfaces after a ~4s grace with load-failure wording (blocked/unreachable bundle). The CSS must load without JS — a real `<link rel="stylesheet">` or inlined `<style>` on no-build pages; a bundler-emitted stylesheet is fine in npm projects.
 - Animation: `transition="get-fill-color 800ms, get-radius 400ms"` on a layer GPU-animates prop changes (also smooths streaming updates via `get-position`). Camera: the `fly-to` action takes `center`/`zoom`/`pitch`/`bearing`/`duration` (e.g. `duration="2s"`) — use it in behaviors or `data-emit` buttons; `zoom-to-feature` also accepts `duration`.
-- Pull-model frame rendering (external video frameworks such as Remotion): mark the map `data-om-recording` (the determinism switch — instant camera, no transitions/gesture interrupts, byte-stable `snapshot()`), then per frame `story.seek(t, {interpolateCamera: true})` + `await mapEl.whenSettled()` + capture; the same frame is byte-identical across processes and orderings. Story effect verbs (fade/pulse/trace/populate) evaluate as pure functions of story time under the switch — a seek landing mid-trace renders the half-drawn outline; only effects dispatched OUTSIDE a story (behaviors, ctx.emit) snap to their end state. `onlymapjs record` remains the built-in push-model path.
+- Pull-model frame rendering (external video frameworks such as Remotion): mark the map `data-om-recording` (the determinism switch — instant camera, no transitions/gesture interrupts, byte-stable `snapshot()`), then per frame `story.seek(t, {interpolateCamera: true})` + `await mapEl.whenSettled()` + capture; the same frame is byte-identical across processes and orderings. Story effect verbs (fade/pulse/trace/populate) evaluate as pure functions of story time under the switch — a seek landing mid-trace renders the half-drawn outline; only effects dispatched OUTSIDE a story (behaviors, ctx.emit) snap to their end state. `onlymapjs record` remains the built-in push-model path; `@nika-js/onlymap-remotion` packages the pull-model path for Remotion.
 - Travel-map animation: a `trace` story step takes `follow` (camera rides the drawing tip along the path) and `easing="linear|ease-in|ease-out|ease-in-out"`; combine with a TripsLayer route + pins toggled by later steps, and export with `npx onlymapjs record`.
 - Fixed-route 3D-tile pre-loading: `<om-story warm-tiles>` pre-fetches AND parses every 3D tileset's tiles along the story's fly-to route in the background at load (deck's own flight arc, sampled), so a flyby plays sharp instead of "blurry then clear" — or dispatch the `warm-tiles` action (`{story?, samples?, budget?}`; default budget raises each tileset cache to 256 MB, raise-only) manually before a take. Completion: `om-tiles-warmed` on `<om-map>`. Persistent per-layer knob: `load-options='{"tileset":{"maximumMemoryUsage":512}}'`.
 - Load-paced ("clean") flyby: `<om-story paced>` steps its own clock frame by frame (optionally `paced="60"` story-fps, default 30), drives the camera itself along the fly-to route, and never advances while any 3D tileset is still refining — NO frame ever shows unrefined tiles, at the cost of wall-clock time (playback is not real-time; use for recorded takes or heavy tilesets — Google Photorealistic 3D Tiles — where no pre-warm fits the flight in cache). Per-frame `om-paced-tick` on the story (`detail = {t, waitedMs}`; `waitedMs > 0` = that frame paused for tiles). Composes with `warm-tiles` (warm first → shorter waits). Paced runs: only `fly-to` steps steer the camera (`zoom-to-feature` etc. are skipped with a warning), and user gestures do NOT pause playback — use the player widget or `story-pause`. VIDEO OUTPUT: `npx onlymapjs record map.html --out flyby.mp4` (needs dev-installed playwright; ffmpeg for assembly, else PNG frames + the command to run) plays the story paced in headless Chromium and writes a video where every frame is fully refined — widgets/overlays/attribution included; options `--story/--fps/--width/--height/--scale/--gpu/--keep-frames/--timeout/--max-hold` (`--gpu` = hardware rendering instead of headless software GL — ~3× shorter tile holds on heavy 3D scenes, recommended); frames survive a deadline hit in `<out>.frames/` for salvage. Per-frame tile waits are capped by `paced-max-hold` on `<om-story>` (duration grammar, default 10s; `--max-hold` sets it) — frames that keep hitting the cap may stay slightly blurry; raise it, or set `"none"` (`--max-hold none`) for an absolute gate: guaranteed-sharp takes, only the overall timeout bounds the run. Custom recorders: `storyEl.setPacedCapture(async (tick) => {...})` — awaited per frame BEFORE that frame's om-paced-tick, so capture is race-free and the ended-state tick means all frames captured. Effect verbs (fade/pulse/trace/populate) animate on the STORY clock during paced runs — recorded frames capture traces half-drawn and fades mid-flight exactly as authored (`trace follow` is skipped; the paced route owns the camera).
@@ -62,6 +62,8 @@ UI panel (legend, chart, stats) → `<om-widget>`. Rich HTML at one map location
 
 In a React codebase, do NOT render om-* elements from JSX (React and the library would contend over the same DOM). Use the first-party adapter instead: `import { OmMap, OmLayer, OmWidget, OmOverlay, useOmMap } from "@nika-js/onlymap/react"` — camelCase deck.gl props, accessors as plain JS functions (`getFillColor={d => ...}`, no expression language), interactions as `onClick`/`onHover` handlers, widget state via the `useOmMap(watchTokens)` hook (tearing-safe: it rides `useSyncExternalStore` over the controller's per-token stores). To sync map state into Redux/MobX/Zustand/Jotai, use `controller.getStore(token)` — a framework-free `{subscribe, getSnapshot}` per watch token with cached plain-data snapshots and `origin: "user"|"programmatic"` tagging for echo-free two-way camera binding; ~20-line recipes: [docs/external-stores.md](docs/external-stores.md). Guide: [docs/react.md](docs/react.md).
 
+If the target is a VIDEO built in Remotion — titles/overlays composited over the map, map content reacting per frame, or one composition rendered as many videos from data — use the separate `@nika-js/onlymap-remotion` package on top of this one (it takes this package as an exact peer). It wraps the pull-model seams below into `<OmMapVideo>`, whose prop selects the camera source (a GeoJSON `route`, a `places` list, `keyframes`, or the manifest's own story) and derives the composition's duration from that same data. It ships its own `llms.txt` and skill. For a plain flyby video with nothing layered on top, `npx onlymapjs record` here is simpler and needs no extra package.
+
 If the target is an Expo/React Native MOBILE app, use the separate `@nika-js/onlymap-native` package instead of this one: same layer vocabulary, but accessors are OnlyMap expression STRINGS (`getPosition="[$lon, $lat]"` — functions cannot cross its JSON bridge), descriptors are plain JSON, and native UI goes beside the map (no om-* elements, no `<OmWidget>`/`<OmOverlay>` components). That package ships its own `llms.txt` and skill; follow those for native work.
 
 ## Docs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nika-js/onlymap",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "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.",
   "license": "SEE LICENSE IN LICENSE.md",
   "publishConfig": {

package/skills/onlymapjs/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: onlymapjs
-description: Build, edit, debug, or review OnlyMapJS declarative HTML maps and dashboards, or React maps via the @nika-js/onlymap/react adapter. Use when a user asks for an interactive map, deck.gl-style visualization, geospatial dashboard, live fleet/telemetry map, choropleth, popup/tooltip map, map story/tour, manual drawing/sketch map, 3D map assets, a React map component, a map page shared as a single HTML file (incl. no-JS fallbacks for chat/email previews), a responsive/mobile map whose controls auto-fold on narrow screens, auditing a map's widget layout with the check-layout tool, syncing OnlyMapJS map/camera state into an app state store (Redux, MobX, Zustand, Jotai — the getStore contract), BIM/IFC models (loading .ifc files in the browser, 3D Tiles per-element picking, isolate/hide/ghost, clash detection, model federation), routes and directions (a styled A-to-B route line, OSRM or another routing engine, click-to-route), live vehicle/rider/delivery tracking (a moving marker gliding between GPS fixes with a follow camera), a React Native or Expo mobile map (route to the separate @nika-js/onlymap-native package), or help with OnlyMapJS syntax, validation, widgets, data formats, testing, or publishing examples.
+description: Build, edit, debug, or review OnlyMapJS declarative HTML maps and dashboards, or React maps via the @nika-js/onlymap/react adapter. Use when a user asks for an interactive map, deck.gl-style visualization, geospatial dashboard, live fleet/telemetry map, choropleth, popup/tooltip map, map story/tour, manual drawing/sketch map, 3D map assets, a React map component, a map page shared as a single HTML file (incl. no-JS fallbacks for chat/email previews), a responsive/mobile map whose controls auto-fold on narrow screens, auditing a map's widget layout with the check-layout tool, syncing OnlyMapJS map/camera state into an app state store (Redux, MobX, Zustand, Jotai — the getStore contract), BIM/IFC models (loading .ifc files in the browser, 3D Tiles per-element picking, isolate/hide/ghost, clash detection, model federation), routes and directions (a styled A-to-B route line, OSRM or another routing engine, click-to-route), live vehicle/rider/delivery tracking (a moving marker gliding between GPS fixes with a follow camera), a React Native or Expo mobile map (route to the separate @nika-js/onlymap-native package), a Remotion map video or programmatic map flyover with overlays (route to the separate @nika-js/onlymap-remotion package), or help with OnlyMapJS syntax, validation, widgets, data formats, testing, or publishing examples.
 ---
 
 # OnlyMapJS
@@ -23,7 +23,7 @@ Use OnlyMapJS as a declarative HTML map library. Write custom elements such as `
 </script>
 ```
 
-For no-build CDN pages, use the single-file standalone bundle from a raw-file CDN — `https://unpkg.com/@nika-js/onlymap@0.7.4` (the bare package URL serves `dist/onlymap.standalone.js`) — plus `<link rel="stylesheet" href="https://unpkg.com/@nika-js/onlymap@0.7.4/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.
+For no-build CDN pages, use the single-file standalone bundle from a raw-file CDN — `https://unpkg.com/@nika-js/onlymap@0.7.5` (the bare package URL serves `dist/onlymap.standalone.js`) — plus `<link rel="stylesheet" href="https://unpkg.com/@nika-js/onlymap@0.7.5/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
 
@@ -66,6 +66,7 @@ Load the smallest reference needed for the task:
 
 ## Authoring Decisions
 
+- Target is a Remotion VIDEO (overlays composited over the map, map content reacting per frame, many videos from one composition) -> the separate `@nika-js/onlymap-remotion` package layered on this one: `<OmMapVideo>` with a `route`/`places`/`keyframes` prop, duration derived from the same data. It ships its own llms.txt and skill. A plain flyby with nothing on top needs no extra package — use `npx onlymapjs record`.
 - Target is an Expo/React Native MOBILE app -> the separate `@nika-js/onlymap-native` package, not this one: same layer vocabulary, but accessors are OnlyMap expression STRINGS (`getPosition="[$lon, $lat]"` — functions cannot cross its JSON bridge), descriptors are plain JSON, no om-* elements and no widget/overlay components (build native UI beside the map). It ships its own llms.txt and skill; follow those for native work.
 - UI panel, control, chart, legend, stats, filter, or draw toolbar -> `<om-widget>`.
 - Sparse rich HTML at one geographic location -> `<om-overlay>`.

package/skills/onlymapjs/references/syntax.md

@@ -16,8 +16,8 @@ Vite/npm project:
 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
-<link rel="stylesheet" href="https://unpkg.com/@nika-js/onlymap@0.7.4/dist/onlymapjs.css">
-<script type="module" src="https://unpkg.com/@nika-js/onlymap@0.7.4"></script>
+<link rel="stylesheet" href="https://unpkg.com/@nika-js/onlymap@0.7.5/dist/onlymapjs.css">
+<script type="module" src="https://unpkg.com/@nika-js/onlymap@0.7.5"></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).
@@ -632,6 +632,7 @@ Rules:
 - No attributes; plain HTML content — links work, so include a hosted-version URL when one exists.
 - Without an `<om-fallback>`, the stylesheet shows a generic text-only banner instead.
 - Requires `onlymapjs.css` to load without JavaScript (see Import Patterns above).
+- `npx @nika-js/onlymap export map.html` produces the shareable single file: relative data embedded as data: URLs (format detection intact), library refs pinned to the CDN, a generic fallback injected when missing, size warnings for heavy data. Shapefiles, COGs, Zarr, and tile templates stay network-backed.
 - Timing (2023+ browsers, via the CSS `scripting` media feature): with scripting disabled the fallback shows instantly; with scripting enabled it never flashes during a slow load — it appears only after a ~4s grace, with load-failure wording, when the bundle is blocked or unreachable. Older engines keep a 400ms reveal delay.
 
 Example: