signalk-polar-performance-plugin 1.4.0 → 2.1.0

package/plugin/index.js

@@ -1,11 +1,8 @@
 'use strict'
 
-const { PolarTable } = require('./PolarTable')
-const PolarFileStore = require('./PolarFileStore')
-const { ImportService, ImportError, createTimestampedId } = require('./import/ImportService')
-const canonical = require('./import/canonical')
-const { parseMatrixPolarText } = require('./import/matrixText')
+const { Polar } = require('polar-math')
 const {
+  MessageHandler,
   createSmoothedPolar,
   createSmoothedHandler,
   SmoothedAngle,
@@ -15,14 +12,10 @@ const {
   KalmanSmoother
 } = require('signalkutilities')
 
-const CURRENT_SETTINGS_VERSION = 1
-
-const STALE_RESUBSCRIBE_PERIOD = 60000 // ms — idle period before live input subscriptions are re-established
+const CURRENT_SETTINGS_VERSION = 2
 
 const DEFAULT_SETTINGS = {
   settingsVersion: CURRENT_SETTINGS_VERSION,
-  activePolar: '',
-  perfAdjust: 1,
   showAllTwsLines: true,
   smootherType: 'Exponential',
   smootherParamExponential: 1,
@@ -47,9 +40,17 @@ module.exports = (app) => {
   let changedOptions = {}     // staged but not yet applied
   let hasPendingChanges = false
   let isRunning = false
-  let polarTable = null
-  let store = null
-  let importService = null
+
+  // Active polar — sourced from the `polars.activePolar` / `polars.performanceFactor`
+  // SK paths (published by a 'polars' resource-provider plugin, e.g. signalk-polar-management).
+  // This plugin no longer stores or manages polar files itself.
+  let polar = null                 // polar-math Polar instance, or null when unavailable
+  let activePolarId = null
+  let activePolarDoc = null        // raw canonical resource, for descriptive metadata
+  let performanceFactor = 1
+  let activePolarHandler = null
+  let performanceFactorHandler = null
+
   let windSmoother = null
   let bspSmoother = null
   let hdgSmoother = null
@@ -82,7 +83,7 @@ module.exports = (app) => {
   function _setLifecycleWarning(id, status, path) {
     const safePath = path || 'unknown path'
     const message = status === 'idle'
-      ? `Input ${id} is idle on ${safePath}; resubscribing`
+      ? `Input ${id} is idle on ${safePath}`
       : `Input ${id} is stale on ${safePath}`
     lifecycleWarningMap.set(id, {
       id,
@@ -102,9 +103,8 @@ module.exports = (app) => {
       .sort((a, b) => b.updatedAt - a.updatedAt)
   }
 
-  function _wireHandlerWatchdog({ id, getPath, unsubscribe, subscribe }) {
+  function _wireHandlerWatchdog({ id, getPath }) {
     return {
-      idlePeriod: STALE_RESUBSCRIBE_PERIOD,
       onDelta: () => {
         _clearLifecycleWarning(id)
       },
@@ -117,14 +117,36 @@ module.exports = (app) => {
       onIdle: () => {
         if (!isRunning) return
         const path = getPath()
-        app.debug(`[${plugin.id}] idle input ${id} on ${path}; resubscribing`)
+        app.debug(`[${plugin.id}] idle input ${id} on ${path}`)
         _setLifecycleWarning(id, 'idle', path)
-        unsubscribe()
-        subscribe()
       }
     }
   }
 
+  // Ratios below this denominator (m/s) are numerically meaningless (near-zero wind).
+  const MIN_RATIO_DENOMINATOR = 0.01
+
+  function finiteOrNull(value) {
+    return Number.isFinite(value) ? value : null
+  }
+
+  function signed(angle, port) {
+    return angle === null ? null : angle * port
+  }
+
+  function ratio(numerator, denominator) {
+    if (!Number.isFinite(numerator) || !Number.isFinite(denominator)) return null
+    return denominator > MIN_RATIO_DENOMINATOR ? numerator / denominator : null
+  }
+
+  function publishNulls(paths) {
+    if (paths.length === 0) return
+    paths.forEach(path => { lastOutputs[path] = null })
+    app.handleMessage(plugin.id, {
+      updates: [{ values: paths.map(path => ({ path, value: null })) }]
+    })
+  }
+
   function getSmootherClass(type) {
     switch (type) {
       case 'None':          return BaseSmoother
@@ -158,30 +180,21 @@ module.exports = (app) => {
       delete s.useTWSsource
       delete s.useSOGsource
       delete s.trueWindSpeedPath
-
-      // Migrate embedded CSV polar to a canonical polar file.
-      // Only advance settingsVersion if the CSV is successfully written —
-      // if it fails, keep csvTable so the migration retries on next start.
-      if (s.csvTable && s.csvTable.trim()) {
-        try {
-          const { resource } = parseMatrixPolarText(s.csvTable)
-          store.saveCanonical('migrated-polar', resource)
-          s.activePolar = 'migrated-polar'
-          delete s.csvTable
-          app.debug('Legacy csvTable migrated to migrated-polar.json')
-        } catch (e) {
-          app.setPluginError('Migration failed — could not save legacy CSV: ' + e.message)
-          app.debug('CSV migration error: %s', e.message)
-          return s  // abort; csvTable kept so next start retries
-        }
-      } else {
-        delete s.csvTable
-      }
-
+      delete s.csvTable
       s.settingsVersion = 1
       app.debug('Settings migrated from v0 to v1')
     }
 
+    if (s.settingsVersion < 2) {
+      // v1 → v2: polar selection and performance adjustment moved to the
+      // `polars.activePolar` / `polars.performanceFactor` SK paths, published
+      // by a 'polars' resource-provider plugin (e.g. signalk-polar-management).
+      delete s.activePolar
+      delete s.perfAdjust
+      s.settingsVersion = 2
+      app.debug('Settings migrated from v1 to v2')
+    }
+
     // 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) {
@@ -197,6 +210,62 @@ module.exports = (app) => {
     return s
   }
 
+  // ---------------------------------------------------------------------------
+  // Active polar — sourced from SK paths published by a 'polars' resource provider
+  // ---------------------------------------------------------------------------
+
+  // Extracts the resource id from an `href` of the shape `/resources/polars/<id>`.
+  function hrefToId(href) {
+    if (typeof href !== 'string') return null
+    const match = href.match(/\/resources\/polars\/([^/]+)$/)
+    return match ? match[1] : null
+  }
+
+  async function checkPolarProvider() {
+    if (!app.resourcesApi || typeof app.resourcesApi.listResources !== 'function') return false
+    try {
+      await app.resourcesApi.listResources('polars', {})
+      return true
+    } catch (_e) {
+      return false
+    }
+  }
+
+  function handleActivePolarDelta() {
+    const value = activePolarHandler.value
+    const href = value?.href
+    if (!href) {
+      polar = null
+      activePolarId = null
+      activePolarDoc = null
+      nullifyOutputs()
+      app.setPluginStatus('No active polar selected — select one in the polar management webapp')
+      return
+    }
+
+    const id = hrefToId(href)
+    if (!id) {
+      app.setPluginError(`Cannot parse active polar href: ${href}`)
+      return
+    }
+
+    app.resourcesApi.getResource('polars', id).then((doc) => {
+      try {
+        polar = Polar.fromTable(doc)
+        activePolarId = id
+        activePolarDoc = doc
+        app.setPluginStatus(`Polar '${doc.name || id}' loaded`)
+      } catch (e) {
+        // Keep the last valid polar (if any) rather than dropping outputs on a bad update.
+        app.setPluginError(`Invalid active polar '${id}': ${e.message}`)
+        if (!polar) nullifyOutputs()
+      }
+    }).catch((e) => {
+      app.setPluginError(`Cannot load active polar '${id}': ${e.message}`)
+      if (!polar) nullifyOutputs()
+    })
+  }
+
   // ---------------------------------------------------------------------------
   // Hot-apply runtime option changes
   // ---------------------------------------------------------------------------
@@ -211,25 +280,6 @@ module.exports = (app) => {
     changedOptions = {}
     hasPendingChanges = false
 
-    // Active polar — load new table
-    if ('activePolar' in settings || 'perfAdjust' in settings) {
-      if (keys.includes('activePolar') && settings.activePolar) {
-        try {
-          polarTable = store.load(settings.activePolar)
-          polarTable.setPerformanceAdjustment(settings.perfAdjust || 1)
-          app.setPluginStatus(`Polar '${settings.activePolar}' loaded`)
-        } catch (e) {
-          app.setPluginError(`Cannot load polar '${settings.activePolar}': ${e.message}`)
-        }
-      } else if (keys.includes('activePolar') && !settings.activePolar) {
-        polarTable = null
-        nullifyOutputs()
-        app.setPluginStatus('No polar configured — set activePolar or upload a CSV file')
-      } else if (keys.includes('perfAdjust') && polarTable) {
-        polarTable.setPerformanceAdjustment(settings.perfAdjust)
-      }
-    }
-
     // Smoother type or parameter changes — update all running smoothers in-place
     const SMOOTHER_KEYS = ['smootherType', 'smootherParamExponential', 'smootherParamMovingAverage', 'smootherParamKalman']
     if (keys.some(k => SMOOTHER_KEYS.includes(k))) {
@@ -259,9 +309,8 @@ module.exports = (app) => {
           SmootherClass: SC,
           smootherOptions: so,
           ..._wireHandlerWatchdog({
-            get path() { return hdgSmoother?.handler?.path ?? 'navigation.headingTrue' },
-            unsubscribe: () => hdgSmoother?.unsubscribe(),
-            subscribe: () => hdgSmoother?.subscribe(false, true),
+            id: 'hdg.smoothed',
+            getPath: () => hdgSmoother?.handler?.path ?? 'navigation.headingTrue',
           })
         })
       } else if (!settings.tackTrue && hdgSmoother) {
@@ -278,11 +327,7 @@ module.exports = (app) => {
     const disabledPaths = keys
       .filter(k => OUTPUT_PATHS[k] && !settings[k])
       .flatMap(k => OUTPUT_PATHS[k])
-    if (disabledPaths.length) {
-      app.handleMessage(plugin.id, {
-        updates: [{ values: disabledPaths.map(path => ({ path, value: null })) }]
-      })
-    }
+    publishNulls(disabledPaths)
   }
 
   // ---------------------------------------------------------------------------
@@ -291,10 +336,7 @@ module.exports = (app) => {
   // ---------------------------------------------------------------------------
 
   function nullifyOutputs() {
-    const allPaths = Object.values(OUTPUT_PATHS).flat()
-    app.handleMessage(plugin.id, {
-      updates: [{ values: allPaths.map(path => ({ path, value: null })) }]
-    })
+    publishNulls(Object.values(OUTPUT_PATHS).flat())
   }
 
   // ---------------------------------------------------------------------------
@@ -303,168 +345,132 @@ module.exports = (app) => {
 
   function computeAndSend() {
     if (hasPendingChanges) applyOptionChanges()
-    if (!polarTable) return
+    if (!polar) return
 
     const wind = windSmoother.polarValue
     const TWS = wind.magnitude
     const TWAsigned = wind.angle
-    if (!Number.isFinite(TWS) || !Number.isFinite(TWAsigned)) return
+    const windValid = Number.isFinite(TWS) && Number.isFinite(TWAsigned)
 
     // TWA is always positive for polar lookups; sign is tracked via `port`
-    const TWA = Math.abs(TWAsigned)
+    const TWA = windValid ? Math.abs(TWAsigned) : null
     const port = TWAsigned < 0 ? -1 : 1
-    const BSP = bspSmoother ? bspSmoother.value : null
-    const HDG = hdgSmoother ? hdgSmoother.value : null
+    const BSP = finiteOrNull(bspSmoother ? bspSmoother.value : null)
+    const HDG = finiteOrNull(hdgSmoother ? hdgSmoother.value : null)
 
     const values = []
     const metas = []
 
-    function add(skPath, value, unit, description) {
-      if (!Number.isFinite(value)) return
-      values.push({ path: skPath, value })
-      if (!metaSentPaths.has(skPath)) {
-        metas.push({ path: skPath, value: { units: unit, description } })
-        metaSentPaths.add(skPath)
-      }
-    }
-
-    // Always emit smoothed inputs
-    if (settings.smoothedInputs) {
-      add('environment.wind.angleTrueWaterDamped', TWAsigned, 'rad',
-        'True Wind Angle after smoothing, negative to port.')
-      if (Number.isFinite(BSP)) {
-        add('performance.boatSpeedDamped', BSP, 'm/s', 'Boat speed after smoothing.')
+    // Each enabled output is either published or explicitly cleared, so
+    // consumers never keep seeing a frozen value once its inputs disappear.
+    // Nulls are only sent on the transition to unavailable to limit bus traffic.
+    function output(settingKey, skPath, value, unit, description) {
+      if (!settings[settingKey]) return
+      if (Number.isFinite(value)) {
+        values.push({ path: skPath, value })
+        if (!metaSentPaths.has(skPath)) {
+          metas.push({ path: skPath, value: { units: unit, description } })
+          metaSentPaths.add(skPath)
+        }
+      } else if (lastOutputs[skPath] !== null) {
+        values.push({ path: skPath, value: null })
       }
     }
 
-    // Polar lookups
-    const isUpwind = TWA < Math.PI / 2
-    const beatAngle = polarTable.getBeatAngle(TWS)
-    const runAngle  = polarTable.getRunAngle(TWS)
-    const beatVMG   = polarTable.getBeatVMG(TWS)
-    const runVMG    = polarTable.getRunVMG(TWS)
+    // Output classes:
+    // - measured values (actual VMG, damped inputs) are published whenever their inputs are valid;
+    // - steering advice (target angle, optimum wind angle, tack heading) is always published,
+    //   including in irons, where it says how far to bear away;
+    // - all other polar values and polar ratios are cleared in irons, where the polar says nothing
+    //   about the boat's current state.
+    const isUpwind = windValid && TWA < Math.PI / 2
+    const speedResult = windValid ? polar.speedAt({ tws: TWS, twa: TWA, performanceFactor }) : null
+    const inIrons = speedResult?.state?.twa === 'in_irons'
+    const fromPolar = value => (inIrons ? null : finiteOrNull(value))
+
+    const targets = windValid ? polar.targetsAt({ tws: TWS, performanceFactor }).value : null
+    const adviceBeatAngle = finiteOrNull(targets?.beat?.twa)
+    const adviceRunAngle  = finiteOrNull(targets?.run?.twa)
+    const adviceAngle     = isUpwind ? adviceBeatAngle : adviceRunAngle
+
+    const beatAngle = fromPolar(adviceBeatAngle)
+    const runAngle  = fromPolar(adviceRunAngle)
+    const beatVMG   = fromPolar(targets?.beat?.vmg)
+    const runVMG    = fromPolar(targets?.run?.vmg)
     const targetAngle = isUpwind ? beatAngle : runAngle
     const targetVMG   = isUpwind ? beatVMG   : runVMG
+    const maxSpeed = fromPolar(targets?.maxSpeed?.speed)
+    const maxSpeedAngle = maxSpeed === null ? null : finiteOrNull(targets?.maxSpeed?.twa)
 
-    if (Number.isFinite(beatAngle)) {
-      if (settings.beatAngle) {
-        add('performance.beatAngle', beatAngle * port, 'rad',
-          'Optimal beat angle for current TWS, negative to port.')
-      }
-      if (settings.targetTWA && isUpwind) {
-        add('performance.targetAngle', beatAngle * port, 'rad',
-          'Target TWA — auto-switches between beat and run, negative to port.')
-      }
-    }
-
-    if (Number.isFinite(runAngle)) {
-      if (settings.beatAngle) {
-        add('performance.gybeAngle', runAngle * port, 'rad',
-          'Optimal run/gybe angle for current TWS, negative to port.')
-      }
-      if (settings.targetTWA && !isUpwind) {
-        add('performance.targetAngle', runAngle * port, 'rad',
-          'Target TWA — auto-switches between beat and run, negative to port.')
-      }
-    }
-
-    if (Number.isFinite(beatVMG)) {
-      if (settings.beatVMG) {
-        add('performance.beatAngleVelocityMadeGood', beatVMG, 'm/s',
-          'Optimal beat VMG for current TWS.')
-      }
-      if (settings.targetTWA && isUpwind) {
-        add('performance.targetVelocityMadeGood', beatVMG, 'm/s',
-          'Target VMG — auto-switches between beat and run.')
-      }
-    }
-
-    if (Number.isFinite(runVMG)) {
-      if (settings.beatVMG) {
-        add('performance.gybeAngleVelocityMadeGood', runVMG, 'm/s',
-          'Optimal run VMG for current TWS.')
-      }
-      if (settings.targetTWA && !isUpwind) {
-        add('performance.targetVelocityMadeGood', runVMG, 'm/s',
-          'Target VMG — auto-switches between beat and run.')
-      }
-    }
+    // Polar speed at the current TWA is also unavailable outside the polar's angle range
+    const speedAtTwa = speedResult?.value
+    const polarSpeed = Number.isFinite(speedAtTwa) && speedAtTwa > 0 ? speedAtTwa : null
 
-    // Optimum wind angle: angular difference between current TWA and optimal angle
-    if (settings.optimumWindAngle) {
-      if (isUpwind && Number.isFinite(beatAngle)) {
-        add('performance.optimumWindAngle', (TWA - beatAngle) * port, 'rad',
-          'Difference between TWA and beat angle, negative to port.')
-      } else if (!isUpwind && Number.isFinite(runAngle)) {
-        add('performance.optimumWindAngle', (runAngle - TWA) * port * -1, 'rad',
-          'Difference between TWA and run angle, negative to port.')
-      }
-    }
+    const targetCos = targetAngle === null ? 0 : Math.abs(Math.cos(targetAngle))
+    const targetSpeed = targetVMG !== null && targetVMG >= 0 && targetCos > 0.01
+      ? targetVMG / targetCos
+      : null
 
-    // Polar speed and performance ratios
-    const polarSpeed = polarTable.getBoatSpeed(TWS, TWA)
-    if (Number.isFinite(polarSpeed) && polarSpeed > 0) {
-      if (settings.polarSpeed) {
-        add('performance.polarSpeed', polarSpeed, 'm/s',
-          'Polar chart boat speed for current TWS and TWA.')
-
-        // Target speed: only meaningful when sailing within the polar range
-        if (Number.isFinite(targetAngle) && Number.isFinite(targetVMG)) {
-          const cosTarget = Math.abs(Math.cos(targetAngle))
-          if (cosTarget > 0.01) {
-            add('performance.targetSpeed', targetVMG / cosTarget, 'm/s',
-              'Boat speed needed to achieve target VMG at the optimal angle.')
-          }
-        }
+    const vmg = windValid && BSP !== null ? BSP * Math.cos(TWA) : null
+    const vmgRatio = ratio(vmg === null ? null : Math.abs(vmg), targetVMG)
 
-        if (Number.isFinite(BSP)) {
-          add('performance.polarSpeedRatio', BSP / polarSpeed, 'ratio',
-            'Actual boat speed divided by polar speed.')
-        }
-      }
+    let optimumWindAngle = null
+    if (isUpwind && adviceBeatAngle !== null) optimumWindAngle = (TWA - adviceBeatAngle) * port
+    else if (windValid && !isUpwind && adviceRunAngle !== null) optimumWindAngle = (adviceRunAngle - TWA) * port * -1
 
-      if (Number.isFinite(BSP)) {
-        if (settings.VMG && Number.isFinite(targetVMG) && targetVMG > 0) {
-          const vmg = BSP * Math.cos(TWA)
-          add('performance.velocityMadeGood', vmg, 'm/s',
-            'Actual VMG based on current boat speed and TWA.')
-          add('performance.polarVelocityMadeGood', targetVMG, 'm/s',
-            'Polar VMG for current TWS.')
-          if (Number.isFinite(vmg)) {
-            add('performance.polarVelocityMadeGoodRatio', Math.abs(vmg) / targetVMG, 'ratio',
-              'Actual VMG divided by polar VMG.')
-          }
-        }
-      }
-    } else {
-      // Clear these paths so no stale non-zero value remains on the SK bus
-      if (settings.polarSpeed) {
-        values.push({ path: 'performance.polarSpeed', value: null })
-        values.push({ path: 'performance.polarSpeedRatio', value: null })
-        values.push({ path: 'performance.targetSpeed', value: null })
-      }
-    }
-
-    // Max speed for current TWS
-    if (settings.maxSpeed) {
-      const maxSpeed = polarTable.getMaxSpeed(TWS)
-      const maxSpeedAngle = polarTable.getMaxSpeedAngle(TWS)
-      if (Number.isFinite(maxSpeed)) {
-        add('performance.maxSpeed', maxSpeed, 'm/s',
-          'Maximum polar boat speed for current TWS.')
-        add('performance.maxSpeedAngle', maxSpeedAngle * port, 'rad',
-          'TWA at which maximum speed is achieved, negative to port.')
-      }
-    }
-
-    // Opposite tack heading
-    if (settings.tackTrue && Number.isFinite(HDG) && Number.isFinite(targetAngle)) {
-      let tack = port < 0 ? HDG - targetAngle : HDG + targetAngle
+    let tack = null
+    if (HDG !== null && adviceAngle !== null) {
+      tack = port < 0 ? HDG - adviceAngle : HDG + adviceAngle
       tack = ((tack % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI)
-      add('performance.tackTrue', tack, 'rad',
-        'Opposite tack heading relative to true north.')
     }
 
+    output('smoothedInputs', 'environment.wind.angleTrueWaterDamped', windValid ? TWAsigned : null, 'rad',
+      'True Wind Angle after smoothing, negative to port.')
+    output('smoothedInputs', 'performance.boatSpeedDamped', BSP, 'm/s',
+      'Boat speed after smoothing.')
+
+    output('beatAngle', 'performance.beatAngle', signed(beatAngle, port), 'rad',
+      'Optimal beat angle for current TWS, negative to port.')
+    output('beatAngle', 'performance.gybeAngle', signed(runAngle, port), 'rad',
+      'Optimal run/gybe angle for current TWS, negative to port.')
+
+    output('beatVMG', 'performance.beatAngleVelocityMadeGood', beatVMG, 'm/s',
+      'Optimal beat VMG for current TWS.')
+    output('beatVMG', 'performance.gybeAngleVelocityMadeGood', runVMG, 'm/s',
+      'Optimal run VMG for current TWS.')
+
+    output('targetTWA', 'performance.targetAngle', signed(adviceAngle, port), 'rad',
+      'Target TWA — auto-switches between beat and run, negative to port.')
+    output('targetTWA', 'performance.targetVelocityMadeGood', targetVMG, 'm/s',
+      'Target VMG — auto-switches between beat and run.')
+
+    output('optimumWindAngle', 'performance.optimumWindAngle', optimumWindAngle, 'rad',
+      isUpwind
+        ? 'Difference between TWA and beat angle, negative to port. The optimal angle comes from the polar for the current true wind speed; zero means sailing at the optimal angle.'
+        : 'Difference between TWA and run angle, negative to port. The optimal angle comes from the polar for the current true wind speed; zero means sailing at the optimal angle.')
+
+    output('polarSpeed', 'performance.polarSpeed', polarSpeed, 'm/s',
+      'Polar chart boat speed for current TWS and TWA.')
+    output('polarSpeed', 'performance.targetSpeed', targetSpeed, 'm/s',
+      'Boat speed needed to achieve target VMG at the optimal angle.')
+    output('polarSpeed', 'performance.polarSpeedRatio', ratio(BSP, polarSpeed), 'ratio',
+      'Actual boat speed divided by polar speed.')
+
+    output('VMG', 'performance.velocityMadeGood', vmg, 'm/s',
+      'Actual VMG based on current boat speed and TWA.')
+    output('VMG', 'performance.polarVelocityMadeGood', targetVMG, 'm/s',
+      "Polar VMG for current TWS. The VMG predicted by the polar, not the vessel's actual VMG.")
+    output('VMG', 'performance.polarVelocityMadeGoodRatio', vmgRatio, 'ratio',
+      'Actual VMG divided by polar VMG.')
+
+    output('maxSpeed', 'performance.maxSpeed', maxSpeed, 'm/s',
+      'Maximum polar boat speed for current TWS.')
+    output('maxSpeed', 'performance.maxSpeedAngle', signed(maxSpeedAngle, port), 'rad',
+      'TWA at which maximum speed is achieved, negative to port.')
+
+    output('tackTrue', 'performance.tackTrue', tack, 'rad',
+      'Opposite tack heading relative to true north.')
+
     if (values.length === 0) return
 
     if (metas.length > 0) {
@@ -473,11 +479,8 @@ module.exports = (app) => {
 
     app.handleMessage(plugin.id, { updates: [{ values }] })
 
-    // Snapshot enabled outputs for /status endpoint
-    // Each output key maps to an array of { path, value } computed this cycle
-    const outputSnapshot = {}
-    values.forEach(({ path, value }) => { outputSnapshot[path] = value })
-    Object.assign(lastOutputs, outputSnapshot)
+    // Snapshot outputs for the /status endpoint and null-transition tracking
+    values.forEach(({ path, value }) => { lastOutputs[path] = value })
   }
 
   // ---------------------------------------------------------------------------
@@ -491,7 +494,7 @@ module.exports = (app) => {
 
     schema: () => ({
       type: "object",
-      description: "The plugin is configured through its webapp. Open it from the Signal K app list (Webapps → Advanced Wind) to set sources, enable corrections and adjust parameters.",
+      description: "The plugin is configured through its webapp. Open it from the Signal K app list (Webapps → Polar Performance) to set sources, enable corrections and adjust parameters. Select the active polar and performance factor in the Polar Management webapp.",
       properties: {}
 }),
 
@@ -503,76 +506,24 @@ module.exports = (app) => {
     registerWithRouter(router) {
       app.debug('registerWithRouter')
 
-      function getStore() {
-        if (!store) {
-          store = new PolarFileStore(app.getDataDirPath())
-        }
-        return store
-      }
-
-      function loadStoredPolar(id) {
-        return getStore().load(id)
-      }
-
-      // Size-1 cache: avoids reloading from disk when consecutive query requests
-      // target the same polar ID (e.g. the N parallel curve fetches on startup).
-      // perfAdjust is applied fresh on every use so it is never part of the key.
-      let cachedPolar = null  // { id, table } | null
-
-      function loadPolarCached(id) {
-        if (!cachedPolar || cachedPolar.id !== id) {
-          cachedPolar = { id, table: loadStoredPolar(id) }
-        }
-        cachedPolar.table.setPerformanceAdjustment(settings.perfAdjust || 1)
-        return cachedPolar.table
-      }
-
-      function invalidatePolarCache(id) {
-        if (cachedPolar && cachedPolar.id === id) cachedPolar = null
-      }
-
-      function getImportService() {
-        if (!importService) {
-          importService = new ImportService(getStore())
-        }
-        return importService
-      }
-
-      // Lightweight internet connectivity probe.
-      // Attempts a HEAD request to Cloudflare's public DNS (1.1.1.1) with a
-      // 3-second timeout.  Returns true if any HTTP response is received,
-      // false on network error or timeout.
-      async function checkInternet() {
-        const TIMEOUT_MS = 3000
-        try {
-          const controller = new AbortController()
-          const timer = setTimeout(() => controller.abort(), TIMEOUT_MS)
-          const response = await fetch('https://1.1.1.1', { method: 'HEAD', signal: controller.signal })
-            .finally(() => clearTimeout(timer))
-          return response.status < 600
-        } catch (_) {
-          return false
-        }
-      }
-
       function errorStatus(error) {
-        return /Polar not found/i.test(error.message) ? 404 : 500
+        return /No active polar/i.test(error.message) ? 404 : 500
       }
 
       function toFixedNumber(value, digits) {
         return Number.isFinite(value) ? parseFloat(value.toFixed(digits)) : null
       }
 
-      function getPolarTwsValues(table) {
-        return table.table
+      function getPolarTwsValues() {
+        return polar.entries
           .filter(entry => entry.tws > 0.001)
           .map(entry => parseFloat(entry.tws.toFixed(4)))
       }
 
-      function buildCurveResult(table, tws, stepRad) {
+      function buildCurveResult(tws, stepRad) {
         const points = []
         for (let twa = 0; twa <= Math.PI + 1e-9; twa += stepRad) {
-          const tbs = table.getBoatSpeed(tws, twa)
+          const { value: tbs } = polar.speedAt({ tws, twa, performanceFactor })
           if (Number.isFinite(tbs) && tbs > 0) {
             points.push({
               twa: toFixedNumber(twa, 5),
@@ -581,325 +532,47 @@ module.exports = (app) => {
           }
         }
 
-        const beatAngle = table.getBeatAngle(tws)
-        const beatVMG = table.getBeatVMG(tws)
-        const runAngle = table.getRunAngle(tws)
-        const runVMG = table.getRunVMG(tws)
-        const beatTbs = Number.isFinite(beatAngle) ? table.getBoatSpeed(tws, beatAngle) : null
-        const runTbs = Number.isFinite(runAngle) ? table.getBoatSpeed(tws, runAngle) : null
-
+        const { value: targets } = polar.targetsAt({ tws, performanceFactor })
         return {
           tws,
           points,
-          beat: (Number.isFinite(beatAngle) && Number.isFinite(beatTbs)) ? {
-            twa: toFixedNumber(beatAngle, 5),
-            tbs: toFixedNumber(beatTbs, 4),
-            vmg: toFixedNumber(beatVMG, 4)
+          beat: targets?.beat ? {
+            twa: toFixedNumber(targets.beat.twa, 5),
+            tbs: toFixedNumber(targets.beat.speed, 4),
+            vmg: toFixedNumber(targets.beat.vmg, 4)
           } : null,
-          run: (Number.isFinite(runAngle) && Number.isFinite(runTbs)) ? {
-            twa: toFixedNumber(runAngle, 5),
-            tbs: toFixedNumber(runTbs, 4),
-            vmg: toFixedNumber(runVMG, 4)
+          run: targets?.run ? {
+            twa: toFixedNumber(targets.run.twa, 5),
+            tbs: toFixedNumber(targets.run.speed, 4),
+            vmg: toFixedNumber(targets.run.vmg, 4)
           } : null
         }
       }
 
-      function buildSpeedResult(table, tws, twa) {
-        const tbs = table.getBoatSpeed(tws, twa)
-        return {
-          tws,
-          twa,
-          tbs: toFixedNumber(tbs, 4),
-          state: table.getInterpolationState(tws, twa)
-        }
-      }
-
-      function buildTargetsResult(table, tws) {
-        const beatAngle = table.getBeatAngle(tws)
-        const runAngle = table.getRunAngle(tws)
-        const beatVMG = table.getBeatVMG(tws)
-        const runVMG = table.getRunVMG(tws)
-        const beatTbs = Number.isFinite(beatAngle) ? table.getBoatSpeed(tws, beatAngle) : null
-        const runTbs = Number.isFinite(runAngle) ? table.getBoatSpeed(tws, runAngle) : null
-
-        return {
-          tws,
-          beat: (Number.isFinite(beatAngle) && Number.isFinite(beatTbs)) ? {
-            twa: toFixedNumber(beatAngle, 5),
-            tbs: toFixedNumber(beatTbs, 4),
-            vmg: toFixedNumber(beatVMG, 4)
-          } : null,
-          run: (Number.isFinite(runAngle) && Number.isFinite(runTbs)) ? {
-            twa: toFixedNumber(runAngle, 5),
-            tbs: toFixedNumber(runTbs, 4),
-            vmg: toFixedNumber(runVMG, 4)
-          } : null
-        }
-      }
-
-      function buildPerformanceMetric(polarValue, actualValue) {
-        if (!Number.isFinite(polarValue) || polarValue <= 0 || !Number.isFinite(actualValue)) {
-          return null
-        }
-        return {
-          polar: toFixedNumber(polarValue, 4),
-          actual: toFixedNumber(actualValue, 4),
-          ratio: toFixedNumber(actualValue / polarValue, 5)
-        }
-      }
-
-      function buildPerformanceResult(table, tws, twa, bsp) {
-        const polarSpeed = table.getBoatSpeed(tws, twa)
-        const upwindLimit = Math.PI / 3
-        const downwindLimit = 2 * Math.PI / 3
-
-        let direction = 'reaching'
-        let polarVmg = null
-        let actualVmg = null
-        if (twa < upwindLimit) {
-          direction = 'upwind'
-          polarVmg = table.getBeatVMG(tws)
-          actualVmg = bsp * Math.cos(twa)
-        } else if (twa > downwindLimit) {
-          direction = 'downwind'
-          polarVmg = table.getRunVMG(tws)
-          actualVmg = Math.abs(bsp * Math.cos(twa))
-        }
-
-        return {
-          tws,
-          twa,
-          bsp,
-          direction,
-          speed: buildPerformanceMetric(polarSpeed, bsp),
-          vmg: direction === 'reaching' ? null : buildPerformanceMetric(polarVmg, actualVmg)
-        }
-      }
-
-      function validatePolarResourceBody(resource) {
-        return canonical.validateCanonicalPolarResourceBody(resource)
-      }
-
-      function generateCanonicalPolarId(resource) {
-        return createTimestampedId(
-          resource?.sailnumber || resource?.name || 'polar',
-          'polar',
-          (candidate) => getStore().exists(candidate),
-          Date.now
-        )
-      }
-
       router.use((req, res, next) => {
         res.set('Origin-Agent-Cluster', '?1')
         next()
       })
 
-      router.get('/polars/active', (req, res) => {
-        if (!settings.activePolar) {
-          return res.status(404).json({ error: 'No polar is currently active' })
-        }
-        res.json({ id: settings.activePolar })
-      })
-
-      router.put('/polars/active', (req, res) => {
-        const id = req.body?.id
-        if (typeof id !== 'string') {
-          return res.status(400).json({ error: "Expected JSON body with string 'id'" })
-        }
-
-        if (!id) {
-          polarTable = null
-          settings.activePolar = ''
-          app.savePluginOptions(settings, (err) => {
-            if (err) app.error('Failed to save settings: ' + err.message)
-          })
-          nullifyOutputs()
-          app.setPluginStatus('No polar configured — set activePolar or upload a CSV file')
-          return res.json({ id: '' })
-        }
-
-        try {
-          polarTable = loadStoredPolar(id)
-          polarTable.setPerformanceAdjustment(settings.perfAdjust || 1)
-          settings.activePolar = id
-          app.savePluginOptions(settings, (err) => {
-            if (err) app.error('Failed to save settings: ' + err.message)
-          })
-          app.setPluginStatus(`Polar '${id}' loaded`)
-          res.json({ id })
-        } catch (e) {
-          res.status(errorStatus(e)).json({ error: e.message })
-        }
-      })
-
-      router.delete('/polars/active', (_req, res) => {
-        polarTable = null
-        settings.activePolar = ''
-        app.savePluginOptions(settings, (err) => {
-          if (err) app.error('Failed to save settings: ' + err.message)
-        })
-        nullifyOutputs()
-        app.setPluginStatus('No polar configured — set activePolar or upload a CSV file')
-        res.json({ id: '' })
-      })
-
-      router.get('/imports/formats', (_req, res) => {
-        res.json(getImportService().listFormats())
-      })
-
-      router.get('/internet', async (_req, res) => {
-        res.json({ online: await checkInternet() })
-      })
-
-      router.get('/imports/sources', (_req, res) => {
-        res.json(getImportService().listSources())
-      })
-
-      router.post('/polars', (req, res) => {
-        const validationError = validatePolarResourceBody(req.body)
-        if (validationError) {
-          return res.status(400).json({ error: validationError })
-        }
-
-        try {
-          const id = generateCanonicalPolarId(req.body)
-          getStore().saveCanonical(id, {
-            ...req.body,
-            name: req.body.name || id
-          })
-          res.status(201).json({ id })
-        } catch (e) {
-          res.status(500).json({ error: e.message })
-        }
-      })
-
-      router.post('/imports/text/:format', (req, res) => {
-        try {
-          const result = getImportService().importText(req.params.format, req.body)
-          res.status(201).json({ id: result.id })
-        } catch (error) {
-          if (error instanceof ImportError) {
-            return res.status(error.status).json({ error: error.message })
-          }
-          res.status(500).json({ error: error.message })
-        }
-      })
+      // ---- Active polar curve queries (read-only — for the webapp's polar canvas) --
 
-      router.get('/imports/sources/:source/search', async (req, res) => {
-        if (!await checkInternet()) {
-          return res.status(503).json({ error: 'No internet connection — external source imports are unavailable' })
-        }
-        try {
-          const results = await getImportService().searchSource(req.params.source, req.query?.q)
-          res.json(results)
-        } catch (error) {
-          if (error instanceof ImportError) {
-            return res.status(error.status).json({ error: error.message })
-          }
-          res.status(500).json({ error: error.message })
-        }
+      router.access('readonly').get('/polar/axes/tws', (req, res) => {
+        if (!polar) return res.status(404).json({ error: 'No active polar selected' })
+        res.json(getPolarTwsValues())
       })
 
-      router.post('/imports/sources/:source/items/:externalId', async (req, res) => {
-        if (!await checkInternet()) {
-          return res.status(503).json({ error: 'No internet connection — external source imports are unavailable' })
-        }
+      router.access('readonly').get('/polar/queries/curve', (req, res) => {
+        if (!polar) return res.status(404).json({ error: 'No active polar selected' })
         try {
-          const result = await getImportService().importSource(req.params.source, req.params.externalId, req.body)
-          res.status(201).json({ id: result.id })
-        } catch (error) {
-          if (error instanceof ImportError) {
-            return res.status(error.status).json({ error: error.message })
-          }
-          res.status(500).json({ error: error.message })
-        }
-      })
-
-      router.get('/polars/:id/axes/tws', (req, res) => {
-        try {
-          const table = loadStoredPolar(req.params.id)
-          res.json(getPolarTwsValues(table))
-        } catch (e) {
-          res.status(errorStatus(e)).json({ error: e.message })
-        }
-      })
-
-      router.get('/polars/:id/queries/curve', (req, res) => {
-        try {
-          const table = loadPolarCached(req.params.id)
           const tws = parseFloat(req.query.tws)
           if (!Number.isFinite(tws) || tws < 0) {
             return res.status(400).json({ error: "'tws' query parameter required (m/s)" })
           }
           const stepRad = parseFloat(req.query.step) || (2 * Math.PI / 180)
-          if (!Number.isFinite(stepRad) || stepRad <= 0 || stepRad > Math.PI / 2) {
-            return res.status(400).json({ error: "'step' must be between 0 and π/2 radians" })
-          }
-          res.json(buildCurveResult(table, tws, stepRad))
-        } catch (e) {
-          res.status(errorStatus(e)).json({ error: e.message })
-        }
-      })
-
-      router.get('/polars/:id/queries/speed', (req, res) => {
-        try {
-          const table = loadPolarCached(req.params.id)
-          const tws = parseFloat(req.query.tws)
-          const twa = parseFloat(req.query.twa)
-          if (!Number.isFinite(tws) || tws < 0 || !Number.isFinite(twa) || twa < 0) {
-            return res.status(400).json({ error: "'tws' and 'twa' query parameters are required" })
+          if (!Number.isFinite(stepRad) || stepRad < Math.PI / 180 || stepRad > Math.PI / 2) {
+            return res.status(400).json({ error: "'step' must be between 1° and π/2 radians" })
           }
-          res.json(buildSpeedResult(table, tws, twa))
-        } catch (e) {
-          res.status(errorStatus(e)).json({ error: e.message })
-        }
-      })
-
-      router.get('/polars/:id/queries/targets', (req, res) => {
-        try {
-          const table = loadPolarCached(req.params.id)
-          const tws = parseFloat(req.query.tws)
-          if (!Number.isFinite(tws) || tws < 0) {
-            return res.status(400).json({ error: "'tws' query parameter required (m/s)" })
-          }
-          res.json(buildTargetsResult(table, tws))
-        } catch (e) {
-          res.status(errorStatus(e)).json({ error: e.message })
-        }
-      })
-
-      router.get('/polars/:id/queries/performance', (req, res) => {
-        try {
-          const table = loadPolarCached(req.params.id)
-          const tws = parseFloat(req.query.tws)
-          const twa = parseFloat(req.query.twa)
-          const bsp = parseFloat(req.query.bsp)
-          if (!Number.isFinite(tws) || tws < 0 || !Number.isFinite(twa) || twa < 0 || !Number.isFinite(bsp) || bsp < 0) {
-            return res.status(400).json({ error: "'tws', 'twa', and 'bsp' query parameters are required" })
-          }
-          res.json(buildPerformanceResult(table, tws, twa, bsp))
-        } catch (e) {
-          res.status(errorStatus(e)).json({ error: e.message })
-        }
-      })
-
-      router.get('/polars/:id/meta', (req, res) => {
-        try {
-          const polarStore = getStore()
-          const table = polarStore.load(req.params.id)
-          const meta = polarStore.readMeta(req.params.id)
-          const twsValues = getPolarTwsValues(table)
-          res.json({
-            id: req.params.id,
-            name: meta.boatName || req.params.id,
-            sailnumber: meta.sailnumber,
-            boatType: meta.boatType,
-            year: meta.year,
-            source: meta.source,
-            notes: meta.notes,
-            twsMin: twsValues.length ? twsValues[0] : null,
-            twsMax: twsValues.length ? twsValues[twsValues.length - 1] : null
-          })
+          res.json(buildCurveResult(tws, stepRad))
         } catch (e) {
           res.status(errorStatus(e)).json({ error: e.message })
         }
@@ -909,16 +582,17 @@ module.exports = (app) => {
       // tws/bsp/polarSpeed in m/s; twa in rad (positive = starboard, negative = port).
       // Returns null for any field not yet available (plugin not running,
       // no BSP source, polar not loaded, or boat in irons).
-      router.get('/live', (req, res) => {
+      router.access('readonly').get('/live', (req, res) => {
         const wind = windSmoother?.ready ? windSmoother.polarValue : null
         const TWS       = wind ? wind.magnitude : null
         const TWAsigned = wind ? wind.angle : null
         const TWA       = Number.isFinite(TWAsigned) ? Math.abs(TWAsigned) : null
         const BSP       = bspSmoother ? bspSmoother.value : null
 
-        const polarSpeed = (polarTable && Number.isFinite(TWS) && Number.isFinite(TWA))
-          ? polarTable.getBoatSpeed(TWS, TWA)
+        const polarResult = (polar && Number.isFinite(TWS) && Number.isFinite(TWA))
+          ? polar.speedAt({ tws: TWS, twa: TWA, performanceFactor })
           : null
+        const polarSpeed = polarResult ? polarResult.value : null
 
         const performance = (Number.isFinite(BSP) && Number.isFinite(polarSpeed) && polarSpeed > 0)
           ? BSP / polarSpeed
@@ -926,17 +600,13 @@ module.exports = (app) => {
 
         const si = v => Number.isFinite(v) ? parseFloat(v.toFixed(5)) : null
 
-        const polarState = (polarTable && Number.isFinite(TWS) && Number.isFinite(TWA))
-          ? polarTable.getInterpolationState(TWS, TWA)
-          : null
-
         res.json({
           tws:         si(TWS),
           twa:         si(TWAsigned),
           bsp:         si(BSP),
           polarSpeed:  si(polarSpeed),
           performance: Number.isFinite(performance) ? parseFloat(performance.toFixed(5)) : null,
-          polarState
+          polarState:  polarResult ? polarResult.state : null
         })
       })
 
@@ -947,7 +617,7 @@ module.exports = (app) => {
       // inputs.smoothed.* — value the plugin actually used for computation
       // outputs.*     — only present for enabled settings; null if polar not ready
       // polarState    — same as /live
-      router.get('/status', (req, res) => {
+      router.access('readonly').get('/status', (req, res) => {
         const si = v => (Number.isFinite(v) ? parseFloat(v.toFixed(5)) : null)
 
         // Raw inputs: read directly from the smoother handlers
@@ -964,8 +634,8 @@ module.exports = (app) => {
 
         const bspPath = settings.useSOG ? 'navigation.speedOverGround' : 'navigation.speedThroughWater'
 
-        const polarState = (polarTable && Number.isFinite(TWS) && Number.isFinite(TWAsigned))
-          ? polarTable.getInterpolationState(TWS, Math.abs(TWAsigned))
+        const polarState = (polar && Number.isFinite(TWS) && Number.isFinite(TWAsigned))
+          ? polar.speedAt({ tws: TWS, twa: Math.abs(TWAsigned), performanceFactor }).state
           : null
 
         // Build outputs object: only include paths that are enabled and were
@@ -1007,10 +677,10 @@ module.exports = (app) => {
       })
 
       // Metadata describing the units and display preferences for each field
-      // returned by /live and the canonical curve query endpoints. displayUnits are fetched from the
-      // SK server's path metadata so user unit preferences (kn vs m/s etc.) are
-      // respected. Falls back to safe defaults when SK metadata is unavailable.
-      router.get('/meta', (req, res) => {
+      // returned by /live and the canonical curve query endpoints, plus a
+      // read-only summary of the active polar and performance factor
+      // (both sourced from the `polars.*` SK paths — not editable here).
+      router.access('readonly').get('/meta', (req, res) => {
         const speed = { formula: 'value * 1.943844', symbol: 'kn', displayFormat: '0.0' }
         const angle = { formula: 'value * 57.29577951308231', symbol: '\u00b0', displayFormat: '0.0' }
         const ratio = { formula: 'value * 100', symbol: '%', displayFormat: '0.1' }
@@ -1023,7 +693,17 @@ module.exports = (app) => {
           performance: { units: 'ratio', displayUnits: ratio },
           'curve.tbs': { units: 'm/s', displayUnits: speed },
           'curve.vmg': { units: 'm/s', displayUnits: speed },
-          'curve.twa': { units: 'rad', displayUnits: angle }
+          'curve.twa': { units: 'rad', displayUnits: angle },
+          activePolar: activePolarDoc ? {
+            id: activePolarId,
+            name: activePolarDoc.name || activePolarId,
+            boatType: activePolarDoc.boatType ?? null,
+            sailnumber: activePolarDoc.sailnumber ?? null,
+            year: activePolarDoc.year ?? null,
+            source: activePolarDoc.source ?? null,
+            notes: activePolarDoc.notes ?? null
+          } : null,
+          performanceFactor
         })
       })
 
@@ -1043,115 +723,50 @@ module.exports = (app) => {
         // wind update (or immediately below if the plugin is already running).
         Object.assign(changedOptions, req.body)
         hasPendingChanges = true
-        // Drain immediately so source/polar changes take effect even when the
+        // Drain immediately so source changes take effect even when the
         // wind data stream is idle.
         if (isRunning) applyOptionChanges()
         res.json({ ...settings, ...changedOptions, _defaults: DEFAULT_SETTINGS })
       })
-
-      // ---- Polar file operations -------------------------------------------
-
-      router.get('/polars', (req, res) => {
-        try {
-          const polarStore = getStore()
-          const polars = polarStore.list().map((id) => {
-            const meta = polarStore.readMeta(id)
-            return {
-              id,
-              name: meta.boatName || id,
-              sailnumber: meta.sailnumber,
-              boatType: meta.boatType,
-              year: meta.year,
-              source: meta.source
-            }
-          })
-          res.json(polars)
-        } catch (e) {
-          res.status(500).json({ error: e.message })
-        }
-      })
-
-      router.get('/polars/:id', (req, res) => {
-        try {
-          const stored = getStore().readObject(req.params.id)
-          res.json({ ...stored, id: req.params.id })
-        } catch (e) {
-          res.status(404).json({ error: e.message })
-        }
-      })
-
-      router.put('/polars/:id', (req, res) => {
-        const validationError = validatePolarResourceBody(req.body)
-        if (validationError) {
-          return res.status(400).json({ error: validationError })
-        }
-
-        try {
-          getStore().saveCanonical(req.params.id, {
-            ...req.body,
-            name: req.body.name || req.params.id
-          })
-          invalidatePolarCache(req.params.id)
-          if (settings.activePolar === req.params.id) {
-            polarTable = loadStoredPolar(req.params.id)
-            polarTable.setPerformanceAdjustment(settings.perfAdjust || 1)
-          }
-          res.json({ id: req.params.id })
-        } catch (e) {
-          res.status(500).json({ error: e.message })
-        }
-      })
-
-      router.delete('/polars/:id', (req, res) => {
-        try {
-          getStore().delete(req.params.id)
-          invalidatePolarCache(req.params.id)
-          if (settings.activePolar === req.params.id) {
-            settings.activePolar = ''
-            polarTable = null
-            nullifyOutputs()
-            app.savePluginOptions(settings, (err) => {
-              if (err) app.error('Failed to save settings: ' + err.message)
-            })
-          }
-          res.json({ id: req.params.id })
-        } catch (e) {
-          res.status(errorStatus(e)).json({ error: e.message })
-        }
-      })
     },
 
     start(options) {
+      app.debug('Starting')
       metaSentPaths = new Set()  // reset so metadata is re-emitted after restart
       lifecycleWarningMap = new Map()
       lifecycleWarnings = []
-
-      store = new PolarFileStore(app.getDataDirPath())
-      importService = new ImportService(store)
+      polar = null
+      activePolarId = null
+      activePolarDoc = null
+      performanceFactor = 1
 
       settings = migrateSettings({ ...DEFAULT_SETTINGS, ...options, settingsVersion: options.settingsVersion ?? 0 })
 
-      const SmootherClass = getSmootherClass(settings.smootherType)
-      const smootherOptions = getSmootherOptions(settings.smootherType, settings)
-
-      // Load the active polar table
-      if (settings.activePolar) {
-        try {
-          polarTable = store.load(settings.activePolar)
-          polarTable.setPerformanceAdjustment(settings.perfAdjust || 1)
-          app.setPluginStatus(`Polar '${settings.activePolar}' loaded`)
-        } catch (e) {
-          // File missing or corrupt — run without a polar rather than crashing.
-          // Keep settings.activePolar so the user can see which file is broken
-          // and re-upload it without reconfiguring. Nullify any stale SK values.
-          polarTable = null
-          nullifyOutputs()
-          app.setPluginError(`Polar '${settings.activePolar}' could not be loaded: ${e.message}`)
-          app.debug('Polar load error: %s', e.message)
+      checkPolarProvider().then((available) => {
+        app.debug(`checkPolarProvider: ${available ? 'polars resource provider found' : 'no polars resource provider'}`)
+        if (!available) {
+          app.setPluginStatus("No 'polars' resource provider registered — install signalk-polar-management (or another plugin providing the 'polars' resource type) to select an active polar.")
         }
-      } else {
-        app.setPluginStatus('No polar configured — set activePolar or upload a CSV file')
+      })
+
+      // Active polar / performance factor — read-only, published by a 'polars' resource provider.
+      // These are event-driven (change only on user action), so sensor idle warnings
+      // do not apply here: absence of deltas is the normal state.
+      activePolarHandler = new MessageHandler(app, plugin.id, 'activePolar')
+      activePolarHandler.path = 'polars.activePolar'
+      activePolarHandler.onDelta = () => handleActivePolarDelta()
+      activePolarHandler.subscribe()
+
+      performanceFactorHandler = new MessageHandler(app, plugin.id, 'performanceFactor')
+      performanceFactorHandler.path = 'polars.performanceFactor'
+      performanceFactorHandler.onDelta = () => {
+        const value = performanceFactorHandler.value
+        performanceFactor = Number.isFinite(value) ? value : 1
       }
+      performanceFactorHandler.subscribe()
+
+      const SmootherClass = getSmootherClass(settings.smootherType)
+      const smootherOptions = getSmootherOptions(settings.smootherType, settings)
 
       // Wind vector smoother (TWS + TWA combined as a Cartesian vector —
       // avoids ±π wraparound discontinuity during smoothing)
@@ -1167,8 +782,6 @@ module.exports = (app) => {
         ..._wireHandlerWatchdog({
           id: 'wind.smoothed',
           getPath: () => `${windSmoother?.polar?.pathMagnitude ?? 'environment.wind.speedTrue'}, ${windSmoother?.polar?.pathAngle ?? 'environment.wind.angleTrueWater'}`,
-          unsubscribe: () => windSmoother?.unsubscribe(),
-          subscribe: () => windSmoother?.subscribe(true, true),
         }),
         onDelta: () => {
           _clearLifecycleWarning('wind.smoothed')
@@ -1190,8 +803,6 @@ module.exports = (app) => {
         ..._wireHandlerWatchdog({
           id: 'bsp.smoothed',
           getPath: () => bspSmoother?.handler?.path ?? (settings.useSOG ? 'navigation.speedOverGround' : 'navigation.speedThroughWater'),
-          unsubscribe: () => bspSmoother?.unsubscribe(),
-          subscribe: () => bspSmoother?.subscribe(),
         })
       })
 
@@ -1206,8 +817,6 @@ module.exports = (app) => {
           ..._wireHandlerWatchdog({
             id: 'hdg.smoothed',
             getPath: () => hdgSmoother?.handler?.path ?? 'navigation.headingTrue',
-            unsubscribe: () => hdgSmoother?.unsubscribe(),
-            subscribe: () => hdgSmoother?.subscribe(false, true),
           })
         })
       }
@@ -1217,12 +826,17 @@ module.exports = (app) => {
     },
 
     stop() {
+      app.debug('Stopping')
       isRunning = false
-      importService = null
       nullifyOutputs()
       if (windSmoother) { windSmoother.terminate(); windSmoother = null }
       if (bspSmoother)  { bspSmoother.terminate();  bspSmoother = null  }
       if (hdgSmoother)  { hdgSmoother.terminate();  hdgSmoother = null  }
+      if (activePolarHandler) { activePolarHandler.unsubscribe(); activePolarHandler = null }
+      if (performanceFactorHandler) { performanceFactorHandler.unsubscribe(); performanceFactorHandler = null }
+      polar = null
+      activePolarId = null
+      activePolarDoc = null
       lifecycleWarningMap = new Map()
       lifecycleWarnings = []
       app.debug('Plugin stopped')