signalk-chiplog 2.3.0 → 2.4.0

package/CHANGELOG.md

@@ -6,6 +6,47 @@ 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
+
+- **Retrospective analysis now shows what has been reconstructed so far while it is still running**, not only once it
+  finishes: passages, distance, engine/sail time, track points and events update after every committed slice instead of
+  only the clock position. A run that fails partway — an InfluxDB query timing out on a slow host — keeps that same
+  summary next to the error, instead of leaving a bare error message with no way to tell what was saved.
+- **A retrospective replay retries an InfluxDB query that times out** up to 3 times, 5 seconds apart, instead of failing
+  the whole run on what is often just a Raspberry Pi momentarily busy sharing its InfluxDB with Signal K itself; the
+  webapp shows which attempt is under way while it waits. The timeout covers the whole round trip, including a chunk's
+  JSON still streaming in after the connection answered, not just getting a connection in the first place. Each window
+  of history is also fetched in smaller, two-hour chunks instead of six, so a slow host has less to answer per request.
+
+### Fixed
+
+- **A retrospective replay running alongside live tracking** could have a live detection tick, track sample or event
+  check land on the passage the replay was reconstructing — mistaking it for the current one, since both read the same
+  `active` row — and close it early or splice live position and instrument data into a past passage. Live detection,
+  track sampling and event watching now pause for as long as a replay is running.
+
 ## [2.3.0] - 2026-09-18
 
 ### Added
@@ -266,7 +307,9 @@ 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.0...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
 [2.1.0]: https://github.com/ricard33/signalk-chiplog/compare/v2.0.0...v2.1.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/index.js

@@ -274,6 +274,20 @@ module.exports = function (app) {
   };
 
   function runDetection() {
+    // A retrospective replay drives the same detector against a past window,
+    // holding its own passage 'active' in log_entries for as long as it takes
+    // to close it there — live detection, track sampling and event watching
+    // must not touch that row in the meantime, or a live tick would treat a
+    // reconstructed passage as the current one and close it early or splice
+    // live data into it.
+    if (replayJob?.status().running) {
+      const status = 'Retrospective replay in progress — live tracking paused';
+      if (status !== lastStatus) {
+        app.setPluginStatus(status);
+        lastStatus = status;
+      }
+      return;
+    }
     try {
       const outcome = detector.tick();
       usbExport.afterDetection(outcome);
@@ -471,11 +485,19 @@ module.exports = function (app) {
     timers = [
       setInterval(runDetection, TICK_INTERVAL_MS),
       setInterval(
-        guarded('Track recording', () => recorder.sample()),
+        guarded('Track recording', () => {
+          if (!replayJob?.status().running) {
+            recorder.sample();
+          }
+        }),
         SAMPLE_INTERVAL_MS
       ),
       setInterval(
-        guarded('Event watching', () => watcher.check()),
+        guarded('Event watching', () => {
+          if (!replayJob?.status().running) {
+            watcher.check();
+          }
+        }),
         CHECK_INTERVAL_MS
       ),
       setInterval(

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/influx-history.js

@@ -18,13 +18,19 @@ const DEFAULT_QUERY_TIMEOUT_SECONDS = 30;
 
 // A resource-constrained host (a Raspberry Pi running both Signal K and
 // InfluxDB) can be brought down by one query spanning weeks across every
-// path at once; six hours at a time keeps each request's result small
+// path at once; two hours at a time keeps each request's result small
 // regardless of how long the requested range is, with a short pause between
 // them so the database is never asked for the next one while still
 // recovering from the last.
-const CHUNK_MS = 6 * 60 * 60 * 1000;
+const CHUNK_MS = 2 * 60 * 60 * 1000;
 const CHUNK_PAUSE_MS = 200;
 
+// A query that times out is retried rather than failing the whole replay
+// outright -- a Raspberry Pi sharing its InfluxDB with Signal K itself is
+// often just busy for a moment, not actually unreachable.
+const QUERY_MAX_RETRIES = 3;
+const QUERY_RETRY_DELAY_MS = 5 * 1000;
+
 // The motion scan asks for one mean per minute, light enough to cover a week
 // per request.
 const SCAN_BUCKET_MS = 60 * 1000;
@@ -112,7 +118,9 @@ function createInfluxHistory({
   selfContext,
   queryTimeoutSeconds = INFLUX_DEFAULTS.influxQueryTimeoutSeconds,
   fetch = globalThis.fetch,
-  signal
+  signal,
+  onRetry = () => {},
+  retryDelayMs = QUERY_RETRY_DELAY_MS
 }) {
   const queryTimeoutMs = queryTimeoutSeconds * 1000;
   // path -> [{ time, node }], ascending by time; `node` is what readSelfPath
@@ -136,36 +144,59 @@ function createInfluxHistory({
       epoch: 'ms',
       q: statements.join(';')
     });
-    const timeout = AbortSignal.timeout(queryTimeoutMs);
-    let response;
-    try {
-      response = await fetch(url, {
-        method: 'POST',
-        headers,
-        body,
-        signal: signal ? AbortSignal.any([timeout, signal]) : timeout
-      });
-    } catch (err) {
-      if (signal?.aborted) {
-        throw err;
-      }
-      if (err.name === 'TimeoutError') {
+
+    // One full round trip: the timeout signal covers reading the response
+    // body too, not just getting the headers back, so a database that is slow
+    // to stream a large chunk's JSON times out here just as it would waiting
+    // for the connection -- both must retry the same way.
+    async function attempt() {
+      const timeout = AbortSignal.timeout(queryTimeoutMs);
+      let response;
+      try {
+        response = await fetch(url, {
+          method: 'POST',
+          headers,
+          body,
+          signal: signal ? AbortSignal.any([timeout, signal]) : timeout
+        });
+      } catch (err) {
+        if (signal?.aborted || err.name === 'TimeoutError') {
+          throw err;
+        }
+        // Node's fetch wraps a connection failure (wrong host, refused,
+        // certificate…) as a bare "fetch failed"; the actual reason is here.
         throw new Error(
-          `InfluxDB at ${protocol}://${host}:${port} did not answer within ${queryTimeoutSeconds}s`,
+          `Could not reach InfluxDB at ${protocol}://${host}:${port}: ${err.cause?.message ?? err.message}`,
           { cause: err }
         );
       }
-      // Node's fetch wraps a connection failure (wrong host, refused,
-      // certificate…) as a bare "fetch failed"; the actual reason is here.
-      throw new Error(
-        `Could not reach InfluxDB at ${protocol}://${host}:${port}: ${err.cause?.message ?? err.message}`,
-        { cause: err }
-      );
+      if (!response.ok) {
+        throw new Error(`InfluxDB query failed: ${response.status} ${await response.text()}`);
+      }
+      return response.json();
     }
-    if (!response.ok) {
-      throw new Error(`InfluxDB query failed: ${response.status} ${await response.text()}`);
+
+    let payload;
+    // Each attempt gets its own full timeout budget, not a shared one left
+    // over from the last -- a query that timed out once is retried outright,
+    // not with less time to answer than before.
+    for (let retries = 0; ; retries += 1) {
+      try {
+        payload = await attempt();
+        onRetry(null);
+        break;
+      } catch (err) {
+        if (signal?.aborted || err.name !== 'TimeoutError') {
+          throw err;
+        }
+        const message = `InfluxDB at ${protocol}://${host}:${port} did not answer within ${queryTimeoutSeconds}s`;
+        if (retries >= QUERY_MAX_RETRIES) {
+          throw new Error(message, { cause: err });
+        }
+        onRetry(retries + 1, QUERY_MAX_RETRIES, message);
+        await sleep(retryDelayMs);
+      }
     }
-    const payload = await response.json();
     return payload.results.map((result) => {
       if (result.error) {
         throw new Error(`InfluxDB query error: ${result.error}`);
@@ -482,4 +513,4 @@ function createInfluxHistory({
   return { preload, clear, scanMotion, readSelfPath };
 }
 
-module.exports = { createInfluxHistory, INFLUX_DEFAULTS };
+module.exports = { createInfluxHistory, INFLUX_DEFAULTS, CHUNK_MS, QUERY_MAX_RETRIES };

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/replay-job.js

@@ -13,7 +13,8 @@ function createReplayJob({
   clock = Date.now,
   log = () => {},
   fetch = globalThis.fetch,
-  onDone = () => {}
+  onDone = () => {},
+  retryDelayMs
 }) {
   let current = null;
   let lastResult = null;
@@ -73,7 +74,19 @@ function createReplayJob({
       selfContext: settings.influxSelfContext || app.selfContext,
       queryTimeoutSeconds: settings.influxQueryTimeoutSeconds,
       fetch,
-      signal
+      signal,
+      retryDelayMs,
+      onRetry: (attempt, of, message) => {
+        if (attempt !== null) {
+          log(
+            'error',
+            `Retrospective replay: InfluxDB query timed out, retrying (attempt ${attempt}/${of}): ${message}`
+          );
+        }
+        if (current) {
+          current.retry = attempt === null ? null : { attempt, of, message };
+        }
+      }
     });
     try {
       await runWindowedReplay({
@@ -91,6 +104,11 @@ function createReplayJob({
         onProgress: (nowMs) => {
           if (current) {
             current.now = iso(nowMs);
+            // Recomputed each slice so the webapp can show what has actually
+            // been committed so far, not just how far the clock has got --
+            // the only way to know anything was saved if the run then times
+            // out or otherwise fails.
+            current.summary = summarise(afterId, to);
           }
         }
       });
@@ -105,7 +123,13 @@ function createReplayJob({
           summary: summarise(afterId, to)
         };
       } else {
-        lastError = { at: iso(clock()), from, to, message: err.message };
+        lastError = {
+          at: iso(clock()),
+          from,
+          to,
+          message: err.message,
+          summary: summarise(afterId, to)
+        };
         log('error', `Retrospective replay failed (${from} to ${to}): ${err.message}`);
       }
     } finally {
@@ -141,7 +165,15 @@ function createReplayJob({
         );
       }
       const controller = new AbortController();
-      current = { from, to, startedAt: iso(clock()), now: from, phase: 'scanning', controller };
+      current = {
+        from,
+        to,
+        startedAt: iso(clock()),
+        now: from,
+        phase: 'scanning',
+        retry: null,
+        controller
+      };
       lastError = null;
       perform(from, to, controller.signal);
       return { from, to };
@@ -163,7 +195,9 @@ function createReplayJob({
           from: current.from,
           to: current.to,
           now: current.now,
-          phase: current.phase
+          phase: current.phase,
+          summary: current.summary ?? null,
+          retry: current.retry
         },
         lastResult,
         lastError