speedandcurrent 1.7.10 → 2.0.2

package/README.md

@@ -29,6 +29,20 @@ The plugin requires no further configuration in the Signal K admin UI. All setti
 
 ---
 
+## Configuring Signal K source priorities
+
+Signal K Server manages source priorities natively. When multiple devices publish the same path, the server delivers the highest-priority source to all subscribers — including this plugin. No per-path source selection is needed inside the plugin itself.
+
+When **Estimate Boat Speed** is enabled the plugin publishes corrected `navigation.speedThroughWater` alongside the raw paddle wheel value. Signal K will deliver whichever source has the higher priority. To ensure the rest of your instrument system sees the *corrected* value:
+
+1. Open the Signal K Server admin UI and navigate to **Server → Data Browser** (or the **Sources** page, depending on your server version).
+2. Locate `navigation.speedThroughWater` and find the source published by this plugin (it is identified as `SpeedAndCurrent`).
+3. Set that source to a higher priority than the raw paddle wheel source.
+
+Once configured, all consumers on the Signal K bus — KIP, OpenCPN, Instrument displays — receive the corrected value automatically without any further configuration.
+
+---
+
 ## Required Signal K paths
 
 | Path | Role |
@@ -84,10 +98,6 @@ The **Inputs** section shows live readings from the raw sensors as they arrive f
 | Ground speed | `navigation.speedOverGround` + `navigation.courseOverGroundTrue` |
 | Attitude (heel) | `navigation.attitude` (roll) |
 
-### Source selection
-
-For each path you can pin the plugin to a specific Signal K source. This is useful when multiple devices publish the same path — for example two GPS receivers, or a fluxgate and a satellite compass both publishing `navigation.headingTrue`. Leave a source blank or select **(any)** to accept values from all sources. This is independent of the Signal K server's global source priority settings.
-
 ### Settings
 
 | Setting | Default | Description |
@@ -98,7 +108,7 @@ For each path you can pin the plugin to a specific Signal K source. This is usef
 
 ## Boatspeed Estimation
 
-The **Boatspeed Estimation** section is enabled with the toggle in the panel header. When off, no corrected output is published; the raw paddle wheel value passes through to the SK bus unchanged (subject to the Prevent Speed Duplication setting).
+The **Boatspeed Estimation** section is enabled with the toggle in the panel header. When off, no corrected output is published; the raw paddle wheel value passes through to the SK bus unchanged.
 
 ### What it shows
 
@@ -120,7 +130,6 @@ The panel is organised into three groups:
 | Setting | Default | Description |
 |---------|---------|-------------|
 | **Estimate Boat Speed** | Off | Master toggle. Apply the correction table and publish corrected STW, leeway, and current. Turn on once the table has reasonable coverage. |
-| **Prevent Speed Duplication** | On | Replace the raw sensor value on the SK bus with the corrected value. When off, both raw and corrected exist under `navigation.speedThroughWater` with different source attributes — useful for comparing before and after. |
 | **Groundspeed Fallback** | Off | When the paddle wheel reads zero and SOG is above a minimum threshold, publish SOG as boatspeed. Primarily intended for clogged or stuck paddle wheels where the instrument is physically present but not turning — giving the rest of the instrument system a usable boat speed until the wheel is cleared. |
 
 ---
@@ -227,40 +236,40 @@ When a new paddle wheel sample arrives the plugin:
 
 Rather than bi-linear interpolation the plugin uses **inverse-distance weighting** over the five nearest cells in speed/heel space:
 
-$$w_i = \frac{1}{d_i + \epsilon}$$
+> wᵢ = 1 / (dᵢ + ε)
 
-where $d_i$ is the Euclidean distance from the query point to cell centre $i$ in normalised speed/heel space. Only cells that have received at least one observation ($N > 0$) contribute.
+where dᵢ is the Euclidean distance from the query point to cell centre i in normalised speed/heel space. Only cells that have received at least one observation (N > 0) contribute.
 
 The final correction is the normalised weighted average:
 
-$$\hat{x} = \frac{\sum_i w_i \cdot x_i}{\sum_i w_i}, \quad \hat{y} = \frac{\sum_i w_i \cdot y_i}{\sum_i w_i}$$
+> x̂ = Σ(wᵢ · xᵢ) / Σwᵢ,  ŷ = Σ(wᵢ · yᵢ) / Σwᵢ
 
 The variance of each axis is propagated through the same weighting, so cells with low confidence (high covariance) influence the result less. If only one or two cells have data, the correction extrapolates gradually to nearby conditions. As more cells fill in, the correction becomes tighter and more local.
 
 ### How the correction table is populated
 
-Each cell is an independent **2-dimensional Kalman filter** tracking the correction vector $[x, y]$ for that speed/heel bin, with a 2×2 covariance matrix expressing confidence in each axis.
+Each cell is an independent **2-dimensional Kalman filter** tracking the correction vector [x, y] for that speed/heel bin, with a 2×2 covariance matrix expressing confidence in each axis.
 
 Every time conditions are right — plugin running for >60 seconds, smoothers settled, speed above minimum threshold — the plugin computes an **observation** of what the correction should be:
 
-$$\text{observation} = R(\psi)^{-1} \cdot \vec{V}_{SOG} - R(\psi)^{-1} \cdot \vec{V}_{current} - \vec{V}_{STW}$$
+> observation = R(ψ)⁻¹ · V_SOG − R(ψ)⁻¹ · V_current − V_STW
 
-where $R(\psi)$ rotates from ground frame to boat frame using true heading $\psi$. In plain terms: rotate GPS velocity into the boat frame, subtract the current estimate (also rotated), subtract the raw paddle wheel velocity. The residual is the implied sensor error for the current speed and heel.
+where R(ψ) rotates from ground frame to boat frame using true heading ψ. In plain terms: rotate GPS velocity into the boat frame, subtract the current estimate (also rotated), subtract the raw paddle wheel velocity. The residual is the implied sensor error for the current speed and heel.
 
 The Kalman update combines this observation with the cell's existing belief:
 
-$$K = P \cdot (P + R_{obs})^{-1}$$
-$$x_{new} = x_{old} + K \cdot (\text{observation} - x_{old})$$
+> K = P · (P + R_obs)⁻¹
+> x_new = x_old + K · (observation − x_old)
 
-where $P$ is the cell's current covariance and $R_{obs}$ is the observation covariance derived from the measurement uncertainty of all contributing signals (SOG variance + current variance + STW variance, rotated appropriately). **Noisy observations produce a smaller gain and move the cell estimate less.**
+where P is the cell's current covariance and R_obs is the observation covariance derived from the measurement uncertainty of all contributing signals (SOG variance + current variance + STW variance, rotated appropriately). **Noisy observations produce a smaller gain and move the cell estimate less.**
 
 ### The stability setting in detail
 
 Each cell has a small **process noise** that allows it to drift slowly over time, reflecting that a paddle wheel's error can change with fouling, recalibration, or crew weight distribution. Process noise is:
 
-$$Q = 10^{-\text{stability}}$$
+> Q = 10^(−stability)
 
-With stability = 7 (default), $Q = 10^{-7}$, making the cell very resistant to change — it effectively averages hundreds of observations before settling. Stability 4–5 makes the table react faster to recent conditions; stability 10–12 is appropriate for a well-characterised boat that changes rarely.
+With stability = 7 (default), Q = 10⁻⁷, making the cell very resistant to change — it effectively averages hundreds of observations before settling. Stability 4–5 makes the table react faster to recent conditions; stability 10–12 is appropriate for a well-characterised boat that changes rarely.
 
 In practical terms: high stability = trust the accumulated history; low stability = trust recent observations more.
 
@@ -268,11 +277,11 @@ In practical terms: high stability = trust the accumulated history; low stabilit
 
 Current is estimated as:
 
-$$\vec{V}_{current} = \vec{V}_{SOG} - R(\psi) \cdot \vec{V}_{STW, corrected}$$
+> V_current = V_SOG − R(ψ) · V_STW_corrected
 
 The corrected STW vector is rotated into the ground frame using heading, then subtracted from the GPS velocity. The residual is the water velocity.
 
-This raw estimate is fed into a **Kalman smoother with very low process noise** (process variance $\approx 10^{-6}$), so it changes very slowly, integrating over many minutes rather than chasing individual GPS fluctuations. At startup the estimate is strongly initialised to zero.
+This raw estimate is fed into a **Kalman smoother with very low process noise** (process variance ≈ 10⁻⁶), so it changes very slowly, integrating over many minutes rather than chasing individual GPS fluctuations. At startup the estimate is strongly initialised to zero.
 
 Current estimation requires an accurate boat speed, so it is gated by the 60-second stabilisation period and only runs when **Estimate Boat Speed** is enabled.
 

package/correctionTable.js

@@ -1,6 +1,21 @@
 const { Table2D} = require('signalkutilities');
 const { KalmanFilter, State } = require('kalman-filter');
 
+// Module-level helpers — avoids creating new Function objects on every Kalman update call
+function _rotateValue(cos, sin, vector) {
+  return [
+     cos * vector[0] + sin * vector[1],
+    -sin * vector[0] + cos * vector[1]
+  ];
+}
+
+function _rotateVariance(cos, sin, vector) {
+  return [
+    [vector[0] * cos ** 2 + vector[1] * sin ** 2, (vector[0] - vector[1]) * cos * sin],
+    [(vector[0] - vector[1]) * cos * sin,          vector[0] * sin ** 2 + vector[1] * cos ** 2]
+  ];
+}
+
 class CorrectionTable extends Table2D{
   /**
    * Represents a 2D correction table for heel and speed.
@@ -114,18 +129,21 @@ class CorrectionTable extends Table2D{
         totalWeight += weight;
       }
     }
-    for (const neighbour of this.neighbours) {
-      if (totalWeight > 0) neighbour.normWeight /= totalWeight;
+    if (totalWeight > 0) {
+      for (const neighbour of this.neighbours) {
+        neighbour.normWeight /= totalWeight;
+      }
     }
 
-    const corrAndVar = { correction: { x, y }, variance: { x: varX, y: varY } };
-    if (totalWeight === 0) return corrAndVar;
+    if (totalWeight === 0) return { correction: { x: 0, y: 0 }, variance: { x: 0, y: 0 } };
 
     // Compute the final correction and variance
+    // Variance of a weighted mean: Σ(w²·var_i) / (Σw)²
+    const tw2 = totalWeight * totalWeight;
     x /= totalWeight;
     y /= totalWeight;
-    varX /= totalWeight;
-    varY /= totalWeight;
+    varX /= tw2;
+    varY /= tw2;
     this.totalWeight = totalWeight;
 
     return { correction: { x, y }, variance: { x: varX, y: varY } };
@@ -136,11 +154,11 @@ class CorrectionTable extends Table2D{
       id: this.id,
       row: { min: this.min[0], max: this.max[0], step: this.step[0] },
       col: { min: this.min[1], max: this.max[1], step: this.step[1] },
-      table: this.table.map(row =>
-        row.map((correction, colIndex, rowArray) => {
+      table: this.table.map((row, rowIndex) =>
+        row.map((correction, colIndex) => {
           const cellReport = correction.report();
           // Derive the bin coordinates from indices
-          const speedBin = this.min[0] + this.step[0] * this.table.indexOf(rowArray); // row axis represents speed
+          const speedBin = this.min[0] + this.step[0] * rowIndex; // row axis represents speed
           const heelBin = this.min[1] + this.step[1] * colIndex; // col axis represents heel
           // Compute forward speed after longitudinal correction
           const forward = speedBin + cellReport.x;
@@ -151,14 +169,10 @@ class CorrectionTable extends Table2D{
           // Trace ( cov_xx + cov_yy ) when covariance available and N>0
           let trace = null;
           if (cellReport.N > 0) {
-            try {
-              const cov = correction.covariance;
-              if (cov && Array.isArray(cov) && cov[0] && cov[1] && Number.isFinite(cov[0][0]) && Number.isFinite(cov[1][1])) {
-                const a = cov[0][0];
-                const d = cov[1][1];
-                trace = a + d;
-              }
-            } catch { /* silent */ }
+            const cov = correction.covariance;
+            if (cov && Array.isArray(cov) && cov[0] && cov[1] && Number.isFinite(cov[0][0]) && Number.isFinite(cov[1][1])) {
+              trace = cov[0][0] + cov[1][1];
+            }
           }
           cellReport.forward = forward;
           cellReport.factor = factor;
@@ -229,22 +243,8 @@ class CorrectionEstimator {
     const cosTheta = Math.cos(heading);
     const sinTheta = Math.sin(heading);
 
-    const rotateValue = (vector) => ([
-      cosTheta * vector[0] + sinTheta * vector[1],
-      -sinTheta * vector[0] + cosTheta * vector[1]]
-    );
-
-    const rotateVariance = (vector) => (
-      [
-        [vector[0] * cosTheta ** 2 + vector[1] * sinTheta ** 2,
-        (vector[0] - vector[1]) * cosTheta * sinTheta],
-        [(vector[0] - vector[1]) * cosTheta * sinTheta,
-        vector[0] * sinTheta ** 2 + vector[1] * cosTheta ** 2]
-      ]
-    );
-
-    var groundVector = rotateValue(groundSpeed.vector);
-    var currentVector = rotateValue(current.vector);
+    var groundVector = _rotateValue(cosTheta, sinTheta, groundSpeed.vector);
+    var currentVector = _rotateValue(cosTheta, sinTheta, current.vector);
     var boatVector = boatSpeed.vector;
 
     const observation = [
@@ -252,8 +252,8 @@ class CorrectionEstimator {
       -boatVector[1] + groundVector[1] - currentVector[1]
     ];
 
-    var groundCov = rotateVariance(groundSpeed.variance);
-    var currentCov = rotateVariance(current.variance);
+    var groundCov = _rotateVariance(cosTheta, sinTheta, groundSpeed.variance);
+    var currentCov = _rotateVariance(cosTheta, sinTheta, current.variance);
     var boatCov = [[boatSpeed.xVariance, 0], [0, boatSpeed.yVariance]];
 
     const observationCovariance = [[

package/index.js

@@ -25,18 +25,15 @@ module.exports = function (app) {
 
   let options = {};
   let changedOptions = {};
+  let hasPendingChanges = false;
   const defaultOptions = {
     sogFallback: true,
     estimateBoatSpeed: false,
     updateCorrectionTable: true,
     stability: 7,
     assumeCurrent: false,
-    headingSource: ' ',
-    boatSpeedSource: ' ',
-    SOGSource: ' ',
-    attitudeSource: ' ',
-    preventDuplication: true,
     tableName: 'correctionTable',
+    configVersion: 2,
     smootherClass: 'MovingAverageSmoother',
     smootherTau: 3,
     smootherTimeSpan: 5,
@@ -66,9 +63,19 @@ 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;
+  /**
+   * Strips obsolete source-selection fields from the persisted config and
+   * writes it back if anything changed. Called once on every start().
+   */
+  function migrateConfig() {
+    const obsoleteKeys = ['headingSource', 'boatSpeedSource', 'SOGSource', 'attitudeSource', 'preventDuplication'];
+    const hadObsolete = obsoleteKeys.some(k => k in options);
+    for (const k of obsoleteKeys) delete options[k];
+    if (hadObsolete || (options.configVersion || 0) < 2) {
+      options.configVersion = 2;
+      saveOptions();
+      app.debug('Config migrated to v2: removed obsolete source-selection fields');
+    }
   }
 
   /**
@@ -105,6 +112,7 @@ module.exports = function (app) {
     table = newTable;
     minSpeed = table.step[0] / 2;
     if (reportFull) reportFull.setTables([table]);
+    lastSave = Date.now(); // explicit table operations already save; defer next periodic save
   }
 
   let isRunning = false;
@@ -131,6 +139,7 @@ module.exports = function (app) {
   let rawGroundSpeed = null;
   let started = null;
   let minSpeed = 0;
+  let lastSave = 0;
 
   const plugin = {};
   plugin.id = "SpeedAndCurrent";
@@ -188,6 +197,7 @@ module.exports = function (app) {
         }
       }
       changedOptions = { ...changedOptions, ...body };
+      hasPendingChanges = true;
       res.json({ ...options, ...changedOptions });
     });
 
@@ -296,6 +306,7 @@ module.exports = function (app) {
     setStatus('Starting');
     app.debug("Starting");
     readOptions(); // pick up any saves since registerWithRouter ran
+    migrateConfig(); // strip obsolete fields from persisted config
     const tableName = options.tableName || 'correctionTable';
     const tableFilePath = path.join(app.getDataDirPath(), tableName + '.json');
     table = loadTable(options, tableFilePath);
@@ -306,8 +317,6 @@ module.exports = function (app) {
 
     // heading
     smoothedHeading = new SmoothedAngle(app, plugin.id, 'heading', 'navigation.headingTrue', {
-      source: options.headingSource,
-      passOn: true,
       angleRange: '0to2pi',
       meta: { displayName: 'Heading', plane: 'Ground' },
       SmootherClass,
@@ -324,8 +333,6 @@ module.exports = function (app) {
       app, pluginId: plugin.id,
       id: 'attitude',
       path: 'navigation.attitude',
-      source: options.attitudeSource,
-      passOn: true,
       subscribe: true,
       SmootherClass,
       smootherOptions
@@ -379,8 +386,6 @@ module.exports = function (app) {
       app, pluginId: plugin.id,
       id: 'boatSpeed',
       path: 'navigation.speedThroughWater',
-      source: options.boatSpeedSource,
-      passOn: !preventDuplication(),
       subscribe: true,
       SmootherClass,
       smootherOptions
@@ -411,8 +416,6 @@ module.exports = function (app) {
       id: 'groundSpeed',
       pathMagnitude: 'navigation.speedOverGround',
       pathAngle: 'navigation.courseOverGroundTrue',
-      source: options.SOGSource,
-      passOn: true,
       angleRange: '0to2pi',
       meta: { displayName: 'Groundspeed', plane: 'Ground' },
       SmootherClass,
@@ -476,11 +479,11 @@ module.exports = function (app) {
     }
 
     isRunning = true;
-    started = new Date();
+    started = Date.now();
+    lastSave = 0;
     setStatus('Running');
     app.debug("Running");
 
-    let lastSave = 0;
     smoothedBoatSpeed.onChange = () => {
       // Drain any pending option changes before calculating
       if (Object.keys(changedOptions).length) applyOptionChanges();
@@ -492,10 +495,12 @@ module.exports = function (app) {
       if (options.updateCorrectionTable) {
         if (wellUnderway) {
           updateTable();
-          // Save correction table periodically
-          const now = new Date();
-          if (now - lastSave > 60 * 1000) {
-            saveTable(table, path.join(app.getDataDirPath(), table.id + '.json'));
+          // Save correction table periodically (skip if table is empty to avoid overwriting good data on disk)
+          const now = Date.now();
+          if (now - lastSave > 60_000) {
+            if (!isTableEmpty(table)) {
+              saveTable(table, path.join(app.getDataDirPath(), table.id + '.json'));
+            }
             lastSave = now;
           }
         } else {
@@ -510,6 +515,9 @@ module.exports = function (app) {
   plugin.stop = () => {
     return new Promise((resolve, reject) => {
       try {
+        if (table && !isTableEmpty(table)) {
+          saveTableSync(table, path.join(app.getDataDirPath(), table.id + '.json'));
+        }
         smoothedHeading = smoothedHeading?.terminate();
         smoothedAttitude = smoothedAttitude?.terminate();
         rawCurrent = rawCurrent?.terminate();
@@ -640,11 +648,25 @@ module.exports = function (app) {
    */
   function loadTable(options, filePath) {
     const stability = (options.stability !== undefined) ? options.stability : 6;
-    const fileData = Table2D.readFromFile(filePath);
+    let fileData = Table2D.readFromFile(filePath);
     let table;
     if (fileData) {
       table = CorrectionTable.fromJSON(fileData, stability);
       app.debug("Correction table loaded: " + (fileData.id || filePath));
+    } else if (fs.existsSync(filePath)) {
+      // File is present but could not be read — transient lock or parse error. Retry once.
+      app.error(`Correction table file exists but could not be read, retrying: ${filePath}`);
+      fileData = Table2D.readFromFile(filePath);
+      if (fileData) {
+        table = CorrectionTable.fromJSON(fileData, stability);
+        app.debug("Correction table loaded on retry: " + (fileData.id || filePath));
+      } else {
+        app.error(`Correction table retry failed — starting with empty table. Disk file preserved: ${filePath}`);
+        const name = options.tableName || 'correctionTable';
+        const row = { min: 0, max: SI.fromKnots(DEFAULT_DIMS.maxSpeed), step: SI.fromKnots(DEFAULT_DIMS.speedStep) };
+        const col = { min: -SI.fromDegrees(DEFAULT_DIMS.maxHeel), max: SI.fromDegrees(DEFAULT_DIMS.maxHeel), step: SI.fromDegrees(DEFAULT_DIMS.heelStep) };
+        table = new CorrectionTable(name, row, col, stability);
+      }
     } else {
       const name = options.tableName || 'correctionTable';
       const row = { min: 0, max: SI.fromKnots(DEFAULT_DIMS.maxSpeed), step: SI.fromKnots(DEFAULT_DIMS.speedStep) };
@@ -657,7 +679,7 @@ module.exports = function (app) {
   }
 
   /**
-   * Saves the correction table to disk as JSON.
+   * Saves the correction table to disk as JSON (async, via library).
    *
    * @param {CorrectionTable} correctionTable - The correction table instance to save.
    * @param {string} filePath - Absolute path of the target JSON file.
@@ -666,10 +688,31 @@ module.exports = function (app) {
     correctionTable.saveToFile(filePath);
   }
 
+  /**
+   * Saves the correction table synchronously. Used in stop() and when learning
+   * is toggled off, to ensure the write completes before the process can exit
+   * or the plugin be restarted.
+   */
+  function saveTableSync(correctionTable, filePath) {
+    try {
+      const data = JSON.stringify(correctionTable.toJSON(), null, 2);
+      fs.writeFileSync(filePath, data);
+    } catch (err) {
+      app.error(`Error saving correction table: ${err.message}`);
+    }
+  }
+
+  /**
+   * Returns true if every cell in the table has N === 0 (no learned data).
+   * Used to guard against overwriting a good on-disk file with an empty table.
+   */
+  function isTableEmpty(correctionTable) {
+    return correctionTable.table.every(row => row.every(cell => cell.N === 0));
+  }
+
   /**
    * Drains changedOptions into options and hot-applies each change where possible.
-   * Source changes are applied in-place on existing handlers; flag changes take
-   * effect immediately since onChange reads from options.* directly.
+   * Flag changes take effect immediately since onChange reads from options.* directly.
    */
   function applyOptionChanges() {
     const changedKeys = Object.keys(changedOptions);
@@ -677,29 +720,35 @@ module.exports = function (app) {
       const value = changedOptions[key];
       options[key] = value;
 
-      // Hot-apply source changes by mutating handler references in-place
-      if (smoothedHeading && key === 'headingSource') {
-        smoothedHeading.handler.source = value;
-      } else if (smoothedAttitude && key === 'attitudeSource') {
-        smoothedAttitude.handler.source = value;
-      } else if (smoothedBoatSpeed && key === 'boatSpeedSource') {
-        smoothedBoatSpeed.handler.source = value;
-      } else if (smoothedGroundSpeed && key === 'SOGSource') {
-        smoothedGroundSpeed.polar.magnitudeHandler.source = value;
-      } else if (key === 'preventDuplication') {
-        if (smoothedBoatSpeed) smoothedBoatSpeed.handler.passOn = !preventDuplication();
-      } else if (key === 'estimateBoatSpeed' ) {
-        if (smoothedBoatSpeed) smoothedBoatSpeed.handler.passOn = !preventDuplication();
-      } else if (key === 'stalenessDetection') {
+      if (key === 'stalenessDetection') {
         const sdVal = Boolean(value);
         for (const s of [smoothedHeading, smoothedAttitude, smoothedBoatSpeed, smoothedGroundSpeed, smoothedCurrent, smoothedResidual]) {
           if (s) s.stalenessDetection = sdVal;
         }
         // noCurrent is always excluded from staleness detection
+      } else if (key === 'updateCorrectionTable') {
+        if (!value && table && !isTableEmpty(table)) {
+          // Learning switched off — persist current state before periodic saves stop
+          saveTableSync(table, path.join(app.getDataDirPath(), table.id + '.json'));
+          app.debug('Correction table saved: learning switched off');
+        } else if (value && table && isTableEmpty(table)) {
+          // Learning switched on and in-memory table is empty — reload from disk
+          // to recover from a failed load at startup
+          const filePath = path.join(app.getDataDirPath(), table.id + '.json');
+          const fileData = Table2D.readFromFile(filePath);
+          if (fileData) {
+            const reloaded = CorrectionTable.fromJSON(fileData, options.stability || 7);
+            reloaded.setDisplayAttributes({ label: reloaded.id });
+            if (!isTableEmpty(reloaded)) {
+              swapTable(reloaded);
+              app.debug('Correction table reloaded from disk: learning switched on (was empty in memory)');
+            }
+          }
+        }
       }
 
-      // All other keys (sogFallback, estimateBoatSpeed, updateCorrectionTable,
-      // assumeCurrent, stability, startWithNewTable, COGSource) are read
+      // All other keys (sogFallback, estimateBoatSpeed, assumeCurrent,
+      // stability, smootherClass, etc.) are read
       // directly from options.* so no extra action needed.
 
       delete changedOptions[key];
@@ -716,6 +765,7 @@ module.exports = function (app) {
       if (smoothedAttitude) { smoothedAttitude.setSmootherClass(SC); smoothedAttitude.setSmootherOptions(so); }
     }
 
+    hasPendingChanges = false;
     saveOptions();
   }
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "speedandcurrent",
-  "version": "1.7.10",
+  "version": "2.0.2",
   "description": "A plugin that automatically corrects boat speed and calculates current and leeway using sensor fusion.",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --test test/plugin.test.js"
   },
   "author": "aswin.bouwmeester@gmail.com",
   "license": "MIT",
@@ -17,25 +17,33 @@
   },
   "homepage": "https://github.com/Asw1n/speedandcurrent#readme",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.0.0",
+    "signalk-server": ">=2.28.0"
   },
   "keywords": [
     "signalk-webapp",
     "signalk-node-server-plugin",
-    "signalk-category-utility"
+    "signalk-category-utility",
+    "signalk-category-instruments"
   ],
   "signalk-plugin-enabled-by-default": false,
   "signalk": {
-    "appIcon": "icon.png",
-    "displayName": "Speed and current"
+    "appIcon": "./icon.png",
+    "displayName": "Speed and current",
+    "screenshots": [
+      "./docs/correctionTable.png",
+      "./docs/STW_estimation.png",
+      "./docs/learning.png"
+    ]
   },
   "dependencies": {
     "kalman-filter": "^2.3.0",
-    "signalkutilities": "^1.12.0"
+    "signalkutilities": "^2.0.1"
   },
   "files": [
     "index.js",
     "correctionTable.js",
-    "public/"
+    "public/",
+    "docs/"
   ]
 }