signalk-pypilot-newui 2.0.4 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,115 @@
 # Changelog
 
+## 2.1.0 — 2026-08-25 — Rev68..Rev87
+
+Twenty in-session Revs of iterative visual + reliability work rolled up
+into a proper minor release. Themes: a full redesign of the compass-rose
+autopilot overlays ("Gota Chain"), a hard-earned fix for AP mutations
+racing each other across the SignalK bus, and a permanent seamless-auth
+story so a Signal K restart never again silently disables the visor's
+mutation buttons.
+
+### Added
+
+- **Gota Chain overlay** — the target diamond and the AWA/TWA wind
+  arrows are now three concentric SVG pieces that interlock into one
+  clean droplet when `target ≡ AWA ≡ TWA`. Each piece carries its own
+  letter (A / T) and its own color ring-tick that marks the exact
+  angle on the compass. When any of the three drifts, its V-hembra
+  opens as a visible hollow. Iterated over 12 Revs (Rev68..Rev82)
+  with Carlos on Tunatunes.
+- **COG line** — chain of yellow chevrons from the bow toward the
+  course-over-ground direction. Visible only when `SOG > 0.15 kn`.
+- **Current vector** — two parallel wavy blue lines with three
+  triangles pointing at the boat. Computed as `SOG − SOW` (added
+  new `navigation.speedThroughWater` subscription). Visible when
+  `|current| > 0.2 kn`.
+- **4-card overlay selector** — long-press any rose corner OR the
+  boat sprite to open the popup with the four toggle cards (AWA,
+  TWA, COG, Current), each with a large preview and a data-
+  requirement line ("Needs a wind sensor", "Only shows when SOG >
+  0.15 kn", etc). Toggles persist in `localStorage`.
+- **Rose cardinals colour-coded**: N orange, E green, S blue, W red.
+  All at the same radius `r = 70`. Thin black stroke around each
+  letter for legibility on any background.
+- **Seamless auth via SK Access Request** — the visor now uses a
+  device-scoped, permanent SK token instead of a short-lived JWT.
+  On first install the user approves once from `SK admin → Security
+  → Access Requests`; from then on the token survives every SK
+  server restart, every plugin redeploy, and every browser reload,
+  so mutations (engage / mode / target) NEVER silently 401 again.
+- **`.\deploy.ps1 -FrontOnly`** — new script flag that syncs
+  `public/` only (no build, no npm install, no `systemctl restart
+  signalk`). Use it when the diff is HTML / CSS / JS only —
+  `Ctrl+F5` in the browser picks it up. Avoids the plugin-socket
+  reconnect to `pypilot_web` on the Pi Zero W that pushed the
+  TinyPilot to hang after a big batch of deploys.
+
+### Fixed
+
+- **AP mutation race (`DIA jumps to a stale target for a beat`).**
+  Frontend used to `Promise.all([engage, target])` and the backend's
+  `pushAutopilotUpdate` published ALL SK autopilot fields on every
+  notify — so whichever POST landed first emitted a delta that
+  carried the OTHER field's STALE value (typically an old target
+  from the previous session, e.g. `115°` when the intent was `75°`).
+  Fixed by refactoring `AutopilotProvider.notifyChanged(fields)` to
+  accept `"engaged" | "target" | "all"` and `pushAutopilotUpdate` to
+  only emit the paths that actually changed. Parallel POSTs no
+  longer clobber each other with stale copies.
+- **Wind-mode target capture on engage.** `doEngage` always sent
+  `state.heading` as the target regardless of mode; pypilot in wind
+  mode interpreted that compass value as a wind angle and steered
+  the boat toward nonsense. Now captures `state.windAngle` (apparent)
+  or `state.windAngleTrue` (true wind) when the active mode contains
+  "wind"; falls back to heading only for compass / gps / nav.
+- **AP button "click missed" and engage / disengage bounce**
+  hardened: switched from `click` to `pointerdown` (fires once per
+  press on both touch and mouse without waiting for the
+  browser-synthesised `click`), swallow the trailing `click` with
+  `preventDefault + stopPropagation`, `touch-action: manipulation`
+  on the button, plus an 800 ms cooldown gate that survives the
+  ~200 ms POST round-trip. Ghost taps from `touchend` no longer
+  produce a phantom second engage.
+- **Wind speed chip tap regressions.** Chip was picked up by the
+  corner-selector `forEach` (auto-attached its 500 ms long-press
+  timer → opened the wrong popup) AND the `<main>` tab-swipe
+  handler treated any tap-with-drift on it as a horizontal swipe
+  → the chip appeared to slide right. Renamed the chip class to
+  `.wind-chip` so the forEach ignores it and replaced the shared
+  handler with a bespoke `pointerdown/up` short-tap detector that
+  stops touch propagation.
+- **HDG chip / compass labels covered by DIA** on engage: reordered
+  the SVG stack so the compass card and HDG chip render AFTER the
+  gota pieces, never behind them.
+- **DIA arc rendering asymmetry** ("bump on one side") when
+  rotated: `stroke-linejoin` switched from `round` to `miter`,
+  raya `stroke-linecap` switched from `round` to `butt` to remove
+  the semi-circle that overshot the ring line.
+
+### Changed
+
+- **Wind speed chip moved from an SVG group to a positioned HTML
+  `.wind-chip` div** overlaid on the rose bottom-center. Text
+  baseline now aligns with the two bottom corner cells so all
+  three values (BL / BC / BR) read as one row.
+- **SVG stacking order** finalised (bottom → top): ring · wind
+  sectors · boat sprite · TWA · AWA · DIA · raya · AWA / TWA
+  colour ring-ticks · COG line · current vector · compass card ·
+  HDG chip. Wind chip is a separate HTML overlay above the SVG.
+- **Restart engine** already switched to `sv restart` (piCore
+  runit) in 2.0.4; the docs, i18n text and Info-tab quick-start
+  now match — the earlier "three escalated restarts" wording was
+  outdated (Emergency section has been 2 buttons since Rev66:
+  `RESTART pypilot` + `reboot Pi`; the safe `restart pypilot_web`
+  lives in the Debug console).
+- **Info-tab quick-start** rewritten in EN + ES to describe the
+  Gota Chain, the 4-card overlay selector, the new cardinal
+  colors, and boat-long-press as an alternative selector opener.
+- **README** overview and "Remote restart / reboot" section
+  rewritten to match the current 2-button + Debug-console layout,
+  and to describe the Gota Chain + optional overlays.
+
 ## 2.0.4 — 2026-08-21 — Rev67
 
 Reintroduces (with proper QA) the UI polish + reliability work that was

package/README.md

@@ -22,18 +22,28 @@ dashboards wired to 1.0.0 paths, see the full migration table in
 - `.calibration.rudderRange` (rad) -> `.rudder.range` (deg)
 - `.gains.<pilot>.<gain>` -> `.ap.pilot.<pilot>.<gain>`
 
-Also new in 2.0.0: three escalated **restart / reboot levels** in
-Setup -> Emergency, all guarded by a helm-manned confirmation modal, and
-a **Debug console** with an SSH-based whitelist of preset diagnostic
-commands (logs, dmesg, top, uptime, df, pypilot version).
+Setup -> Emergency ships **two remote restart buttons** (`RESTART pypilot`
+and `reboot Pi`), both guarded by a helm-manned confirmation modal.
+`restart pypilot_web` (the safe web-only restart that does not interrupt
+steering) lives as a preset in the **Debug console** — an SSH-based
+whitelist of preset diagnostic commands (logs, dmesg, top, uptime, df,
+pypilot version, restart pypilot_web).
 
 ## 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).
+- Compass rose with HDG readout, colour-coded cardinals (N orange, E green,
+  S blue, W red) + degree ticks, hull-fixed green/red sailing wedges, and 4
+  configurable corner tiles (long-press to reconfigure).
+- **Gota Chain** overlay: three concentric arrow pieces on the rose — cyan
+  target diamond, amber `A` (AWA), sea-green `T` (TWA). Interlock into one
+  clean droplet when all three angles coincide; the V-hembra of any piece
+  that drifts opens up as a visible hollow, and a colour ring-tick marks
+  the exact angle on the compass. Optional **COG line** from the bow
+  (yellow chevrons) and **current vector** (SOG − SOW, blue wavy arrow)
+  can be toggled from a 4-card selector opened by long-press on any
+  corner or on the boat sprite.
 - 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),
@@ -116,28 +126,29 @@ register the same ID and behaviour is undefined). Valid setups:
 
 Absorb mode lives in **Setup → Autopilot Provider (one-socket mode)**.
 
-## Remote restart / reboot triad + Debug console
-
-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. From then on you get three escalated actions, colour-coded
-from safest to loudest, each guarded by a helm-manned confirmation modal that
-asks whether someone is at the helm before executing:
-
-1. **restart pypilot_web** (~3-5 s) - only the web server restarts. The AP
-   core keeps steering. Use when the visor gets stuck but the pilot is fine.
-2. **RESTART pypilot** (~10-15 s) - restarts pypilot core + web. The AP drops
-   the heading briefly and re-engages when it comes back up.
-3. **reboot Pi** (~35-60 s) - full `sudo reboot` of the Raspberry Pi. No
-   autopilot for almost a minute. Last-resort when the box is in a bad state.
-
-Underneath the triad there is a **Debug console** that runs a closed
-whitelist of preset diagnostic commands over the same SSH session:
-`logs pypilot`, `logs pypilot_web`, `dmesg`, `top`, `uptime`, `df`,
-`pypilot --version`. Output goes into a scrollable textarea, a "Follow
-logs" toggle polls `journalctl --since '30 s ago'` every 3 seconds, and
-Copy / Share buttons let you paste the dump straight into a GitHub
-issue or a WhatsApp / email conversation with your friendly rigger.
+## Remote restart / reboot + Debug console
+
+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. From then on you get **two big restart buttons**,
+each guarded by a helm-manned confirmation modal that asks whether someone
+is at the helm before executing:
+
+1. **RESTART pypilot** (~10-15 s) — `sv restart` of the pypilot core + web
+   (runit under piCore). The AP drops the heading briefly and re-engages
+   when it comes back up.
+2. **reboot Pi** (~35-60 s) — full `sudo reboot` of the Raspberry Pi. No
+   autopilot for almost a minute. Last-resort when the box is in a bad
+   state.
+
+The safe **restart pypilot_web** (web server only, does not interrupt
+steering) lives as a preset button in the **Debug console** below,
+alongside a closed whitelist of preset diagnostic commands over the same
+SSH session: `logs pypilot`, `logs pypilot_web`, `dmesg`, `top`, `uptime`,
+`df`, `pypilot --version`. Output goes into a scrollable textarea, a
+"Follow logs" toggle polls `journalctl --since '30 s ago'` every 3
+seconds, and Copy / Share buttons let you paste the dump straight into a
+GitHub issue or a WhatsApp / email conversation with your friendly rigger.
 
 The endpoint (`POST /plugins/*/debug-cmd`) refuses any command that is
 not in the whitelist, so a leaked JWT cannot be used to run arbitrary
@@ -156,8 +167,8 @@ that isolated TinyPilot.
 | `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 (level 2 of the triad), uses `sshUser` + `sshPassword` from plugin config |
-| `POST` | `/plugins/signalk-pypilot-newui/debug-cmd`     | Run one of a closed whitelist of preset diagnostic / restart commands over SSH (levels 1 and 3 of the triad + logs / dmesg / top / etc). Body: `{ "preset": "<name>" }` |
+| `POST` | `/plugins/signalk-pypilot-newui/restart-pypilot` | SSH `sv restart` of pypilot core+web on the TinyPilot, uses `sshUser` + `sshPassword` from plugin config |
+| `POST` | `/plugins/signalk-pypilot-newui/debug-cmd`     | Run one of a closed whitelist of preset diagnostic / restart commands over SSH (`restart.web`, `reboot.pi`, `logs.pypilot`, `logs.web`, `dmesg`, `top`, `uptime`, `df`, `pypilot.version`). Body: `{ "preset": "<name>" }` |
 | `POST` | `/plugins/signalk-pypilot-newui/pause`         | Disconnect local socket (for scripts) |
 | `POST` | `/plugins/signalk-pypilot-newui/resume`        | Reconnect local socket (for scripts) |
 

package/dist/autopilot-provider.js

@@ -13,6 +13,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutopilotProvider = void 0;
 const DEG_TO_RAD = Math.PI / 180;
 const RAD_TO_DEG = 180 / Math.PI;
+// Rev68: after a local target write we ignore pypilot echoes that do not
+// match, for up to this many ms. 2 s covers the worst RTT + pypilot apply
+// latency observed on Tunatunes (~500-800 ms). See receiveValue for why.
+const TARGET_PENDING_MS = 2500;
+// Tolerance for treating an echoed heading_command as "the value we asked
+// for" vs "stale echo of the previous value". Pypilot stores heading_command
+// as float and echoes verbatim in practice, but allow a small margin for
+// rounding on the wire.
+const TARGET_ECHO_TOL_RAD = 2 * DEG_TO_RAD;
+function shortestArcRad(a, b) {
+    let d = a - b;
+    while (d > Math.PI)
+        d -= 2 * Math.PI;
+    while (d <= -Math.PI)
+        d += 2 * Math.PI;
+    return d;
+}
 class AutopilotProvider {
     constructor(client, 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -40,8 +57,23 @@ class AutopilotProvider {
         };
         this.pypilotModes = [];
         this.allowDodge = false;
+        // Rev68: echo cancellation for local target writes. See setTarget /
+        // adjustTarget / receiveValue.
+        this.pendingTarget = null;
+        // Rev70: same treatment for the engaged flag. Without it, a pypilot
+        // ap.enabled=false echo can arrive between our POST /engage and the
+        // real echo, flip data.engaged to false, push a SK delta, and the
+        // JS button turns off; user re-taps and the AP ends up bouncing.
+        this.pendingEngaged = null;
         if (opts?.allowDodge)
             this.allowDodge = true;
+        this.onDataChanged = opts?.onDataChanged;
+    }
+    notifyChanged(fields) {
+        try {
+            this.onDataChanged?.(fields || "all");
+        }
+        catch { /* silent */ }
     }
     // Called from PypilotClient 'value' event. Returns true if apData changed
     // and an autopilotUpdate should be pushed.
@@ -51,6 +83,28 @@ class AutopilotProvider {
             case "ap.heading_command":
                 if (typeof value === "number") {
                     const rad = value * DEG_TO_RAD;
+                    // Rev68: echo cancellation. When JS pushes a nudge or engage the
+                    // provider assigns data.target OPTIMISTICALLY and marks pending.
+                    // Pypilot needs 200-800 ms to apply the set and echo the new
+                    // heading_command; meanwhile its 2 Hz watch tick may push the
+                    // OLD value on the wire. Without gating, that stale echo would
+                    // overwrite data.target and the diamond would jump back to the
+                    // previous target, then jump forward again when the real echo
+                    // finally landed. Bug reported by Carlos on Rev67 v2.0.4:
+                    // "aparece en mal sitio, nudge lo mueve pero se mueve solo
+                    // luego, hace rebotes".
+                    if (this.pendingTarget && Date.now() < this.pendingTarget.until) {
+                        const diff = Math.abs(shortestArcRad(rad, this.pendingTarget.value));
+                        if (diff <= TARGET_ECHO_TOL_RAD) {
+                            // Real echo landed - clear pending, keep our value (may be
+                            // slightly more precise than the echo). No change signal
+                            // needed since data.target already equals the pending value.
+                            this.pendingTarget = null;
+                        }
+                        // Whether match or stale, do not overwrite data.target inside
+                        // the pending window.
+                        break;
+                    }
                     if (rad !== this.data.target) {
                         this.data.target = rad;
                         changed = true;
@@ -58,6 +112,7 @@ class AutopilotProvider {
                 }
                 else if (value === false && this.data.target !== null) {
                     this.data.target = null;
+                    this.pendingTarget = null;
                     changed = true;
                 }
                 break;
@@ -78,6 +133,21 @@ class AutopilotProvider {
                 break;
             case "ap.enabled": {
                 const eng = !!value;
+                // Rev70: echo cancellation on the engaged flag. See notes on
+                // pendingEngaged. Without this, when the JS button POSTs an
+                // engage, pypilot's 2 Hz watch tick may push ap.enabled=false
+                // (its OLD stored value) between our set and pypilot's real
+                // apply. That stale echo would flip data.engaged back to false,
+                // publish a SK delta, and the JS button would grey out
+                // momentarily - Carlos re-taps and the whole AP bounces
+                // engage-disengage-engage. Ignore echoes that don't match the
+                // pending intent while the pending window is open.
+                if (this.pendingEngaged && Date.now() < this.pendingEngaged.until) {
+                    if (eng === this.pendingEngaged.value) {
+                        this.pendingEngaged = null;
+                    }
+                    break;
+                }
                 const st = eng ? "enabled" : "disabled";
                 if (this.data.state !== st || this.data.engaged !== eng) {
                     this.data.state = st;
@@ -95,6 +165,8 @@ class AutopilotProvider {
         if (this.data.state !== "off-line" || this.data.engaged) {
             this.data.state = "off-line";
             this.data.engaged = false;
+            this.pendingEngaged = null;
+            this.pendingTarget = null;
             this.recomputeActions();
         }
     }
@@ -103,8 +175,25 @@ class AutopilotProvider {
         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;
+        // Rev70: optimistic + echo-cancellation on ap.enabled. Same rationale
+        // as setTarget: SK subscribers see the ordered engaged state in the
+        // same tick as the write, and receiveValue() ignores stale pypilot
+        // echoes while pending.
+        const eng = st.engaged;
+        const apSt = eng ? "enabled" : "disabled";
+        this.data.state = apSt;
+        this.data.engaged = eng;
+        this.pendingEngaged = { value: eng, until: Date.now() + TARGET_PENDING_MS };
+        this.recomputeActions();
+        this.client.set("ap.enabled", eng);
+        // Rev84: publish ONLY the engaged/state/actions delta - do NOT
+        // include target. If setTarget was called in parallel, its own
+        // notifyChanged("target") will publish the new target value
+        // independently. Publishing target here would carry the STALE
+        // apProvider.data.target and clobber JS state.target if this
+        // delta happens to land second.
+        this.notifyChanged("engaged");
+        return eng;
     }
     async setMode(mode) {
         if (this.data.options.modes.length > 0 &&
@@ -115,13 +204,25 @@ class AutopilotProvider {
     }
     async setTarget(rad) {
         const deg = rad * RAD_TO_DEG;
+        // Rev68: optimistic + echo-cancellation. Assign our authoritative value
+        // immediately so downstream SK deltas (and every subscribed UI) snap to
+        // the ordered target in the same tick as the write; mark a pending
+        // window during which receiveValue() filters stale pypilot echoes.
+        this.data.target = rad;
+        this.pendingTarget = { value: rad, until: Date.now() + TARGET_PENDING_MS };
         this.client.set("ap.heading_command", deg);
+        // Rev84: publish ONLY the target delta - see setState notes.
+        this.notifyChanged("target");
     }
     async adjustTarget(rad) {
         if (this.data.engaged) {
             const base = typeof this.data.target === "number" ? this.data.target : 0;
             const newRad = base + rad;
+            this.data.target = newRad;
+            this.pendingTarget = { value: newRad, until: Date.now() + TARGET_PENDING_MS };
             this.client.set("ap.heading_command", newRad * RAD_TO_DEG);
+            // Rev84: publish ONLY the target delta.
+            this.notifyChanged("target");
         }
         else if (this.allowDodge) {
             await this.dodge(rad);

package/dist/index.js

@@ -6,7 +6,7 @@ const scanner_1 = require("./scanner");
 const autopilot_provider_1 = require("./autopilot-provider");
 // Rev counter bumped on every build so the user can distinguish deploys
 // from the webapp header (feedback_revision_bump_each_build).
-const PLUGIN_REVISION = "Rev67";
+const PLUGIN_REVISION = "Rev87";
 // Rev59: read package.json once at load time so /status can report the
 // npm package version alongside the internal Rev counter.
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -216,6 +216,14 @@ module.exports = function (app) {
                 try {
                     apProvider = new autopilot_provider_1.AutopilotProvider(client, app, {
                         allowDodge: !!props.allowDirectServo,
+                        // Rev68: setTarget/adjustTarget assign optimistically and need
+                        // to push a canonical steering.autopilot.target delta right
+                        // then so JS + KIP + WilhelmSK snap without waiting for the
+                        // pypilot echo round-trip.
+                        // Rev84: forward the field mask ("engaged" / "target" /
+                        // "all") so pushAutopilotUpdate filters the emitted delta
+                        // paths accordingly.
+                        onDataChanged: (fields) => pushAutopilotUpdate(fields),
                     });
                     app.registerAutopilotProvider(apProvider.toProviderInterface(), apProvider.pilotIds);
                     // Watches for ap.enabled/mode/heading_command/modes are registered
@@ -880,36 +888,54 @@ module.exports = function (app) {
             sshPassword: typeof options.sshPassword === "string" ? options.sshPassword : "",
         };
     }
-    function pushAutopilotUpdate() {
+    function pushAutopilotUpdate(fields = "all") {
         if (!apProvider)
             return;
         try {
-            // Push structured update through the Autopilot API (WilhelmSK etc.)
+            // Push structured update through the Autopilot API (WilhelmSK etc.).
+            // The App API accepts partial updates - only include changed fields
+            // so a target-only or engaged-only notify does not overwrite the
+            // sibling field's provider-visible value with a stale copy.
             if (typeof app.autopilotUpdate === "function") {
-                app.autopilotUpdate(apProvider.deviceId, {
-                    state: apProvider.data.state,
-                    mode: apProvider.data.mode,
-                    target: apProvider.data.target,
-                    engaged: apProvider.data.engaged,
-                    actions: apProvider.data.options.actions,
-                });
+                const apUpdate = {};
+                if (fields === "all" || fields === "engaged") {
+                    apUpdate.state = apProvider.data.state;
+                    apUpdate.engaged = apProvider.data.engaged;
+                    apUpdate.actions = apProvider.data.options.actions;
+                }
+                if (fields === "all" || fields === "target") {
+                    apUpdate.target = apProvider.data.target;
+                }
+                if (fields === "all") {
+                    apUpdate.mode = apProvider.data.mode;
+                }
+                app.autopilotUpdate(apProvider.deviceId, apUpdate);
             }
         }
         catch (e) {
             app.debug(`[absorb] autopilotUpdate failed: ${e?.message || e}`);
         }
-        // ALSO emit canonical steering.autopilot.* deltas so anything subscribed
-        // to the WebSocket stream (including our own webapp) sees the change.
-        // autopilotUpdate() alone only feeds the REST endpoint - deltas would not
-        // arrive to stream subscribers otherwise.
-        const values = [
-            { path: "steering.autopilot.state", value: apProvider.data.state },
-            { path: "steering.autopilot.mode", value: apProvider.data.mode },
-            { path: "steering.autopilot.target", value: apProvider.data.target },
-            { path: "steering.autopilot.engaged", value: apProvider.data.engaged },
-            { path: "steering.autopilot.availableActions",
-                value: apProvider.data.options.actions.filter((a) => a.available).map((a) => a.id) },
-        ];
+        // Rev84: canonical SK deltas now filtered by the same field mask.
+        // setTarget publishes ONLY steering.autopilot.target, setState
+        // publishes ONLY state/engaged/availableActions. This kills the
+        // race where a parallel /engage + /target pair produced two deltas
+        // each carrying both fields; whichever landed second would clobber
+        // the sibling with a stale copy (the "DIA jumps to 115° then back
+        // to 75°" Carlos reported on Rev82). "all" is still used by the
+        // 30-s keep-alive and startup push.
+        const values = [];
+        if (fields === "all" || fields === "engaged") {
+            values.push({ path: "steering.autopilot.state", value: apProvider.data.state }, { path: "steering.autopilot.engaged", value: apProvider.data.engaged }, { path: "steering.autopilot.availableActions",
+                value: apProvider.data.options.actions.filter((a) => a.available).map((a) => a.id) });
+        }
+        if (fields === "all" || fields === "target") {
+            values.push({ path: "steering.autopilot.target", value: apProvider.data.target });
+        }
+        if (fields === "all") {
+            values.push({ path: "steering.autopilot.mode", value: apProvider.data.mode });
+        }
+        if (values.length === 0)
+            return;
         try {
             app.handleMessage(PLUGIN_ID, {
                 context: "vessels." + app.selfId,
@@ -925,12 +951,15 @@ module.exports = function (app) {
         }
         // Rev34: mirror the active mode into the mode.* radio switch group
         // so KIP's Simple Switch widgets reflect pypilot's current mode.
-        try {
-            const emit = app._pypilotNewuiEmitModeSwitches;
-            if (emit)
-                emit(apProvider.data.mode);
+        // Only when publishing the "all" or a mode-carrying update.
+        if (fields === "all") {
+            try {
+                const emit = app._pypilotNewuiEmitModeSwitches;
+                if (emit)
+                    emit(apProvider.data.mode);
+            }
+            catch { /* silent */ }
         }
-        catch { /* silent */ }
     }
     function setupWatches(c, catalog) {
         // High-rate: engage/mode changes and gains that the user might slide.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-pypilot-newui",
-  "version": "2.0.4",
+  "version": "2.1.0",
   "description": "Signal K friendly UI for the pypilot autopilot, with the capability to spread its functions and buttons to other programs like KIP, WilhelmSK and freeboard. Touch-first mobile visor + full pypilot data (servo, gains, calibration, tack, warnings) as first-class Signal K paths and Simple Switches. Coexists with pypilot-autopilot-provider.",
   "main": "./dist/index.js",
   "scripts": {