signalk-polar-performance-plugin 2.1.0 → 2.2.0

package/CHANGELOG.md

@@ -4,7 +4,26 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## Unreleased
+
+### Fixed
+- Keep `performance.targetSpeed` and `performance.targetVelocityMadeGood` published in irons using the selected beat or run target; polar values and ratios based on the boat's current angle are still cleared.
+
+## [2.2.0] - 2026-11-02
+
+### Changed
+- Polar calculations now come directly from signalk-polar-management's live calculation service: the plugin always follows the active polar, the sailplan selection and the performance factor chosen in the Polar Management webapp — including v2 polar sets, which could not be calculated before. The active polar's details shown in the webapp come from the same service. signalk-polar-management (with the calculation service, >=1.5.0) is now required for all polar outputs; the `polar-math` library is no longer bundled.
+- The overview now shows the selected sailplan for v2 polar sets, and the active polar's details refresh automatically after selection changes or edits in the management webapp, without reloading the page.
+- Smoothed-input outputs (damped TWA and boat speed) are now published even while no polar is active; polar-derived outputs are still cleared.
+- The webapp now distinguishes between a missing calculation service (management plugin not installed or disabled) and no active polar being selected.
+
+### Fixed
+- The polar selected in Polar Management is picked up automatically after a Signal K server restart, without reselecting it ([#41](https://github.com/htool/signalk-polar-performance-plugin/issues/41)).
+
+### Known limitations
+- Sea state (wave) correction is not applied: the Signal K specification defines no paths for the required wave height, period and direction inputs. It can be added once such paths exist.
+
+## [2.1.0] - 2026-10-27
 
 ### Changed
 - Requires signalk-server >=2.35.0 for the upstream metadata-first subscription fix ([SignalK/signalk-server#3216](https://github.com/SignalK/signalk-server/pull/3216)).

package/README.md

@@ -7,8 +7,8 @@ Polar Performance calculates live sailing performance metrics — target boat sp
 **Polar Performance works together with a polar provider plugin** (such as [signalk-polar-management](https://github.com/Asw1n/signalk-polar-management)).
 
 Starting in version 2.0.0, polar file storage, file format conversion, ORC imports, and polar selection are decoupled from this compute plugin:
-- **Polar Provider (`signalk-polar-management`):** Stores polar files, imports ORC/CSV/text polar files, manages polar metadata, and publishes the selected active polar to Signal K (`polars.activePolar`) along with any performance factor (`polars.performanceFactor`).
-- **Performance Plugin (`signalk-polar-performance-plugin`):** Subscribes to the active polar and boat instrument data (TWS, TWA, STW/SOG), calculates real-time performance values using the [`polar-math`](https://github.com/Asw1n/polar-math) engine, and publishes the resulting performance metrics back to the Signal K delta stream.
+- **Polar Provider (`signalk-polar-management`):** Stores polar files, imports ORC/CSV/text polar files, manages polar metadata, publishes the selected active polar to Signal K (`polars.activePolar`) along with the shared performance factor (`polars.performanceFactor`), and provides an in-process polar calculation service to other plugins.
+- **Performance Plugin (`signalk-polar-performance-plugin`):** Subscribes to boat instrument data (TWS, TWA, STW/SOG), calculates real-time performance values through the management plugin's live *active polar* calculation handle, and publishes the resulting performance metrics back to the Signal K delta stream. The handle automatically follows the active polar, the sailplan selection, and the performance factor chosen in the Polar Management webapp — including v2 polar sets.
 
 When a polar lookup cannot be completed or required instrument data is missing/stale, output paths are cleanly set to `null` and the webapp status indicates the exact cause.
 
@@ -16,7 +16,7 @@ When a polar lookup cannot be completed or required instrument data is missing/s
 
 ## Installation
 
-Requires signalk-server >=2.35.0 for reliable metadata-first input subscriptions. Idle/stale warnings do not trigger resubscriptions; existing subscriptions receive data when the source resumes.
+Requires signalk-server >=2.35.0 for reliable metadata-first input subscriptions. Idle/stale warnings do not trigger resubscriptions; existing subscriptions receive data when the source resumes. Requires signalk-polar-management >=1.5.0, which provides the in-process polar calculation service.
 
 Install both plugins from the Signal K App Store, or via npm:
 
@@ -25,7 +25,7 @@ cd ~/.signalk
 npm install signalk-polar-performance-plugin signalk-polar-management
 ```
 
-Then restart Signal K and enable both plugins in **Server → Plugin Config**. Without a polar resource provider installed and enabled, Polar Performance will wait for an active polar to be published and indicate this in its status.
+Then restart Signal K and enable both plugins in **Server → Plugin Config**. This plugin requires signalk-polar-management for all polar calculations: without it (or with it disabled), Polar Performance runs but publishes nothing and reports the missing calculation service in its status.
 
 ---
 
@@ -68,7 +68,7 @@ Most configuration is done through the webapp.
 
 ### Active polar and performance factor
 
-These are **not** configured here. Select the active polar and set the performance factor in the polar management webapp (e.g. signalk-polar-management); this plugin reads them from the `polars.activePolar` and `polars.performanceFactor` Signal K paths. If no polar is active, the plugin runs but publishes nothing; any previously published values are nullified immediately.
+These are **not** configured here. Select the active polar (and, for v2 polar sets, a sailplan) and set the performance factor in the polar management webapp (signalk-polar-management); this plugin's calculation handle follows those selections automatically on every calculation. If no polar is active, the plugin runs but publishes nothing; any previously published values are nullified immediately.
 
 ### Smoother
 
@@ -175,9 +175,10 @@ The polar defines two zones above the beat angle:
 |------|---------|----------|
 | Measured | `velocityMadeGood`, `angleTrueWaterDamped`, `boatSpeedDamped` | Published |
 | Steering advice | `targetAngle`, `optimumWindAngle`, `tackTrue` | Published, so you can see how far to bear away |
-| Polar values and ratios based on them | `polarSpeed`, `polarSpeedRatio`, `targetSpeed`, `targetVelocityMadeGood`, `polarVelocityMadeGood`, `polarVelocityMadeGoodRatio`, `beatAngle`, `gybeAngle`, `beatAngleVelocityMadeGood`, `gybeAngleVelocityMadeGood`, `maxSpeed`, `maxSpeedAngle` | Set to `null` |
+| Selected target performance | `targetSpeed`, `targetVelocityMadeGood` | Published from the selected beat or run target |
+| Polar values and ratios based on them | `polarSpeed`, `polarSpeedRatio`, `polarVelocityMadeGood`, `polarVelocityMadeGoodRatio`, `beatAngle`, `gybeAngle`, `beatAngleVelocityMadeGood`, `gybeAngleVelocityMadeGood`, `maxSpeed`, `maxSpeedAngle` | Set to `null` |
 
-Clearing the polar values in irons also prevents spikes in the performance ratios while tacking. Through a tack the boat carries its speed head-to-wind while the polar speed falls towards zero, which would briefly drive the ratios to meaningless values. As soon as you bear away out of irons, all values return on the next wind update.
+The selected target speed and VMG remain available in irons because they describe the optimal beat or run target for the current TWS, rather than the boat's current angle. Clearing values based on the boat's current polar state prevents spikes in performance ratios while tacking. Through a tack the boat carries its speed head-to-wind while the polar speed falls towards zero, which would briefly drive the ratios to meaningless values. As soon as you bear away out of irons, all other polar values return on the next wind update.
 
 A value is set to `null` once when it becomes unavailable and is not repeated until it returns.
 
@@ -185,7 +186,7 @@ A value is set to `null` once when it becomes unavailable and is not repeated un
 
 ## Managing polars
 
-Polar storage, import (ORC, text formats), and active-polar/performance-factor selection are handled by a separate 'polars' resource-provider plugin, such as [signalk-polar-management](https://github.com/Asw1n/signalk-polar-management). See that plugin's documentation for import formats, the ORC certificate search, and extrapolation behaviour of the underlying `polar-math` library.
+Polar storage, import (ORC, text formats), and active-polar/sailplan/performance-factor selection are handled by [signalk-polar-management](https://github.com/Asw1n/signalk-polar-management), which also performs all polar calculations for this plugin through its in-process calculation service. See that plugin's documentation for import formats, the ORC certificate search, and extrapolation behaviour of the underlying `polar-math` library.
 
 ---
 
@@ -246,7 +247,8 @@ The webapp shows warnings whenever something prevents accurate calculation:
 | *True wind speed — no data* | `environment.wind.speedTrue` is not arriving from Signal K.  |
 | *True wind angle — no data* | `environment.wind.angleTrueWater` is not arriving.  |
 | *Boat speed — no data* | `navigation.speedThroughWater` (or SOG) is not arriving.  |
-| *No active polar* | No `polars.activePolar` is published. Select an active polar in the polar management webapp. |
+| *No active polar* | No active polar is selected. Select one in the polar management webapp. |
+| *Polar calculation service not available* | signalk-polar-management is not installed, not enabled, or too old to provide the in-process calculation service. |
 | *Sailing in irons* | TWA is below the in-irons cutoff. Polar values and the ratios based on them are set to `null`; measured values and steering advice keep updating. See [Output handling when pinching and in irons](#output-handling-when-pinching-and-in-irons). |
 | *Pinching* | TWA is between the in-irons cutoff and the beat angle. All outputs are published; values come from the extrapolated beat zone. |
 | *Extrapolated beyond run angle* | TWA is deeper than the run angle. Values come from the cosine-VMG extrapolation model. |
@@ -270,11 +272,12 @@ If you want to consume this plugin's live performance queries, use the developer
 
 - [Developer reference](docs/developer-reference.md) for the plugin REST API.
 - [openApi.json](openApi.json) for the authoritative machine-readable contract.
-- For the canonical `polarTable` structure, polar storage, and import, see [signalk-polar-management](https://github.com/Asw1n/signalk-polar-management) and the [polar-format](https://github.com/Asw1n/polar-format) / [polar-math](https://github.com/Asw1n/polar-math) packages it depends on.
+- For the canonical `polarTable` / `polarSet` structures, polar storage, import, and the in-process calculation service, see [signalk-polar-management](https://github.com/Asw1n/signalk-polar-management) and the [polar-format](https://github.com/Asw1n/polar-format) / [polar-math](https://github.com/Asw1n/polar-math) packages it depends on.
 
 ---
 
 ## Known limitations
 
 - Heel angle is not taken into account in the polar lookup. Most ORC polars are upright polars.
-- Requires a 'polars' resource-provider plugin (e.g. `signalk-polar-management`) to be installed and running for polar storage, import, and active polar selection.
+- Requires `signalk-polar-management` to be installed and running: it stores and imports polars, owns the active selection, and performs all polar calculations for this plugin.
+- Sea state (wave) correction is not applied, even when the active v2 polar set carries a wave-correction table. The Signal K specification currently defines no paths for the required inputs (significant wave height, wave period, wave direction), so this plugin has nothing to feed the correction with. Support can be added once such paths exist in the specification.

package/docs/developer-reference.md

@@ -1,25 +1,44 @@
 # Polar Performance Developer Reference
 
 This document covers the REST API this plugin still exposes. It no longer stores, imports,
-or manages polar files — that is handled by a separate 'polars' resource-provider plugin
-(e.g. [signalk-polar-management](https://github.com/Asw1n/signalk-polar-management)). For the
-canonical `polarTable` format and its management API, see that plugin's documentation and the
-[polar-format](https://github.com/Asw1n/polar-format) / [polar-math](https://github.com/Asw1n/polar-math)
-packages it depends on.
+or manages polar files — that is handled by
+[signalk-polar-management](https://github.com/Asw1n/signalk-polar-management), which also
+provides the in-process polar calculation service this plugin uses. For the canonical
+`polarTable` / `polarSet` formats and the management API, see that plugin's documentation
+and the [polar-format](https://github.com/Asw1n/polar-format) package; the underlying
+calculation engine, [polar-math](https://github.com/Asw1n/polar-math), is a dependency of
+the management plugin, not of this one.
 
 For installation, day-to-day use, and webapp workflow, start with [../README.md](../README.md).
 
 ## How the active polar is resolved
 
-This plugin subscribes to two Signal K paths published by the 'polars' resource provider:
+All polar calculations and all active-polar metadata go through the in-process
+calculation service announced by signalk-polar-management via the `polarManagement`
+PropertyValue. At startup this plugin subscribes with
+`app.onPropertyValues('polarManagement', …)` and acquires an **active-polar handle**
+(`service.activePolar()`). Every calculation call on that handle automatically follows
+the shared active polar, the shared sailplan selection (for v2 polar sets), the shared
+performance factor, and the shared wave-correction toggle — this plugin applies none of
+them itself. When the management plugin is missing or stopped, calculations are
+unavailable and the plugin reports this in its status; results then carry
+`state.available: false` with a reason such as `no_active_polar`.
 
-- `polars.activePolar` — `{ href: '/resources/polars/<id>' }`, or absent if no polar is active.
-- `polars.performanceFactor` — a number applied as a multiplier to all polar speeds.
+Descriptive metadata comes from the same handle: `handle.describe()` returns the active
+document's name, boat details, selected sailplan, the applied performance factor, and the
+selected table's TWS axis. The plugin refreshes this snapshot on `handle.onChange`
+notifications and serves it through `/meta` and `/polar/axes/tws`. It does not subscribe
+to the `polars.*` Signal K paths and performs no resource lookups; those paths remain
+published by signalk-polar-management for other consumers.
 
-On a change to `polars.activePolar`, the plugin resolves `<id>` via the in-process
-`app.resourcesApi.getResource('polars', id)` call and builds a `polar-math` `Polar` instance
-from the returned canonical document. If the resource provider or the active polar becomes
-unavailable, the last successfully loaded polar is kept until a valid update arrives.
+### Sea state / wave correction
+
+v2 polar sets can carry a wave-correction table, and active handles accept per-call
+`seaState` input. This plugin does not supply `seaState`, because the Signal K
+specification currently defines no paths for the required inputs (significant wave height,
+wave period, wave direction). Wave correction therefore has no effect on this plugin's
+outputs. If the specification gains such paths, sea state can be wired into the existing
+handle calls without restructuring.
 
 ## REST API
 
@@ -35,7 +54,7 @@ fields are also available to read-only users.
 |--------|------|-------------|--------|
 | `GET` | `/live` | Current smoothed TWS, TWA, BSP, polar speed, and polar state. | Read-only |
 | `GET` | `/status` | Full snapshot: raw inputs, smoothed inputs, and all enabled output values. | Read-only |
-| `GET` | `/meta` | Display unit metadata for all fields, plus a read-only summary of the active polar (name, boatType, sailnumber, year, source) and performance factor. | Read-only |
+| `GET` | `/meta` | Display unit metadata for all fields, plus a read-only summary of the active polar (name, boatType, sailnumber, year, source, notes, selected sailplan) and the applied performance factor. | Read-only |
 | `GET` | `/settings` | Current plugin settings (smoother, output toggles, speed source — no polar selection). | Administrator |
 | `PUT` | `/settings` | Update settings. Body: JSON object with changed keys only. | Administrator |
 | `GET` | `/polar/axes/tws` | TWS axis of the currently active polar. 404 if none is active. | Read-only |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-polar-performance-plugin",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Calculates live sailing performance from the active polar selected in a polar management plugin (e.g. signalk-polar-management).",
   "main": "plugin/index.js",
   "exports": {
@@ -26,16 +26,10 @@
     "prepublishOnly": "npm test"
   },
   "dependencies": {
-    "polar-math": "^1.1.1",
     "signalkutilities": "^3.2.0"
   },
-  "peerDependencies": {
-    "signalk-polar-management": ">=1.0.0"
-  },
-  "peerDependenciesMeta": {
-    "signalk-polar-management": {
-      "optional": true
-    }
+  "devDependencies": {
+    "polar-math": "^1.1.1"
   },
   "repository": {
     "type": "git",
@@ -51,6 +45,9 @@
   "signalk": {
     "appIcon": "./icon.png",
     "displayName": "Polar Performance",
+    "requires": [
+      "signalk-polar-management"
+    ],
     "screenshots": [
       "./docs/plotter.png",
       "./docs/overview.png",

package/plugin/index.js

@@ -1,8 +1,6 @@
 'use strict'
 
-const { Polar } = require('polar-math')
 const {
-  MessageHandler,
   createSmoothedPolar,
   createSmoothedHandler,
   SmoothedAngle,
@@ -41,15 +39,16 @@ module.exports = (app) => {
   let hasPendingChanges = false
   let isRunning = false
 
-  // 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
+  // Active polar — provided entirely by signalk-polar-management's in-process
+  // service, discovered through the `polarManagement` PropertyValue. The active
+  // handle mirrors the shared active polar, sailplan, performance factor and
+  // wave-correction toggle on every calculation, so this plugin applies none of
+  // them itself. Descriptive metadata and the plotter's TWS axis come from the
+  // handle's describe() snapshot — no resource lookups or `polars.*` paths.
+  let polarHandle = null           // live activePolar() calculation handle, or null
+  let polarDescription = null      // latest handle.describe() result, or null
+  let unsubscribeDiscovery = null  // PropertyValues discovery subscription
+  let unsubscribeChanges = null    // polarHandle.onChange subscription
 
   let windSmoother = null
   let bspSmoother = null
@@ -186,9 +185,8 @@ module.exports = (app) => {
     }
 
     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).
+      // v1 → v2: polar selection and performance adjustment moved to
+      // signalk-polar-management, which owns the shared selection and factor.
       delete s.activePolar
       delete s.perfAdjust
       s.settingsVersion = 2
@@ -211,59 +209,59 @@ module.exports = (app) => {
   }
 
   // ---------------------------------------------------------------------------
-  // Active polar — sourced from SK paths published by a 'polars' resource provider
+  // Active polar — calculations and descriptive metadata via the polar
+  // management in-process service
   // ---------------------------------------------------------------------------
 
-  // 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
+  // Refreshes the cached describe() snapshot that feeds /meta and the plotter's
+  // TWS axis, clears outputs when the polar becomes unavailable, and keeps the
+  // plugin status in sync with the current selection.
+  function refreshDescription() {
+    if (!polarHandle) return
+    const hadPolar = polarDescription?.available === true
+    polarDescription = polarHandle.describe()
+    if (polarDescription.available) {
+      app.setPluginStatus(`Polar '${polarDescription.name || polarDescription.id}' active`)
+    } else {
+      if (hadPolar) nullifyOutputs()
+      app.setPluginStatus(polarDescription.reason === 'no_active_polar'
+        ? 'No active polar selected — select one in the polar management webapp'
+        : `Polar calculations unavailable (${String(polarDescription.reason).replace(/_/g, ' ')})`)
     }
   }
 
-  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')
+  // Discovery of the polar calculation service announced by
+  // signalk-polar-management through the `polarManagement` PropertyValue.
+  // Only the latest record counts: an `available: false` record means the
+  // provider stopped and old handles are permanently unusable.
+  function handleServiceDiscovery(history) {
+    const record = history.findLast(entry => entry?.setter === 'signalk-polar-management')
+    const service = record?.value
+    unsubscribeChanges?.()
+    unsubscribeChanges = null
+    const hadPolar = polarDescription?.available === true
+    polarHandle = null
+    polarDescription = null
+    if (service?.apiVersion !== 1 || service.available !== true ||
+        typeof service.activePolar !== 'function' || typeof service.polar !== 'function') {
+      if (hadPolar) nullifyOutputs()
+      app.setPluginStatus('Polar calculation service not available — install or enable signalk-polar-management')
       return
     }
-
-    const id = hrefToId(href)
-    if (!id) {
-      app.setPluginError(`Cannot parse active polar href: ${href}`)
+    const handle = service.activePolar()
+    if (typeof handle.describe !== 'function') {
+      if (hadPolar) nullifyOutputs()
+      app.setPluginError('signalk-polar-management is too old — update it to a version whose polar handles provide describe()')
       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()
+    polarHandle = handle
+    // Every change kind can affect the description (selection, edits, factor).
+    // Callbacks must stay short, so the snapshot refresh is deferred.
+    unsubscribeChanges = polarHandle.onChange((change) => {
+      app.debug('Polar configuration changed: %o', change)
+      setImmediate(() => { if (polarHandle === handle) refreshDescription() })
     })
+    refreshDescription()
   }
 
   // ---------------------------------------------------------------------------
@@ -345,7 +343,7 @@ module.exports = (app) => {
 
   function computeAndSend() {
     if (hasPendingChanges) applyOptionChanges()
-    if (!polar) return
+    if (!polarHandle) return
 
     const wind = windSmoother.polarValue
     const TWS = wind.magnitude
@@ -384,11 +382,11 @@ module.exports = (app) => {
     // - 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 speedResult = windValid ? polarHandle.speedAt({ tws: TWS, twa: TWA }) : 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 targets = windValid ? polarHandle.targetsAt({ tws: TWS }).value : null
     const adviceBeatAngle = finiteOrNull(targets?.beat?.twa)
     const adviceRunAngle  = finiteOrNull(targets?.run?.twa)
     const adviceAngle     = isUpwind ? adviceBeatAngle : adviceRunAngle
@@ -397,8 +395,8 @@ module.exports = (app) => {
     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 targetVMG = finiteOrNull(isUpwind ? targets?.beat?.vmg : targets?.run?.vmg)
+    const polarTargetVMG = fromPolar(targetVMG)
     const maxSpeed = fromPolar(targets?.maxSpeed?.speed)
     const maxSpeedAngle = maxSpeed === null ? null : finiteOrNull(targets?.maxSpeed?.twa)
 
@@ -406,13 +404,13 @@ module.exports = (app) => {
     const speedAtTwa = speedResult?.value
     const polarSpeed = Number.isFinite(speedAtTwa) && speedAtTwa > 0 ? speedAtTwa : null
 
-    const targetCos = targetAngle === null ? 0 : Math.abs(Math.cos(targetAngle))
+    const targetCos = adviceAngle === null ? 0 : Math.abs(Math.cos(adviceAngle))
     const targetSpeed = targetVMG !== null && targetVMG >= 0 && targetCos > 0.01
       ? targetVMG / targetCos
       : null
 
     const vmg = windValid && BSP !== null ? BSP * Math.cos(TWA) : null
-    const vmgRatio = ratio(vmg === null ? null : Math.abs(vmg), targetVMG)
+    const vmgRatio = ratio(vmg === null ? null : Math.abs(vmg), polarTargetVMG)
 
     let optimumWindAngle = null
     if (isUpwind && adviceBeatAngle !== null) optimumWindAngle = (TWA - adviceBeatAngle) * port
@@ -458,7 +456,7 @@ module.exports = (app) => {
 
     output('VMG', 'performance.velocityMadeGood', vmg, 'm/s',
       'Actual VMG based on current boat speed and TWA.')
-    output('VMG', 'performance.polarVelocityMadeGood', targetVMG, 'm/s',
+    output('VMG', 'performance.polarVelocityMadeGood', polarTargetVMG, '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.')
@@ -514,16 +512,18 @@ module.exports = (app) => {
         return Number.isFinite(value) ? parseFloat(value.toFixed(digits)) : null
       }
 
+      // TWS axis for the webapp plotter — from the handle's description, which
+      // already reflects the active selection (v1 table, or v2 best/sailplan).
       function getPolarTwsValues() {
-        return polar.entries
-          .filter(entry => entry.tws > 0.001)
-          .map(entry => parseFloat(entry.tws.toFixed(4)))
+        return polarDescription.twsAxis
+          .filter(tws => Number.isFinite(tws) && tws > 0.001)
+          .map(tws => parseFloat(tws.toFixed(4)))
       }
 
       function buildCurveResult(tws, stepRad) {
         const points = []
         for (let twa = 0; twa <= Math.PI + 1e-9; twa += stepRad) {
-          const { value: tbs } = polar.speedAt({ tws, twa, performanceFactor })
+          const { value: tbs } = polarHandle.speedAt({ tws, twa })
           if (Number.isFinite(tbs) && tbs > 0) {
             points.push({
               twa: toFixedNumber(twa, 5),
@@ -532,7 +532,7 @@ module.exports = (app) => {
           }
         }
 
-        const { value: targets } = polar.targetsAt({ tws, performanceFactor })
+        const { value: targets } = polarHandle.targetsAt({ tws })
         return {
           tws,
           points,
@@ -557,12 +557,12 @@ module.exports = (app) => {
       // ---- Active polar curve queries (read-only — for the webapp's polar canvas) --
 
       router.access('readonly').get('/polar/axes/tws', (req, res) => {
-        if (!polar) return res.status(404).json({ error: 'No active polar selected' })
+        if (!polarDescription?.available) return res.status(404).json({ error: 'No active polar selected' })
         res.json(getPolarTwsValues())
       })
 
       router.access('readonly').get('/polar/queries/curve', (req, res) => {
-        if (!polar) return res.status(404).json({ error: 'No active polar selected' })
+        if (!polarHandle || !polarDescription?.available) return res.status(404).json({ error: 'No active polar selected' })
         try {
           const tws = parseFloat(req.query.tws)
           if (!Number.isFinite(tws) || tws < 0) {
@@ -589,8 +589,8 @@ module.exports = (app) => {
         const TWA       = Number.isFinite(TWAsigned) ? Math.abs(TWAsigned) : null
         const BSP       = bspSmoother ? bspSmoother.value : null
 
-        const polarResult = (polar && Number.isFinite(TWS) && Number.isFinite(TWA))
-          ? polar.speedAt({ tws: TWS, twa: TWA, performanceFactor })
+        const polarResult = (polarHandle && Number.isFinite(TWS) && Number.isFinite(TWA))
+          ? polarHandle.speedAt({ tws: TWS, twa: TWA })
           : null
         const polarSpeed = polarResult ? polarResult.value : null
 
@@ -634,8 +634,8 @@ module.exports = (app) => {
 
         const bspPath = settings.useSOG ? 'navigation.speedOverGround' : 'navigation.speedThroughWater'
 
-        const polarState = (polar && Number.isFinite(TWS) && Number.isFinite(TWAsigned))
-          ? polar.speedAt({ tws: TWS, twa: Math.abs(TWAsigned), performanceFactor }).state
+        const polarState = (polarHandle && Number.isFinite(TWS) && Number.isFinite(TWAsigned))
+          ? polarHandle.speedAt({ tws: TWS, twa: Math.abs(TWAsigned) }).state
           : null
 
         // Build outputs object: only include paths that are enabled and were
@@ -678,8 +678,10 @@ module.exports = (app) => {
 
       // Metadata describing the units and display preferences for each field
       // 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).
+      // read-only summary of the active polar and performance factor, taken
+      // from the management handle's describe() snapshot. The factor is
+      // informational: the handle applies it in every calculation, so this
+      // plugin never multiplies by it.
       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' }
@@ -694,16 +696,17 @@ module.exports = (app) => {
           'curve.tbs': { units: 'm/s', displayUnits: speed },
           'curve.vmg': { units: 'm/s', displayUnits: speed },
           '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
+          activePolar: polarDescription?.available ? {
+            id: polarDescription.id,
+            name: polarDescription.name || polarDescription.id,
+            boatType: polarDescription.boatType,
+            sailnumber: polarDescription.sailnumber,
+            year: polarDescription.year,
+            source: polarDescription.source,
+            notes: polarDescription.notes,
+            sailplanId: polarDescription.sailplanId
           } : null,
-          performanceFactor
+          performanceFactor: polarDescription?.available ? polarDescription.performanceFactor : null
         })
       })
 
@@ -735,35 +738,21 @@ module.exports = (app) => {
       metaSentPaths = new Set()  // reset so metadata is re-emitted after restart
       lifecycleWarningMap = new Map()
       lifecycleWarnings = []
-      polar = null
-      activePolarId = null
-      activePolarDoc = null
-      performanceFactor = 1
+      polarHandle = null
+      polarDescription = null
 
       settings = migrateSettings({ ...DEFAULT_SETTINGS, ...options, settingsVersion: options.settingsVersion ?? 0 })
 
-      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.")
-        }
-      })
-
-      // 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
+      // Discover the in-process polar calculation service. The callback fires
+      // immediately with the retained PropertyValues history, so startup order
+      // relative to signalk-polar-management does not matter. The handle also
+      // provides the active selection's metadata through describe(), so no
+      // `polars.*` subscriptions or resource lookups are needed.
+      if (typeof app.onPropertyValues === 'function') {
+        unsubscribeDiscovery = app.onPropertyValues('polarManagement', handleServiceDiscovery)
+      } else {
+        app.setPluginError('Signal K server does not support PropertyValues — polar calculations unavailable')
       }
-      performanceFactorHandler.subscribe()
 
       const SmootherClass = getSmootherClass(settings.smootherType)
       const smootherOptions = getSmootherOptions(settings.smootherType, settings)
@@ -832,11 +821,10 @@ module.exports = (app) => {
       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
+      if (unsubscribeDiscovery) { unsubscribeDiscovery(); unsubscribeDiscovery = null }
+      if (unsubscribeChanges) { unsubscribeChanges(); unsubscribeChanges = null }
+      polarHandle = null
+      polarDescription = null
       lifecycleWarningMap = new Map()
       lifecycleWarnings = []
       app.debug('Plugin stopped')

package/public/app.js

@@ -349,6 +349,13 @@ function polarStateWarnings(d) {
   const s = d?.polarState
   if (!s) return []
   const msgs = []
+  // Unavailable results from the management calculation service carry a reason
+  // instead of interpolation details.
+  if (s.available === false) {
+    if (s.reason === 'no_active_polar') msgs.push('No active polar — select one in the polar management webapp')
+    else if (s.reason) msgs.push('Polar calculations unavailable (' + s.reason.replace(/_/g, ' ') + ')')
+    return msgs
+  }
   if (s.tws === 'below_range') msgs.push('Wind speed is below the polar table range — values are extrapolated')
   if (s.tws === 'above_range') msgs.push('Wind speed is above the polar table range — values are extrapolated')
   if (s.twa === 'in_irons')    msgs.push('Sailing in irons — too close to the wind for polar data')
@@ -471,6 +478,7 @@ function _tickOverview() {
         { label: 'Sail number', id: 'ov-polar-sailnumber' },
         { label: 'Year',        id: 'ov-polar-year' },
         { label: 'Source',      id: 'ov-polar-source' },
+        { label: 'Sailplan',    id: 'ov-polar-sailplan' },
         { label: 'Performance factor', id: 'ov-polar-perf' },
       ]))
     }
@@ -480,6 +488,7 @@ function _tickOverview() {
       setVal('ov-polar-sailnumber',  p.sailnumber || '—')
       setVal('ov-polar-year',        p.year ? String(p.year) : '—')
       setVal('ov-polar-source',      p.source || '—')
+      setVal('ov-polar-sailplan',    p.sailplanId || '—')
       setVal('ov-polar-perf',        fmtVal(meta?.performanceFactor, 'performance', RATIO_DEFAULT))
     }
   }
@@ -512,7 +521,7 @@ function _tickOverview() {
   if (d?.tws        == null) warns.push('True wind speed — no data (environment.wind.speedTrue)')
   if (d?.twa        == null) warns.push('True wind angle — no data (environment.wind.angleTrueWater)')
   if (d?.bsp        == null) warns.push('Boat speed — no data')
-  if (d?.tws != null && d?.polarState == null) warns.push('No active polar — select one in the polar management webapp')
+  if (d?.tws != null && d?.polarState == null) warns.push('Polar calculation service not available — install or enable signalk-polar-management')
   warns.push(...polarStateWarnings(d))
   updateWarnings(document.getElementById('ov-warnings'), warns)
 }
@@ -720,6 +729,7 @@ function switchPage(page) {
 function startPolling() {
   setInterval(refreshLive, 1000)
   setInterval(async () => {
+    await loadMeta()
     await refreshLibrary()
     if (activePage === 'overview' && polar) polar.setLibraryData(twsList, curves, liveCurve)
   }, 5000)

package/test/lifecycle.test.js

@@ -25,6 +25,7 @@ function makeApp(dataDir) {
     },
     getDataDirPath: () => dataDir,
     handleMessage: () => {},
+    onPropertyValues: () => () => {},
     config: { port: 3000 },
     subscriptionmanager: {
       subscribe: (_sub, unsubscribes, _onErr, _onDelta) => {

package/test/outputs.test.js

@@ -52,10 +52,56 @@ const targets = reference.targetsAt({ tws: TWS }).value
 const close = (actual, expected, msg) =>
   assert.ok(Number.isFinite(actual) && Math.abs(actual - expected) < 1e-9, `${msg}: ${actual} != ${expected}`)
 
-function harness(table = TABLE) {
+function harness(table = TABLE, { withService = true, description = {} } = {}) {
   const subscribers = new Map()
   const bus = new Map()      // latest value per path written by the plugin
   const writes = []          // every { path, value } written, in order
+  const calls = []           // every calculation call made on the service handle
+  const changeListeners = new Set()
+
+  // Fake in-process calculation service, as announced by signalk-polar-management
+  // through the `polarManagement` PropertyValue. Wraps a real polar-math Polar
+  // so numeric expectations stay exact. The handle owns the performance factor;
+  // recorded calls let tests assert the plugin never supplies one. `state`
+  // drives describe(), mirroring how real active handles follow shared settings.
+  const polar = Polar.fromTable(table)
+  const state = {
+    active: true,
+    id: 'ref',
+    sailplanId: null,
+    performanceFactor: 1,
+    name: table.name ?? null,
+    twsAxis: table.axes?.tws ?? [],
+    ...description
+  }
+  const handle = {
+    speedAt:   options => { calls.push({ method: 'speedAt', options }); return polar.speedAt(options) },
+    vmgAt:     options => { calls.push({ method: 'vmgAt', options }); return polar.vmgAt(options) },
+    targetsAt: options => { calls.push({ method: 'targetsAt', options }); return polar.targetsAt(options) },
+    rangeAt:   options => { calls.push({ method: 'rangeAt', options }); return polar.rangeAt(options) },
+    describe:  () => state.active
+      ? {
+          available: true,
+          id: state.id,
+          sailplanId: state.sailplanId,
+          performanceFactor: state.performanceFactor,
+          name: state.name,
+          boatType: null, sailnumber: null, year: null, source: null, notes: null,
+          twsAxis: state.twsAxis
+        }
+      : { available: false, reason: 'no_active_polar' },
+    onChange:  callback => { changeListeners.add(callback); return () => changeListeners.delete(callback) }
+  }
+  const service = {
+    apiVersion: 1,
+    available: true,
+    activePolar: () => handle,
+    polar: () => handle
+  }
+  const notifyChange = (change = { type: 'selection', ids: [] }) => {
+    for (const callback of [...changeListeners]) callback(change)
+  }
+
   const app = {
     debug: () => {}, error: () => {},
     setPluginStatus: () => {}, setPluginError: () => {},
@@ -69,9 +115,11 @@ function harness(table = TABLE) {
         }
       }
     },
-    resourcesApi: {
-      listResources: async () => ({}),
-      getResource: async () => table
+    onPropertyValues: (name, callback) => {
+      if (name === 'polarManagement' && withService) {
+        callback([{ setter: 'signalk-polar-management', value: service }])
+      }
+      return () => {}
     },
     subscriptionmanager: {
       subscribe: (msg, unsubscribes, _err, callback) => {
@@ -99,10 +147,9 @@ function harness(table = TABLE) {
     }
   }
   return {
-    app, plugin, bus, writes, routes, deliver,
+    app, plugin, bus, writes, calls, routes, deliver, state, notifyChange,
     async start(options = ALL_OUTPUTS) {
       plugin.start(options)
-      deliver('polars.activePolar', { href: '/resources/polars/ref' })
       await new Promise(resolve => setImmediate(resolve))
     },
     sail({ tws = TWS, twa, bsp, hdg }) {
@@ -160,13 +207,14 @@ describe('computeAndSend output validity', () => {
     const ironsTwa = rad(20)
     assert.equal(reference.speedAt({ tws: TWS, twa: ironsTwa }).state.twa, 'in_irons')
     h.sail({ twa: ironsTwa, bsp, hdg: 1 })
-    for (const path of ['performance.polarSpeed', 'performance.polarSpeedRatio', 'performance.targetSpeed',
-      'performance.targetVelocityMadeGood', 'performance.polarVelocityMadeGood',
+    for (const path of ['performance.polarSpeed', 'performance.polarSpeedRatio', 'performance.polarVelocityMadeGood',
       'performance.polarVelocityMadeGoodRatio', 'performance.beatAngle', 'performance.gybeAngle',
       'performance.beatAngleVelocityMadeGood', 'performance.gybeAngleVelocityMadeGood',
       'performance.maxSpeed', 'performance.maxSpeedAngle']) {
       assert.equal(h.bus.get(path), null, path)
     }
+    close(h.bus.get('performance.targetSpeed'), targets.beat.vmg / Math.cos(targets.beat.twa), 'targetSpeed in irons')
+    close(h.bus.get('performance.targetVelocityMadeGood'), targets.beat.vmg, 'targetVMG in irons')
     close(h.bus.get('performance.targetAngle'), targets.beat.twa, 'targetAngle in irons')
     close(h.bus.get('performance.optimumWindAngle'), ironsTwa - targets.beat.twa, 'optimumWindAngle in irons')
     close(h.bus.get('performance.tackTrue'), 1 + targets.beat.twa, 'tackTrue in irons')
@@ -178,7 +226,8 @@ describe('computeAndSend output validity', () => {
 
     const status = h.status()
     assert.equal(status.outputs['performance.polarSpeed'], null)
-    assert.equal(status.outputs['performance.targetSpeed'], null)
+    assert.ok(Math.abs(status.outputs['performance.targetSpeed'] - targets.beat.vmg / Math.cos(targets.beat.twa)) < 0.001)
+    assert.ok(Math.abs(status.outputs['performance.targetVelocityMadeGood'] - targets.beat.vmg) < 0.001)
 
     // Pinching is not in irons, so nothing is cleared
     const pinchTwa = rad(38)
@@ -221,8 +270,8 @@ describe('computeAndSend output validity', () => {
 
     h.sail({ twa: rad(-20), bsp })
     assert.equal(h.bus.get('performance.polarSpeed'), null)
-    assert.equal(h.bus.get('performance.targetSpeed'), null)
-    assert.equal(h.bus.get('performance.targetVelocityMadeGood'), null)
+    close(h.bus.get('performance.targetSpeed'), targets.beat.vmg / Math.cos(targets.beat.twa), 'targetSpeed port irons')
+    close(h.bus.get('performance.targetVelocityMadeGood'), targets.beat.vmg, 'targetVMG port irons')
     assert.equal(h.bus.get('performance.beatAngle'), null)
     close(h.bus.get('performance.targetAngle'), -targets.beat.twa, 'targetAngle port irons')
     close(h.bus.get('performance.optimumWindAngle'), -(rad(20) - targets.beat.twa), 'optimumWindAngle port irons')
@@ -301,4 +350,70 @@ describe('computeAndSend output validity', () => {
       assert.equal(h.bus.get(path), null, path)
     }
   })
+
+  it('leaves the performance factor and sea state to the management handle', async () => {
+    await h.start()
+    h.sail({ twa: rad(50), bsp: 6 * KNOTS, hdg: 1 })
+    assert.ok(h.calls.length > 0, 'calculations must go through the service handle')
+    for (const { method, options } of h.calls) {
+      assert.ok(!('performanceFactor' in options), `${method} must not supply performanceFactor`)
+      assert.ok(!('seaState' in options), `${method} must not supply seaState`)
+    }
+  })
+
+  it('publishes nothing when the calculation service is not available', async () => {
+    h = harness(TABLE, { withService: false })
+    await h.start()
+    h.sail({ twa: rad(50), bsp: 6 * KNOTS, hdg: 1 })
+    assert.equal(h.writes.length, 0)
+    assert.equal(h.calls.length, 0)
+  })
+
+  it('serves the TWS axis and metadata from the handle description, following selection changes', async () => {
+    await h.start()
+    let result
+    const res = { json: v => { result = v }, status: () => res }
+
+    h.routes['/polar/axes/tws']({}, res)
+    assert.deepEqual(result, TABLE.axes.tws.map(tws => parseFloat(tws.toFixed(4))))
+
+    h.routes['/meta']({}, res)
+    assert.equal(result.activePolar.id, 'ref')
+    assert.equal(result.activePolar.name, 'Reference Polar')
+    assert.equal(result.activePolar.sailplanId, null)
+    assert.equal(result.performanceFactor, 1)
+
+    // A selection change (e.g. picking a v2 sailplan) is reflected after the
+    // onChange notification, with no resource lookups or polars.* deltas.
+    h.state.sailplanId = 'jib'
+    h.state.twsAxis = [6, 12, 18]
+    h.state.performanceFactor = 0.9
+    h.notifyChange({ type: 'selection', ids: [] })
+    await new Promise(resolve => setImmediate(resolve))
+
+    h.routes['/polar/axes/tws']({}, res)
+    assert.deepEqual(result, [6, 12, 18])
+    h.routes['/meta']({}, res)
+    assert.equal(result.activePolar.sailplanId, 'jib')
+    assert.equal(result.performanceFactor, 0.9)
+  })
+
+  it('clears outputs and polar endpoints when the active polar is deselected', async () => {
+    await h.start()
+    h.sail({ twa: rad(50), bsp: 6 * KNOTS })
+    assert.ok(h.bus.get('performance.polarSpeed') > 0)
+
+    h.state.active = false
+    h.notifyChange({ type: 'selection', ids: [] })
+    await new Promise(resolve => setImmediate(resolve))
+
+    assert.equal(h.bus.get('performance.polarSpeed'), null)
+    let result
+    const res = { json: v => { result = v }, status: code => ({ json: v => { result = { code, ...v } } }) }
+    h.routes['/polar/axes/tws']({}, res)
+    assert.equal(result.code, 404)
+    h.routes['/meta']({}, res)
+    assert.equal(result.activePolar, null)
+    assert.equal(result.performanceFactor, null)
+  })
 })