@meri-imperiumi/signalk-triplogger 1.3.1 → 1.4.0

package/.eslintrc.json

@@ -1,5 +1,8 @@
 {
   "extends": "airbnb-base",
+  "parserOptions": {
+    "ecmaVersion": 2022
+  },
   "rules": {
     "linebreak-style": "warn"
   }

package/.github/workflows/publish.yml

@@ -5,14 +5,19 @@ on:
     tags:
       - "*"
 
+permissions:
+  id-token: write  # Required for OIDC
+  contents: read
+
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3.0.2
-      - uses: actions/setup-node@v3.4.1
+      - uses: actions/setup-node@v3.1.1
         with:
-          node-version: 12
+          node-version: 24
+          package-manager-cache: false  # never use caching in release builds
       - run: npm install
       - run: npm test
 
@@ -21,10 +26,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3.0.2
-      - uses: actions/setup-node@v3.4.1
+      - uses: actions/setup-node@v3.1.1
         with:
-          node-version: 12
+          node-version: 24
           registry-url: https://registry.npmjs.org/
+          package-manager-cache: false  # never use caching in release builds
       - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/.github/workflows/test.yml

@@ -8,22 +8,14 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [12.x]
+        node-version: [24.x]
     steps:
     - uses: actions/checkout@v3.0.2
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v3.4.1
+      uses: actions/setup-node@v3.1.1
       with:
         node-version: ${{ matrix.node-version }}
     - run: npm install
     - run: npm test
       env:
         CI: true
-  merge-me:
-    name: Auto-merge dependency updates
-    needs: test
-    runs-on: ubuntu-latest
-    steps:
-    - uses: ridedott/merge-me-action@v2.10.22
-      with:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/CHANGELOG.md

@@ -1,29 +1,57 @@
 # Changelog
 
+## [Unreleased]
+
+## [1.4.0] - 2026-09-09
+
+### Added
+- Option to publish the current trip log (`log_path`) and the total log
+  (`totals_path`) under configurable Signal K paths, for setups where the
+  standard `navigation.trip.log`/`navigation.log` paths are owned by another
+  provider. Non-standard paths are announced with `units: m` metadata
+
+### Fixed
+- Don't overwrite the current trip log at startup: log preparation is now
+  serialized so distance appends and state handling always run against the
+  persisted log once it has finished loading from disk
+
+## [1.3.2] - 2026-08-23
+
+### Added
+- Added smoke tests for the plugin entry point (start/stop, subscription,
+  state-change resets, position logging, totals)
+
 ## [1.3.1] - 2026-06-16
 
+### Added
 - Added application icon for SK appstore
 
 ## [1.3.0] - 2026-06-10
 
+### Fixed
 - Don't start a new trip at startup if there's an ongoing one
 
 ## [1.2.0] - 2023-04-27
 
+### Added
 - Added support for populating `navigation.log` for totals
 
 ## [1.1.1] - 2023-02-28
 
+### Fixed
 - Fix issue when `navigation.position` doesn't contain coordinates
 
 ## [1.1.0] - 2022-03-04
 
+### Added
 - Persist logs for current day/month/year, also by sailing/motoring
 
 ## [1.0.1] - 2022-02-18
 
+### Fixed
 - Fix issue with reading lat and lon
 
 ## [1.0.0] - 2022-02-18
 
+### Added
 - Initial version, logging in-memory only

package/README.md

@@ -6,4 +6,4 @@ The plugin monitors vessel `navigation.state` as set by the [signalk-autostate](
 
 ## Changes
 
-See <CHANGELOG.md>
+See [Changelog](CHANGELOG.md)

package/index.js

@@ -27,37 +27,56 @@ module.exports = (app) => {
     return join(app.getDataDirPath(), `${logName}.json`);
   }
 
+  let logsPrepared = Promise.resolve();
+
   function prepareLogs() {
-    const newLogs = getLogNames();
-    return Promise.all(Object.keys(logs).map((logName) => {
-      // Close old logs
-      if (newLogs.indexOf(logName) === -1) {
-        // If log is not in the new log list, end it
-        const oldLog = logs[logName];
-        delete logs[logName];
-        return oldLog.endTrip();
-      }
-      return Promise.resolve();
-    }))
-      .then(() => Promise.all(newLogs.map((logName) => {
-        // Load new logs
-        if (!logs[logName]) {
-          // New log, or saved log?
-          logs[logName] = new Logger(getLogPath(logName));
-          return logs[logName].exists()
-            .then((exists) => {
-              if (!exists) {
-                // New log, no need to load
-                return Promise.resolve();
-              }
-              return logs[logName].load();
-            });
+    // Serialize preparations: a Logger instance is created synchronously,
+    // but only loaded from disk asynchronously. Without serialization a
+    // second call (for example, a position delta right after a state
+    // delta at startup) would see the instance already in `logs` and
+    // proceed before `load()` has finished, appending to and saving a
+    // fresh zeroed log over the persisted one.
+    const preparation = logsPrepared.then(() => {
+      const newLogs = getLogNames();
+      return Promise.all(Object.keys(logs).map((logName) => {
+        // Close old logs
+        if (newLogs.indexOf(logName) === -1) {
+          // If log is not in the new log list, end it
+          const oldLog = logs[logName];
+          delete logs[logName];
+          return oldLog.endTrip();
         }
         return Promise.resolve();
-      })));
+      }))
+        .then(() => Promise.all(newLogs.map((logName) => {
+          // Load new logs
+          if (!logs[logName]) {
+            // New log, or saved log?
+            const log = new Logger(getLogPath(logName));
+            logs[logName] = log;
+            return log.exists()
+              .then((exists) => {
+                if (!exists) {
+                  // New log, no need to load
+                  return Promise.resolve();
+                }
+                return log.load();
+              });
+          }
+          return Promise.resolve();
+        })));
+    });
+    // Keep the chain usable even if a single preparation fails
+    logsPrepared = preparation.catch(() => {});
+    return preparation;
   }
 
   plugin.start = (options) => {
+    // Paths the logs are published under. Configure these when another
+    // provider owns the standard paths, for example when a club's total
+    // log is maintained elsewhere for their maintenance schedule.
+    const tripLogPath = options.log_path || 'navigation.trip.log';
+    const totalLogPath = options.totals_path || 'navigation.log';
     const subscription = {
       context: 'vessels.self',
       subscribe: [
@@ -77,7 +96,7 @@ module.exports = (app) => {
       const resetTime = logs.current.log.started;
       const values = [
         {
-          path: 'navigation.trip.log',
+          path: tripLogPath,
           value: logs.current.log.total,
         },
         {
@@ -88,7 +107,7 @@ module.exports = (app) => {
       if (options.totals) {
         const base = options.totals_base || 0;
         values.push({
-          path: 'navigation.log',
+          path: totalLogPath,
           value: logs.total.log.total + base,
         });
       }
@@ -118,14 +137,14 @@ module.exports = (app) => {
         .then(() => {
           const values = [
             {
-              path: 'navigation.trip.log',
+              path: tripLogPath,
               value: logs.current.log.total,
             },
           ];
           if (options.totals) {
             const base = options.totals_base || 0;
             values.push({
-              path: 'navigation.log',
+              path: totalLogPath,
               value: logs.total.log.total + base,
             });
           }
@@ -141,6 +160,9 @@ module.exports = (app) => {
               },
             ],
           });
+        })
+        .catch((err) => {
+          app.error(`Error:${err}`);
         });
     }
 
@@ -158,9 +180,53 @@ module.exports = (app) => {
             resetTrip();
             setStatus('New trip has started. Log reset');
           }
+        })
+        .catch((err) => {
+          app.error(`Error:${err}`);
         });
     }
 
+    function sendMeta() {
+      // Non-standard paths are not in the Signal K schema, so consumers
+      // cannot know their units. Tell the server they are meters.
+      const meta = [];
+      if (tripLogPath !== 'navigation.trip.log') {
+        meta.push({
+          path: tripLogPath,
+          value: {
+            units: 'm',
+            displayName: 'Current trip log',
+            description: 'Distance travelled during the current trip',
+          },
+        });
+      }
+      if (options.totals && totalLogPath !== 'navigation.log') {
+        meta.push({
+          path: totalLogPath,
+          value: {
+            units: 'm',
+            displayName: 'Total log',
+            description: 'Total distance travelled',
+          },
+        });
+      }
+      if (meta.length === 0) {
+        return;
+      }
+      app.handleMessage(plugin.id, {
+        context: `vessels.${app.selfId}`,
+        updates: [
+          {
+            source: {
+              label: plugin.id,
+            },
+            timestamp: (new Date().toISOString()),
+            meta,
+          },
+        ],
+      });
+    }
+
     app.subscriptionmanager.subscribe(
       subscription,
       unsubscribes,
@@ -204,6 +270,15 @@ module.exports = (app) => {
       },
     );
 
+    // Load persisted logs eagerly so that a trip ongoing from a previous
+    // session is continued when deltas arrive, instead of being reset
+    prepareLogs().catch((err) => {
+      app.error(`Error:${err}`);
+    });
+
+    // Declare units for any non-standard paths we publish to
+    sendMeta();
+
     setStatus('Waiting for updates');
   };
 
@@ -220,10 +295,20 @@ module.exports = (app) => {
         default: 10000,
         title: 'How often to update log, in milliseconds',
       },
+      log_path: {
+        type: 'string',
+        default: 'navigation.trip.log',
+        title: 'Signal K path to publish the current trip log to',
+      },
       totals: {
         type: 'boolean',
         default: true,
-        title: 'Publish a total number in navigation.log',
+        title: 'Publish a total number in the total log path',
+      },
+      totals_path: {
+        type: 'string',
+        default: 'navigation.log',
+        title: 'Signal K path to publish the total log to',
       },
       totals_base: {
         type: 'number',

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@meri-imperiumi/signalk-triplogger",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Log the length of the current trip",
   "main": "index.js",
   "scripts": {
-    "lint": "eslint .",
-    "test": "npm run lint"
+    "test": "node --test --test-force-exit \"tests/*.test.js\" && eslint .",
+    "lint": "eslint ."
   },
   "repository": {
     "type": "git",

package/tests/fake-app.js

@@ -0,0 +1,78 @@
+/**
+ * Shared test fakes: a mock Signal K app matching the patterns used by the
+ * signalk-aprsfi-ais-reporter test suite, adapted for the triplogger's
+ * needs (subscriptionmanager + handleMessage + setPluginStatus + data dir).
+ *
+ * @file fake-app.js
+ */
+
+/* eslint-disable class-methods-use-this */
+
+const { join } = require('node:path');
+const { mkdtempSync } = require('node:fs');
+const { tmpdir } = require('node:os');
+
+/**
+ * Minimal Signal K app fake with subscriptionmanager + handleMessage +
+ * setPluginStatus + setProviderStatus + getDataDirPath + error.
+ *
+ * The data path is a fresh temp directory per instance so the Logger can
+ * write log files without touching the project tree.
+ */
+class FakeSignalKApp {
+  constructor() {
+    this.selfId = 'urn:mrn:imo:mmsi:230999999';
+    this.subscriptionmanager = {
+      subscriptions: [],
+      subscribe(subscription, unsubscribes, onError, onDelta) {
+        this.subscriptions.push({ subscription, onDelta });
+        unsubscribes.push(() => {
+          const idx = this.subscriptions.findIndex(
+            (s) => s.subscription === subscription,
+          );
+          if (idx >= 0) this.subscriptions.splice(idx, 1);
+        });
+      },
+    };
+    this.statusMessages = [];
+    this.errors = [];
+    this.messages = [];
+    this.dataPath = mkdtempSync(join(tmpdir(), 'triplogger-test-'));
+  }
+
+  getDataDirPath() {
+    return this.dataPath;
+  }
+
+  setPluginStatus = (msg) => {
+    this.statusMessages.push({ type: 'status', msg });
+  };
+
+  setProviderStatus = (msg) => {
+    this.statusMessages.push({ type: 'status', msg });
+  };
+
+  handleMessage = (sourceId, message) => {
+    this.messages.push({ sourceId, message });
+  };
+
+  debug() {}
+
+  error(msg) {
+    this.errors.push(msg);
+  }
+}
+
+/**
+ * Emits a delta into the subscriptionmanager's registered handlers, for
+ * tests that want to feed navigation values.
+ *
+ * @param {FakeSignalKApp} app
+ * @param {object} delta
+ * @returns {void}
+ */
+function emitDelta(app, delta) {
+  app.subscriptionmanager.subscriptions.forEach(({ onDelta }) => onDelta(delta));
+}
+
+module.exports = { FakeSignalKApp, emitDelta };

package/tests/plugin.test.js

@@ -0,0 +1,479 @@
+/**
+ * Smoke tests for the plugin entry point (plugin shape, start/stop,
+ * subscription, state-change resets, position logging, totals).
+ * @file plugin.test.js
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { readFileSync, writeFileSync } = require('node:fs');
+const { join } = require('node:path');
+
+const makePlugin = require('../index');
+const { FakeSignalKApp, emitDelta } = require('./fake-app');
+
+/**
+ * Poll until `predicate` returns truthy, retrying every ~10ms up to `timeout`
+ * milliseconds. Resolves true on success, false on timeout. Useful for
+ * awaiting async plugin side-effects (file I/O) without fixed sleeps.
+ *
+ * @param {() => boolean} predicate
+ * @param {number} [timeout]
+ * @returns {Promise<boolean>}
+ */
+function waitFor(predicate, timeout = 500) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const tick = () => {
+      if (predicate()) {
+        resolve(true);
+        return;
+      }
+      if (Date.now() - start >= timeout) {
+        resolve(false);
+        return;
+      }
+      setTimeout(tick, 10);
+    };
+    tick();
+  });
+}
+
+/**
+ * Build a started plugin instance wired to a fresh fake app with the
+ * given settings (defaulted).
+ *
+ * @param {object} [overrides]
+ * @returns {{app: FakeSignalKApp, plugin: object}}
+ */
+function makeStarted(overrides) {
+  const app = new FakeSignalKApp();
+  const plugin = makePlugin(app);
+  plugin.start({
+    update_interval: 10000,
+    totals: true,
+    totals_base: 0,
+    ...overrides,
+  });
+  return { app, plugin };
+}
+
+/**
+ * Read a log file written by the Logger from the app's data dir.
+ *
+ * @param {FakeSignalKApp} app
+ * @param {string} name
+ * @returns {object}
+ */
+function readLog(app, name) {
+  return JSON.parse(readFileSync(join(app.dataPath, `${name}.json`), 'utf-8'));
+}
+
+/**
+ * Pre-seed a log file in the app's data dir before start, so the Logger
+ * loads an existing state instead of starting fresh. Used to make the
+ * "new trip" transition deterministic without racing two state emits.
+ *
+ * @param {FakeSignalKApp} app
+ * @param {string} name
+ * @param {object} contents
+ * @returns {void}
+ */
+function seedLog(app, name, contents) {
+  writeFileSync(join(app.dataPath, `${name}.json`), JSON.stringify(contents, null, 2));
+}
+
+test('creates a plugin object with the right id/name', () => {
+  const app = new FakeSignalKApp();
+  const plugin = makePlugin(app);
+  assert.strictEqual(plugin.id, 'signalk-triplogger');
+  assert.strictEqual(plugin.name, 'Trip logger');
+  assert.ok(plugin.description);
+});
+
+test('schema is a JSON object with the expected options', () => {
+  const app = new FakeSignalKApp();
+  const plugin = makePlugin(app);
+  assert.strictEqual(plugin.schema.type, 'object');
+  assert.ok(plugin.schema.properties.update_interval);
+  assert.ok(plugin.schema.properties.totals);
+  assert.ok(plugin.schema.properties.totals_base);
+});
+
+test('start subscribes to navigation.state and navigation.position', () => {
+  const { app, plugin } = makeStarted();
+  assert.strictEqual(app.subscriptionmanager.subscriptions.length, 1);
+  const sub = app.subscriptionmanager.subscriptions[0].subscription;
+  assert.strictEqual(sub.context, 'vessels.self');
+  const paths = sub.subscribe.map((s) => s.path);
+  assert.ok(paths.includes('navigation.state'));
+  assert.ok(paths.includes('navigation.position'));
+  plugin.stop();
+});
+
+test('start sets an initial status message', () => {
+  const { app, plugin } = makeStarted();
+  assert.ok(
+    app.statusMessages.some(
+      (m) => m.type === 'status' && /waiting/i.test(m.msg),
+    ),
+    `got ${JSON.stringify(app.statusMessages)}`,
+  );
+  plugin.stop();
+});
+
+test('transitioning into a trip resets the log and posts a status', async () => {
+  const app = new FakeSignalKApp();
+  // A fresh current log is considered already in-trip. To make the
+  // transition into a trip deterministic (instead of racing two async
+  // state emits), seed an *ended* current log so inTrip() starts false,
+  // then emit a single trip-starting state.
+  seedLog(app, 'current', {
+    started: '2026-01-01T00:00:00.000Z',
+    ended: '2026-01-01T01:00:00.000Z',
+    total: 0,
+    states: {},
+  });
+  const plugin = makePlugin(app);
+  plugin.start({});
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.state', value: 'sailing' }] },
+    ],
+  });
+  await waitFor(
+    () => app.statusMessages.some((m) => /new trip/i.test(m.msg)),
+  );
+  plugin.stop();
+  assert.ok(
+    app.statusMessages.some(
+      (m) => m.type === 'status' && /new trip/i.test(m.msg),
+    ),
+    `got ${JSON.stringify(app.statusMessages)}`,
+  );
+});
+
+test('position updates append distance to the trip log and emit deltas', async () => {
+  const app = new FakeSignalKApp();
+  // Seed an ended current log so start isn't considered in-trip, then emit
+  // a single trip-starting state. This avoids racing two async state emits.
+  seedLog(app, 'current', {
+    started: '2026-01-01T00:00:00.000Z',
+    ended: '2026-01-01T01:00:00.000Z',
+    total: 0,
+    states: {},
+  });
+  const plugin = makePlugin(app);
+  plugin.start({ totals: true });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [{ values: [{ path: 'navigation.state', value: 'sailing' }] }],
+  });
+  // Wait for the new-trip reset to settle before sending positions.
+  await waitFor(
+    () => app.statusMessages.some((m) => /new trip/i.test(m.msg)),
+  );
+
+  // First position just establishes lastPosition; no distance yet.
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.0, longitude: 24.0 } }] },
+    ],
+  });
+
+  // Second position ~111m east of the first → appendTrip writes log files.
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.001, longitude: 24.0 } }] },
+    ],
+  });
+  await waitFor(() => {
+    const tripValue = app.messages
+      .flatMap(({ message }) => message.updates.flatMap((u) => u.values))
+      .find((v) => v.path === 'navigation.trip.log' && v.value > 0);
+    return !!tripValue;
+  });
+
+  plugin.stop();
+
+  // A trip.log delta should have been published to the app.
+  const tripMsgs = app.messages.filter(
+    ({ message }) => message.updates.some((u) => u.values.some((v) => v.path === 'navigation.trip.log')),
+  );
+  assert.ok(tripMsgs.length > 0, 'no navigation.trip.log delta was emitted');
+
+  // The current trip log file should be persisted with a positive total.
+  const current = readLog(app, 'current');
+  assert.ok(current.total > 0, `current.total was ${current.total}`);
+});
+
+test('totals option also publishes navigation.log', async () => {
+  const app = new FakeSignalKApp();
+  seedLog(app, 'current', {
+    started: '2026-01-01T00:00:00.000Z',
+    ended: '2026-01-01T01:00:00.000Z',
+    total: 0,
+    states: {},
+  });
+  const plugin = makePlugin(app);
+  plugin.start({ totals: true, totals_base: 100 });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [{ values: [{ path: 'navigation.state', value: 'motoring' }] }],
+  });
+  await waitFor(
+    () => app.statusMessages.some((m) => /new trip/i.test(m.msg)),
+  );
+
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.0, longitude: 24.0 } }] },
+    ],
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.002, longitude: 24.0 } }] },
+    ],
+  });
+  await waitFor(() => {
+    const logValue = app.messages
+      .flatMap(({ message }) => message.updates.flatMap((u) => u.values))
+      .find((v) => v.path === 'navigation.log' && v.value > 100);
+    return !!logValue;
+  });
+  plugin.stop();
+
+  const logMsgs = app.messages.filter(
+    ({ message }) => message.updates.some((u) => u.values.some((v) => v.path === 'navigation.log')),
+  );
+  assert.ok(logMsgs.length > 0, 'no navigation.log delta was emitted');
+  const last = logMsgs[logMsgs.length - 1];
+  const { value } = last.message.updates
+    .flatMap((u) => u.values)
+    .find((v) => v.path === 'navigation.log');
+  // totals_base of 100 should be added on top of the logged distance.
+  assert.ok(value > 100, `navigation.log value was ${value}`);
+});
+
+test('startup with an ongoing trip continues it instead of resetting to zero', async () => {
+  const app = new FakeSignalKApp();
+  // An ongoing trip from a previous session: started, never ended.
+  seedLog(app, 'current', {
+    started: '2026-01-01T00:00:00.000Z',
+    ended: null,
+    total: 5000,
+    states: { sailing: 5000 },
+  });
+  const plugin = makePlugin(app);
+  plugin.start({ totals: false });
+
+  // Emit state and positions back-to-back, in the same tick, so they
+  // race against the async log loading from disk. This used to overwrite
+  // current.json with a fresh zeroed log before the saved one was loaded.
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [{ values: [{ path: 'navigation.state', value: 'sailing' }] }],
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.0, longitude: 24.0 } }] },
+    ],
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.001, longitude: 24.0 } }] },
+    ],
+  });
+  await waitFor(() => app.messages
+    .flatMap(({ message }) => message.updates.flatMap((u) => u.values))
+    .some((v) => v.path === 'navigation.trip.log'));
+  plugin.stop();
+
+  // The persisted trip must survive startup: no reset to zero, and the
+  // newly logged distance accumulates on top of the existing total.
+  const current = readLog(app, 'current');
+  assert.ok(
+    current.total >= 5000,
+    `current.total was ${current.total}, expected the ongoing trip to continue`,
+  );
+  assert.ok(
+    !app.statusMessages.some((m) => /new trip/i.test(m.msg)),
+    `unexpected new-trip reset at startup: ${JSON.stringify(app.statusMessages)}`,
+  );
+
+  // The published trip log should also continue from the persisted total.
+  const tripValues = app.messages
+    .flatMap(({ message }) => message.updates.flatMap((u) => u.values))
+    .filter((v) => v.path === 'navigation.trip.log');
+  assert.ok(tripValues.length > 0, 'no navigation.trip.log delta was emitted');
+  assert.ok(
+    tripValues[tripValues.length - 1].value >= 5000,
+    `last trip.log value was ${tripValues[tripValues.length - 1].value}`,
+  );
+});
+
+/**
+ * Flatten all value objects the app has received from the plugin.
+ * Meta-only messages have no `values`, so those updates are skipped.
+ *
+ * @param {FakeSignalKApp} app
+ * @returns {Array<{path: string, value: number}>}
+ */
+function emittedValues(app) {
+  return app.messages.flatMap(
+    ({ message }) => message.updates.filter((u) => u.values).flatMap((u) => u.values),
+  );
+}
+
+/**
+ * Flatten all meta entries the app has received from the plugin.
+ *
+ * @param {FakeSignalKApp} app
+ * @returns {Array<{path: string, value: object}>}
+ */
+function emittedMeta(app) {
+  return app.messages.flatMap(
+    ({ message }) => message.updates.filter((u) => u.meta).flatMap((u) => u.meta),
+  );
+}
+
+test('custom log_path publishes the trip log under the configured path', async () => {
+  const app = new FakeSignalKApp();
+  seedLog(app, 'current', {
+    started: '2026-01-01T00:00:00.000Z',
+    ended: '2026-01-01T01:00:00.000Z',
+    total: 0,
+    states: {},
+  });
+  const plugin = makePlugin(app);
+  plugin.start({
+    log_path: 'navigation.trip.currentTripLog',
+    totals: false,
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [{ values: [{ path: 'navigation.state', value: 'sailing' }] }],
+  });
+  await waitFor(
+    () => app.statusMessages.some((m) => /new trip/i.test(m.msg)),
+  );
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.0, longitude: 24.0 } }] },
+    ],
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.001, longitude: 24.0 } }] },
+    ],
+  });
+  await waitFor(
+    () => emittedValues(app).some(
+      (v) => v.path === 'navigation.trip.currentTripLog' && v.value > 0,
+    ),
+  );
+  plugin.stop();
+
+  // The trip log is published under the configured custom path...
+  assert.ok(
+    emittedValues(app).some((v) => v.path === 'navigation.trip.currentTripLog'),
+    'no delta was emitted to navigation.trip.currentTripLog',
+  );
+  // ...and not under the standard path
+  assert.ok(
+    !emittedValues(app).some((v) => v.path === 'navigation.trip.log'),
+    'navigation.trip.log should not be written when log_path is set',
+  );
+  // The non-standard path is announced with units metadata
+  const tripMeta = emittedMeta(app).find((m) => m.path === 'navigation.trip.currentTripLog');
+  assert.ok(tripMeta, 'no meta was sent for the custom trip log path');
+  assert.strictEqual(tripMeta.value.units, 'm');
+});
+
+test('custom totals_path publishes the total under the configured path', async () => {
+  const app = new FakeSignalKApp();
+  seedLog(app, 'current', {
+    started: '2026-01-01T00:00:00.000Z',
+    ended: '2026-01-01T01:00:00.000Z',
+    total: 0,
+    states: {},
+  });
+  const plugin = makePlugin(app);
+  plugin.start({
+    totals: true,
+    totals_base: 100,
+    totals_path: 'navigation.log.clubTotal',
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [{ values: [{ path: 'navigation.state', value: 'motoring' }] }],
+  });
+  await waitFor(
+    () => app.statusMessages.some((m) => /new trip/i.test(m.msg)),
+  );
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.0, longitude: 24.0 } }] },
+    ],
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.002, longitude: 24.0 } }] },
+    ],
+  });
+  await waitFor(
+    () => emittedValues(app).some(
+      (v) => v.path === 'navigation.log.clubTotal' && v.value > 100,
+    ),
+  );
+  plugin.stop();
+
+  // The total is published under the configured custom path...
+  assert.ok(
+    emittedValues(app).some((v) => v.path === 'navigation.log.clubTotal'),
+    'no delta was emitted to navigation.log.clubTotal',
+  );
+  // ...and not under the standard path
+  assert.ok(
+    !emittedValues(app).some((v) => v.path === 'navigation.log'),
+    'navigation.log should not be written when totals_path is set',
+  );
+  // The trip log keeps its standard path unless configured otherwise
+  assert.ok(
+    emittedValues(app).some((v) => v.path === 'navigation.trip.log'),
+    'navigation.trip.log should still be emitted with only totals_path set',
+  );
+  // The non-standard path is announced with units metadata
+  const totalMeta = emittedMeta(app).find((m) => m.path === 'navigation.log.clubTotal');
+  assert.ok(totalMeta, 'no meta was sent for the custom totals path');
+  assert.strictEqual(totalMeta.value.units, 'm');
+  // No meta is needed for the standard trip path
+  assert.ok(
+    !emittedMeta(app).some((m) => m.path === 'navigation.trip.log'),
+    'standard paths should not get meta',
+  );
+});
+
+test('standard paths send no meta messages', () => {
+  const { app, plugin } = makeStarted();
+  assert.strictEqual(emittedMeta(app).length, 0);
+  plugin.stop();
+});
+
+test('stop clears subscriptions', () => {
+  const { app, plugin } = makeStarted();
+  assert.strictEqual(app.subscriptionmanager.subscriptions.length, 1);
+  plugin.stop();
+  assert.strictEqual(app.subscriptionmanager.subscriptions.length, 0);
+});