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

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [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

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.3",
-  "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-view.js

@@ -32,6 +32,7 @@
 
 /* global L */
 
+import { greatCircleNm } from "../sereno-physics.mjs";
 import {
   blockShapes,
   chartAssetsFromManifest,
@@ -63,6 +64,9 @@ class PbMapView extends HTMLElement {
     this._blocks = [];
     this._payload = null;
     this._vessel = null;
+    this._liveFix = null;
+    this._vesselMarker = null;
+    this._fitted = false;
     this._ribbonRows = [];
     this._events = [];
     this._resourceRegions = {};
@@ -107,6 +111,25 @@ class PbMapView extends HTMLElement {
             0 0 3px var(--bg-base, #080a0c),
             0 0 3px var(--bg-base, #080a0c);
         }
+        /* The vessel herself (work doc #34 session): a live "you are
+           here" marker at navigation.position, the way
+           signalk-dead-reckoning marks the boat — a pulsing dot the
+           crew finds instantly on every map */
+        .pb-vessel {
+          background: transparent;
+          border: none;
+        }
+        .pb-vessel-dot {
+          display: block;
+          width: 10px;
+          height: 10px;
+          border-radius: 50%;
+          background: var(--color-teal, #4ec9b0);
+          border: 2px solid rgba(255, 255, 255, 0.55);
+          box-shadow:
+            0 0 6px rgba(78, 201, 176, 0.8),
+            0 0 2px rgba(78, 201, 176, 0.9);
+        }
         .pb-pin.sev-warn { filter: sepia(1) saturate(4) hue-rotate(-25deg); }
         .pb-pin.sev-severe { filter: sepia(1) saturate(6) hue-rotate(-40deg); }
         .pb-pin:focus { outline: none; }
@@ -449,7 +472,9 @@ class PbMapView extends HTMLElement {
   setPayload(payload) {
     this._payload = payload ?? null;
     // The vessel anchors the map when no route does (here mode: the
-    // payload carries the vessel's position as its single waypoint)
+    // payload carries the vessel's position as its single waypoint).
+    // A live fix already received outranks the fetch-time waypoint —
+    // setVesselPosition keeps it current.
     const waypoints = this._payload?.waypoints ?? [];
     this._vessel =
       waypoints.length === 1 &&
@@ -457,10 +482,60 @@ class PbMapView extends HTMLElement {
       Number.isFinite(waypoints[0]?.lon)
         ? waypoints[0]
         : null;
+    if (this._liveFix != null) {
+      this._vessel = this._liveFix;
+    }
     this._render();
     this._fit();
   }
 
+  /**
+   * The vessel's live position (work doc #34 session): the here-mode
+   * map centers on `navigation.position`, not the briefing payload's
+   * fetch-time waypoint. Refits only when the boat materially moved —
+   * a fix at anchor must not yank the view the crew is reading; the
+   * distance test is against the position the current fit was built
+   * on.
+   *
+   * @param {{lat: number, lon: number}|null} position
+   */
+  setVesselPosition(position) {
+    if (
+      !position ||
+      !Number.isFinite(position.lat) ||
+      !Number.isFinite(position.lon)
+    ) {
+      return;
+    }
+    this._liveFix = position;
+    const previous = this._vessel;
+    this._vessel = position;
+    const moved =
+      previous != null &&
+      Number.isFinite(previous.lat) &&
+      Number.isFinite(previous.lon)
+        ? greatCircleNm(previous.lat, previous.lon, position.lat, position.lon)
+        : Infinity;
+    // The direct center applies only when the vessel anchors the view
+    // (here mode, no route ribbon) — route maps keep their route fit
+    // and draw the marker along it.
+    const anchors = (this._ribbon ?? []).length === 0;
+    if (anchors && (previous == null || moved > 5 || !this._fitted)) {
+      this._fit();
+      // Belt and braces: the fit's bounds arithmetic can bail mid-reveal
+      // (hidden container, unmeasured tick), and the observer then has
+      // no size change left to refit on. The vessel center itself is
+      // always finite — land on it directly when the map is live.
+      if (!this._fitted && this.map != null && this.mapEl.clientWidth > 50) {
+        this.map.setView([position.lat, position.lon], 6);
+        this._fitted = true;
+      }
+    }
+    if (this._vesselMarker != null) {
+      this._vesselMarker.setLatLng([position.lat, position.lon]);
+    }
+  }
+
   /**
    * The simulated passage rows (work doc #47): they colorize the real
    * route geometry — comfort tier colors, motoring stretches dashed,
@@ -792,6 +867,26 @@ class PbMapView extends HTMLElement {
         .addTo(this._overlayGroup);
       this._eventMarkers.set(pin.index, marker);
     }
+    // The vessel herself (work doc #34 session): a live "you are
+    // here" marker at navigation.position, dead-reckoning style.
+    // Drawn on every map — here mode centers on it, route mode draws
+    // it along the route.
+    if (this._vesselMarker) {
+      this._vesselMarker.remove();
+      this._vesselMarker = null;
+    }
+    if (this._vessel != null && this.map != null) {
+      this._vesselMarker = L.marker([this._vessel.lat, this._vessel.lon], {
+        interactive: false,
+        zIndexOffset: 1000,
+        icon: L.divIcon({
+          className: "pb-vessel",
+          html: '<span class="pb-vessel-dot"></span>',
+          iconSize: [14, 14],
+          iconAnchor: [7, 7],
+        }),
+      }).addTo(this.map);
+    }
   }
 
   /** Click-through: hand the console the block index. */
@@ -885,17 +980,28 @@ class PbMapView extends HTMLElement {
     // under 50 px is unmeasured — the resize tick refits once the
     // card reveals.
     if (this.mapEl.clientWidth < 50 || this.mapEl.clientHeight < 50) {
+      console.info(
+        "pb-map-view: fit deferred — container unmeasured (hidden or mid-layout)",
+      );
       this._needsFit = true;
       return;
     }
     const all = this._drawablePoints();
-    // No route: the vessel anchors the view — a couple hundred miles
-    // of water around her, a fabricated square so the span holds
-    // across screen sizes instead of leaning on a zoom level
-    const vesselBounds =
-      all.length === 1 && this._vessel ? vesselFitBounds(this._vessel) : null;
+    // The vessel anchors the view — a couple hundred miles of water
+    // around her, a fabricated square so the span holds across screen
+    // sizes instead of leaning on a zoom level. Keyed on the vessel's
+    // presence, not on what else is drawable: the here map's shapes
+    // and regions arrive asynchronously, and a fit that waits for
+    // them never runs at all — the map stays on its birth view (the
+    // 0,0 the crew stared at).
+    const vesselAnchors =
+      this._vessel != null && (this._ribbon ?? []).length === 0;
+    const vesselBounds = vesselAnchors ? vesselFitBounds(this._vessel) : null;
     const bounds = vesselBounds ?? frameBounds(all);
     if (!bounds) {
+      console.info(
+        "pb-map-view: fit skipped — nothing drawable yet (vessel and shapes pending)",
+      );
       return;
     }
     const [minLon, minLat, maxLon, maxLat] = bounds;
@@ -938,7 +1044,9 @@ class PbMapView extends HTMLElement {
       // tick refits
       this.map.setView([0, 0], 3);
       this._needsFit = true;
+      return;
     }
+    this._fitted = true;
   }
 }