signalk-chiplog 1.1.0 → 2.0.0

package/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to Chiplog are documented here. The format follows [Keep a C
 
 ## [Unreleased]
 
+## [2.0.0] - 2026-09-16
+
+### Added
+
+- The passage page has a **Boat status** card: each engine's hour counter, at departure and arrival, and every tank's level (and volume) and every battery's charge, voltage and current as noted at departure. Tanks and batteries are noted once on the passage as it opens (`startTanks`, `startBatteries`), whether detection or the crew opens it, and included in the JSON export.
+- Merging two entries now keeps a record of the stop between them: a `stopover` line on the surviving passage's timeline, naming the place and its position — previously that information was silently lost once the merge took the later entry's arrival as its own.
+- The passage page's track map now shows a small boat marker at the selected point, pointing along its heading, and a scrubber under the map to step back and forth through the track's history — it defaults to the latest point, doubling as the current position on a passage in progress. A band below it shows that point's time, SOG, COG, STW, TWS, TWD, TWA and AWA. Speed through water now rides along with every track point like wind and heading already did, not just the hourly instrument snapshot.
+- Retrospective analysis: a new **Retrospective** page reconstructs past passages for a date range from a [signalk-to-influxdb](https://github.com/tkurki/signalk-to-influxdb) history (InfluxDB 1.x, local or remote — a new recommended companion plugin), through the exact same detection pipeline used live rather than a separate implementation. Runs in the background with a progress bar, refuses a range that overlaps a passage already on record, refuses to run at all while a passage is under way (it would be driving that same live passage through the replay's detector at the same time), and can be cancelled mid-way without losing what it already reconstructed. Data is matched to this server's own vessel identity by default, overridable (`influxSelfContext`) for running it from a different Signal K server than the one that wrote the history; a mismatch fails with the vessel contexts actually found, rather than reconstructing nothing with no explanation. An InfluxDB that never answers — unreachable, or overloaded — fails after 30 seconds with the actual connection problem, rather than hanging indefinitely on a generic "fetch failed". A quick first pass reads one mean speed per minute to find when the boat moved, and only those stretches are then fetched — one value per track interval — and replayed, committing once per ten simulated minutes, and the page sums up what a run added (passages, distance, engine and sail time, track points, events): a month now takes seconds rather than the best part of an hour, and no longer holds every raw reading of the range in memory. Requests stay bounded (a week for the scan, six hours for a stretch) with a short pause between them, so a multi-week reconstruction cannot overwhelm a database sharing a resource-constrained host (a Raspberry Pi) with Signal K itself; cancelling works at any stage. A replay wakes the place-naming lookup immediately once it finishes, rather than leaving newly-reconstructed departures and arrivals waiting out whatever backoff that chain was already in. Signal K alarms are not reconstructed, since a typical InfluxDB history does not archive notifications the way it does a numeric reading, nor are weather events while the boat lay still between passages, nor the extra track points live recording adds on turns and speed changes.
+
+### Fixed
+
+- The arrival instrument snapshot (`entry_end`) is now dated from the moment the passage actually ended, not from the later tick that found out about it once the stop had held past the closure threshold (up to `stopClosureMinutes`) — it could otherwise sort after an hourly reading taken during that wait, even though the passage had already ended before that reading was taken.
+
+## [1.2.0] - 2026-09-15
+
+### Added
+
+- The tablet app's handwriting pad now fills the whole screen and has a toolbar: fine pen, thick pen, highlighter, eraser, undo and a choice of colour (kept to the theme's colour in night mode). The eraser removes only the points it touches, splitting a stroke instead of deleting all of it; undo now steps back through erasing too, not just strokes. A stroke's colour and tool travel with it to the webapp's timeline and the PDF export, not just the tablet.
+
+### Fixed
+
+- The tablet app's stylus canvas now prevents the default action on every contact, not just the pen's — a resting palm's touch was left to the browser, which could hijack it as a gesture and cancel the pen's in-progress stroke, or show a native text-selection highlight over the canvas. iOS Safari's long-press selection callout on the canvas needed the whole entry app, not just the canvas, to opt out of selection to reliably stay away, plus blocking `selectstart`/`contextmenu`/`dragstart` directly since the CSS alone is unreliable on some iOS versions.
+- Quickly lifting and reapplying the pen could have its next stroke silently dropped: the previous contact's pointerup can arrive after the next one's pointerdown, which read as "still drawing" and refused to start the new stroke.
+- Worked around an iPadOS Safari/Scribble bug that could swallow a pen's pointer events mid-stroke, dropping strokes or having them mistakenly typed into the comment field, by also preventing the canvas's underlying touch events directly, not just the pointer ones.
+- An autopilot engagement, disengagement or mode change now takes an instrument snapshot like every other automatic event, instead of logging the change with no conditions attached.
+
 ## [1.1.0] - 2026-09-15
 
 ### Added
@@ -76,6 +102,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/v1.1.0...HEAD
+[Unreleased]: https://github.com/ricard33/signalk-chiplog/compare/v2.0.0...HEAD
+[2.0.0]: https://github.com/ricard33/signalk-chiplog/compare/v1.2.0...v2.0.0
+[1.2.0]: https://github.com/ricard33/signalk-chiplog/compare/v1.1.0...v1.2.0
 [1.1.0]: https://github.com/ricard33/signalk-chiplog/compare/v1.0.0...v1.1.0
 [1.0.0]: https://github.com/ricard33/signalk-chiplog/releases/tag/v1.0.0

package/README.md

@@ -23,6 +23,7 @@ English and French, chosen from the browser's language.
 - [Configuration](#configuration)
 - [Signal K data used](#signal-k-data-used)
 - [Backups and abandon ship](#backups-and-abandon-ship)
+- [Retrospective analysis](#retrospective-analysis)
 - [Privacy and online services](#privacy-and-online-services)
 - [Troubleshooting](#troubleshooting)
 - [Limitations](#limitations)
@@ -68,7 +69,7 @@ A **passage** is one logbook entry: from leaving a berth or anchorage to arrivin
 - **Power cuts and restarts.** If the server comes back after the boat has been still for longer than the tolerance, the passage is closed at its last movement. A short restart carries on with the same passage.
 - **Under way or stopped** comes from `navigation.state` when signalk-autostate provides it. Otherwise Chiplog averages speed over ground over 3 minutes: under way above 1 knot, stopped below half a knot. This keeps a boat swinging at anchor from starting passages.
 
-A passage that was split in two — a stop just longer than the tolerance, for instance — can be merged back from the logbook webapp.
+A passage that was split in two — a stop just longer than the tolerance, for instance — can be merged back from the logbook webapp. The stop the merge folds away is kept on the timeline as its own line, naming the place, since it would otherwise leave no trace once the merge takes the later passage's arrival as its own.
 
 ### Track and distance
 
@@ -120,7 +121,7 @@ Open **Chiplog** from the Signal K webapps, or `/signalk-chiplog/`. Reading need
 
 - **Status bar** — under way under sail or engine, stopped, or waiting for data, with a link to the passage in progress. A warning shows when detection works from speed alone because signalk-autostate is missing.
 - **Logbook** — a summary above the list (number of passages, total distance, total time, across every passage logged, 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, and the highest speed and wind seen), map of the track (OpenStreetMap with OpenSeaMap seamarks, which can be hidden), the tide forecast near the departure (place, high/low times and heights, height curve) when one was fetched, the engine and sail periods with each engine's hour counter at departure and arrival and the hours run, 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.
+- **Passage page** — summary (distance, duration, average speed, and the highest speed and wind seen), 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 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.
 - **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;
@@ -128,6 +129,7 @@ Open **Chiplog** from the Signal K webapps, or `/signalk-chiplog/`. Reading need
   - merge with the previous or next passage;
   - delete a passage (admin).
 - **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)).
 
 **Helm entry** in the top bar opens the tablet entry app.
 
@@ -153,9 +155,9 @@ Other entries made with no passage open go to the last passage if the boat is st
 ### Notes and handwriting
 
 - **Note** — type and tap **Log it**.
-- **Handwriting** — write or draw on the pad with a stylus or a finger, optionally add a comment, and tap **Log it**. Pen pressure sets the line width. **Undo stroke** and **Clear** fix mistakes. Once a stylus has touched the pad, fingers are ignored, so a palm resting on the screen does not draw.
+- **Handwriting** — takes over the whole screen, with a toolbar above the pad: fine pen, thick pen, highlighter, eraser, undo, and a choice of colour (kept to the theme's colour in night mode, to spare night vision). Pen pressure also sets the line width. The eraser removes only what it actually touches, splitting a stroke rather than deleting all of it; undo steps back through strokes and erasing alike. Once a stylus has touched the pad, fingers are ignored, so a palm resting on the screen does not draw. Add a comment and tap **Log it** to send.
 
-Handwritten notes appear as drawn in the logbook's timeline.
+Handwritten notes appear as drawn — colour, pen or highlighter included — in the logbook's timeline and in the PDF export, not just on the tablet.
 
 ### Latest entries
 
@@ -187,25 +189,31 @@ To revoke it, delete the device under **Security → Devices**: the tablet asks
 
 In the Signal K admin, **Apps & Plugins → Configuration → Chiplog**.
 
-| Setting                                            | Default                                       | What it does                                                                                            |
-| -------------------------------------------------- | --------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
-| Stop duration that ends a passage                  | 30 min                                        | Shorter stops stay within the same passage.                                                             |
-| Under-way speed without navigation.state           | 1 kn                                          | Used only without signalk-autostate: under way above it, stopped below half of it.                      |
-| Propulsion assumed without engine data             | sail                                          | When nothing says whether the engine is running. Set to engine on a motorboat.                          |
-| Instrument snapshot interval                       | 60 min                                        | Readings on this clock boundary during a passage.                                                       |
-| Track point interval                               | 15 s                                          | A track point at least this often while moving.                                                         |
-| Place matching radius                              | 200 m                                         | A departure or arrival this close to a known place takes its name.                                      |
-| Name departures and arrivals with online geocoding | on                                            | Turn off to never send positions online; places are then named after their coordinates until corrected. |
-| Geocoding service                                  | `https://nominatim.openstreetmap.org`         | Any Nominatim-compatible service, e.g. a self-hosted one.                                               |
-| Fetch the tide forecast at departure               | on                                            | Turn off to never send the departure position online; the passage page then shows no tide.              |
-| Tide service                                       | `https://marine-api.open-meteo.com/v1/marine` | Any Open-Meteo Marine-compatible service, e.g. a self-hosted one.                                       |
-| USB export directory                               | —                                             | Where the abandon-ship copy is written, e.g. `/media/usb`. Empty turns the USB copy off.                |
-| Automatic USB copy interval                        | 15 min                                        | How often the USB copy is brought up to date. 0 turns the periodic copy off.                            |
-| Copy to the USB drive at each arrival              | on                                            | Brings the USB copy up to date as soon as a passage ends.                                               |
-| Logbook language (PDF)                             | en                                            | Language of the PDF logbooks on the USB drive (English or French).                                      |
-| Ship's time zone (PDF)                             | the server's                                  | Time zone of the PDF logbooks on the USB drive, e.g. `Europe/Paris`.                                    |
-| Wind speed thresholds                              | 20, 30 kn                                     | Logged when the 2-minute average true wind crosses them.                                                |
-| Barometric drop warning                            | 4 hPa / 3 h                                   | 0 turns it off.                                                                                         |
+| Setting                                            | Default                                       | What it does                                                                                                                                            |
+| -------------------------------------------------- | --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Stop duration that ends a passage                  | 30 min                                        | Shorter stops stay within the same passage.                                                                                                             |
+| Under-way speed without navigation.state           | 1 kn                                          | Used only without signalk-autostate: under way above it, stopped below half of it.                                                                      |
+| Propulsion assumed without engine data             | sail                                          | When nothing says whether the engine is running. Set to engine on a motorboat.                                                                          |
+| Instrument snapshot interval                       | 60 min                                        | Readings on this clock boundary during a passage.                                                                                                       |
+| Track point interval                               | 15 s                                          | A track point at least this often while moving.                                                                                                         |
+| Place matching radius                              | 200 m                                         | A departure or arrival this close to a known place takes its name.                                                                                      |
+| Name departures and arrivals with online geocoding | on                                            | Turn off to never send positions online; places are then named after their coordinates until corrected.                                                 |
+| Geocoding service                                  | `https://nominatim.openstreetmap.org`         | Any Nominatim-compatible service, e.g. a self-hosted one.                                                                                               |
+| Fetch the tide forecast at departure               | on                                            | Turn off to never send the departure position online; the passage page then shows no tide.                                                              |
+| Tide service                                       | `https://marine-api.open-meteo.com/v1/marine` | Any Open-Meteo Marine-compatible service, e.g. a self-hosted one.                                                                                       |
+| USB export directory                               | —                                             | Where the abandon-ship copy is written, e.g. `/media/usb`. Empty turns the USB copy off.                                                                |
+| Automatic USB copy interval                        | 15 min                                        | How often the USB copy is brought up to date. 0 turns the periodic copy off.                                                                            |
+| Copy to the USB drive at each arrival              | on                                            | Brings the USB copy up to date as soon as a passage ends.                                                                                               |
+| Logbook language (PDF)                             | en                                            | Language of the PDF logbooks on the USB drive (English or French).                                                                                      |
+| Ship's time zone (PDF)                             | the server's                                  | Time zone of the PDF logbooks on the USB drive, e.g. `Europe/Paris`.                                                                                    |
+| Wind speed thresholds                              | 20, 30 kn                                     | Logged when the 2-minute average true wind crosses them.                                                                                                |
+| Barometric drop warning                            | 4 hPa / 3 h                                   | 0 turns it off.                                                                                                                                         |
+| InfluxDB host (retrospective analysis)             | —                                             | Local or remote host of the InfluxDB 1.x database signalk-to-influxdb writes to. Empty turns the retrospective analysis page off.                       |
+| InfluxDB port                                      | 8086                                          |                                                                                                                                                         |
+| InfluxDB database                                  | —                                             |                                                                                                                                                         |
+| InfluxDB username / password                       | —                                             | Leave empty if the database needs none.                                                                                                                 |
+| InfluxDB protocol                                  | http                                          | `http` or `https`.                                                                                                                                      |
+| InfluxDB vessel context                            | this server's own                             | Only needed running the replay from a different Signal K server than the one that wrote the history, e.g. development pointed at a production database. |
 
 ## Signal K data used
 
@@ -216,6 +224,7 @@ None of these is required except position and speed over ground; each feature us
 | Passages, track, distance | `navigation.position`, `navigation.speedOverGround`, `navigation.courseOverGroundTrue`, `navigation.state`                                                                                                                                                                                                                         |
 | Engine or sail            | `propulsion.*.revolutions`, `propulsion.*.state`, `navigation.state`                                                                                                                                                                                                                                                               |
 | Readings                  | `navigation.headingTrue` (or `headingMagnetic` + `magneticVariation`), `navigation.speedThroughWater`, `environment.wind.*`, `environment.depth.belowSurface` (or `belowTransducer`), `environment.outside.pressure`, `environment.outside.temperature`, `environment.water.temperature`, `navigation.log`, `propulsion.*.runTime` |
+| Boat status               | `tanks.*.*.currentLevel`, `.currentVolume`, `.capacity`, `.name`, `electrical.batteries.*.voltage`, `.current`, `.capacity.stateOfCharge`, `.temperature`, `.name`                                                                                                                                                                 |
 | Events                    | `notifications.*`, `steering.autopilot.state`, `.mode`, `.engaged`, `.target`, `environment.wind.speedTrue`, `environment.outside.pressure`                                                                                                                                                                                        |
 
 ## Backups and abandon ship
@@ -227,11 +236,22 @@ None of these is required except position and speed over ground; each feature us
   - The Export page shows the schedule, the last copy, the next one, and the last failure if any.
 - **The database** — `chiplog.sqlite` in the plugin's data folder can be copied while the plugin is stopped.
 
+## Retrospective analysis
+
+Already have a history of the boat's Signal K data before Chiplog was installed, or from a period the plugin was stopped? The **Retrospective** page (admin access) reconstructs those passages from it, using the exact same detection Chiplog runs live — the same thresholds, so a reconstructed passage is one Chiplog would have logged had it been running at the time.
+
+- **Requires [signalk-to-influxdb](https://github.com/tkurki/signalk-to-influxdb)** (a recommended companion plugin) already having written the boat's data into an InfluxDB 1.x database — local or on another machine, set in **Apps & Plugins → Configuration**: host, port, database, and a username/password if it needs one.
+- Pick a **from** and **to** date on the Retrospective page and start it. It runs in the background — the page shows its progress — and can be cancelled at any point; a first quick pass finds when the boat moved, and only those stretches are then fetched and reconstructed, so weeks in port take next to no time. Once done, the page sums up what it added: passages, distance, time under engine and sail, track points and events; what was already reconstructed up to that point stays on record.
+- **Refuses to run while a passage is under way**, whatever the date range asked for — it would be reconstructing history through the same detection that is simultaneously tracking the live passage.
+- **Refuses a range that overlaps a passage already logged**, to avoid a duplicate or a conflicting one. Reconstruction only ever adds passages; it does not edit or merge into an existing one.
+- **What is not reconstructed**: Signal K alarms and emergencies (`sk_alarm` events), since a typical InfluxDB history does not archive notifications the way it does a numeric reading; strong-wind and falling-barometer events while the boat lay still between passages; and the extra track points recorded live on turns and speed changes — a reconstructed track has one point per **Track point interval**. Everything else read from a continuously published path — position, speed, wind, engine, autopilot, depth, barometer — is reconstructed the same as live.
+
 ## Privacy and online services
 
 - **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.
 - **Tide forecast.** With it on, the departure position of each passage is sent to the tide service — the public Open-Meteo by default — once, at departure. Nothing at all when it is off.
 - **Maps.** The logbook webapp loads map tiles from OpenStreetMap and OpenSeaMap while the device viewing it is online. Offline, the track is still drawn, on a blank background.
+- **Retrospective analysis.** Running one queries the InfluxDB database set in the plugin configuration — the boat's own, local or remote, never a third party — for the Signal K history in the requested range.
 - **Nothing else** leaves the boat. There is no account, analytics or cloud service.
 
 Map data and place names © OpenStreetMap contributors (ODbL); seamarks © OpenSeaMap; tide data © [Open-Meteo.com](https://open-meteo.com/) (CC BY 4.0).
@@ -279,6 +299,26 @@ The USB drive is not mounted at the configured directory, or cannot be written.
 
 The server's clock is wrong — common on a Raspberry Pi without a real-time clock. Set it from GPS with `signalk-set-system-time`.
 
+### Handwriting strokes are dropped or turn into typed text
+
+On an iPad, this is Apple's **Scribble** intercepting the Apple Pencil before the page sees it — a known iPadOS/Safari limitation with no web-page-level fix (Scribble runs beneath the browser). If it happens often, turn Scribble off under **Settings → Apple Pencil → Scribble**; a tablet dedicated to Chiplog does not need it.
+
+### A retrospective analysis finishes but reconstructs nothing
+
+Signal K tags historical data with the vessel it came from; a replay only reads data tagged for its own vessel. This shows up running the replay from a different Signal K server than the one that wrote the history — a development instance pointed at a production database, typically — since each server has its own vessel identity by default. The replay's error names the vessel contexts it actually found in the database; set the matching one as **InfluxDB vessel context** in the plugin configuration.
+
+### A retrospective analysis takes minutes then fails with no clear reason
+
+The InfluxDB server did not answer — unreachable, overloaded, a firewall or a VPN not connected. Each query now gives up after 30 seconds with the connection problem it ran into, rather than hanging until some far longer, less informative failure; check that the server named in the plugin configuration is reachable from wherever Signal K runs, and that it is not overloaded.
+
+### A retrospective analysis over several days makes the InfluxDB server unresponsive
+
+The replay first reads one mean speed per minute, a week at a time, then fetches only the stretches where the boat moved, six hours at a time and already reduced to one value per track interval, with a short pause between requests, specifically so this does not happen — a boat's InfluxDB often shares a resource-constrained host (a Raspberry Pi) with Signal K itself, and one query spanning weeks across every path at once can overwhelm it. If it still struggles on a very small or busy host, run the reconstruction over shorter date ranges instead of the whole history at once.
+
+### Reconstructed passages keep their provisional place names for a while
+
+A replay wakes the geocoding lookup as soon as it finishes, but the lookup itself still needs internet access to succeed — the passage page shows the raw coordinates until it does. If the boat (or the Signal K server running the replay) has no internet access at the time, naming is retried on the same backoff as any other departure or arrival, up to an hour between attempts; nothing is lost, it just takes longer to resolve.
+
 ## Limitations
 
 - **Not yet:** a places page, and editing manoeuvre shortcuts from the webapps.

package/index.js

@@ -3,9 +3,11 @@ const { openDatabase } = require('./lib/database');
 const { createPassageDetector, DETECTION_DEFAULTS, TICK_INTERVAL_MS } = require('./lib/detection');
 const { ApiError } = require('./lib/errors');
 const { createEventWatcher, CHECK_INTERVAL_MS, EVENT_DEFAULTS } = require('./lib/event-watcher');
+const { INFLUX_DEFAULTS } = require('./lib/influx-history');
 const { OBSERVATION_DEFAULTS } = require('./lib/observation-recorder');
 const { createPlaceNamer, GEOCODING_DEFAULTS } = require('./lib/place-names');
 const { PROPULSION_DEFAULTS } = require('./lib/propulsion-detector');
+const { createReplayJob } = require('./lib/replay-job');
 const { createTideForecaster, TIDE_DEFAULTS } = require('./lib/tide-forecaster');
 const { createTrackRecorder, SAMPLE_INTERVAL_MS, TRACK_DEFAULTS } = require('./lib/track-recorder');
 const {
@@ -55,6 +57,7 @@ module.exports = function (app) {
   let namer = null;
   let tideForecaster = null;
   let usbExport = null;
+  let replayJob = null;
   let namingTimer = null;
   let tideTimer = null;
   let timers = [];
@@ -188,6 +191,43 @@ module.exports = function (app) {
           'The log records a pressure fall of at least this much over three hours; 0 disables it',
         default: EVENT_DEFAULTS.pressureDropThreshold,
         minimum: 0
+      },
+      influxHost: {
+        type: 'string',
+        title: 'InfluxDB host (retrospective analysis)',
+        description:
+          'For reconstructing past passages from a signalk-to-influxdb history (InfluxDB 1.x), local or remote. Leave empty to turn that feature off'
+      },
+      influxPort: {
+        type: 'number',
+        title: 'InfluxDB port',
+        default: INFLUX_DEFAULTS.influxPort
+      },
+      influxDatabase: {
+        type: 'string',
+        title: 'InfluxDB database'
+      },
+      influxUsername: {
+        type: 'string',
+        title: 'InfluxDB username',
+        description: 'Leave empty if the database needs none'
+      },
+      influxPassword: {
+        type: 'string',
+        title: 'InfluxDB password',
+        format: 'password'
+      },
+      influxProtocol: {
+        type: 'string',
+        title: 'InfluxDB protocol',
+        enum: ['http', 'https'],
+        default: INFLUX_DEFAULTS.influxProtocol
+      },
+      influxSelfContext: {
+        type: 'string',
+        title: 'InfluxDB vessel context',
+        description:
+          'Only needed running the replay from a different Signal K server than the one that wrote the history — e.g. a development instance pointed at a boat’s production database. The vessel context the data was tagged with, such as "vessels.urn:mrn:imo:mmsi:123456789"; a failed replay names the contexts actually found. Leave empty to use this server’s own (Signal K → Server → Vessel Identity)'
       }
     }
   };
@@ -209,6 +249,18 @@ module.exports = function (app) {
     }
   }
 
+  // A retrospective replay can create newly-pending place names; wake the
+  // naming chain immediately rather than leave it to whatever backoff it
+  // was already in. Guarded against the plugin having stopped in the
+  // meantime, since a replay runs in the background and isn't awaited.
+  function nudgeNaming() {
+    if (!namer) {
+      return;
+    }
+    clearTimeout(namingTimer);
+    namingTimer = setTimeout(runNaming, 0);
+  }
+
   // Geocoding is a network call, so it runs as its own chain of timeouts rather
   // than inside detection: each lookup says when the next one is due.
   async function runNaming() {
@@ -304,7 +356,14 @@ module.exports = function (app) {
           : 'en',
         logbookTimeZone: config.logbookTimeZone || null,
         windSpeedThresholds: config.windSpeedThresholds ?? EVENT_DEFAULTS.windSpeedThresholds,
-        pressureDropThreshold: config.pressureDropThreshold ?? EVENT_DEFAULTS.pressureDropThreshold
+        pressureDropThreshold: config.pressureDropThreshold ?? EVENT_DEFAULTS.pressureDropThreshold,
+        influxHost: config.influxHost || null,
+        influxPort: config.influxPort ?? INFLUX_DEFAULTS.influxPort,
+        influxDatabase: config.influxDatabase || null,
+        influxUsername: config.influxUsername || null,
+        influxPassword: config.influxPassword || null,
+        influxProtocol: config.influxProtocol || INFLUX_DEFAULTS.influxProtocol,
+        influxSelfContext: config.influxSelfContext || null
       };
 
       if (settings.logbookTimeZone && !isTimeZone(settings.logbookTimeZone)) {
@@ -347,6 +406,13 @@ module.exports = function (app) {
       pdfOptions,
       log: (level, message) => (level === 'error' ? app.error(message) : app.debug(message))
     });
+    replayJob = createReplayJob({
+      db: database,
+      settings,
+      app,
+      log: (level, message) => (level === 'error' ? app.error(message) : app.debug(message)),
+      onDone: nudgeNaming
+    });
     namingTimer = setTimeout(runNaming, FIRST_NAMING_DELAY_MS);
     tideTimer = setTimeout(runTides, FIRST_TIDE_DELAY_MS);
     lastStatus = null;
@@ -379,6 +445,8 @@ module.exports = function (app) {
     tideForecaster = null;
     usbExport?.stop();
     usbExport = null;
+    replayJob?.cancel();
+    replayJob = null;
     detector = null;
     if (database) {
       database.close();
@@ -404,7 +472,9 @@ module.exports = function (app) {
           now: () => new Date().toISOString(),
           vesselPosition: () => readVesselPosition(app),
           observeEvent: (entryId, time) => detector.observeEvent(entryId, time),
+          noteDeparture: (entryId) => detector.noteDeparture(entryId),
           usbExport,
+          replayJob,
           pdfOptions,
           detection: () => ({
             mode: detector.mode(),

package/lib/api.js

@@ -269,22 +269,27 @@ function registerRoutes(router, { getContext, logError }) {
 
   // Conditions at a manoeuvre, note or sketch belong in the log — but only as
   // it happens; readings now say nothing about one logged after the fact.
-  const observeLiveEvent = (observeEvent, input, { event, created }) => {
+  // Likewise the boat's state, for a passage the crew opened by casting off.
+  const observeLiveEvent = (context, input, { event, created, openedEntry }) => {
     if (created && events.CLIENT_EVENT_TYPES.includes(event.type) && input.time === undefined) {
-      observeEvent(event.entryId, event.time);
+      context.observeEvent(event.entryId, event.time);
+      if (openedEntry) {
+        context.noteDeparture(event.entryId);
+      }
     }
   };
 
   readwrite.post(
     '/api/entries/:id/events',
-    handle(({ db, now, vesselPosition, observeEvent }, req, res) => {
+    handle((context, req, res) => {
+      const { db, now, vesselPosition } = context;
       const id = entryId(req);
       const input = parseEventInput(v.requireBody(req.body, EVENT_FIELDS));
       const outcome = events.createEvent(db, id, input, {
         now: now(),
         vesselPosition: vesselPosition()
       });
-      observeLiveEvent(observeEvent, input, outcome);
+      observeLiveEvent(context, input, outcome);
       res.status(outcome.created ? 201 : 200);
       return outcome.event;
     })
@@ -293,14 +298,15 @@ function registerRoutes(router, { getContext, logError }) {
   // What the tablet posts: the server finds the passage the entry belongs to.
   readwrite.post(
     '/api/events',
-    handle(({ db, config, now, vesselPosition, observeEvent }, req, res) => {
+    handle((context, req, res) => {
+      const { db, config, now, vesselPosition } = context;
       const input = parseEventInput(v.requireBody(req.body, EVENT_FIELDS));
       const outcome = events.logCrewEvent(db, input, {
         now: now(),
         vesselPosition: vesselPosition(),
         placeMatchRadius: config.placeMatchRadius
       });
-      observeLiveEvent(observeEvent, input, outcome);
+      observeLiveEvent(context, input, outcome);
       res.status(outcome.created ? 201 : 200);
       return { ...outcome.event, openedEntry: outcome.openedEntry };
     })
@@ -450,6 +456,32 @@ function registerRoutes(router, { getContext, logError }) {
       return usbExport.run('manual');
     })
   );
+
+  readonly.get(
+    '/api/replay',
+    handle(({ replayJob }) => replayJob.status())
+  );
+
+  admin.post(
+    '/api/replay',
+    handle(({ replayJob }, req) => {
+      const from = v.parseTimestamp(req.body.from, 'from');
+      const to = v.parseTimestamp(req.body.to, 'to');
+      if (to <= from) {
+        throw badRequest('to must be after from');
+      }
+      return replayJob.start(from, to);
+    })
+  );
+
+  admin.post(
+    '/api/replay/cancel',
+    handle(({ replayJob }) => {
+      if (!replayJob.cancel()) {
+        throw conflict('replay_not_running', 'No retrospective replay is running');
+      }
+    })
+  );
 }
 
 module.exports = { registerRoutes };

package/lib/database.js

@@ -239,6 +239,23 @@ const MIGRATIONS = [
     fetched_at TEXT NOT NULL,
     points TEXT NOT NULL
   );
+  `,
+  `
+  -- Speed through water at each track point, for the passage page's position
+  -- scrubber (SPEC §4.1) -- true wind angle is derived from twd and heading
+  -- instead of stored, since it needs no sensor of its own.
+  ALTER TABLE track_points ADD COLUMN stw REAL;
+  `,
+  // Another CHECK-widening rebuild, same reason and same shape as
+  // addPropulsionChangeEventType.
+  addStopoverEventType,
+  `
+  -- The boat's state noted as the passage opened (SPEC §4.5.1), as JSON
+  -- arrays: every tank's level, volume and capacity, every battery's voltage,
+  -- current, state of charge and temperature, in SI units. NULL when the boat
+  -- publishes none, or the passage was opened after the fact.
+  ALTER TABLE log_entries ADD COLUMN start_tanks TEXT;
+  ALTER TABLE log_entries ADD COLUMN start_batteries TEXT;
   `
 ];
 
@@ -290,6 +307,56 @@ function addPropulsionChangeEventType(db, version) {
   db.exec('PRAGMA foreign_keys = ON');
 }
 
+function addStopoverEventType(db, version) {
+  db.exec('PRAGMA foreign_keys = OFF');
+  withTransaction(db, () => {
+    db.exec(`
+      -- Merging two entries (SPEC §3.1) folds the earlier one's arrival into
+      -- the middle of the surviving passage, which would otherwise silently
+      -- drop the only record of where that stop was.
+      CREATE TABLE events_new (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        entry_id INTEGER NOT NULL REFERENCES log_entries (id) ON DELETE CASCADE,
+        time TEXT NOT NULL,
+        type TEXT NOT NULL CHECK (
+          type IN (
+            'manoeuvre',
+            'text_annotation',
+            'handwritten_annotation',
+            'sk_alarm',
+            'autopilot',
+            'weather_threshold',
+            'manual_correction',
+            'propulsion_change',
+            'stopover'
+          )
+        ),
+        subtype TEXT,
+        lat REAL,
+        lon REAL,
+        comment TEXT,
+        payload TEXT,
+        source TEXT NOT NULL DEFAULT 'manual' CHECK (source IN ('auto', 'manual')),
+        created_at TEXT NOT NULL,
+        client_ref TEXT
+      );
+      INSERT INTO events_new (
+        id, entry_id, time, type, subtype, lat, lon, comment, payload, source, created_at, client_ref
+      )
+      SELECT id, entry_id, time, type, subtype, lat, lon, comment, payload, source, created_at, client_ref
+      FROM events;
+      DROP TABLE events;
+      ALTER TABLE events_new RENAME TO events;
+      CREATE INDEX idx_events_entry_time ON events (entry_id, time);
+      CREATE INDEX idx_events_type ON events (type);
+      CREATE UNIQUE INDEX idx_events_client_ref ON events (client_ref)
+        WHERE client_ref IS NOT NULL;
+    `);
+    db.exec(`PRAGMA user_version = ${version + 1}`);
+  });
+  db.exec('PRAGMA foreign_keys = ON');
+}
+
 function seedBuiltinManoeuvreTypes(db) {
   const insert = db.prepare(
     `INSERT INTO manoeuvre_types (key, label, sort_order, builtin)
@@ -301,8 +368,24 @@ function seedBuiltinManoeuvreTypes(db) {
   }
 }
 
+// Open transactions per connection. A call made inside another joins it
+// rather than starting its own -- the retrospective replay wraps many
+// detection ticks in one, so a long replay commits (and syncs) once per slice
+// instead of once per tick. Only the outermost call commits or rolls back.
+const transactionDepth = new WeakMap();
+
 function withTransaction(db, fn) {
+  const depth = transactionDepth.get(db) ?? 0;
+  if (depth > 0) {
+    transactionDepth.set(db, depth + 1);
+    try {
+      return fn();
+    } finally {
+      transactionDepth.set(db, depth);
+    }
+  }
   db.exec('BEGIN');
+  transactionDepth.set(db, 1);
   try {
     const result = fn();
     db.exec('COMMIT');
@@ -310,6 +393,8 @@ function withTransaction(db, fn) {
   } catch (err) {
     db.exec('ROLLBACK');
     throw err;
+  } finally {
+    transactionDepth.delete(db);
   }
 }
 

package/lib/detection.js

@@ -360,7 +360,11 @@ function createPassageDetector({ db, readSelfPath, settings, clock = Date.now })
         closePassage(entry, now);
         // Closed well after the tolerance ran out means the plugin was not
         // running: current conditions say nothing about that arrival.
-        closed = { id: entry.id, late: stoppedFor > closureMs + LATE_CLOSURE_MARGIN_MS };
+        closed = {
+          id: entry.id,
+          endTime: entry.stopped_since,
+          late: stoppedFor > closureMs + LATE_CLOSURE_MARGIN_MS
+        };
         entry = null;
       } else if (current === 'underway') {
         resumedAt = resumeTime(entry, now);
@@ -400,11 +404,16 @@ function createPassageDetector({ db, readSelfPath, settings, clock = Date.now })
     stateIssue: () => stateIssue,
     motion: () => motion,
     propulsion: () => propulsionType,
-    observeEvent: (entryId, time) => observations.recordEvent(entryId, time, clock())
+    observeEvent: (entryId, time) => observations.recordEvent(entryId, time, clock()),
+    noteDeparture: (entryId) => observations.noteDeparture(entryId, clock())
   };
 }
 
 module.exports = {
+  AUTOSTATE_SOURCE_PREFIX,
+  MAX_AGE_MS,
+  METRES_PER_SECOND_PER_KNOT,
+  UNDERWAY_STATES,
   createFreshnessTracker,
   createPassageDetector,
   DETECTION_DEFAULTS,

package/lib/entries.js

@@ -29,6 +29,8 @@ function toEntry(row) {
     engineDuration: row.engine_duration,
     sailDuration: row.sail_duration,
     openedByEventId: row.opened_by_event_id,
+    startTanks: row.start_tanks === null ? null : JSON.parse(row.start_tanks),
+    startBatteries: row.start_batteries === null ? null : JSON.parse(row.start_batteries),
     createdAt: row.created_at,
     updatedAt: row.updated_at
   };
@@ -307,6 +309,16 @@ function mergeEntries(db, id, otherId, now) {
       );
     }
 
+    // The "entry_end" observation is dated the same as the entry's own end,
+    // so this is normally a no-op; it only matters for an entry closed
+    // before that was true, when the reading could be up to
+    // `stopClosureMinutes` later than end_time. Read before the reassignment
+    // below, while entry_id still tells earlier's own snapshot apart from
+    // later's.
+    const entryEndObservation = db
+      .prepare(`SELECT MAX(time) AS time FROM observations WHERE entry_id = ? AND reason = ?`)
+      .get(earlier.id, 'entry_end').time;
+
     for (const table of CHILD_TABLES) {
       db.prepare(`UPDATE ${table} SET entry_id = ? WHERE entry_id = ?`).run(earlier.id, later.id);
     }
@@ -314,6 +326,38 @@ function mergeEntries(db, id, otherId, now) {
     // index would otherwise reject the update below.
     db.prepare('DELETE FROM log_entries WHERE id = ?').run(later.id);
 
+    // The merge below overwrites the earlier entry's end with the later
+    // entry's: without this, the place where the passage actually stopped —
+    // the whole reason a merge exists — would leave no trace on the timeline.
+    if (earlier.end_place_name !== null) {
+      // Placed no earlier than the entry_end reading, so it follows it on
+      // the timeline instead of appearing to predate the passage's own
+      // arrival. Falls back to the entry's end time when there is no
+      // reading to follow — closed by hand, or with no instrument data.
+      const time =
+        entryEndObservation && entryEndObservation > earlier.end_time
+          ? entryEndObservation
+          : earlier.end_time;
+      // The comment carries the raw place name too, like an sk_alarm's
+      // message, so it still reads in a CSV export or before any
+      // translation is applied.
+      db.prepare(
+        `INSERT INTO events (entry_id, time, type, lat, lon, comment, payload, source, created_at)
+         VALUES (?, ?, 'stopover', ?, ?, ?, ?, 'auto', ?)`
+      ).run(
+        earlier.id,
+        time,
+        earlier.end_lat,
+        earlier.end_lon,
+        earlier.end_place_name,
+        JSON.stringify({
+          placeName: earlier.end_place_name,
+          placePending: earlier.end_place_pending === 1
+        }),
+        now
+      );
+    }
+
     db.prepare(
       `UPDATE log_entries SET
          state = ?, end_time = ?, stopped_since = ?,