@meri-imperiumi/signalk-dead-reckoning 0.13.2 → 0.13.3

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.13.3] - 2026-10-15
+
+### Changed
+
+- **The state flush no longer writes rows that did not change, and WAL checkpoint bursts are bounded** (`plugin/db.js`; found by file-activity profiling of a boat server, which showed the DR store's WAL parked at the 4 MB auto-checkpoint high-water and ~40 MB/day of flash writes at the 60 s flush cadence): `setState()` now reads the stored value and skips the write when it is identical — while anchored most flush scalars (`dr_log_nm`, `dr_trip_log_nm`, `dr_trip_start_ms`, `dr_log_since_origin`, `dr_underway_since_origin_s`, `dr_origin_error_nm`) are unchanged, so each flush previously dirtied a 4 kB WAL page per row for nothing; suppressing no-op upserts cuts the anchored flush to the rows that genuinely move (`last_known_good_fix`, whose fix timestamp advances, and `dr_elapsed_since_origin_s`, the wall-clock cone input). `updated_at` then stays at the value's last real change, which is the truthful reading of the column; nothing in the codebase reads it. The database also opens with `PRAGMA wal_autocheckpoint = 256` and `PRAGMA journal_size_limit = 1048576`: the default 1000-page (4 MB) threshold turned every WAL generation into a single ~4 MB copy-back burst on SD-card hardware, and the WAL file parked at its high-water size forever — the same bytes now flow as four 1 MB bursts and the file shrinks back between checkpoints.
+
 ## [0.13.2] - 2026-10-11
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meri-imperiumi/signalk-dead-reckoning",
-  "version": "0.13.2",
+  "version": "0.13.3",
   "description": "Offline-first dead reckoning and sensor fusion engine for Signal K",
   "main": "plugin/index.js",
   "scripts": {

package/plugin/db.js

@@ -206,6 +206,15 @@ function openDatabase(dbPath) {
   // sustained minute after minute on SD-card boat hardware — for that
   // small window is the right default. FULL would fsync every commit.
   db.exec("PRAGMA synchronous = NORMAL");
+  // Bound the WAL's write bursts: the default auto-checkpoint threshold
+  // is 1000 pages (4 MB), so every WAL generation ends in a single ~4 MB
+  // copy back into the main database — a periodic flash-write spike on
+  // SD-card boat hardware. 256 pages (1 MB) spreads the same bytes over
+  // four smaller bursts, and journal_size_limit lets the WAL file shrink
+  // back to 1 MB after each checkpoint instead of parking forever at its
+  // high-water size (observed at ~4 MB on production stores).
+  db.exec("PRAGMA wal_autocheckpoint = 256");
+  db.exec("PRAGMA journal_size_limit = 1048576");
   db.exec("PRAGMA foreign_keys = ON");
   for (const stmt of SCHEMA_DDL) {
     db.exec(stmt);
@@ -351,17 +360,33 @@ function getState(db, key) {
 /**
  * Writes a scalar value to `dr_state_store`, upserting.
  *
+ * Identical values are not written: the periodic state flush rewrites
+ * the same scalars every cycle (log totals, origin error, trip state),
+ * and on SD-card boat hardware even a no-op upsert dirties a 4 kB page
+ * in the WAL, so suppressing unchanged writes is the single biggest
+ * flash-wear lever this store has. `updated_at` then stays at the
+ * value's last real change, which is the truthful reading of the
+ * column anyway. Column reads elsewhere only consume `value`.
+ *
  * @param {import("node:sqlite").DatabaseSync} db
  * @param {string} key
  * @param {string} value
- * @returns {void}
+ * @returns {boolean} True when a write happened, false when the stored
+ *   value was already identical.
  */
 function setState(db, key, value) {
+  const existing = db
+    .prepare("SELECT value FROM dr_state_store WHERE key = ?")
+    .get(key);
+  if (existing && existing.value === value) {
+    return false;
+  }
   db.prepare(
     `INSERT INTO dr_state_store (key, value, updated_at)
      VALUES (?, ?, ?)
      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`,
   ).run(key, value, new Date().toISOString());
+  return true;
 }
 
 /**

package/tests/db.test.js

@@ -243,6 +243,39 @@ test("setState upserts and getState reads back", () => {
   db.close();
 });
 
+test("setState skips identical values (flash-wear guard)", () => {
+  const db = openDatabase(join(tempDir, "c.sqlite"));
+  assert.strictEqual(setState(db, "dr_log_nm", "123.45"), true);
+  const firstUpdatedAt = db
+    .prepare("SELECT updated_at FROM dr_state_store WHERE key = ?")
+    .get("dr_log_nm").updated_at;
+  // Identical write is suppressed: no updated_at churn, no WAL page dirtied
+  assert.strictEqual(setState(db, "dr_log_nm", "123.45"), false);
+  assert.strictEqual(
+    db
+      .prepare("SELECT updated_at FROM dr_state_store WHERE key = ?")
+      .get("dr_log_nm").updated_at,
+    firstUpdatedAt,
+  );
+  // A changed value still writes
+  assert.strictEqual(setState(db, "dr_log_nm", "124.00"), true);
+  assert.strictEqual(getState(db, "dr_log_nm"), "124.00");
+  db.close();
+});
+
+test("openDatabase bounds WAL checkpoint bursts and file high-water", () => {
+  const db = openDatabase(join(tempDir, "c.sqlite"));
+  assert.strictEqual(
+    db.prepare("PRAGMA wal_autocheckpoint").get()["wal_autocheckpoint"],
+    256,
+  );
+  assert.strictEqual(
+    db.prepare("PRAGMA journal_size_limit").get()["journal_size_limit"],
+    1048576,
+  );
+  db.close();
+});
+
 test("dr_matrix_bins primary key enforces bin-level uniqueness", () => {
   const db = openDatabase(join(tempDir, "d.sqlite"));
   const ins = db.prepare(