signalk-underkeel 0.6.1 → 0.6.2

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to signalk-underkeel are documented here.
 
+## [0.6.2] - 2026-11-13
+
+### Fixed
+
+- Closing the details panel no longer logs an error in the Signal K server log. The panel
+  subscribed to `notifications.navigation.underKeel` itself, and on close Freeboard sent
+  Signal K an unsubscribe for that one path, which Signal K refuses (it takes only an
+  unsubscribe of everything). The background page, which never closes, now holds that
+  subscription and passes the message to the panel.
+
 ## [0.6.1] - 2026-11-13
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-underkeel",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Under-keel clearance awareness for Signal K: look-ahead grounding risk, route checks and a living chart.",
   "main": "lib/index.js",
   "files": [

package/public/panel.js

@@ -145,19 +145,45 @@ async function refreshRoutes() {
   }
 }
 
-if (client.hasCapability("signalk.stream")) {
-  await client.signalk.subscribe(["notifications.navigation.underKeel"], (ev) => {
-    text("message", ev.value && typeof ev.value === "object" ? ev.value.message : "");
-    if (!document.hidden) {
-      void refreshStatus();
+/** Reads overlap as the status ones do: only the latest may update the message. */
+let noticeRequest = 0;
+
+/** The notification's message, which the background page keeps in the extension state. */
+async function refreshNotice() {
+  const id = ++noticeRequest;
+  try {
+    const { ukcNotice } = await client.state.get(["ukcNotice"], "extension");
+    if (id !== noticeRequest) {
+      return;
+    }
+    text("message", ukcNotice && typeof ukcNotice.message === "string" ? ukcNotice.message : "");
+  } catch (err) {
+    if (id !== noticeRequest) {
+      return;
     }
-  });
+    // An old message left on screen could say normal over a warning; the poll reads it again.
+    text("message", "Under-keel message unavailable: the chart host did not answer.");
+    console.warn("under-keel notice", err);
+  }
 }
+
+// No Signal K subscription of its own: the host would unsubscribe it path by path when the
+// panel closes, which Signal K refuses and logs as an error. The background page relays it.
 await client.subscribe(["state.changed"], (_name, params) => {
-  if (params && params.scope === "extension" && params.keys.includes("routeCheck")) {
+  if (!params || params.scope !== "extension") {
+    return;
+  }
+  if (params.keys.includes("routeCheck")) {
     void refreshRoutes();
   }
+  if (params.keys.includes("ukcNotice")) {
+    void refreshNotice();
+    if (!document.hidden) {
+      void refreshStatus();
+    }
+  }
 });
+void refreshNotice();
 // The background runtime answers the button, over an event the host must carry.
 const recheck = document.getElementById("recheck");
 recheck.hidden = !["events.publish", "routes", "background.iframe"].every((c) => client.hasCapability(c));
@@ -176,6 +202,7 @@ function checkStatusAge() {
 function poll() {
   void refreshStatus();
   void refreshRoutes();
+  void refreshNotice();
 }
 
 // A hidden page polls nothing; back on screen an old status reads unknown until the poll answers.

package/public/runtime.js

@@ -427,11 +427,64 @@ if (has("routes")) {
   }, RECHECK_MS);
 }
 
+// ---- the notification, relayed to the details panel ----
+/**
+ * The panel opens and closes, and the chart host unsubscribes a closed page's Signal K paths
+ * one by one, which Signal K refuses: it only takes an unsubscribe of everything, and logs the
+ * rest as errors. So this page, which never closes, holds the notification's subscription and
+ * keeps its message in the extension state, where the panel reads it.
+ */
+const NOTICE = "notifications.navigation.underKeel";
+/** A write that fails is tried again this many times, each wait longer by this much. */
+const NOTICE_RETRIES = 5;
+const NOTICE_RETRY_MS = 2000;
+/** The last notice received and not given up on, as JSON; a newer one replaces a retry of an older one. */
+let latestNotice;
+let noticeRetry;
+
+function relayNotice(value) {
+  const n = value && typeof value === "object" ? value : {};
+  const notice = { message: typeof n.message === "string" ? n.message : "", state: n.state };
+  const key = JSON.stringify(notice);
+  if (key === latestNotice) {
+    return;
+  }
+  latestNotice = key;
+  clearTimeout(noticeRetry);
+  void writeNotice(notice, key, 0);
+}
+
+/**
+ * Writes the notice to the extension state. A notification is sent only when it changes, so
+ * a write that fails is tried again rather than left until the next one.
+ */
+async function writeNotice(notice, key, tries) {
+  try {
+    await client.state.set({ ukcNotice: notice }, "extension");
+  } catch (err) {
+    if (key !== latestNotice) {
+      return;
+    }
+    if (tries < NOTICE_RETRIES) {
+      noticeRetry = setTimeout(() => void writeNotice(notice, key, tries + 1), NOTICE_RETRY_MS * (tries + 1));
+    } else {
+      // Given up: the same notice, sent again on a reconnect, is written rather than dropped.
+      latestNotice = undefined;
+      console.warn("under-keel notice", err);
+    }
+  }
+}
+
 /** Without the Signal K stream, or when subscribing to it fails, the envelope is polled. */
 let streaming = false;
 if (has("signalk.stream")) {
   try {
-    await client.signalk.subscribe(Object.keys(onPath), (ev) => {
+    await client.signalk.subscribe([...Object.keys(onPath), NOTICE], (ev) => {
+      // A notification is sent only when it changes, so its age says nothing about the plugin.
+      if (ev.path === NOTICE) {
+        relayNotice(ev.value);
+        return;
+      }
       const left = fresh(ev.path, ev.timestamp, Date.now());
       if (left > 0) {
         onPath[ev.path](ev.value, left);