sailkick-boat 0.30.0 → 0.32.0

package/README.md

@@ -203,6 +203,16 @@ because a renderer handed a gzip header errors hard while a missing tile simply
 to its parent. Content that is legitimately gzip — a `.gz` asset, a gzip content-type — is
 left alone: that is a payload, not an encoding.
 
+**`/sw.js` is network-first too**, and it is the sharpest case. The mobile app is a PWA
+whose service worker answers `mobile.html` and its assets from its *own* cache — before
+the request ever reaches this mirror — and the browser installs a new worker only when
+`sw.js`'s bytes change. So `sw.js` is the one un-hashed file that *is* the update signal:
+serve a stale one and the whole mobile shell freezes, however fresh the copy of
+`mobile.html` in the store happens to be. (Strictly it was never pinned *forever* — the
+manifest's `app` family invalidates it whenever the app's sha changes — but making the
+shell's update depend on a best-effort 5-minute poller is exactly the dependency the
+entry-document rule exists to remove.)
+
 ## Offline map coverage — global base seed + region prefetch
 On-demand caching only holds what you browsed. To make a usable map exist offline
 *everywhere*, the plugin seeds a worldwide low-zoom base on start and lets you warm a
@@ -503,6 +513,44 @@ dead feed is exactly a timestamp that stops moving). The two are reconciled by b
 the skew: a SignalK clock more than a minute from system time falls back to system time
 with one warning, rather than reporting a permanent phantom "feed stale".
 
+## A dead instrument is a gap, not a frozen value
+
+The telemetry state accumulates every SignalK delta into one object, so without care
+nothing in it ever expires. When **one** instrument dies while the others keep publishing,
+its fields freeze at their last value while `updatedAt` stays fresh — and every consumer
+treats dead data as live.
+
+This is not hypothetical. In deep water the sounder loses the bottom and simply stops
+publishing. Measured on this boat: for the hour after it went quiet the cloud (which
+stores only real updates) showed an honest **gap**, while the boat's ring recorded
+`224.85 m` every 15 seconds — a dead-flat plateau, and with min/max bands a **zero-width
+envelope**, which is the most confident possible rendering of an instrument that is not
+there. Two stories about the same hour; the plateau is the lie.
+
+So every field carries the time it was last patched, and the published view omits anything
+older than `fieldTtlSec` (default 15 s). Downstream this needs no cooperation: the ring
+records nothing so the series gaps, the app's `Number.isFinite` guards show `—`, and the
+alert evaluator's own "cannot tell" semantics take over — which never clears a raised
+alarm and never raises a new one on dead data. A returning instrument reappears on its
+first fresh delta; the internal state is never mutated, only filtered on read.
+
+Two cases needed more than a timestamp:
+
+- **A position expires whole.** `lat`/`lon` arrive as one `navigation.position` value, half
+  a fix is not a fix, and an anchor watch must not watch a frozen one.
+- **`headingDeg` is computed**, not patched — it never appears in a delta, so its freshness
+  is derived from its inputs (compass + variation, or a published true heading). Without
+  that rule it would never expire, which is the frozen-heading bug surviving the fix.
+
+**The TTL is measured, not guessed.** Every path that feeds BoatState on this boat arrives
+at ~1 Hz with a worst observed inter-sample gap of 2.8 s, so 15 s is about seven times the
+worst case. Crucially the subscription is fixed-period (`{ path: '*', period: 1000 }`) and
+the server republishes unchanged values — `navigation.magneticVariation`,
+`navigation.gnss.satellites` and `propulsion.port.runTime` all arrive at 1 Hz with 100%
+repeated values — so a healthy-but-constant instrument (an engine at rest publishing
+`rpm 0`) keeps arriving and does not expire. A boat configured on-change could differ,
+which is why `proxy.fieldTtlSec` can be raised by hand.
+
 ## Two paths, one reading
 
 Source priorities solve *several devices on one path*. There is a second, separate case:
@@ -785,10 +833,22 @@ A useful side-effect: the auto-coarsening that keeps the ring under `MAX_SAMPLES
 longer lossy. Only the *emit* rate coarsens, never the poll, so a 30-day passage emitting
 every ~52 s still carries the true min/max within each 52 s.
 
-**Compass channels never get a band** — `twd`, `twa`, `awa`, `cog`, `heading`, `wptBrg`.
-The mean of 359° and 1° is 180°, the exact opposite of the truth, so those carry a
-last-reading snapshot and no band, ever. It is the one error here that would look entirely
-plausible on screen, so the tests pin it.
+**Compass channels are circular-meaned and never get a band** — `twd`, `twa`, `awa`,
+`cog`, `heading`, `wptBrg`. The *arithmetic* mean of 359° and 1° is 180°, the exact
+opposite of the truth, so these use the unit-vector mean `atan2(Σsin, Σcos)` instead: a
+genuine average with no seam. A min/max stays meaningless on a circle, so they carry no
+band, ever — the one error here that would look entirely plausible on screen.
+
+Two things the tests pin hard. **`twa` and `awa` stay signed, −180..180**, port negative,
+because that is what the number means; a circular mean returns 0..360, so they are folded
+back — without it a port-side wind reads as 270°, which is not a rounding difference but a
+different quantity. (Pinned as a fuzzed invariant, not two examples.) And **readings that
+cancel report nothing rather than north**: two exactly opposite bearings have no average,
+and `atan2(0, 0)` answers 0° with total confidence.
+
+Before 0.31.0 these channels served the last reading in each bucket — correct, but one
+sample per bucket, and the emit rate coarsens to ~52 s on a 30-day passage, so a direction
+trace was visibly jumpier aboard than ashore for the same minute.
 
 `chans=sog,aws` narrows the answer to the channels actually plotted; `bands` appears only
 when `stats=1` was asked *and* the provider produced them, so every client degrades to the

package/index.js

@@ -372,7 +372,12 @@ module.exports = function (app) {
 
       if (p.serveTelemetry !== false) {
         try {
-          telemetry = createTelemetry(app, {})
+          // fieldTtlSec is a hand-editable escape hatch, not a config field: the right
+          // value follows from the bus's publish cadence, which the owner has no way to
+          // judge. Measured on this boat, every path feeding BoatState arrives at ~1 Hz
+          // (worst gap 2.8 s), so the 15 s default is ~7x margin. A boat whose SignalK is
+          // configured on-change, or with a slow NMEA0183 source, can raise it here.
+          telemetry = createTelemetry(app, { fieldTtlSec: p.fieldTtlSec })
           telemetry.start()
           pOpts.telemetryUpgrade = (req, sock, head) => telemetry.handleUpgrade(req, sock, head)
         } catch (e) {

package/lib/history/angles.js

@@ -0,0 +1,86 @@
+// VENDORED from sailkick/shared/engine/angles.js @ a8c7153  sha256:6d001aa2e5a8f83b
+// Do not edit here — fix upstream and re-vendor. ONE definition of compass maths, so the
+// boat and the cloud answer "what was the average wind direction in this minute" the same
+// way. test/history-ring.test.js exercises it through the ring.
+//
+// Converted ESM -> CommonJS ONLY (export keywords removed, module.exports appended).
+// No logic changed.
+//
+// NB the upstream note on wrap180: it is deliberately duplicated here and in
+// perf-live.js rather than imported, so that each stays a SINGLE-FILE vendor with its own
+// pinned hash. The app fuzzes the two definitions against each other
+// (tests/test-angles.mjs); the same discipline applies to this copy.
+
+// Compass angle maths. Pure — no imports, no DOM — because shared/engine is the layer the
+// boat plugin vendors (tests/test-layering.mjs enforces both).
+//
+// The one idea worth stating: a compass reading is a point on a CIRCLE, and almost every
+// arithmetic operation you would reach for is wrong on a circle. The mean of 359° and 1° is
+// 180°, the exact reciprocal. min/max across the seam are meaningless. A line drawn from
+// 359° to 1° streaks the full height of a chart. Each of those has bitten this codebase.
+//
+// Two frames, and the whole file is about keeping them straight:
+//
+//   WRAPPED   — every value in [0,360). What instruments publish and what BoatState,
+//               /api/history/series and the dials all use. Correct for "where is it now",
+//               useless for "how did it change".
+//   UNWRAPPED — a continuous frame where 359 → 1 is recorded as 359 → 361. Differences and
+//               averages are ordinary arithmetic again. Correct for a series, meaningless
+//               as an absolute bearing until you wrap360 it at the very end.
+//
+// Same doctrine the routing field already uses for longitude — work in an unwrapped frame,
+// wrap only at the boundary (shared/engine/route-field.js:48, docs/ROUTING-FIELD.md:85).
+
+const wrap360 = (d) => ((d % 360) + 360) % 360;
+
+// Signed shortest path, (-180, 180]. NOTE: deliberately duplicated from perf-live.js:16
+// rather than imported. perf-live.js is vendored into sailkick-boat as a SINGLE FILE with a
+// pinned hash (see server/history/influx-provider.js:22); giving it an import would turn a
+// one-file copy into a two-file vendor contract. tests/test-angles.mjs fuzzes the two
+// definitions against each other, which buys the anti-drift guarantee without the coupling.
+const wrap180 = (d) => { const x = wrap360(d); return x > 180 ? x - 360 : x; };
+
+// One step of the UNBOUNDED accumulate: the nearest equivalent of `deg` to `prev`.
+// `prev` is the previous UNWRAPPED value, or null/undefined to seed the chain.
+//
+// Unbounded is the whole point, and is what separates this from the superficially identical
+// accumulators in perf-live.js:43 and mobile/main.js:352 — both of those re-wrap on every
+// step (bounded), because a dial must not spin away. A series must: after a full 360° veer
+// the result is legitimately start+360, and clamping it would reintroduce the jump this
+// exists to remove.
+const unwrapStep = (prev, deg) => (prev == null ? wrap360(deg) : prev + wrap180(deg - prev));
+
+// Lift a wrapped compass series into the unwrapped frame, in array order.
+//
+// Non-finite entries pass through untouched and DO NOT reset the chain. That is not
+// politeness about bad data: re-seeding after a dropout picks a fresh branch of the circle,
+// so every later point silently shifts by a multiple of 360 and the trace jumps for a reason
+// no one will ever track down.
+function unwrapDeg(degs) {
+  const out = new Array(degs.length);
+  let prev = null;
+  for (let i = 0; i < degs.length; i++) {
+    const d = degs[i];
+    if (!Number.isFinite(d)) { out[i] = d; continue; }
+    prev = unwrapStep(prev, d);
+    out[i] = prev;
+  }
+  return out;
+}
+
+// Circular mean of wrapped degrees — the honest average of a set of directions, via the
+// unit-vector sum. Returns wrapped degrees, or null when there is nothing to average or the
+// directions cancel exactly (opposite readings have no meaningful mean, and atan2(0,0) would
+// answer 0° with false confidence).
+function circularMeanDeg(degs) {
+  let sx = 0, sy = 0, n = 0;
+  for (const d of degs) {
+    if (!Number.isFinite(d)) continue;
+    const r = d * Math.PI / 180;
+    sx += Math.cos(r); sy += Math.sin(r); n++;
+  }
+  if (!n || Math.hypot(sx, sy) < 1e-9) return null;
+  return wrap360(Math.atan2(sy, sx) * 180 / Math.PI);
+}
+
+module.exports = { wrap360, wrap180, unwrapStep, unwrapDeg, circularMeanDeg }

package/lib/history/ring.js

@@ -63,7 +63,14 @@ const CHANNELS = [
 // mistake here would look entirely plausible on screen, which is why the test pins it.
 const WRAPPED = new Set(['twd', 'twa', 'awa', 'cog', 'heading', 'wptBrg'])
 
-const wrap360 = (d) => ((d % 360) + 360) % 360
+// Of those, TWA and AWA are SIGNED: -180..+180 with port negative, because "40° off the
+// bow to port" is what the number means. The other four are absolute bearings, 0..360.
+// A circular mean always comes back 0..360, so these two MUST be folded back or a
+// port-side wind reads as 270° — nonsense on every screen that shows it.
+const SIGNED = new Set(['twa', 'awa'])
+const rewrap = (c, d) => (SIGNED.has(c) ? wrap180(d) : wrap360(d))
+
+const { wrap360, wrap180, circularMeanDeg } = require('./angles')
 // Stored values are rounded to 3 decimals. Rows now carry a mean plus two extremes per
 // channel, so full float noise ("6.430000000000001") would inflate every persisted line
 // for precision no instrument has and no chart can draw.
@@ -134,7 +141,7 @@ class RingHistoryProvider {
     // polls counts readings seen since the last emit. Zero means the telemetry source
     // gave us nothing at all, and we push no row — a gap is the honest record, where a
     // row of nulls would be a claim that we looked and the boat had no data.
-    this._acc = { polls: 0, sum: {}, cnt: {}, lo: {}, hi: {}, last: {}, lat: null, lon: null }
+    this._acc = { polls: 0, sum: {}, cnt: {}, lo: {}, hi: {}, last: {}, sinS: {}, cosS: {}, lat: null, lon: null }
   }
 
   // BoatState -> the flat channel map this ring records. Kept separate from the
@@ -169,7 +176,18 @@ class RingHistoryProvider {
       const v = raw[c]
       if (!Number.isFinite(v)) continue
       a.last[c] = v
-      if (WRAPPED.has(c)) continue // a bearing has no meaningful mean or extreme
+      if (WRAPPED.has(c)) {
+        // A bearing still has no meaningful min/max — but it does have an average: the
+        // unit-vector (circular) mean, which is a genuine average with no seam. Serving
+        // one sample per bucket instead was correct but jumpy, and on a long passage the
+        // emit rate coarsens to ~52 s, so that would be one reading per bucket where the
+        // cloud averages every sample.
+        const r = v * DEG
+        a.sinS[c] = (a.sinS[c] || 0) + Math.sin(r)
+        a.cosS[c] = (a.cosS[c] || 0) + Math.cos(r)
+        a.cnt[c] = (a.cnt[c] || 0) + 1
+        continue
+      }
       a.sum[c] = (a.sum[c] || 0) + v
       a.cnt[c] = (a.cnt[c] || 0) + 1
       a.lo[c] = Math.min(a.lo[c] == null ? v : a.lo[c], v)
@@ -188,7 +206,15 @@ class RingHistoryProvider {
     if (!a.polls) return
     const row = { t: Date.now(), lo: {}, hi: {}, n: {} }
     for (const c of CHANNELS) {
-      if (WRAPPED.has(c)) { row[c] = a.last[c] == null ? null : round3(a.last[c]); continue }
+      if (WRAPPED.has(c)) {
+        const n = a.cnt[c] || 0
+        // A near-zero resultant means the readings cancelled (exactly opposite bearings):
+        // there is no meaningful average, and atan2(0, 0) would answer 0° — due north,
+        // with total confidence. A gap is the honest record.
+        const mag = n ? Math.hypot(a.sinS[c], a.cosS[c]) : 0
+        row[c] = mag < 1e-9 ? null : round3(rewrap(c, wrap360(Math.atan2(a.sinS[c], a.cosS[c]) / DEG)))
+        continue
+      }
       const n = a.cnt[c] || 0
       if (!n) { row[c] = null; continue }
       row[c] = round3(a.sum[c] / n)
@@ -258,9 +284,9 @@ class RingHistoryProvider {
         if (v == null) continue
         const key = step ? Math.floor(r.t / step) * step : seq++
         let b = buckets.get(key)
-        if (!b) buckets.set(key, (b = { t: step ? key + step : r.t, sum: 0, n: 0, lo: Infinity, hi: -Infinity, last: null }))
+        if (!b) buckets.set(key, (b = { t: step ? key + step : r.t, sum: 0, n: 0, lo: Infinity, hi: -Infinity, last: null, dirs: [] }))
         b.last = v
-        if (wrapped) continue
+        if (wrapped) { b.dirs.push(v); continue }
         // Rows written before v0.29.0 carry no lo/hi/n. Reading them defensively means an
         // append-log from an older version still loads and simply yields a degenerate
         // band (the point value itself) rather than an empty chart or a crash.
@@ -273,8 +299,15 @@ class RingHistoryProvider {
         if (hi > b.hi) b.hi = hi
       }
       const out = [...buckets.values()].sort((a, b) => a.t - b.t)
+      // Wrapped channels re-bucket by circular mean too — unweighted, matching the
+      // cloud's provider: a row built from 15 polls counts the same as one built from 3.
+      // A small inaccuracy, kept deliberately, because the two providers answering the
+      // same question identically is worth more here than either being marginally righter
+      // alone. Buckets whose directions cancel drop out rather than reporting north.
       const pts = wrapped
-        ? out.map((b) => [b.t, b.last])
+        ? out.map((b) => [b.t, circularMeanDeg(b.dirs)])
+          .filter(([, d]) => d != null)
+          .map(([t, d]) => [t, round3(rewrap(c, d))])
         : out.filter((b) => b.n > 0).map((b) => [b.t, round3(b.sum / b.n)])
       if (!pts.length) continue
       series[c] = pts

package/lib/proxy/index.js

@@ -48,7 +48,20 @@ const isImmutableApi = (p) => IMMUTABLE_API_PREFIXES.some((x) => p.startsWith(x)
 // 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'])
+//
+// /sw.js is here for the same reason as the entry documents, and it is the sharpest case:
+// it is the mobile PWA's ONE un-hashed file, and its bytes ARE the update signal. The
+// browser installs a new service worker only when sw.js differs from the installed one,
+// and until it does, the worker keeps answering mobile.html and its assets from its own
+// cache — before the request ever reaches this mirror. So a stale sw.js freezes the whole
+// mobile shell, and a fresh mobile.html sitting in our store makes no difference at all.
+//
+// It was not, strictly, pinned FOREVER: the cache-manifest's `app` family invalidates it
+// whenever the app's sha changes (measured on this boat — the family was invalidated at
+// 03:21 on 2026-09-01). But making the shell's update depend on a best-effort 5-minute
+// poller is the dependency the entry-document rule above exists to remove, and if the
+// manifest is unreachable or its endpoint changes shape, "forever" becomes literally true.
+const LIVE_PATHS = new Set(['/health', '/sw.js'])
 const isEntryDocument = (p) => {
   const path = p.split('?')[0]
   return path === '/' || path.endsWith('/') || path.endsWith('.html') ||

package/lib/telemetry/index.js

@@ -32,6 +32,45 @@ const WS_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
 const SUBPROTOCOL = 'sailkick.telemetry.v1'
 const wrap360d = (d) => ((d % 360) + 360) % 360
 const wrap180 = (d) => { const w = wrap360d(d); return w > 180 ? w - 360 : w }
+// PER-FIELD FRESHNESS. The accumulated state merges every delta into one object, so
+// nothing in it ever expires: when ONE instrument dies while the others keep publishing,
+// its fields freeze at their last value while `updatedAt` stays fresh, and every consumer
+// treats dead data as live. Measured on this boat: the sounder lost the bottom in deep
+// water and stopped publishing at 05:20, and for the hour that followed the history ring
+// recorded 224.85 m every 15 s — a dead-flat plateau with a zero-width min/max band,
+// which reads as "rock steady" — while the cloud, which stores only real updates, showed
+// an honest gap for the same hour. Two stories about the same hour; the plateau is the
+// lie. The same freeze makes a wind-speed alarm unable to fire during a wind-instrument
+// outage, because it keeps seeing the last live reading.
+//
+// So each field carries the time it was last PATCHED, and the published view omits any
+// field older than the TTL. The internal state is never mutated — filtering happens on
+// read and on emit, so a returning instrument reappears on its first fresh delta.
+//
+// TTL: measured on this boat's bus, every path that feeds BoatState arrives at ~1 Hz with
+// a worst inter-sample gap of 1.1–2.1 s (magneticVariation reaches 2.8 s from its fast
+// sources). 15 s is ~7x the worst case. Critically, this subscription is FIXED-PERIOD
+// ({ path: '*', period: 1000 }), and the server republishes unchanged values — proven by
+// magneticVariation, gnss.satellites and propulsion.port.runTime arriving at 1 Hz with
+// 100% repeated values. So a healthy-but-constant instrument (an engine at rest
+// publishing rpm 0) keeps arriving and does NOT expire. A boat whose SignalK is
+// configured on-change, or with a slow NMEA0183 source, could differ — hence the knob.
+const FIELD_TTL_SEC = 15
+
+// Fields that are ONE physical reading and must expire together. A position is published
+// as a single navigation.position value; half a fix is not a fix, and a stale one should
+// disappear whole so the anchor watch stops watching a frozen position.
+const FIELD_GROUPS = [['lat', 'lon']]
+
+// headingDeg is COMPUTED at the merge site, so it never appears in a patch and has no
+// freshness of its own. Its inputs do: the compass path plus variation, or a published
+// true heading. Without this it would either never expire — the frozen-heading bug
+// surviving the fix — or expire always. (Note the `|| 0` fallback below, which is why a
+// boat with no heading source currently reads due north rather than nothing.)
+const COMPUTED_FRESHNESS = {
+  headingDeg: (fresh) => (fresh('hdgMagDeg') && fresh('magVarDeg')) || fresh('hdgTrueDeg')
+}
+
 const SEED = { sogKt: 0, cogDeg: 0, headingDeg: 0, awsKt: null, awaDeg: null }
 
 function encodeTextFrame (str) {
@@ -197,6 +236,30 @@ function createTelemetry (app, options = {}) {
     return compass
   }
 
+  // field -> ms when it was last patched. Never pruned: it is bounded by the number of
+  // BoatState fields, and an entry for a field that never returns is a few bytes.
+  const seenAt = {}
+  const ttlMs = Math.max(1, (options.fieldTtlSec || FIELD_TTL_SEC)) * 1000
+
+  // The ONE view every consumer sees — getState(), the update broadcast and the hello
+  // frame. They must not disagree: a field the ring records but the screen omits (or the
+  // reverse) is the same class of bug as the freeze itself.
+  function publicState (now = Date.now()) {
+    if (!state) return state
+    const fresh = (k) => seenAt[k] != null && (now - seenAt[k]) < ttlMs
+    const out = { updatedAt: state.updatedAt } // whole-feed staleness stays the app's job
+    for (const [k, v] of Object.entries(state)) {
+      if (k === 'updatedAt') continue
+      const rule = COMPUTED_FRESHNESS[k]
+      if (rule ? rule(fresh) : fresh(k)) out[k] = v
+    }
+    // Grouped fields go together or not at all.
+    for (const g of FIELD_GROUPS) {
+      if (g.some((k) => !(k in out))) for (const k of g) delete out[k]
+    }
+    return out
+  }
+
   function onDelta (delta) {
     if (!delta || !Array.isArray(delta.updates)) return
     const patch = {}
@@ -212,9 +275,11 @@ function createTelemetry (app, options = {}) {
       state = { ...SEED }
     }
     state = { ...state, ...patch, updatedAt: ts || new Date().toISOString() }
+    const now = Date.now()
+    for (const k of Object.keys(patch)) seenAt[k] = now
     const hd = resolveHeading(state)
     state.headingDeg = Number.isFinite(hd) ? hd : (state.headingDeg || state.cogDeg || 0)
-    broadcast({ type: 'telemetry/update', state })
+    broadcast({ type: 'telemetry/update', state: publicState(now) })
   }
 
   function start () {
@@ -260,16 +325,21 @@ function createTelemetry (app, options = {}) {
     socket.on('close', drop)
     socket.on('error', () => { drop(); try { socket.destroy() } catch {} })
     socket.on('data', (buf) => { if (buf && buf.length && (buf[0] & 0x0f) === 0x8) { drop(); try { socket.destroy() } catch {} } }) // client close frame
-    send(socket, { type: 'hello', source: 'signalk-local', state })
+    send(socket, { type: 'hello', source: 'signalk-local', state: publicState() })
   }
 
   // current BoatState (or null before the first fix) — used as the DB-less ring
   // history source, and by tests.
-  function getState () { return state }
+  // Filtered, like everything else. Consumers (the history ring, the alert engine, the
+  // polar %) then see an absent field rather than a frozen one: the ring records a gap,
+  // and the shared alert evaluator's own "cannot tell" semantics take over — which never
+  // clears a raised alarm.
+  function getState () { return publicState() }
   function _ingest (delta) { onDelta(delta) } // for tests
   const _state = getState
+  const _rawState = () => state // tests + status: the unfiltered accumulator
 
-  return { start, stop, status, handleUpgrade, getState, _ingest, _state }
+  return { start, stop, status, handleUpgrade, getState, _ingest, _state, _rawState, _seenAt: () => seenAt, _publicState: publicState }
 }
 
 module.exports = { createTelemetry, encodeTextFrame, SUBPROTOCOL }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sailkick-boat",
-  "version": "0.30.0",
+  "version": "0.32.0",
   "description": "Run the sailkick app on board with no internet: charts, weather, climatology, trends and AIS all served from the boat itself. With a sailkick account it also syncs your metrics to the cloud in real time. Alpha, invite-only — info@sailkick.io",
   "main": "index.js",
   "scripts": {