signalk-performance-processor 0.0.0-stage → 0.0.1

package/lib/processor.js

@@ -0,0 +1,287 @@
+'use strict'
+
+// The processing pipeline, free of Signal K so it can be tested and replayed against
+// logged data. Units throughout: degrees and knots. Angles are signed, + = starboard;
+// heel + = starboard side down; leeway + = sliding to starboard.
+//
+// Order of work:
+//   input corrections  (CORRECTIONS with stage 'input')
+//   true wind          apparent wind minus boat velocity through the water
+//   true wind corrections (stage 'trueWind')
+//   derived            TWD and current
+//
+// A new correction is one more entry in CORRECTIONS plus its defaults in defaults.js;
+// the pipeline, the Live view and the enable switch pick it up from there.
+
+const { DEFAULTS } = require('./defaults')
+
+const MAX_LEEWAY_DEG = 15
+const MIN_LEEWAY_STW_KN = 1 // below this K x heel / STW^2 blows up; no leeway
+
+const norm360 = d => ((d % 360) + 360) % 360
+const norm180 = d => { const n = norm360(d); return n > 180 ? n - 360 : n }
+const rad = d => d * Math.PI / 180
+const deg = r => r * 180 / Math.PI
+
+// Linear interpolation, holding the end values beyond either end.
+function interp (xs, ys, x) {
+  if (x <= xs[0]) return ys[0]
+  const n = xs.length - 1
+  if (x >= xs[n]) return ys[n]
+  let i = 0
+  while (xs[i + 1] < x) i++
+  const t = (x - xs[i]) / (xs[i + 1] - xs[i])
+  return ys[i] + (ys[i + 1] - ys[i]) * t
+}
+
+// Upwind row in full up to angles.upwind, reach row at angles.reach, downwind row from
+// angles.downwind, linear in |TWA| between.
+function blendRows (absTwa, angles, up, reach, down) {
+  if (absTwa <= angles.upwind) return up
+  if (absTwa <= angles.reach) return up + (reach - up) * (absTwa - angles.upwind) / (angles.reach - angles.upwind)
+  if (absTwa <= angles.downwind) return reach + (down - reach) * (absTwa - angles.reach) / (angles.downwind - angles.reach)
+  return down
+}
+
+function tableLookup (table, angles, absTwa, tws) {
+  return blendRows(absTwa, angles,
+    interp(table.tws, table.upwind, tws),
+    interp(table.tws, table.reach, tws),
+    interp(table.tws, table.downwind, tws))
+}
+
+const fmt = (v, d = 1) => (v > 0 ? '+' : '') + v.toFixed(d)
+
+const CORRECTIONS = [
+  {
+    id: 'stw',
+    stage: 'input',
+    name: 'Boat speed (STW)',
+    apply (c, cfg) {
+      // Linearity starts at its first bin; below that taper to zero at 0 kn, so a
+      // stopped boat is not given speed.
+      const lin = cfg.linearity
+      const add1 = c.stw < lin.stw[0]
+        ? lin.add[0] * Math.max(0, c.stw) / lin.stw[0]
+        : interp(lin.stw, lin.add, c.stw)
+      const add2 = c.heel == null ? 0 : interp(cfg.heel.heel, cfg.heel.add, Math.abs(c.heel))
+      const before = c.stw
+      c.stw = Math.max(0, c.stw + add1 + add2)
+      return {
+        input: `${before.toFixed(2)} kn` + (c.heel == null ? '' : ` · heel ${Math.abs(c.heel).toFixed(0)}°`),
+        detail: `${fmt(add1, 2)} linearity, ${fmt(add2, 2)} heel` + (c.heel == null ? ' (no heel data)' : ''),
+        output: `${c.stw.toFixed(2)} kn`
+      }
+    }
+  },
+  {
+    id: 'leeway',
+    stage: 'input',
+    name: 'Leeway',
+    apply (c, cfg) {
+      if (c.heel == null) return { skipped: 'no heel data' }
+      const k = cfg.k
+      c.leeway = c.stw < MIN_LEEWAY_STW_KN
+        ? 0
+        : Math.max(-MAX_LEEWAY_DEG, Math.min(MAX_LEEWAY_DEG, k * c.heel / (c.stw * c.stw)))
+      return {
+        input: `heel ${c.heel.toFixed(0)}°`,
+        detail: `K ${k} × heel ÷ STW²`,
+        output: `${Math.abs(c.leeway).toFixed(1)}° ${c.leeway < 0 ? 'port' : 'stbd'}`
+      }
+    }
+  },
+  {
+    id: 'twa',
+    stage: 'trueWind',
+    name: 'TWA table',
+    apply (c, cfg) {
+      const abs = Math.abs(c.twa)
+      const add = tableLookup(cfg, cfg.angles, abs, c.tws)
+      const before = c.twa
+      c.twa = Math.sign(c.twa || 1) * Math.max(0, Math.min(180, abs + add))
+      return {
+        input: `TWA ${Math.abs(before).toFixed(1)}° · TWS ${c.tws.toFixed(1)}`,
+        detail: `${fmt(add)}°`,
+        output: `TWA ${Math.abs(c.twa).toFixed(1)}°`
+      }
+    }
+  },
+  {
+    id: 'tws',
+    stage: 'trueWind',
+    name: 'TWS table',
+    apply (c, cfg, all) {
+      const pct = tableLookup(cfg, all.corrections.twa.angles, Math.abs(c.twa), c.tws)
+      const before = c.tws
+      c.tws = c.tws * (1 + pct / 100)
+      return {
+        input: `TWS ${before.toFixed(1)} kn`,
+        detail: `${fmt(pct)}%`,
+        output: `TWS ${c.tws.toFixed(1)} kn`
+      }
+    }
+  }
+]
+
+function runStage (stage, c, config, steps) {
+  for (const corr of CORRECTIONS.filter(x => x.stage === stage)) {
+    const cfg = config.corrections[corr.id]
+    if (!cfg || !cfg.enabled) {
+      steps.push({ id: corr.id, name: corr.name, enabled: false })
+      continue
+    }
+    const r = corr.apply(c, cfg, config)
+    steps.push({ id: corr.id, name: corr.name, enabled: true, ...r })
+  }
+}
+
+// Input corrections only: STW and leeway from raw STW and heel. Used on its own to
+// republish corrected STW as soon as the paddlewheel reports.
+function correctInputs (input, config) {
+  const c = { stw: input.stw, heel: input.heel == null ? null : input.heel, leeway: 0 }
+  const steps = []
+  runStage('input', c, config, steps)
+  return { c, steps }
+}
+
+// input: { awa, aws, stw, heel?, headingMagnetic?, headingTrue?, sog?, cog? }
+// returns { out: { stw, leeway, twa, tws, heading?, twd?, current? }, steps }
+function process (input, config) {
+  const { c, steps } = correctInputs(input, config)
+
+  // True wind: apparent wind minus the boat's velocity through the water, which points
+  // along the heading turned by leeway.
+  const a = rad(input.awa)
+  const l = rad(c.leeway)
+  const x = input.aws * Math.cos(a) - c.stw * Math.cos(l)
+  const y = input.aws * Math.sin(a) - c.stw * Math.sin(l)
+  c.twa = deg(Math.atan2(y, x))
+  c.tws = Math.hypot(x, y)
+  steps.push({
+    id: 'truewind',
+    name: 'True wind',
+    enabled: true,
+    input: `AWA ${Math.abs(input.awa).toFixed(1)}° · ${input.aws.toFixed(1)} kn`,
+    detail: 'apparent wind − boat velocity',
+    output: `TWA ${Math.abs(c.twa).toFixed(1)}° · ${c.tws.toFixed(1)} kn`
+  })
+
+  runStage('trueWind', c, config, steps)
+
+  const out = { stw: c.stw, leeway: c.leeway, twa: c.twa, tws: c.tws }
+
+  const heading = input.headingTrue != null
+    ? input.headingTrue
+    : input.headingMagnetic != null ? input.headingMagnetic + config.variation : null
+  if (heading != null) {
+    out.heading = norm360(heading)
+    out.twd = norm360(heading + c.twa)
+    if (input.sog != null && input.cog != null) {
+      // Current = ground velocity - water velocity; set is where it flows to.
+      const cr = rad(input.cog)
+      const wr = rad(heading + c.leeway)
+      const e = input.sog * Math.sin(cr) - c.stw * Math.sin(wr)
+      const n = input.sog * Math.cos(cr) - c.stw * Math.cos(wr)
+      out.current = { drift: Math.hypot(e, n), set: norm360(deg(Math.atan2(e, n))) }
+      steps.push({
+        id: 'current',
+        name: 'Current',
+        enabled: true,
+        input: `SOG ${input.sog.toFixed(1)} · COG ${input.cog.toFixed(0)}°`,
+        detail: 'ground − water velocity',
+        output: `${out.current.drift.toFixed(2)} kn → ${out.current.set.toFixed(0)}°`
+      })
+    }
+  }
+  return { out, steps }
+}
+
+// ---- configuration --------------------------------------------------------
+
+const clone = o => JSON.parse(JSON.stringify(o))
+
+function isPlainObject (o) {
+  return o !== null && typeof o === 'object' && !Array.isArray(o)
+}
+
+// Defaults first, then whatever the stored config sets. Arrays replace, objects merge.
+function merge (base, over) {
+  if (!isPlainObject(over)) return base
+  const out = clone(base)
+  for (const [k, v] of Object.entries(over)) {
+    if (isPlainObject(v) && isPlainObject(out[k])) out[k] = merge(out[k], v)
+    else if (v !== undefined) out[k] = v
+  }
+  return out
+}
+
+function checkAxis (errors, label, xs) {
+  if (!Array.isArray(xs) || xs.length < 1) { errors.push(`${label}: needs at least one value`); return }
+  if (xs.some(v => typeof v !== 'number' || !Number.isFinite(v))) { errors.push(`${label}: every value must be a number`); return }
+  for (let i = 1; i < xs.length; i++) {
+    if (!(xs[i] > xs[i - 1])) { errors.push(`${label}: must increase from left to right`); return }
+  }
+}
+
+function checkRow (errors, label, ys, n) {
+  if (!Array.isArray(ys) || ys.length !== n) { errors.push(`${label}: needs ${n} values, one per column`); return }
+  if (ys.some(v => typeof v !== 'number' || !Number.isFinite(v))) errors.push(`${label}: every value must be a number`)
+}
+
+function checkNumber (errors, label, v) {
+  if (typeof v !== 'number' || !Number.isFinite(v)) errors.push(`${label}: must be a number`)
+}
+
+// Merge a stored or submitted config over the defaults and check it. Numbers typed
+// into a form arrive as strings, so coerce numeric-looking strings first.
+function normalizeConfig (input) {
+  const coerce = v => {
+    if (Array.isArray(v)) return v.map(coerce)
+    if (isPlainObject(v)) return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, coerce(x)]))
+    if (typeof v === 'string' && v.trim() !== '' && Number.isFinite(Number(v))) return Number(v)
+    return v
+  }
+  const raw = isPlainObject(input) ? clone(input) : {}
+  // Source names are text even when they look numeric.
+  const keepText = { sources: raw.sources, mode: raw.mode }
+  const config = merge(DEFAULTS, { ...coerce(raw), ...Object.fromEntries(Object.entries(keepText).filter(([, v]) => v !== undefined)) })
+  const errors = []
+  const k = config.corrections
+
+  if (!['shadow', 'replace'].includes(config.mode)) errors.push('mode: must be shadow or replace')
+  checkNumber(errors, 'variation', config.variation)
+
+  checkAxis(errors, 'STW linearity speeds', k.stw.linearity.stw)
+  checkRow(errors, 'STW linearity values', k.stw.linearity.add, (k.stw.linearity.stw || []).length)
+  checkAxis(errors, 'STW heel angles', k.stw.heel.heel)
+  checkRow(errors, 'STW heel values', k.stw.heel.add, (k.stw.heel.heel || []).length)
+  if (Array.isArray(k.stw.linearity.stw) && !(k.stw.linearity.stw[0] > 0)) errors.push('STW linearity speeds: must start above 0 kn')
+
+  checkNumber(errors, 'Leeway K', k.leeway.k)
+
+  for (const id of ['twa', 'tws']) {
+    const t = k[id]
+    const name = id.toUpperCase() + ' table'
+    checkAxis(errors, `${name} TWS columns`, t.tws)
+    for (const row of ['upwind', 'reach', 'downwind']) checkRow(errors, `${name} ${row} row`, t[row], (t.tws || []).length)
+  }
+  const ang = k.twa.angles
+  ;['upwind', 'reach', 'downwind'].forEach(r => checkNumber(errors, `TWA table ${r} angle`, ang[r]))
+  if (!(ang.upwind < ang.reach && ang.reach < ang.downwind && ang.upwind > 0 && ang.downwind < 180)) {
+    errors.push('TWA table angles: need 0 < upwind < reach < downwind < 180')
+  }
+
+  for (const [id, c] of Object.entries(k)) {
+    if (typeof c.enabled !== 'boolean') errors.push(`${id}: enabled must be true or false`)
+  }
+  return { config, errors }
+}
+
+module.exports = {
+  process,
+  correctInputs,
+  normalizeConfig,
+  CORRECTIONS,
+  _internals: { interp, blendRows, tableLookup, merge, norm180 }
+}

package/package.json

@@ -1,6 +1,46 @@
 {
   "name": "signalk-performance-processor",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1",
+  "description": "H5000-style calibration for Signal K: corrects boat speed and leeway, applies TWA and TWS correction tables, and publishes true wind and current. Proof of concept.",
+  "main": "index.js",
+  "scripts": {
+    "test": "node --test",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "signalk-node-server-plugin",
+    "signalk-webapp",
+    "signalk-category-utility",
+    "signalk",
+    "sailing",
+    "racing",
+    "true-wind",
+    "calibration",
+    "leeway",
+    "speed-through-water"
+  ],
+  "signalk-plugin-enabled-by-default": false,
+  "signalk": {
+    "displayName": "Performance Processor",
+    "appIcon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "lib/",
+    "public/",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ghotihook/signalk-performance-processor.git"
+  },
+  "homepage": "https://github.com/ghotihook/signalk-performance-processor#readme",
+  "bugs": {
+    "url": "https://github.com/ghotihook/signalk-performance-processor/issues"
+  },
+  "author": "ghotihook",
+  "license": "MIT"
+}

package/public/app.js

@@ -0,0 +1,328 @@
+(function () {
+  'use strict'
+
+  const API = '/plugins/signalk-performance-processor'
+  const LIVE_MS = 1000
+  const STALE_MS = 5000
+
+  // Display names and help for each correction, in pipeline order. A correction the
+  // plugin knows but this list does not still shows, under its id.
+  const CORRECTIONS = {
+    stw: { name: 'Boat speed (STW)', what: 'Paddlewheel linearity at low speed, plus the loss when heeled. Knots added to STW before anything else uses it.' },
+    leeway: { name: 'Leeway', what: 'Sideways slip: leeway = K × heel ÷ STW². Turns the boat’s velocity to leeward for true wind and current.' },
+    twa: { name: 'TWA table', what: 'Degrees added to |TWA| by TWS, upwind, reaching and downwind, H5000 style. Negative = TWA was reading too wide. Rows blend by TWA at the angles below.' },
+    tws: { name: 'TWS table', what: 'Percent applied to TWS by TWS, upwind, reaching and downwind. Blended at the TWA table’s angles. H5000 default is −10% downwind.' }
+  }
+
+  const SOURCE_LABELS = {
+    apparentWind: 'Apparent wind',
+    stw: 'Speed through water',
+    heading: 'Heading',
+    attitude: 'Heel (attitude)',
+    gps: 'SOG and COG'
+  }
+
+  const state = {
+    view: 'live',
+    saved: null, // config as stored by the plugin
+    draft: null, // config being edited
+    defaults: null,
+    selected: 'twa',
+    live: null,
+    liveAt: 0,
+    saving: false
+  }
+
+  const $ = id => document.getElementById(id)
+  const clone = o => JSON.parse(JSON.stringify(o))
+  const esc = s => String(s == null ? '' : s).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]))
+  const fmt = (v, d = 1) => v == null || !Number.isFinite(v) ? '--' : v.toFixed(d)
+  const dirty = () => JSON.stringify(state.saved) !== JSON.stringify(state.draft)
+
+  // ---- data ----------------------------------------------------------------
+
+  async function getJson (path) {
+    const res = await fetch(API + path, { credentials: 'include', cache: 'no-store' })
+    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`)
+    return res.json()
+  }
+
+  async function loadConfig () {
+    try {
+      const body = await getJson('/config')
+      state.saved = body.config
+      state.draft = clone(body.config)
+      state.defaults = body.defaults
+      $('conn').hidden = true
+    } catch (e) {
+      $('conn').textContent = `Cannot reach the plugin (${e.message}). Is Performance Processor enabled?`
+      $('conn').hidden = false
+    }
+    renderAll()
+  }
+
+  async function pollLive () {
+    try {
+      state.live = await getJson('/live')
+      state.liveAt = Date.now()
+      $('conn').hidden = true
+    } catch (e) {
+      $('conn').textContent = `Lost contact with the plugin (${e.message})`
+      $('conn').hidden = false
+    }
+    renderHeader()
+    if (state.view === 'live') renderLive()
+    if (state.view === 'settings') renderSourcesIfIdle()
+  }
+
+  async function save () {
+    state.saving = true
+    renderSaveBar()
+    try {
+      const res = await fetch(API + '/config', {
+        method: 'PUT',
+        credentials: 'include',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(state.draft)
+      })
+      const body = await res.json().catch(() => ({}))
+      if (!res.ok) {
+        const why = body.errors ? body.errors.join('; ') : `${res.status} ${res.statusText}`
+        throw new Error(res.status === 401 || res.status === 403 ? 'not authorised — log in to Signal K with write access' : why)
+      }
+      state.saved = body.config
+      state.draft = clone(body.config)
+      $('saveErrors').textContent = ''
+    } catch (e) {
+      $('saveErrors').textContent = e.message
+    }
+    state.saving = false
+    renderAll()
+  }
+
+  // ---- editing ---------------------------------------------------------------
+
+  // data-path="corrections.twa.upwind.2" → state.draft.corrections.twa.upwind[2]
+  function setPath (path, value) {
+    const keys = path.split('.')
+    let o = state.draft
+    for (let i = 0; i < keys.length - 1; i++) o = o[keys[i]]
+    o[keys[keys.length - 1]] = value
+  }
+
+  function onEdit (e) {
+    const el = e.target
+    if (!el.dataset || !el.dataset.path || !state.draft) return
+    let value
+    if (el.type === 'checkbox') value = el.checked
+    else if (el.type === 'number') {
+      if (el.value === '') return // keep the old value until something is typed
+      value = Number(el.value)
+    } else value = el.value
+    setPath(el.dataset.path, value)
+    renderSaveBar()
+    if (el.type === 'checkbox' || el.type === 'radio' || el.tagName === 'SELECT') renderAll()
+  }
+
+  // ---- rendering -----------------------------------------------------------
+
+  function renderAll () {
+    renderHeader()
+    renderSaveBar()
+    for (const v of ['live', 'calibration', 'settings']) $('view-' + v).hidden = v !== state.view
+    document.querySelectorAll('nav a').forEach(a => a.classList.toggle('current', a.dataset.view === state.view))
+    if (state.view === 'live') renderLive()
+    if (state.view === 'calibration') renderCalibration()
+    if (state.view === 'settings') renderSettings()
+  }
+
+  function renderHeader () {
+    const mode = state.saved ? state.saved.mode : null
+    const badge = $('mode')
+    badge.textContent = mode === 'replace' ? 'Replace' : mode === 'shadow' ? 'Shadow' : '--'
+    badge.classList.toggle('replace', mode === 'replace')
+    $('status').textContent = state.live ? (state.live.running ? state.live.status : 'Plugin not running') : ''
+  }
+
+  function renderSaveBar () {
+    $('saveBar').hidden = !(state.draft && (dirty() || $('saveErrors').textContent))
+    $('save').disabled = state.saving || !dirty()
+    $('revert').disabled = state.saving
+  }
+
+  // -- Live
+
+  // True wind straight from the inputs, with no corrections, for comparison.
+  function uncorrected (input) {
+    const a = input.awa * Math.PI / 180
+    const x = input.aws * Math.cos(a) - input.stw
+    const y = input.aws * Math.sin(a)
+    return { twa: Math.atan2(y, x) * 180 / Math.PI, tws: Math.hypot(x, y) }
+  }
+
+  function tile (label, value, unit, raw) {
+    return `<div class="tile"><div class="label">${esc(label)}</div>` +
+      `<div class="value">${esc(value)}<span class="unit">${esc(unit)}</span></div>` +
+      `<div class="raw">${esc(raw || '')}</div></div>`
+  }
+
+  function renderLive () {
+    const live = state.live
+    const r = live && live.result
+    const old = !r || live.ageMs > STALE_MS
+    $('liveAge').textContent = r ? (old ? `last update ${Math.round(live.ageMs / 1000)} s ago` : '') : ''
+
+    if (!r) {
+      $('tiles').innerHTML = ''
+      $('steps').innerHTML = `<tr><td colspan="4" class="muted center">${esc(live ? live.status || 'Waiting for data…' : 'Waiting for data…')}</td></tr>`
+    } else {
+      const o = r.out
+      const u = uncorrected(r.input)
+      const side = v => v < 0 ? 'port' : 'stbd'
+      $('tiles').innerHTML = [
+        tile('TWA', fmt(Math.abs(o.twa)), `° ${side(o.twa)}`, `uncorrected ${fmt(Math.abs(u.twa))}°`),
+        tile('TWS', fmt(o.tws), 'kn', `uncorrected ${fmt(u.tws)} kn`),
+        tile('TWD', o.twd == null ? '--' : fmt(o.twd, 0), '° T', o.twd == null ? 'no heading' : ''),
+        tile('STW', fmt(o.stw, 2), 'kn', `paddlewheel ${fmt(r.input.stw, 2)} kn`),
+        tile('Leeway', fmt(Math.abs(o.leeway)), `° ${side(o.leeway)}`, r.input.heel == null ? 'no heel' : `heel ${fmt(r.input.heel, 0)}°`),
+        tile('Current', o.current ? fmt(o.current.drift, 2) : '--', o.current ? `kn · ${fmt(o.current.set, 0)}°` : 'kn', o.current ? '' : 'no SOG/COG or heading')
+      ].join('')
+      $('steps').innerHTML = r.steps.map(s => s.enabled
+        ? `<tr><th scope="row">${esc(s.name)}</th><td class="mono">${esc(s.input || '')}</td><td>${esc(s.skipped ? 'skipped — ' + s.skipped : s.detail || '')}</td><td class="mono">${esc(s.output || '')}</td></tr>`
+        : `<tr class="off"><th scope="row">${esc(s.name)}</th><td></td><td>off</td><td></td></tr>`
+      ).join('')
+    }
+
+    const inputs = live ? Object.entries(live.inputs) : []
+    $('inputs').innerHTML = inputs.length
+      ? inputs.sort().map(([path, i]) => `<tr><td>${esc(path)}</td><td>${esc(i.source)}</td><td class="num ${i.ageMs > STALE_MS ? 'warn' : ''}">${fmt(i.ageMs / 1000)} s</td></tr>`).join('')
+      : '<tr><td colspan="3" class="muted center">Nothing received yet</td></tr>'
+  }
+
+  // -- Calibration
+
+  function correctionIds () {
+    const known = Object.keys(CORRECTIONS)
+    const all = Object.keys(state.draft.corrections)
+    return known.filter(id => all.includes(id)).concat(all.filter(id => !known.includes(id)))
+  }
+
+  function renderCalibration () {
+    if (!state.draft) return
+    const ids = correctionIds()
+    if (!ids.includes(state.selected)) state.selected = ids[0]
+    $('corrList').innerHTML = ids.map(id => {
+      const c = state.draft.corrections[id]
+      const name = (CORRECTIONS[id] || {}).name || id
+      return `<li class="${id === state.selected ? 'selected' : ''}">` +
+        `<button type="button" data-select="${esc(id)}" aria-pressed="${id === state.selected}">${esc(name)}</button>` +
+        `<label><input type="checkbox" data-path="corrections.${esc(id)}.enabled" ${c.enabled ? 'checked' : ''} aria-label="Enable ${esc(name)}"></label></li>`
+    }).join('')
+
+    const id = state.selected
+    const c = state.draft.corrections[id]
+    const meta = CORRECTIONS[id] || { name: id, what: '' }
+    let body = ''
+    if (id === 'stw') {
+      body = grid('Linearity (kn added)', 'STW kn', `corrections.stw.linearity`, 'stw', [['Add', 'add']], c.linearity) +
+        grid('Heel correction (kn added)', 'Heel °', `corrections.stw.heel`, 'heel', [['Add', 'add']], c.heel)
+    } else if (id === 'leeway') {
+      body = `<div class="fields">${field('K', 'corrections.leeway.k', c.k, 0.01)}</div>`
+    } else if (id === 'twa' || id === 'tws') {
+      const rows = [['Upwind', 'upwind'], ['Reach', 'reach'], ['Downwind', 'downwind']]
+      body = grid(id === 'twa' ? 'Degrees added to |TWA|' : 'Percent applied to TWS', 'TWS kn', `corrections.${id}`, 'tws', rows, c)
+      if (id === 'twa') {
+        const a = c.angles
+        body += `<div class="fields">${field('Upwind row to (° TWA)', 'corrections.twa.angles.upwind', a.upwind, 1)}` +
+          `${field('Reach row at (° TWA)', 'corrections.twa.angles.reach', a.reach, 1)}` +
+          `${field('Downwind row from (° TWA)', 'corrections.twa.angles.downwind', a.downwind, 1)}</div>`
+      }
+    }
+    $('corrEditor').innerHTML =
+      `<div class="panel-head"><h2>${esc(meta.name)}</h2><span class="state ${c.enabled ? 'on' : ''}">${c.enabled ? 'Enabled' : 'Disabled'}</span></div>` +
+      `<p class="what muted">${esc(meta.what)}</p>${body}` +
+      `<div><button type="button" class="ghost" data-defaults="${esc(id)}">Reset to defaults</button></div>`
+  }
+
+  // A table whose first row is its axis (editable) and whose other rows are values.
+  function grid (title, axisLabel, base, axisKey, rows, obj) {
+    const axis = obj[axisKey]
+    const cell = (path, v, cls) => `<td><input type="number" step="any" class="${cls || ''}" data-path="${esc(path)}" value="${esc(v)}"></td>`
+    return `<div><h2>${esc(title)}</h2><div class="table-wrap"><table class="grid">` +
+      `<tr><th scope="row" class="muted">${esc(axisLabel)}</th>${axis.map((v, i) => cell(`${base}.${axisKey}.${i}`, v, 'axis')).join('')}</tr>` +
+      rows.map(([label, key]) => `<tr><th scope="row">${esc(label)}</th>${obj[key].map((v, i) => cell(`${base}.${key}.${i}`, v)).join('')}</tr>`).join('') +
+      '</table></div></div>'
+  }
+
+  function field (label, path, value, step) {
+    return `<label class="field">${esc(label)}<input type="number" step="${step}" data-path="${esc(path)}" value="${esc(value)}"></label>`
+  }
+
+  // -- Settings
+
+  const MODES = [
+    ['shadow', 'Shadow', 'Publish to separate …Corrected paths. Your instruments and displays carry on as before.'],
+    ['replace', 'Replace', 'Publish on the standard paths. Rank this plugin first in Server → Source Priorities, and zero the instrument’s own corrections so nothing is corrected twice.']
+  ]
+
+  function renderSettings () {
+    if (!state.draft) return
+    $('modes').innerHTML = '<legend class="sr-only">Publish mode</legend>' + MODES.map(([id, name, desc]) =>
+      `<label class="mode ${state.draft.mode === id ? 'checked' : ''}"><input type="radio" name="mode" value="${id}" data-path="mode" ${state.draft.mode === id ? 'checked' : ''}>` +
+      `<div><b>${esc(name)}</b><span>${esc(desc)}</span></div></label>`).join('')
+    const v = $('variation')
+    if (document.activeElement !== v) v.value = state.draft.variation
+    renderSources()
+  }
+
+  function renderSources () {
+    const seen = (state.live && state.live.sourcesSeen) || {}
+    $('sources').innerHTML = Object.entries(SOURCE_LABELS).map(([key, label]) => {
+      const chosen = state.draft.sources[key] || ''
+      const opts = Array.from(new Set([...(seen[key] || []), chosen].filter(Boolean)))
+      return `<label>${esc(label)}<select data-path="sources.${key}">` +
+        `<option value="">Any</option>` +
+        opts.map(s => `<option value="${esc(s)}" ${s === chosen ? 'selected' : ''}>${esc(s)}${(seen[key] || []).includes(s) ? '' : ' (not seen)'}</option>`).join('') +
+        '</select></label>'
+    }).join('')
+  }
+
+  // Sources arrive with live data; refresh the list unless a dropdown is in use.
+  function renderSourcesIfIdle () {
+    if (!state.draft || (document.activeElement && document.activeElement.tagName === 'SELECT')) return
+    renderSources()
+  }
+
+  // ---- wiring ----------------------------------------------------------------
+
+  function route () {
+    const v = location.hash.replace('#', '')
+    state.view = ['live', 'calibration', 'settings'].includes(v) ? v : 'live'
+    renderAll()
+  }
+
+  document.addEventListener('change', onEdit)
+  document.addEventListener('click', e => {
+    const sel = e.target.closest('[data-select]')
+    if (sel) { state.selected = sel.dataset.select; renderCalibration() }
+    const def = e.target.closest('[data-defaults]')
+    if (def && state.defaults) {
+      const id = def.dataset.defaults
+      state.draft.corrections[id] = clone(state.defaults.corrections[id])
+      renderAll()
+    }
+  })
+  $('save').addEventListener('click', save)
+  $('revert').addEventListener('click', () => {
+    state.draft = clone(state.saved)
+    $('saveErrors').textContent = ''
+    renderAll()
+  })
+  window.addEventListener('hashchange', route)
+  window.addEventListener('beforeunload', e => { if (state.draft && dirty()) { e.preventDefault(); e.returnValue = '' } })
+
+  route()
+  loadConfig()
+  pollLive()
+  setInterval(pollLive, LIVE_MS)
+})()

package/public/icon.svg

@@ -0,0 +1,15 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="128" height="128" viewBox="0 0 64 64" role="img" aria-label="Performance processor">
+  <rect width="64" height="64" rx="10" fill="#0d1117"/>
+  <!-- hull, seen from above, heading up -->
+  <path d="M32 9 C 41 19 41 39 37.5 54 H 26.5 C 23 39 23 19 32 9 Z" fill="none" stroke="#e6edf3" stroke-width="3" stroke-linejoin="round"/>
+  <!-- measured wind, from ahead to starboard -->
+  <line x1="56" y1="12" x2="36" y2="30" stroke="#8b949e" stroke-width="3" stroke-linecap="round" stroke-dasharray="4 4"/>
+  <!-- corrected true wind -->
+  <line x1="58" y1="24" x2="38" y2="34" stroke="#4cd97b" stroke-width="3.5" stroke-linecap="round"/>
+  <path d="M42.5 29.5 l-4.5 4.5 6 1.5" fill="none" stroke="#4cd97b" stroke-width="3.5" stroke-linecap="round" stroke-linejoin="round"/>
+  <!-- the correction between them -->
+  <path d="M51 16.5 A 12 12 0 0 1 54 26" fill="none" stroke="#f0b429" stroke-width="3" stroke-linecap="round"/>
+  <!-- leeway: slip to leeward -->
+  <path d="M14 46 H 22" stroke="#58a6ff" stroke-width="3" stroke-linecap="round"/>
+  <path d="M17.5 42.5 l-3.5 3.5 3.5 3.5" fill="none" stroke="#58a6ff" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>