@meri-imperiumi/signalk-passage-briefing 0.2.0

package/tests/history-backfill.test.js

@@ -0,0 +1,341 @@
+const { test, describe } = require("node:test");
+const assert = require("node:assert/strict");
+const { mkdtempSync } = require("node:fs");
+const { tmpdir } = require("node:os");
+const { join } = require("node:path");
+
+const { PassageDatabase } = require("../plugin/sqlite-db.js");
+const {
+  WINDOW_MINUTES,
+  foldTwaDegrees,
+  circularMeanDegrees,
+  createLogbookWindStats,
+  extractWindWindowStats,
+  createHistoryWindStats,
+  applySailEvent,
+  backfillSailEvents,
+} = require("../plugin/history-backfill.js");
+
+const makeDb = () =>
+  new PassageDatabase(mkdtempSync(join(tmpdir(), "passage-backfill-")));
+
+const approx = (actual, expected, epsilon = 1e-3) =>
+  assert.ok(
+    Math.abs(actual - expected) < epsilon,
+    `expected ${actual} ≈ ${expected}`,
+  );
+
+describe("wind helpers", () => {
+  test("folds directions onto 0..180", () => {
+    assert.equal(foldTwaDegrees(0), 0);
+    assert.equal(foldTwaDegrees(90), 90);
+    assert.equal(foldTwaDegrees(210), 150);
+    assert.equal(foldTwaDegrees(-30), 30);
+    assert.equal(foldTwaDegrees(360), 0);
+  });
+
+  test("circular mean of folded angles stays in 0..180", () => {
+    assert.equal(circularMeanDegrees([10, 20]), 15);
+    assert.equal(circularMeanDegrees([45, 135]), 90);
+    // Opposite ends of the folded range average through the middle
+    assert.equal(circularMeanDegrees([175, 5]), 90);
+    assert.equal(circularMeanDegrees([10]), 10);
+  });
+});
+
+describe("createLogbookWindStats", () => {
+  const entries = [
+    {
+      datetime: "2023-03-20T08:00:00.000Z",
+      wind: { speed: 10, direction: 200 },
+    },
+    {
+      datetime: "2023-03-20T09:20:00.000Z",
+      text: "Motor stopped, sailing with Main",
+      wind: { speed: 12, direction: 210 },
+    },
+    {
+      datetime: "2023-03-20T09:28:00.000Z",
+      text: "Sails set: Main (1st reef)",
+      wind: { speed: 16, direction: 220 },
+    },
+    {
+      datetime: "2023-03-20T11:00:00.000Z",
+      wind: { speed: 20, direction: 230 },
+    },
+  ];
+
+  test("collects the event entry and adjacent entries in the window", () => {
+    const getStats = createLogbookWindStats(entries);
+    const stats = getStats({ timestamp: "2023-03-20T09:28:00.000Z" });
+    assert.equal(stats.samples, 2);
+    assert.equal(stats.twsAvg, 14);
+    assert.equal(stats.twsPeak, 16);
+    // Circular mean of 150 (from 210°) and 140 (from 220°)
+    assert.equal(Math.round(stats.twaAvg), 145);
+  });
+
+  test("window is bounded at 15 minutes before the event", () => {
+    const getStats = createLogbookWindStats(entries);
+    const stats = getStats({ timestamp: "2023-03-20T09:28:00.000Z" });
+    // 08:00 entry (88 min before) is outside the window
+    assert.equal(stats.samples, 2);
+
+    const hour = createLogbookWindStats(entries, 300);
+    assert.equal(hour({ timestamp: "2023-03-20T09:28:00.000Z" }).samples, 3);
+  });
+
+  test("null when the window has no wind data", () => {
+    const getStats = createLogbookWindStats(entries);
+    assert.equal(getStats({ timestamp: "2023-03-20T10:30:00.000Z" }), null);
+  });
+});
+
+describe("createHistoryWindStats", () => {
+  test("queries the window and converts SI values", async () => {
+    const calls = [];
+    const fetchImpl = async (url) => {
+      calls.push(String(url));
+      const u = new URL(url);
+      assert.equal(u.pathname, "/signalk/v2/api/history/values");
+      assert.equal(
+        u.searchParams.get("paths"),
+        "environment.wind.speedTrue,environment.wind.angleTrue",
+      );
+      return {
+        ok: true,
+        json: async () => ({
+          values: [
+            { path: "environment.wind.speedTrue" },
+            { path: "environment.wind.angleTrue" },
+          ],
+          data: [
+            // m/s, radians: 5.1444 m/s = 10 kn, 210° from = -150° → folded 150
+            ["2023-03-20T09:20:00Z", 5.1444, -2.617994],
+            ["2023-03-20T09:25:00Z", 8.231, -2.792527],
+          ],
+        }),
+      };
+    };
+    const getStats = createHistoryWindStats({
+      baseUrl: "http://localhost:3000",
+      fetchImpl,
+    });
+    const stats = await getStats({ timestamp: "2023-03-20T09:28:00.000Z" });
+    assert.equal(stats.samples, 2);
+    // 5.1444 m/s = 10 kn, 8.2310 m/s = 16 kn
+    approx(stats.twsAvg, 13);
+    approx(stats.twsPeak, 16);
+    // Angles −150° and −160° fold to 150° and 160°
+    approx(stats.twaAvg, 155);
+    const from = new URL(calls[0]).searchParams.get("from");
+    const to = new URL(calls[0]).searchParams.get("to");
+    assert.equal(
+      new Date(to).getTime() - new Date(from).getTime(),
+      WINDOW_MINUTES * 60 * 1000,
+    );
+  });
+
+  test("HTTP errors propagate", async () => {
+    const getStats = createHistoryWindStats({
+      baseUrl: "http://localhost:3000",
+      fetchImpl: async () => ({ ok: false, status: 500, statusText: "boom" }),
+    });
+    await assert.rejects(
+      getStats({ timestamp: "2023-03-20T09:28:00.000Z" }),
+      /History API returned 500/,
+    );
+  });
+});
+
+describe("extractWindWindowStats", () => {
+  test("bounds the window and skips non-numeric samples", () => {
+    const historyData = {
+      values: [
+        { path: "environment.wind.speedTrue" },
+        { path: "environment.wind.angleTrue" },
+      ],
+      data: [
+        ["2023-03-20T09:00:00Z", 5.0, 1.0], // Outside window
+        ["2023-03-20T09:20:00Z", 5.1444, 2.617994], // 10 kn, 150° TWA
+        ["2023-03-20T09:25:00Z", null, 2.0], // No speed → skipped
+        ["2023-03-20T09:27:00Z", 8.23104, 1.5707963], // 16 kn, 90° TWA
+      ],
+    };
+    const stats = extractWindWindowStats({
+      historyData,
+      from: new Date("2023-03-20T09:15:00Z"),
+      to: new Date("2023-03-20T09:28:00Z"),
+    });
+    assert.equal(stats.samples, 2);
+    approx(stats.twsAvg, 13);
+    approx(stats.twsPeak, 16);
+    approx(stats.twaAvg, 120);
+  });
+
+  test("null when no speed column or no data", () => {
+    assert.equal(
+      extractWindWindowStats({
+        historyData: { values: [], data: [] },
+        from: new Date("2023-03-20T09:15:00Z"),
+        to: new Date("2023-03-20T09:28:00Z"),
+      }),
+      null,
+    );
+  });
+});
+
+describe("applySailEvent", () => {
+  test("seeds the matrix bin and the EMA converges with more samples", () => {
+    const db = makeDb();
+    try {
+      const first = applySailEvent({
+        db,
+        event: {
+          timestamp: "2023-03-20T09:28:00.000Z",
+          eventType: "REEF_INCREASE",
+          sailState: "GENOA_1_MAIN_1_REEF",
+        },
+        stats: { samples: 1, twsAvg: 16, twsPeak: 16, twaAvg: 145 },
+      });
+      assert.equal(first.twsBin, 3); // 15..20 kn bin
+      assert.equal(first.twaBin, 4); // 120..150° bin
+      assert.equal(first.sampleCount, 1);
+      assert.equal(first.avgTwsTrigger, 16);
+      assert.equal(first.peakGustTrigger, 16);
+
+      // α = 0.2 EMA toward the new observation (same bin: 15..20 kn)
+      const second = applySailEvent({
+        db,
+        event: {
+          timestamp: "2023-03-25T09:28:00.000Z",
+          eventType: "REEF_INCREASE",
+          sailState: "GENOA_1_MAIN_1_REEF",
+        },
+        stats: { samples: 2, twsAvg: 18, twsPeak: 21, twaAvg: 145 },
+      });
+      assert.equal(second.sampleCount, 2);
+      approx(second.avgTwsTrigger, 0.8 * 16 + 0.2 * 18);
+      approx(second.peakGustTrigger, 0.8 * 16 + 0.2 * 21);
+
+      const matrix = db.getSailPreferenceMatrix();
+      assert.equal(matrix.matrix.length, 1);
+      assert.equal(matrix.matrix[0].preferredSailState, "GENOA_1_MAIN_1_REEF");
+      assert.equal(matrix.matrix[0].samplesCount, 2);
+
+      // Wind cache rows exist for both events
+      assert.equal(
+        db.getWindHistory("2023-03-20T00:00:00Z", "2023-03-26T00:00:00Z")
+          .length,
+        2,
+      );
+    } finally {
+      db.close();
+    }
+  });
+});
+
+describe("backfillSailEvents", () => {
+  const events = [
+    {
+      timestamp: "2023-03-20T09:28:00.000Z",
+      eventType: "REEF_INCREASE",
+      sailState: "GENOA_1_MAIN_1_REEF",
+      notes: "Sails set: Main (1st reef), Genoa 1",
+    },
+    {
+      timestamp: "2023-03-20T09:45:00.000Z", // Window has no wind entries
+      eventType: "SAIL_CHANGE",
+      sailState: "NO_SAILS",
+    },
+  ];
+
+  test("learns events with wind, skips events without, is idempotent", async () => {
+    const db = makeDb();
+    try {
+      const entries = [
+        {
+          datetime: "2023-03-20T09:28:00.000Z",
+          wind: { speed: 16, direction: 220 },
+        },
+      ];
+      const getWindStats = createLogbookWindStats(entries);
+
+      const first = await backfillSailEvents({ db, events, getWindStats });
+      assert.equal(first.total, 2);
+      assert.equal(first.learned, 1);
+      assert.equal(first.skippedNoData, 1);
+      assert.equal(first.cells.length, 1);
+
+      // Recorded into the logbook events table
+      assert.equal(db.getSailEvents().length, 1);
+      assert.equal(db.getSailEvents()[0].eventType, "REEF_INCREASE");
+
+      // Re-run: everything already cached
+      const second = await backfillSailEvents({ db, events, getWindStats });
+      assert.equal(second.learned, 0);
+      assert.equal(second.skippedCached, 1);
+      assert.equal(second.skippedNoData, 1);
+      assert.equal(db.getMatrixBins().length, 1);
+      assert.equal(db.getMatrixBins()[0].sampleCount, 1);
+    } finally {
+      db.close();
+    }
+  });
+
+  test("processes events chronologically regardless of input order", async () => {
+    const db = makeDb();
+    try {
+      const entries = [
+        {
+          datetime: "2023-03-20T09:28:00.000Z",
+          wind: { speed: 16, direction: 220 },
+        },
+        {
+          datetime: "2023-03-21T09:28:00.000Z",
+          wind: { speed: 8, direction: 220 },
+        },
+      ];
+      // Shuffled input: the 03-21 reef decrease first, then the two
+      // 03-20 events out of order. The shake-out 90 s after the reef
+      // shares the reef event's wind window (adjacent-entry wind).
+      const summary = await backfillSailEvents({
+        db,
+        events: [
+          {
+            timestamp: "2023-03-21T09:28:00.000Z",
+            eventType: "REEF_DECREASE",
+            sailState: "GENOA_1_MAIN",
+          },
+          {
+            timestamp: "2023-03-20T09:29:30.000Z",
+            eventType: "SAIL_CHANGE",
+            sailState: "NO_SAILS",
+          },
+          {
+            timestamp: "2023-03-20T09:28:00.000Z",
+            eventType: "REEF_INCREASE",
+            sailState: "GENOA_1_MAIN_1_REEF",
+          },
+        ],
+        getWindStats: createLogbookWindStats(entries),
+      });
+      assert.equal(summary.total, 3);
+      assert.equal(summary.learned, 3);
+
+      const bins = db.getMatrixBins();
+      assert.equal(bins.length, 2);
+      // Chronological order matters: the bin's preferred sail is the
+      // most recent observation, and the EMA runs over 16 → 16 → 8 kn
+      const reefBin = bins.find((bin) => bin.twsBin === 3);
+      assert.equal(reefBin.sampleCount, 2);
+      approx(reefBin.avgTwsTrigger, 0.8 * 16 + 0.2 * 16);
+      assert.equal(reefBin.preferredSail, "NO_SAILS");
+      const lightBin = bins.find((bin) => bin.twsBin === 1);
+      assert.equal(lightBin.sampleCount, 1);
+      assert.equal(lightBin.preferredSail, "GENOA_1_MAIN");
+    } finally {
+      db.close();
+    }
+  });
+});

package/tests/logbook-source.test.js

@@ -0,0 +1,324 @@
+const { test, describe } = require("node:test");
+const assert = require("node:assert/strict");
+const { mkdtempSync, writeFileSync, mkdirSync } = require("node:fs");
+const { tmpdir } = require("node:os");
+const { join } = require("node:path");
+
+const {
+  parseSailsString,
+  sailStateKey,
+  classifySailChange,
+  extractSailEvents,
+  readLogbookSailEvents,
+} = require("../plugin/logbook-source.js");
+
+describe("parseSailsString", () => {
+  test("parses a plain sail list", () => {
+    const state = parseSailsString("Main, Genoa 1");
+    assert.deepEqual(state, {
+      MAIN: { reefs: null, furledPercent: null },
+      GENOA_1: { reefs: null, furledPercent: null },
+    });
+  });
+
+  test("parses reef and furl modifiers", () => {
+    const state = parseSailsString("Main (1st reef), Genoa 1 (20% furled)");
+    assert.equal(state.MAIN.reefs, 1);
+    assert.equal(state.GENOA_1.furledPercent, 20);
+  });
+
+  test("cuts manually appended free text at the first period", () => {
+    const state = parseSailsString(
+      "Main (1st reef), Genoa 1 (30% furled). Big waves and low clouds",
+    );
+    assert.deepEqual(Object.keys(state), ["MAIN", "GENOA_1"]);
+    assert.equal(state.MAIN.reefs, 1);
+    assert.equal(state.GENOA_1.furledPercent, 30);
+  });
+
+  test("filters free-text noise against the sail inventory", () => {
+    const known = new Set(["MAIN", "GENOA_1", "STAYSAIL"]);
+    // Manual edit without a period separator: unknown component ends
+    // the parse before the noise
+    const state = parseSailsString(
+      "Main, the combo stopped working so we drifted",
+      { knownSailKeys: known },
+    );
+    assert.deepEqual(Object.keys(state), ["MAIN"]);
+    // Without an inventory everything parses (and the noise pollutes)
+    const unfiltered = parseSailsString("Main, the combo stopped working");
+    assert.equal(unfiltered.THE_COMBO_STOPPED_WORKING.reefs, null);
+  });
+
+  test("keeps periods inside parentheticals", () => {
+    const state = parseSailsString("Main, Genoa 1 (2.5 oz cloth)");
+    assert.deepEqual(Object.keys(state), ["MAIN", "GENOA_1"]);
+  });
+
+  test("ignores unrecognized parentheticals but keeps the sail", () => {
+    const state = parseSailsString("Main (?)");
+    assert.deepEqual(state, { MAIN: { reefs: null, furledPercent: null } });
+  });
+
+  test("returns null for a fragment with no sail component", () => {
+    assert.equal(parseSailsString(". Just notes, no sails"), null);
+    assert.equal(parseSailsString(""), null);
+  });
+});
+
+describe("sailStateKey", () => {
+  test("is order-independent and canonical", () => {
+    const a = sailStateKey(parseSailsString("Main (1st reef), Genoa 1"));
+    const b = sailStateKey(parseSailsString("Genoa 1, Main (1st reef)"));
+    assert.equal(a, b);
+    assert.equal(a, "GENOA_1_MAIN_1_REEF");
+  });
+
+  test("encodes furl ratio", () => {
+    assert.equal(
+      sailStateKey(parseSailsString("Genoa 1 (20% furled)")),
+      "GENOA_1_20_FURLED",
+    );
+  });
+
+  test("bare poles", () => {
+    assert.equal(sailStateKey({}), "NO_SAILS");
+    assert.equal(sailStateKey(null), "NO_SAILS");
+  });
+});
+
+describe("classifySailChange", () => {
+  const s = (text) => parseSailsString(text);
+
+  test("reef increase", () => {
+    assert.equal(
+      classifySailChange(s("Main, Genoa 1"), s("Main (1st reef), Genoa 1")),
+      "REEF_INCREASE",
+    );
+  });
+
+  test("reef decrease", () => {
+    assert.equal(
+      classifySailChange(
+        s("Main (2nd reef), Staysail"),
+        s("Main (1st reef), Staysail"),
+      ),
+      "REEF_DECREASE",
+    );
+  });
+
+  test("furling in counts as a reef increase", () => {
+    assert.equal(
+      classifySailChange(s("Main, Genoa 1"), s("Main, Genoa 1 (30% furled)")),
+      "REEF_INCREASE",
+    );
+  });
+
+  test("handing a sail is a sail change even with reefs involved", () => {
+    assert.equal(
+      classifySailChange(s("Main (1st reef), Genoa 1"), s("Main (2nd reef)")),
+      "SAIL_CHANGE",
+    );
+  });
+
+  test("unknown previous state is a plain sail change", () => {
+    assert.equal(classifySailChange(null, s("Main")), "SAIL_CHANGE");
+  });
+});
+
+describe("extractSailEvents", () => {
+  test("inventory filter keeps events but normalizes state keys", () => {
+    const known = new Set(["MAIN", "GENOA_1"]);
+    const events = extractSailEvents(
+      [
+        {
+          datetime: "2023-03-20T14:19:16.099Z",
+          text: "Sails set: Main (1st reef), The cone",
+          wind: { speed: 15, direction: 225 },
+        },
+        {
+          datetime: "2023-03-20T16:00:00.000Z",
+          text: "Sails set: Main (2nd reef), Genoa 1",
+          wind: { speed: 20, direction: 225 },
+        },
+        {
+          datetime: "2023-03-20T18:00:00.000Z",
+          text: "Sails set: Main (3rd reef), Genoa 1",
+          wind: { speed: 24, direction: 225 },
+        },
+      ],
+      { knownSailKeys: known },
+    );
+    // First event parses to just the Main component; the state still
+    // transitions, and the noise never becomes a sail state key
+    assert.equal(events.length, 3);
+    assert.equal(events[0].sailState, "MAIN_1_REEF");
+    assert.equal(events[1].sailState, "GENOA_1_MAIN_2_REEF");
+    assert.equal(events[2].sailState, "GENOA_1_MAIN_3_REEF");
+    // Unknown → Main is a plain change; handing the genoa alongside a
+    // reef is a mixed change; the third step is a pure reef increase
+    assert.equal(events[0].eventType, "SAIL_CHANGE");
+    assert.equal(events[1].eventType, "SAIL_CHANGE");
+    assert.equal(events[2].eventType, "REEF_INCREASE");
+  });
+
+  test("tracks state across the real-world text patterns", () => {
+    const events = extractSailEvents([
+      {
+        datetime: "2023-03-20T10:00:00.000Z",
+        text: "Motor stopped, sailing with Main, Genoa 1",
+        wind: { speed: 11.2, direction: 210 },
+      },
+      {
+        datetime: "2023-03-20T12:00:00.000Z",
+        text: "Sailing with Main, Genoa 1",
+        wind: { speed: 12, direction: 220 },
+      },
+      {
+        datetime: "2023-03-20T14:19:16.099Z",
+        text: "Sails set: Main (1st reef), Genoa 1",
+        wind: { speed: 15.5, direction: 225 },
+      },
+      {
+        datetime: "2023-03-20T15:49:51.097Z",
+        text: "Sails set: Main, Genoa 1",
+        wind: { speed: 13, direction: 230 },
+      },
+      {
+        datetime: "2023-03-20T17:00:00.000Z",
+        text: "Sails down, motoring. Thunder.",
+        wind: { speed: 6, direction: 180 },
+      },
+      {
+        datetime: "2023-03-20T17:30:00.000Z",
+        text: "Sails up, motor off",
+      },
+    ]);
+
+    assert.equal(events.length, 3);
+    // The motor-stop snapshot established the state, so the identical
+    // "Sailing with" declaration produced no event — the reef went in next
+    assert.equal(events[0].eventType, "REEF_INCREASE");
+    assert.equal(events[0].sailState, "GENOA_1_MAIN_1_REEF");
+    assert.equal(events[0].twsKnots, 15.5);
+    assert.equal(events[0].twaDeg, 135);
+    assert.match(events[0].notes, /Sails set/);
+    // Shake-out
+    assert.equal(events[1].eventType, "REEF_DECREASE");
+    // Bare poles (manual suffix ignored)
+    assert.equal(events[2].eventType, "SAIL_CHANGE");
+    assert.equal(events[2].sailState, "NO_SAILS");
+    assert.equal(events[2].twaDeg, 180);
+  });
+
+  test("skips duplicate state declarations and sorts out of order input", () => {
+    const events = extractSailEvents([
+      { datetime: "2023-03-20T12:00:00.000Z", text: "Sails set: Main" },
+      {
+        datetime: "2023-03-20T10:00:00.000Z",
+        text: "Sails set: Main, Genoa 1",
+      },
+      { datetime: "2023-03-20T14:00:00.000Z", text: "Sails set: Main" },
+    ]);
+    assert.equal(events.length, 2);
+    assert.equal(events[0].sailState, "GENOA_1_MAIN");
+    assert.equal(events[1].sailState, "MAIN");
+  });
+
+  test("unknown motor-stop snapshots do not clobber known state", () => {
+    const events = extractSailEvents([
+      {
+        datetime: "2023-03-20T10:00:00.000Z",
+        text: "Sails set: Main (1st reef)",
+      },
+      { datetime: "2023-03-20T11:00:00.000Z", text: "Motor stopped, sailing" },
+      {
+        datetime: "2023-03-20T12:00:00.000Z",
+        text: "Sails set: Main (2nd reef)",
+      },
+    ]);
+    assert.equal(events.length, 2);
+    assert.equal(events[1].eventType, "REEF_INCREASE");
+  });
+});
+
+describe("readLogbookSailEvents", () => {
+  test("walks day files chronologically and filters the range", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "passage-logbook-"));
+    writeFileSync(
+      join(dir, "2023-03-19.yml"),
+      `- datetime: 2023-03-19T09:00:00.000Z
+  text: "Motor stopped, sailing with Main, Genoa 1"
+  wind:
+    speed: 10.0
+    direction: 200
+`,
+    );
+    writeFileSync(
+      join(dir, "2023-03-20.yml"),
+      `- datetime: 2023-03-20T08:00:00.000Z
+  text: "Sails set: Main (1st reef), Genoa 1"
+  wind:
+    speed: 16.0
+    direction: 210
+- datetime: 2023-03-20T10:00:00.000Z
+  text: "Sails down, motoring"
+  wind:
+    speed: 8.0
+    direction: 220
+`,
+    );
+    // Unrelated file must be ignored
+    writeFileSync(join(dir, "notes.txt"), "hello");
+
+    const all = await readLogbookSailEvents({ dir });
+    assert.equal(all.length, 2);
+    assert.equal(all[0].eventType, "REEF_INCREASE");
+    assert.equal(all[1].eventType, "SAIL_CHANGE");
+
+    const windowed = await readLogbookSailEvents({
+      dir,
+      from: "2023-03-20T00:00:00.000Z",
+      to: "2023-03-20T09:00:00.000Z",
+    });
+    assert.equal(windowed.length, 1);
+    assert.equal(windowed[0].eventType, "REEF_INCREASE");
+
+    // Missing store is not fatal
+    const none = await readLogbookSailEvents({
+      dir: join(dir, "nope"),
+    });
+    assert.deepEqual(none, []);
+  });
+
+  test("state tracking reaches back before the requested range", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "passage-logbook-"));
+    writeFileSync(
+      join(dir, "2023-03-19.yml"),
+      `- datetime: 2023-03-19T09:00:00.000Z
+  text: "Sails set: Main (1st reef)"
+`,
+    );
+    writeFileSync(
+      join(dir, "2023-03-20.yml"),
+      `- datetime: 2023-03-20T08:00:00.000Z
+  text: "Sails set: Main (2nd reef)"
+`,
+    );
+    const windowed = await readLogbookSailEvents({
+      dir,
+      from: "2023-03-20T00:00:00.000Z",
+    });
+    assert.equal(windowed.length, 1);
+    // Classified against the state from the previous day's file
+    assert.equal(windowed[0].eventType, "REEF_INCREASE");
+  });
+
+  test("skips corrupt day files", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "passage-logbook-"));
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "2023-03-20.yml"), "{{{{ not yaml");
+    const events = await readLogbookSailEvents({ dir });
+    assert.deepEqual(events, []);
+  });
+});