signalk-polar-performance-plugin 1.3.2 → 1.4.0

package/CHANGELOG.md

@@ -6,15 +6,30 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 
+## [1.4.0] - 2026-09-01
+
+### Changed
+- npm publishes now use GitHub Actions OIDC trusted publishing instead of a long-lived `NPM_TOKEN`, and only run after a merge to `main`.
+
+### Fixed
+- Polar interpolation no longer reports 0 kn when the polar lacks derived beat/run target rows for some TWS columns (common in Jieter/Expedition exports that only emit targets when they change). Missing targets are now interpolated across TWS during load; previously the fallback pinned the beat angle to the lowest tabulated angle (e.g. 52° between 44° and 38° neighbours), which nulled the pinch zone for every TWS bracket interpolated against the gap — upwind polar speed read 0 kn at 11–15 kt for affected polars.
+- `getBoatSpeed` now evaluates the in-irons boundary against the interpolated beat angle, matching `getInterpolationState`, instead of each TWS bracket's own angle. A bracket whose own pinch zone is stricter no longer nulls the entire interpolated result.
+- The zero-wind padding entry is now created before extrapolation coefficients are computed, so light-wind lookups (below the polar's lowest TWS) in the pinch and run-extrapolation zones interpolate smoothly toward zero instead of returning null.
+- `getInterpolationState` now reports `above_range` consistently with `getBoatSpeed`'s interpolated run-extrapolation limit, even when the TWA is still tabulated for one of the TWS brackets.
+- Removed dead CSV-era helpers (`_processTWSHeader`, `_processSpeedRow`) that could insert zero-speed points into the table if ever reused with `0.0`-padded CSV.
+- Plugin start no longer fails with `TypeError: callback is not a function` when migrating existing settings. `savePluginOptions` now receives the callback Signal K requires.
+
+## [1.3.3] - 2026-08-28
+
+### Changed
+- Idle input recovery is now always enabled; the temporary `detectStaleData` setting has been removed from the runtime settings UI.
+
 ### Fixed
 - Signal K admin styling now loads from standalone CSS records in current Vite manifests while retaining support for entry-associated CSS and older server fallbacks.
 - `/live` and `/status` endpoints now return `null` for `tws`/`twa` (and downstream fields) when the wind smoother has no data or is stale, instead of `0`. The guard was checking for the presence of the smoother object rather than its `ready` state.
 - `computeAndSend`: when the polar table lookup fails (boat outside polar range — in irons or above max TWS), the `performance.polarSpeed`, `performance.polarSpeedRatio`, and `performance.targetSpeed` SK paths are now written with `null` instead of `0`. Writing `0` was misleading because it is a valid-looking value rather than an explicit "no data" signal.
 - Live input subscriptions are now re-established after prolonged silence for all subscribed inputs, not just true wind. Boat speed and optional true heading use the same recovery path, and the plugin now reports their lifecycle state through the webapp/status endpoints.
 
-### Changed
-- Idle input recovery is now always enabled; the temporary `detectStaleData` setting has been removed from the runtime settings UI.
-
 ## [1.2.1] - 2026-07-25
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-polar-performance-plugin",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "description": "Calculates live sailing performance from polar data, with built-in polar management and import tools.",
   "main": "plugin/index.js",
   "exports": {

package/plugin/PolarTable.js

@@ -208,13 +208,17 @@ class PolarTable {
       const maxTwa = Math.max(lowerLastTwa, upperLastTwa)
       const lowerLimit = lowerEntry._runExtrap?.extrapLimit ?? lowerLastTwa
       const upperLimit = upperEntry._runExtrap?.extrapLimit ?? upperLastTwa
+      // The interpolated limit is the effective polar boundary at this TWS —
+      // getBoatSpeed returns null above it, so report above_range even when the
+      // TWA is still tabulated for one of the brackets (the other bracket's
+      // tighter limit wins by design, keeping the boundary smooth across TWS).
       const extrapLimit = lowerLimit + twsInterp.ratio * (upperLimit - lowerLimit)
-      if (normalizedTwa <= maxTwa) {
-        twaState = 'in_range'
-      } else if (normalizedTwa <= extrapLimit) {
+      if (normalizedTwa > extrapLimit) {
+        twaState = 'above_range'
+      } else if (normalizedTwa > maxTwa) {
         twaState = 'extrapolated'
       } else {
-        twaState = 'above_range'
+        twaState = 'in_range'
       }
     }
 
@@ -366,25 +370,29 @@ class PolarTable {
    * Handles beat-angle quadratic extrapolation, run-angle quadratic extrapolation,
    * and normal bilinear lookup.
    *
+   * The in-irons boundary itself is NOT checked here — getBoatSpeed evaluates it
+   * against the interpolated beat angle so both TWS brackets share one boundary.
+   * When this entry's own beat angle is above the requested TWA, the boat is
+   * treated as stopped (0) rather than "no data", so the other bracket can
+   * still contribute to the TWS interpolation.
+   *
    * @private
    * @param {Object} entry  - A single TWS table entry (this.table[i])
    * @param {number} twa    - True Wind Angle in radians (0–π, already normalised)
-   * @returns {number|null} Boat speed in m/s, or null when in irons / beyond π
+   * @returns {number|null} Boat speed in m/s, or null when no tabulated data
+   *   covers the angle
    */
   _getSpeedFromEntry(entry, twa) {
     const beatAngle = entry['Beat angle']
     const twaArray  = entry.twa
 
-    // ── In irons: below the pinch point — no polar data ──────────────────────
-    if (beatAngle && twa < this.pinchFactor * beatAngle) return null
-
     // ── Beat angle extrapolation zone (pinch point … beat angle) ─────────────
     // Quadratic ramp anchored at 0 speed at pinchAngle (25°) through beat angle
     // with C1 continuity at beat angle.
     if (beatAngle && twa < beatAngle) {
-      if (!entry._beatExtrap) return null
+      if (!entry._beatExtrap) return 0
       const u = twa - entry._beatExtrap.zeroAngle
-      if (u <= 0) return null                         // below the analytic zero — treat as in irons
+      if (u <= 0) return 0                            // below the analytic zero — stopped
       return Math.max(0, entry._beatExtrap.a * u * u + entry._beatExtrap.b * u)
     }
 
@@ -422,6 +430,14 @@ class PolarTable {
     const lowerEntry = this.table[twsInterpolation.lowerIndex]
     const upperEntry = this.table[twsInterpolation.upperIndex]
 
+    // ── In irons: below the pinch point of the interpolated beat angle ──────
+    // Evaluating the boundary against the interpolated beat angle (like
+    // getInterpolationState) keeps the two consistent and avoids a discontinuity
+    // when neighbouring TWS entries carry different beat angles: with per-entry
+    // boundaries, the stricter bracket would null the whole interpolation.
+    const beatAngle = this.getBeatAngle(tws)
+    if (beatAngle && normalizedTwa < this.pinchFactor * beatAngle) return null
+
     // ── Run extrap limit: interpolate the limit between the two TWS brackets ───
     // Moving the check here (rather than per-entry) prevents a discontinuity
     // where the lower bracket's tighter limit would otherwise cause a sudden jump
@@ -470,25 +486,6 @@ class PolarTable {
   }
 
 
-  /**
-   * Helper method to process the TWS header row from CSV data.
-   * Creates the initial polar table structure with TWS entries.
-   * 
-   * @private
-   * @param {Array} row - CSV row containing 'twa/tws' and wind speed values
-   * @param {Object} app - Optional debug logging object
-   * @returns {Array} Array of polar entries with TWS values
-   */
-  _processTWSHeader(row, app) {
-    app && app.debug('First row with TWS columns')
-    const polar = []
-    for (let index = 1; index < row.length; index++) {
-      polar.push({ tws: SI.fromKnots(row[index]) })
-    }
-    app && app.debug('polar: %s', JSON.stringify(polar))
-    return polar
-  }
-
   /**
    * Helper method to add speed data to a polar table entry.
    * Handles TWA data addition and max speed tracking.
@@ -530,47 +527,6 @@ class PolarTable {
     }
   }
 
-  /**
-   * Helper method to process a speed data row from CSV.
-   * Handles both regular speed data and optimal angle rows.
-   * 
-   * @private
-   * @param {Array} row - CSV row with angle and speed data
-   * @param {Array} polar - Polar table array to update
-   * @param {Object} app - Optional debug logging object
-   */
-  _processSpeedRow(row, polar, app) {
-    const angle = SI.fromDegrees(Number(row[0]))
-    const halfPi = Math.PI / 2
-    
-    // Check if this is a beat/run angle row (multiple zeros — trim before comparing)
-    const isOptimalAngle = row.filter(i => i.trim() === '0').length > 1
-    let angleName, VMGName
-    
-    if (isOptimalAngle) {
-      app && app.debug('beat and run angles are included')
-      if (angle < halfPi) {
-        angleName = 'Beat angle'
-        VMGName = 'Beat VMG'
-        app && app.debug('cvsToPolar: row includes Beat angle: %s', row.join(';'))
-      } else {
-        angleName = 'Run angle'
-        VMGName = 'Run VMG'
-        app && app.debug('cvsToPolar: row includes Run angle: %s', row.join(';'))
-      }
-    }
-
-    // Process each TWS column
-    for (let index = 0; index < row.length - 1; index++) {
-      const speedValue = (row[index + 1] || '').trim()
-      if (speedValue && speedValue !== '0') {
-        const tbs = SI.fromKnots(Number(speedValue))
-        const vmg = tbs * Math.abs(Math.cos(angle))
-        this._addSpeedData(polar[index], angle, tbs, vmg, angleName, VMGName, app)
-      }
-    }
-  }
-
   /**
    * Helper method for decimal rounding.
    * 
@@ -587,8 +543,10 @@ class PolarTable {
    * Computes quadratic extrapolation coefficients for each TWS entry and stores
    * them on the entry as `_beatExtrap` and `_runExtrap`.
    *
-   * Called after _sortAndOptimizePolar (needs sorted twa arrays and beat/run angles)
-   * and before _addPolarPadding (operates on the raw data, not the padded form).
+   * Called after _sortAndOptimizePolar (needs sorted twa arrays and beat/run
+   * angles) and after _addPolarPadding, so the zero-wind padding entry receives
+   * degenerate zero-valued coefficients — exactly what light-wind interpolation
+   * toward zero needs.
    *
    * Beat angle model — f(u) = a·u² + b·u, u = twa − zeroAngle (pinchAngle = 25°):
    *   f(d)  = beatSpeed   where d = beatAngle − zeroAngle
@@ -770,6 +728,67 @@ class PolarTable {
     })
   }
 
+  /**
+   * Builds a complete per-TWS derived target table, filling gaps by interpolation.
+   *
+   * Many polar sources (Jieter/Expedition CSV exports, ORC data) only emit
+   * beat/run target rows for a subset of the TWS columns.  Without this pass,
+   * TWS entries lacking a target fall back to _sortAndOptimizePolar's
+   * argmax-VMG-over-tabulated-angles heuristic, which pins the beat angle to
+   * the lowest tabulated angle and disagrees sharply with neighbouring TWS
+   * entries — nulling out the pinch zone for every TWS interpolated against
+   * the gap (polar speed reads 0 while sailing).
+   *
+   * For each TWS axis value missing a beat (or run) target, the target is
+   * linearly interpolated from the nearest entries below and above that have
+   * one; at the ends of the axis the nearest available target is used as-is.
+   *
+   * @private
+   * @param {number[]} twsAxis - TWS axis values in m/s (ascending)
+   * @param {Array} derivedRows - Derived rows from the canonical resource
+   * @returns {Array<Object>} Array aligned with twsAxis; each item has optional
+   *   `beat`/`run` targets ({twa, tbs, vmg} in SI units)
+   */
+  _interpolateDerivedTargets(twsAxis, derivedRows) {
+    const targets = twsAxis.map(tws => {
+      const row = derivedRows.find(candidate => Math.abs(candidate.tws - tws) < 1e-6)
+      const target = {}
+      if (row?.beat && Number.isFinite(row.beat.twa) && Number.isFinite(row.beat.tbs)) {
+        target.beat = { ...row.beat }
+      }
+      if (row?.run && Number.isFinite(row.run.twa) && Number.isFinite(row.run.tbs)) {
+        target.run = { ...row.run }
+      }
+      return target
+    })
+
+    for (const key of ['beat', 'run']) {
+      for (let i = 0; i < targets.length; i++) {
+        if (targets[i][key]) continue
+
+        let lo = -1
+        let hi = -1
+        for (let j = i - 1; j >= 0; j--) { if (targets[j][key]) { lo = j; break } }
+        for (let j = i + 1; j < targets.length; j++) { if (targets[j][key]) { hi = j; break } }
+
+        if (lo >= 0 && hi >= 0 && twsAxis[hi] - twsAxis[lo] > 1e-9) {
+          const ratio = (twsAxis[i] - twsAxis[lo]) / (twsAxis[hi] - twsAxis[lo])
+          const a = targets[lo][key]
+          const b = targets[hi][key]
+          const twa = a.twa + ratio * (b.twa - a.twa)
+          const tbs = a.tbs + ratio * (b.tbs - a.tbs)
+          targets[i][key] = { twa, tbs, vmg: tbs * Math.abs(Math.cos(twa)) }
+        } else if (lo >= 0) {
+          targets[i][key] = { ...targets[lo][key] }
+        } else if (hi >= 0) {
+          targets[i][key] = { ...targets[hi][key] }
+        }
+      }
+    }
+
+    return targets
+  }
+
   /**
    * Loads polar table data from the canonical PolarResource representation.
    *
@@ -789,6 +808,12 @@ class PolarTable {
     }
 
     const derivedRows = Array.isArray(resource?.derived?.rows) ? resource.derived.rows : []
+    // Fill gaps in derived beat/run targets across TWS so entries without an
+    // explicit target get an interpolated one instead of falling back to the
+    // argmax-VMG-over-tabulated-angles heuristic (which pins the beat angle to
+    // the lowest tabulated angle and disagrees sharply with neighbouring TWS,
+    // nulling out the pinch zone for every TWS interpolated against the gap).
+    const derivedTargets = this._interpolateDerivedTargets(twsAxis, derivedRows)
     const polar = twsAxis.map(tws => ({ tws, twa: [] }))
 
     for (let rowIndex = 0; rowIndex < twsAxis.length; rowIndex++) {
@@ -808,9 +833,7 @@ class PolarTable {
         this._addSpeedData(polar[rowIndex], angle, tbs, vmg, null, null, null)
       }
 
-      const derivedRow = derivedRows[rowIndex] && Math.abs(derivedRows[rowIndex].tws - twsAxis[rowIndex]) < 1e-6
-        ? derivedRows[rowIndex]
-        : derivedRows.find(candidate => Math.abs(candidate.tws - twsAxis[rowIndex]) < 1e-6)
+      const derivedRow = derivedTargets[rowIndex]
 
       if (derivedRow?.beat && Number.isFinite(derivedRow.beat.twa) && Number.isFinite(derivedRow.beat.tbs)) {
         const beatVmg = Number.isFinite(derivedRow.beat.vmg)
@@ -848,8 +871,12 @@ class PolarTable {
     }
 
     this._sortAndOptimizePolar(polar, null)
-    this._computeExtrapolationCoefficients(polar, null)
+    // Padding must be in place before coefficients are computed so the zero-wind
+    // entry gets zero-valued _beatExtrap/_runExtrap models; without them, any
+    // low-wind lookup in the pinch or run-extrapolation zone returns null
+    // instead of interpolating smoothly toward zero.
     this._addPolarPadding(polar, null)
+    this._computeExtrapolationCoefficients(polar, null)
     this.table = polar
     return this
   }

package/plugin/index.js

@@ -182,10 +182,16 @@ module.exports = (app) => {
       app.debug('Settings migrated from v0 to v1')
     }
 
-    // Persist if any migration ran, so migrations don't repeat on next start
+    // Persist if any migration ran, so migrations don't repeat on next start.
+    // Signal K requires a callback; omitting it throws TypeError and aborts start().
     if ((s.settingsVersion ?? 0) > version) {
-      app.savePluginOptions(s)
-      app.debug('Migrated settings saved (v%d → v%d)', version, s.settingsVersion)
+      app.savePluginOptions(s, (err) => {
+        if (err) {
+          app.error('Failed to save migrated settings: ' + err.message)
+        } else {
+          app.debug('Migrated settings saved (v%d → v%d)', version, s.settingsVersion)
+        }
+      })
     }
 
     return s

package/test/PolarTable.test.js

@@ -243,6 +243,121 @@ describe('PolarTable — interpolation state', () => {
   })
 })
 
+describe('PolarTable — derived target gap filling', () => {
+  // Polar shaped like real Jieter/Expedition exports: derived beat/run targets
+  // only exist for a subset of TWS columns (here 6 kt has both, 12 kt only a
+  // run target, 16 kt only a beat target). Before the fix, the missing targets
+  // fell back to argmax-VMG over tabulated angles (beat angle = 52°, the lowest
+  // tabulated angle), nulling the pinch zone for every TWS interpolated
+  // against the gap — polar speed read 0 kn while sailing upwind at 11–15 kt.
+  const GAPPED = {
+    kind: 'polarTable',
+    schemaVersion: '1.0.0',
+    name: 'Gapped Polar',
+    units: { tws: 'm/s', twa: 'rad', boatSpeed: 'm/s' },
+    symmetry: { portStarboardSymmetric: true },
+    axes: {
+      tws: [6, 12, 16].map(SI.fromKnots),
+      twa: [52, 60, 75, 90, 110, 120, 135, 150, 160].map(SI.fromDegrees)
+    },
+    values: {
+      boatSpeedMatrix: [
+        [3.3, 3.2, 3.59, 3.51, 3.38, 2.95, 2.93, 2.56, 2.65].map(SI.fromKnots),
+        [4.84, 5.32, 5.52, 5.69, 5.46, 5.22, 4.93, 4.82, 4.98].map(SI.fromKnots),
+        [5.41, 5.8, 6.18, 6.18, 6.03, 6.02, 5.87, 5.62, 5.7].map(SI.fromKnots)
+      ]
+    },
+    derived: {
+      rows: [
+        { tws: SI.fromKnots(6), beat: targetPoint(39, 3.308), run: targetPoint(175, 4.435) },
+        { tws: SI.fromKnots(12), run: targetPoint(177, 5.177) },
+        { tws: SI.fromKnots(16), beat: targetPoint(38, 5.316) }
+      ]
+    }
+  }
+  let polar
+
+  before(() => { polar = new PolarTable().loadFromCanonical(GAPPED) })
+
+  it('interpolates a missing beat target across TWS (12 kt: between 39° and 38°)', () => {
+    const beat = polar.getBeatAngle(SI.fromKnots(12))
+    assert.ok(approxEqual(SI.toDegrees(beat), 38.4, 0.5),
+      `Expected ~38.4°, got ${SI.toDegrees(beat).toFixed(1)}°`)  
+  })
+
+  it('does not snap a gapped beat angle to the lowest tabulated angle (52°)', () => {
+    for (const tws of [7, 9, 11, 13, 15]) {
+      const beat = SI.toDegrees(polar.getBeatAngle(SI.fromKnots(tws)))
+      assert.ok(beat < 45, `Beat angle ${beat.toFixed(1)}° at ${tws} kt should stay below 45°`)
+    }
+  })
+
+  it('clamps a missing run target at the end of the TWS axis (16 kt ← 12 kt)', () => {
+    const run = polar.getRunAngle(SI.fromKnots(16))
+    assert.ok(approxEqual(SI.toDegrees(run), 177, 0.5),
+      `Expected ~177°, got ${SI.toDegrees(run).toFixed(1)}°`)
+  })
+
+  it('returns polar speed upwind between gapped TWS brackets (was 0 kn / null)', () => {
+    for (const tws of [9, 11, 13, 15]) {
+      const speed = polar.getBoatSpeed(SI.fromKnots(tws), SI.fromDegrees(40))
+      assert.ok(speed !== null && SI.toKnots(speed) > 3,
+        `Expected > 3 kn at ${tws} kt / 40°, got ${speed === null ? 'null' : SI.toKnots(speed).toFixed(2) + ' kn'}`)
+    }
+  })
+
+  it('keeps dead-downwind data at TWS interpolated against a run-angle gap', () => {
+    // 14–15 kt interpolate against the 16 kt bracket whose run target is filled
+    const speed = polar.getBoatSpeed(SI.fromKnots(15), SI.fromDegrees(170))
+    assert.ok(speed !== null && SI.toKnots(speed) > 4,
+      `Expected > 4 kn at 15 kt / 170°, got ${speed === null ? 'null' : SI.toKnots(speed).toFixed(2) + ' kn'}`)
+  })
+
+  it('interpolates toward zero below the first TWS column in the pinch zone', () => {
+    // 3 kt is below the 6 kt minimum: pinch zone (35.1° … 39°) must ramp
+    // toward zero instead of returning null
+    const speed = polar.getBoatSpeed(SI.fromKnots(3), SI.fromDegrees(37))
+    assert.ok(speed !== null && SI.toKnots(speed) > 0 && SI.toKnots(speed) < 3.308,
+      `Expected 0 < speed < 3.3 kn at 3 kt / 37°, got ${speed === null ? 'null' : SI.toKnots(speed).toFixed(2) + ' kn'}`)
+  })
+
+  it('interpolates toward zero below the first TWS column beyond the last TWA', () => {
+    const speed = polar.getBoatSpeed(SI.fromKnots(3), SI.fromDegrees(176))
+    assert.ok(speed !== null && SI.toKnots(speed) > 0 && SI.toKnots(speed) < 4.435,
+      `Expected 0 < speed < 4.4 kn at 3 kt / 176°, got ${speed === null ? 'null' : SI.toKnots(speed).toFixed(2) + ' kn'}`)
+  })
+})
+
+describe('PolarTable — getBoatSpeed / getInterpolationState consistency', () => {
+  // getBoatSpeed must return null exactly when the state machine reports
+  // in_irons or above_range — the two share the interpolated beat angle and
+  // the interpolated run-extrapolation limit.
+  let polar
+
+  before(() => { polar = new PolarTable().loadFromCanonical(CANONICAL) })
+
+  it('null ⇔ in_irons or above_range across a TWS/TWA sweep', () => {
+    for (let tws = 3; tws <= 26; tws += 0.5) {
+      for (let twa = 5; twa <= 180; twa += 1) {
+        const speed = polar.getBoatSpeed(SI.fromKnots(tws), SI.fromDegrees(twa))
+        const state = polar.getInterpolationState(SI.fromKnots(tws), SI.fromDegrees(twa))
+        const expectNull = state.twa === 'in_irons' || state.twa === 'above_range'
+        assert.equal(speed === null, expectNull,
+          `TWS ${tws} kt / ${twa}°: speed=${speed} but state=${state.tws}/${state.twa}`)
+      }
+    }
+  })
+
+  it('pinching zone returns a speed between 0 and the beat-angle speed', () => {
+    const tws = SI.fromKnots(12)
+    const beatAngle = polar.getBeatAngle(tws)
+    const speed = polar.getBoatSpeed(tws, 0.95 * beatAngle)
+    const beatSpeed = polar.getBoatSpeed(tws, beatAngle)
+    assert.ok(speed !== null && speed > 0 && speed < beatSpeed,
+      `Expected 0 < speed < ${SI.toKnots(beatSpeed).toFixed(2)} kn, got ${speed}`)
+  })
+})
+
 describe('PolarTable — port/starboard symmetry', () => {
   let polar
 

package/test/api.test.js

@@ -157,7 +157,12 @@ function makeApp(dataDir) {
     error: () => {},
     setPluginStatus: () => {},
     setPluginError: () => {},
-    savePluginOptions: (_options, callback) => callback && callback(),
+    savePluginOptions: (_options, callback) => {
+      if (typeof callback !== 'function') {
+        throw new TypeError('callback is not a function')
+      }
+      callback(null)
+    },
     getDataDirPath: () => dataDir,
     handleMessage: () => {},
     config: { port: 3000 },

package/test/lifecycle.test.js

@@ -16,7 +16,12 @@ function makeApp(dataDir) {
     error: () => {},
     setPluginStatus: () => {},
     setPluginError: () => {},
-    savePluginOptions: () => {},
+    savePluginOptions: (_options, callback) => {
+      if (typeof callback !== 'function') {
+        throw new TypeError('callback is not a function')
+      }
+      callback(null)
+    },
     getDataDirPath: () => dataDir,
     handleMessage: () => {},
     config: { port: 3000 },

package/test/migration.test.js

@@ -40,7 +40,13 @@ function makeApp(dataDir) {
     error: () => {},
     setPluginStatus: () => {},
     setPluginError: (msg) => errors.push(msg),
-    savePluginOptions: (opts) => saved.push(JSON.parse(JSON.stringify(opts))),
+    savePluginOptions: (opts, callback) => {
+      if (typeof callback !== 'function') {
+        throw new TypeError('callback is not a function')
+      }
+      saved.push(JSON.parse(JSON.stringify(opts)))
+      callback(null)
+    },
     getDataDirPath: () => dataDir,
     subscriptionmanager: {
       subscribe: (_sub, unsubscribes, _onErr, _onDelta) => {