@meri-imperiumi/signalk-passage-briefing 0.13.2 → 0.14.0

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [0.14.0] - 2026-10-19
+
+### Changed
+- The departure mode pulldown (Auto / Now / First light / In 1 hour / In 2 hours / Custom) is gone from the departure chip: the daylight anchor (work doc #15) decides the timing, the route switcher's departure-day variants (work doc #34) are the crew's explicit choices, and the chip stays as the honest statement of the effective departure — "First light 05:48" or "Underway — from now". The manual presets had become a second, weaker copy of the variant browsing; `effectiveDeparture`'s mode machinery left with them (`departureCandidates` is the one departure-decision path now).
+- The polar consumption is rewritten on the vendored polar-math engine (work doc #25): monotone PCHIP interpolation over the *observed* cells only — a learned table's 0.0 cells mean "never sailed there", not zero speed, and no longer drag whole angle bands toward zero (the crew's own table read ~0.4 kn at 45°/6 kn under bilinear); below the modeled pinch boundary the lookup returns "in irons" instead of a fabricated speed; the dead-run band is modeled on VMG instead of wobbling between isolated cells. With it, the propulsion decision becomes speed-based: sail what the polar allows, and motor only when the achieved speed — on course, or VMG while beating — drops below the new `motoring_speed_threshold` (2 kn); `motoring_tws_threshold` now only gates the becalmed drift. In irons the plan beats the best angle the crew's own data supports: progress at VMG, comfort and rig read at the beat angle (the boat makes its own apparent wind, so beating works into light air — the fill floor checks AWS), and the timeline carries a "Beating — N h tacking · VMG" episode (⇄) per continuous stretch. Whole-passage plans shift with the more honest speeds, deliberately.
+- The conditions-here map centers on the vessel's live `navigation.position` instead of the briefing payload's fetch-time waypoint (work doc #34 session): seeded with the briefing's own fix at render, refined by the stream's live one, and refitting only when the boat materially moves — a fix at anchor never yanks the view. The map also draws the vessel marker on every surface now — a static teal "you are here" dot at the boat on the here, tactical and strategic maps, riding along the route.
+
+### Added
+- Arrival as a timeline event: the passage's payoff moment was only numbers on the ETA card while the timeline ran from departure to — nothing. The simulated track's final row is the nominal arrival, so the milestone lands on the same schedule the rest of the timeline reads: 🏁 row at the destination, night context and map pin included, distance from departure in the detail. It only appears when the plan actually reached the destination inside the forecast horizon — a horizon-cap end is no arrival, and the ETA card's percentiles already say why.
+- Departure-day variants in the route switcher (work doc #34, before-departure half): while the boat is stationary, the active route's entry gains "«route», +24 h", "+48 h" and — with the default `departure_days` of 4 — "+72 h" options, each the daylight-anchored departure of its candidate day, the same work doc #15 rules (dawn anchor, prep delay) applied one day later, not a raw clock offset. Selecting one re-anchors the whole briefing to that day: departure chip, timeline, ETA percentiles and the simulated track all recompute from the same cached weather array — a comparison costs worker CPU, not fetches. Candidates departing beyond the payload's forecast horizon stay listed but disabled ("beyond forecast") rather than simulating on clamped weather; underway the variants collapse to the single now-departure, and touching the departure control overrides the browsed variant until it is re-picked. Two knobs back it: `departure_days` (candidate count, 1–7) and `forecast_days` (the route-briefing fetch horizon, default 7, up to 16) — a late variant is only simulable when the horizon reaches past its arrival, and every extra fetched day costs a fetch per waypoint per refresh.
+- Landfall sightings in the briefing (work doc #6): the simulation now raycasts the planned course against the corridor DEM and reports where and when topography first breaks the visual horizon — "At 14:00 assumed landfall, Neiafu visible at 230° True." — named from the on-board vector chart's Shortbread place labels. Multiple sightings per passage are episodes: island chains pass through the same list, separated by an out-of-sight gate (`landfall_min_offshore_hours`, 12 h — nothing within the horizon for that long before a sighting counts as new, and none reported until the departure land has disappeared), the arrival coast flagged final and shown with the ETA block in the strategic outlook, every episode riding the unified timeline (⛰ glyph, also on the map pins) and the tactical 24 h slice. Configuration: `landfall_enabled`, `height_of_eye_m` (3 m eye height in the 2.08·(√h+√H) horizon), `landfall_max_range_nm` (120), `landfall_min_offshore_hours` (12). The estimator (`public/landfall-estimator.mjs`) is pure with injectable elevation and gazetteer; the browser readers (`public/landfall-tiles.mjs`) fetch the corridor downloader's elevation MBTiles (Mapterhorn GLO-30 lossless-WebP Terrarium tiles, decoded natively) and the Shortbread base vector tiles (`place_labels`) over the same chart endpoints the map already uses — no new online fetches, tiles are content the boat already carries.
+
+### Fixed
+- The tactical screen's warnings map drew timeline event pins only for the 24 h slice while the strategic map drew the whole passage's — mid-passage the pins just stopped. The map now gets the full merged timeline like the strategic screen's does, so every placeable event shows where it happens; the timeline list stays the tactical 24 h slice, and the pin↔row click-through translates between the two index spaces through the shared event objects.
+## [0.13.3] - 2026-10-19
+
+### Fixed
+- Every map overlay — route, timeline pins, warning regions, notes, cyclone graphics — vanished mid-pan when the view crossed the antimeridian: `worldCopyJump` silently teleports a drag across the ±180° seam back into the primary world copy, where the basemap repeats (tiles wrap every world) but the overlays do not — they are unwrapped into the boat's own world copy (work doc #47), which on a Tonga→New Zealand passage lies west of the seam, so one pan across it left everything drawn 360° off-screen until the next data-driven fit. The option stays off now; overlays slide naturally with the pan instead of disappearing from a map that looks unchanged.
+- The map drew the simplified simulated track instead of the route's own geometry: the "one route line" refactor computed the colorized route ribbon and then a leftover assignment overwrote it with the sim-row ribbon (shipped in v0.12.8), so the drawn line drifted a mile or two off the actual route — the exact drift the refactor was meant to remove. The row-or-route selection moved into the model (`ribbonSpec`) and the view renders it in one assignment.
+
 ## [0.13.2] - 2026-10-19
 
 ### Fixed

package/README.md

@@ -11,6 +11,7 @@ Offshore passage daily briefing webapp for Signal K: a plugin that plans and rev
 - Fetches bulletins, official structured alerts, global disaster events and synoptic charts for the waters the route actually crosses
 - Keeps working offline: everything fetches in the online window and survives the other 23 hours from the cache
 - Shows a mini summary on the chart plotter and learns from every logbook entry the crew writes
+- Publishes weather warning areas as Signal K regions and notes for chartplotter apps to visualize
 
 The plugin fetches weather along the planned route — from the server's Weather API when a provider answers, Open-Meteo otherwise; fetched online, or via a GRIB/text spool when offline offshore. It runs a step-forward isochrone simulation with a monohull comfort model, learns the crew's sail preferences from the electronic logbook, and serves a two-screen webapp: a 24-hour tactical dashboard and a strategic passage summary. See [SPEC.md](SPEC.md) for the full design.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@meri-imperiumi/signalk-passage-briefing",
-  "version": "0.13.2",
-  "description": "Offshore passage daily briefing webapp for Signal K",
+  "version": "0.14.0",
+  "description": "Offshore passage daily briefing including weather warnings for Signal K",
   "main": "plugin/index.js",
   "scripts": {
     "format": "npx @biomejs/biome check --use-editorconfig=true --write plugin/ tests/ bin/ public/",
@@ -45,8 +45,10 @@
     "node": ">=22.12.0"
   },
   "dependencies": {
+    "@mapbox/vector-tile": "^3.0.0",
     "@openwaters/almanac": "^0.10.0",
     "@openwaters/maritime-zones": "^0.2.1",
+    "pbf": "^5.1.2",
     "satellite.js": "^7.1.0"
   },
   "devDependencies": {

package/plugin/index.js

@@ -189,6 +189,10 @@ const HERE_TTL_MS = 3 * 60 * 60 * 1000;
  */
 const DEFAULTS = {
   motoring_tws_threshold: 3.5,
+  // The engine's fallback bar: achieved speed (polar on course, or
+  // VMG while beating in irons) below this and the motor comes on
+  // (work doc #49)
+  motoring_speed_threshold: 2,
   // Downwind-sail night policy (work doc #47 session): "break" is
   // the default — no downwind sail at night; dusk strikes the sail
   // and reefable white sails (poled out) carry the dark period, dawn
@@ -203,6 +207,20 @@ const DEFAULTS = {
   k_heel: 0.35,
   k_pitch: 0.4,
   lines_of_interest_enabled: true,
+  /** Departure-day variants (work doc #34): how many candidate days
+   * the route switcher offers — today, +24 h, +48 h, +72 h at 4. */
+  departure_days: 4,
+  /** Forecast horizon for route briefings (days). The departure-day
+   * variants need the horizon to reach past the *latest* candidate's
+   * arrival — a +72 h variant of a week-long passage wants ~11 days.
+   * Each extra day is fetched for every waypoint on every refresh. */
+  forecast_days: DEFAULT_FORECAST_DAYS,
+  /** Landfall estimator (work doc #6): where and when topography
+   * first breaks the visual horizon along the planned course. */
+  landfall_enabled: true,
+  height_of_eye_m: 3,
+  landfall_max_range_nm: 120,
+  landfall_min_offshore_hours: 12,
   hazard_events_enabled: true,
   hazard_min_alert_level: "orange",
   hazard_radius_offroute_nm: 500,
@@ -302,6 +320,9 @@ module.exports = (app) => {
     k_heel: DEFAULTS.k_heel,
     k_pitch: DEFAULTS.k_pitch,
   };
+  /** Configured route-briefing fetch horizon in days (the default
+   * `forecastDays` every refresh path falls back to). */
+  let simulationForecastDays = DEFAULT_FORECAST_DAYS;
   /** @type {NodeJS.Timeout|null} */
   let cronTimer = null;
   /** Last known values of the watched paths. */
@@ -1596,7 +1617,7 @@ module.exports = (app) => {
    */
   async function refreshBriefingQueued(
     routeId,
-    forecastDays = DEFAULT_FORECAST_DAYS,
+    forecastDays = simulationForecastDays,
   ) {
     if (!isOnline()) {
       sourceStatus?.record({ ...WEATHER_SOURCE, skip: true });
@@ -2525,9 +2546,22 @@ module.exports = (app) => {
       properties: {
         motoring_tws_threshold: {
           type: "number",
-          title: "Motoring TWS Threshold (knots)",
+          title: "Becalmed Wind Threshold (knots)",
+          description:
+            "True wind below which the plan drifts (drift mode on) or " +
+            "motors — the becalmed case. Above it, the engine decision " +
+            "is speed-based, not wind-based.",
           default: DEFAULTS.motoring_tws_threshold,
         },
+        motoring_speed_threshold: {
+          type: "number",
+          title: "Motoring Speed Threshold (knots)",
+          description:
+            "The engine's fallback bar: when the achieved speed — polar " +
+            "speed on course, or VMG while beating in irons — drops " +
+            "below this, the motor comes on (work doc #49).",
+          default: DEFAULTS.motoring_speed_threshold,
+        },
         downwind_night_policy: {
           type: "string",
           title: "Downwind Sail Night Policy",
@@ -2580,6 +2614,37 @@ module.exports = (app) => {
             "antimeridian crossings along the planned route.",
           default: DEFAULTS.lines_of_interest_enabled,
         },
+        landfall_enabled: {
+          type: "boolean",
+          title: "Landfall sightings (visual horizon)",
+          description:
+            "Where and when topography first breaks the visual horizon " +
+            "along the planned course, named from the corridor DEM and " +
+            "its vector place names.",
+          default: DEFAULTS.landfall_enabled,
+        },
+        height_of_eye_m: {
+          type: "number",
+          title: "Landfall Height of Eye (meters)",
+          description:
+            "Observer height above the water for the visual-horizon " +
+            "distance: land at height H appears at 2.08·(√h+√H) nm.",
+          default: DEFAULTS.height_of_eye_m,
+        },
+        landfall_max_range_nm: {
+          type: "number",
+          title: "Landfall Scan Range (nm)",
+          default: DEFAULTS.landfall_max_range_nm,
+        },
+        landfall_min_offshore_hours: {
+          type: "number",
+          title: "Landfall Minimum Offshore Hours",
+          description:
+            "Land becomes a reported sighting only after this many hours " +
+            "with nothing within the visual horizon — coasting an island " +
+            "does not repeat the announcement.",
+          default: DEFAULTS.landfall_min_offshore_hours,
+        },
         hazard_events_enabled: {
           type: "boolean",
           title: "GDACS Hazard Events (earthquakes, cyclones, floods)",
@@ -2648,6 +2713,27 @@ module.exports = (app) => {
             "(−6° = civil dawn).",
           default: DEFAULTS.departure_dawn_altitude_deg,
         },
+        departure_days: {
+          type: "number",
+          title: "Departure Variant Days",
+          description:
+            "How many departure days the route switcher offers while " +
+            "stationary: today plus the +24 h/+48 h/… candidates, each " +
+            "the daylight-anchored departure of its own day. The latest " +
+            "candidate also needs the forecast horizon to cover its " +
+            "arrival.",
+          default: DEFAULTS.departure_days,
+        },
+        forecast_days: {
+          type: "number",
+          title: "Forecast Horizon (days)",
+          description:
+            "How many days of weather each route briefing fetches. Every " +
+            "extra day costs a fetch per waypoint per refresh — and is " +
+            "what makes late departure variants (work doc #34) simulable " +
+            "instead of disabled beyond forecast.",
+          default: DEFAULTS.forecast_days,
+        },
         celestial_eye_height_m: {
           type: "number",
           title: "Eye Height Above Water (meters)",
@@ -2884,14 +2970,32 @@ module.exports = (app) => {
               typeof station.station === "string",
           )
         : [];
+      // Departure-day variants (work doc #34): the candidate-day count
+      // the route switcher offers, clamped to a sane range
+      const departureDays = Math.min(
+        Math.max(Math.round(Number(config.departure_days) || 4), 1),
+        7,
+      );
+      // Forecast horizon (days): the fetch weight knob. The default
+      // stays the historical 7 — a late departure variant wants more
+      simulationForecastDays = Math.min(
+        Math.max(Math.round(Number(config.forecast_days) || 7), 1),
+        16,
+      );
       simulationConfig = {
         motoring_tws_threshold: config.motoring_tws_threshold,
+        motoring_speed_threshold: config.motoring_speed_threshold,
         drift_mode_enabled: config.drift_mode_enabled,
         motor_fuel_l_per_hour: config.motor_fuel_l_per_hour,
         waterline_length_m: config.waterline_length_m,
         k_heel: config.k_heel,
         k_pitch: config.k_pitch,
         lines_of_interest_enabled: config.lines_of_interest_enabled,
+        landfall_enabled: config.landfall_enabled !== false,
+        height_of_eye_m: config.height_of_eye_m,
+        landfall_max_range_nm: config.landfall_max_range_nm,
+        landfall_min_offshore_hours: config.landfall_min_offshore_hours,
+        departure_days: departureDays,
         // Downwind sail inventory for the deployment advisor (work
         // doc #41): empty until the start-time read lands — the
         // advisor stays silent rather than recommending canvas the
@@ -3193,7 +3297,7 @@ module.exports = (app) => {
           const days =
             typeof req.query.days === "string" && Number(req.query.days) > 0
               ? Number(req.query.days)
-              : DEFAULT_FORECAST_DAYS;
+              : simulationForecastDays;
           res.json(await refreshBriefing(routeId, days));
         } catch (error) {
           app.error(`Briefing refresh failed: ${error.message}`);

package/public/components/conditions-here.js

@@ -366,6 +366,17 @@ class ConditionsHere extends HTMLElement {
       map.setPayload(payload);
       map.setBulletin(payload?.metareaBulletin ?? null);
       map.hidden = !map.hasShapes();
+      // Seed the center with the briefing's own fix: the payload's
+      // waypoint is the position the briefing was compiled at, and a
+      // real center beats the birth view even before the stream
+      // delivers the live one (the race that stranded the map at 0,0)
+      const seeded = payload?.waypoints?.[0];
+      if (Number.isFinite(seeded?.lat) && Number.isFinite(seeded?.lon)) {
+        map.setVesselPosition({ lat: seeded.lat, lon: seeded.lon });
+      }
+      if (this._vesselPosition != null) {
+        map.setVesselPosition(this._vesselPosition);
+      }
     }
     this._map = map;
 
@@ -515,6 +526,18 @@ class ConditionsHere extends HTMLElement {
     }
   }
 
+  /**
+   * The vessel's live position (work doc #34 session): forwards to
+   * the map so the here view centers on `navigation.position`, not
+   * the briefing payload's fetch-time waypoint.
+   *
+   * @param {{lat: number, lon: number}|null} position
+   */
+  setVesselPosition(position) {
+    this._vesselPosition = position ?? null;
+    this._map?.setVesselPosition?.(position);
+  }
+
   /**
    * Click-through target (work doc #47): scroll to and flash one
    * warning block's text inside the console box.

package/public/components/departure-control.js

@@ -1,17 +1,13 @@
 /**
- * `<departure-control>` — the departure-time control shared by the
- * tactical and strategic views (work doc #15, SPEC §6.3 element
- * conventions).
+ * `<departure-control>` — the departure chip shared by the tactical
+ * and strategic views (work doc #15, SPEC §6.3 element conventions).
  *
- * Auto mode anchors to daylight (next civil dawn at night, prep delay
- * during the day, next dawn when the sun would set within the prep
- * window); the manual presets — Now, First light, +1 h, +2 h, and a
- * custom instant — are the crew's word and override auto until it is
- * put back to Auto. The root component owns the state; this element
- * renders it and reports changes, so both views always agree.
- *
- * The chip line states the assumption instead of silently shifting
- * numbers: "First light 05:48 (+7 h)" or "Underway — from now".
+ * Displays the effective departure instead of silently shifting
+ * numbers: "First light 05:48 (+7 h)" or "Underway — from now". The
+ * timing itself is decided in two places: the daylight anchor (auto,
+ * work doc #15) and the route switcher's departure-day variants
+ * (work doc #34) — the old mode pulldown went away once the variants
+ * made the manual presets redundant.
  *
  * DOM-free import safe: the element registers only in the browser.
  *
@@ -20,15 +16,6 @@
 
 import { fmtShip } from "./models.mjs";
 
-const MODES = [
-  ["auto", "Auto (daylight)"],
-  ["now", "Now"],
-  ["dawn", "First light"],
-  ["+1h", "In 1 hour"],
-  ["+2h", "In 2 hours"],
-  ["custom", "Custom…"],
-];
-
 /**
  * Reason → chip text, the part the departure anchor explains.
  *
@@ -64,52 +51,17 @@ class DepartureControl extends HTMLElement {
       this.shadowRoot.innerHTML = `
         <style>
           :host { display: block; }
-          .row {
-            display: flex; flex-wrap: wrap; gap: 8px;
-            align-items: center; margin: 8px 0 0;
-          }
           .chip {
             font-family: var(--font-data, ui-monospace, monospace);
             font-size: 0.8rem; font-weight: 700;
             letter-spacing: 0.08em; text-transform: uppercase;
             color: var(--color-grey);
+            margin: 8px 0 0;
           }
-          select, input {
-            min-height: 36px; padding: 4px 8px;
-          }
-          input[hidden] { display: none; }
         </style>
-        <div class="row">
-          <span class="chip" id="chip"></span>
-          <select id="mode" aria-label="Departure time"></select>
-          <input type="datetime-local" id="custom" hidden
-            aria-label="Custom departure time"></input>
-        </div>
+        <span class="chip" id="chip"></span>
       `;
       this._chip = this.shadowRoot.getElementById("chip");
-      this._select = this.shadowRoot.getElementById("mode");
-      this._custom = this.shadowRoot.getElementById("custom");
-      for (const [value, label] of MODES) {
-        const option = document.createElement("option");
-        option.value = value;
-        option.textContent = label;
-        this._select.appendChild(option);
-      }
-      this._select.addEventListener("change", () => {
-        const mode = this._select.value;
-        this._custom.hidden = mode !== "custom";
-        if (mode !== "custom") {
-          this._customTime = null;
-        }
-        this.emit({ mode, customTime: this._customTime });
-      });
-      this._custom.addEventListener("change", () => {
-        if (this._custom.value) {
-          // datetime-local is naive local time; convert to epoch
-          this._customTime = new Date(this._custom.value).toISOString();
-          this.emit({ mode: "custom", customTime: this._customTime });
-        }
-      });
       this._rendered = true;
     }
     this.render(this._state ?? {});
@@ -119,31 +71,14 @@ class DepartureControl extends HTMLElement {
    * Renders the current departure state.
    *
    * @param {object} state
-   * @param {string} state.mode - Selected mode
    * @param {{time: string|Date, reason: string, assumed: boolean}|
    *   null} state.departure - Effective departure
-   * @param {string|null} state.customTime - Custom instant (ISO)
    */
   render(state) {
     this._state = state ?? {};
-    if (!this._select) {
+    if (!this._chip) {
       return; // Not yet connected: rendered on connect
     }
-    if (this._select.value !== this._state.mode) {
-      this._select.value = this._state.mode ?? "auto";
-      this._custom.hidden = this._select.value !== "custom";
-    }
-    if (this._state.customTime && this._state.mode === "custom") {
-      const custom = this._state.customTime;
-      if (this._custom.value !== custom) {
-        // datetime-local wants local wall time; offset from ISO
-        const date = new Date(custom);
-        const pad = (n) => String(n).padStart(2, "0");
-        this._custom.value =
-          `${date.getFullYear()}-${pad(date.getMonth() + 1)}-` +
-          `${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}`;
-      }
-    }
     const departure = this._state.departure;
     if (!departure?.time) {
       this._chip.textContent = "";
@@ -155,12 +90,6 @@ class DepartureControl extends HTMLElement {
       ? `${reason} ${stamp}`
       : `Departure ${stamp}`;
   }
-
-  emit(detail) {
-    this.dispatchEvent(
-      new CustomEvent("departurechange", { detail, bubbles: true }),
-    );
-  }
 }
 
 if (typeof customElements !== "undefined") {

package/public/components/map-model.mjs

@@ -870,6 +870,38 @@ export function routeRibbon(waypoints, track, referenceLon = null) {
   return segments.map(({ key, ...segment }) => segment);
 }
 
+/**
+ * The one route line the map draws: the payload's real geometry
+ * colorized by the plan ({@link routeRibbon}) when it exists, the
+ * simulated rows ({@link ribbonSegments}) only without it (here mode
+ * and pre-compile views). The selection lives here — not in the view
+ * — so the row fallback cannot clobber the route line again (the
+ * discard regression of 2026-10: the view computed the route ribbon
+ * and then overwrote it with the rows).
+ *
+ * @param {Array<{lat: number, lon: number}>} waypoints - The viewed
+ *   route's sampled geometry (empty in here mode)
+ * @param {Array<{distanceFromStartNm: number, lat: number, lon: number,
+ *   comfortLevel: string|null, slatting: boolean, motoring: boolean,
+ *   night: boolean}>} track - summary.track rows
+ * @param {number|null} referenceLon - The map's longitude frame
+ * @returns {Array<{points: number[][], comfortLevel: string|null,
+ *   slatting: boolean, motoring: boolean, night: boolean}>}
+ */
+export function ribbonSpec(waypoints, track, referenceLon = null) {
+  const hasGeometry =
+    (waypoints ?? []).filter(
+      (w) => Number.isFinite(w?.lat) && Number.isFinite(w?.lon),
+    ).length >= 2;
+  if (!hasGeometry) {
+    return ribbonSegments(track ?? [], referenceLon);
+  }
+  return (
+    routeRibbon(waypoints, track ?? [], referenceLon) ??
+    ribbonSegments(track ?? [], referenceLon)
+  );
+}
+
 /**
  * The coordinates the map's initial fit frames (work doc #47 session:
  * the fit is the route's, not the warnings'). When route geometry