signalk-chiplog 2.0.0 → 2.2.0

package/lib/database.js

@@ -46,7 +46,9 @@ const MIGRATIONS = [
     start_time TEXT NOT NULL,
     end_time TEXT,
     -- Set when the vessel stops, cleared if it moves again before the
-    -- configured tolerance elapses (SPEC §3.1).
+    -- configured tolerance elapses (SPEC §3.1). Since migration 13, only a
+    -- passage the crew opened by casting off waits like this; detection
+    -- closes the others at once.
     stopped_since TEXT,
     start_lat REAL,
     start_lon REAL,
@@ -256,6 +258,106 @@ const MIGRATIONS = [
   -- 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;
+  `,
+  `
+  -- The marine weather forecast fetched near a passage's departure (SPEC
+  -- §4.5.3), shaped like tide_forecasts: "points" is JSON [{ time, windSpeed,
+  -- ..., currentDirection }], hourly over the 24 h from departure, in SI units
+  -- with null for what the service did not give; empty once fetched if it had
+  -- nothing for the position.
+  CREATE TABLE weather_forecasts (
+    entry_id INTEGER PRIMARY KEY REFERENCES log_entries (id) ON DELETE CASCADE,
+    lat REAL NOT NULL,
+    lon REAL NOT NULL,
+    fetched_at TEXT NOT NULL,
+    points TEXT NOT NULL
+  );
+  `,
+  `
+  -- Who closed a passage: detection, on arrival, or the crew. Only a passage
+  -- detection closed is reopened by a departure within stopClosureMinutes
+  -- (SPEC §4.2); the crew closing one confirms the arrival. NULL while active,
+  -- and for passages closed before this column existed.
+  ALTER TABLE log_entries ADD COLUMN closed_by TEXT CHECK (closed_by IN ('detection', 'crew'));
+  `,
+  `
+  -- Crew list (SPEC §4.11): a small global roster of who might be aboard,
+  -- ever -- unlike manoeuvre_types there is no builtin/sort_order, since the
+  -- list is short enough to sort alphabetically at read time, like places.
+  CREATE TABLE crew_members (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    role TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  -- Who was aboard a given passage -- the schema's first many-to-many
+  -- relationship. name/role are denormalised on purpose, exactly like
+  -- log_entries.start_place_name: a logbook is a historical record, so
+  -- correcting or deleting a crew_members row (ON DELETE SET NULL) must
+  -- never rewrite who a past passage says was aboard.
+  CREATE TABLE log_entry_crew (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    entry_id INTEGER NOT NULL REFERENCES log_entries (id) ON DELETE CASCADE,
+    crew_member_id INTEGER REFERENCES crew_members (id) ON DELETE SET NULL,
+    name TEXT NOT NULL,
+    role TEXT,
+    created_at TEXT NOT NULL
+  );
+
+  CREATE INDEX idx_log_entry_crew_entry ON log_entry_crew (entry_id);
+
+  -- A roster member is assigned to a given entry at most once. An ad hoc
+  -- crew member with no roster row (crew_member_id NULL) has nothing to
+  -- deduplicate against, hence the partial index.
+  CREATE UNIQUE INDEX idx_log_entry_crew_unique_member
+    ON log_entry_crew (entry_id, crew_member_id)
+    WHERE crew_member_id IS NOT NULL;
+  `,
+  `
+  -- Landmarks -- amers (SPEC §4.13): the named features a journal line's
+  -- position is read against, "1.2 nm NE (053°) of Phare du Cap-Ferret".
+  -- Fetched from OpenStreetMap area by area and kept: the bearing itself is
+  -- worked out at read time, so a past passage fills in as soon as its area
+  -- is known, and nothing here is part of the logbook's record.
+  CREATE TABLE landmarks (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    osm_type TEXT NOT NULL CHECK (osm_type IN ('node', 'way', 'relation')),
+    osm_id INTEGER NOT NULL,
+    name TEXT NOT NULL,
+    kind TEXT NOT NULL CHECK (
+      kind IN ('lighthouse', 'light', 'cape', 'landmark', 'beacon', 'harbour')
+    ),
+    lat REAL NOT NULL,
+    lon REAL NOT NULL,
+    -- The nominal range of its light in metres, when OpenStreetMap gives one:
+    -- how far out this amer is still worth naming a position from.
+    light_range REAL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE UNIQUE INDEX idx_landmarks_osm ON landmarks (osm_type, osm_id);
+
+  -- Supports the bounding-box prefilter, as for places.
+  CREATE INDEX idx_landmarks_position ON landmarks (lat, lon);
+
+  -- The half-degree cells landmarks have already been fetched for. A fetch
+  -- covers its cell plus a margin, so every position inside the cell has all
+  -- the amers within range in the table -- one request per cell, ever.
+  CREATE TABLE landmark_areas (
+    cell_lat INTEGER NOT NULL,
+    cell_lon INTEGER NOT NULL,
+    fetched_at TEXT NOT NULL,
+    PRIMARY KEY (cell_lat, cell_lon)
+  );
+
+  -- Cleared once every cell a closed passage sailed through has been fetched.
+  -- An open passage stays pending: it keeps moving into new cells. Existing
+  -- 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));
   `
 ];
 

package/lib/departure-forecast.js

@@ -0,0 +1,150 @@
+const { withTransaction } = require('./database');
+
+// What the tide and weather forecasters share: fetch, once per passage, a
+// forecast near the departure position for the 24 h from departure, and keep
+// it in a table of its own -- one row per entry, `points` as JSON
+// [{ time, ... }] (SPEC §4.5.2, §4.5.3).
+
+const IDLE_MS = 60 * 1000;
+// Offline is the normal state at sea; retry patiently rather than hammering.
+const FIRST_RETRY_MS = 5 * 60 * 1000;
+const MAX_RETRY_MS = 60 * 60 * 1000;
+// A fetch this long after departure would no longer be "near departure" --
+// the forecast window has mostly gone by, so give up rather than keep trying.
+const MAX_FETCH_AGE_MS = 3 * 60 * 60 * 1000;
+const WINDOW_MS = 24 * 60 * 60 * 1000;
+const REQUEST_TIMEOUT_MS = 10 * 1000;
+
+function iso(ms) {
+  return new Date(ms).toISOString();
+}
+
+// The entry most recently departed that has no forecast yet -- fetched or
+// found to have none, either way recorded as a row, so this never re-selects
+// it. Bounded to recent departures: a fetch long after departure would mean
+// requesting a window mostly in the past, which the forecast API does not
+// have, and repeatedly retrying an entry the boat was offline for the whole
+// relevant window of would never succeed anyway.
+function nextPending(db, table, now) {
+  return db
+    .prepare(
+      `SELECT id, start_time, start_lat AS lat, start_lon AS lon FROM log_entries
+       WHERE start_lat IS NOT NULL AND start_lon IS NOT NULL
+         AND start_time >= ?
+         AND id NOT IN (SELECT entry_id FROM ${table})
+       ORDER BY id DESC LIMIT 1`
+    )
+    .get(iso(now - MAX_FETCH_AGE_MS));
+}
+
+function save(db, table, entryId, position, now, points) {
+  withTransaction(db, () => {
+    db.prepare(
+      `INSERT INTO ${table} (entry_id, lat, lon, fetched_at, points)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT (entry_id) DO NOTHING`
+    ).run(entryId, position.lat, position.lon, iso(now), JSON.stringify(points));
+  });
+}
+
+// Open-Meteo answers hourly times as "2026-09-17T08:00", in UTC as asked.
+function utcTime(time) {
+  return `${time}:00.000Z`;
+}
+
+// A GET to an Open-Meteo-style service. Rate limiting or server trouble is
+// worth retrying later (throws); any other refusal -- an unrecognised
+// parameter, say -- is a final answer of "nothing usable" (null).
+async function getJson(fetch, url, { userAgent, signal, label }) {
+  const response = await fetch(url, {
+    headers: { 'User-Agent': userAgent, Accept: 'application/json' },
+    signal: AbortSignal.any([signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)])
+  });
+  if (response.status === 429 || response.status >= 500) {
+    throw new Error(`${label} answered HTTP ${response.status}`);
+  }
+  if (!response.ok) {
+    return null;
+  }
+  return response.json();
+}
+
+// `fetchPoints(position, signal)` returns every point the service has (the
+// window is cut here), throws to be retried, or returns [] for no data.
+function createDepartureForecaster({ db, table, isEnabled, fetchPoints }) {
+  const stopping = new AbortController();
+  // Consecutive failures for `failingEntryId`: the retry delay grows with
+  // them, and starts afresh for another passage -- a new one should not
+  // inherit the long delay an earlier, abandoned one had reached.
+  let failures = 0;
+  let failingEntryId = null;
+
+  return {
+    async resolveNext() {
+      if (!isEnabled()) {
+        return { outcome: 'disabled', retryInMs: IDLE_MS };
+      }
+      const now = Date.now();
+      const pending = nextPending(db, table, now);
+      if (!pending) {
+        failures = 0;
+        return { outcome: 'idle', retryInMs: IDLE_MS };
+      }
+      if (pending.id !== failingEntryId) {
+        failures = 0;
+        failingEntryId = pending.id;
+      }
+
+      const departure = Date.parse(pending.start_time);
+      const position = { lat: pending.lat, lon: pending.lon };
+
+      let all;
+      try {
+        all = await fetchPoints(position, stopping.signal);
+      } 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)
+        };
+      }
+      if (stopping.signal.aborted) {
+        return { outcome: 'stopped' };
+      }
+      failures = 0;
+
+      const points = all.filter((point) => {
+        const time = Date.parse(point.time);
+        return time >= departure && time < departure + WINDOW_MS;
+      });
+      save(db, table, pending.id, position, now, points);
+      return { outcome: points.length > 0 ? 'fetched' : 'no_data', retryInMs: 0 };
+    },
+
+    stop() {
+      stopping.abort();
+    }
+  };
+}
+
+function readForecast(db, table, entryId) {
+  const row = db.prepare(`SELECT * FROM ${table} WHERE entry_id = ?`).get(entryId);
+  if (!row) {
+    return null;
+  }
+  const points = JSON.parse(row.points);
+  if (points.length === 0) {
+    return null;
+  }
+  return {
+    position: { lat: row.lat, lon: row.lon },
+    fetchedAt: row.fetched_at,
+    points
+  };
+}
+
+module.exports = { createDepartureForecaster, readForecast, getJson, utcTime };

package/lib/detection.js

@@ -1,4 +1,6 @@
 const { withTransaction } = require('./database');
+const crew = require('./crew');
+const { recordStopover, reopenableEntry } = require('./entries');
 const { initialPlaceName } = require('./place-names');
 const { createObservationRecorder } = require('./observation-recorder');
 const { createPropulsionTracker } = require('./propulsion-detector');
@@ -280,7 +282,9 @@ function createPassageDetector({ db, readSelfPath, settings, clock = Date.now })
     return { time: entry.last_moving_at ?? iso(now), position: storedEnd(entry) ?? position };
   }
 
-  function closePassage(entry, now) {
+  // Returns what the tick reports about the closure. `late` means the plugin was
+  // not running at the arrival: current conditions say nothing about it.
+  function closePassage(entry, now, { late = false } = {}) {
     // A name the crew typed before arrival is kept as it is.
     const place =
       entry.end_place_name === null
@@ -289,13 +293,27 @@ function createPassageDetector({ db, readSelfPath, settings, clock = Date.now })
     db.prepare(
       `UPDATE log_entries
        SET state = 'closed', end_time = stopped_since, stopped_since = NULL,
-           end_place_id = ?, end_place_name = ?, end_place_pending = ?, updated_at = ?
+           end_place_id = ?, end_place_name = ?, end_place_pending = ?, closed_by = 'detection',
+           updated_at = ?
        WHERE id = ?`
     ).run(place.id, place.name, place.pending, iso(now), entry.id);
+    return { id: entry.id, endTime: entry.stopped_since, late };
   }
 
-  function openPassage(now, position) {
-    const departure = speeds.departure(now) ?? { time: now, position };
+  // A departure soon after detection closed the last passage carries it on:
+  // the stop it ended at stays on its timeline as a stopover.
+  function reopenPassage(entry, now, position) {
+    recordStopover(db, entry, iso(now));
+    db.prepare(
+      `UPDATE log_entries
+       SET state = 'active', end_time = NULL, closed_by = NULL, end_place_id = NULL,
+           end_place_name = NULL, end_place_pending = 0, updated_at = ?
+       WHERE id = ?`
+    ).run(iso(now), entry.id);
+    recordMovement(activeEntry(), now, position, { force: true });
+  }
+
+  function openPassage(now, position, departure) {
     const previousEnd = db
       .prepare('SELECT MAX(end_time) AS endTime FROM log_entries')
       .get().endTime;
@@ -324,13 +342,16 @@ function createPassageDetector({ db, readSelfPath, settings, clock = Date.now })
         iso(now),
         iso(now)
       );
-    return Number(lastInsertRowid);
+    const entryId = Number(lastInsertRowid);
+    crew.copyCrewFromPreviousEntry(db, entryId, iso(now));
+    return entryId;
   }
 
   function step(now, current, position, previous) {
     let entry = activeEntry();
     let resumedAt = null;
     let opened = null;
+    let reopened = null;
     let closed = null;
 
     // A passage left open across a restart with no movement recorded for longer
@@ -342,6 +363,8 @@ function createPassageDetector({ db, readSelfPath, settings, clock = Date.now })
         const lastMoving = entry.last_moving_at ?? entry.start_time;
         if (now - Date.parse(lastMoving) >= closureMs) {
           entry = markStopped(entry, { time: lastMoving, position: storedEnd(entry) }, now);
+          closed = closePassage(entry, now, { late: true });
+          entry = null;
         }
       }
     }
@@ -350,21 +373,21 @@ function createPassageDetector({ db, readSelfPath, settings, clock = Date.now })
       if (current === 'underway') {
         recordMovement(entry, now, position);
       } else if (current === 'stopped') {
+        // Closed as soon as the vessel stops; moving again soon reopens it.
         entry = markStopped(entry, arrivalOf(entry, now, position), now);
+        closed = closePassage(entry, now);
+        entry = null;
       }
     }
 
+    // Still stopped while active: a passage the crew opened by casting off,
+    // not under way yet (or one a previous version left waiting out its stop).
     if (entry && entry.stopped_since !== null) {
       const stoppedFor = now - Date.parse(entry.stopped_since);
       if (stoppedFor >= closureMs) {
-        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,
-          endTime: entry.stopped_since,
+        closed = closePassage(entry, now, {
           late: stoppedFor > closureMs + LATE_CLOSURE_MARGIN_MS
-        };
+        });
         entry = null;
       } else if (current === 'underway') {
         resumedAt = resumeTime(entry, now);
@@ -375,10 +398,18 @@ function createPassageDetector({ db, readSelfPath, settings, clock = Date.now })
     // Only a transition opens a passage: an entry closed by hand while still
     // moving must not be reopened on the next tick.
     if (!entry && current === 'underway' && previous !== 'underway') {
-      opened = openPassage(now, position);
+      const departure = speeds.departure(now) ?? { time: now, position };
+      const previousEntry = reopenableEntry(db, iso(departure.time), closureMs);
+      if (previousEntry) {
+        reopenPassage(previousEntry, now, position);
+        resumedAt = departure.time;
+        reopened = previousEntry.id;
+      } else {
+        opened = openPassage(now, position, departure);
+      }
     }
 
-    return { resumedAt, opened, closed };
+    return { resumedAt, opened, reopened, closed };
   }
 
   return {

package/lib/entries.js

@@ -1,4 +1,5 @@
 const { withTransaction } = require('./database');
+const crew = require('./crew');
 const { badRequest, conflict, notFound } = require('./errors');
 const { coordinatesName, initialPlaceName } = require('./place-names');
 const { distanceBetween, rememberPlaceName } = require('./places');
@@ -10,6 +11,9 @@ const CHILD_TABLES = ['track_points', 'observations', 'propulsion_segments', 'ev
 // passage's destination: an alarm or a note there belongs to it.
 const STILL_AT_ARRIVAL_METRES = 1852;
 
+// Logged with no passage open, these open one: the crew is leaving.
+const DEPARTURE_MANOEUVRES = ['cast_off', 'anchor_up'];
+
 function toEntry(row) {
   return {
     id: row.id,
@@ -119,7 +123,8 @@ function getEntry(db, id) {
     },
     maxSpeed,
     maxWindSpeed: wind.tws ?? wind.aws,
-    maxWindApparent: wind.tws === null && wind.aws !== null
+    maxWindApparent: wind.tws === null && wind.aws !== null,
+    crew: crew.listEntryCrew(db, id)
   };
 }
 
@@ -211,13 +216,16 @@ function updateEntry(db, id, patch, { placeMatchRadius, now }) {
       next.distance = patch.distance;
     }
 
+    // landmarks_pending: an edited departure or arrival position may sit in an
+    // area no landmarks have been fetched for (SPEC §4.13); the lookup checks
+    // and clears it again.
     db.prepare(
       `UPDATE log_entries SET
          start_time = ?, end_time = ?,
          start_lat = ?, start_lon = ?, end_lat = ?, end_lon = ?,
          start_place_id = ?, end_place_id = ?, start_place_name = ?, end_place_name = ?,
          start_place_pending = ?, end_place_pending = ?,
-         distance = ?, updated_at = ?
+         distance = ?, landmarks_pending = 1, updated_at = ?
        WHERE id = ?`
     ).run(
       next.start_time,
@@ -260,7 +268,8 @@ function closeEntry(db, id, { now, position, placeMatchRadius }) {
     db.prepare(
       `UPDATE log_entries
        SET state = 'closed', end_time = ?, stopped_since = NULL, end_lat = ?, end_lon = ?,
-           end_place_id = ?, end_place_name = ?, end_place_pending = ?, updated_at = ?
+           end_place_id = ?, end_place_name = ?, end_place_pending = ?, closed_by = 'crew',
+           updated_at = ?
        WHERE id = ?`
     ).run(
       endTime,
@@ -277,6 +286,37 @@ function closeEntry(db, id, { now, position, placeMatchRadius }) {
   });
 }
 
+// The end of a passage that goes on -- merged into the next one, or reopened
+// by a departure soon after -- would leave no trace on the timeline once
+// overwritten; it is kept as a stopover event at that stop instead. 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. 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.
+function recordStopover(db, row, now) {
+  if (row.end_place_name === null) {
+    return;
+  }
+  const reading = db
+    .prepare(`SELECT MAX(time) AS time FROM observations WHERE entry_id = ? AND reason = ?`)
+    .get(row.id, 'entry_end').time;
+  const time = reading && reading > row.end_time ? reading : row.end_time;
+  db.prepare(
+    `INSERT INTO events (entry_id, time, type, lat, lon, comment, payload, source, created_at)
+     VALUES (?, ?, 'stopover', ?, ?, ?, ?, 'auto', ?)`
+  ).run(
+    row.id,
+    time,
+    row.end_lat,
+    row.end_lon,
+    row.end_place_name,
+    JSON.stringify({ placeName: row.end_place_name, placePending: row.end_place_pending === 1 }),
+    now
+  );
+}
+
 // The earlier entry survives and absorbs the later one, so the passage keeps
 // its original id and departure.
 function mergeEntries(db, id, otherId, now) {
@@ -309,15 +349,13 @@ 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;
+    // Before the reassignment below, while entry_id still tells earlier's own
+    // entry_end reading apart from later's.
+    recordStopover(db, earlier, now);
+    // Unioned rather than reassigned: carry-over (§4.11) means the two crews
+    // usually overlap, and a straight UPDATE would collide with the partial
+    // unique index on (entry_id, crew_member_id).
+    crew.absorbCrewOnMerge(db, earlier.id, later.id, now);
 
     for (const table of CHILD_TABLES) {
       db.prepare(`UPDATE ${table} SET entry_id = ? WHERE entry_id = ?`).run(earlier.id, later.id);
@@ -326,48 +364,19 @@ 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
-      );
-    }
-
+    // landmarks_pending: the merged passage now covers the later one's track
+    // as well, which may reach areas no landmarks have been fetched for.
     db.prepare(
       `UPDATE log_entries SET
-         state = ?, end_time = ?, stopped_since = ?,
+         state = ?, end_time = ?, stopped_since = ?, closed_by = ?,
          end_lat = ?, end_lon = ?, end_place_id = ?, end_place_name = ?, end_place_pending = ?,
-         distance = ?, updated_at = ?
+         distance = ?, landmarks_pending = 1, updated_at = ?
        WHERE id = ?`
     ).run(
       later.state,
       later.end_time,
       later.stopped_since,
+      later.closed_by,
       later.end_lat,
       later.end_lon,
       later.end_place_id,
@@ -405,6 +414,40 @@ function entryNearArrival(db, position) {
   return stillThere ? last.id : null;
 }
 
+// The passage a departure at `time` carries on rather than starting a new
+// one: the last one, if detection closed it (the crew closing one confirms the
+// arrival) less than `closureMs` before -- or the crew cast off from it less
+// than `closureMs` before, the boat taking a while to get going. Nothing may
+// have started since, which also keeps a replay of the past from reopening a
+// passage that live passages have since followed.
+function reopenableEntry(db, time, closureMs) {
+  const last = db
+    .prepare(
+      `SELECT * FROM log_entries WHERE state = 'closed' AND end_time <= ?
+       ORDER BY end_time DESC, id DESC LIMIT 1`
+    )
+    .get(time);
+  if (!last || last.closed_by !== 'detection') {
+    return null;
+  }
+  const later = db
+    .prepare('SELECT 1 FROM log_entries WHERE id <> ? AND start_time >= ? AND start_time <= ?')
+    .get(last.id, last.end_time, time);
+  if (later) {
+    return null;
+  }
+  const castOff = db
+    .prepare(
+      `SELECT MAX(time) AS time FROM events
+       WHERE entry_id = ? AND type = 'manoeuvre' AND source = 'manual'
+         AND subtype IN (${DEPARTURE_MANOEUVRES.map(() => '?').join(', ')})
+         AND time >= ? AND time <= ?`
+    )
+    .get(last.id, ...DEPARTURE_MANOEUVRES, last.end_time, time).time;
+  const since = castOff ?? last.end_time;
+  return Date.parse(time) - Date.parse(since) < closureMs ? last : null;
+}
+
 // A passage opened by the crew casting off, before detection sees the vessel
 // move. It starts stopped, so the first movement resumes it rather than opening
 // another one, and a departure that never happens closes like any long stop.
@@ -432,7 +475,9 @@ function openEntryByHand(db, { time, position, placeMatchRadius, now }) {
       now,
       now
     );
-  return Number(lastInsertRowid);
+  const entryId = Number(lastInsertRowid);
+  crew.copyCrewFromPreviousEntry(db, entryId, now);
+  return entryId;
 }
 
 function deleteEntry(db, id) {
@@ -453,5 +498,8 @@ module.exports = {
   recomputeDurations,
   activeEntryId,
   entryNearArrival,
-  openEntryByHand
+  openEntryByHand,
+  recordStopover,
+  reopenableEntry,
+  DEPARTURE_MANOEUVRES
 };

package/lib/event-watcher.js

@@ -1,14 +1,12 @@
 const { createFreshnessTracker } = require('./detection');
 const { activeEntryId, entryNearArrival } = require('./entries');
+const { CRITICAL_STATES } = require('./events');
 
 const METRES_PER_SECOND_PER_KNOT = 1852 / 3600;
 
 const EVENT_DEFAULTS = { windSpeedThresholds: [20, 30], pressureDropThreshold: 4 };
 
 const CHECK_INTERVAL_MS = 1000;
-
-// Any notification reaching these states is critical, whatever its path.
-const CRITICAL_STATES = new Set(['alarm', 'emergency']);
 const NOTIFICATION_METADATA_KEYS = new Set([
   'meta',
   'values',