signalk-pypilot-newui 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,186 @@
+# Changelog
+
+## 1.0.0 — 2026-08-18 — Rev32..Rev62 first public release
+
+The webapp went from a minimum viable control panel to a full-blown touch
+visor + first-class Signal K bridge in this batch. Highlights:
+
+### UI - Control tab
+
+- **Compass rose** (Rev47..Rev58): cardinals + 30° tick labels, boat-fixed
+  green/red sailing wedges reaching under the hull, AWA (amber) + TWA
+  (magenta dashed) arrows, cyan target diamond outside the ring, HDG at
+  the top rim, wind speed at the bottom.
+- **4 configurable corner tiles** (Rev48): long-press to pick datum (HDG,
+  AWA/TWA/TWS/TWD, SOG, COG, TGT, depth, mode, polar-performance keys,
+  custom SK path).
+- **Wind arrow independent toggles** (Rev58): AWA and TWA on/off separately,
+  persisted in localStorage.
+- **Custom SK path** (Rev58): add any published Signal K path as a corner
+  tile with label + unit. Datalist auto-suggests paths seen on the bus.
+- **Polar-performance opt-in** (Rev58): checkboxes for the 10 keys of
+  `signalk-polar-performance-plugin` + water temperature.
+- **Optimistic AP engage** (Rev56): visual state flips instantly on click,
+  auto-retries on Tailscale flakes, rolls back with red-border flash on
+  hard failure. Guard blocks double-taps from firing opposite POSTs.
+- **KIP-friendly Simple Switches** (Rev33..Rev38): `electrical.switches.pypilot.*`
+  for ap.state (momentary boolean), nudge (4 momentary), tack (3 momentary),
+  mode (radio), dynamic profile (radio).
+
+### UI - Tune tab
+
+- **Locked-by-default gain sliders** (Rev42): unlock checkbox, auto-relocks
+  on tab exit.
+- **±10 / ±1 fine-tune buttons** (Rev43) flanking each slider.
+- **Orange "was" reference** shown when unlocked so the operator sees what
+  they are moving from.
+- All `RangeSetting` config sliders from the pypilot catalog appear here
+  automatically (Rev45).
+
+### UI - Race tab (new, Rev35)
+
+- T1/T2 countdown timer with audible beeps, screen flash, spoken seconds
+  ("10, 5, 4, 3, 2, 1, Start"). Runs in the background across tabs.
+- SYNC rounds to the nearest minute mid-countdown; RESET returns to idle.
+
+### UI - Setup tab
+
+- **Remote `RESTART pypilot`** (Rev55): SSH into the TinyPilot using the
+  user + password stored in plugin config (via `ssh2` npm), runs
+  `sudo systemctl restart pypilot pypilot_web`, reconnects local socket.
+  Falls back to reconnect-only if SSH fails or password not set.
+- **`_pluginConfigMerge` helper** (Rev55): GETs the full plugin config from
+  `/skServer/plugins/<id>/config`, overlays only the patched fields, POSTs
+  back - so saving Nudge or Absorb no longer wipes the SSH credentials
+  (or vice versa) via full-replace.
+- Pause/Resume buttons removed from the UI (backend endpoints kept).
+- Absorb-provider hint reworded, security note added for the plain-text
+  plugin config storage.
+
+### UI - Paths & API tab
+
+- KIP mini-table trimmed to the current recommended surface (Simple Switch
+  + Autopilot API v2 Put). Legacy `.actions.engage/nudge/tack/*Int` paths
+  hidden from the UI (backend handlers still registered for backwards
+  compatibility).
+- Horizontal-scroll wrapper on both tables so long SK paths remain readable
+  on portrait phones.
+
+### UI - Info tab (new, Rev58..Rev59)
+
+- Safety notice, quick-start (10 steps), About, Acknowledgements
+  (Sean D'Epagnier, Jean-Marc at Navitop, Signal K community, Panaaj),
+  Apache 2.0 license attribution, GitHub issue links, coexistence rules
+  with `pypilot-autopilot-provider`.
+- **Config export/import** (Rev59): Web Share API to email / WhatsApp /
+  Signal / AirDrop, `.json` download, clipboard copy, file / text import,
+  reset. Payload includes corners, wind-arrow flags, polar toggles, custom
+  paths. Never includes SSH credentials.
+- Version + Rev header, link to the classic pypilot_web UI on the TinyPilot.
+
+### i18n (Rev61)
+
+- Full **English / Español / Deutsch / Français** with browser auto-detect
+  on first visit, override in Setup → Language.
+- ~90 keys covering tabs, Setup, popup, Paths, Regatta, alerts, prompts,
+  confirms. EN + ES complete; DE + FR cover tabs + core Setup + calibration
+  and fall back to EN for the rest.
+- Info tab uses `data-lang` sibling blocks (EN + ES fully written).
+- `<html lang="…">` reflects the active language.
+
+### Layout / responsiveness (Rev49..Rev57)
+
+- Landscape: rose stretches to fill the left column; control column becomes
+  a `1fr 1fr auto` grid so tack + AP rows fill the height instead of
+  clustering at the top. Text auto-shrinks via `clamp(min, min(vw, vh), max)`.
+- Portrait: nav bar and swipe hint always visible; corner tiles inside the
+  rose square; long paths get horizontal scroll wrappers.
+- **Swipe navigation** (Rev43..Rev57) between tabs: 80px threshold, 2.2×
+  H/V ratio, first-move axis lock so scrolling never triggers a stray
+  tab flip. Excluded over unlocked sliders and `.paths-scroll` wrappers.
+- Nav-bar auto-hide toggle via yellow triangle in the swipe-hint strip.
+
+### Backend (src/index.ts)
+
+- `PLUGIN_REVISION` bumped Rev32 → Rev61 (11 packaged Revs since 0.1.0).
+- New `sshUser` + `sshPassword` plugin config fields (Rev55).
+- New `POST /plugins/*/restart-pypilot` router using `ssh2` (Rev55).
+- `/status` exposes `sshUser`, `sshPasswordSet` (never the password itself),
+  and the package `version` from `package.json` (Rev59).
+- Wildcard subscription to `performance.*` for polar-performance keys +
+  `environment.water.temperature` (Rev58).
+- Optimistic UI + retry helper in the frontend (Rev56); no backend change.
+
+### Screenshots + logo (Rev61)
+
+- App Store screenshots in `public/screenshots/` (JPEG < 500 KB each,
+  4 shots: Control / Tune / Info / Setup).
+- Vector logo `public/Pypilot_New_UI.svg` (33 KB) wired as
+  `signalk.appIcon`.
+- `signalk.screenshots[]` populated for the App Store card.
+
+### Docs
+
+- README rewritten: full feature list, coexistence table, remote restart,
+  updated endpoint table, acknowledgements, safety, reporting.
+- App Store `description` in `package.json` replaced with a
+  user-facing one-paragraph blurb.
+
+## 0.1.0 — 2026-07-21
+
+### Rev1..Rev6 first-boot iteration on the Tunatunes Pi
+
+- Rev1 scaffold.
+- Rev2 fix: factory function forgot to `return plugin` -> SK crashed with
+  `Cannot read properties of undefined (reading 'id')`.
+- Rev3 fix: `publishMeta` sent `updates:[{meta:[...]}]` without `values`,
+  triggering `update.values is not iterable` in the SK delta iterator.
+- Rev4 refactor: attach `meta` INLINE on the first `publishValue` of each
+  path so no delta ever carries an empty `values` array. Dropped the
+  separate `publishMeta` call.
+- Rev5 diagnostic: catalog counts in `setPluginStatus`.
+- Rev6 fix: pypilot exposes gains as `ap.pilot.<pilot>.<gain>` (SINGULAR),
+  not `ap.pilots.*` as the initial brief assumed. Confirmed by inspecting
+  `pypilot_values` on the socket.io wire. Corrected in publisher.ts,
+  index.ts (setupWatches + status), and public/app.js (renderGains).
+
+### Known limitation
+
+`signalk-pushover-plugin@0.0.6` emits two `Unhandled rejection: TypeError:
+update.values is not iterable` at every SK restart, even before our plugin
+publishes anything. The stack is pushover's own (`index.js:193:71`) and
+does not reference our plugin. Ignore, or file upstream against
+pushover-plugin.
+
+### Backend
+- src/pypilot-client.ts: socket.io client to `pypilot_web`, reconnect,
+  `pypilot_values` catalog discovery, watch/set primitives, ping/pong.
+- src/publisher.ts: fixed + dynamic mapping table pypilot names to
+  `steering.autopilot.pypilot.*` (gains, servo, calibration, tack,
+  errors, warnings, runtime, version). Deg->rad and C->K conversions.
+- src/scanner.ts: /24 LAN scan, TCP probe on ports 80 and 8000, HTTP
+  fingerprint on `<title>pypilot control</title>`.
+- src/index.ts: plugin lifecycle + JSON schema + PUT handlers (with
+  reverse rad->deg on angle paths) + HTTP router (`/status`, `/paths`,
+  `/catalog`, `/scan`, `/raw`).
+
+### Reserved for pypilot-autopilot-provider (never republished)
+`ap.enabled`, `ap.heading`, `ap.heading_command`, `ap.mode`. Both plugins
+coexist.
+
+- Backend: socket.io client to `pypilot_web`, catalog discovery via
+  `pypilot_values`, watch subscriptions, delta publisher with
+  configurable per-path enable/disable.
+- Paths: full `steering.autopilot.pypilot.*` tree (gains, servo,
+  calibration, tack, errors, warnings, runtime, version).
+- HTTP: `/scan` LAN discovery, `/status`, `/paths` KIP-friendly catalog,
+  `/raw` protected write.
+- Webapp: mobile-first dark, four tabs (Control, Ajustes, Paths & API,
+  Setup). Control tab fully wired against the Autopilot API v1 of
+  Signal K (engage / disengage / mode / target / tack / heading nudges);
+  Ajustes tab with translucent-while-adjusting sliders for gains and
+  calibration; Paths & API tab with live path list + copy-for-KIP;
+  Setup tab with LAN scan.
+- Coexists with the official `pypilot-autopilot-provider` — this plugin
+  never publishes `steering.autopilot.state / mode / target / engaged`
+  (those stay with the provider).

package/NOTICE

@@ -0,0 +1,30 @@
+signalk-pypilot-newui
+Copyright 2026 Aitonos
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this project except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+
+This project includes an "Autopilot Provider" adapter
+(src/autopilot-provider.ts) whose method structure and command
+translation semantics are derived from:
+
+    pypilot-autopilot-provider
+    Copyright (c) Panaaj
+    https://github.com/panaaj/pypilot-autopilot-provider
+    Apache License 2.0
+
+The upstream project ships its own socket.io client. In our fork we
+re-implemented the same command surface on top of the PypilotClient we
+already carry (src/pypilot-client.ts) so that a Signal K server with
+both plugins effectively active only ever opens ONE socket to the
+pypilot_web process on the TinyPilot. This is a functional benefit for
+Pi Zero W hardware; no derivative works of the upstream code itself are
+distributed.
+
+For the socket.io protocol layer talking to pypilot_web (watch=, name=value)
+we independently confirmed it against the upstream pypilot sources
+(https://github.com/pypilot/pypilot) which are LGPL-3.0.

package/README.md

@@ -0,0 +1,171 @@
+# signalk-pypilot-newui
+
+**PyPilot New-UI + SK Paths** — a modern, touch-first control panel for the
+open-source [pypilot](https://github.com/pypilot/pypilot) autopilot, plus every
+pypilot value exposed as a first-class Signal K path so tools like
+[KIP](https://kip.signalk.org), WilhelmSK and freeboard can build custom gauges
+and switches out of the box.
+
+Runs alongside [`pypilot-autopilot-provider`](https://www.npmjs.com/package/pypilot-autopilot-provider)
+by Panaaj — see [Working alongside pypilot-autopilot-provider](#working-alongside-pypilot-autopilot-provider).
+
+## What it does
+
+**Touch webapp** (mobile / tablet / chart-plotter, dark theme):
+
+- Compass rose with heading readout, cardinals + degree ticks, hull-fixed
+  green/red sailing wedges, AWA + TWA arrows (independent, toggleable), cyan
+  target diamond, and 4 configurable corner tiles (long-press to reconfigure).
+- Big-touch AP engage / disengage with optimistic UI + auto-retry over
+  flaky links (Tailscale-safe).
+- Tack port / starboard, mode selector (compass / GPS / wind / true wind / nav),
+  nudge ±1 / ±10 with configurable step size, current heading snap on engage.
+- **Tune** tab with locked-by-default gain sliders (auto-relock on tab exit),
+  ±10 / ±1 buttons flanking each slider, orange "previous value" reference.
+- **Race** timer T1/T2 with beeps, screen flash, spoken seconds countdown
+  ("10, 5, 4, 3, 2, 1, Start"). Runs in the background across tabs.
+- **Setup** with LAN scan, manual host+port, KIP absorb-provider toggle,
+  SSH-based remote `RESTART pypilot` button (credentials stored in plugin
+  config), nudge step size, language, IMU / rudder calibration.
+- **Paths & API** tab with live catalog of published paths, per-path publish
+  toggles, KIP copy-to-clipboard helpers.
+- **Info** tab with quick-start, coexistence rules, credits, license, GitHub
+  link, config export / import (Web Share API → email / WhatsApp / Signal /
+  AirDrop, `.json` download, clipboard).
+- Full i18n: **English / Español / Deutsch / Français** (auto-detected from
+  browser, override in Setup → Language).
+- Regatta-safe swipe navigation between tabs with vertical-axis-lock so
+  scrolling never triggers a stray tab flip.
+- Signal K polar-performance and any custom SK path bindable to a corner tile.
+
+**~60 Signal K paths** under `steering.autopilot.pypilot.*` (opt-in per path):
+
+- Gains per pilot (`P`, `I`, `D`, `DD`, `PR`, `FF`).
+- Servo telemetry (voltage, current, controller / motor temperatures, flags,
+  amp-hours, clutch engaged, controller error).
+- Rudder calibration (offset, scale, non-linearity, range, calibration state).
+- IMU heading offset, errors, warnings.
+- Active pilot, active profile, available pilots / profiles / modes.
+- Tack state, tack direction, tack timeout.
+- Runtime, version.
+
+**KIP-ready Simple Switches** under `electrical.switches.pypilot.*`:
+
+- `ap.state` — momentary boolean, engage / disengage.
+- `nudge.{bigPort,smallPort,smallStar,bigStar}` — momentary, auto-reset.
+- `tack.{port,starboard,cancel}` — momentary.
+- `mode.{compass,gps,wind,trueWind,nav}` — radio (mutually exclusive).
+- `profile.<name>` — radio, dynamic per pilot profile.
+
+## Installation
+
+1. Signal K Server → **App Store** → search **PyPilot New-UI**.
+2. Server → **Plugin Config** → **PyPilot New-UI + SK Paths**.
+3. Enter the `pypilot_web` host (IP or hostname) and port. On TinyPilot the
+   default is port `80`; on a classic pypilot install it is `8000`.
+4. The **Scan LAN** button in the webapp auto-detects hosts running
+   `pypilot_web` on ports 80 / 8000 of your subnet if you don't know the IP.
+5. Enable the plugin.
+
+**Webapp URL**: `http://<sk-host>:3000/signalk-pypilot-newui/`
+
+## Working alongside `pypilot-autopilot-provider`
+
+We build on top of the excellent
+[`pypilot-autopilot-provider`](https://www.npmjs.com/package/pypilot-autopilot-provider)
+by Panaaj — the plugin that gives Signal K the standard
+**Autopilot API v2** surface (`/signalk/v2/api/vessels/self/autopilots/*`) so
+WilhelmSK, freeboard and other clients can drive pypilot through the canonical
+interface. Panaaj focuses tightly on that API and opens its own socket.io
+connection to `pypilot_web`.
+
+This plugin adds ~60 additional pypilot values on top (gains, servo telemetry,
+calibration, warnings, profiles, tack detail, etc.), ships the touch webapp,
+and can optionally register the Autopilot API v2 itself via the
+**absorbProvider** option in Setup, so a single socket hits `pypilot_web`
+instead of two — useful when pypilot runs on a Pi Zero W.
+
+Signal K only allows one provider per pilot ID, so if you turn on
+**absorbProvider** here you should disable Panaaj's plugin (otherwise both
+register the same ID and behaviour is undefined). Valid setups:
+
+| Panaaj `pypilot-autopilot-provider` | `signalk-pypilot-newui` absorb | Result |
+|---|---|---|
+| Enabled | Off (default) | Both run happily side by side. Panaaj owns the AP v2 API; this plugin adds the extra paths + UI. **2 sockets** to `pypilot_web`. |
+| Disabled | **On** | Only this plugin. Same AP v2 API + all the extras. **1 socket**. Handy on Pi Zero W. |
+| Enabled | On | Both try to register the same AP ID — leave one off. |
+| Disabled | Off | WilhelmSK / freeboard / KIP won't see the AP. Only useful if you exclusively use this plugin's own webapp. |
+
+Absorb mode lives in **Setup → Autopilot Provider (one-socket mode)**.
+
+## Remote `RESTART pypilot`
+
+When the autopilot process on the TinyPilot gets wedged you don't need to open
+an SSH session by hand. In **Setup → Emergency**, save the TinyPilot's SSH user
++ password once; the **RESTART pypilot** button then runs
+`sudo systemctl restart pypilot pypilot_web` over SSH and reconnects the local
+socket. Signal K stores plugin configs in plain text under
+`~/.signalk/plugin-config-data/` so use credentials that are only valid for
+that isolated TinyPilot.
+
+## HTTP endpoints (plugin router)
+
+| Method | Path | Purpose |
+|---|---|---|
+| `GET`  | `/plugins/signalk-pypilot-newui/status`        | Connection + last-seen catalog summary + Rev + version |
+| `GET`  | `/plugins/signalk-pypilot-newui/scan`          | Scan LAN for `pypilot_web` hosts |
+| `GET`  | `/plugins/signalk-pypilot-newui/paths`         | Live list of published SK paths with GET / PUT URLs and units |
+| `GET`  | `/plugins/signalk-pypilot-newui/catalog`       | Raw pypilot catalog (all values + metadata) |
+| `PUT`  | `/plugins/signalk-pypilot-newui/raw`           | Send raw `name=value` to pypilot (protected by `allowWrites`) |
+| `POST` | `/plugins/signalk-pypilot-newui/restart-pypilot` | SSH remote restart, uses `sshUser` + `sshPassword` from plugin config |
+| `POST` | `/plugins/signalk-pypilot-newui/pause`         | Disconnect local socket (for scripts) |
+| `POST` | `/plugins/signalk-pypilot-newui/resume`        | Reconnect local socket (for scripts) |
+
+## Safety
+
+- `allowDirectServo` defaults to **off** — the direct `servo.command` back-door
+  used by pypilot's own UI for manual steering is not exposed until you enable
+  it explicitly in the plugin config.
+- All PUT handlers validate ranges from the pypilot catalog before sending.
+- On plugin stop the socket closes cleanly; the visor auto-reconnects on
+  Signal K restart.
+- This plugin is an aid to navigation and steering. It does not replace the
+  vigilance of the skipper, correct manoeuvring, direct observation of the
+  surroundings, or official charts and notices. Verify in safe waters before
+  relying on the autopilot for demanding manoeuvres.
+
+## Acknowledgements
+
+- **Sean D'Epagnier** — creator of [pypilot](https://github.com/pypilot/pypilot),
+  the open-source autopilot that makes this plugin possible.
+- **Jean-Marc** at [Navitop](https://www.navitop.fr/) — for the TinyPilot
+  hardware and marine integrations, and for making pypilot accessible to
+  European sailors.
+- The [Signal K](https://signalk.org/) community and OpenPlotter for the open
+  ecosystem this plugin runs on.
+- Panaaj — for
+  [`pypilot-autopilot-provider`](https://www.npmjs.com/package/pypilot-autopilot-provider),
+  the reference AP v2 provider this plugin builds on top of.
+
+## Reporting issues / feature requests
+
+Open an issue on GitHub —
+[github.com/Aitonos/signalk-pypilot-newui/issues](https://github.com/Aitonos/signalk-pypilot-newui/issues).
+Include the Rev (visible in the app under **Info** → top header, or via
+`GET /plugins/signalk-pypilot-newui/status`), what you expected, what happened,
+and a screenshot if possible.
+
+## Development
+
+```
+git clone https://github.com/Aitonos/signalk-pypilot-newui
+cd signalk-pypilot-newui
+npm install
+npm run build
+```
+
+Deploy from a Windows laptop to a Raspberry Pi: `.\deploy.ps1 -Restart`.
+
+## License
+
+Apache-2.0, Aitonos. See `NOTICE` for third-party attributions.

package/dist/autopilot-provider.js

@@ -0,0 +1,220 @@
+"use strict";
+// Autopilot Provider adapter. When props.absorbProvider is on, this plugin
+// registers itself with the SK server as an autopilot provider, in addition
+// to its own steering.autopilot.pypilot.* paths. Purpose: eliminate the
+// duplicate socket to pypilot_web that occurs when both this plugin and the
+// official pypilot-autopilot-provider are enabled.
+//
+// Translation semantics of engage / setMode / setTarget / tack / dodge come
+// from the official pypilot-autopilot-provider (Apache-2.0, Panaaj). We
+// re-implemented them here on top of our own PypilotClient so we keep a
+// single socket to pypilot_web. See NOTICE + CHANGELOG for attribution.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutopilotProvider = void 0;
+const DEG_TO_RAD = Math.PI / 180;
+const RAD_TO_DEG = 180 / Math.PI;
+class AutopilotProvider {
+    constructor(client, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    app, opts) {
+        this.client = client;
+        this.app = app;
+        this.deviceId = "pypilot-newui";
+        this.pilotIds = ["pypilot-newui"];
+        this.data = {
+            state: "off-line",
+            mode: null,
+            target: null,
+            engaged: false,
+            options: {
+                states: [
+                    { name: "enabled", engaged: true },
+                    { name: "disabled", engaged: false },
+                ],
+                modes: [],
+                actions: [
+                    { id: "tack", name: "Tack", available: false },
+                    { id: "courseCurrentPoint", name: "To Destination", available: false },
+                ],
+            },
+        };
+        this.pypilotModes = [];
+        this.allowDodge = false;
+        if (opts?.allowDodge)
+            this.allowDodge = true;
+    }
+    // Called from PypilotClient 'value' event. Returns true if apData changed
+    // and an autopilotUpdate should be pushed.
+    receiveValue(name, value) {
+        let changed = false;
+        switch (name) {
+            case "ap.heading_command":
+                if (typeof value === "number") {
+                    const rad = value * DEG_TO_RAD;
+                    if (rad !== this.data.target) {
+                        this.data.target = rad;
+                        changed = true;
+                    }
+                }
+                else if (value === false && this.data.target !== null) {
+                    this.data.target = null;
+                    changed = true;
+                }
+                break;
+            case "ap.mode":
+                if (typeof value === "string" && value !== this.data.mode) {
+                    this.data.mode = value;
+                    if (this.data.options.modes.length === 0) {
+                        this.data.options.modes.push(value);
+                    }
+                    changed = true;
+                }
+                break;
+            case "ap.modes":
+                if (Array.isArray(value)) {
+                    this.pypilotModes = value.map(String);
+                    this.data.options.modes = [...this.pypilotModes];
+                }
+                break;
+            case "ap.enabled": {
+                const eng = !!value;
+                const st = eng ? "enabled" : "disabled";
+                if (this.data.state !== st || this.data.engaged !== eng) {
+                    this.data.state = st;
+                    this.data.engaged = eng;
+                    changed = true;
+                }
+                break;
+            }
+        }
+        if (changed)
+            this.recomputeActions();
+        return changed;
+    }
+    markOffline() {
+        if (this.data.state !== "off-line" || this.data.engaged) {
+            this.data.state = "off-line";
+            this.data.engaged = false;
+            this.recomputeActions();
+        }
+    }
+    // ---- write path ----
+    async setState(state) {
+        const st = this.data.options.states.find((s) => s.name === state);
+        if (!st)
+            throw new Error(`Invalid state: ${state}`);
+        this.client.set("ap.enabled", st.engaged);
+        return st.engaged;
+    }
+    async setMode(mode) {
+        if (this.data.options.modes.length > 0 &&
+            !this.data.options.modes.includes(mode)) {
+            throw new Error(`Invalid mode: ${mode}`);
+        }
+        this.client.set("ap.mode", mode);
+    }
+    async setTarget(rad) {
+        const deg = rad * RAD_TO_DEG;
+        this.client.set("ap.heading_command", deg);
+    }
+    async adjustTarget(rad) {
+        if (this.data.engaged) {
+            const base = typeof this.data.target === "number" ? this.data.target : 0;
+            const newRad = base + rad;
+            this.client.set("ap.heading_command", newRad * RAD_TO_DEG);
+        }
+        else if (this.allowDodge) {
+            await this.dodge(rad);
+        }
+        else {
+            throw new Error("Adjust while disengaged requires allowDirectServo");
+        }
+    }
+    async tack(direction) {
+        // The upstream provider only writes ap.tack.direction and lets pypilot
+        // auto-begin. We explicitly send begin too so the tack starts even on
+        // pypilot versions that require it.
+        this.client.set("ap.tack.direction", direction);
+        this.client.set("ap.tack.state", "begin");
+    }
+    async engage() {
+        try {
+            await this.setNavMode();
+        }
+        catch {
+            await this.setState("enabled");
+        }
+    }
+    async disengage() {
+        await this.setState("disabled");
+    }
+    async setNavMode() {
+        const cdata = await this.app.getCourse?.();
+        if (cdata?.nextPoint &&
+            this.getAvailableActionIds().includes("courseCurrentPoint")) {
+            await this.setMode("nav");
+            setTimeout(() => this.setState("enabled").catch(() => { }), 500);
+        }
+        else {
+            throw new Error("Nav mode is not available");
+        }
+    }
+    async dodge(rad) {
+        if (!this.allowDodge) {
+            throw new Error("Dodge requires allowDirectServo=true in plugin config");
+        }
+        // Simple dodge: emit a servo.command pulse. Upstream watchdogs it every
+        // 200 ms for a couple of ticks; we only emit once and let pypilot's own
+        // servo watchdog return the rudder to neutral (6 s upstream default).
+        const sign = rad > 0 ? 1 : -1;
+        this.client.set("servo.command", -sign);
+    }
+    recomputeActions() {
+        for (const a of this.data.options.actions) {
+            if (a.id === "tack") {
+                a.available = this.data.engaged;
+            }
+            else if (a.id === "courseCurrentPoint") {
+                a.available = this.data.engaged && this.pypilotModes.includes("nav");
+            }
+        }
+    }
+    getAvailableActionIds() {
+        return this.data.options.actions
+            .filter((a) => a.available)
+            .map((a) => a.id);
+    }
+    // Object literal expected by app.registerAutopilotProvider(...).
+    toProviderInterface() {
+        const self = this;
+        return {
+            getData: async (_id) => self.data,
+            getState: async (_id) => self.data.state,
+            setState: async (state, _id) => {
+                await self.setState(state);
+            },
+            getMode: async (_id) => self.data.mode,
+            setMode: async (mode, _id) => self.setMode(mode),
+            getTarget: async (_id) => self.data.target,
+            setTarget: async (value, _id) => self.setTarget(value),
+            adjustTarget: async (value, _id) => self.adjustTarget(value),
+            engage: async (_id) => self.engage(),
+            disengage: async (_id) => self.disengage(),
+            courseCurrentPoint: async (_id) => self.setNavMode(),
+            courseNextPoint: async (_id) => {
+                throw new Error("Not implemented");
+            },
+            tack: async (direction, _id) => self.tack(direction),
+            gybe: async (_direction, _id) => {
+                throw new Error("Not implemented");
+            },
+            dodge: async (value, _id) => {
+                if (value)
+                    await self.dodge(value);
+                else
+                    throw new Error("Not implemented");
+            },
+        };
+    }
+}
+exports.AutopilotProvider = AutopilotProvider;