signalk-performance-processor 0.0.3 → 0.0.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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.

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.4).** 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
@@ -99,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
@@ -129,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
 

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.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": {

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>`
   }
@@ -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; }