@meri-imperiumi/signalk-passage-briefing 0.7.1 → 0.8.1

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+## [0.8.1] - 2026-10-08
+
+### Added
+- Branding on the webapp page (per the Signal K visuals spec): the plugin's app icon (`icon-256.png`) serves as favicon and the base canvas color ships as the `theme-color` meta, so browser chrome matches the console background in both day and night modes.
+
+### Fixed
+- The per-minute source-status tick no longer touches the logbook — fixes "Server unreachable: Fetch is aborted" with an empty route picker on production since 0.8.0. The checklist's logbook probe went through the resources API, whose `logentries` provider answers even a `limit: 1` listing by reading and schema-validating every day file — on a multi-year log that meant overlapping full-store scans every 60 s starving the server so `/api/status` and `/api/routes` blew the webapp's 8 s abort timeout. The logbook is a once-used learning resource (backfill), not an ongoing ingest source, so it leaves the data source statuses entirely; with no provider installed, backfill now fails loudly with the reason instead of silently reporting zero events.
+
+## [0.8.0] - 2026-10-06
+
+### Added
+- Conditions tabs on the unified timeline (work doc #18): each entry carries a small colored tab on its left edge — the comfort tier color the tactical sparkline paints at that hour, so the passage's weather development reads at a glance. The tier comes from the simulated track's nearest hourly step; sail changes keep their own enriched conditions block as the authoritative tier, slatting renders as the sparkline's hatch stripes, and entries outside track coverage degrade to the unknown gray instead of inventing a tier.
+- Provenance on every estimation and warning (work doc #31): a compact ↗ affordance where an external origin or on-board viewer exists, deep-linked to the specific record rather than a site front page — GDACS events link their gdacs.org event page (hazard notes on the timeline carry the same page through from the note), CAP alerts the sender's info page (feed URL as fallback), bulletin console blocks the feed rung the text arrived from, zone transitions the exact Marine Regions gazetteer record keyed by the boundary zone's MRGID (search-by-territory fallback when a source carries no MRGID; the here view's waters-you-are-in zone names link their records too), satellite passes a live tracker page keyed by the NORAD catalog number parsed from TLE line 1, and weather the on-board viewer deep link (`signalk-weather-map` webapp with `lat/lon/time/layer`, detected via the server's registered webapps — absent siblings serve no dead links) plus the external Open-Meteo forecast page rewritten to the item's own position: a simulated item links the patch of ocean the boat plans to be at, not the departure. Computed-on-board items carry no glyph: absence never implies external authority. Sky-event and official-alert rows on the conditions-here view get the same treatment.
+- Night-darkness cloud cover (work doc #32): Open-Meteo `cloud_cover` rides the simulated track (interpolated in `weatherAt`, hourly rows and the compact `passageSummary.track`; unknown on either side of a span stays null, never blended or invented) and is stamped on every timeline item at its hour. Night entries render a ☁ beside the moon glyph, opacity scaling with cover (every night entry with a known cover carries the mark — clear nights show it faint, so an absent mark unambiguously means the source publishes none); night ETA rows in the strategic outlook get the same mark; provider mode stays honest with the moon glyph alone.
+- Sky times on tactical and here (work doc #33): `celestialNights` entries gain `sunrise`/`sunset`/`moonrise`/`moonset` from `astronomy-engine` rise/set searches (null-degrading across polar day/night), and both views render a compact monospace sky line — sunset, nautical dusk (the briefing's night boundary), the moon's rise/set within the night window, and the now cloud cover from the first forecast step — so watch planning reads off one line instead of guesswork around dusk. Also fixed the conditions-here CAP empty state early-returning before the waters-you-are-in card could render.
+
+### Changed
+- The briefing refresh button reads "Update now" instead of "Fetch now" (matching loading strips "Updating briefing…" / "Updating conditions…"): from the crew's side the action regenerates the briefing with fresh weather — the fetching is the plugin's business, not the button's.
+
+### Fixed
+- The critical-hazard banner rendered always — an empty red strip with an ACK button above the webapp header even with no active alerts: the banner stylesheet's `display: flex` beats the browser's built-in `[hidden] { display: none }` regardless of specificity, so the `hidden` attribute did nothing (the `.tab-bar` already carried the `[hidden]` antidote; the banner and the embed-mode header now do too). With the bar permanently visible but empty, ACK had nothing to acknowledge. Also fixed red-on-red text: the banner painted message and background with the same `--color-red`, so a real emergency's message would have been invisible — text now uses the base canvas color per the codebase's text-on-color pattern.
+- CAP alerts whose `<instruction>` carries a bare placeholder — PTWC ships a literal "N/A" on its tsunami information statements — rendered "N/A" as the crew's action line; the parser now treats the placeholder as no instruction, and the Official Alerts card renders no action row for them.
+
+### Changed
+
+- Logbook reading moved from signalk-logbook's on-disk YAML store to the Signal K v2 Resources API: the plugin now consumes the `logentries` resource type (the contract signalk-logbook documents in `docs/logentries-resource.md` and serves as its reference provider) through `app.resourcesApi` — in-process, no tokens, no filesystem coupling to another plugin's storage layout. The reader normalizes the resource representation at one boundary (`navigation.position` pathvalue for position, `environment.wind.speedOverGround` m/s → kn and `environment.wind.directionTrue` rad → deg for the wind snapshots); the sail-text parsing and event classification are unchanged. The source-status checklist row probes the resource type instead of the store directory. `bin/backfill-report.js` reads over the REST surface (`--url`/`--token`, a `readonly` token suffices) instead of a local YAML copy — usable ashore against any reachable server. The `yaml` dependency is dropped.
+
 ## [0.7.1] - 2026-10-05
 
 ### Fixed

package/README.md

@@ -28,7 +28,7 @@ Part of the Lille Ø offshore suite, alongside [@meri-imperiumi/signalk-energy-p
 - Resources API — route geometries and polar tables
 - History API (on board) — wind/attempt snapshots for the sail-event backfill
 - Published tile paths — `navigation.briefing.generatedAt` / `.route` / `.hasNew` / `.comfort` drive the plotter-extension tile (`.acknowledgedAt` is writable to clear the NEW badge)
-- [signalk-logbook](https://github.com/meri-imperiumi/signalk-logbook) store — crewed sail events (reefs, sail changes) that train the preference matrix
+- `logentries` resource API (for example [signalk-logbook](https://github.com/meri-imperiumi/signalk-logbook)) — crewed sail events (reefs, sail changes) that train the preference matrix; any provider implementing the resource contract works
 - [signalk-ships-time](https://github.com/meri-imperiumi/signalk-ships-time) — `environment.time.timezoneOffset` / `.timezoneRegion`, the vessel's published timezone: briefing stamps render in ship's time when available (the offset rides on every stamp), falling back to UTC `Z` when nothing is published
 - [signalk-watch-schedule](https://github.com/hoeken/signalk-watch-schedule) — `watch.state.onWatch`, `watch.state.startedAt`, `watch.system` and `watch.schedule`: the running watch rotation. While a watch is running, planned sail changes anchor to the previous watch handover (both teams awake) instead of sunrise/sunset; boundaries are extrapolated across the forecast horizon from the rotation cycle
 - [@signalk/sailsconfiguration](https://www.npmjs.com/package/@signalk/sailsconfiguration) — sail inventory used to filter free-text noise out of log entries

package/bin/backfill-report.js

@@ -2,10 +2,10 @@
 /**
  * Logbook backfill & sail usage report.
  *
- * Runs the SPEC §4.2 sail preference backfill over a
- * `signalk-logbook` store using the wind snapshots written in the log
- * entries (no History API needed — usable ashore against a copy of
- * the log repository), then reports:
+ * Runs the SPEC §4.2 sail preference backfill over the logbook
+ * entries served by a Signal K server's `logentries` resource (the
+ * signalk-logbook contract), using the wind snapshots written in the
+ * log entries (no History API needed), then reports:
  *
  * 1. the learned sail preference matrix (SPEC §3.2);
  * 2. the conditions actually experienced per sail combination, next
@@ -15,11 +15,13 @@
  *
  * Usage:
  *
- *   node bin/backfill-report.js [--dir <logbook-dir>] [--sails <json>]
- *        [--from <iso>] [--to <iso>] [--db <sqlite-file>] [--json]
+ *   node bin/backfill-report.js [--url <server>] [--token <jwt>]
+ *        [--sails <json>] [--from <iso>] [--to <iso>] [--db <sqlite-file>]
+ *        [--json]
  *
- * Defaults: `--dir ~/.signalk/plugin-config-data/signalk-logbook`,
- * `--sails ~/.signalk/plugin-config-data/sailsconfiguration.json`.
+ * Defaults: `--url http://localhost:3000` (a `readonly` token is
+ * enough for reads), `--sails
+ * ~/.signalk/plugin-config-data/sailsconfiguration.json`.
  *
  * Once on board, re-run the backfill through the plugin's
  * `POST /api/backfill?source=history&baseUrl=<server>` route to learn
@@ -34,7 +36,7 @@ const { join } = require("node:path");
 
 const { PassageDatabase } = require("../plugin/sqlite-db.js");
 const {
-  readLogbookEntries,
+  readLogbookEntriesRest,
   readLogbookSailEvents,
 } = require("../plugin/logbook-source.js");
 const {
@@ -49,6 +51,11 @@ const {
 
 const SIGNALK_DIR = join(homedir(), ".signalk", "plugin-config-data");
 
+/**
+ * Server to read the logbook from when `--url` is not given.
+ */
+const DEFAULT_SERVER_URL = "http://localhost:3000";
+
 /**
  * Parses argv into a `{flag: value}` map (`--flag value`, boolean
  * flags without value become true).
@@ -77,10 +84,9 @@ function parseArgs(argv) {
 
 function main() {
   const args = parseArgs(process.argv.slice(2));
-  const logbookDir =
-    typeof args.dir === "string"
-      ? args.dir
-      : join(SIGNALK_DIR, "signalk-logbook");
+  const serverUrl =
+    typeof args.url === "string" ? args.url : DEFAULT_SERVER_URL;
+  const token = typeof args.token === "string" ? args.token : undefined;
   const sailsFile =
     typeof args.sails === "string"
       ? args.sails
@@ -94,54 +100,75 @@ function main() {
   );
   const db = new PassageDatabase(dataDir);
 
-  return Promise.all([
-    readLogbookEntries(logbookDir),
-    readSailsConfiguration(sailsFile),
-  ])
-    .then(async ([entries, sails]) => {
-      const knownSailKeys =
-        sails.length > 0
-          ? new Set(sails.map((sail) => sail.nameKey))
-          : undefined;
-      const events = await readLogbookSailEvents({
-        dir: logbookDir,
+  (async () => {
+    try {
+      const report = await collectReport({
+        serverUrl,
+        token,
+        sailsFile,
         from,
         to,
-        knownSailKeys,
-      });
-      const summary = await backfillSailEvents({
         db,
-        events,
-        getWindStats: createLogbookWindStats(entries),
       });
-      const matrix = db.getSailPreferenceMatrix();
-      const usage = summarizeSailUsage(
-        db.getSailEvents({ limit: 10000 }),
-        db.getWindHistory("0000-01-01T00:00:00Z", "9999-12-31T23:59:59Z"),
-      );
-      return {
-        logbook: logbookDir,
-        entries: entries.length,
-        events: events.length,
-        summary,
-        matrix,
-        usage,
-        sails,
-      };
-    })
-    .then((report) => {
-      db.close();
       if (asJson) {
         console.log(JSON.stringify(report, null, 2));
         return;
       }
       printReport(report);
-    })
-    .catch((error) => {
-      db.close();
+    } catch (error) {
       console.error(`backfill-report: ${error.message}`);
       process.exitCode = 1;
-    });
+    } finally {
+      db.close();
+    }
+  })();
+}
+
+/**
+ * Reads the logbook over the resources API and runs the backfill.
+ *
+ * @param {object} options
+ * @param {string} options.serverUrl - Signal K server base URL
+ * @param {string|undefined} options.token - Bearer token for reads
+ * @param {string} options.sailsFile - Sails configuration JSON path
+ * @param {string|undefined} options.from - Event window start
+ * @param {string|undefined} options.to - Event window end
+ * @param {object} options.db - Passage database
+ * @returns {Promise<object>} Report for printReport/JSON output
+ */
+async function collectReport({ serverUrl, token, sailsFile, from, to, db }) {
+  const entries = await readLogbookEntriesRest({
+    baseUrl: serverUrl,
+    token,
+  });
+  const sails = await readSailsConfiguration(sailsFile);
+  const knownSailKeys =
+    sails.length > 0 ? new Set(sails.map((sail) => sail.nameKey)) : undefined;
+  const events = await readLogbookSailEvents({
+    entries,
+    from,
+    to,
+    knownSailKeys,
+  });
+  const summary = await backfillSailEvents({
+    db,
+    events,
+    getWindStats: createLogbookWindStats(entries),
+  });
+  const matrix = db.getSailPreferenceMatrix();
+  const usage = summarizeSailUsage(
+    db.getSailEvents({ limit: 10000 }),
+    db.getWindHistory("0000-01-01T00:00:00Z", "9999-12-31T23:59:59Z"),
+  );
+  return {
+    logbook: serverUrl,
+    entries: entries.length,
+    events: events.length,
+    summary,
+    matrix,
+    usage,
+    sails,
+  };
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meri-imperiumi/signalk-passage-briefing",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "description": "Offshore passage daily briefing webapp for Signal K",
   "main": "plugin/index.js",
   "scripts": {
@@ -46,8 +46,7 @@
   "dependencies": {
     "@openwaters/maritime-zones": "^0.2.1",
     "astronomy-engine": "^2.1.19",
-    "satellite.js": "^7.1.0",
-    "yaml": "^2.9.0"
+    "satellite.js": "^7.1.0"
   },
   "devDependencies": {
     "@signalk/server-api": "^2.30.0"

package/plugin/cap-source.js

@@ -27,6 +27,13 @@ const { tagValue, unescapeXml } = require("./hazard-source.js");
 /** Severity ranking for CAP's own vocabulary. */
 const SEVERITY_RANK = { extreme: 3, severe: 2, moderate: 1, minor: 0 };
 
+/**
+ * Instruction placeholders some senders ship (PTWC's CAP documents
+ * carry a literal "N/A"): rendered as the crew's action, so a bare
+ * placeholder is no instruction at all.
+ */
+const INSTRUCTION_PLACEHOLDER = /^n\/?a\.?$/i;
+
 /** Default feed: the NWS Pacific tsunami warning center. */
 const CAP_DEFAULT_URL = "https://www.tsunami.gov/events/xml/PHEBCAP.xml";
 
@@ -218,6 +225,7 @@ function parseCapAlert(xml, { sourceUrl = null, raw = null } = {}) {
   const info = pickInfoBlock(xml) ?? "";
   const expires = capText(info, "expires") || null;
   const geometry = infoGeometry(info);
+  const instruction = capText(info, "instruction") || null;
   return {
     id: `${identifier}|${sent ?? ""}`,
     identifier,
@@ -232,7 +240,10 @@ function parseCapAlert(xml, { sourceUrl = null, raw = null } = {}) {
     expires,
     headline: capText(info, "headline") || null,
     description: capText(info, "description") || null,
-    instruction: capText(info, "instruction") || null,
+    instruction:
+      instruction && !INSTRUCTION_PLACEHOLDER.test(instruction)
+        ? instruction
+        : null,
     web: capText(info, "web") || null,
     areaDesc: capText(info, "areaDesc") || null,
     geometry,

package/plugin/celestial-ephemeris.js

@@ -238,10 +238,19 @@ function twilightTimes(date, lat, lon) {
 
 /**
  * Daily night context for the briefing payload (`celestialNights`):
- * one entry per day with the twilight times of that night and the
- * moon phase/illumination at nightfall. The timeline's night glyph
- * and any future "when is it really dark" display read this instead
- * of re-deriving astronomy in the browser.
+ * one entry per day with the twilight times of that night, the moon
+ * phase/illumination at nightfall, and the sun/moon rise and set
+ * stamps bracketing the night (work doc #33 — the sky line reads
+ * these instead of re-deriving astronomy in the browser). The
+ * timeline's night glyph and any future "when is it really dark"
+ * display read this instead of re-deriving astronomy in the browser.
+ *
+ * Rise/set search semantics: sunset is the setting crossing before
+ * the night's civil dusk, sunrise the rising crossing after the dusk
+ * anchor; moonrise/moonset are the moon's next crossings after dusk
+ * (a moon already up at dusk reports tomorrow's rise — the set stamp
+ * is tonight's). Polar day/night and missing crossings degrade to
+ * null like the twilight bounds.
  *
  * @param {object} params
  * @param {Date} params.from - Window start
@@ -252,21 +261,61 @@ function twilightTimes(date, lat, lon) {
  *   moonIllumination: number, civilDusk: string|null,
  *   nauticalDusk: string|null, astronomicalDusk: string|null,
  *   astronomicalDawn: string|null, nauticalDawn: string|null,
- *   civilDawn: string|null}>}
+ *   civilDawn: string|null, sunrise: string|null, sunset: string|null,
+ *   moonrise: string|null, moonset: string|null}>}
  */
 function celestialNights({ from, days = 8, lat, lon }) {
   const nights = [];
+  const observer = observerAt(lat, lon);
+  // First rise/set crossing of a body after `start`; missing
+  // crossings (polar day/night, no crossing within the window)
+  // degrade to null
+  const riseSet = (body, direction, start) => {
+    try {
+      const found = A.SearchRiseSet(
+        body,
+        observer,
+        direction,
+        A.MakeTime(start),
+        1.5,
+      );
+      return found ? found.date.toISOString() : null;
+    } catch (_error) {
+      return null;
+    }
+  };
   for (let d = 0; d < days; d++) {
     const base = new Date(from.getTime() + d * 86400000);
     const twilights = twilightTimes(base, lat, lon);
     const anchor = twilights.nauticalDusk
       ? new Date(twilights.nauticalDusk)
       : base;
+    // Sunset: the setting crossing before this night's civil dusk —
+    // search from a day back so the search's forward window covers it
+    const civilDuskMs = twilights.civilDusk
+      ? new Date(twilights.civilDusk).getTime()
+      : null;
+    const sunset = civilDuskMs
+      ? riseSet(A.Body.Sun, -1, new Date(civilDuskMs - 18 * 3600000))
+      : null;
+    // Dawn side: the next rising after the dusk anchor (the same
+    // night's sunrise); the +2 min skips the numerical tangency at
+    // the crossing itself, as the dawn chain does
+    const afterDusk = new Date(anchor.getTime() + 120000);
+    const sunrise = riseSet(A.Body.Sun, 1, afterDusk);
+    // Moon brackets (work docs #32/#33): the next set and rise after
+    // dusk — a moon already up at dusk reports tomorrow's rise
+    const moonset = riseSet(A.Body.Moon, -1, afterDusk);
+    const moonrise = riseSet(A.Body.Moon, 1, afterDusk);
     nights.push({
       timestamp: anchor.toISOString(),
       moonPhaseDeg: Math.round(moonPhaseDeg(anchor) * 10) / 10,
       moonIllumination: Math.round(moonIllumination(anchor) * 1000) / 1000,
       ...twilights,
+      sunset,
+      sunrise,
+      moonrise,
+      moonset,
     });
   }
   return nights;

package/plugin/fetch-engine.js

@@ -564,11 +564,21 @@ async function fetchWeatherAlongTrack({
   if (currentsResponse != null) {
     models.push("marine:smoc_currents");
   }
+  const fetchedAt = new Date().toISOString();
   return {
     metadata: {
-      fetchedAt: new Date().toISOString(),
+      fetchedAt,
       source: "api",
       models,
+      // Where this forecast came from (work doc #31): the canonical
+      // per-position Open-Meteo forecast page for the first waypoint
+      provenance: {
+        kind: "forecast",
+        label: `Open-Meteo · ${models.join(", ")}`,
+        url: `https://open-meteo.com/en/docs?latitude=${waypoints[0].lat}&longitude=${waypoints[0].lon}`,
+        viewerBase: null,
+        at: fetchedAt,
+      },
     },
     waypoints: payloadWaypoints,
   };

package/plugin/index.js

@@ -20,13 +20,7 @@
 
 const { join } = require("node:path");
 const { homedir } = require("node:os");
-const {
-  mkdir,
-  readdir,
-  readFile,
-  unlink,
-  writeFile,
-} = require("node:fs/promises");
+const { mkdir, readFile, unlink, writeFile } = require("node:fs/promises");
 
 const { PassageStateMachine } = require("./state-machine.js");
 const { PassageDatabase } = require("./sqlite-db.js");
@@ -533,11 +527,19 @@ module.exports = (app) => {
   /** Filtered blocks for one cache entry against a track: structured
    * UKHO JSON entries skip the text pipeline entirely. */
   function blocksForEntry(entry, track) {
+    // Provenance (work doc #31): the feed URL the text arrived from,
+    // stamped on every surviving block — the spool path has a file
+    // path, not a URL, and carries no provenance
+    const sourceUrl = /^https?:\/\//.test(entry.url ?? "") ? entry.url : null;
+    const withProvenance = (blocks) =>
+      sourceUrl ? blocks.map((block) => ({ ...block, sourceUrl })) : blocks;
     if (entry.format === "ukho-json") {
       try {
-        return ukhoBlocksFromWarnings(
-          parseUkhoWarnings(JSON.parse(entry.text)),
-          track,
+        return withProvenance(
+          ukhoBlocksFromWarnings(
+            parseUkhoWarnings(JSON.parse(entry.text)),
+            track,
+          ),
         );
       } catch {
         return []; // Corrupted entry: skip, other entries still serve
@@ -549,7 +551,7 @@ module.exports = (app) => {
       track,
       issuedAt: entry.fetchedAt,
     });
-    return bulletin?.blocks ?? [];
+    return withProvenance(bulletin?.blocks ?? []);
   }
 
   /** Bulletin-level metadata (header/issuedAt/source/raw text) for
@@ -830,6 +832,42 @@ module.exports = (app) => {
    *   samples (route mode) or the position waypoint (here mode)
    * @returns {Promise<void>}
    */
+  /**
+   * On-board viewer base for weather provenance (work doc #31): the
+   * weather-map sibling webapp renders the same fields the briefing
+   * derives from, reachable over the LAN underway. The server knows
+   * its registered webapps; a link to an absent sibling is dropped
+   * rather than served dead. Deep-link parameters (lat/lon/time/
+   * layer) are appended per item by the webapp.
+   *
+   * @returns {string|null} Viewer base path when installed
+   */
+  function weatherViewerBase() {
+    const webapps = app.webapps;
+    if (!Array.isArray(webapps)) {
+      return null;
+    }
+    return webapps.some((webapp) => webapp?.name === "signalk-weather-map")
+      ? "/signalk-weather-map/"
+      : null;
+  }
+
+  /**
+   * Stamps the on-board viewer link onto a payload's weather
+   * provenance record (work doc #31). Payloads whose cache predates
+   * the provenance field keep no record — the UI degrades to no
+   * glyph, never a dead link.
+   *
+   * @param {object} payload - Briefing payload, mutated in place
+   * @returns {void}
+   */
+  function attachWeatherViewer(payload) {
+    const base = weatherViewerBase();
+    if (base && payload?.metadata?.provenance) {
+      payload.metadata.provenance.viewerBase = base;
+    }
+  }
+
   async function attachHazardEvents(payload, vessel, waypoints) {
     if (!hazardEventsEnabled) {
       return;
@@ -854,7 +892,22 @@ module.exports = (app) => {
       ...hazardFilterConfig,
       now: new Date(),
     });
-    payload.hazardEvents = events;
+    // Provenance (work doc #31): the GDACS event page rides each
+    // surviving event — one tap from timeline row to origin
+    payload.hazardEvents = events.map((event) =>
+      event.link
+        ? {
+            ...event,
+            provenance: {
+              kind: "warning",
+              label: "GDACS",
+              url: event.link,
+              viewerUrl: null,
+              at: event.timestamp ?? null,
+            },
+          }
+        : event,
+    );
     if (notesStore) {
       const result = await publishHazardNotes({ store: notesStore, events });
       if (result.published.length > 0 || result.pruned.length > 0) {
@@ -954,12 +1007,33 @@ module.exports = (app) => {
     }
     const events =
       result?.events ?? (await capSource.loadCapAlerts(app.getDataDirPath()));
-    payload.capAlerts = capSource.filterCapAlerts({
-      events,
-      track: waypoints.map((w) => [w.lon, w.lat]),
-      minSeverity: capMinSeverity,
-      now: new Date(),
-    });
+    // Provenance (work doc #31): the sender's info page when
+    // published, else the feed the document arrived from. Stamped on
+    // the FILTERED survivors — stamping the raw cache instead would
+    // bypass the severity, expiry and geography gates (a Puerto Rico
+    // information statement reached a Tonga vessel that way once).
+    payload.capAlerts = capSource
+      .filterCapAlerts({
+        events,
+        track: waypoints.map((w) => [w.lon, w.lat]),
+        minSeverity: capMinSeverity,
+        now: new Date(),
+      })
+      .map((alert) => {
+        const url = alert.web ?? alert.sourceUrl ?? null;
+        return url
+          ? {
+              ...alert,
+              provenance: {
+                kind: "warning",
+                label: alert.web ? "Official alert page" : "CAP feed",
+                url,
+                viewerUrl: null,
+                at: alert.sent ?? null,
+              },
+            }
+          : alert;
+      });
     if (notesStore) {
       const result = await publishCapAlertNotes({
         store: notesStore,
@@ -1045,6 +1119,7 @@ module.exports = (app) => {
       }),
     );
     payload.metadata.mode = "here";
+    attachWeatherViewer(payload);
     const bulletin = await bulletinForTrack(waypoints);
     if (bulletin) {
       payload.metareaBulletin = bulletin;
@@ -1208,6 +1283,7 @@ module.exports = (app) => {
     const payload = await withSourceStatus(WEATHER_SOURCE, () =>
       trackWeatherFetcher({ waypoints, forecastDays }),
     );
+    attachWeatherViewer(payload);
     const bulletin = await bulletinForTrack(waypoints);
     if (bulletin) {
       payload.metareaBulletin = bulletin;
@@ -1782,18 +1858,6 @@ module.exports = (app) => {
     }
   }
 
-  /**
-   * Location of the signalk-logbook on-disk store. When the Signal K
-   * Resource API grows logbook support, this (and the logbook-source
-   * module behind it) is the swap point.
-   *
-   * @returns {string}
-   */
-  function logbookStoreDir() {
-    const configPath = app.config?.configPath ?? app.dataDir;
-    return join(configPath, "plugin-config-data", "signalk-logbook");
-  }
-
   /** Startup grace (ms) before the delta-fed path sources are
    * recorded in the status registry (work doc #23, bergie session
    * note): the server replays current values to new subscriptions a
@@ -1932,21 +1996,6 @@ module.exports = (app) => {
         now,
       });
     }
-    let logbookReadable = false;
-    try {
-      await readdir(logbookStoreDir());
-      logbookReadable = true;
-    } catch (_error) {
-      logbookReadable = false;
-    }
-    sourceStatus.record({
-      id: "sk-logbook",
-      label: "Logbook (signalk-logbook)",
-      kind: "signalk",
-      url: logbookStoreDir(),
-      ...(logbookReadable ? {} : { absent: true }),
-      now,
-    });
   }
 
   /**
@@ -2440,7 +2489,7 @@ module.exports = (app) => {
       router.get("/api/logbook-events", async (req, res) => {
         try {
           const events = await readLogbookSailEvents({
-            dir: logbookStoreDir(),
+            app,
             from:
               typeof req.query.from === "string" ? req.query.from : undefined,
             to: typeof req.query.to === "string" ? req.query.to : undefined,
@@ -2700,7 +2749,7 @@ module.exports = (app) => {
           const to =
             typeof req.query.to === "string" ? req.query.to : undefined;
           const events = await readLogbookSailEvents({
-            dir: logbookStoreDir(),
+            app,
             from,
             to,
             knownSailKeys: await knownSailKeys(),
@@ -2709,9 +2758,7 @@ module.exports = (app) => {
             req.query.source === "history" &&
             typeof req.query.baseUrl === "string"
               ? createHistoryWindStats({ baseUrl: req.query.baseUrl })
-              : createLogbookWindStats(
-                  await readLogbookEntries(logbookStoreDir()),
-                );
+              : createLogbookWindStats(await readLogbookEntries(app));
           const summary = await backfillSailEvents({
             db,
             events,