sailkick-boat 0.14.7 → 0.17.0

package/README.md

@@ -27,7 +27,7 @@ One Signal K plugin, independently-toggleable modules — so the boat stays
   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 the boat's local InfluxDB (or a DB-less telemetry ring) — full local history.
+    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.
 
@@ -139,37 +139,71 @@ config passes through untouched. (Hand-edit `proxy.openAccess: false` to keep th
 login gate — there is no toggle, since the gate cannot complete over the mirror anyway.)
 
 ## Local history (offline Trends + track)
-Two ways, chosen automatically:
-- **Read token set** → full history queried from a **local InfluxDB** (e.g. a bucket
-  written by `signalk-to-influxdb-v2`).
-- **No token, telemetry on** → a **DB-less ring** sampled from live telemetry (the
-  same BoatState feeding `/ws/telemetry`) — for boats with no local InfluxDB, e.g.
-  **SignalK on a Victron GX / Venus OS**. Same JSON contract, fully offline, no database.
-  (`historyAvailable` reports true either way, so the app shows the Trends panel.)
-  Same eight channels as the InfluxDB path, `stw` included.
-
-**Serving an archive.** Set `historyToken` and the three `history*` fields point at any
-InfluxDB holding `signalk-to-influxdb-v2`-schema data — a still-running local database,
-or a bucket you imported an old logbook into. That is the archive's real value: history
-from before this boat ever synced to the cloud. The token is the switch; blank means the
-built-in ring. The plugin logs which source it chose at startup:
-
-```
-[sailkick-boat] history -> archive http://127.0.0.1:8086 org=addiction bucket=bandg
-[sailkick-boat] history -> built-in ring (no archive token set)
-```
-
-Upgrading from before 0.14.7, when these lived in a hidden `proxy.history` block: your
-saved values still win over the newly pre-filled defaults, so an archive in a
-non-default org/bucket is not silently lost when the config UI writes `signalk` over it.
-The plugin says so in the log — copy the values into the visible fields when convenient.
-
-**Do you actually need a local InfluxDB?** For *live* trends, usually not. The app never requests finer
-than `every=5s` over a `window` of 24 h, and the ring's floor at that window is 2 s — so
-set `ringSampleSec: 5` and it matches anything the UI can draw, from live state, with no
-database to run. A local InfluxDB is worth it only for history predating cloud sync,
-more than 30 days offline, or channels outside BoatState (engine, batteries) that the
-Trends panel does not chart anyway.
+**One source: a live ring**, sampled from the same BoatState that feeds `/ws/telemetry`
+— no database, works on a Victron GX with nothing else installed. `historyAvailable` is
+forced on so the app shows the Trends panel, and the eight channels match what the cloud
+serves, `stw` included.
+
+There is deliberately **no way to point this at a local InfluxDB**. Until v0.15.0 a read
+token did exactly that, and it was a trap: the app only ever asks for a *relative* window
+clamped to 24 h, so aiming it at a bucket of older data matched nothing — Trends went
+blank **and** the working live ring was switched off. If you still have a token in your
+config it is now inert; the plugin logs `history -> live ring` regardless.
+
+A local InfluxDB is not a competitor here anyway. The app never requests finer than
+`every=5s` over a 24 h window, and the ring's floor at that window is 2 s — set
+`ringSampleSec: 5` and it matches anything the UI can draw, from live state. What an old
+database *is* good for is its contents ending up **in the cloud** — see below.
+
+## 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.
+
+## Copying older history to the cloud (one-time)
+If the boat recorded into its own InfluxDB before it started syncing — a
+`signalk-to-influxdb-v2` bucket, or an imported logbook — the **backfill** copies it up
+so the cloud holds your full history. Live sync can't do this: it only ever sees deltas
+arriving now, and the spool only replays what it captured itself while offline.
+
+Fill the **Copy older history to the cloud** section and save. It walks backwards in
+one-hour windows (newest first, so recent history lands first), resumes after a restart
+from a manifest, and stands aside whenever live telemetry has a backlog — the data-
+critical path is never starved by a bulk upload. Progress shows in the status line.
+
+It needs a **cloud read+write token**, not the write token from signup. Every hour it
+uploads is verified by counting the destination, and a write-only token cannot read. A
+`204` means InfluxDB accepted the bytes, not that every point landed — without the count
+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.
+
+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. Everything in the bucket is copied, including AIS contexts; hand-edit
+`backfill.selfOnly: true` to restrict it to your own vessel if cloud series cardinality
+becomes a problem.
 
 **True wind comes from your instruments.** If the boat publishes
 `environment.wind.speedTrue` / `directionTrue`, those are stored verbatim — a wind
@@ -190,14 +224,14 @@ water. (Before v0.14.6 the derivation used SOG, which in 3 kt of foul tide skewe
 
 The sailkick app is deployment-agnostic about history: *central Influx in the
 cloud, in-memory ring on a DB-less edge*. The boat is a third case — an edge that
-serves the app's history endpoints from its **own** data (local InfluxDB or the ring):
+serves the app's history endpoints from its **own** live data:
 ```
 GET /api/history/series?window=3600s&every=30s -> { series: { sog|heading|tws|… : [[tMs,val],…] } }
 GET /api/history/track?window=3600s            -> { track: [{ t, lat, lon }, …] }
 ```
 Same JSON the cloud returns, so the browser can't tell the difference — but it
-works **offline** with the boat's own data. Only when neither a local InfluxDB nor
-telemetry is available do these paths **fall through to the cloud mirror**, so an
+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.
 
 ## Setup: register on the web, then paste the token
@@ -237,21 +271,16 @@ in `index.js`.
 
 - **Sailkick account**: `slug` (boat name), `writeToken`
 - **Telemetry sync → cloud**: `enabled`
+- **Upload AIS targets**: `enabled` (default off), `source`
 - **Offline app & maps**: `enabled`, `proxyPort` (default 8080), `localSignalkUrl`
   (default `http://127.0.0.1:3000`), `dataDir`, `seedEnabled`, `prefetchRadiusNm`,
   `prefetchDetailZoom`
-- **History archive** (optional): `historyToken`, `historyInfluxUrl`
-  (default `http://127.0.0.1:8086`), `historyOrg` + `historyBucket` (default `signalk`,
-  matching `signalk-to-influxdb-v2`)
 
 `dataDir` is the one storage location — cached maps, the telemetry spool and the
 history ring log all live under it. **Put it on the SSD/USB disk, not the SD card.**
 Leave it blank and each part falls back to its historical spot under the plugin data
 dir.
 
-`historyToken` is optional and only matters if the boat already runs its own InfluxDB.
-Blank — the normal case — uses the built-in DB-less ring.
-
 Cache-manifest polling is always on (no toggle): tile freshness comes from the cloud
 announcing bakes, and without it a re-baked dataset would never refresh.
 

package/index.js

@@ -6,6 +6,8 @@ const { createSync } = require('./lib/sync')
 const { createProxy } = require('./lib/proxy')
 const { createTelemetry } = require('./lib/telemetry')
 const { createHistory } = require('./lib/history')
+const { createBackfill } = require('./lib/backfill')
+const { createAis } = require('./lib/ais')
 const { resolveAccountConfig } = require('./lib/account')
 
 // sailkick-boat: one Signal K plugin, two independently-toggleable modules —
@@ -43,15 +45,8 @@ const PROXY_TUNING = { requestTimeoutMs: 20000, localPaths: ['/signalk'], teleme
 const MANIFEST = { enabled: true, path: '/api/cache-manifest', pollIntervalSec: 300 }
 const SEED_TUNING = { coastlineMaxZoom: 8, seabedMaxZoom: 6, concurrency: 4 }
 const PREFETCH_TUNING = { concurrency: 4 }
-const HISTORY_TUNING = {
-  influxUrl: 'http://127.0.0.1:8086',
-  org: 'signalk',
-  bucket: 'signalk',
-  requestTimeoutMs: 15000,
-  ringPersist: true,
-  ringWindowSec: 86400,
-  ringSampleSec: 15
-}
+const HISTORY_TUNING = { ringPersist: true, ringWindowSec: 86400, ringSampleSec: 15 }
+const BACKFILL_SRC_DEFAULTS = { influxUrl: 'http://127.0.0.1:8086', org: 'signalk', bucket: 'signalk' }
 
 // A *cloud* endpoint on a loopback or private address means telemetry never leaves the
 // LAN. On the wire that is indistinguishable from a normal offline backlog — the spool
@@ -69,13 +64,12 @@ function isPrivateHostUrl (u) {
   } catch { return false }
 }
 
-// A pre-filled schema default must not silently shadow a legacy value that differs. The
-// Signal K config UI writes every default on save, so `historyOrg: "signalk"` appears on
-// a boat whose archive has always lived in org "addiction" under the old nested
-// proxy.history block — and the archive would go quiet with no explanation. Rule: an
-// explicitly-changed field wins; otherwise a legacy value that differs from the default
-// wins; otherwise the default.
-function pickHistoryField (flat, legacy, dflt) {
+// The Signal K config UI writes every schema default on save, so a freshly pre-filled
+// `backfillOrg: "signalk"` can appear on a boat whose archive has always lived in org
+// "addiction" under the pre-0.15 `proxy.history` block — and the backfill would read an
+// empty bucket. Rule: an explicitly-changed field wins; else a legacy value that differs
+// from the default wins; else the default.
+function pickField (flat, legacy, dflt) {
   const f = String(flat == null ? '' : flat).trim()
   const l = String(legacy == null ? '' : legacy).trim()
   if (f && f !== dflt) return { value: f, from: 'config' }
@@ -98,6 +92,8 @@ module.exports = function (app) {
   let proxy = null
   let telemetry = null
   let history = null
+  let backfill = null
+  let ais = null
   let statusTimer = null
   let accountStatus = null
   let syncWarning = null
@@ -130,6 +126,28 @@ module.exports = function (app) {
           enabled: { type: 'boolean', title: 'Enable telemetry sync', default: true }
         }
       },
+      ais: {
+        type: 'object',
+        title: 'Upload AIS targets',
+        description: 'Send the AIS this boat\'s own receiver hears to the cloud, so the web app can show other vessels, their heading and their trail. Only locally received AIS is forwarded — an internet feed such as signalk-aisstream is skipped, since the cloud can fetch that itself without spending your uplink. REQUIRES a cloud that filters history on self; until then leave this off or the owner\'s SOG and heading charts will pick up other ships.',
+        properties: {
+          enabled: { type: 'boolean', title: 'Upload AIS targets', default: false },
+          source: { type: 'string', title: 'Only this AIS source', description: 'Blank forwards every source except known internet feeds. The plugin logs the AIS sources it sees — copy the one for your own receiver here if you want to be explicit.' }
+        }
+      },
+      backfill: {
+        type: 'object',
+        title: 'Copy older history to the cloud (one-time)',
+        description: 'If this boat recorded data into its own InfluxDB before it started syncing — a signalk-to-influxdb-v2 bucket, or an imported logbook — this copies it up so the app can chart it. It runs in the background, resumes after a restart, verifies every hour it uploads, and stands aside whenever live telemetry is behind. Safe to re-run: identical points overwrite rather than duplicate.',
+        properties: {
+          enabled: { type: 'boolean', title: 'Run the backfill', default: false },
+          cloudToken: { type: 'string', title: 'Cloud read+write token', description: 'A token with READ and WRITE on your cloud bucket. Your normal write token cannot read, and reading is how each uploaded hour is verified. Needed only while the backfill runs — revoke it afterwards; live sync is unaffected.' },
+          sourceToken: { type: 'string', title: 'Local InfluxDB read token' },
+          sourceUrl: { type: 'string', title: '…local InfluxDB URL', default: 'http://127.0.0.1:8086' },
+          sourceOrg: { type: 'string', title: '…organization', default: 'signalk' },
+          sourceBucket: { type: 'string', title: '…bucket', default: 'signalk' }
+        }
+      },
       proxy: {
         type: 'object',
         title: 'Offline app & maps',
@@ -154,11 +172,7 @@ module.exports = function (app) {
             enum: [12, 13, 14, 15],
             enumNames: ['Overview (z12)', 'Coastal (z13)', 'Detailed (z14)', 'Harbor (z15)'],
             default: 13
-          },
-          historyToken: { type: 'string', title: 'History archive: read token', description: 'Leave blank for the built-in lightweight history, which is what most boats want and needs no database. Paste a read token to serve Trends and the track from a local InfluxDB instead — worth it for history recorded before this boat synced to the cloud, for more than 30 days offline, or for an imported archive. Setting a token switches the source; the three fields below say where to find it.' },
-          historyInfluxUrl: { type: 'string', title: '…InfluxDB URL', description: 'Where the archive lives. The default is an InfluxDB on this machine.', default: 'http://127.0.0.1:8086' },
-          historyOrg: { type: 'string', title: '…organization', description: 'Default matches signalk-to-influxdb-v2.', default: 'signalk' },
-          historyBucket: { type: 'string', title: '…bucket', description: 'Default matches signalk-to-influxdb-v2. An imported archive often uses its own name.', default: 'signalk' }
+          }
         }
       }
     }
@@ -237,21 +251,7 @@ module.exports = function (app) {
       const oldSeed = p.seed || {}
       const oldPrefetch = p.prefetch || {}
       const oldHistory = p.history || {}
-      // History source, resolved before the modules start so it can be reported. A token
-      // is the switch: present = query the archive, absent = the built-in ring.
-      const hUrl = pickHistoryField(p.historyInfluxUrl, oldHistory.influxUrl, HISTORY_TUNING.influxUrl)
-      const hOrg = pickHistoryField(p.historyOrg, oldHistory.org, HISTORY_TUNING.org)
-      const hBucket = pickHistoryField(p.historyBucket, oldHistory.bucket, HISTORY_TUNING.bucket)
-      const hToken = String(p.historyToken || oldHistory.token || '').trim()
-      const fromLegacy = [['URL', hUrl], ['org', hOrg], ['bucket', hBucket]].filter(([, v]) => v.from === 'legacy')
-      if (hToken) {
-        console.log(`[sailkick-boat] history -> archive ${hUrl.value} org=${hOrg.value} bucket=${hBucket.value}`)
-        if (fromLegacy.length) {
-          ;(app.error || console.error)(`[sailkick-boat] history archive ${fromLegacy.map(([n]) => n).join(' + ')} taken from the old proxy.history config, not the new field(s) — copy the value(s) up to keep them after the next save`)
-        }
-      } else {
-        console.log('[sailkick-boat] history -> built-in ring (no archive token set)')
-      }
+      console.log('[sailkick-boat] history -> live ring')
 
       if (upstream.ignored) {
         ;(app.error || console.error)(`[sailkick-boat] ignoring proxy.sailkickUrl "${upstream.ignored}" left over from an older config — mirroring ${upstream.url}. Set proxy.selfHosted:true to keep your own server.`)
@@ -284,10 +284,6 @@ module.exports = function (app) {
         history: {
           ...HISTORY_TUNING,
           enabled: oldHistory.enabled !== false,
-          influxUrl: hUrl.value,
-          org: hOrg.value,
-          bucket: hBucket.value,
-          token: hToken,
           ringPersist: oldHistory.ringPersist !== false,
           ringWindowSec: oldHistory.ringWindowSec || HISTORY_TUNING.ringWindowSec,
           ringSampleSec: oldHistory.ringSampleSec || HISTORY_TUNING.ringSampleSec,
@@ -328,6 +324,68 @@ module.exports = function (app) {
       }
     }
 
+    // --- AIS upload (isolated; yields to telemetry, its own spool) ---
+    const aisOpts = opts.ais || {}
+    if (aisOpts.enabled === true) {
+      if (!b.writeToken) {
+        (app.error || console.error)('[sailkick-boat] AIS upload needs a paired account for its destination bucket — skipped')
+      } else {
+        try {
+          ais = createAis(app, {
+            influxUrl: influx.url,
+            org: b.org || SYNC_TUNING.org,
+            bucket: b.bucket,
+            token: b.writeToken,
+            source: String(aisOpts.source || '').trim() || null,
+            spoolDir: store ? path.join(store, 'ais-spool') : undefined,
+            pending: sync ? sync.pending : null
+          })
+          ais.start()
+          console.log(`[sailkick-boat] ais -> ${influx.url} bucket=${b.bucket}${aisOpts.source ? ' source=' + aisOpts.source : ''}`)
+        } catch (e) {
+          (app.error || console.error)('[sailkick-boat] AIS start failed: ' + e.message)
+          ais = null
+        }
+      }
+    }
+
+    // --- backfill (best-effort, isolated: it must never disturb sync or the proxy) ---
+    const bf = opts.backfill || {}
+    const oldHist = (opts.proxy || {}).history || {}
+    if (bf.enabled === true) {
+      // Pre-0.15 installs kept the archive's coordinates in proxy.history.* — reuse them
+      // so nobody retypes an org/bucket the plugin already knows.
+      const src = {
+        url: pickField(bf.sourceUrl, oldHist.influxUrl, BACKFILL_SRC_DEFAULTS.influxUrl).value,
+        org: pickField(bf.sourceOrg, oldHist.org, BACKFILL_SRC_DEFAULTS.org).value,
+        bucket: pickField(bf.sourceBucket, oldHist.bucket, BACKFILL_SRC_DEFAULTS.bucket).value,
+        token: String(bf.sourceToken || oldHist.token || '').trim()
+      }
+      const dst = { url: influx.url, org: b.org || SYNC_TUNING.org, bucket: b.bucket, token: String(bf.cloudToken || '').trim() }
+      if (!b.writeToken) {
+        (app.error || console.error)('[sailkick-boat] backfill needs a paired account for its destination bucket — skipped')
+      } else if (!dst.token) {
+        (app.error || console.error)('[sailkick-boat] backfill needs a cloud READ+WRITE token: every uploaded hour is verified by counting the destination, which the write-only sync token cannot do — skipped')
+      } else if (!src.token) {
+        (app.error || console.error)('[sailkick-boat] backfill needs a read token for the local InfluxDB — skipped')
+      } else {
+        try {
+          backfill = createBackfill(app, {
+            src,
+            dst,
+            selfOnly: bf.selfOnly === true,
+            startBound: bf.startBound,
+            stateFile: path.join((app.getDataDirPath && app.getDataDirPath()) || '.', 'backfill.json'),
+            pending: sync ? sync.pending : null
+          })
+          backfill.start()
+        } catch (e) {
+          (app.error || console.error)('[sailkick-boat] backfill start failed: ' + e.message)
+          backfill = null
+        }
+      }
+    }
+
     statusTimer = setInterval(updateStatus, 5000)
     updateStatus()
   }
@@ -341,6 +399,8 @@ module.exports = function (app) {
     if (proxy) parts.push(proxy.status())
     if (telemetry) parts.push(telemetry.status())
     if (history) parts.push(history.status())
+    if (ais) parts.push(ais.status())
+    if (backfill) parts.push(backfill.status())
     try { app.setPluginStatus(parts.join('   |   ') || 'idle (both features off)') } catch {}
   }
 
@@ -350,10 +410,14 @@ module.exports = function (app) {
     try { if (sync) sync.stop() } catch {}
     try { if (telemetry) telemetry.stop() } catch {}
     try { if (history) history.stop() } catch {}
+    try { if (ais) ais.stop() } catch {}
+    try { if (backfill) backfill.stop() } catch {}
     try { if (proxy) proxy.stop() } catch {}
     sync = null
     telemetry = null
     history = null
+    backfill = null
+    ais = null
     proxy = null
     accountStatus = null
     syncWarning = null

package/lib/ais/index.js

@@ -0,0 +1,262 @@
+'use strict'
+
+// AIS upload — forward the targets this boat's own receiver hears, so the cloud app can
+// draw other vessels, their heading and their trail.
+//
+// The cloud already renders AIS (public/viewer/ais.js → /api/ais), but its source polls a
+// SignalK server over the LAN and keeps everything in memory. That only works while the
+// cloud can reach the boat inbound, which stops being true on a mobile link. So the boat
+// pushes instead.
+//
+// Only LOCALLY RECEIVED AIS is worth uploading. A boat running an internet feed like
+// signalk-aisstream would otherwise spend uplink bandwidth sending data the cloud could
+// fetch directly from the same API over a fat pipe. The value is what your own VHF hears
+// offshore, where commercial feeds are blind — which is also why there is no radius or
+// rate limit here: VHF line-of-sight is the honest limiter, and offshore it tends to zero.
+//
+// Two invariants this module must not break:
+//   - Telemetry always wins the link. Separate spool, separate uploader, and it stands
+//     down whenever the telemetry spool has a backlog.
+//   - Every row is tagged self=false. The cloud's history queries filter on self=="true"
+//     to keep other vessels out of the boat's own Trends and track; if that tag were
+//     wrong, AIS would land in the owner's SOG and heading charts.
+
+const fs = require('fs')
+const path = require('path')
+const { Spool } = require('../sync/spool')
+const { writeLines } = require('../sync/influxWrite')
+const { deltaToLines } = require('../sync/lineprotocol')
+
+// What the cloud's /api/ais envelope needs. Subscribing to these rather than '*' keeps
+// delta volume down without imposing a rate limit.
+const POSITION_PATHS = [
+  'navigation.position',
+  'navigation.speedOverGround',
+  'navigation.courseOverGroundTrue',
+  'navigation.headingTrue',
+  'navigation.headingMagnetic',
+  'navigation.magneticVariation',
+  'navigation.rateOfTurn'
+]
+// Static/identity data: repeats every ~6 min per vessel and essentially never changes.
+const STATIC_PATHS = ['design.length', 'design.beam', 'design.aisShipType']
+const ALL_PATHS = [...POSITION_PATHS, ...STATIC_PATHS]
+
+// Sources that are internet feeds rather than a receiver on this boat. Uploading these
+// is pure round-tripping. Matched case-insensitively as a substring of $source.
+const INTERNET_FEEDS = ['aisstream', 'aishub', 'marinetraffic', 'vesselfinder']
+
+const DEFAULTS = {
+  staticIntervalMs: 3600000, // re-send a vessel's identity at most hourly
+  flushIntervalMs: 5000,
+  batchSize: 2000,
+  maxBufferBytes: 50 * 1024 * 1024, // its own, smaller cap — see below
+  idlePollMs: 5000,
+  retryMinMs: 2000,
+  retryMaxMs: 120000,
+  requestTimeoutMs: 30000
+}
+
+const isInternetFeed = (src) => {
+  const s = String(src || '').toLowerCase()
+  return INTERNET_FEEDS.some((f) => s.includes(f))
+}
+
+function createAis (app, options) {
+  const log = (m) => (app.debug ? app.debug('[ais] ' + m) : console.log('[sailkick-boat:ais]', m))
+  const warn = (m) => (app.error ? app.error('[sailkick-boat:ais] ' + m) : console.error('[sailkick-boat:ais]', m))
+
+  const cfg = { ...DEFAULTS, ...options }
+  let state = null
+
+  function start () {
+    if (!cfg.influxUrl || !cfg.bucket || !cfg.token) {
+      warn('not started — the boat is not paired, so there is no destination bucket')
+      state = { statusLine: 'ais: not configured', stopped: true }
+      return
+    }
+    const dataDir = (app.getDataDirPath && app.getDataDirPath()) || '.'
+    // A SEPARATE spool. Sharing the telemetry one would be dangerous: it drops the
+    // OLDEST files on overflow, so an AIS flood in a busy anchorage could evict
+    // telemetry that had not been sent yet.
+    const spoolDir = cfg.spoolDir || path.join(dataDir, 'ais-spool')
+    const spool = new Spool({ dir: spoolDir, maxBytes: cfg.maxBufferBytes, logger: log })
+    const selfContext = app.selfContext || ('vessels.' + (app.selfId || 'self'))
+
+    state = {
+      spool,
+      selfContext,
+      batch: [],
+      lastStatic: new Map(), // context -> ms, so identity is re-sent at most hourly
+      sourcesSeen: new Map(), // $source -> count, for the discovery log
+      targets: new Set(),
+      forwarded: 0,
+      dropped: 0,
+      lastOkAt: null,
+      backoff: cfg.retryMinMs,
+      pumping: false,
+      stopped: false,
+      unsubscribes: [],
+      statusLine: 'ais: starting'
+    }
+
+    spool.init().then(() => {
+      // stop() can land before init resolves (disable during startup, or a fast
+      // restart). Without this the timers are installed on an already-stopped module
+      // and never cleared — a leaked interval that also keeps the host process alive.
+      if (!state || state.stopped) return
+      state.flushTimer = setInterval(flush, cfg.flushIntervalMs)
+      state.reportTimer = setInterval(reportSources, 300000)
+      // Unref every timer: this module must never be the reason the Signal K server
+      // cannot exit.
+      if (state.flushTimer.unref) state.flushTimer.unref()
+      if (state.reportTimer.unref) state.reportTimer.unref()
+      subscribe()
+      pump()
+      log(`started; ${cfg.source ? 'source "' + cfg.source + '" only' : 'all sources except known internet feeds'}; buffer ${spoolDir}`)
+    }).catch((e) => warn('init failed: ' + e.message))
+  }
+
+  // Which $source values are actually producing AIS, so the config field can be filled
+  // in from the log instead of guessed.
+  function reportSources () {
+    if (!state || !state.sourcesSeen.size) return
+    const list = [...state.sourcesSeen.entries()].sort((a, b) => b[1] - a[1])
+      .map(([s, n]) => `${s} (${n}${isInternetFeed(s) ? ', internet feed — not forwarded' : ''})`)
+    log('AIS sources seen: ' + list.join('; '))
+  }
+
+  function accept (context, source) {
+    if (!context || context === state.selfContext) return false // never our own vessel
+    if (cfg.source) return String(source) === String(cfg.source)
+    return !isInternetFeed(source)
+  }
+
+  function handleDelta (delta) {
+    if (!state || state.stopped || !delta || !Array.isArray(delta.updates)) return
+    const context = delta.context
+    if (!context || context === state.selfContext) return
+
+    for (const update of delta.updates) {
+      if (!update || !Array.isArray(update.values)) continue
+      const source = update.$source || (update.source && (update.source.label || update.source.type)) || 'unknown'
+      state.sourcesSeen.set(source, (state.sourcesSeen.get(source) || 0) + 1)
+      if (!accept(context, source)) { state.dropped++; continue }
+
+      // Split identity from position: identity repeats constantly and never changes.
+      const now = Date.now()
+      const staticDue = (now - (state.lastStatic.get(context) || 0)) >= cfg.staticIntervalMs
+      const values = update.values.filter((pv) => {
+        if (!pv || !pv.path) return false
+        if (STATIC_PATHS.includes(pv.path)) return staticDue
+        return POSITION_PATHS.includes(pv.path)
+      })
+      if (!values.length) continue
+      if (staticDue && values.some((pv) => STATIC_PATHS.includes(pv.path))) state.lastStatic.set(context, now)
+
+      // self:false is the tag the cloud filters on to keep AIS out of the owner's charts.
+      const lines = deltaToLines({ context, updates: [{ ...update, values }] }, { self: false })
+      if (lines.length) {
+        state.batch.push(...lines)
+        state.targets.add(context)
+        state.forwarded += lines.length
+      }
+      if (state.batch.length >= cfg.batchSize) flush()
+    }
+  }
+
+  function subscribe () {
+    const sub = { context: '*', subscribe: ALL_PATHS.map((p) => ({ path: p, period: cfg.periodMs || 10000 })) }
+    if (app.subscriptionmanager && app.subscriptionmanager.subscribe) {
+      app.subscriptionmanager.subscribe(sub, state.unsubscribes, (err) => warn('subscription error: ' + err), handleDelta)
+    } else if (app.signalk && app.signalk.on) {
+      const h = (d) => handleDelta(d)
+      app.signalk.on('delta', h)
+      state.unsubscribes.push(() => app.signalk.removeListener('delta', h))
+    } else {
+      warn('no subscription mechanism available — nothing will be forwarded')
+    }
+  }
+
+  function flush () {
+    if (!state || state.stopped || !state.batch.length) return
+    const lines = state.batch
+    state.batch = []
+    state.spool.append(lines).then(() => pump()).catch((e) => {
+      warn('spool append failed: ' + e.message)
+      state.batch.unshift(...lines)
+    })
+  }
+
+  async function pump () {
+    if (!state || state.stopped || state.pumping) return
+    // Telemetry always wins the link: stand down entirely while its spool is behind.
+    if (cfg.pending) {
+      let depth = 0
+      try { depth = (await cfg.pending()).count || 0 } catch {}
+      if (depth) { refreshStatus(`waiting — telemetry backlog (${depth})`); scheduleIdle(); return }
+    }
+    state.pumping = true
+    try {
+      for (const file of await state.spool.pending()) {
+        if (state.stopped) break
+        let body
+        try { body = await fs.promises.readFile(file, 'utf8') } catch { continue }
+        if (!body.trim()) { await state.spool.remove(file); continue }
+        const res = await writeLines({ influxUrl: cfg.influxUrl, org: cfg.org, bucket: cfg.bucket, token: cfg.token, timeoutMs: cfg.requestTimeoutMs }, body)
+        if (res.ok) {
+          await state.spool.remove(file); state.lastOkAt = new Date(); state.backoff = cfg.retryMinMs
+        } else if (res.retryable) {
+          state.pumping = false; scheduleRetry(res); return
+        } else {
+          warn(`batch rejected (HTTP ${res.status}) — quarantined`)
+          await state.spool.quarantine(file)
+        }
+      }
+    } catch (e) {
+      warn('pump error: ' + e.message); state.pumping = false; scheduleRetry(); return
+    }
+    state.pumping = false
+    scheduleIdle()
+    refreshStatus()
+  }
+
+  function scheduleRetry (res) {
+    if (!state || state.stopped) return
+    clearTimeout(state.pumpTimer)
+    const delay = state.backoff
+    state.backoff = Math.min(state.backoff * 2, cfg.retryMaxMs)
+    state.pumpTimer = setTimeout(pump, delay)
+    if (state.pumpTimer.unref) state.pumpTimer.unref()
+    refreshStatus(`${res && res.status ? 'HTTP ' + res.status : 'offline'} — retry ${Math.round(delay / 1000)}s`)
+  }
+  function scheduleIdle () {
+    if (!state || state.stopped) return
+    clearTimeout(state.pumpTimer)
+    state.pumpTimer = setTimeout(pump, cfg.idlePollMs)
+    if (state.pumpTimer.unref) state.pumpTimer.unref()
+  }
+  function refreshStatus (suffix) {
+    if (!state) return
+    state.statusLine = `ais: ${state.targets.size} target(s), ${state.forwarded} point(s)${state.dropped ? `, ${state.dropped} skipped` : ''}${suffix ? '; ' + suffix : ''}`
+  }
+
+  function stop () {
+    if (!state) return
+    state.stopped = true
+    clearInterval(state.flushTimer)
+    clearInterval(state.reportTimer)
+    clearTimeout(state.pumpTimer)
+    for (const u of (state.unsubscribes || [])) { try { u() } catch {} }
+    if (state.batch && state.batch.length && state.spool) {
+      try { fs.writeFileSync(path.join(state.spool.dir, `${Date.now()}-final.lp`), state.batch.join('\n') + '\n') } catch {}
+      state.batch = []
+    }
+  }
+
+  function status () { return state ? state.statusLine : 'ais: off' }
+
+  return { start, stop, status, _handleDelta: handleDelta, _state: () => state, _flush: flush }
+}
+
+module.exports = { createAis, isInternetFeed, POSITION_PATHS, STATIC_PATHS }

package/lib/backfill/index.js

@@ -0,0 +1,257 @@
+'use strict'
+
+// Backfill: copy an older local InfluxDB into the boat's cloud bucket.
+//
+// The point is history from BEFORE this boat ever synced. Live sync only ever sees
+// deltas arriving now, and the spool only replays what it captured itself while offline,
+// so nothing else in the plugin can reach back.
+//
+// The control flow is lifted from sailkick-sync/tools/import-bandg.sh, which has already
+// done this job for real: newest-first hour windows, count-before-fetch, a manifest of
+// completed windows, verify each window against the destination, and abort a run after
+// consecutive errors so a boat that has gone offline never marks a window falsely done.
+// The difference is direction — that script PULLS from the boat and must reach its
+// InfluxDB inbound, which a boat on a mobile link cannot offer, so this PUSHES.
+//
+// Safety rests on two things. Writes are idempotent on (measurement, tagset, ns
+// timestamp), so re-running is always harmless. And every window is verified by counting
+// the destination, which is why this needs a read+write cloud token rather than the
+// write-only one live sync uses: a 204 means InfluxDB accepted the bytes, not that every
+// point landed. That token is only needed during the migration and can be revoked after,
+// leaving live sync on its least-privilege token.
+
+const fs = require('fs')
+const path = require('path')
+const { writeLines } = require('../sync/influxWrite')
+const { csvToLineProtocol } = require('./lineproto')
+
+const HOUR_MS = 3600000
+const DEFAULTS = {
+  windowMs: HOUR_MS,
+  batchSize: 10000,
+  idleMs: 2000, // breathing room between windows so a slow link isn't monopolised
+  backlogWaitMs: 15000, // how long to stand down when live sync has a backlog
+  maxErrorStreak: 5,
+  queryTimeoutMs: 120000
+}
+
+const iso = (ms) => new Date(ms).toISOString()
+const hourFloor = (ms) => Math.floor(ms / HOUR_MS) * HOUR_MS
+const sleep = (ms) => new Promise((r) => { const t = setTimeout(r, ms); if (t.unref) t.unref() })
+
+function createBackfill (app, options) {
+  const log = (m) => (app.debug ? app.debug('[backfill] ' + m) : console.log('[sailkick-boat:backfill]', m))
+  const warn = (m) => (app.error ? app.error('[sailkick-boat:backfill] ' + m) : console.error('[sailkick-boat:backfill]', m))
+
+  const cfg = {
+    ...DEFAULTS,
+    ...options,
+    src: { ...(options.src || {}) },
+    dst: { ...(options.dst || {}) }
+  }
+  let state = null
+  let running = false
+  let stopped = false
+  let statusLine = 'backfill: off'
+  let runPromise = null
+
+  // --- persisted manifest -------------------------------------------------------
+  function load () {
+    try {
+      const j = JSON.parse(fs.readFileSync(cfg.stateFile, 'utf8'))
+      if (j && typeof j === 'object') return { done: j.done || {}, earliest: j.earliest || null, points: j.points || 0, complete: !!j.complete }
+    } catch {}
+    return { done: {}, earliest: null, points: 0, complete: false }
+  }
+  function save () {
+    try {
+      fs.mkdirSync(path.dirname(cfg.stateFile), { recursive: true })
+      const tmp = `${cfg.stateFile}.tmp-${process.pid}`
+      fs.writeFileSync(tmp, JSON.stringify(state), { mode: 0o600 })
+      fs.renameSync(tmp, cfg.stateFile)
+    } catch (e) { warn('could not persist progress: ' + e.message) }
+  }
+
+  // --- InfluxDB reads -----------------------------------------------------------
+  async function flux (conn, body) {
+    const url = `${conn.url.replace(/\/+$/, '')}/api/v2/query?org=${encodeURIComponent(conn.org)}`
+    let resp
+    try {
+      resp = await fetch(url, {
+        method: 'POST',
+        headers: { Authorization: `Token ${conn.token}`, 'Content-Type': 'application/vnd.flux', Accept: 'application/csv' },
+        body,
+        signal: AbortSignal.timeout(cfg.queryTimeoutMs)
+      })
+    } catch (e) { return { ok: false, message: e.message } }
+    if (!resp.ok) {
+      const t = await resp.text().catch(() => '')
+      return { ok: false, status: resp.status, message: `HTTP ${resp.status}: ${t.slice(0, 160)}` }
+    }
+    return { ok: true, text: await resp.text() }
+  }
+
+  // Total points in a window. Returns a number, or null on ANY transport/HTTP failure —
+  // never 0, so an unreachable database can't be mistaken for "no data here" and mark a
+  // window falsely done. (The source script is emphatic about this distinction.)
+  async function count (conn, bucket, startMs, stopMs) {
+    const r = await flux(conn, `from(bucket:"${bucket}")|>range(start:${iso(startMs)},stop:${iso(stopMs)})|>count()|>group()|>sum()|>keep(columns:["_value"])`)
+    if (!r.ok) return null
+    for (const line of r.text.split('\n')) {
+      if (!line || line.startsWith('#')) continue
+      const cells = line.trim().split(',')
+      const last = cells[cells.length - 1]
+      if (/^\d+$/.test(last)) return Number(last)
+    }
+    return 0
+  }
+
+  async function earliestPoint () {
+    // `first()` reduces each series before anything is merged, then _time is isolated
+    // BEFORE group(). Both matter on a real bucket: grouping the raw stream fails with
+    // "schema collision: cannot group boolean and integer types together" the moment the
+    // database holds more than one field type, which any real boat's does.
+    const r = await flux(cfg.src, `from(bucket:"${cfg.src.bucket}")|>range(start:0)|>first()|>keep(columns:["_time"])|>group()|>min(column:"_time")`)
+    if (!r.ok) return null
+    for (const line of r.text.split('\n')) {
+      if (!line || line.startsWith('#') || line.includes('_time')) continue
+      for (const cell of line.split(',')) {
+        // Must look like RFC3339. Date.parse is far too permissive for scanning cells:
+        // the CSV's `table` column is "0", and Date.parse('0') happily returns the year
+        // 2000 — which would set the floor 26 years too early and walk a quarter of a
+        // million empty windows.
+        if (!/^\d{4}-\d{2}-\d{2}T/.test(cell.trim())) continue
+        const ms = Date.parse(cell.trim())
+        if (!Number.isNaN(ms)) return ms
+      }
+    }
+    return null
+  }
+
+  // --- one window ---------------------------------------------------------------
+  // Returns 'done' | 'empty' | 'retry' | 'stopped'.
+  async function doWindow (startMs, stopMs) {
+    const srcCount = await count(cfg.src, cfg.src.bucket, startMs, stopMs)
+    if (srcCount == null) return 'retry'
+    if (srcCount === 0) return 'empty'
+
+    const filter = cfg.selfOnly ? '|>filter(fn:(r)=>r.self=="true")' : ''
+    const r = await flux(cfg.src, `from(bucket:"${cfg.src.bucket}")|>range(start:${iso(startMs)},stop:${iso(stopMs)})${filter}|>drop(columns:["_start","_stop"])`)
+    if (!r.ok) { warn(`read ${iso(startMs)} failed — ${r.message}`); return 'retry' }
+
+    const { lines, skipped } = csvToLineProtocol(r.text, { selfOnly: cfg.selfOnly })
+    if (skipped) log(`${iso(startMs)}: skipped ${skipped} unconvertible row(s)`)
+    if (!lines.length) return 'empty'
+
+    for (let i = 0; i < lines.length; i += cfg.batchSize) {
+      if (stopped) return 'stopped'
+      const body = lines.slice(i, i + cfg.batchSize).join('\n') + '\n'
+      const res = await writeLines({ influxUrl: cfg.dst.url, org: cfg.dst.org, bucket: cfg.dst.bucket, token: cfg.dst.token, timeoutMs: cfg.queryTimeoutMs }, body)
+      if (!res.ok) {
+        // 4xx is fatal: bad credentials or malformed data, and retrying cannot fix it.
+        if (!res.retryable) { warn(`write REJECTED (HTTP ${res.status}) — ${res.body ? String(res.body).slice(0, 160) : 'no detail'}`); return 'fatal' }
+        warn(`write ${iso(startMs)} failed — ${res.status ? 'HTTP ' + res.status : 'unreachable'}; will retry`)
+        return 'retry'
+      }
+    }
+
+    // Verify: a 204 says the bytes were accepted, not that every point landed. This is
+    // the check the write-only sync token could never perform.
+    const dstCount = await count(cfg.dst, cfg.dst.bucket, startMs, stopMs)
+    if (dstCount == null) { warn(`could not verify ${iso(startMs)} — leaving it for the next run`); return 'retry' }
+    if (dstCount < lines.length) {
+      warn(`${iso(startMs)} MISMATCH: wrote ${lines.length}, destination has ${dstCount} — not marking done`)
+      return 'retry'
+    }
+    if (state) state.points += lines.length
+    return 'done'
+  }
+
+  // --- the walk -----------------------------------------------------------------
+  async function run () {
+    running = true
+    try {
+      if (state.earliest == null) {
+        const e = await earliestPoint()
+        if (e == null) { warn('could not read the oldest point from the source — is it reachable?'); statusLine = 'backfill: source unreachable'; return }
+        state.earliest = e
+        log(`oldest point in ${cfg.src.bucket}: ${iso(e)}`)
+        save()
+      }
+      // Floor to the START of the hour that CONTAINS the oldest point. Comparing the
+      // cursor against the raw timestamp drops that window entirely — the loop stops as
+      // soon as the next cursor falls below it, so an archive whose first point is at
+      // 21:20 never gets its 21:00 window copied. That is silent data loss at the very
+      // edge the backfill exists to reach.
+      const rawFloor = cfg.startBound ? Math.max(state.earliest, Date.parse(cfg.startBound)) : state.earliest
+      const floor = hourFloor(rawFloor)
+
+      let cursor = hourFloor(Date.now()) // newest-first: recent history lands first
+      let errStreak = 0
+      let didWork = 0
+
+      while (!stopped && cursor >= floor) {
+        const startMs = cursor
+        const stopMs = cursor + cfg.windowMs
+        cursor -= cfg.windowMs
+        const key = iso(startMs)
+        if (state.done[key]) continue
+
+        // Live telemetry is data-critical; this is not. Stand down while it is behind.
+        while (!stopped && cfg.pending) {
+          let depth = 0
+          try { depth = (await cfg.pending()).count || 0 } catch {}
+          if (!depth) break
+          statusLine = `backfill: paused — live sync backlog (${depth} file(s))`
+          await sleep(cfg.backlogWaitMs)
+        }
+        if (stopped) break
+
+        const r = await doWindow(startMs, stopMs)
+        if (r === 'stopped') break
+        if (r === 'fatal') { statusLine = 'backfill: stopped — write rejected, see the log'; return }
+        if (r === 'retry') {
+          if (++errStreak >= cfg.maxErrorStreak) { warn(`${errStreak} consecutive failures — stopping this run, it resumes on restart`); statusLine = 'backfill: paused after repeated errors'; return }
+          continue
+        }
+        errStreak = 0
+        state.done[key] = r === 'empty' ? 'empty' : 'ok'
+        didWork++
+        save()
+        statusLine = `backfill: ${iso(startMs).slice(0, 10)} → now, ${Object.keys(state.done).length} window(s), ${state.points} point(s)`
+        await sleep(cfg.idleMs)
+      }
+
+      if (!stopped && cursor < floor) {
+        state.complete = true
+        save()
+        statusLine = `backfill: complete — ${state.points} point(s) from ${iso(floor).slice(0, 10)}`
+        log(`complete: ${Object.keys(state.done).length} windows, ${state.points} points`)
+      } else if (didWork === 0 && !stopped) {
+        statusLine = 'backfill: nothing to do'
+      }
+    } finally {
+      running = false
+    }
+  }
+
+  function start () {
+    if (running) return runPromise
+    stopped = false
+    state = load()
+    if (state.complete) { statusLine = `backfill: complete — ${state.points} point(s)`; return null }
+    if (!cfg.src.token || !cfg.src.bucket || !cfg.src.url) { statusLine = 'backfill: not configured (source)'; return null }
+    if (!cfg.dst.token || !cfg.dst.bucket) { statusLine = 'backfill: not configured (cloud token)'; return null }
+    log(`${cfg.src.url} ${cfg.src.org}/${cfg.src.bucket} -> ${cfg.dst.url} ${cfg.dst.org}/${cfg.dst.bucket}${cfg.selfOnly ? ' [self only]' : ''}`)
+    statusLine = 'backfill: starting'
+    runPromise = run().catch((e) => { warn('run failed: ' + e.message); statusLine = 'backfill: error — ' + e.message })
+    return runPromise
+  }
+
+  function stop () { stopped = true }
+  function status () { return statusLine }
+
+  return { start, stop, status, _state: () => state, _doWindow: doWindow, _wait: () => runPromise }
+}
+
+module.exports = { createBackfill }

package/lib/backfill/lineproto.js

@@ -0,0 +1,114 @@
+'use strict'
+
+// InfluxDB annotated-CSV → line protocol, with types preserved.
+//
+// Ported from sailkick-sync/tools/parse-bandg.js, which has already moved this boat's
+// `bandg` bucket into the dev InfluxDB — so the shape is proven on exactly this data
+// rather than invented here.
+//
+// The whole point is the `#datatype` header. lib/history's old parser skipped every `#`
+// line, which is fine for reading a couple of float columns to draw a chart and wrong
+// for copying a database: without it every integer, boolean and string is rewritten as a
+// float, and the copy silently differs from the original. Types come from the annotation
+// when present, and are inferred only as a fallback.
+//
+// Tags are carried through verbatim. Timestamps are converted to nanoseconds, which is
+// what makes a re-run idempotent: same (measurement, tagset, ns) overwrites rather than
+// duplicating, so an interrupted backfill can always simply be run again.
+
+// Split one CSV line, honouring quoted fields and "" escapes.
+function parseCsvLine (line) {
+  const out = []
+  let cur = ''
+  let q = false
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i]
+    if (q) {
+      if (c === '"') { if (line[i + 1] === '"') { cur += '"'; i++ } else q = false } else cur += c
+    } else {
+      if (c === '"') q = true
+      else if (c === ',') { out.push(cur); cur = '' } else cur += c
+    }
+  }
+  out.push(cur)
+  return out
+}
+
+const escM = (s) => String(s).replace(/([,\s])/g, '\\$1')
+const escT = (s) => String(s).replace(/([,=\s])/g, '\\$1')
+const escS = (s) => '"' + String(s).replace(/(["\\])/g, '\\$1') + '"'
+
+function toNs (t) {
+  const ms = Date.parse(t)
+  return Number.isNaN(ms) ? null : (BigInt(ms) * 1000000n).toString()
+}
+
+const NUM = /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/
+
+// Columns that are structural, not tags.
+const NOT_A_TAG = new Set(['', 'result', 'table', '_start', '_stop', '_time', '_value', '_field', '_measurement'])
+
+// Render one record. `valueType` is the #datatype entry for the _value column, e.g.
+// 'double' | 'long' | 'unsignedLong' | 'boolean' | 'string'.
+function recordToLine (rec, valueType, { selfOnly = false } = {}) {
+  const m = rec._measurement
+  if (!m) return null
+  const v = rec._value
+  if (v === '' || v == null) return null
+  if (selfOnly && rec.self !== 'true') return null
+
+  let fv
+  if (valueType === 'double') fv = v
+  else if (valueType === 'long') fv = v + 'i'
+  else if (valueType === 'unsignedLong') fv = v + 'u'
+  else if (valueType === 'boolean') fv = v
+  else if (valueType === 'string') fv = escS(v)
+  else if (v === 'true' || v === 'false') fv = v // no annotation → infer
+  else if (NUM.test(v)) fv = v
+  else fv = escS(v)
+
+  const tags = []
+  for (const k of Object.keys(rec)) {
+    if (NOT_A_TAG.has(k)) continue
+    const val = rec[k]
+    if (val !== '' && val != null) tags.push(`${escT(k)}=${escT(val)}`)
+  }
+  tags.sort() // stable series key regardless of column order
+
+  const ns = toNs(rec._time)
+  if (ns == null) return null
+  const field = rec._field || 'value'
+  return `${escM(m)}${tags.length ? ',' + tags.join(',') : ''} ${escT(field)}=${fv} ${ns}`
+}
+
+// Convert a whole annotated-CSV document. Returns { lines, skipped }.
+// A CSV response can contain several tables, each re-declaring #datatype and a header —
+// a blank line resets both, exactly as the source tool does.
+function csvToLineProtocol (text, opts = {}) {
+  const lines = []
+  let skipped = 0
+  let cols = null
+  let dt = null
+  let valueIdx = -1
+
+  for (const raw of String(text).split('\n')) {
+    const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw
+    if (line === '') { cols = null; dt = null; valueIdx = -1; continue }
+    if (line.startsWith('#datatype')) { dt = parseCsvLine(line); continue }
+    if (line.startsWith('#')) continue // #group / #default carry nothing we need
+    const f = parseCsvLine(line)
+    if (cols === null) {
+      cols = f
+      valueIdx = cols.indexOf('_value')
+      continue
+    }
+    const rec = {}
+    cols.forEach((c, i) => { rec[c] = f[i] })
+    const valueType = (dt && valueIdx >= 0) ? dt[valueIdx] : undefined
+    const out = recordToLine(rec, valueType, opts)
+    if (out) lines.push(out); else skipped++
+  }
+  return { lines, skipped }
+}
+
+module.exports = { csvToLineProtocol, recordToLine, parseCsvLine }

package/lib/history/index.js

@@ -1,20 +1,19 @@
 'use strict'
 
 // History module — serves the sailkick app's GET /api/history/series and
-// /api/history/track from the boat's LOCAL InfluxDB (a signalk-to-influxdb-v2
-// style bucket), so the app's Trends panel + track work offline with the full
-// local dataset.
+// /api/history/track from the boat's own LIVE data, so the Trends panel and the track
+// work offline. The JSON envelope is byte-for-byte what the app's
+// server/routes/history.js returns, so the browser can't tell the difference.
 //
-// This is the boat-edge counterpart of the app's server/history/influx-provider.js:
-// the Flux queries and channel map are ported VERBATIM (the signalk-to-influxdb-v2 schema —
-// measurement=SignalK path, field="value", position→lat/lon — is exactly what that
-// provider assumes), and the JSON envelope is byte-for-byte the same the app's
-// server/routes/history.js returns, so the browser client can't tell the difference.
-// Keep MAP / the queries in sync with the app copy.
+// There is exactly ONE source: the DB-less ring (lib/history/ring.js), sampled from the
+// same BoatState that feeds /ws/telemetry.
 //
-// When no local InfluxDB is configured (e.g. SignalK on a Victron GX / Venus OS)
-// but a telemetry source is available, it instead serves a DB-less in-memory ring
-// (lib/history/ring.js) — same JSON contract, ~1h offline window, no database.
+// Until v0.15.0 a local InfluxDB could be configured here instead, and it won because a
+// read token was present. That was a trap: the app only ever asks for a RELATIVE window
+// clamped to 24 h (sailkick/server/routes/history.js), so pointing this at a bucket of
+// older data returned nothing at all — Trends went blank AND the working live ring was
+// switched off. Local history is now always live; an old InfluxDB's value is getting its
+// contents INTO the cloud, which is what lib/backfill is for.
 
 const path = require('path')
 const { RingHistoryProvider } = require('./ring')
@@ -24,21 +23,6 @@ const RAD2DEG = 180 / Math.PI
 const wrap360 = (d) => ((d % 360) + 360) % 360
 const wrap180 = (d) => { const x = wrap360(d); return x > 180 ? x - 360 : x }
 
-// SignalK path (Influx measurement) → { chan, conv }. Field key is "value".
-// Some channels have a fallback measurement (primary wins when both present).
-const MAP = {
-  'environment.wind.speedTrue': { chan: 'tws', conv: (v) => v * MS_TO_KT },
-  'environment.wind.directionTrue': { chan: 'twd', conv: (v) => wrap360(v * RAD2DEG) },
-  'environment.wind.speedApparent': { chan: 'aws', conv: (v) => v * MS_TO_KT },
-  'environment.wind.angleApparent': { chan: 'awa', conv: (v) => wrap180(v * RAD2DEG) },
-  'navigation.speedOverGround': { chan: 'sog', conv: (v) => v * MS_TO_KT },
-  'navigation.speedThroughWater': { chan: 'stw', conv: (v) => v * MS_TO_KT },
-  'navigation.headingTrue': { chan: 'heading', conv: (v) => wrap360(v * RAD2DEG) },
-  'navigation.headingMagnetic': { chan: 'heading', conv: (v) => wrap360(v * RAD2DEG), fallback: true },
-  'environment.depth.belowTransducer': { chan: 'depth', conv: (v) => v },
-  'environment.depth.belowSurface': { chan: 'depth', conv: (v) => v, fallback: true }
-}
-const MEASUREMENTS = Object.keys(MAP)
 
 // Parse a duration like "1h" / "30m" / "600s" / "3600" → seconds, clamped.
 // Ported from the app's server/routes/history.js so limits match exactly.
@@ -50,44 +34,13 @@ function dur (s, def, min, max) {
   return Math.max(min, Math.min(max, n))
 }
 
-// Minimal InfluxDB v2 annotated-CSV parser (same approach as the app's
-// server/influx/client.js). Values in our long-format queries are simple.
-function parseAnnotatedCsv (text) {
-  const rows = []
-  let header = null
-  for (const raw of text.split('\n')) {
-    const line = raw.replace(/\r$/, '')
-    if (!line || line.startsWith('#')) { header = null; continue }
-    const cols = line.split(',')
-    if (!header) { header = cols; continue }
-    const o = {}
-    for (let i = 0; i < header.length; i++) o[header[i]] = cols[i]
-    rows.push(o)
-  }
-  return rows
-}
 
 function createHistory (app, options) {
   const log = (m) => (app.debug ? app.debug('[history] ' + m) : console.log('[sailkick-boat:history]', m))
-  let cfg = null
-  let provider = null // { getSeries, getTrack, destroy? } — InfluxDB queries or the ring
-  let mode = null // 'influx' | 'ring' | null
+  let provider = null // the ring, or null when there is no telemetry to sample
 
   function start () {
-    cfg = {
-      url: (options.influxUrl || 'http://127.0.0.1:8086').replace(/\/+$/, ''),
-      org: options.org || 'signalk',
-      bucket: options.bucket || 'signalk',
-      token: options.token || '',
-      timeoutMs: options.requestTimeoutMs || 15000
-    }
-    if (cfg.url && cfg.token && cfg.bucket) {
-      // Full history from a local InfluxDB.
-      provider = { getSeries: influxSeries, getTrack: influxTrack }
-      mode = 'influx'
-      log(`serving /api/history from ${cfg.url} bucket "${cfg.bucket}"`)
-    } else if (options.ringSource && options.ringSource.getState) {
-      // No local InfluxDB → DB-less rolling ring from live telemetry (GX/Venus OS).
+    if (options.ringSource && options.ringSource.getState) {
       // Persist the append-log so it survives restarts (unless ringPersist is off).
       // Default location: a "history" folder under the tile cache dir (storeDir), so it
       // sits on the SSD/USB with the tiles; `ringDir` overrides. Resolve storeDir the
@@ -102,19 +55,18 @@ function createHistory (app, options) {
         sampleSec: options.ringSampleSec,
         persistFile
       })
-      mode = 'ring'
       log(persistFile
-        ? `serving /api/history from a persistent DB-less ring (${persistFile})`
-        : 'serving /api/history from an in-memory DB-less ring')
+        ? `serving /api/history from a persistent ring (${persistFile})`
+        : 'serving /api/history from an in-memory ring')
     } else {
-      provider = null; mode = null
-      log('no local InfluxDB and no telemetry — /api/history falls through to the mirror')
+      provider = null
+      log('no telemetry source — /api/history falls through to the cloud mirror')
     }
   }
 
   function stop () {
     try { if (provider && provider.destroy) provider.destroy() } catch {}
-    provider = null; mode = null; cfg = null
+    provider = null
   }
 
   // available() gates local serving: when false the proxy lets /api/history fall
@@ -123,79 +75,10 @@ function createHistory (app, options) {
 
   function status () {
     if (!provider) return 'history: off'
-    return mode === 'ring' ? `history: ring${provider._persistFile ? ' (persistent)' : ''}` : `history: ${cfg.bucket}@local`
-  }
-
-  async function queryFlux (flux, signal) {
-    const url = `${cfg.url}/api/v2/query?org=${encodeURIComponent(cfg.org)}`
-    let resp
-    try {
-      resp = await fetch(url, {
-        method: 'POST',
-        headers: { Authorization: `Token ${cfg.token}`, 'Content-Type': 'application/vnd.flux', Accept: 'application/csv' },
-        body: flux,
-        signal: signal || AbortSignal.timeout(cfg.timeoutMs)
-      })
-    } catch (e) {
-      if (e && e.name === 'AbortError') return { ok: false, status: 0, message: 'InfluxDB query aborted/timed out' }
-      return { ok: false, status: 502, message: `Network error talking to InfluxDB: ${e.message}` }
-    }
-    if (!resp.ok) {
-      const body = await resp.text().catch(() => '')
-      return { ok: false, status: resp.status, message: `InfluxDB ${resp.status}: ${body.slice(0, 200)}` }
-    }
-    return { ok: true, rows: parseAnnotatedCsv(await resp.text()) }
-  }
-
-  async function influxSeries ({ windowSec, everySec, signal }) {
-    const filt = MEASUREMENTS.map((m) => `r._measurement == "${m}"`).join(' or ')
-    const flux = `from(bucket: "${cfg.bucket}")
-  |> range(start: -${windowSec}s)
-  |> filter(fn: (r) => r._field == "value" and (${filt}))
-  |> aggregateWindow(every: ${everySec}s, fn: mean, createEmpty: false)
-  |> keep(columns: ["_time", "_value", "_measurement"])`
-    const r = await queryFlux(flux, signal)
-    if (!r.ok) return r
-
-    const byChan = {} // chan -> { primary:[[t,v]], fallback:[[t,v]] }
-    for (const row of r.rows) {
-      const spec = MAP[row._measurement]
-      if (!spec) continue
-      const t = Date.parse(row._time)
-      const v = Number(row._value)
-      if (!Number.isFinite(t) || !Number.isFinite(v)) continue
-      const slot = (byChan[spec.chan] || (byChan[spec.chan] = { primary: [], fallback: [] }))
-      ;(spec.fallback ? slot.fallback : slot.primary).push([t, spec.conv(v)])
-    }
-    const series = {}
-    for (const [chan, { primary, fallback }] of Object.entries(byChan)) {
-      const pts = (primary.length ? primary : fallback).sort((a, b) => a[0] - b[0])
-      if (pts.length) series[chan] = pts
-    }
-    return { ok: true, series }
-  }
-
-  async function influxTrack ({ windowSec, everySec = 30, signal }) {
-    const flux = `from(bucket: "${cfg.bucket}")
-  |> range(start: -${windowSec}s)
-  |> filter(fn: (r) => r._measurement == "navigation.position" and (r._field == "lat" or r._field == "lon"))
-  |> aggregateWindow(every: ${everySec}s, fn: last, createEmpty: false)
-  |> pivot(rowKey: ["_time"], columnKey: ["_field"], valueColumn: "_value")
-  |> keep(columns: ["_time", "lat", "lon"])`
-    const r = await queryFlux(flux, signal)
-    if (!r.ok) return r
-    const track = []
-    for (const row of r.rows) {
-      const t = Date.parse(row._time)
-      const lat = Number(row.lat)
-      const lon = Number(row.lon)
-      if (Number.isFinite(t) && Number.isFinite(lat) && Number.isFinite(lon)) track.push({ t, lat, lon })
-    }
-    track.sort((a, b) => a.t - b.t)
-    return { ok: true, track }
+    return `history: ring${provider._persistFile ? ' (persistent)' : ''}`
   }
 
-  // Abort the Influx query if the client disconnects mid-request.
+  // Abort the query if the client disconnects mid-request.
   function abortOnClose (res) {
     const ac = new AbortController()
     res.on('close', () => { if (!res.writableFinished) ac.abort() })
@@ -241,7 +124,7 @@ function createHistory (app, options) {
     }
   }
 
-  return { start, stop, status, available, handleSeries, handleTrack, _mode: () => mode, _getSeries: influxSeries, _getTrack: influxTrack }
+  return { start, stop, status, available, handleSeries, handleTrack, _provider: () => provider }
 }
 
 module.exports = { createHistory }

package/lib/sync/index.js

@@ -175,7 +175,14 @@ function createSync (app, options) {
 
   function status () { return state ? state.statusLine : 'sync: off' }
 
-  return { start, stop, status }
+  // Spool depth, so best-effort work (the backfill) can stand down while live telemetry
+  // is behind. Live data is the one thing that must not be starved by a bulk upload.
+  async function pending () {
+    if (!state || !state.spool) return { count: 0, bytes: 0 }
+    try { return await state.spool.stats() } catch { return { count: 0, bytes: 0 } }
+  }
+
+  return { start, stop, status, pending }
 }
 
 module.exports = { createSync }

package/lib/sync/lineprotocol.js

@@ -85,16 +85,21 @@ function emit (path, value, tags, ns, lines) {
 
 // delta -> array of line-protocol strings.
 // opts.context = fallback self context ("vessels.<urn>") when delta.context absent.
+// opts.self    = value of the `self` tag; defaults to true because live telemetry is
+//                self-only. AIS targets pass false, and that tag is what the cloud's
+//                history queries filter on to keep other vessels out of the boat's own
+//                Trends and track — the two halves of that contract must agree.
 function deltaToLines (delta, opts) {
   const lines = []
   if (!delta || !Array.isArray(delta.updates)) return lines
   const ctx = escapeTag(delta.context || (opts && opts.context) || 'vessels.self')
+  const selfTag = (opts && opts.self === false) ? 'false' : 'true'
 
   for (const update of delta.updates) {
     if (!update || !Array.isArray(update.values)) continue
     const source = escapeTag(update.$source || sourceLabel(update.source) || 'unknown')
     const ns = toNs(update.timestamp != null ? update.timestamp : Date.now())
-    const tags = `context=${ctx},self=true,source=${source}`
+    const tags = `context=${ctx},self=${selfTag},source=${source}`
     for (const pv of update.values) {
       if (!pv || !pv.path) continue // skip vessel-level '' path objects
       emit(pv.path, pv.value, tags, ns, lines)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sailkick-boat",
-  "version": "0.14.7",
+  "version": "0.17.0",
   "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": {