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

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meri-imperiumi/signalk-passage-briefing",
-  "version": "0.13.2",
+  "version": "0.13.3",
   "description": "Offshore passage daily briefing webapp for Signal K",
   "main": "plugin/index.js",
   "scripts": {

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

package/public/components/map-view.js

@@ -44,8 +44,7 @@ import {
   OSM_LAYER,
   parseChartLayers,
   regionShapes,
-  ribbonSegments,
-  routeRibbon,
+  ribbonSpec,
   stormGraphic,
   stormRingColor,
   vesselFitBounds,
@@ -159,7 +158,14 @@ class PbMapView extends HTMLElement {
       // that far anyway
       minZoom: 2,
       attributionControl: false,
-      worldCopyJump: true,
+      // worldCopyJump stays OFF on purpose: every overlay is unwrapped
+      // into the boat's own world copy (work doc #47), which on a
+      // Tonga→New Zealand passage is the western one beyond the
+      // antimeridian. The jump silently teleports a drag across the
+      // seam back into the primary copy — tiles repeat every world so
+      // the basemap looks unchanged, but the route, pins and warning
+      // shapes do not repeat, and everything is suddenly 360°
+      // off-screen until the next data-driven fit
     });
     L.control.zoom({ position: "bottomleft" }).addTo(this.map);
     // On touch the collapsed gear is one more tap between the crew and
@@ -578,17 +584,14 @@ class PbMapView extends HTMLElement {
     // One route line (work doc #47 session): the real route geometry
     // carrying the plan's color encoding — not a plain route line
     // plus a second sim-track ribbon that drifts off it. The row
-    // ribbon survives only where no route geometry exists
-    this._ribbon =
-      (this._payload?.waypoints ?? []).filter(
-        (w) => Number.isFinite(w?.lat) && Number.isFinite(w?.lon),
-      ).length >= 2
-        ? routeRibbon(
-            this._payload.waypoints,
-            this._ribbonRows ?? [],
-            referenceLon,
-          )
-        : ribbonSegments(this._ribbonRows ?? [], referenceLon);
+    // ribbon survives only where no route geometry exists; the
+    // selection lives in the model (ribbonSpec) so no second
+    // assignment can clobber the route line again
+    this._ribbon = ribbonSpec(
+      this._payload?.waypoints ?? [],
+      this._ribbonRows ?? [],
+      referenceLon,
+    );
     this._regions = regionShapes(this._resourceRegions, referenceLon);
     this._noteMarkers = notePins(
       this._resourceNotes,
@@ -601,7 +604,6 @@ class PbMapView extends HTMLElement {
     this._consoleIndex = new Map(
       (this._blocks ?? []).map((block, index) => [block.text, index]),
     );
-    this._ribbon = ribbonSegments(this._ribbonRows ?? [], referenceLon);
     this._eventPins = eventPins(this._events ?? [], referenceLon);
     this._storms = (this._blocks ?? [])
       .map((block, index) => stormGraphic(block, index, referenceLon))

package/tests/map-model.test.js

@@ -365,8 +365,14 @@ test("map model", async (t) => {
 });
 
 test("ribbon segments and event pins (work doc #47)", async (t) => {
-  const { eventPins, ribbonSegments, routeRibbon, fitPoints, vesselFitBounds } =
-    await import("../public/components/map-model.mjs");
+  const {
+    eventPins,
+    ribbonSegments,
+    ribbonSpec,
+    routeRibbon,
+    fitPoints,
+    vesselFitBounds,
+  } = await import("../public/components/map-model.mjs");
 
   await t.test("ribbonSegments run-length groups the plan's regimes", () => {
     const track = [
@@ -562,6 +568,74 @@ test("ribbon segments and event pins (work doc #47)", async (t) => {
     assert.equal(routeRibbon([{ lat: 1, lon: 2 }], []), null);
   });
 
+  await t.test(
+    "ribbonSpec draws the route geometry, rows only without it",
+    () => {
+      // The one-line rule the view renders by: the payload's real
+      // geometry colorized by the plan when it exists, the simulated
+      // rows only without it (here mode, pre-compile). The selection
+      // lives in the model so the row fallback cannot clobber the
+      // route line again — the 2026-10 discard regression had the
+      // view compute the route ribbon and then overwrite it with the
+      // rows, drawing the simplified sim-track line that drifts off
+      // the route instead of the route itself
+      const waypoints = [
+        { lat: -18.6, lon: -174, distanceFromStartNm: 0 },
+        { lat: -18.8, lon: -174.4, distanceFromStartNm: 30 },
+      ];
+      const track = [
+        {
+          distanceFromStartNm: 0,
+          lat: -18.6,
+          lon: -174,
+          comfortLevel: "pleasant",
+          slatting: false,
+          motoring: false,
+          night: false,
+        },
+      ];
+      const spec = ribbonSpec(waypoints, track);
+      assert.deepEqual(
+        spec[0].points[0],
+        [-174, -18.6],
+        "route geometry drives the line",
+      );
+      assert.equal(spec[0].comfortLevel, "pleasant");
+      // No route geometry: the row ribbon survives
+      const rowsOnly = ribbonSpec([], track);
+      assert.deepEqual(rowsOnly, ribbonSegments(track));
+      assert.equal(rowsOnly.length, 1);
+      // Null payloads (pre-compile views) degrade to the rows too
+      assert.deepEqual(ribbonSpec(null, track), ribbonSegments(track));
+    },
+  );
+
+  await t.test(
+    "ribbonSpec unwraps the route into the reference frame across the antimeridian",
+    () => {
+      // The Tonga→New Zealand passage straddles ±180°: with the map
+      // framed on the boat (first waypoint -175), the plan's eastern
+      // points must draw as their western-copy equivalents so route
+      // and warnings share one world copy
+      const waypoints = [
+        { lat: -19.05, lon: -175.4, distanceFromStartNm: 0 },
+        { lat: -20.3, lon: -179.9, distanceFromStartNm: 300 },
+        { lat: -21.5, lon: 175.2, distanceFromStartNm: 600 },
+        { lat: -22.4, lon: 173.8, distanceFromStartNm: 900 },
+      ];
+      const spec = ribbonSpec(waypoints, [], -175.4);
+      const lons = spec[0].points.map(([lon]) => lon);
+      assert.ok(
+        lons.every((lon, i) => i === 0 || lon < lons[i - 1] + 180),
+        `one continuous frame: ${JSON.stringify(lons)}`,
+      );
+      assert.ok(
+        lons.at(-1) < -180,
+        `New Zealand lands in the western copy: ${lons.at(-1)}`,
+      );
+    },
+  );
+
   await t.test(
     "fitPoints frames the route, then the vessel, then the warnings",
     () => {

package/tests/map-view.test.js

@@ -156,3 +156,52 @@ test("maplibreStyleFor builds a source-and-trio style for a vector chart", async
   );
   assert.ok(seamarkIdx > waterIdx, "seamarks above water fills");
 });
+
+test("the map view mounts Leaflet without view-copy teleporting", async () => {
+  // Leaflet only mounts in a browser, so the component itself has no
+  // node-test harness — these two mount/render regressions are pinned
+  // at the source level instead.
+  //
+  // worldCopyJump silently wraps a drag across the antimeridian back
+  // into the primary world copy: tiles repeat every world so the
+  // basemap looks unchanged, but the overlays are unwrapped into the
+  // boat's own copy (work doc #47) and do not repeat — on a
+  // Tonga→New Zealand passage (route astride ±180°) one pan across
+  // the seam left every route, pin and warning shape 360° off-screen
+  // until the next data-driven fit. The option must stay off.
+  const { readFileSync } = require("node:fs");
+  const { join } = require("node:path");
+  const source = readFileSync(
+    join(__dirname, "../public/components/map-view.js"),
+    "utf8",
+  );
+  assert.ok(
+    !/worldCopyJump\s*:\s*true/.test(source),
+    "worldCopyJump must not be enabled — it teleports the view off the boat's overlay frame mid-drag",
+  );
+});
+
+test("the view renders the ribbon through the model's one-line selector", async () => {
+  // The 2026-10 discard regression: the view computed the route-geometry
+  // ribbon (routeRibbon) and then overwrote it with the sim-row ribbon
+  // (ribbonSegments) — the map drew the simplified sim track that drifts
+  // off the route instead of the route itself. The selection now lives in
+  // map-model's ribbonSpec; the view must call it once and never assign
+  // _ribbon again. The only allowed assignments are the pre-mount []
+  // initializer and the render's ribbonSpec call.
+  const { readFileSync } = require("node:fs");
+  const { join } = require("node:path");
+  const source = readFileSync(
+    join(__dirname, "../public/components/map-view.js"),
+    "utf8",
+  );
+  const initializers = [...source.matchAll(/this\._ribbon\s*=\s*(\S)/g)].map(
+    (match) => match[1],
+  );
+  assert.deepEqual(
+    initializers,
+    ["[", "r"],
+    `the only _ribbon assignments must be the [] initializer and the render's ribbonSpec call (found: ${JSON.stringify(initializers)})`,
+  );
+  assert.match(source, /ribbonSpec\(/, "the selector comes from the model");
+});