signalk-pypilot-newui 2.0.3 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,196 @@
 # 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
+withdrawn in 2.0.3 when 2.0.2 hit regressions. Every item below was
+tested on Carlos's Tunatunes Pi Zero W setup before publish.
+
+### Fixed
+
+- **Restart engine now uses `sv` (runit), not `systemctl`.** piCore does
+  not ship systemd; the previous `sudo systemctl restart pypilot pypilot_web`
+  was silently falling through to `|| true` on every install. Only the
+  `pkill -9` had any effect, and runit's `runsv` was auto-relaunching
+  the killed processes into a slightly inconsistent state that
+  accumulated zombies + I2C contention until the Pi Zero locked up.
+  Fixed to `sudo sv restart /etc/sv/pypilot /etc/sv/pypilot_web /etc/sv/pypilot_hat`
+  with a selective `pkill -9 -f 'python.*pypilot --version'` safety net.
+- **`pypilot --version` preset in Debug console wrapped in `timeout 3`.**
+  On piCore that command starts the full pypilot process and never
+  exits cleanly; each click was leaving a zombie holding I2C and TCP
+  resources. Falls back to reading the packaged version file.
+- **Target diamond drifted after tapping AP on laggy links.** The
+  optimistic-target assign now happens INSTANTLY on click (same tick),
+  not after the parallel promise resolves - so the diamond snaps to
+  the captured heading immediately, without a jump to the stale value
+  then back. Nudge also updates `state.target` optimistically so the
+  diamond moves in the same tick as the button press.
+- **socket.io auto-reconnect no longer gives up.** `reconnectionAttempts`
+  changed from 30 (which could exhaust on a long outage) to Infinity;
+  backoff capped at 30 s. Restarts done via `/debug-cmd` (`restart.web`
+  / `reboot.pi`) now schedule an explicit `pause+resume` after the
+  operation.
+- **Reconnection watchdog** (every 60 s, was 30 s): if the socket has
+  been disconnected > 90 s, force a pause+resume once. Max 3 forced
+  reconnects in a rolling 15-min window so a permanently-dead
+  pypilot_web is not turned into a local DDoS. Watchdog interval
+  loosened per Carlos: "con la Pi Zero debemos ser suuuuuper ratas".
+
+### Changed - Emergency section simplified
+
+The 3-level escalated restart triad shipped in 2.0.2 has been trimmed
+to 2 levels in Setup -> Emergency: **RESTART pypilot** (level 2, ~10-15 s
+outage) + **reboot Pi** (level 3, ~35-60 s). The old level 1
+(`restart pypilot_web`) rarely helps in practice - when the Pi Zero is
+saturated a full reboot is what actually helps - so it moved to the
+Debug console below as an advanced preset for the ~5 % edge cases.
+
+### Compass rose
+
+- HDG in a small dark chip that straddles the top of the ring, narrowed
+  from 48 to 40 units wide so the enlarged target diamond can peek out
+  on all four sides even when target is dead ahead.
+- Target diamond enlarged (28 wide, 30 tall) so its top point asoma
+  above the HDG chip and its bottom point below it.
+- Wind arrows both solid (no dashed shaft on TWA), amber AWA (big head)
+  + sea-green (#5ce8c0) TWA (small head), each with its own rotating
+  text label placed at very different radii so they never overlap even
+  when both arrows point in the same direction.
+- Wind speed at the bottom of the rose now inside a small dark chip
+  (same look as the HDG chip on top). Short-tap on the chip OR on a
+  corner mapped to "wind" flips AWS/TWS. Long-press opens the popup.
+- Corner options `AWA` and `TWA` now show angle AND matching wind speed
+  (AWA/AWS and TWA/TWS) as a combined 2-line cell, consistent with the
+  `wind` combo.
+
+### Rudder angle indicator in the swipe-hint bar
+
+- Default range **±70°** (was ±45°), matching typical TinyPilot configs.
+- Explicit numeric labels at both ends showing the actual range from
+  the pypilot catalog.
+- Intermediate tick marks every 10° plus numeric mid-labels at 20°, 40°
+  and 60° each side, so the operator reads the rudder angle at a glance.
+
+### Internal
+
+- Debug console preset `pypilot.version` now `timeout 3 python3 -c
+  'import pypilot; print(pypilot.__version__)'` with fallback.
+- Merge-based `_pluginConfigMerge()` helper preserved.
+- Per-cell state for the long-press / short-tap handler on the corner
+  dashboard (Rev65's shared timer flags were race-flipping and killing
+  the tap toggle intermittently).
+
 ## 2.0.3 — 2026-08-20 — Rev66 - rollback of 2.0.2
 
 Codebase is functionally identical to 2.0.1. Version 2.0.2 introduced

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);