signalk-chiplog 2.3.1 → 2.4.0

package/CHANGELOG.md

@@ -6,6 +6,26 @@ All notable changes to Chiplog are documented here. The format follows
 
 ## [Unreleased]
 
+## [2.4.0] - 2026-09-18
+
+### Added
+
+- **Previous and next passage links at the top of a passage page**, to step through the log without going back to it.
+  `GET /entries/:id` gives them as `previousEntryId` and `nextEntryId`, in the log's order. Alt+← and Alt+→ do the same
+  from the keyboard.
+- **A Statistics page** sums the logbook up over a period: number of passages, first and last dates, total distance,
+  time under way, top speed, strongest wind, the longest passage without a stop (a passage is cut at its stopovers, each
+  stretch measured on its own), the flags of the countries visited, and the top 5 passages by duration, distance,
+  average speed, top speed and wind. The period is a shortcut — all time, this month, last month, the last 12 months,
+  this year, last year — or a range picked in a calendar with two clicks, the first and the last day. It reads
+  `GET /statistics`.
+- **One range picker for every date range** in the webapp: the Animation, Export and Retrospective pages use the same
+  calendar — two clicks, the first and the last day — instead of a pair of date fields, so a range with its end before
+  its start can no longer be entered.
+- **Places now know their country** (`countryCode` on `GET /places`), from the same geocoding lookup that names them;
+  places saved earlier, or added by hand, are asked about in the background once pending names are done. Database
+  migration 16.
+
 ## [2.3.1] - 2026-09-18
 
 ### Added
@@ -287,7 +307,8 @@ First release.
 - REST API under `/plugins/signalk-chiplog/api`, documented in [docs/API.md](docs/API.md).
 - Single SQLite database through Node's built-in `node:sqlite`: no native module to build.
 
-[Unreleased]: https://github.com/ricard33/signalk-chiplog/compare/v2.3.1...HEAD
+[Unreleased]: https://github.com/ricard33/signalk-chiplog/compare/v2.4.0...HEAD
+[2.4.0]: https://github.com/ricard33/signalk-chiplog/compare/v2.3.1...v2.4.0
 [2.3.1]: https://github.com/ricard33/signalk-chiplog/compare/v2.3.0...v2.3.1
 [2.3.0]: https://github.com/ricard33/signalk-chiplog/compare/v2.2.0...v2.3.0
 [2.2.0]: https://github.com/ricard33/signalk-chiplog/compare/v2.1.0...v2.2.0

package/README.md

@@ -201,36 +201,48 @@ Open **Chiplog** from the Signal K webapps, or `/signalk-chiplog/`. Reading need
   not just what is loaded), then passages grouped by day, newest first, with times, departure and arrival, distance,
   duration and an engine/sail bar. A passage across midnight appears on both days. Provisional place names are shown as
   such.
-- **Passage page** — summary (distance, duration, average speed, the highest speed and wind seen, and the crew aboard),
-  map of the track (OpenStreetMap with OpenSeaMap seamarks, which can be hidden) with a small boat marker at the
-  selected point, a scrubber under the map to step back and forth through its history (defaulting to the latest point,
-  so it shows the current position on a passage in progress) with a band of that point's time, SOG, COG, STW, TWS, TWD,
-  TWA and AWA, the marine weather forecast every 3 hours from departure, the tide forecast near the departure (place,
-  high/low times and heights, height curve) when one was fetched, the engine and sail periods, the boat's status (each
-  engine's hour counter at departure and arrival and the hours run, and the tank levels and battery charge, voltage and
-  current noted at departure), and the log: every reading and event in order, including handwritten notes. A passage in
-  progress refreshes every minute. Each line's comment can be edited (read/write access); a manoeuvre or note the crew
-  logged themselves can also be deleted — automatic lines (alarms, autopilot, weather, corrections) can only be
-  annotated. Under each position, in grey, its bearing and distance from the nearest landmark.
+- **Passage page** — links at the top to the previous and the next passage (or **Alt+←** and **Alt+→**), then a summary
+  (distance, duration, average speed, the highest speed and wind seen, and the crew aboard), map of the track
+  (OpenStreetMap with OpenSeaMap seamarks, which can be hidden) with a small boat marker at the selected point, a
+  scrubber under the map to step back and forth through its history (defaulting to the latest point, so it shows the
+  current position on a passage in progress) with a band of that point's time, SOG, COG, STW, TWS, TWD, TWA and AWA, the
+  marine weather forecast every 3 hours from departure, the tide forecast near the departure (place, high/low times and
+  heights, height curve) when one was fetched, the engine and sail periods, the boat's status (each engine's hour
+  counter at departure and arrival and the hours run, and the tank levels and battery charge, voltage and current noted
+  at departure), and the log: every reading and event in order, including handwritten notes. A passage in progress
+  refreshes every minute. Each line's comment can be edited (read/write access); a manoeuvre or note the crew logged
+  themselves can also be deleted — automatic lines (alarms, autopilot, weather, corrections) can only be annotated.
+  Under each position, in grey, its bearing and distance from the nearest landmark.
 - **Corrections** (read/write access):
   - rename the departure, or the arrival once the passage is closed — a passage in progress has none yet to rename;
   - switch an engine period to sail or back;
   - close a passage in progress, e.g. to confirm an arrival;
   - merge with the previous or next passage;
   - delete a passage (admin).
-- **Animation** — pick two dates and every passage between them replays on the map, one after another, the port time
-  skipped. The map follows the boat at a scale chosen for each passage — a short hop kept readable rather than
-  magnified, a long crossing allowed a wider view but never so wide the boat crawls across empty water — while a bubble
-  shows the speed, the distance covered since the start and the date. Play, pause and a slider over the animation's own
-  time, at ×0,5, ×1, ×2 or ×4. **Export MP4** saves it as a video in one of five shapes (Mobile 9:16, Portrait 3:4,
-  Square 1:1, Landscape 4:3, Widescreen 16:9). Everything happens in the browser: nothing is rendered or encoded on the
-  Signal K server, and the map tiles are the only thing downloaded.
+- **Statistics** — the logbook summed up over a period: a shortcut (all time, this month, last month, the last 12
+  months, this year, last year) or a range picked in a calendar with two clicks, the first and the last day. It gives
+  the number of passages, the dates of the first and the last, total distance, time under way, top speed and strongest
+  wind, the longest passage without a stop (a passage with a stopover counts as its stretches between stops) with its
+  distance and time, the flags of the countries visited, and the top 5 passages by duration, distance, average speed,
+  top speed and wind. Countries come from the place names, so they need geocoding enabled and the boat online now and
+  then; places named before this existed fill in by themselves.
+- **Animation** — pick a period and every passage in it replays on the map, one after another, the port time skipped.
+  The map follows the boat at a scale chosen for each passage — a short hop kept readable rather than magnified, a long
+  crossing allowed a wider view but never so wide the boat crawls across empty water — while a bubble shows the speed,
+  the distance covered since the start and the date. Play, pause and a slider over the animation's own time, at ×0,5,
+  ×1, ×2 or ×4. **Export MP4** saves it as a video in one of five shapes (Mobile 9:16, Portrait 3:4, Square 1:1,
+  Landscape 4:3, Widescreen 16:9). Everything happens in the browser: nothing is rendered or encoded on the Signal K
+  server, and the map tiles are the only thing downloaded.
 - **Export** — download the whole logbook or a date range as a PDF logbook to print, JSON, CSV or GPX, and write the
   abandon-ship copy to the USB drive now (admin). The PDF is written in the webapp's language and the device's time
   zone.
 - **Retrospective** (admin) — reconstruct past passages for a date range from an InfluxDB history (see
   [Retrospective analysis](#retrospective-analysis-)).
 
+Every date range in the webapp — Statistics, Animation, Export and Retrospective — is picked the same way: one button
+showing the period, and a calendar under it where two clicks, the first and the last day, make the range. Statistics has
+shortcuts beside it; where any date is allowed, the calendar has an _Any date_ button to clear the range.
+
 **Helm entry** in the top bar opens the tablet entry app.
 
 ## The tablet entry app 📱
@@ -410,6 +422,8 @@ at the time.
 - **Place names.** With geocoding on, the position of each departure and arrival that matches no known place is sent to
   the geocoding service — OpenStreetMap's public Nominatim by default. Nothing else is sent, and nothing at all when it
   is off.
+- **Countries.** With geocoding on, a place whose country is not known yet has its position sent to the geocoding
+  service once, to ask which country it is in. Nothing at all when it is off.
 - **Landmarks.** With them on, the area a passage sailed through — a half-degree box, not its track — is sent to the
   Overpass service, OpenStreetMap's public instance by default, once per area ever. Nothing at all when it is off.
 - **Tide forecast.** With it on, the departure position of each passage is sent to the tide service — the public

package/lib/api.js

@@ -12,6 +12,7 @@ const places = require('./places');
 const propulsion = require('./propulsion');
 const { getTideForecast } = require('./tide-forecaster');
 const { getWeatherForecast } = require('./weather-forecaster');
+const { getStatistics } = require('./statistics');
 const track = require('./track');
 const v = require('./validation');
 
@@ -132,6 +133,11 @@ function registerRoutes(router, { getContext, logError }) {
     handle(({ db, now }, req) => entries.getStats(db, { ...parseRange(req.query), now: now() }))
   );
 
+  readonly.get(
+    '/api/statistics',
+    handle(({ db, now }, req) => getStatistics(db, { ...parseRange(req.query), now: now() }))
+  );
+
   readonly.get(
     '/api/entries/:id',
     handle(({ db }, req) => entries.getEntry(db, entryId(req)))

package/lib/database.js

@@ -358,6 +358,19 @@ const MIGRATIONS = [
   -- passages default to pending, so their areas are fetched too.
   ALTER TABLE log_entries ADD COLUMN landmarks_pending INTEGER NOT NULL DEFAULT 1
     CHECK (landmarks_pending IN (0, 1));
+  `,
+  `
+  -- The country a place is in (SPEC §4.14), as an upper-case ISO 3166-1
+  -- alpha-2 code, for the statistics page's visited countries. It lives on the
+  -- place rather than on each entry: a passage reaches its country through
+  -- start_place_id / end_place_id. country_checked says the lookup has been
+  -- made, so a place whose position has no country (open water, or geocoding
+  -- switched off after the fact) is not asked about forever. Existing places
+  -- start unchecked and are filled in by the same background chain that names
+  -- pending departures.
+  ALTER TABLE places ADD COLUMN country_code TEXT;
+  ALTER TABLE places ADD COLUMN country_checked INTEGER NOT NULL DEFAULT 0
+    CHECK (country_checked IN (0, 1));
   `
 ];
 

package/lib/entries.js

@@ -48,7 +48,7 @@ function requireEntryRow(db, id) {
   return row;
 }
 
-// Shared by listEntries and getStats, so a date range means the same thing
+// Shared by listEntries, getStats and the statistics page, so a date range means the same thing
 // to both: matched on startTime, from inclusive and to exclusive.
 function rangeWhere({ from, to }) {
   const conditions = [];
@@ -94,8 +94,27 @@ function getStats(db, { from, to, now }) {
   return { count: row.count, distance: row.distance, duration: Math.round(row.duration) };
 }
 
+// The passages either side of this one in the log's order (start time, then
+// id), for a page to step to its neighbours.
+function neighbourIds(db, row) {
+  const before = db
+    .prepare(
+      `SELECT id FROM log_entries WHERE start_time < ?1 OR (start_time = ?1 AND id < ?2)
+       ORDER BY start_time DESC, id DESC LIMIT 1`
+    )
+    .get(row.start_time, row.id);
+  const after = db
+    .prepare(
+      `SELECT id FROM log_entries WHERE start_time > ?1 OR (start_time = ?1 AND id > ?2)
+       ORDER BY start_time, id LIMIT 1`
+    )
+    .get(row.start_time, row.id);
+  return { previousEntryId: before?.id ?? null, nextEntryId: after?.id ?? null };
+}
+
 function getEntry(db, id) {
-  const entry = toEntry(requireEntryRow(db, id));
+  const row = requireEntryRow(db, id);
+  const entry = toEntry(row);
   const count = (table) =>
     db.prepare(`SELECT COUNT(*) AS n FROM ${table} WHERE entry_id = ?`).get(id).n;
   const maxSpeed = db
@@ -116,6 +135,7 @@ function getEntry(db, id) {
     .get(id, id);
   return {
     ...entry,
+    ...neighbourIds(db, row),
     counts: {
       trackPoints: count('track_points'),
       observations: count('observations'),
@@ -488,6 +508,7 @@ function deleteEntry(db, id) {
 module.exports = {
   toEntry,
   requireEntryRow,
+  rangeWhere,
   listEntries,
   getStats,
   getEntry,

package/lib/place-names.js

@@ -61,6 +61,19 @@ function pickName(result) {
   return district && district !== settlement ? `${settlement} (${district})` : settlement;
 }
 
+// The country as an upper-case ISO 3166-1 alpha-2 code, which Nominatim gives in
+// lower case. Null when the position has none, as at sea.
+function pickCountry(result) {
+  const code = result?.address?.country_code;
+  return typeof code === 'string' && /^[a-z]{2}$/i.test(code) ? code.toUpperCase() : null;
+}
+
+// Country level for a place asked about only for its country: the answer to a
+// position in a marina at street level would be the same, at more cost to
+// Nominatim's own lookup.
+const COUNTRY_ZOOM = 3;
+const NAME_ZOOM = 17;
+
 function createPlaceNamer({ db, settings, userAgent, fetch = globalThis.fetch }) {
   const stopping = new AbortController();
   let failures = 0;
@@ -101,18 +114,35 @@ function createPlaceNamer({ db, settings, userAgent, fetch = globalThis.fetch })
 
   // The places table is the geocoding cache: the next departure or arrival
   // within the radius is named from it, with no request.
-  function rememberGeocoded(name, { lat, lon }) {
+  function rememberGeocoded(name, { lat, lon }, countryCode) {
     const now = new Date().toISOString();
     const { lastInsertRowid } = db
       .prepare(
-        `INSERT INTO places (name, lat, lon, source, created_at, updated_at)
-         VALUES (?, ?, ?, 'geocoding', ?, ?)`
+        `INSERT INTO places (name, lat, lon, source, country_code, country_checked, created_at, updated_at)
+         VALUES (?, ?, ?, 'geocoding', ?, 1, ?, ?)`
       )
-      .run(name, lat, lon, now, now);
+      .run(name, lat, lon, countryCode, now, now);
     return { id: Number(lastInsertRowid), name };
   }
 
-  async function lookup({ lat, lon }) {
+  // A place added by hand, or one saved before countries were recorded, has
+  // not been asked about yet.
+  function nextPlaceWithoutCountry() {
+    return db
+      .prepare('SELECT id, lat, lon FROM places WHERE country_checked = 0 ORDER BY id DESC LIMIT 1')
+      .get();
+  }
+
+  // Only a place whose country has not been set since is filled in, so a
+  // lookup that was out while the place was deleted or corrected changes nothing.
+  function settleCountry({ id }, countryCode) {
+    db.prepare(
+      'UPDATE places SET country_code = ?, country_checked = 1 WHERE id = ? AND country_checked = 0'
+    ).run(countryCode, id);
+  }
+
+  // The raw answer, or null when Nominatim has nothing for the position.
+  async function lookup({ lat, lon }, zoom) {
     const base = settings.geocodingUrl.endsWith('/')
       ? settings.geocodingUrl
       : `${settings.geocodingUrl}/`;
@@ -120,7 +150,7 @@ function createPlaceNamer({ db, settings, userAgent, fetch = globalThis.fetch })
     url.searchParams.set('format', 'jsonv2');
     url.searchParams.set('lat', String(lat));
     url.searchParams.set('lon', String(lon));
-    url.searchParams.set('zoom', '17');
+    url.searchParams.set('zoom', String(zoom));
     url.searchParams.set('addressdetails', '1');
 
     const response = await fetch(url, {
@@ -141,7 +171,36 @@ function createPlaceNamer({ db, settings, userAgent, fetch = globalThis.fetch })
       return null;
     }
     const result = await response.json();
-    return result.error ? null : pickName(result);
+    return result.error ? null : result;
+  }
+
+  // What the caller does with a lookup that could not be made or was
+  // interrupted; shared by naming and country lookups.
+  function failure(error) {
+    if (stopping.signal.aborted) {
+      return { outcome: 'stopped' };
+    }
+    failures += 1;
+    return {
+      outcome: 'failed',
+      error,
+      retryInMs: Math.min(FIRST_RETRY_MS * 2 ** (failures - 1), MAX_RETRY_MS)
+    };
+  }
+
+  async function resolveCountry(place) {
+    let result;
+    try {
+      result = await lookup(place, COUNTRY_ZOOM);
+    } catch (error) {
+      return failure(error);
+    }
+    if (stopping.signal.aborted) {
+      return { outcome: 'stopped' };
+    }
+    failures = 0;
+    settleCountry(place, pickCountry(result));
+    return { outcome: 'country', retryInMs: NEXT_LOOKUP_MS };
   }
 
   return {
@@ -151,7 +210,8 @@ function createPlaceNamer({ db, settings, userAgent, fetch = globalThis.fetch })
       }
       const pending = nextPending();
       if (!pending) {
-        return { outcome: 'idle', retryInMs: IDLE_MS };
+        const unchecked = nextPlaceWithoutCountry();
+        return unchecked ? resolveCountry(unchecked) : { outcome: 'idle', retryInMs: IDLE_MS };
       }
 
       // A lookup for a nearby departure or arrival may already have named it.
@@ -161,25 +221,18 @@ function createPlaceNamer({ db, settings, userAgent, fetch = globalThis.fetch })
         return { outcome: 'known', retryInMs: 0 };
       }
 
-      let name;
+      let result;
       try {
-        name = await lookup(pending);
+        result = await lookup(pending, NAME_ZOOM);
       } catch (error) {
-        if (stopping.signal.aborted) {
-          return { outcome: 'stopped' };
-        }
-        failures += 1;
-        return {
-          outcome: 'failed',
-          error,
-          retryInMs: Math.min(FIRST_RETRY_MS * 2 ** (failures - 1), MAX_RETRY_MS)
-        };
+        return failure(error);
       }
       if (stopping.signal.aborted) {
         return { outcome: 'stopped' };
       }
       failures = 0;
 
+      const name = result ? pickName(result) : null;
       if (!name) {
         settle(pending, null);
         return { outcome: 'no_result', retryInMs: NEXT_LOOKUP_MS };
@@ -187,7 +240,7 @@ function createPlaceNamer({ db, settings, userAgent, fetch = globalThis.fetch })
       withTransaction(db, () => {
         const place =
           findNearestPlace(db, pending, settings.placeMatchRadius) ??
-          rememberGeocoded(name, pending);
+          rememberGeocoded(name, pending, pickCountry(result));
         settle(pending, place);
       });
       return { outcome: 'resolved', name, retryInMs: NEXT_LOOKUP_MS };

package/lib/places.js

@@ -54,6 +54,7 @@ function toPlace(row) {
     name: row.name,
     position: { lat: row.lat, lon: row.lon },
     source: row.source,
+    countryCode: row.country_code,
     createdAt: row.created_at,
     updatedAt: row.updated_at
   };

package/lib/statistics.js

@@ -0,0 +1,208 @@
+const { rangeWhere } = require('./entries');
+const { distanceBetween } = require('./places');
+
+const TOP_COUNT = 5;
+
+// Each ranking of the statistics page, sorted on the passage figure of the same name.
+const RANKINGS = ['duration', 'distance', 'averageSpeed', 'maxSpeed', 'maxWindSpeed'];
+
+const seconds = (from, to) => Math.max(0, (Date.parse(to) - Date.parse(from)) / 1000);
+
+const keepHigher = (current, candidate) =>
+  candidate !== null && (current === null || candidate > current) ? candidate : current;
+
+// Highest reading per passage, from the dense track points and the sparse
+// instrument snapshots alike -- the same sources as a single passage's own
+// figures (GET /entries/:id), and the same preference for true wind over apparent.
+function loadPeaks(db, where, params) {
+  const peaks = new Map();
+  const inRange = `entry_id IN (SELECT id FROM log_entries ${where})`;
+  for (const table of ['track_points', 'observations']) {
+    const rows = db
+      .prepare(
+        `SELECT entry_id, MAX(sog) AS speed, MAX(tws) AS tws, MAX(aws) AS aws
+         FROM ${table} WHERE ${inRange} GROUP BY entry_id`
+      )
+      .all(...params);
+    for (const row of rows) {
+      const peak = peaks.get(row.entry_id) ?? { speed: null, tws: null, aws: null };
+      peak.speed = keepHigher(peak.speed, row.speed);
+      peak.tws = keepHigher(peak.tws, row.tws);
+      peak.aws = keepHigher(peak.aws, row.aws);
+      peaks.set(row.entry_id, peak);
+    }
+  }
+  return peaks;
+}
+
+function loadStops(db, where, params) {
+  const stops = new Map();
+  const rows = db
+    .prepare(
+      `SELECT entry_id, time, comment FROM events
+       WHERE type = 'stopover' AND entry_id IN (SELECT id FROM log_entries ${where})
+       ORDER BY entry_id, time`
+    )
+    .all(...params);
+  for (const row of rows) {
+    const list = stops.get(row.entry_id) ?? [];
+    list.push(row);
+    stops.set(row.entry_id, list);
+  }
+  return stops;
+}
+
+// A passage is cut wherever it stopped over -- a lock, a lunch anchorage kept
+// within one entry (SPEC §3.1) -- and each stretch between two stops is measured
+// on its own from the track. A passage that never stopped is one stretch, and
+// its own distance and times stand: no track needs reading for it.
+function legsOf(db, entry, stops, now) {
+  if (stops.length === 0) {
+    return [
+      {
+        entryId: entry.id,
+        startTime: entry.start_time,
+        endTime: entry.end_time,
+        distance: entry.distance,
+        duration: seconds(entry.start_time, entry.end_time ?? now),
+        startPlaceName: entry.start_place_name,
+        endPlaceName: entry.end_place_name
+      }
+    ];
+  }
+
+  const legs = stops.map((stop, index) => ({
+    entryId: entry.id,
+    startTime: index === 0 ? entry.start_time : null,
+    endTime: stop.time,
+    distance: 0,
+    startPlaceName: index === 0 ? entry.start_place_name : stops[index - 1].comment,
+    endPlaceName: stop.comment
+  }));
+  legs.push({
+    entryId: entry.id,
+    startTime: null,
+    endTime: entry.end_time,
+    distance: 0,
+    startPlaceName: stops[stops.length - 1].comment,
+    endPlaceName: entry.end_place_name
+  });
+
+  let leg = 0;
+  let previous = null;
+  const points = db
+    .prepare('SELECT time, lat, lon FROM track_points WHERE entry_id = ? ORDER BY time')
+    .iterate(entry.id);
+  for (const point of points) {
+    // A point at the very moment of a stop still belongs to the stretch that
+    // ended there.
+    while (leg < stops.length && point.time > stops[leg].time) {
+      leg += 1;
+      previous = null;
+    }
+    // A stretch starts when the vessel got under way again: its first point.
+    legs[leg].startTime ??= point.time;
+    if (previous) {
+      legs[leg].distance += distanceBetween(previous, point);
+    }
+    previous = point;
+  }
+
+  // A stretch with no track has no distance to speak of, and no start time
+  // either; it cannot be the longest.
+  return legs
+    .filter((candidate) => candidate.startTime !== null)
+    .map((candidate) => ({
+      ...candidate,
+      duration: seconds(candidate.startTime, candidate.endTime ?? now)
+    }));
+}
+
+// Countries reached by a departure or an arrival in the range, in order of the
+// first visit. A place whose country is not known yet -- geocoding off, or not
+// answered so far -- is simply not counted.
+function loadCountries(db, where, params, now) {
+  return db
+    .prepare(
+      `SELECT places.country_code AS code, MIN(visit.time) AS firstTime
+       FROM (
+         SELECT start_place_id AS place_id, start_time AS time FROM log_entries ${where}
+         UNION ALL
+         SELECT end_place_id, COALESCE(end_time, ?) FROM log_entries ${where}
+       ) AS visit
+       JOIN places ON places.id = visit.place_id
+       WHERE places.country_code IS NOT NULL
+       GROUP BY places.country_code
+       ORDER BY firstTime, code`
+    )
+    .all(...params, now, ...params);
+}
+
+// Figures across every passage the range matches (SPEC §4.14). A passage still
+// in progress counts as it stands, as in GET /entries/stats.
+function getStatistics(db, { from, to, now }) {
+  const { where, params } = rangeWhere({ from, to });
+  const entries = db
+    .prepare(`SELECT * FROM log_entries ${where} ORDER BY start_time, id`)
+    .all(...params);
+  const peaks = loadPeaks(db, where, params);
+  const stops = loadStops(db, where, params);
+
+  const passages = entries.map((entry) => {
+    const peak = peaks.get(entry.id) ?? { speed: null, tws: null, aws: null };
+    const duration = seconds(entry.start_time, entry.end_time ?? now);
+    return {
+      id: entry.id,
+      startTime: entry.start_time,
+      endTime: entry.end_time,
+      startPlaceName: entry.start_place_name,
+      endPlaceName: entry.end_place_name,
+      startPlacePending: entry.start_place_pending === 1,
+      endPlacePending: entry.end_place_pending === 1,
+      distance: entry.distance,
+      duration,
+      averageSpeed: duration > 0 ? entry.distance / duration : null,
+      maxSpeed: peak.speed,
+      maxWindSpeed: peak.tws ?? peak.aws,
+      maxWindApparent: peak.tws === null && peak.aws !== null
+    };
+  });
+
+  const top = {};
+  for (const ranking of RANKINGS) {
+    top[ranking] = passages
+      .filter((passage) => passage[ranking] !== null && passage[ranking] > 0)
+      .sort(
+        (a, b) => b[ranking] - a[ranking] || b.startTime.localeCompare(a.startTime) || b.id - a.id
+      )
+      .slice(0, TOP_COUNT);
+  }
+
+  let longestNonStop = null;
+  for (const entry of entries) {
+    for (const leg of legsOf(db, entry, stops.get(entry.id) ?? [], now)) {
+      if (leg.distance > 0 && (longestNonStop === null || leg.distance > longestNonStop.distance)) {
+        longestNonStop = leg;
+      }
+    }
+  }
+
+  return {
+    count: passages.length,
+    distance: passages.reduce((sum, passage) => sum + passage.distance, 0),
+    duration: Math.round(passages.reduce((sum, passage) => sum + passage.duration, 0)),
+    firstTime: passages[0]?.startTime ?? null,
+    lastTime: passages.reduce((latest, passage) => {
+      const end = passage.endTime ?? now;
+      return latest === null || end > latest ? end : latest;
+    }, null),
+    maxSpeed: top.maxSpeed[0]?.maxSpeed ?? null,
+    maxWindSpeed: top.maxWindSpeed[0]?.maxWindSpeed ?? null,
+    maxWindApparent: top.maxWindSpeed[0]?.maxWindApparent ?? false,
+    longestNonStop,
+    countries: loadCountries(db, where, params, now),
+    top
+  };
+}
+
+module.exports = { getStatistics, TOP_COUNT };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-chiplog",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "description": "Nautical logbook for Signal K: automatic entries, handwritten notes",
   "main": "index.js",
   "files": [