signalk-performance-processor 0.0.3 → 0.0.5

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.0.5 — 2026-10-29
+
+Still a proof of concept: run it in Shadow mode alongside your instruments.
+
+- **Fix: feedback loop with another STW plugin in Replace mode.** With `signalk-stw-heel-correction` (0.2 or earlier) on the same server, each plugin corrected the other's STW and handed it back, so STW and true wind ran away. Without a chosen STW source, STW is now read from sensors only (updates that carry a `source` object from a data connection), never from another plugin. Choosing a source in Settings still overrides this.
+- **Rate limit as a circuit breaker:** no path is published more often than 20 Hz. A feedback loop is cut at its first repeat, and a backlog flushed after a dropout is thinned rather than stopped; nothing latches. While updates are being dropped, the status and the Live page say so, with a count and the source driving them, for 10 s after the last one; the first is logged.
+- The status says when STW is arriving only from other plugins, and names them.
+- Settings: the STW source's blank choice reads **Auto (sensors only)**.
+
+## 0.0.4 — 2026-10-29
+
+Still a proof of concept: run it in Shadow mode alongside your instruments. Saved configurations are upgraded to schema 2 on first load.
+
+- **STW correction is a heel × speed table** (signed heel rows, STW columns), like the H5000's boat speed / heel table, with bilinear interpolation and blank cells filled from the nearest value. The default is the owner's full measured table. A table in the `signalk-stw-heel-correction` CSV format can be pasted into the webapp.
+- **TWS table is in knots** (H5000 units). Default downwind −0.5 … −3 kn (−10% of each column); upwind and reach blank, meaning no correction.
+- **New TWA table defaults** from the owner's calibration fit. Blank TWA cells mean too little data and use the nearest measured cells in the row.
+- Config file schema 2. Schema 1 files are upgraded on load: the two STW rows become their grid and TWS percentages become knots.
+- Live pipeline: each step's result is tagged **Published** or **Working**, worked out from what later enabled steps replace, so intermediate values are not mistaken for outputs.
+- Calibration tables: the breakpoints (TWS columns, STW speeds, heel angles) are fixed labels, not editable fields; only the correction values are edited.
+- Live page: a "Published to Signal K" table lists exactly what the plugin sends and on which path. The pipeline's true wind step is labelled "before tables", so its working TWA is not mistaken for a second output.
+
 ## 0.0.3 — 2026-10-29
 
 Still a proof of concept: run it in Shadow mode alongside your instruments.

package/README.md

@@ -8,7 +8,7 @@ If your TWD swings 5–10° every time you tack or gybe, the wind hasn't shifted
 
 This plugin does the calibration job of a B&G H5000-class instrument processor inside Signal K. It corrects boat speed and leeway, then applies H5000-style TWA and TWS correction tables, and publishes corrected true wind and current. You edit everything in a webapp and can watch each correction work live. Run it in **Shadow mode** first: it publishes alongside your existing instruments without changing anything they do.
 
-> **Proof of concept (0.0.3).** Compare it against your instruments in Shadow mode before relying on it. See the [changelog](CHANGELOG.md).
+> **Proof of concept (0.0.5).** Compare it against your instruments in Shadow mode before relying on it. See the [changelog](CHANGELOG.md).
 
 ## Why it exists
 
@@ -22,14 +22,14 @@ Instrument processors fix this with calibration tables, but:
 
 This plugin moves the calibration into Signal K, where you can see it, change it, log it and fit it from your own race data:
 
-- **The same shape as an H5000:** boat speed linearity and heel correction, leeway, and TWA/TWS tables by wind speed with upwind, reach and downwind rows. An existing calibration carries across, and the H5000 tuning rule ("TWD lifts on every tack: take half the error off TWA") works unchanged.
+- **The same shape as an H5000:** a boat speed table by heel and speed, leeway (K × heel ÷ boat speed²), and TWA/TWS tables by wind speed with upwind, reach and downwind rows. An existing calibration carries across, and the H5000 tuning rule ("TWD lifts on every tack: take half the error off TWA") works unchanged.
 - **Every correction has a switch and a live readout,** so you can see what each one does to the numbers right now.
 - **The calibration is a versioned JSON file,** easy to back up, compare and fit from logged races offline.
 - **It is safe to try.** Shadow mode publishes `…Corrected` paths beside your instruments. Replace mode takes over the standard paths only when you choose it.
 
 ### On the boat it was built for
 
-From the offline model the defaults were fitted with: trained on 2025 race logs, tested on Jan–Mar 2026 races it had not seen, and measured by how far true wind direction jumps through each manoeuvre (median). The shipped defaults differ slightly (the owner's leeway K, and the TWA table resampled to H5000 breakpoints).
+From the offline model the defaults were fitted with: trained on 2025 race logs, tested on Jan–Mar 2026 races it had not seen, and measured by how far true wind direction jumps through each manoeuvre (median). The shipped defaults differ (the owner's leeway K, full STW table and TWA table from a later calibration fit), so treat these as an indication, not a guarantee.
 
 | | Uncorrected | Instrument (H2000) | This plugin |
 |---|---|---|---|
@@ -54,11 +54,11 @@ The corrections run in this order, each on the output of the one before:
 
 | Step | What | Default |
 |---|---|---|
-| Boat speed (STW) | Knots added to the paddlewheel: a **linearity** row by speed plus a **heel correction** row by heel, the same split as the H5000 | On |
+| Boat speed (STW) | Knots added to the paddlewheel from a **heel × speed table** (signed heel rows, STW columns), like the H5000's boat speed / heel table | On |
 | Leeway | Leeway = K × heel ÷ STW², turning the boat's velocity to leeward | On, K = 7.9446 |
 | True wind | Apparent wind minus the boat's velocity through the water | Always |
 | TWA table | Degrees added to \|TWA\| by TWS, with upwind, reach and downwind rows blended by TWA (70° / 100° / 130°) | On |
-| TWS table | Percent applied to TWS by TWS, same rows and blending | Off |
+| TWS table | Knots added to TWS by TWS, same rows and blending (H5000 units) | Off |
 | TWD, current | TWD from heading and corrected TWA; current from SOG/COG minus water velocity | Always, when heading and GPS are available |
 
 ### Inputs
@@ -73,7 +73,17 @@ The corrections run in this order, each on the output of the one before:
 
 True wind is worked out on every apparent wind update. Inputs older than 3 seconds are not used. Without STW there is no true wind. Without heel, the heel correction and leeway are skipped. Without heading, there is no TWD or current.
 
-Feed it **measured** apparent wind and **raw** paddlewheel speed. If another plugin already corrects STW (for example `signalk-stw-heel-correction`), choose the instrument as the STW source in Settings, or the correction is applied twice.
+Feed it **measured** apparent wind and **raw** paddlewheel speed. Unless you choose an STW source in Settings, STW is read **from sensors only**: updates that came in through a data connection (NMEA 0183, NMEA 2000), which carry a `source` object, and not STW published by another plugin, which does not. See [Running alongside other STW plugins](#running-alongside-other-stw-plugins).
+
+### Running alongside other STW plugins
+
+This plugin publishes STW too, so it must never correct another plugin's STW and hand the result back. Two correctors on `navigation.speedThroughWater` that each take any source but their own correct each other's output without end: STW, and true wind with it, run away. Signal K's own pattern for correction plugins (subscribe with `sourcePolicy: 'all'`, skip your own `$source`, publish on the same path) does not cover this case, because neither plugin ever sees its own source come back.
+
+- **By default it reads STW from sensors only**, so another corrector's output is ignored and no loop can form.
+- **Choosing a source in Settings overrides this**, including choosing another plugin, for a deliberate chain such as `signalk-stw-heel-correction` → this plugin with the STW correction here turned off. That plugin must then read only the paddlewheel (its own default from 0.3.0).
+- **Circuit breaker:** whatever the sources, the plugin never publishes a path more often than 20 Hz: an update less than 50 ms after the last one on that path is not published. A loop's next hop arrives within the same millisecond, so the chain ends at the first repeat instead of running away, and the server stays responsive. A backlog flushed after a dropout is thinned, not stopped. Nothing latches. While updates are being dropped the status and the Live page end with `Rate limited: N updates over 20 Hz not published in the last 10 s, driven by "…"`, naming the source. If it stays up, look for a loop with another STW plugin; a loop that is cut still leaves STW corrected twice.
+
+Only one plugin should correct STW. Otherwise the correction is applied twice even without a loop. In Shadow mode, note that `signalk-stw-heel-correction` also uses `navigation.speedThroughWaterCorrected` for its separate-path output, so the two would overwrite each other there.
 
 ### Outputs
 
@@ -86,7 +96,7 @@ Feed it **measured** apparent wind and **raw** paddlewheel speed. If another plu
 | Leeway (when on) | `navigation.leewayAngle` | `navigation.leewayAngleCorrected` |
 | Current | `environment.current` (`drift`, `setTrue`) | `environment.currentCorrected` |
 
-Everything is published under this plugin's own `$source`. Corrected STW goes out each time the paddlewheel reports, while the STW correction is on; the rest goes out with each apparent wind update. Shadow paths carry `meta` with units, since they are not in the Signal K schema.
+Everything is published under this plugin's own `$source`. Corrected STW goes out each time the paddlewheel reports, while the STW correction is on; the rest goes out with each apparent wind update. No path goes out more often than 20 Hz (see **Circuit breaker** under [Running alongside other STW plugins](#running-alongside-other-stw-plugins)). Shadow paths carry `meta` with units, since they are not in the Signal K schema.
 
 ## Modes
 
@@ -99,28 +109,28 @@ Everything is published under this plugin's own `$source`. Corrected STW goes ou
 
 Open **Webapps → Performance Processor**.
 
-- **Live**: the outputs next to their uncorrected values, what each step is doing right now, and which source and how fresh each input is.
-- **Calibration**: every correction in pipeline order with an on/off switch. Select one to edit its values, then **Save**. **Reset to defaults** puts back this boat's fitted values for that correction.
-- **Settings**: Shadow or Replace, the fallback magnetic variation, and which source to read for each input.
+- **Live**: the outputs next to their uncorrected values; the pipeline, with each step's result tagged **Published** (sent to Signal K) or **Working** (only feeds the next step); a **Published to Signal K** table listing every value sent and its path; and which source and how fresh each input is.
+- **Calibration**: every correction in pipeline order with an on/off switch. Select one to edit its values, then **Save**. Table headings (the breakpoints) are fixed; only the values are edited, and blank cells are allowed where a table says so. The boat speed table also has **Paste a table**, which reads the `signalk-stw-heel-correction` CSV format. **Reset to defaults** puts back this boat's values for that correction.
+- **Settings**: Shadow or Replace, the fallback magnetic variation, and which source to read for each input. **Any** takes every source; for STW the blank choice is **Auto (sensors only)**.
 
 All configuration lives in the webapp. It is saved to `config.json` in the plugin's data directory (under `~/.signalk/plugin-config-data/`), not in the admin **Plugin Config** form, which only points here; saving that form cannot overwrite the tables. Saving needs write access when Signal K security is on.
 
 ## Defaults for this boat
 
-Fitted to the 2025 race logs and checked on Jan–Mar 2026 races not used in fitting, by how little true wind direction and current jump through tacks, gybes and roundings.
+What a fresh install starts with. Every value can be changed in the webapp.
 
-- **STW:** linearity +0.58 kn at 0.5 kn falling to 0 at 8.5 kn (tapering to 0 below 0.5 kn); heel 0 to −0.29 kn at 30°. This is the owner's measured heel × STW table, reduced to two rows within 0.03 kn of every cell.
+- **STW:** the owner's measured heel × STW table, 15 heel rows (−35° to +35°) by 17 speed columns (0.5 to 8.5 kn), in knots added. Blank cells (corners the boat never sails in) are filled from the nearest value in their row; below 0.5 kn the correction tapers to zero. A table in the same CSV format as `signalk-stw-heel-correction` can be pasted straight into the webapp.
 - **Leeway:** K = 7.9446, one value for every sail.
-- **TWA table (°):**
+- **TWA table (°)**, from the owner's calibration fit (blank = too little data):
 
   | TWS (kn) | 5 | 10 | 15 | 20 | 25 | 30 |
   |---|---|---|---|---|---|---|
-  | Upwind | −12.0 | −13.4 | −5.7 | −4.3 | −4.3 | −4.3 |
-  | Reach | −10.7 | −10.7 | −10.7 | −10.7 | −10.7 | −10.7 |
-  | Downwind | −4.2 | −3.5 | −1.6 | −1.3 | −1.3 | −1.3 |
+  | Upwind | −7.6 | −12.6 | −5.8 | −5.7 | +0.2 | |
+  | Reach | −2.4 | −4.4 | −5.4 | +1.4 | +3.9 | +1.0 |
+  | Downwind | +1.2 | −3.5 | +1.0 | | | |
 
-  The reach row is provisional: it rests on roundings only.
-- **TWS table (%):** off. Downwind −11.1% at 15 kn and −14.4% from 20 kn; light air and upwind left at 0.
+  A blank TWA cell uses the measured cells either side, holding the nearest one at the ends: upwind at 30 kn uses +0.2, downwind from 20 kn uses +1.0.
+- **TWS table (kn):** off. Downwind −0.5, −1, −1.5, −2, −2.5, −3 (−10% of each column); upwind and reach blank, which in this table means no correction.
 - **Fallback variation:** 12.8° E, used only when nothing on the boat sends true heading or magnetic variation. The Live page shows which applies.
 
 ## Configuration file
@@ -129,15 +139,20 @@ Fitted to the 2025 race logs and checked on Jan–Mar 2026 races not used in fit
 
 ```json
 {
-  "schema": 1,
+  "schema": 2,
   "mode": "shadow",
   "variation": 12.8,
   "sources": { "apparentWind": "", "stw": "", "heading": "", "attitude": "", "gps": "", "variation": "" },
-  "corrections": { "stw": { … }, "leeway": { … }, "twa": { … }, "tws": { … } }
+  "corrections": {
+    "stw": { "enabled": true, "heel": [-35, …, 35], "stw": [0.5, …, 8.5], "add": [[…], …] },
+    "leeway": { "enabled": true, "k": 7.9446 },
+    "twa": { "enabled": true, "tws": [5, …, 30], "upwind": […], "reach": […], "downwind": […], "angles": { … } },
+    "tws": { "enabled": false, "tws": [5, …, 30], "upwind": […], "reach": […], "downwind": […] }
+  }
 }
 ```
 
-`schema` is the version of the file's shape. A release that changes the shape bumps `CONFIG_SCHEMA` in `lib/processor.js` and adds a migration from the previous version, so older files are upgraded as they load and nothing is reset. A file without `schema` (saved by 0.0.1) is read as schema 1. A file from a newer release is refused rather than guessed at, and is never overwritten by an older plugin.
+`schema` is the version of the file's shape. A release that changes the shape bumps `CONFIG_SCHEMA` in `lib/processor.js` and adds a migration from the previous version, so older files are upgraded as they load and nothing is reset. A file without `schema` (saved by 0.0.1) is read as schema 1. Schema 1 files (0.0.1–0.0.3) are upgraded to 2: their two STW rows become the grid they describe, and their TWS percentages become knots. Blank table cells are stored as `null`. A file from a newer release is refused rather than guessed at, and is never overwritten by an older plugin.
 
 ## Adding a correction
 

package/index.js

@@ -20,6 +20,12 @@ const MAX_PLAUSIBLE_HEEL_DEG = 90
 // See signalk-stw-heel-correction: below this a correction is float noise, and recording
 // it as an output would make the next identical raw sample look like an echo.
 const ECHO_MIN_DELTA_MS = 1e-6
+// Circuit breaker: no path is published more often than this (20 Hz). A feedback loop
+// through another plugin delivers its next update within the same millisecond, so the
+// chain ends at the first repeat rather than running away, and the server stays
+// responsive. Nothing latches; the status says while it is happening.
+const MIN_PUBLISH_INTERVAL_MS = 50
+const RATE_NOTE_MS = 10000 // how long a dropped update keeps the status flagged
 
 // Inputs, grouped the way they are chosen in Settings.
 const INPUTS = {
@@ -84,10 +90,38 @@ module.exports = function (app) {
     return s === plugin.id || s.startsWith(plugin.id + '.')
   }
 
+  // A plugin publishes with no source object, so the server gives its update only a
+  // $source. Data from a connection (NMEA 0183, NMEA 2000) always carries one.
+  const fromSensor = update => update.source != null && typeof update.source === 'object'
+
   // Backstop echo detector for the one path that is both input and output (STW in
   // replace mode): remember published values that differ from their input.
   const recentStw = []
   let loopWarned = false
+
+  // Rate limit (see MIN_PUBLISH_INTERVAL_MS): when each path was last published, and
+  // when updates were dropped recently, for the status.
+  let publishedAt = {}
+  let dropsAt = []
+  let dropFrom = ''
+  function recentDrops (now) {
+    while (dropsAt.length && now - dropsAt[0] > RATE_NOTE_MS) dropsAt.shift()
+    return dropsAt.length
+  }
+  function noteDrop (now, from) {
+    const first = !recentDrops(now)
+    dropsAt.push(now)
+    dropFrom = from
+    if (!first) return
+    app.error(`Rate limited: "${from}" is driving updates faster than ${1000 / MIN_PUBLISH_INTERVAL_MS} Hz. Is another plugin correcting this plugin's output?`)
+    lastStatus = statusText + rateNote(now) // flag it now, not at the next refresh
+    app.setPluginStatus(lastStatus)
+  }
+  function rateNote (now) {
+    const n = recentDrops(now)
+    return n ? ` · Rate limited: ${n} update${n === 1 ? '' : 's'} over ${1000 / MIN_PUBLISH_INTERVAL_MS} Hz not published in the last ${RATE_NOTE_MS / 1000} s, ` +
+      `driven by "${dropFrom}". Usually a feedback loop with another STW plugin: check the STW source in Settings` : ''
+  }
   function noteStw (ms) {
     recentStw.push(ms)
     if (recentStw.length > 32) recentStw.shift()
@@ -103,10 +137,13 @@ module.exports = function (app) {
   // live numbers in the status keep moving without flooding the admin UI.
   let statusAt = 0
   let statusKind = null
+  let statusText = ''
   function status (kind, text) {
     const now = Date.now()
     if (kind === statusKind && now - statusAt < STATUS_INTERVAL_MS) return
     statusKind = kind
+    statusText = text
+    text += rateNote(now)
     lastStatus = text
     statusAt = now
     app.setPluginStatus(text)
@@ -120,7 +157,15 @@ module.exports = function (app) {
     return Math.abs(h) > MAX_PLAUSIBLE_HEEL_DEG ? null : h
   }
 
-  function publish (values, timestamp) {
+  function publish (values, timestamp, from) {
+    const now = Date.now()
+    const kept = values.filter(v => {
+      if (now - (publishedAt[v.path] ?? -Infinity) < MIN_PUBLISH_INTERVAL_MS) return false
+      publishedAt[v.path] = now
+      return true
+    })
+    if (kept.length < values.length) noteDrop(now, from)
+    values = kept
     if (!values.length) return
     // No source object: the server stamps $source with plugin.id, which is what the
     // loop guard and the user's Source Priorities entry match on.
@@ -128,7 +173,7 @@ module.exports = function (app) {
   }
 
   // Corrected STW goes out as soon as the paddlewheel reports, at its own rate.
-  function onStw (rawMs, timestamp, now) {
+  function onStw (rawMs, timestamp, now, from) {
     const stw = config.corrections.stw
     if (!stw.enabled) return
     const stwKn = rawMs * MS_TO_KN
@@ -138,16 +183,21 @@ module.exports = function (app) {
     const { c } = correctInputs({ stw: stwKn, heel: heelDeg(now) }, config)
     const ms = c.stw / MS_TO_KN
     if (config.mode === 'replace' && Math.abs(ms - rawMs) > ECHO_MIN_DELTA_MS) noteStw(ms)
-    publish([{ path: outPath('stw'), value: ms }], timestamp)
+    publish([{ path: outPath('stw'), value: ms }], timestamp, from)
   }
 
   // True wind, current and leeway go out on every apparent wind update.
-  function onWind (timestamp, now) {
+  function onWind (timestamp, now, from) {
     const awa = fresh('environment.wind.angleApparent', now)
     const aws = fresh('environment.wind.speedApparent', now)
     const stw = fresh('navigation.speedThroughWater', now)
     if (awa == null || aws == null) return status('nowind', 'Waiting for apparent wind')
-    if (stw == null) return status('nostw', 'Waiting for speed through water — no true wind without it')
+    if (stw == null) {
+      const others = !config.sources.stw && sourcesSeen.stw ? Array.from(sourcesSeen.stw) : []
+      return status('nostw', others.length
+        ? `No speed through water from a sensor, only from ${others.join(', ')}. Choose the STW source in Settings`
+        : 'Waiting for speed through water — no true wind without it')
+    }
 
     const awsKn = aws * MS_TO_KN
     const stwKn = stw * MS_TO_KN
@@ -178,7 +228,7 @@ module.exports = function (app) {
     if (o.twd != null) values.push({ path: outPath('twd'), value: o.twd / RAD_TO_DEG })
     if (config.corrections.leeway.enabled) values.push({ path: outPath('leeway'), value: o.leeway / RAD_TO_DEG })
     if (o.current) values.push({ path: outPath('current'), value: { drift: o.current.drift / MS_TO_KN, setTrue: o.current.set / RAD_TO_DEG } })
-    publish(values, timestamp)
+    publish(values, timestamp, from)
 
     const missing = []
     if (input.heel == null) missing.push('heel')
@@ -191,6 +241,7 @@ module.exports = function (app) {
     const now = Date.now()
     let windChanged = false
     let windTimestamp = null
+    let windFrom = ''
     for (const update of (delta.updates || [])) {
       if (isOwnSource(update.$source)) continue
       for (const v of (update.values || [])) {
@@ -199,9 +250,14 @@ module.exports = function (app) {
         if (v.path !== 'navigation.attitude' && !Number.isFinite(v.value)) continue
 
         const src = String(update.$source || '')
+        const sensor = fromSensor(update)
         ;(sourcesSeen[group] = sourcesSeen[group] || new Set()).add(src)
         const wanted = config.sources[group]
         if (wanted && src !== wanted) continue
+        // Without a chosen source, STW is read from sensors only. Another plugin's STW
+        // is already corrected, and this plugin publishes STW too: taking each other's
+        // output, two correctors feed each other without end.
+        if (!wanted && group === 'stw' && !sensor) continue
 
         if (v.path === 'navigation.speedThroughWater' && config.mode === 'replace' && isStwEcho(v.value)) {
           if (!loopWarned) {
@@ -212,16 +268,18 @@ module.exports = function (app) {
         }
 
         latest[v.path] = { value: v.value, source: src, at: now }
-        if (group === 'apparentWind') { windChanged = true; windTimestamp = update.timestamp }
-        if (group === 'stw') onStw(v.value, update.timestamp, now)
+        if (group === 'apparentWind') { windChanged = true; windTimestamp = update.timestamp; windFrom = src }
+        if (group === 'stw') onStw(v.value, update.timestamp, now, src)
       }
     }
-    if (windChanged) onWind(windTimestamp, now)
+    if (windChanged) onWind(windTimestamp, now, windFrom)
   }
 
   function startWith (cfg) {
     stopEverything()
     config = cfg
+    publishedAt = {}
+    dropsAt = []
     latest = {}
     sourcesSeen = {}
     lastResult = null

package/lib/defaults.js

@@ -13,35 +13,53 @@ const DEFAULTS = {
   variation: 12.8,
   sources: { apparentWind: '', stw: '', heading: '', attitude: '', gps: '', variation: '' }, // '' = any but this plugin
   corrections: {
-    // Knots added to STW: linearity by speed, plus heel correction by |heel|.
-    // The 185-cell heel x STW table reduced to two rows (every cell within 0.03 kn).
     stw: {
       enabled: true,
-      linearity: { stw: [0.5, 1, 2, 3, 4, 6, 8.5], add: [0.58, 0.61, 0.38, 0.19, 0.09, 0.02, 0.00] },
-      heel: { heel: [0, 10, 20, 30, 35], add: [0.00, -0.03, -0.13, -0.29, -0.29] }
+      // Knots added to STW, by signed heel (rows, + = starboard side down) and STW (columns).
+      // The owner's measured heel x STW table; blank cells are filled from the nearest value.
+      heel: [-35, -30, -25, -20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35],
+      stw: [0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5],
+      add: [
+        [null, null, null, null, null, null, null, null, null, null, null, -0.276, -0.283, -0.287, -0.291, -0.293, -0.294],
+        [null, null, null, null, null, null, null, null, null, null, -0.266, -0.276, -0.283, -0.287, -0.291, -0.293, -0.294],
+        [null, null, null, null, null, null, null, null, -0.139, -0.16, -0.175, -0.185, -0.192, -0.197, -0.2, -0.202, -0.203],
+        [null, null, null, null, null, null, 0.009, -0.035, -0.065, -0.086, -0.101, -0.111, -0.118, -0.122, -0.126, -0.128, -0.129],
+        [0.536, 0.555, 0.442, 0.315, 0.208, 0.125, 0.065, 0.022, -0.008, -0.029, -0.043, -0.053, -0.06, -0.065, -0.068, -0.07, -0.071],
+        [0.552, 0.582, 0.474, 0.351, 0.246, 0.165, 0.105, 0.063, 0.033, 0.012, -0.002, -0.012, -0.019, -0.023, -0.026, -0.029, -0.03],
+        [0.562, 0.597, 0.493, 0.372, 0.268, 0.188, 0.129, 0.087, 0.057, 0.037, 0.022, 0.013, 0.006, 0.001, -0.002, -0.004, -0.005],
+        [0.565, 0.602, 0.5, 0.379, 0.276, 0.196, 0.137, 0.095, 0.065, 0.045, 0.031, 0.021, 0.014, 0.01, 0.007, 0.004, 0.003],
+        [0.562, 0.597, 0.494, 0.372, 0.269, 0.188, 0.129, 0.087, 0.057, 0.037, 0.023, 0.013, 0.006, 0.002, -0.001, -0.004, -0.005],
+        [0.552, 0.582, 0.475, 0.352, 0.246, 0.165, 0.106, 0.063, 0.034, 0.013, -0.001, -0.011, -0.018, -0.023, -0.026, -0.028, -0.029],
+        [0.536, 0.557, 0.444, 0.317, 0.21, 0.127, 0.067, 0.024, -0.006, -0.027, -0.042, -0.051, -0.058, -0.063, -0.066, -0.068, -0.069],
+        [null, null, null, null, null, null, 0.012, -0.031, -0.062, -0.083, -0.098, -0.108, -0.114, -0.119, -0.122, -0.124, -0.126],
+        [null, null, null, null, null, null, null, null, -0.133, -0.155, -0.17, -0.18, -0.187, -0.191, -0.194, -0.197, -0.198],
+        [null, null, null, null, null, null, null, null, null, null, -0.258, -0.268, -0.275, -0.28, -0.283, -0.285, -0.286],
+        [null, null, null, null, null, null, null, null, null, null, null, -0.268, -0.275, -0.28, -0.283, -0.285, -0.286]
+      ]
     },
     // Leeway (degrees) = K x heel / STW^2, one K for every sail: downwind heel is
     // small, so leeway there is near zero whatever K is.
     leeway: { enabled: true, k: 7.9446 },
-    // Degrees added to |TWA| by TWS; negative = TWA was reading too wide.
-    // Rows are blended by TWA: upwind in full to angles.upwind, reach at angles.reach,
-    // downwind from angles.downwind. The TWS table shares these angles.
+    // Degrees added to |TWA| by TWS; negative = TWA was reading too wide. From the
+    // owner's boatcal fit; blank = too little data, filled from the nearest measured
+    // cells in the row. Rows are blended by TWA: upwind in full to angles.upwind, reach
+    // at angles.reach, downwind from angles.downwind. The TWS table shares these angles.
     twa: {
       enabled: true,
       tws: TWS_BINS.slice(),
-      upwind: [-12.0, -13.4, -5.7, -4.3, -4.3, -4.3],
-      reach: [-10.7, -10.7, -10.7, -10.7, -10.7, -10.7],
-      downwind: [-4.2, -3.5, -1.6, -1.3, -1.3, -1.3],
+      upwind: [-7.6, -12.6, -5.8, -5.7, 0.2, null],
+      reach: [-2.4, -4.4, -5.4, 1.4, 3.9, 1.0],
+      downwind: [1.2, -3.5, 1.0, null, null, null],
       angles: { upwind: 70, reach: 100, downwind: 130 }
     },
-    // Percent applied to TWS by TWS, same rows and blending as the TWA table.
-    // Off by default: light air fitted to implausible values, so it is zeroed here.
+    // Knots added to TWS by TWS, same rows and blending as the TWA table (H5000 units).
+    // Downwind: -10% of each column. Blank = no correction. Off until switched on.
     tws: {
       enabled: false,
       tws: TWS_BINS.slice(),
-      upwind: [0, 0, 0, 0, 0, 0],
-      reach: [0, 0, 0, 0, 0, 0],
-      downwind: [0, 0, -11.1, -14.4, -14.4, -14.4]
+      upwind: [null, null, null, null, null, null],
+      reach: [null, null, null, null, null, null],
+      downwind: [-0.5, -1, -1.5, -2, -2.5, -3]
     }
   }
 }

package/lib/processor.js

@@ -43,11 +43,74 @@ function blendRows (absTwa, angles, up, reach, down) {
   return down
 }
 
+// Interpolate along a row whose blank cells (null) mean "not measured": use only the
+// measured cells, holding the nearest one beyond them. An all-blank row is zero.
+function interpRow (xs, ys, x) {
+  const kx = []; const ky = []
+  ys.forEach((y, i) => { if (y != null) { kx.push(xs[i]); ky.push(y) } })
+  return kx.length ? interp(kx, ky, x) : 0
+}
+
 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))
+    interpRow(table.tws, table.upwind, tws),
+    interpRow(table.tws, table.reach, tws),
+    interpRow(table.tws, table.downwind, tws))
+}
+
+// ---- heel x STW table ----------------------------------------------------------
+
+// A blank cell means "not measured", typically a corner of the grid the boat never
+// sails in. Extend the nearest value in its row into it rather than reading it as zero,
+// then fill an all-blank row from the nearest row with data. As signalk-stw-heel-correction.
+function fillGaps (grid) {
+  const table = grid.map(r => r.slice())
+  const cols = table[0].length
+  for (const row of table) {
+    let last = null
+    for (let j = 0; j < cols; j++) { if (row[j] != null) last = row[j]; else if (last != null) row[j] = last }
+    last = null
+    for (let j = cols - 1; j >= 0; j--) { if (row[j] != null) last = row[j]; else if (last != null) row[j] = last }
+  }
+  for (let i = 0; i < table.length; i++) {
+    if (table[i][0] != null) continue
+    for (let d = 1; d < table.length; d++) {
+      const src = (i - d >= 0 && table[i - d][0] != null) ? table[i - d] : (i + d < table.length && table[i + d][0] != null) ? table[i + d] : null
+      if (src) { table[i] = src.slice(); break }
+    }
+  }
+  return table
+}
+
+function bracket (bins, v) {
+  if (v <= bins[0]) return [0, 0, 0]
+  const n = bins.length - 1
+  if (v >= bins[n]) return [n, n, 0]
+  let i = 0
+  while (bins[i + 1] < v) i++
+  return [i, i + 1, (v - bins[i]) / (bins[i + 1] - bins[i])]
+}
+
+// The filled grid is worked out once per config object, not on every update.
+const filledCache = new WeakMap()
+function filledGrid (cfg) {
+  let f = filledCache.get(cfg)
+  if (!f) { f = fillGaps(cfg.add); filledCache.set(cfg, f) }
+  return f
+}
+
+// Bilinear in signed heel and STW, holding the edge values beyond the grid. Below the
+// first STW column the correction tapers to zero at 0 kn, so a stopped boat is not
+// given speed.
+function stwGridLookup (cfg, heel, stw) {
+  const t = filledGrid(cfg)
+  const s0 = cfg.stw[0]
+  const at = s => {
+    const [h0, h1, ht] = bracket(cfg.heel, heel)
+    const [j0, j1, st] = bracket(cfg.stw, s)
+    return t[h0][j0] * (1 - ht) * (1 - st) + t[h0][j1] * (1 - ht) * st + t[h1][j0] * ht * (1 - st) + t[h1][j1] * ht * st
+  }
+  return stw < s0 ? at(s0) * Math.max(0, stw) / s0 : at(stw)
 }
 
 const fmt = (v, d = 1) => (v > 0 ? '+' : '') + v.toFixed(d)
@@ -55,27 +118,23 @@ const fmt = (v, d = 1) => (v > 0 ? '+' : '') + v.toFixed(d)
 const CORRECTIONS = [
   {
     id: 'stw',
+    produces: ['stw'], // quantities this step's result replaces
     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 add = stwGridLookup(cfg, c.heel == null ? 0 : c.heel, c.stw)
       const before = c.stw
-      c.stw = Math.max(0, c.stw + add1 + add2)
+      c.stw = Math.max(0, c.stw + add)
       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)' : ''),
+        input: `${before.toFixed(2)} kn` + (c.heel == null ? ' · no heel data, upright row used' : ` · heel ${c.heel.toFixed(0)}°`),
+        detail: `${fmt(add, 2)} kn from the heel × STW table`,
         output: `${c.stw.toFixed(2)} kn`
       }
     }
   },
   {
     id: 'leeway',
+    produces: ['leeway'], // quantities this step's result replaces
     stage: 'input',
     name: 'Leeway',
     apply (c, cfg) {
@@ -93,6 +152,7 @@ const CORRECTIONS = [
   },
   {
     id: 'twa',
+    produces: ['twa'], // quantities this step's result replaces
     stage: 'trueWind',
     name: 'TWA table',
     apply (c, cfg) {
@@ -109,15 +169,19 @@ const CORRECTIONS = [
   },
   {
     id: 'tws',
+    produces: ['tws'], // quantities this step's result replaces
     stage: 'trueWind',
     name: 'TWS table',
     apply (c, cfg, all) {
-      const pct = tableLookup(cfg, all.corrections.twa.angles, Math.abs(c.twa), c.tws)
+      // Blank cells mean no correction there.
+      const z = row => row.map(v => v == null ? 0 : v)
+      const kn = tableLookup({ tws: cfg.tws, upwind: z(cfg.upwind), reach: z(cfg.reach), downwind: z(cfg.downwind) },
+        all.corrections.twa.angles, Math.abs(c.twa), c.tws)
       const before = c.tws
-      c.tws = c.tws * (1 + pct / 100)
+      c.tws = Math.max(0, c.tws + kn)
       return {
         input: `TWS ${before.toFixed(1)} kn`,
-        detail: `${fmt(pct)}%`,
+        detail: `${fmt(kn, 2)} kn`,
         output: `TWS ${c.tws.toFixed(1)} kn`
       }
     }
@@ -128,11 +192,11 @@ 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 })
+      steps.push({ id: corr.id, name: corr.name, produces: corr.produces, enabled: false })
       continue
     }
     const r = corr.apply(c, cfg, config)
-    steps.push({ id: corr.id, name: corr.name, enabled: true, ...r })
+    steps.push({ id: corr.id, name: corr.name, produces: corr.produces, enabled: true, ...r })
   }
 }
 
@@ -160,7 +224,8 @@ function process (input, config) {
   c.tws = Math.hypot(x, y)
   steps.push({
     id: 'truewind',
-    name: 'True wind',
+    produces: ['twa', 'tws'],
+    name: 'True wind, before tables',
     enabled: true,
     input: `AWA ${Math.abs(input.awa).toFixed(1)}° · ${input.aws.toFixed(1)} kn`,
     detail: 'apparent wind − boat velocity',
@@ -196,6 +261,7 @@ function process (input, config) {
       out.current = { drift: Math.hypot(e, n), set: norm360(deg(Math.atan2(e, n))) }
       steps.push({
         id: 'current',
+        produces: ['current'],
         name: 'Current',
         enabled: true,
         input: `SOG ${input.sog.toFixed(1)} · COG ${input.cog.toFixed(0)}°`,
@@ -234,9 +300,10 @@ function checkAxis (errors, label, xs) {
   }
 }
 
-function checkRow (errors, label, ys, n) {
+function checkRow (errors, label, ys, n, blanksAllowed) {
   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`)
+  const ok = v => (blanksAllowed && v === null) || (typeof v === 'number' && Number.isFinite(v))
+  if (!ys.every(ok)) errors.push(`${label}: every value must be a number${blanksAllowed ? ' or blank' : ''}`)
 }
 
 function checkNumber (errors, label, v) {
@@ -250,11 +317,32 @@ function checkNumber (errors, label, v) {
 // config of schema `old` into schema `old + 1`. Older files are then upgraded step by
 // step as they load and saved back in the current shape; nothing is lost or reset.
 //
-// Schema 1 (0.0.1): mode, variation, sources, corrections { stw, leeway, twa, tws }.
+// Schema 1 (0.0.1–0.0.3): mode, variation, sources, corrections { stw, leeway, twa, tws },
+//   with stw as two rows: linearity { stw, add } and heel { heel, add } by |heel|.
+// Schema 2 (0.0.4): stw is one grid { heel (signed), stw, add[heel][stw] }, blanks allowed;
+//   the TWS table is in knots (was percent); both wind tables allow blanks.
 
-const CONFIG_SCHEMA = 1
+const CONFIG_SCHEMA = 2
 const MIGRATIONS = {
-  // 1: cfg => ({ ...cfg, schema: 2, ... }),
+  // Two rows become the grid they describe: signed heel rows mirrored from the |heel|
+  // row, the linearity speeds as columns, each cell linearity + heel.
+  1: cfg => {
+    cfg = clone(cfg)
+    const t = cfg.corrections && cfg.corrections.tws
+    if (t && Array.isArray(t.tws)) {
+      // percent of TWS -> knots at each column
+      for (const r of ['upwind', 'reach', 'downwind']) {
+        if (Array.isArray(t[r])) t[r] = t[r].map((v, j) => typeof v === 'number' ? +(v / 100 * t.tws[j]).toFixed(3) : v)
+      }
+    }
+    const old = cfg.corrections && cfg.corrections.stw
+    if (!old || !old.linearity || !old.heel) return cfg
+    const ah = old.heel.heel
+    const heel = Array.from(new Set(ah.map(h => -h).concat(ah))).sort((x, y) => x - y)
+    const stwBins = old.linearity.stw
+    const add = heel.map(h => stwBins.map((_, j) => +(old.linearity.add[j] + interp(ah, old.heel.add, Math.abs(h))).toFixed(4)))
+    return { ...cfg, corrections: { ...cfg.corrections, stw: { enabled: old.enabled, heel, stw: stwBins, add } } }
+  }
 }
 
 // Bring a raw config up to the current schema. A config without `schema` predates the
@@ -295,11 +383,19 @@ function normalizeConfig (input) {
   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')
+  checkAxis(errors, 'STW table heel angles', k.stw.heel)
+  checkAxis(errors, 'STW table speeds', k.stw.stw)
+  if (Array.isArray(k.stw.stw) && !(k.stw.stw[0] > 0)) errors.push('STW table speeds: must start above 0 kn')
+  const g = k.stw.add
+  if (!Array.isArray(g) || !Array.isArray(k.stw.heel) || g.length !== k.stw.heel.length) {
+    errors.push('STW table: needs one row per heel angle')
+  } else if (g.some(r => !Array.isArray(r) || r.length !== (k.stw.stw || []).length)) {
+    errors.push('STW table: every row needs one value per speed')
+  } else if (g.some(r => r.some(v => v !== null && (typeof v !== 'number' || !Number.isFinite(v))))) {
+    errors.push('STW table: every value must be a number or blank')
+  } else if (!g.some(r => r.some(v => v !== null))) {
+    errors.push('STW table: has no values at all')
+  }
 
   checkNumber(errors, 'Leeway K', k.leeway.k)
 
@@ -307,7 +403,7 @@ function normalizeConfig (input) {
     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)
+    for (const row of ['upwind', 'reach', 'downwind']) checkRow(errors, `${name} ${row} row`, t[row], (t.tws || []).length, true)
   }
   const ang = k.twa.angles
   ;['upwind', 'reach', 'downwind'].forEach(r => checkNumber(errors, `TWA table ${r} angle`, ang[r]))
@@ -327,5 +423,5 @@ module.exports = {
   normalizeConfig,
   CORRECTIONS,
   CONFIG_SCHEMA,
-  _internals: { interp, blendRows, tableLookup, merge, norm180, migrate }
+  _internals: { interp, interpRow, blendRows, tableLookup, merge, norm180, migrate, fillGaps, stwGridLookup }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-performance-processor",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "True wind direction that holds steady through tacks and gybes. H5000-style calibration in Signal K: boat speed, leeway, and TWA/TWS tables by wind speed, edited and watched live in a webapp. Try it in shadow mode beside your existing instruments.",
   "main": "index.js",
   "scripts": {

package/public/app.js

@@ -8,10 +8,10 @@
   // 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.' },
+    stw: { name: 'Boat speed (STW)', what: 'Knots added to the paddlewheel by heel (rows, + = starboard side down) and speed (columns), like the H5000 boat speed / heel table. Blank cells are filled from the nearest value in their row. Applied before anything else uses STW.' },
     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.' }
+    tws: { name: 'TWS table', what: 'Knots added to TWS by TWS, upwind, reaching and downwind, H5000 style. Blended at the TWA table’s angles. Blank = no correction. The default downwind row is −10% of each column.' }
   }
 
   const SOURCE_LABELS = {
@@ -119,8 +119,9 @@
     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)
+      // A blank cell in a table that allows it means "not measured"; elsewhere keep the
+      // old value until something is typed.
+      if (el.value === '') { if (!el.dataset.nullable) return; value = null } else value = Number(el.value)
     } else value = el.value
     setPath(el.dataset.path, value)
     renderSaveBar()
@@ -186,7 +187,7 @@
 
     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>`
+      $('steps').innerHTML = `<tr><td colspan="5" 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)
@@ -199,10 +200,23 @@
         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('')
+      // A step's result is published only if no later enabled step replaces it; otherwise
+      // it is a working value that only feeds the steps after it.
+      const last = {}
+      r.steps.forEach((s, i) => { if (s.enabled && !s.skipped) (s.produces || []).forEach(q => { last[q] = i }) })
+      const NAMES = { stw: 'STW', leeway: 'Leeway', twa: 'TWA', tws: 'TWS', current: 'Current' }
+      $('steps').innerHTML = r.steps.map((s, i) => {
+        if (!s.enabled) return `<tr class="off"><th scope="row">${esc(s.name)}</th><td></td><td>off</td><td></td><td></td></tr>`
+        const sent = (s.produces || []).filter(q => last[q] === i)
+        const working = (s.produces || []).filter(q => last[q] !== i)
+        const tag = s.skipped ? '' : [
+          sent.length ? `<span class="chip pub">Published: ${sent.map(q => NAMES[q]).join(', ')}</span>` : '',
+          working.length ? `<span class="chip work">Working: ${working.map(q => NAMES[q]).join(', ')}</span>` : ''
+        ].join(' ')
+        return `<tr class="${sent.length ? '' : 'working'}"><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 result">${esc(s.output || '')}</td><td>${tag}</td></tr>`
+      }).join('')
+      renderPublished(o, live.outputPaths || {})
     }
 
     const inputs = live ? Object.entries(live.inputs) : []
@@ -211,6 +225,22 @@
       : '<tr><td colspan="3" class="muted center">Nothing received yet</td></tr>'
   }
 
+  // The values the plugin actually sends, one per path, matching what index.js publishes.
+  function renderPublished (o, paths) {
+    const on = id => !!(state.saved && state.saved.corrections[id] && state.saved.corrections[id].enabled)
+    const side = v => v < 0 ? 'port' : 'stbd'
+    const rows = [
+      ['TWA', `${fmt(Math.abs(o.twa))}° ${side(o.twa)}`, paths.twa],
+      ['TWS', `${fmt(o.tws)} kn`, paths.tws]
+    ]
+    if (o.twd != null) rows.push(['TWD', `${fmt(o.twd, 0)}° T`, paths.twd])
+    if (on('stw')) rows.push(['STW', `${fmt(o.stw, 2)} kn`, paths.stw])
+    if (on('leeway')) rows.push(['Leeway', `${fmt(Math.abs(o.leeway))}° ${side(o.leeway)}`, paths.leeway])
+    if (o.current) rows.push(['Current', `${fmt(o.current.drift, 2)} kn → ${fmt(o.current.set, 0)}°`, paths.current])
+    $('published').innerHTML = rows.map(([label, value, p]) =>
+      `<tr><th scope="row">${esc(label)}</th><td class="num">${esc(value)}</td><td class="mono">${esc(p || '')}</td></tr>`).join('')
+  }
+
   // -- Calibration
 
   function correctionIds () {
@@ -236,13 +266,16 @@
     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)
+      body = grid2d('Knots added to STW', 'Heel ° ╲ STW kn', 'corrections.stw', c) +
+        `<details class="paste"><summary>Paste a table</summary>` +
+        `<p class="muted sub">Same format as signalk-stw-heel-correction: first row <code>heel\\stw</code> then the speeds; each further row a heel angle then its corrections. Commas, tabs or semicolons; blank cells allowed.</p>` +
+        `<textarea id="pasteStw" rows="8" spellcheck="false" aria-label="Heel by STW table to paste"></textarea>` +
+        `<div><button type="button" class="ghost" id="pasteStwGo">Replace the table</button> <span id="pasteStwMsg" class="warn"></span></div></details>`
     } 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)
+      body = grid(id === 'twa' ? 'Degrees added to |TWA| (blank = not enough data: nearest measured value used)' : 'Knots added to TWS (blank = no correction)', 'TWS kn', `corrections.${id}`, 'tws', rows, c, true)
       if (id === 'twa') {
         const a = c.angles
         body += `<div class="fields">${field('Upwind row to (° TWA)', 'corrections.twa.angles.upwind', a.upwind, 1)}` +
@@ -256,16 +289,47 @@
       `<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) {
+  // A table whose header row is its fixed axis (the breakpoints, shown as labels) and
+  // whose other rows are the editable correction values.
+  function grid (title, axisLabel, base, axisKey, rows, obj, nullable) {
     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>`
+    const cell = (path, v, name) => `<td><input type="number" step="any"${nullable ? ' data-nullable="1"' : ''} data-path="${esc(path)}" value="${v == null ? '' : esc(v)}" aria-label="${esc(name)}"></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('') +
+      `<tr><th scope="row" class="muted">${esc(axisLabel)}</th>${axis.map(v => `<th scope="col" class="axis">${esc(v)}</th>`).join('')}</tr>` +
+      rows.map(([label, key]) => `<tr><th scope="row">${esc(label)}</th>${obj[key].map((v, i) => cell(`${base}.${key}.${i}`, v, `${label} at ${axis[i]}`)).join('')}</tr>`).join('') +
       '</table></div></div>'
   }
 
+  // A two-dimensional table: fixed row and column headings, editable cells, and blank
+  // cells allowed (null = not measured).
+  function grid2d (title, corner, base, t) {
+    const head = `<tr><th scope="col" class="muted">${esc(corner)}</th>${t.stw.map(v => `<th scope="col" class="axis">${esc(v)}</th>`).join('')}</tr>`
+    const rows = t.heel.map((h, i) => `<tr><th scope="row" class="axis">${esc(h)}</th>` +
+      t.add[i].map((v, j) => `<td><input type="number" step="any" data-nullable="1" data-path="${base}.add.${i}.${j}" value="${v == null ? '' : esc(v)}" aria-label="heel ${esc(h)} at ${esc(t.stw[j])} kn"></td>`).join('') + '</tr>')
+    return `<div><h2>${esc(title)}</h2><div class="table-wrap"><table class="grid">${head}${rows.join('')}</table></div></div>`
+  }
+
+  // Read a pasted heel x STW table: header row of speeds, then a heel angle and its
+  // corrections per row. Tolerates the usual spreadsheet damage.
+  function parseStwTable (text) {
+    const clean = c => c.trim().replace(/^"(.*)"$/, '$1').replace(/\u2212/g, '-').replace(/\u00b0/g, '').trim()
+    const lines = text.replace(/^\ufeff/, '').trim().split(/\r?\n/).filter(l => l.trim())
+    if (lines.length < 2) throw new Error('needs a header row of speeds and at least one heel row')
+    const sep = lines[0].includes(',') ? ',' : lines[0].includes('\t') ? '\t' : ';'
+    const rows = lines.map(l => l.split(sep).map(clean))
+    const num = (c, what) => { const n = Number(c); if (c === '' || !Number.isFinite(n)) throw new Error(`${what} is not a number: "${c}"`); return n }
+    let stw = rows[0].slice(1).map((c, j) => num(c, `speed ${j + 1} in the header`))
+    let heel = []; let add = []
+    rows.slice(1).forEach((r, i) => {
+      if (r.length - 1 !== stw.length) throw new Error(`row ${i + 2} has ${r.length - 1} values, the header has ${stw.length} speeds`)
+      heel.push(num(r[0], `heel in row ${i + 2}`))
+      add.push(r.slice(1).map((c, j) => c === '' ? null : num(c, `value at heel ${r[0]}, ${stw[j]} kn`)))
+    })
+    if (stw.length > 1 && stw[0] > stw[stw.length - 1]) { stw = stw.reverse(); add = add.map(r => r.reverse()) }
+    if (heel.length > 1 && heel[0] > heel[heel.length - 1]) { heel = heel.reverse(); add = add.reverse() }
+    return { heel, stw, add }
+  }
+
   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>`
   }
@@ -293,7 +357,7 @@
       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>` +
+        `<option value="">${key === 'stw' ? 'Auto (sensors only)' : '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('')
@@ -317,6 +381,15 @@
   document.addEventListener('click', e => {
     const sel = e.target.closest('[data-select]')
     if (sel) { state.selected = sel.dataset.select; renderCalibration() }
+    if (e.target.id === 'pasteStwGo') {
+      try {
+        const t = parseStwTable($('pasteStw').value)
+        Object.assign(state.draft.corrections.stw, t)
+        renderAll()
+      } catch (err) {
+        $('pasteStwMsg').textContent = err.message
+      }
+    }
     const def = e.target.closest('[data-defaults]')
     if (def && state.defaults) {
       const id = def.dataset.defaults

package/public/index.html

@@ -35,10 +35,20 @@
       <div id="tiles" class="tiles"></div>
       <div class="panel">
         <div class="panel-head"><h2>Pipeline</h2><span id="liveAge" class="muted sub"></span></div>
+        <p class="muted sub intro">Each step works on the result of the one before. Only results marked <b>Published</b> are sent to Signal K; <b>Working</b> results feed the next step and go nowhere else.</p>
         <div class="table-wrap">
           <table>
-            <thead><tr><th>Step</th><th>In</th><th>Correction</th><th>Out</th></tr></thead>
-            <tbody id="steps"><tr><td colspan="4" class="muted center">Waiting for data…</td></tr></tbody>
+            <thead><tr><th>Step</th><th>In</th><th>Correction</th><th>Result</th><th>Sent to Signal K</th></tr></thead>
+            <tbody id="steps"><tr><td colspan="5" class="muted center">Waiting for data…</td></tr></tbody>
+          </table>
+        </div>
+      </div>
+      <div class="panel">
+        <div class="panel-head"><h2>Published to Signal K</h2><span class="muted sub">only these values are sent; the pipeline above shows the working</span></div>
+        <div class="table-wrap">
+          <table>
+            <thead><tr><th>Value</th><th class="num">Now</th><th>Path</th></tr></thead>
+            <tbody id="published"><tr><td colspan="3" class="muted center">Nothing published yet</td></tr></tbody>
           </table>
         </div>
       </div>

package/public/style.css

@@ -104,6 +104,11 @@ table { width: 100%; border-collapse: collapse; }
 th, td { padding: 8px; border-bottom: 1px solid var(--line); white-space: nowrap; text-align: left; }
 th { font-size: 0.75em; color: var(--muted); text-transform: uppercase; }
 tr.off td { color: var(--muted); }
+/* Pipeline: published results stand out, working values recede */
+.chip { display: inline-block; font-size: 0.7em; font-weight: 700; padding: 2px 8px; border-radius: 999px; white-space: nowrap; }
+.chip.pub { background: var(--active); color: var(--accent); border: 1px solid var(--accent); }
+.chip.work { color: var(--muted); border: 1px dashed var(--line); }
+tr.working .result { color: var(--muted); font-style: italic; }
 td.mono { font-variant-numeric: tabular-nums; }
 
 /* Calibration */
@@ -153,12 +158,16 @@ td.mono { font-variant-numeric: tabular-nums; }
 .grid th, .grid td { border: 0; padding: 0; }
 .grid th { padding: 0 6px; }
 .grid input { width: 4.6em; text-align: right; font-variant-numeric: tabular-nums; background: var(--cell); }
-.grid input.axis { background: var(--bg); color: var(--muted); }
+.grid th.axis { text-align: right; padding: 0 10px 2px; font-size: 0.8em; font-weight: 600; color: var(--muted); font-variant-numeric: tabular-nums; }
 .grid input:focus, .field input:focus { outline: 2px solid var(--accent); outline-offset: 0; }
 .fields { display: flex; flex-wrap: wrap; gap: 16px; }
 .field { display: flex; flex-direction: column; gap: 4px; font-size: 0.8em; font-weight: 600; }
 .field input { width: 7em; }
 
+.paste summary { cursor: pointer; font-size: 0.85em; color: var(--accent); min-height: 32px; }
+.paste textarea { width: 100%; font: 0.8em ui-monospace, monospace; background: var(--bg); color: var(--fg); border: 1px solid var(--line); border-radius: 6px; padding: 8px; }
+.paste code { font-size: 0.95em; }
+
 /* Settings */
 .modes { border: 0; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 8px; }
 .mode { display: flex; gap: 12px; align-items: flex-start; padding: 10px; border: 1px solid var(--line); border-radius: 8px; cursor: pointer; }