signalk-performance-processor 0.0.2 → 0.0.4

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 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.
+
+- Fix: the Calibration and Settings pages were empty on a real server. The plugin's `/config` endpoint was shadowed by the server's own route of that name; it is now `/calibration`, and the webapp says so if the calibration cannot be loaded.
+- README and App Store description explain the problem this solves, who it is for, and the results on the boat it was built for.
+
 ## 0.0.2 — 2026-10-29
 
 Still a proof of concept: run it in Shadow mode alongside your instruments.

package/README.md

@@ -2,13 +2,51 @@
 
 # signalk-performance-processor
 
-> **Proof of concept (0.0.2).** Run it in Shadow mode alongside your instruments and compare before relying on it.
+**True wind direction that holds steady when you tack.**
 
-Signal K plugin and webapp that does the calibration job of an instrument processor such as a B&G H5000: it corrects boat speed and leeway, works out true wind from apparent wind, applies H5000-style TWA and TWS correction tables, and publishes true wind and current.
+If your TWD swings 5–10° every time you tack or gybe, the wind hasn't shifted: your true wind calibration is off. It makes real shifts hard to call, puts laylines in the wrong place, and feeds bad numbers into your polars and targets.
 
-Each correction can be switched on or off and edited in the webapp. A fresh install starts with values fitted to this boat's 2025 race logs.
+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.
 
-See the [changelog](CHANGELOG.md) for what changed in each release.
+> **Proof of concept (0.0.4).** Compare it against your instruments in Shadow mode before relying on it. See the [changelog](CHANGELOG.md).
+
+## Why it exists
+
+True wind is worked out from apparent wind, boat speed and heading, so it inherits every error in them. The masthead sensor reads a bent airflow upwind, the paddlewheel misreads when heeled, and the boat slides sideways. None of these is the same on every point of sail, and some flip from one tack to the other. That is why an uncalibrated TWD jumps through every tack.
+
+Instrument processors fix this with calibration tables, but:
+
+- **The tables are locked in the box.** You edit them through display menus, cannot see what each one is doing at any moment, and keep no history of what you changed or why.
+- **Older and simpler systems have less to work with.** An H2000, for example, has a TWS correction that only applies downwind, and many systems have no tables at all.
+- **Formula-based corrections don't fit every boat.** A single upwash formula cannot follow a boat whose correction is twice as big in light air as in a breeze at the same apparent wind angle. That was the case on the boat this was built for; a table can follow it.
+
+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:** 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 (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 |
+|---|---|---|---|
+| Tacks (41) | 6.2° | 2.5° | 2.2° |
+| Gybes (5) | 2.4° | 4.7° | 1.1° |
+| Roundings (38) | 9.3° | 9.7° | 7.3° |
+| Current step through manoeuvres | 0.65 kn | 0.65 kn | 0.37 kn |
+
+These figures are one boat's, and the defaults are that boat's. On a different boat, start from the defaults in Shadow mode and refit. After the boat's own rig and log changes in late 2026, the defaults needed refitting too.
+
+## Who it's for
+
+- **Racing sailors running Signal K** who want TWD they can call shifts on, and polars built on corrected wind.
+- **Boats with an older or limited instrument processor,** or none, that still have apparent wind, a paddlewheel, heading and heel on the network.
+- **Anyone who wants to see and log** what their wind calibration is doing, rather than trust a box.
+
+You need apparent wind, boat speed through the water and heading in Signal K. Heel (`navigation.attitude`) enables the heel and leeway corrections; SOG and COG enable current.
 
 ## What it does
 
@@ -16,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
@@ -61,28 +99,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.
+- **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.
 
 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
@@ -91,15 +129,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
 
@@ -109,8 +152,8 @@ Corrections live in `lib/processor.js` as entries in `CORRECTIONS`, each with a
 
 Under `/plugins/signalk-performance-processor`:
 
-- `GET /config` returns the configuration in use and the defaults.
-- `PUT /config` validates, saves and restarts with a new configuration. It returns 400 with the reasons if the configuration is invalid.
+- `GET /calibration` returns the configuration in use and the defaults.
+- `PUT /calibration` validates, saves and restarts with a new configuration. It returns 400 with the reasons if the configuration is invalid.
 - `GET /live` returns the latest result, each step, input ages and the sources seen.
 
 ## Development

package/index.js

@@ -48,7 +48,7 @@ module.exports = function (app) {
   const plugin = {
     id: 'signalk-performance-processor',
     name: 'gh - Performance Processor',
-    description: 'H5000-style calibration: corrects STW and leeway, then true wind angle and speed, and publishes true wind and current'
+    description: 'Steady true wind through tacks and gybes: H5000-style calibration of boat speed, leeway and TWA/TWS, configured in the Performance Processor webapp'
   }
 
   let config = null
@@ -356,12 +356,14 @@ module.exports = function (app) {
   }
 
   plugin.registerWithRouter = function (router) {
-    router.get('/config', (req, res) => {
+    // Not /config: the server registers GET and POST /config on every plugin's router
+    // for its own options, ahead of the plugin's routes, so ours would never be reached.
+    router.get('/calibration', (req, res) => {
       res.set('Cache-Control', 'no-store')
       res.json({ config: config || normalizeConfig(loadStored()).config, defaults: DEFAULTS })
     })
 
-    router.put('/config', async (req, res) => {
+    router.put('/calibration', async (req, res) => {
       let body
       try { body = await readBody(req) } catch (e) { return res.status(400).json({ errors: ['body is not valid JSON'] }) }
       const { config: cfg, errors } = normalizeConfig(body)

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,7 +1,7 @@
 {
   "name": "signalk-performance-processor",
-  "version": "0.0.2",
-  "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.",
+  "version": "0.0.4",
+  "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": {
     "test": "node --test",

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 = {
@@ -50,14 +50,16 @@
 
   async function loadConfig () {
     try {
-      const body = await getJson('/config')
+      const body = await getJson('/calibration')
+      if (!body || !body.config || !body.config.corrections) throw new Error('the plugin returned no calibration')
       state.saved = body.config
       state.draft = clone(body.config)
       state.defaults = body.defaults
-      $('conn').hidden = true
+      state.configError = null
     } catch (e) {
-      $('conn').textContent = `Cannot reach the plugin (${e.message}). Is Performance Processor enabled?`
-      $('conn').hidden = false
+      // Kept until a load succeeds: the live poll must not clear it.
+      state.configError = `Could not load the calibration (${e.message}). Is Performance Processor enabled and up to date?`
+      setTimeout(loadConfig, 5000)
     }
     renderAll()
   }
@@ -80,7 +82,7 @@
     state.saving = true
     renderSaveBar()
     try {
-      const res = await fetch(API + '/config', {
+      const res = await fetch(API + '/calibration', {
         method: 'PUT',
         credentials: 'include',
         headers: { 'Content-Type': 'application/json' },
@@ -117,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()
@@ -138,6 +141,8 @@
   }
 
   function renderHeader () {
+    $('cfgError').textContent = state.configError || ''
+    $('cfgError').hidden = !state.configError
     const mode = state.saved ? state.saved.mode : null
     const badge = $('mode')
     badge.textContent = mode === 'replace' ? 'Replace' : mode === 'shadow' ? 'Shadow' : '--'
@@ -182,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)
@@ -195,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) : []
@@ -207,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 () {
@@ -232,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)}` +
@@ -252,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>`
   }
@@ -313,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

@@ -20,6 +20,7 @@
     </nav>
     <div id="status" class="muted status"></div>
     <div id="conn" class="warn" hidden></div>
+    <div id="cfgError" class="warn" hidden></div>
   </header>
 
   <div id="saveBar" class="save-bar" hidden>
@@ -34,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; }