sailkick-boat 0.18.2 → 0.18.4

package/README.md

@@ -1,35 +1,98 @@
 # sailkick-boat
 
-> ## ⚠️ Project status: early alpha — invite only
+> ## ⚠️ Project status: alpha
 >
-> This plugin is the **boat-side companion of the sailkick platform**: **cloud
-> telemetry** (gapless boat→shore sync of your vessel's data into a central InfluxDB)
-> and a **local proxy that keeps the sailkick app and its charts/maps fully usable
-> offline** on board. The service runs at **[www.sailkick.io](https://www.sailkick.io)**.
+> An offline webapp and mobile app for boat metrics, with weather, climatology and
+> basic routing. Add a sailkick account and you also get real-time cloud sync of those
+> metrics, polars, and an optional public page — so others can follow the boat, or you
+> can check on it while you are away.
 >
-> **Registration is invite-only** and happens on the website, not in the plugin — so
-> installing this from the Signal K Appstore is not enough on its own. Expect breaking
-> changes while the version is 0.x.
+> **Registration is free, and invite-only.** I'm looking for courageous early testers:
+> if you would like to try the plugin, email **[info@sailkick.io](mailto:info@sailkick.io)**.
+> Self-hosters can point it at their own sailkick server and InfluxDB v2 instead — see
+> [Config](#config).
 >
-> **Want an invite, or more information?** Get in touch:
-> **[info@sailkick.io](mailto:info@sailkick.io)**. Early testers are welcome.
-> Self-hosters can point the plugin at their own sailkick server and InfluxDB v2
-> instead — see [Config](#config).
-
-One Signal K plugin, independently-toggleable modules — so the boat stays
-"just SignalK + plugins":
-
-- **`sync`** — gapless store-and-forward of self-vessel telemetry to InfluxDB v2
-  (durable spool; survives offline + restarts). Data **out**.
-- **`proxy`** — offline-first caching **mirror of the sailkick host**: fetch once
-  online, serve from disk forever (incl. offline). Data **in**.
-- served alongside the mirror, from the boat's **own** data (so the app uses the
-  same contracts as the cloud, offline-first):
-  - **`/ws/telemetry`** — the app's live telemetry bus, fed from local SignalK.
-  - **`/api/history/{series,track}`** — the app's Trends panel + track, served
-    from a live ring sampled on the boat — full local history, no database.
-
-Kept as separate modules so a proxy fault can't wedge the data-critical sync path.
+> Expect breaking changes while the version is 0.x.
+
+One Signal K plugin doing four jobs, each independently toggleable — so the boat stays
+"just SignalK + plugins". They are deliberately separate modules: a fault in the cache
+must never wedge the data-critical sync path.
+
+**1. Data out — telemetry and AIS to the cloud.** Gapless store-and-forward of this
+vessel's data into your sailkick account, so the cloud holds your history and (later)
+can analyse it. Buffered on disk, so an offline passage or a restart loses nothing.
+Locally-received AIS targets go up too, letting you see the boat's surroundings from
+shore.
+
+**2. Data in — the app and its maps, cached for offline.** An offline-first mirror of
+the sailkick host: fetch once online, serve from disk forever. Charts, terrain, the app
+itself. Plus a worldwide base map seeded on start and an on-demand download of the area
+around the boat, so a usable chart exists before you lose connectivity — not only where
+you happened to browse.
+
+**3. Live data, served by the boat itself.** Caching alone would leave you offline with
+a dead app: no position, no instruments, no trends, no AIS, and a login wall. So the
+boat *answers* the app's live contracts from its own SignalK — `/ws/telemetry`,
+`/api/history/{series,track}`, `/api/ais` — and serves `/api/config` with the cloud
+login disabled. Same JSON the cloud returns, so the browser cannot tell the difference.
+
+**4. Backfill — an existing InfluxDB archive into the cloud.** If the boat recorded
+into its own database before it ever synced (a `signalk-to-influxdb-v2` bucket, or an
+imported logbook), a one-time resumable copy lifts that history into the cloud where the
+app can reach it.
+
+
+# 1 · Data out — telemetry and AIS to the cloud
+
+## Telemetry sync — gapless by design
+Every value on `vessels.self` is batched, written to a durable on-disk spool as one
+atomic file, and only then uploaded. A file is deleted **only** after InfluxDB
+acknowledges it with a `204`, so an offline stretch or a Signal K restart simply leaves
+files to send later — nothing is lost in the gap.
+
+- Network errors, `429` and `5xx` are retried with backoff (1 s → 60 s); the data stays
+  on disk.
+- A `4xx` is quarantined to `spool/dead/` rather than retried forever, because a
+  malformed or unauthorised batch would otherwise wedge the queue behind it.
+- The buffer is bounded (500 MB). On overflow the **oldest** files are dropped and
+  logged — a long-offline boat fills its own disk otherwise.
+- Timestamps are nanosecond-precise, so replaying after a reconnect overwrites rather
+  than duplicating. Re-sending is always safe.
+
+The destination is fixed at `https://sync.sailkick.io` and cannot be changed from the
+config page — a wrong endpoint here is invisible, since telemetry piling up in the spool
+looks exactly like a normal offline backlog. See
+[Troubleshooting](#troubleshooting-is-telemetry-actually-leaving-the-boat).
+
+## Uploading AIS targets
+The cloud app already draws other vessels, but its AIS source polls a SignalK server over
+the LAN and keeps everything in memory — which cannot work once a boat is on a mobile
+link. Enable **Upload AIS targets** and the boat pushes what its own receiver hears, so
+the web app can show other boats, their heading and their trail from stored data.
+
+Only **locally received** AIS is forwarded. A boat running an internet feed such as
+`signalk-aisstream` would otherwise spend uplink bandwidth sending data the cloud can
+fetch directly from the same API — known feeds are skipped automatically. The plugin logs
+the AIS sources it sees, so you can name your own receiver in **Only this AIS source** if
+you want to be explicit.
+
+There is no radius or rate limit: a real AIS receiver is bounded by VHF line-of-sight,
+which is the honest limiter, and offshore — where this data is most valuable, because
+commercial feeds are blind there — it tends to zero. Vessel identity (name, dimensions,
+ship type) repeats every few minutes and never changes, so it is re-sent at most hourly;
+positions are never throttled.
+
+Telemetry always wins the link. AIS buffers in its **own** spool with its own cap and
+stands down completely whenever the telemetry spool has a backlog, so a busy anchorage
+can never delay or evict your own boat's data.
+
+> ⚠️ **Requires a cloud that filters history on `self`.** Every AIS row is tagged
+> `self=false`, and the cloud's Trends and track queries must filter `self == "true"`.
+> Without that, other ships' speed and heading appear in *your* charts. Leave this off
+> until the server side is in place.
+
+
+# 2 · Data in — the app and its maps, cached offline
 
 ## Proxy: how it works
 ```
@@ -62,6 +125,14 @@ comes from the cloud **announcing bakes**, not from a clock:
 
 `X-Sailkick-Cache` reports `HIT` / `MISS` / `UPDATED` / `STALE` / `LIVE` per response.
 
+**The app itself is never pinned.** `/`, any `index.html`, the web manifest and `/health`
+are fetched fresh whenever online. They are the only files whose URL does not change
+between deploys — everything they pull in is content-hashed (`main-Cm1RhM4y.js`), so a
+fresh shell drags in a new build as ordinary cache misses, and the old hashed files just
+sit there harmlessly. Pin the shell instead and the boat stays on whatever build it
+cached first, forever. Offline the last-seen shell is served as `STALE`, so the app still
+opens with no uplink.
+
 **Static vs dynamic — two strategies.** Tiles and app assets are **cache-first**
 (pinned, offline forever). Dynamic `/api/*` data (AIS, weather, lightning) is
 **network-first**: fetched live every time online (so it never goes stale), with the
@@ -113,6 +184,31 @@ passage area on demand.
   boat's current position from local SignalK, builds a box, and warms the chart layers
   in the background (progress in the status line). Idempotent; re-saving tops up. An
   oversized radius+detail is refused (reduce one). Config `prefetchRadiusNm` / `prefetchDetailZoom`.
+
+  **Each layer is clamped to the zoom it actually publishes**, read from the upstream's
+  `/api/assets` (with a built-in fallback so it still works offline). Coastline tops out
+  at z13 where osm-standard reaches z19, so asking for "Harbor (z15)" fetches osm, seamap
+  and bathy to 15 and coastline only to 13 — instead of spending ~23% of the budget on
+  coastline tiles that can only 404. Those refusals also counted toward the cap, so a
+  request could be turned away for tiles that were never there.
+
+  **What fits under the 150k cap** (four layers, mid-latitude, from z6):
+
+  | radius | z12 | z13 | z14 | z15 |
+  |---|---|---|---|---|
+  | 25 nm | 1.1k | 4.1k | 12.5k | 46k |
+  | 50 nm | 4.1k | 15.3k | 48k | 179k ✗ |
+  | 100 nm | 15.5k | 60k | 192k ✗ | 715k ✗ |
+
+  So **50 nm at z14** or **25 nm at z15** are the practical maxima. A refused request
+  pre-warms *nothing* — check the status line rather than assuming coverage exists.
+
+**Resolution is only limited when pre-warming.** On-demand caching has no zoom ceiling:
+whatever the browser requests while online is stored and served offline afterwards, up to
+the upstream's own maximum (z19 for osm-standard, z18 seamap). Browse a harbour approach
+once with a connection and it is yours. Pre-warming is capped at z15 by the settings
+dropdown — 3.5 m/px, ample for coastal work but coarser than the z17–18 you might want
+alongside a berth.
 - **Region prefetch (API)** — for scripted/arbitrary boxes, warm the detailed chart layers for an area:
   ```
   POST /plugins/sailkick-boat/prefetch/region
@@ -128,6 +224,9 @@ passage area on demand.
 Note: the app's **Coastline** and depth layers are default-off toggles — enable them in
 the app to see the seeded base.
 
+
+# 3 · Live data, served by the boat
+
 ## No login on the boat (single-tenant)
 The cloud app gates behind a boat-account login (a `Secure` session cookie), which
 can't work over the boat's plain-HTTP offline mirror — the browser drops a `Secure`
@@ -171,32 +270,8 @@ the chart.
 This works **with no uplink at all**, which is when other vessels on your chart matter
 most. Turn it off by hand-editing `proxy.serveAis: false`.
 
-## Uploading AIS targets
-The cloud app already draws other vessels, but its AIS source polls a SignalK server over
-the LAN and keeps everything in memory — which cannot work once a boat is on a mobile
-link. Enable **Upload AIS targets** and the boat pushes what its own receiver hears, so
-the web app can show other boats, their heading and their trail from stored data.
-
-Only **locally received** AIS is forwarded. A boat running an internet feed such as
-`signalk-aisstream` would otherwise spend uplink bandwidth sending data the cloud can
-fetch directly from the same API — known feeds are skipped automatically. The plugin logs
-the AIS sources it sees, so you can name your own receiver in **Only this AIS source** if
-you want to be explicit.
-
-There is no radius or rate limit: a real AIS receiver is bounded by VHF line-of-sight,
-which is the honest limiter, and offshore — where this data is most valuable, because
-commercial feeds are blind there — it tends to zero. Vessel identity (name, dimensions,
-ship type) repeats every few minutes and never changes, so it is re-sent at most hourly;
-positions are never throttled.
 
-Telemetry always wins the link. AIS buffers in its **own** spool with its own cap and
-stands down completely whenever the telemetry spool has a backlog, so a busy anchorage
-can never delay or evict your own boat's data.
-
-> ⚠️ **Requires a cloud that filters history on `self`.** Every AIS row is tagged
-> `self=false`, and the cloud's Trends and track queries must filter `self == "true"`.
-> Without that, other ships' speed and heading appear in *your* charts. Leave this off
-> until the server side is in place.
+# 4 · Backfill — an existing archive into the cloud
 
 ## Copying older history to the cloud (one-time)
 If the boat recorded into its own InfluxDB before it started syncing — a
@@ -215,6 +290,43 @@ uploads is verified by counting the destination, and a write-only token cannot r
 a partial write would be marked done and lost. The token is only needed while the
 backfill runs: **revoke it afterwards**, live sync is unaffected.
 
+> The two tokens a boat normally has are **both insufficient**: the scoped read token
+> cannot write (`403 insufficient permissions for write`) and the scoped write token
+> cannot verify. Mint one carrying *both* permissions on `<slug>_raw`.
+
+### What to expect
+This is a background job measured in **days or weeks**, not minutes. Measured on a real
+boat — a Raspberry Pi over Starlink, migrating a `signalk-to-influxdb-v2` archive of
+~57 GB going back 20 months:
+
+| | |
+|---|---|
+| sustained throughput | ~10,000 points/s |
+| archive consumed | ~24× realtime |
+| a dense hour (2.7M points) | subdivides into ~30 chunks |
+
+It gets faster as it goes: the walk is newest-first and older data is usually sparser
+(that boat's recent hours held ~2.7M points, its oldest ~0.8M). Leave it running — it
+survives restarts, and it yields to live telemetry so it cannot delay your own boat's
+data.
+
+**Watching progress.** The status line shows the current window and running total. For
+detail, the manifest lists every completed hour:
+
+```bash
+cat <dataDir>/backfill.json    # {"done":{...},"points":532062426,"complete":false}
+```
+
+From the cloud side, the oldest point in your bucket marches backwards as it works — that
+is the single clearest signal that it is delivering:
+
+```flux
+from(bucket:"<slug>_raw")|>range(start:0)|>keep(columns:["_time"])|>group()|>min(column:"_time")
+```
+
+Once the bucket is large that query gets expensive; counting a single one-hour window
+near the frontier is cheaper and tells you the same thing.
+
 Safe to re-run. Points are keyed by (measurement, tagset, nanosecond timestamp), so an
 identical point overwrites rather than duplicating — an interrupted migration is simply
 run again.
@@ -287,6 +399,9 @@ works **offline** with the boat's own data. Only when no telemetry source is
 available at all do these paths **fall through to the cloud mirror**, so an
 online boat is never worse off than before.
 
+
+# Running it
+
 ## Setup: register on the web, then paste the token
 1. Register your boat at **[www.sailkick.io](https://www.sailkick.io)** (an invite code
    is needed — see above). The signup screen shows your boat's ingest credentials.
@@ -389,6 +504,23 @@ curl -i -XPOST "https://sync.sailkick.io/api/v2/write?org=sailkick&bucket=<slug>
 ```
 `204` = good, `401` = token not valid for that bucket.
 
+## Known gaps
+Things this deliberately does not do yet, so they don't come as a surprise:
+
+- **Wind and current fields are not prefetched.** Velocity tiles are pinned once fetched
+  (they are keyed by forecast run, so they never go stale), but nothing warms them ahead
+  of time — offline, the wind field covers only where you have already panned. Old
+  forecast runs are also never pruned, so their tiles accumulate.
+- **The backfill cannot fill gaps in live coverage.** It only copies data *older* than
+  the point where cloud sync began, so if live sync ever dropped data — an outage longer
+  than the spool's capacity — that hole stays, even when the local archive still has it.
+- **Backfilled history is not browsable in the app.** `/api/history/*` accepts only a
+  relative window clamped to 24 h, so once 2024 is in the cloud there is still no way to
+  display it. That needs `from`/`to` support server-side.
+- **Per-path sync rate is approximate.** The subscription sets `period` without a
+  `policy`, so Signal K's default governs and a few chatty paths exceed the configured
+  interval.
+
 ## Dev / tests
 ```bash
 npm install && npm test   # proxy: mirror/cache/offline + Express route; sync: subscribe+buffer

package/lib/proxy/index.js

@@ -30,7 +30,39 @@ const { countBboxTiles, bboxTiles, boxAround } = require('./tiles')
 // must stay live, otherwise the boat pins itself to a stale forecast run forever.
 const IMMUTABLE_API_PREFIXES = ['/api/velocity/tiles/']
 const isImmutableApi = (p) => IMMUTABLE_API_PREFIXES.some((x) => p.startsWith(x))
-const isNetworkFirst = (p) => p.startsWith('/api/') && !isImmutableApi(p)
+
+// HTML entry documents are network-first too, for the opposite reason to tiles: they are
+// the ONE file whose URL never changes across deploys. Everything they pull in is
+// content-hashed (main-Cm1RhM4y.js, main-BboaeyYc.css), so a fresh index.html
+// automatically drags in the new build as ordinary cache misses — but a pinned one keeps
+// the boat on whatever version it happened to cache first, forever.
+//
+// The cache manifest was supposed to handle this by announcing a new `app` id. In
+// practice that id is the app's package version, which does not change on every deploy
+// (three deploys in one day all reported "0.2.0"), so nothing was ever invalidated.
+// Not caching the entry document removes the dependency on that signal entirely.
+//
+// Costs one ~8 KB request per app load while online. Offline it falls back to the cached
+// copy as STALE like any network-first path, so the app still opens with no uplink.
+// /health reports the running build and uptime — pinning it freezes the version the UI
+// displays, which is its own small version of this bug.
+const LIVE_PATHS = new Set(['/health'])
+const isEntryDocument = (p) => {
+  const path = p.split('?')[0]
+  return path === '/' || path.endsWith('/') || path.endsWith('.html') ||
+    path.endsWith('.webmanifest') || LIVE_PATHS.has(path)
+}
+const isNetworkFirst = (p) => isEntryDocument(p) || (p.startsWith('/api/') && !isImmutableApi(p))
+
+// A prefetch must not spend its tile budget on tiles that cannot exist. Layers top out
+// at very different zooms — coastline at 13 where osm-standard goes to 19 — so applying
+// one "detail level" to all of them wasted 23% of a real 50nm/z15 run on ~55k coastline
+// requests that could only 404. Those also counted toward the cap, so a request could be
+// refused for tiles that were never there.
+//
+// The upstream publishes the real limits at /api/assets, so ask rather than hardcode;
+// these are only the fallback for when it cannot be reached (offline, or an older host).
+const FALLBACK_MAX_ZOOM = { 'osm-standard': 19, seamap: 18, bathy: 16, coastline: 13, 'natural-earth': 7 }
 
 function createProxy (app, options) {
   const log = (m) => (app.debug ? app.debug('[proxy] ' + m) : console.log('[sailkick-boat:proxy]', m))
@@ -129,6 +161,56 @@ function createProxy (app, options) {
     return `proxy: mirror ${cfg.upstream}${cfg.port ? ' :' + cfg.port : ''}; live -> ${cfg.localSignalk}${m}${s}${areaStatus()}`
   }
 
+  // Per-layer max zoom from the upstream asset manifest, cached. Never throws: on any
+  // failure the fallback table is used, so a prefetch still runs offline.
+  let zoomCache = null
+  // Synchronous view, so planning a prefetch never waits on the network. The fallback
+  // matches what the upstream publishes today; refreshLayerZooms() replaces it in the
+  // background at start, and the region API awaits it for the freshest numbers.
+  const zooms = () => zoomCache || FALLBACK_MAX_ZOOM
+  async function layerMaxZooms () {
+    if (zoomCache) return zoomCache
+    const out = { ...FALLBACK_MAX_ZOOM }
+    try {
+      const r = await fetch(cfg.upstream + '/api/assets', { signal: AbortSignal.timeout(cfg.timeoutMs) })
+      if (r.ok) {
+        const j = await r.json()
+        const raster = j && j.tiles && j.tiles.manifest && j.tiles.manifest.maxZoom
+        if (raster && typeof raster === 'object') Object.assign(out, raster)
+        // coastline is a vector layer and reports its own bounds separately
+        if (j && j.coastline && Number.isFinite(j.coastline.maxZoom)) out.coastline = j.coastline.maxZoom
+        log(`layer max zooms: ${Object.entries(out).map(([k, v]) => k + '=' + v).join(' ')}`)
+      }
+    } catch { log('could not read /api/assets — using fallback layer zoom limits') }
+    zoomCache = out
+    return out
+  }
+
+  // COUNT ONLY — arithmetic, no allocation. The cap exists to stop absurd requests, so
+  // it has to be checked before anything is enumerated: a global z0-15 box is ~1.4
+  // billion tiles per layer, which must never reach an array.
+  function planTiles (bbox, minZoom, maxZoom, layers, zooms) {
+    const perLayer = {}
+    let total = 0
+    for (const l of layers) {
+      const top = Math.min(maxZoom, zooms[l] == null ? maxZoom : zooms[l])
+      const count = top < minZoom ? 0 : countBboxTiles(bbox, minZoom, top)
+      perLayer[l] = { top, count }
+      total += count
+    }
+    return { total, perLayer }
+  }
+
+  // Enumerate only once the plan is known to be within the cap. A generator, so even a
+  // large accepted plan is streamed rather than held twice.
+  function * enumerateTiles (bbox, minZoom, perLayer) {
+    const ext = (l) => (l === 'coastline' ? 'pbf' : 'png')
+    for (const [l, { top }] of Object.entries(perLayer)) {
+      if (top < minZoom) continue
+      for (const { z, x, y } of bboxTiles(bbox, minZoom, top)) yield `/tiles/${l}/${z}/${x}/${y}.${ext(l)}`
+    }
+  }
+
   const isLocal = (p) => cfg.localPaths.some((lp) => p === lp || p.startsWith(lp + '/') || p.startsWith(lp + '?'))
 
   async function serveMirror (req, res) {
@@ -351,18 +433,15 @@ function createProxy (app, options) {
       const maxZoom = Math.max(minZoom, clampInt(body.maxZoom, 15, 0, 20))
       const layers = (Array.isArray(body.layers) && body.layers.length) ? body.layers : ['osm-standard', 'bathy', 'seamap', 'coastline']
       const CAP = 50000
-      const estimate = countBboxTiles(bbox, minZoom, maxZoom) * layers.length
-      if (estimate > CAP && !body.force) {
-        res.json({ ok: true, capped: true, estimate, cap: CAP, message: `~${estimate} tiles exceeds ${CAP}; narrow bbox/zoom or pass force:true` })
+      if (!zoomCache) layerMaxZooms().catch(() => {}) // refresh for next time; never block a request
+      const { total, perLayer } = planTiles(bbox, minZoom, maxZoom, layers, zooms())
+      if (total > CAP && !body.force) {
+        res.json({ ok: true, capped: true, estimate: total, cap: CAP, perLayer, message: `~${total} tiles exceeds ${CAP}; narrow bbox/zoom or pass force:true` })
         return
       }
-      const ext = (layer) => (layer === 'coastline' ? 'pbf' : 'png')
-      const paths = []
-      for (const layer of layers) {
-        for (const { z, x, y } of bboxTiles(bbox, minZoom, maxZoom)) paths.push(`/tiles/${layer}/${z}/${x}/${y}.${ext(layer)}`)
-      }
+      const paths = [...enumerateTiles(bbox, minZoom, perLayer)]
       const r = await warmMany(paths, { concurrency: body.concurrency || 6 })
-      res.json({ ok: true, requested: paths.length, ...r })
+      res.json({ ok: true, requested: paths.length, perLayer, ...r })
     })
   }
 
@@ -392,14 +471,19 @@ function createProxy (app, options) {
       if (attempt < 30 && !stopping) { const t = setTimeout(() => startAreaPrefetch(attempt + 1), 10000); if (t.unref) t.unref() } else log('area prefetch: no boat position — skipped')
       return null
     }
+    // Learn the real per-layer limits for next time; plan now with what we have. Only
+    // probed when a prefetch is actually configured — a boat that never prefetches
+    // should not make the request at all.
+    if (!zoomCache) layerMaxZooms().catch(() => {})
+
     const bbox = boxAround(pos.latitude, pos.longitude, radius)
     const CAP = 150000
-    const total = countBboxTiles(bbox, minZoom, maxZoom) * layers.length
+    const { total, perLayer } = planTiles(bbox, minZoom, maxZoom, layers, zooms())
+    const clamped = Object.entries(perLayer).filter(([, v]) => v.top < maxZoom)
+    if (clamped.length) log(`area prefetch: ${clamped.map(([l, v]) => `${l} capped at z${v.top}`).join(', ')} (upstream limit — those tiles do not exist)`)
     if (total > CAP) { area = { capped: true, total, radius, maxZoom }; log(`area prefetch: ~${total} tiles too large — reduce radius/detail`); return null }
-    const ext = (l) => (l === 'coastline' ? 'pbf' : 'png')
-    const paths = []
-    for (const l of layers) { for (const { z, x, y } of bboxTiles(bbox, minZoom, maxZoom)) paths.push(`/tiles/${l}/${z}/${x}/${y}.${ext(l)}`) }
-    area = { done: 0, total: paths.length, running: true, radius, maxZoom }
+    const paths = [...enumerateTiles(bbox, minZoom, perLayer)]
+    area = { done: 0, total: paths.length, running: true, radius, maxZoom, perLayer }
     log(`area prefetch: ${radius}nm around ${pos.latitude.toFixed(2)},${pos.longitude.toFixed(2)} to z${maxZoom} — ${paths.length} tiles`)
     area.promise = warmMany(paths, { concurrency: pf.concurrency || 4, onProgress: () => { area.done++ } })
       .then((r) => { area.running = false; area.result = r; log(`area prefetch done: ${r.cached} cached, ${r.empty} empty, ${r.failed} failed`); return r })
@@ -416,4 +500,4 @@ function createProxy (app, options) {
   return { start, stop, status, handleGet, handlePrefetch, handlePrefetchRegion, handleClear, _serveMirror: serveMirror, _serveConfig: serveConfig, _manifest: () => manifest, _seeder: () => seeder, _startAreaPrefetch: startAreaPrefetch, _area: () => area }
 }
 
-module.exports = { createProxy, isNetworkFirst, isImmutableApi }
+module.exports = { createProxy, isNetworkFirst, isImmutableApi, isEntryDocument }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sailkick-boat",
-  "version": "0.18.2",
+  "version": "0.18.4",
   "description": "EARLY ALPHA — cloud telemetry + offline maps for sailkick boats (www.sailkick.io; register on the web, paste the write token). Gapless boat→cloud telemetry sync to InfluxDB, and a local proxy that keeps the sailkick app and its charts/maps working fully offline on board.",
   "main": "index.js",
   "scripts": {