speedandcurrent 1.7.3 → 1.7.6

package/README.md

@@ -32,7 +32,7 @@ After the initial ~60 second stabilization period the plugin starts sending the
 | Water current set (direction) | self.environment.current.setTrue | rad | True direction (set) the current flows toward. |
 
 Boat speed overwrite / duplication behavior:
-- When the setting "Prevent duplication of boat speed" = true (default): plugin overwrites navigation.speedThroughWater with corrected value.
+- When the setting "Prevent speed duplication" = true (default): plugin overwrites navigation.speedThroughWater with corrected value.
 - When false: both raw and corrected updates exist under navigation.speedThroughWater with distinct source attributes (viewable in deltas / data browser) allowing comparison.
 
 Current vector representation: Published as polar (drift + set). Set angle is the direction the water moves toward (oceanographic convention). Verify tooling expectations if it assumes FROM direction.
@@ -60,7 +60,7 @@ All settings are managed from the plugin webapp. The Signal K admin UI is not us
 | Show Statistics | Off | Displays σ (standard deviation) next to smoothed values. | Enable for debugging or to inspect signal quality. |
 
 ### Smoother
-Controls how raw sensor signals are smoothed before being fed into the correction and learning calculations. The smoother type and its parameter apply to heading, boat speed, ground speed, and attitude.
+Controls how raw sensor signals are smoothed before being fed into the learning calculations. The smoother type and its parameter apply to heading, boat speed, ground speed, and attitude.
 
 | Setting | Default | Description |
 |---------|---------|-------------|
@@ -93,8 +93,8 @@ Leave a source blank or set to *(any)* to accept values from all sources. If mul
 ### Output Behavior
 | Setting | Default | Description | Notes |
 |---------|---------|-------------|-------|
-| Prevent duplication of boat speed | On | Overwrites navigation.speedThroughWater with corrected value. | Disable to compare raw vs corrected via distinct source attributes under the same path. |
-| SOG fallback | Off | Copy navigation.speedOverGround (GPS) to navigation.speedThroughWater (Paddle wheel) if paddle wheel malfunction is detected. |  SOG fallback activates when navigation.speedThroughWater = 0 and navigation.speedOverGround > treshold.|
+| Prevent speed duplication | On | Overwrites navigation.speedThroughWater with corrected value. | Disable to compare raw vs corrected via distinct source attributes under the same path. |
+| Groundspeed fallback | Off | Copy navigation.speedOverGround (GPS) to navigation.speedThroughWater (Paddle wheel) if paddle wheel malfunction is detected. | Activates when navigation.speedThroughWater = 0 and navigation.speedOverGround > threshold. |
 
 ### Tips
 1. Be patient with the correction table. Its corrections will improve over time.
@@ -116,7 +116,7 @@ The "Assume Current" option is experimental. It works best on a stable correctio
 ## WebApp Usage Guide
 Open via Signal K Server: Apps → Speed and current.
 
-The webapp has a collapsible sidebar with four sections, and a status message in the top-right of the nav bar (blue = stabilizing, amber = SOG fallback active, red = error or stopped).
+The webapp has a collapsible sidebar with four sections, and a status message in the top-right of the nav bar (blue = stabilizing, amber = SOG fallback active, red = error or stopped). All settings changes take effect immediately — no plugin restart required.
 
 ### Inputs
 The **Inputs** section contains two sub-sections:
@@ -125,17 +125,16 @@ The **Inputs** section contains two sub-sections:
 
 ### Boatspeed Estimation
 The **Boatspeed Estimation** section has an On/Off toggle at the top of the card and contains:
-- **Settings**: `SOG fallback` and `Prevent duplication of boat speed`.
+- **Settings**: `Groundspeed fallback` and `Prevent speed duplication`.
 - **Inputs**: The raw signal values used for correction (heading, raw STW, SOG, attitude).
-- **Intermediates**: Internally derived quantities such as the correction vector and leeway.
-- **Outputs**: Corrected STW, leeway angle, and estimated current.
+- **Intermediates**: Internally derived quantities including the speed correction vector, boat speed over ground, and residual.
+- **Outputs**: Corrected boatspeed & leeway, and estimated current.
 
 ### Correction Table Learning
 The **Correction Table Learning** section has an On/Off toggle and contains:
 - **Settings**: Stability, Assume Current, and Show Statistics (σ display toggle).
 - **Smoother**: Type selector (Moving average / Exponential / Kalman) and its single tuning parameter. Only the parameter relevant to the selected smoother is shown.
 - **Inputs**: Smoothed values fed into the learning algorithm. When Show Statistics is on, σ values are shown.
-- **Intermediates**: Derived observations used to update correction table cells.
 
 ### Correction Table
 The **Correction Table** section shows the current correction table grid. Table management buttons appear top-right:
@@ -146,11 +145,11 @@ The **Correction Table** section shows the current correction table grid. Table
 
 Each populated cell shows:
 - **Factor** (±%): how much the paddle wheel over- or under-reads at this speed and heel (green = reads slow, orange = reads fast).
-- **Leeway** (°): the estimated sideways drift angle at this speed and heel.
+- **Leeway** (°): the estimated sideways drift angle; also encoded visually as the stripe direction in the cell background.
 
 Cell highlighting:
-- **Bold border**: the most recently updated table cell.
-- **Faint blue tint**: cells contributing to the current interpolation. Deeper = higher weight.
+- **Blue outline**: the most recently updated table cell.
+- **Dashed outline**: cells contributing to the current interpolation.
 - **No content**: not yet populated by learning.
 
 ### Correction Table Health Checklist

package/index.js

@@ -33,7 +33,6 @@ module.exports = function (app) {
     assumeCurrent: false,
     headingSource: ' ',
     boatSpeedSource: ' ',
-    COGSource: ' ',
     SOGSource: ' ',
     attitudeSource: ' ',
     preventDuplication: true,
@@ -45,8 +44,7 @@ module.exports = function (app) {
     showStatistics: false
   };
 
-  const isReadyAndFresh = (input) => !!input && input.ready === true && !input.stale;
-
+  
 
   function readOptions() {
     const stored = app.readPluginOptions();
@@ -67,6 +65,11 @@ module.exports = function (app) {
     saveOptions();
   }
 
+  // only allow prevent duplication when correctedBoatSpeed is enabled, otherwise it would prevent any boat speed from being published at all
+  const preventDuplication = () => {
+    return options.preventDuplication && options.estimateBoatSpeed;
+  }
+
   /**
    * Derives { SmootherClass, smootherOptions } from the current options.
    * Enforces minimums so the smoother always has at least two observations for
@@ -99,6 +102,7 @@ module.exports = function (app) {
 
   function swapTable(newTable) {
     table = newTable;
+    minSpeed = table.step[0] / 2;
     if (reportFull) reportFull.setTables([table]);
   }
 
@@ -111,12 +115,13 @@ module.exports = function (app) {
   let smoothedCurrent = null;
   let smoothedBoatSpeed = null;
   let correctedBoatSpeed = null;
+  let lrnBoatSpeed = null;
   let boatSpeedRefGround = null;
   let smoothedGroundSpeed = null;
   let speedCorrection = null;
   let residual = null;
+  let smoothedResidual = null;
   let reportFull = null;
-  let reportVector = null;
   let table = null;
 
   // add missing declarations
@@ -126,6 +131,7 @@ module.exports = function (app) {
   let rawBoatSpeed = null;
   let rawGroundSpeed = null;
   let started = null;
+  let minSpeed = 0;
 
   const plugin = {};
   plugin.id = "SpeedAndCurrent";
@@ -159,13 +165,7 @@ module.exports = function (app) {
       }
     });
 
-    router.get('/getVectors', (req, res) => {
-      if (!isRunning) {
-        res.status(503).json({ error: "Plugin is not running" });
-      } else {
-        res.json(reportVector.report());
-      }
-    });
+
 
     router.get('/api/status', (req, res) => {
       res.json({ status: pluginStatus, isRunning });
@@ -300,6 +300,7 @@ module.exports = function (app) {
     const tableName = options.tableName || 'correctionTable';
     const tableFilePath = path.join(app.getDataDirPath(), tableName + '.json');
     table = loadTable(options, tableFilePath);
+    minSpeed = table.step[0] / 2;
 
     //#region Handler and Polar Initialization
     const { SmootherClass, smootherOptions } = resolveSmootherConfig();
@@ -369,21 +370,34 @@ module.exports = function (app) {
       }
     });
 
+    // boatspeed
+    smoothedBoatSpeed = createSmoothedHandler({
+      app, pluginId: plugin.id,
+      id: 'boatSpeed',
+      path: 'navigation.speedThroughWater',
+      source: options.boatSpeedSource,
+      passOn: !preventDuplication(),
+      subscribe: true,
+      SmootherClass,
+      smootherOptions
+    });
+    rawBoatSpeed = smoothedBoatSpeed.handler;
+
+    // Learning polar — used for updating the correction table
+    lrnBoatSpeed = new Polar(app, plugin.id, "lrnBoatSpeed");
+    lrnBoatSpeed.configureMagnitude("navigation.speedThroughWater");
+    lrnBoatSpeed.configureAngle("navigation.leewayAngle");
+    lrnBoatSpeed.setMeta({ displayName: "Learning boat speed", plane: "Boat" });
+    lrnBoatSpeed.setAngleRange('-piToPi');
 
-    // boat speed — STW magnitude is optionally forwarded; leeway angle passOn is always false
-    const rawBoatSpeedPolar = new Polar(app, plugin.id, 'boatSpeed');
-    rawBoatSpeedPolar.configureMagnitude('navigation.speedThroughWater', options.boatSpeedSource, !options.preventDuplication);
-    rawBoatSpeedPolar.configureAngle('navigation.leewayAngle', options.boatSpeedSource, false);
-    rawBoatSpeedPolar.setMeta({ displayName: 'Boat speed', plane: 'Boat' });
-    rawBoatSpeedPolar.setAngleRange('-piToPi');
-    rawBoatSpeedPolar.subscribe(true, false);
-    smoothedBoatSpeed = new PolarSmoother(rawBoatSpeedPolar, SmootherClass, smootherOptions);
-    rawBoatSpeedPolar.onChange = () => { smoothedBoatSpeed.sample(); };
-    rawBoatSpeed = rawBoatSpeedPolar;
+    
+    // corrected boatspeed holds both corrected boatspeed and estimated leeway
     correctedBoatSpeed = new Polar(app, plugin.id, "correctedBoatSpeed");
     correctedBoatSpeed.configureMagnitude("navigation.speedThroughWater");
     correctedBoatSpeed.configureAngle("navigation.leewayAngle");
     correctedBoatSpeed.setMeta({ displayName: "Corrected boatspeed / Leeway", plane: "Boat" });
+    
+    // boatspeed vector in ground frame, used for current estimation and residual calculation
     boatSpeedRefGround = new Polar(app, plugin.id, "boatSpeedRefGround");
     boatSpeedRefGround.setMeta({ displayName: "Boat speed over ground", plane: "Ground" });
 
@@ -409,6 +423,10 @@ module.exports = function (app) {
     // residual
     residual = new Polar(app, plugin.id, "residual");
     residual.setMeta({ displayName: "Residual", plane: "Ground" });
+    smoothedResidual = new PolarSmoother(residual, ExponentialSmoother, { tau: 30, timeSpan: 30 }); // id auto-derived: 'residual.smoothed'
+    smoothedResidual.setAngleRange('0to2pi');
+    // smoothedResidual.xSmoother.reset(0, 0.00000001);
+    // smoothedResidual.ySmoother.reset(0, 0.00000001);
 
     //#endregion
 
@@ -418,34 +436,26 @@ module.exports = function (app) {
     if (options.estimateBoatSpeed) {
       reportFull.addDelta(rawHeading);
       reportFull.addAttitude(rawAttitude);
-      reportFull.addPolar(rawBoatSpeed);
+      reportFull.addDelta(rawBoatSpeed);
       reportFull.addPolar(speedCorrection);
       reportFull.addPolar(boatSpeedRefGround);
       reportFull.addPolar(correctedBoatSpeed);
       reportFull.addPolar(rawGroundSpeed);
       reportFull.addPolar(smoothedCurrent);
+      reportFull.addPolar(residual);
+      reportFull.addPolar(smoothedResidual);
     }
     if (options.updateCorrectionTable) {
       reportFull.addDelta(smoothedHeading);
       reportFull.addAttitude(smoothedAttitude);
-      reportFull.addPolar(smoothedBoatSpeed);
+      reportFull.addDelta(smoothedBoatSpeed);
       reportFull.addPolar(smoothedGroundSpeed);
       if (options.assumeCurrent) {
         reportFull.addPolar(smoothedCurrent);
       }
-      reportFull.addPolar(residual);
     }
     reportFull.addTable(table);
 
-    // Make reporting object for webApp
-    reportVector = new Reporter();
-    reportVector.addDelta(rawHeading);
-    reportVector.addPolar(residual);
-    reportVector.addPolar(speedCorrection);
-    if (options.assumeCurrent) reportVector.addPolar(smoothedCurrent);
-    reportVector.addPolar(correctedBoatSpeed);
-    reportVector.addPolar(rawBoatSpeed);
-    reportVector.addPolar(rawGroundSpeed);
     //#endregion
 
     isRunning = true;
@@ -459,24 +469,14 @@ module.exports = function (app) {
       if (Object.keys(changedOptions).length) applyOptionChanges();
 
       const wellUnderway = started < new Date() - 60 * 1000;
-      const minSpeed = table.step[0] / 2;
 
-      if (options.sogFallback && fallingBackToSog(minSpeed)) {
-        setStatus('Falling back to Speed Over Ground');
-        app.debug("Falling back");
-        return;
-      }
-      if (!wellUnderway) {
-        setStatus('Stabilizing');
-      } else {
-        setStatus('Running');
-      }
+      setStatus(wellUnderway ? 'Running' : 'Stabilizing');
       if (options.estimateBoatSpeed) correct(wellUnderway);
       if (options.updateCorrectionTable && wellUnderway) {
-        updateTable(options.assumeCurrent, minSpeed);
+        updateTable();
         // Save correction table periodically
         const now = new Date();
-        if (now - lastSave > 5 * 1000) {
+        if (now - lastSave > 60 * 1000) {
           saveTable(table, path.join(app.getDataDirPath(), table.id + '.json'));
           lastSave = now;
         }
@@ -494,12 +494,13 @@ module.exports = function (app) {
         smoothedCurrent = smoothedCurrent?.terminate?.();
         smoothedBoatSpeed = smoothedBoatSpeed?.terminate();
         correctedBoatSpeed = correctedBoatSpeed?.terminate();
+        lrnBoatSpeed = lrnBoatSpeed?.terminate();
         boatSpeedRefGround = boatSpeedRefGround?.terminate();
         smoothedGroundSpeed = smoothedGroundSpeed?.terminate();
         speedCorrection = speedCorrection?.terminate();
         residual = residual?.terminate();
+        smoothedResidual = smoothedResidual?.terminate?.();
         reportFull = null;
-        reportVector = null;
         table = null;
         rawHeading = null;
         rawAttitude = null;
@@ -519,50 +520,70 @@ module.exports = function (app) {
     });
   };
 
-  function fallingBackToSog( minSpeed) {
-    if (!rawBoatSpeed.stale && rawBoatSpeed.magnitude > 0) return false;
-    if (rawGroundSpeed.stale || rawGroundSpeed.magnitude < minSpeed) return false;
-    // Fallback to SOG
-    correctedBoatSpeed.setVectorValue({ x: rawGroundSpeed.magnitude, y: 0 });
-    Polar.send(app, plugin.id, [correctedBoatSpeed]);
-    return true;
-  }
-
-   /**
-   * Estimates and applies corrections to boat speed, leeway, and current.
+  /**
+   * Corrects and publishes boat speed. Handles SOG fallback and missing-input
+   * silent fallback so that navigation.speedThroughWater is always written
+   * when estimateBoatSpeed is on, as long as any usable speed source exists.
    *
-   * This function uses the current attitude, boat speed, and heading to compute a correction
-   * vector from the correction table, applies it to the observed boat speed, and sends the
-   * corrected value. If the vessel is well underway, it also estimates the current vector
-   * by comparing the corrected boat speed (rotated to heading) with the ground speed.
+   * Priority order:
+   *   1. STW zero + sogFallback enabled + SOG available → publish SOG magnitude
+   *   2. attitude/heading not ready → publish raw STW unchanged (silent fallback)
+   *   3. All inputs ready → apply table correction; estimate current if wellUnderway
    *
-   * @param {boolean} wellUnderway - True if the vessel is considered underway and current estimation should be performed.
+   * @param {boolean} wellUnderway - Gates current estimation (requires 60 s settling).
    */
   function correct(wellUnderway) {
-    // prepare iteration
-    if (!isReadyAndFresh(rawAttitude) || !isReadyAndFresh(rawBoatSpeed) || !isReadyAndFresh(rawHeading)) return;
-    const heel = rawAttitude.value?.roll;
-    const speed = rawBoatSpeed.magnitude;
-    const theta = rawHeading.value;
-    //app.debug(`Heel: ${SI.toDegrees(heel).toFixed(1)}°, Speed: ${SI.toKnots(speed).toFixed(2)} kn, Heading: ${SI.toDegrees(theta).toFixed(1)}°`);
+    // copy the boatspeed delta to polar
+    correctedBoatSpeed.setVectorValue({ x: rawBoatSpeed.value, y: 0 }); 
     
-    correctedBoatSpeed.copyFrom(rawBoatSpeed);
-    speedCorrection.setVectorValue({ x: 0, y: 0 }) ;
-    if (speed > 0 ) {
-      const { correction, variance } = table.getCorrection(speed, heel);
-      speedCorrection.setVectorValue(correction, variance);
-      correctedBoatSpeed.add(speedCorrection);
+    speedCorrection.setVectorValue({ x: 0, y: 0 });
+
+    // Priority 1: SOG fallback when STW is stuck at zero
+    // (onChange only fires when STW is ready, so a missing STW cannot reach here)
+    if (options.sogFallback && rawGroundSpeed.ready && correctedBoatSpeed.magnitude === 0 && rawGroundSpeed.magnitude >= minSpeed) {
+        correctedBoatSpeed.setVectorValue({ x: rawGroundSpeed.magnitude, y: 0 });
     }
-    Polar.send(app, plugin.id, [correctedBoatSpeed]);
-    // estimate current
-    if (wellUnderway && isReadyAndFresh(rawGroundSpeed)) {
-      boatSpeedRefGround.copyFrom(correctedBoatSpeed);
-      boatSpeedRefGround.rotate(theta);
-      rawCurrent.copyFrom(rawGroundSpeed);
-      rawCurrent.substract(boatSpeedRefGround);
-      smoothedCurrent.sample();
+    else if (rawAttitude.ready) {
+      if (correctedBoatSpeed.magnitude > 0) {
+        const { correction, variance } = table.getCorrection(correctedBoatSpeed.magnitude, rawAttitude.value?.roll);
+        speedCorrection.setVectorValue(correction, variance);
+        correctedBoatSpeed.add(speedCorrection);
+      }
+      // Current estimation and residual also require heading (to rotate into ground frame).
+      // Also handle near-zero SOG where COG is unavailable: treat groundspeed as zero vector.
+      const sogHandler = rawGroundSpeed.magnitudeHandler;
+      const nearZeroGroundSpeed = !rawGroundSpeed.ready &&
+        sogHandler.ready &&
+        Number.isFinite(sogHandler.value) &&
+        sogHandler.value < 0.3;
+      if (rawHeading.ready && (rawGroundSpeed.ready || nearZeroGroundSpeed)) {
+        boatSpeedRefGround.copyFrom(correctedBoatSpeed);
+        boatSpeedRefGround.rotate(rawHeading.value);
+        // Current estimation gated by wellUnderway (smoothers need to settle first)
+        if (wellUnderway) {
+          if (rawGroundSpeed.ready) {
+            rawCurrent.copyFrom(rawGroundSpeed);
+          } else {
+            // COG unavailable but SOG is near-zero: boat is stationary, groundspeed treated as zero
+            rawCurrent.setVectorValue({ x: 0, y: 0 });
+          }
+          rawCurrent.substract(boatSpeedRefGround);
+          smoothedCurrent.sample();
+        }
+        // Residual requires full groundspeed (both SOG and COG)
+        if (rawGroundSpeed.ready) {
+          residual.copyFrom(rawGroundSpeed);
+          residual.substract(boatSpeedRefGround);
+          residual.substract(smoothedCurrent);
+          smoothedResidual.sample();
+        }
+      }
     }
-    PolarSmoother.send(app, plugin.id, [smoothedCurrent]);
+    // Implicit fallback: attitude not ready — correctedBoatSpeed = raw STW, no correction
+
+    PolarSmoother.send(app, plugin.id, [smoothedCurrent, smoothedResidual]);
+
+    Polar.send(app, plugin.id, [correctedBoatSpeed]);
   }
 
   /**
@@ -575,25 +596,15 @@ module.exports = function (app) {
    * @param {boolean} [assumeCurrent=false] - If true, uses the smoothed current for correction; otherwise, assumes no current.
    * @param {number} [minSpeed=0] - The minimum speed threshold (in SI units) required to update the correction table.
    */
-  function updateTable(assumeCurrent = false, minSpeed = 0) {
-    if (!isReadyAndFresh(smoothedAttitude) || !isReadyAndFresh(smoothedBoatSpeed) || !isReadyAndFresh(smoothedHeading) || !isReadyAndFresh(smoothedGroundSpeed)) return;
-    // prepare iteration
-    const heel = smoothedAttitude.value.roll;
-    const speed = smoothedBoatSpeed.magnitude;
-    const theta = smoothedHeading.value;
-
-        // update correction table
-    if (speed > minSpeed ) {
-      table.update(speed, heel, smoothedGroundSpeed, assumeCurrent ? smoothedCurrent : noCurrent, smoothedBoatSpeed, theta);
+  function updateTable() {
+    lrnBoatSpeed.setVectorValue({ x: smoothedBoatSpeed.value, y: 0 });
+    if (!smoothedAttitude.ready || !smoothedBoatSpeed.ready || !smoothedHeading.ready || !smoothedGroundSpeed.ready || (options.assumeCurrent ? !smoothedCurrent.ready : !noCurrent.ready)) return;
+    
+    // update correction table
+    if (smoothedBoatSpeed.value > minSpeed) {
+      table.update(smoothedBoatSpeed.value, smoothedAttitude.value?.roll, smoothedGroundSpeed, options.assumeCurrent ? smoothedCurrent : noCurrent, lrnBoatSpeed, smoothedHeading.value);
     }
 
-    // calculate residual
-    residual.copyFrom(smoothedGroundSpeed);
-    boatSpeedRefGround.copyFrom(correctedBoatSpeed);
-    boatSpeedRefGround.rotate(theta);
-    residual.substract(boatSpeedRefGround);
-    residual.substract(smoothedCurrent);
-
   }
 
   /**
@@ -680,12 +691,15 @@ module.exports = function (app) {
       } else if (smoothedAttitude && key === 'attitudeSource') {
         smoothedAttitude.handler.source = value;
       } else if (smoothedBoatSpeed && key === 'boatSpeedSource') {
-        smoothedBoatSpeed.polar.magnitudeHandler.source = value;
+        smoothedBoatSpeed.handler.source = value;
       } else if (smoothedGroundSpeed && key === 'SOGSource') {
         smoothedGroundSpeed.polar.magnitudeHandler.source = value;
       } else if (key === 'preventDuplication') {
-        if (smoothedBoatSpeed) smoothedBoatSpeed.polar.magnitudeHandler.passOn = !value;
+        if (smoothedBoatSpeed) smoothedBoatSpeed.handler.passOn = !preventDuplication();
+      } else if (key === 'estimateBoatSpeed' ) {
+        if (smoothedBoatSpeed) smoothedBoatSpeed.handler.passOn = !preventDuplication();
       }
+
       // All other keys (sogFallback, estimateBoatSpeed, updateCorrectionTable,
       // assumeCurrent, stability, startWithNewTable, COGSource) are read
       // directly from options.* so no extra action needed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speedandcurrent",
-  "version": "1.7.3",
+  "version": "1.7.6",
   "description": "A plugin that automatically corrects boat speed and calculates current and leeway using sensor fusion.",
   "main": "index.js",
   "scripts": {
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "kalman-filter": "^2.3.0",
-    "signalkutilities": "^1.9.1"
+    "signalkutilities": "^1.11.0"
   },
   "files": [
     "index.js",

package/public/app.js

@@ -121,6 +121,36 @@ function isStale(item) {
   return item.state?.stale === true;
 }
 
+function isNotReady(item) {
+  if (!item) return true;
+  return item.state?.ready !== true;
+}
+
+function getAnyItem(id) {
+  return state.polarsById[id] || state.deltasById[id] || state.attitudesById[id] || null;
+}
+
+function renderWarnings(elId, ids) {
+  const el = document.getElementById(elId);
+  if (!el) return;
+  el.innerHTML = '';
+  const notReady = ids.filter(id => isNotReady(getAnyItem(id)));
+  if (notReady.length === 0) return;
+  const h = document.createElement('h6');
+  h.className = 'text-uppercase fw-bold text-muted border-bottom pb-1 mt-3 mb-1 small';
+  h.textContent = 'Warnings';
+  el.appendChild(h);
+  const ul = document.createElement('ul');
+  ul.className = 'list-unstyled text-danger small ps-3';
+  notReady.forEach(id => {
+    const label = metaById[id]?.displayName ?? id;
+    const li = document.createElement('li');
+    li.textContent = `"${label}" — not available`;
+    ul.appendChild(li);
+  });
+  el.appendChild(ul);
+}
+
 // ─── Config (live settings mirror) ───────────────────────────────────────────
 let config = null;
 
@@ -216,7 +246,7 @@ const paramMeta = {
   stability:             { label: 'Stability (1–20)',                     type: 'number', min: 1, max: 20, step: 1, default: 7, description: 'How quickly the correction table adapts to new observations. Higher values mean slower, more stable changes.' },
   showStatistics:        { label: 'Show statistics (σ)',                  type: 'boolean', description: 'Display standard deviation alongside smoothed values for debugging.' },
   headingSource:  { label: 'Heading source',          type: 'source', sourceOf: { type: 'delta',   id: 'heading.smoothed'     } },
-  boatSpeedSource:{ label: 'Boat speed source',       type: 'source', sourceOf: { type: 'polar',   id: 'boatSpeed.smoothed'   } },
+  boatSpeedSource:{ label: 'Boat speed source',       type: 'source', sourceOf: { type: 'delta',   id: 'boatSpeed.smoothed'   } },
   SOGSource:      { label: 'Groundspeed source',      type: 'source', sourceOf: { type: 'polar',   id: 'groundSpeed.smoothed' } },
   attitudeSource: { label: 'Attitude source',         type: 'source', sourceOf: { type: 'attitude',id: 'attitude.smoothed'    } },
   smootherClass: {
@@ -492,9 +522,9 @@ function renderGroupInto(elId, polars, deltas, attitudes) {
   if (!el) return;
   el.innerHTML = '';
   const rows = [
-    ...polars   .map(p => ({ label: itemLabel(p), value: formatPolarValue(p),    stale: isStale(p) })),
-    ...deltas   .map(d => ({ label: itemLabel(d), value: formatDeltaValue(d),    stale: isStale(d) })),
-    ...attitudes.map(a => ({ label: itemLabel(a), value: formatAttitudeValue(a), stale: isStale(a) }))
+    ...polars   .map(p => ({ label: itemLabel(p), value: formatPolarValue(p),    stale: isNotReady(p) })),
+    ...deltas   .map(d => ({ label: itemLabel(d), value: formatDeltaValue(d),    stale: isNotReady(d) })),
+    ...attitudes.map(a => ({ label: itemLabel(a), value: formatAttitudeValue(a), stale: isNotReady(a) }))
   ];
   if (rows.length) el.appendChild(buildDataTable(rows));
 }
@@ -502,20 +532,20 @@ function renderGroupInto(elId, polars, deltas, attitudes) {
 function renderLiveSections() {
   // Inputs section — raw sensor readings only (smoothing is internal to the plugin)
   renderGroupInto('inputs-values',
-    filterById(state.polarsAll,    ['boatSpeed', 'groundSpeed']),
-    filterById(state.deltasAll,    ['heading.angle']),
+    filterById(state.polarsAll,    ['groundSpeed']),
+    filterById(state.deltasAll,    ['heading.angle', 'boatSpeed']),
     filterById(state.attitudesAll, ['attitude'])
   );
 
   // Estimation — inputs (raw sensor data used for boat speed estimation)
   renderGroupInto('estimation-inputs',
-    filterById(state.polarsAll,    ['boatSpeed', 'groundSpeed']),
-    filterById(state.deltasAll,    ['heading.angle']),
+    filterById(state.polarsAll,    ['groundSpeed']),
+    filterById(state.deltasAll,    ['heading.angle', 'boatSpeed']),
     filterById(state.attitudesAll, ['attitude'])
   );
   // Estimation — intermediates
   renderGroupInto('estimation-intermediates',
-    filterById(state.polarsAll, ['boatSpeedRefGround', 'speedCorrection']),
+    filterById(state.polarsAll, ['boatSpeedRefGround', 'speedCorrection', 'residual', 'residual.smoothed']),
     [], []
   );
   // Estimation — outputs
@@ -523,21 +553,24 @@ function renderLiveSections() {
     filterById(state.polarsAll, ['correctedBoatSpeed', 'current.smoothed']),
     [], []
   );
+  // Estimation — warnings
+  renderWarnings('estimation-warnings',
+    ['boatSpeed', 'attitude', 'heading.angle', 'groundSpeed']
+  );
 
   // Learning — inputs: smoothed sensors + current if assumeCurrent
   const learningCurrentPolars = (config && config.assumeCurrent)
     ? filterById(state.polarsAll, ['current.smoothed'])
     : [];
   renderGroupInto('learning-inputs',
-    [...filterById(state.polarsAll, ['boatSpeed.smoothed', 'groundSpeed.smoothed']), ...learningCurrentPolars],
-    filterById(state.deltasAll,    ['heading.smoothed']),
+    [...filterById(state.polarsAll, ['groundSpeed.smoothed']), ...learningCurrentPolars],
+    filterById(state.deltasAll,    ['heading.smoothed', 'boatSpeed.smoothed']),
     filterById(state.attitudesAll, ['attitude.smoothed'])
   );
-  // Learning — intermediates
-  renderGroupInto('learning-intermediates',
-    filterById(state.polarsAll, ['residual']),
-    [], []
-  );
+  // Learning — warnings
+  const learningWarningIds = ['boatSpeed.smoothed', 'groundSpeed.smoothed', 'heading.smoothed', 'attitude.smoothed'];
+  if (config && config.assumeCurrent) learningWarningIds.push('current.smoothed');
+  renderWarnings('learning-warnings', learningWarningIds);
   // Correction table
   const tableEl = document.getElementById('table-container');
   if (tableEl) {

package/public/index.html

@@ -104,6 +104,7 @@
               <div id="estimation-intermediates"></div>
               <h6 class="text-uppercase fw-bold text-muted border-bottom pb-1 mt-3 mb-1 small">Outputs</h6>
               <div id="estimation-outputs"></div>
+              <div id="estimation-warnings"></div>
             </div>
           </div>
         </div>
@@ -130,8 +131,7 @@
               </table>
               <h6 class="text-uppercase fw-bold text-muted border-bottom pb-1 mt-3 mb-1 small">Inputs</h6>
               <div id="learning-inputs"></div>
-              <h6 class="text-uppercase fw-bold text-muted border-bottom pb-1 mt-3 mb-1 small">Intermediates</h6>
-              <div id="learning-intermediates"></div>
+              <div id="learning-warnings"></div>
             </div>
           </div>
         </div>