node-red-contrib-timer-events 0.1.0

package/test-scripts/test-harness.js

@@ -0,0 +1,203 @@
+// Test harness for the #1 fix: authoritative wall-clock remaining time.
+// Stubs enough of the Node-RED runtime to instantiate the node, then
+// exercises the exact scenarios that were broken, all with Status
+// Reporting = "none" (the default, and the previously-broken case).
+"use strict";
+const os = require("os");
+const fs = require("fs");
+const path = require("path");
+
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+let failures = 0;
+function check(label, cond, detail) {
+  if (cond) { console.log("PASS  " + label); }
+  else { failures++; console.log("FAIL  " + label + (detail !== undefined ? "  [" + detail + "]" : "")); }
+}
+function near(actual, expected, tol) { return Math.abs(actual - expected) <= tol; }
+
+// ---- RED stub --------------------------------------------------------------
+function makeRED(userDir) {
+  const registered = {};
+  return {
+    nodes: {
+      registerType(name, ctor) { registered[name] = ctor; },
+      createNode(node, n) {
+        node.id = n.id;
+        node._handlers = {};
+        node.on = function(evt, fn) { node._handlers[evt] = fn; };
+        node.receive = function(msg) { node._handlers["input"](msg); };
+        node.close = function(removed) {
+          return new Promise(res => node._handlers["close"](removed, res));
+        };
+        node.sent = [];
+        node.send = function(arr) { node.sent.push(arr); };
+        node.status = function() {};
+        node.warn = function() {};
+        node.error = function(e) { console.log("NODE ERROR:", e); };
+      },
+      get(name) { return registered[name]; }
+    },
+    util: {
+      cloneMessage(m) { return JSON.parse(JSON.stringify(m || {})); },
+      evaluateNodeProperty(v) { return v; }
+    },
+    settings: { userDir: userDir }
+  };
+}
+
+function lastEvent(node, type) {
+  for (let i = node.sent.length - 1; i >= 0; i--) {
+    const m = node.sent[i].find(x => x && x.timerEvent === type);
+    if (m) return m;
+  }
+  return null;
+}
+
+function makeNode(RED, cfg) {
+  const Ctor = RED.nodes.get("timer-events");
+  const node = {};
+  Ctor.call(node, Object.assign({
+    id: "t" + Math.random().toString(36).slice(2),
+    duration: "5", durationType: "num", units: "Second",
+    reporting: "none", reportingformat: "seconds",
+    persist: false, ignoretimerpass: false, donotresettimer: false,
+    thresholdaction: "donothing", thresholdcount: "0",
+    thresholdaddtime: "0", thresholdaddtimeunits: "Second",
+    heartbeatinterval: "0", heartbeatintervalunits: "Second",
+    cooldownduration: "0", cooldownunits: "Second"
+  }, cfg));
+  return node;
+}
+
+(async function main() {
+  const userDir = fs.mkdtempSync(path.join(os.tmpdir(), "timerevents-test-"));
+  const RED = makeRED(userDir);
+  require("/home/claude/timer-events.js")(RED);
+
+  // -- T1: pause/resume accuracy with reporting off ("Never") ---------------
+  {
+    const n = makeNode(RED, { duration: "10" }); // 10s
+    n.receive({ payload: "go" });
+    await sleep(3000);
+    n.receive({ payload: "pause" });
+    let p = lastEvent(n, "paused");
+    check("T1a pause freezes at ~7000ms (was: full 10000ms)", p && near(p.remainingTime, 7000, 300), p && p.remainingTime);
+    await sleep(1500); // frozen time must not move
+    n.receive({ payload: "query" });
+    let q = lastEvent(n, "query");
+    check("T1b remaining unchanged while paused", q && near(q.remainingTime, 7000, 300), q && q.remainingTime);
+    n.receive({ payload: "resume" });
+    const resumeAt = Date.now();
+    await new Promise(res => {
+      const iv = setInterval(() => { if (lastEvent(n, "expired")) { clearInterval(iv); res(); } }, 100);
+    });
+    const ranFor = Date.now() - resumeAt;
+    check("T1c resume runs ~7s more, not 10s (was: full duration back)", near(ranFor, 7000, 500), ranFor);
+    await n.close(false);
+  }
+
+  // -- T2: query mid-run reports live remaining time ------------------------
+  {
+    const n = makeNode(RED, { duration: "10" });
+    n.receive({ payload: "go" });
+    await sleep(4000);
+    n.receive({ payload: "query" });
+    const q = lastEvent(n, "query");
+    check("T2 query at t+4s reports ~6000ms (was: 10000ms)", q && near(q.remainingTime, 6000, 300), q && q.remainingTime);
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- T3: adjusttime computes from true remaining, and never leaks into next run
+  {
+    const n = makeNode(RED, { duration: "10" });
+    n.receive({ payload: "go" });
+    await sleep(2000);
+    n.receive({ payload: "adjusttime", adjusttime: 5000 });
+    const a = lastEvent(n, "timeadjusted");
+    check("T3a adjust +5s at t+2s -> ~13000ms (was: 15000ms)", a && near(a.remainingTime, 13000, 300), a && a.remainingTime);
+    n.receive({ payload: "stop" });
+    n.sent.length = 0;
+    n.receive({ payload: "go2" }); // fresh run: original duration must return
+    const s = lastEvent(n, "started");
+    check("T3b next run starts at original 10000ms (no adjustment leak)", s && near(s.remainingTime, 10000, 50), s && s.remainingTime);
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- T4: settime while paused updates the frozen snapshot ------------------
+  {
+    const n = makeNode(RED, { duration: "10" });
+    n.receive({ payload: "go" });
+    await sleep(1000);
+    n.receive({ payload: "pause" });
+    n.receive({ payload: "settime", settime: 4000 });
+    n.receive({ payload: "query" });
+    const q = lastEvent(n, "query");
+    check("T4 settime while paused -> frozen at exactly 4000ms", q && q.remainingTime === 4000, q && q.remainingTime);
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- T5: persistence writes the real target (reporting off) ----------------
+  {
+    const n = makeNode(RED, { duration: "10", persist: true });
+    n.receive({ payload: "go" });
+    await sleep(3000);
+    n.receive({ payload: "lock" }); // any mid-run writeState trigger
+    const dir = path.join(userDir, "timerevents-timers");
+    const file = fs.readdirSync(dir).map(f => path.join(dir, f))
+      .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs)[0];
+    const saved = JSON.parse(fs.readFileSync(file));
+    const persistedRemaining = new Date(saved.time).getTime() - Date.now();
+    check("T5 persisted target reflects ~7000ms left (was: ~10000ms)", near(persistedRemaining, 7000, 400), Math.round(persistedRemaining));
+    n.receive({ payload: "stop" });
+    await n.close(true);
+  }
+
+  // -- T6: cooldown query reports live cooldown remaining --------------------
+  {
+    const n = makeNode(RED, { duration: "1", cooldownduration: "6" });
+    n.receive({ payload: "go" });
+    await sleep(1300); // expire -> cooldown starts
+    check("T6a cooldownstarted fired", !!lastEvent(n, "cooldownstarted"));
+    await sleep(2000); // 2s into the 6s cooldown
+    n.receive({ payload: "query" });
+    const q = lastEvent(n, "query");
+    check("T6b cooldown query state", q && q.timerState === "cooldown", q && q.timerState);
+    check("T6c cooldown remaining ~4000ms (was: full 6000ms)", q && near(q.remainingTime, 3900, 400), q && q.remainingTime);
+    n.receive({ payload: "stop" }); // cancel cooldown
+    const st = lastEvent(n, "stopped");
+    check("T6d stop after cooldown reports remainingTime 0", st && st.remainingTime === 0, st && st.remainingTime);
+    await n.close(false);
+  }
+
+  // -- T7: regression - reporting ON still behaves (natural expiry timing) ---
+  {
+    const n = makeNode(RED, { duration: "4", reporting: "every_second" });
+    const t0 = Date.now();
+    n.receive({ payload: "go" });
+    await new Promise(res => {
+      const iv = setInterval(() => { if (lastEvent(n, "expired")) { clearInterval(iv); res(); } }, 100);
+    });
+    check("T7a expiry fires at ~4s with reporting on", near(Date.now() - t0, 4000, 500), Date.now() - t0);
+    const e = lastEvent(n, "expired");
+    check("T7b expired reports remainingTime 0", e && e.remainingTime === 0, e && e.remainingTime);
+    await n.close(false);
+  }
+
+  // -- T8: regression - blocked restart while locked, envelope still sane ----
+  {
+    const n = makeNode(RED, { duration: "10", donotresettimer: true });
+    n.receive({ payload: "go" });
+    await sleep(2000);
+    n.receive({ payload: "again" }); // ignored restart
+    const r = lastEvent(n, "restarted");
+    check("T8 ignored restart carries live remaining ~8000ms", r && r.ignored === true && near(r.remainingTime, 8000, 300), r && r.remainingTime);
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  console.log(failures === 0 ? "\nALL TESTS PASSED" : "\n" + failures + " FAILURE(S)");
+  process.exit(failures === 0 ? 0 : 1);
+})();

package/test-scripts/test-paused-restore.js

@@ -0,0 +1,157 @@
+// Tests for open-item 1 (Option A): a paused timer restores at the SAME
+// frozen remaining and elapsed values regardless of Node-RED downtime.
+// Running/cooldown restores remain wall-clock (downtime absorbed). Legacy
+// persist files without the new fields fall back to the old calculation.
+"use strict";
+const os = require("os");
+const fs = require("fs");
+const path = require("path");
+
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+let failures = 0;
+function check(label, cond, detail) {
+  if (cond) { console.log("PASS  " + label); }
+  else { failures++; console.log("FAIL  " + label + (detail !== undefined ? "  [" + detail + "]" : "")); }
+}
+function near(a, e, tol) { return Math.abs(a - e) <= tol; }
+
+function makeRED(userDir) {
+  const registered = {};
+  return {
+    nodes: {
+      registerType(name, ctor) { registered[name] = ctor; },
+      createNode(node, n) {
+        node.id = n.id;
+        node._handlers = {};
+        node.on = function(evt, fn) { node._handlers[evt] = fn; };
+        node.receive = function(msg) { node._handlers["input"](msg); };
+        node.close = function(removed) {
+          return new Promise(res => node._handlers["close"](removed, res));
+        };
+        node.sent = [];
+        node.send = function(arr) { node.sent.push(arr); };
+        node.status = function() {};
+        node.warn = function() {};
+        node.error = function(e) { console.log("NODE ERROR:", e); };
+      },
+      get(name) { return registered[name]; }
+    },
+    util: {
+      cloneMessage(m) { return JSON.parse(JSON.stringify(m || {})); },
+      evaluateNodeProperty(v) { return v; }
+    },
+    settings: { userDir: userDir }
+  };
+}
+
+function events(node, type) {
+  const out = [];
+  for (const arr of node.sent) for (const m of arr) if (m && m.timerEvent === type) out.push(m);
+  return out;
+}
+function lastEvent(node, type) { const e = events(node, type); return e.length ? e[e.length - 1] : null; }
+function query(n) { n.receive({ payload: "query" }); return lastEvent(n, "query"); }
+
+function makeNode(RED, cfg) {
+  const Ctor = RED.nodes.get("timer-events");
+  const node = {};
+  Ctor.call(node, Object.assign({
+    id: "z-fixed", duration: "10", durationType: "num", units: "Second",
+    reporting: "none", reportingformat: "seconds",
+    persist: true, ignoretimerpass: false, donotresettimer: false,
+    thresholdaction: "donothing", thresholdcount: "0",
+    thresholdaddtime: "0", thresholdaddtimeunits: "Second",
+    heartbeatinterval: "0", heartbeatintervalunits: "Second",
+    cooldownduration: "0", cooldownunits: "Second"
+  }, cfg));
+  return node;
+}
+function persistFile(userDir, id) { return path.join(userDir, "timerevents-timers", id); }
+
+(async function main() {
+  const userDir = fs.mkdtempSync(path.join(os.tmpdir(), "timerevents-oi1-"));
+  const RED = makeRED(userDir);
+  require("/home/claude/timer-events.js")(RED);
+
+  // -- Z1: paused restore ignores downtime -----------------------------------
+  {
+    const n1 = makeNode(RED, { id: "z1" });
+    n1.receive({ payload: "go" });
+    await sleep(3000);
+    n1.receive({ payload: "pause" }); // frozen: ~7000 remaining / ~3000 elapsed
+    await n1.close(false);
+    await sleep(2000);                // 2s of downtime - must NOT be deducted
+    const n2 = makeNode(RED, { id: "z1" });
+    const q = query(n2);
+    check("Z1a remaining unchanged across downtime (~7000, was: ~5000)",
+      q && q.timerState === "paused" && near(q.remainingTime, 7000, 300), q && Math.round(q.remainingTime));
+    check("Z1b elapsed unchanged across downtime (~3000, was: ~5000)",
+      q && near(q.elapsedTime, 3000, 300), q && Math.round(q.elapsedTime));
+    // resume must honor the frozen value end-to-end
+    n2.receive({ payload: "resume" });
+    const t0 = Date.now();
+    await new Promise(res => { const iv = setInterval(() => { if (lastEvent(n2, "expired")) { clearInterval(iv); res(); } }, 100); });
+    check("Z1c resume after restore runs the full frozen ~7s", near(Date.now() - t0, 7000, 600), Date.now() - t0);
+    await n2.close(true);
+  }
+
+  // -- Z2: frozenElapsed independence survives (settime while paused) --------
+  {
+    const n1 = makeNode(RED, { id: "z2" });
+    n1.receive({ payload: "go" });
+    await sleep(3000);
+    n1.receive({ payload: "pause" });                       // elapsed frozen ~3000
+    n1.receive({ payload: "settime", settime: 9000 });      // remaining -> 9000, elapsed untouched
+    await n1.close(false);
+    await sleep(1000);
+    const n2 = makeNode(RED, { id: "z2" });
+    const q = query(n2);
+    check("Z2a settime'd remaining restores exactly (9000)",
+      q && q.remainingTime === 9000, q && q.remainingTime);
+    check("Z2b frozen elapsed restores independently (~3000, not derived 1000)",
+      q && near(q.elapsedTime, 3000, 300), q && Math.round(q.elapsedTime));
+    n2.receive({ payload: "stop" });
+    await n2.close(true);
+  }
+
+  // -- Z3: legacy persist file (no new fields) -> old fallback behavior ------
+  {
+    const n1 = makeNode(RED, { id: "z3" });
+    n1.receive({ payload: "go" });
+    await sleep(3000);
+    n1.receive({ payload: "pause" });
+    await n1.close(false);
+    // Strip the new fields to simulate a pre-upgrade persist file
+    const file = persistFile(userDir, "z3");
+    const saved = JSON.parse(fs.readFileSync(file));
+    delete saved.remaining;
+    delete saved.frozenElapsed;
+    fs.writeFileSync(file, JSON.stringify(saved));
+    await sleep(2000);
+    const n2 = makeNode(RED, { id: "z3" });
+    const q = query(n2);
+    check("Z3 legacy file falls back to target-minus-now (~5000 after 2s downtime)",
+      q && q.timerState === "paused" && near(q.remainingTime, 5000, 400), q && Math.round(q.remainingTime));
+    n2.receive({ payload: "stop" });
+    await n2.close(true);
+  }
+
+  // -- Z4: regression - RUNNING restore still absorbs downtime ----------------
+  {
+    const n1 = makeNode(RED, { id: "z4" });
+    n1.receive({ payload: "go" });
+    await sleep(3000); // ~7000 remaining
+    await n1.close(false);
+    await sleep(2000); // downtime SHOULD be absorbed for a running timer
+    const n2 = makeNode(RED, { id: "z4" });
+    await sleep(150);
+    const s = lastEvent(n2, "started");
+    check("Z4 running restore still deducts downtime (~5000 remaining)",
+      s && near(s.remainingTime, 5000, 700), s && Math.round(s.remainingTime));
+    n2.receive({ payload: "stop" });
+    await n2.close(true);
+  }
+
+  console.log(failures === 0 ? "\nALL OPEN-ITEM-1 TESTS PASSED" : "\n" + failures + " FAILURE(S)");
+  process.exit(failures === 0 ? 0 : 1);
+})();

package/test-scripts/test-redundant-stop.js

@@ -0,0 +1,190 @@
+// Tests for fix #5 (Option A): stop while truly idle (stopped/expired) is a
+// redundant command - ignored:true on output 4, zero state change, no
+// _timerpass arming. Stop stays genuine for running/paused/cooldown.
+// Redundant disable harmonized to no-increment. Blocked idle starts still
+// count (command-redundancy-only scope).
+"use strict";
+const os = require("os");
+const fs = require("fs");
+const path = require("path");
+
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+let failures = 0;
+function check(label, cond, detail) {
+  if (cond) { console.log("PASS  " + label); }
+  else { failures++; console.log("FAIL  " + label + (detail !== undefined ? "  [" + detail + "]" : "")); }
+}
+
+function makeRED(userDir) {
+  const registered = {};
+  return {
+    nodes: {
+      registerType(name, ctor) { registered[name] = ctor; },
+      createNode(node, n) {
+        node.id = n.id;
+        node._handlers = {};
+        node.on = function(evt, fn) { node._handlers[evt] = fn; };
+        node.receive = function(msg) { node._handlers["input"](msg); };
+        node.close = function(removed) {
+          return new Promise(res => node._handlers["close"](removed, res));
+        };
+        node.sent = [];
+        node.send = function(arr) { node.sent.push(arr); };
+        node.status = function() {};
+        node.warn = function() {};
+        node.error = function(e) { console.log("NODE ERROR:", e); };
+      },
+      get(name) { return registered[name]; }
+    },
+    util: {
+      cloneMessage(m) { return JSON.parse(JSON.stringify(m || {})); },
+      evaluateNodeProperty(v) { return v; }
+    },
+    settings: { userDir: userDir }
+  };
+}
+
+function events(node, type) {
+  const out = [];
+  for (const arr of node.sent) for (const m of arr) if (m && m.timerEvent === type) out.push(m);
+  return out;
+}
+function output2(node) { return node.sent.map(a => a[1]).filter(Boolean); }
+function lastEvent(node, type) { const e = events(node, type); return e.length ? e[e.length - 1] : null; }
+
+function makeNode(RED, cfg) {
+  const Ctor = RED.nodes.get("timer-events");
+  const node = {};
+  Ctor.call(node, Object.assign({
+    id: "x" + Math.random().toString(36).slice(2),
+    duration: "5", durationType: "num", units: "Second",
+    reporting: "none", reportingformat: "seconds",
+    persist: false, ignoretimerpass: false, donotresettimer: false,
+    thresholdaction: "donothing", thresholdcount: "0",
+    thresholdaddtime: "0", thresholdaddtimeunits: "Second",
+    heartbeatinterval: "0", heartbeatintervalunits: "Second",
+    cooldownduration: "0", cooldownunits: "Second"
+  }, cfg));
+  return node;
+}
+
+(async function main() {
+  const userDir = fs.mkdtempSync(path.join(os.tmpdir(), "timerevents-t5-"));
+  const RED = makeRED(userDir);
+  require("/home/claude/timer-events.js")(RED);
+
+  // -- X1: stop on a never-started node -> ignored, output 4 only ------------
+  {
+    const n = makeNode(RED);
+    n.receive({ payload: "stop" });
+    const st = lastEvent(n, "stopped");
+    check("X1a stop while stopped -> ignored:true on output 4",
+      st && st.ignored === true && st.timerState === "stopped", st && st.ignored + "/" + st.timerState);
+    check("X1b nothing on output 2 (was: phantom stop)",
+      output2(n).length === 0, output2(n).length);
+    await n.close(false);
+  }
+
+  // -- X2: stop after natural expiry -> ignored, state stays expired ---------
+  {
+    const n = makeNode(RED, { duration: "1", donotresettimer: true });
+    n.receive({ payload: "go" });
+    await sleep(500);
+    n.receive({ payload: "poke" }); // ignoredCount 1 during the run
+    await sleep(800);               // expire (expiry resets count to 0)
+    n.sent.length = 0;
+    n.receive({ payload: "stop" });
+    const st = lastEvent(n, "stopped");
+    check("X2a stop after expiry -> ignored:true, state stays 'expired' (was: flip to stopped)",
+      st && st.ignored === true && st.timerState === "expired", st && st.timerState);
+    check("X2b no phantom stop on output 2", output2(n).length === 0, output2(n).length);
+    check("X2c zero counter touch", st && st.ignoredCount === 0 && st.lastIgnoredTime === null,
+      st && st.ignoredCount + "/" + st.lastIgnoredTime);
+    n.receive({ payload: "stop" }); // second redundant stop, same treatment
+    check("X2d repeated stops all ignored", events(n, "stopped").every(e => e.ignored === true) && events(n, "stopped").length === 2, events(n, "stopped").length);
+    await n.close(false);
+  }
+
+  // -- X3: post-expiry stop no longer arms the _timerpass filter -------------
+  {
+    const n = makeNode(RED, { duration: "1" });
+    n.receive({ payload: "go" });
+    await sleep(1300); // expire
+    n.receive({ payload: "stop" }); // ignored - must NOT arm the filter
+    n.sent.length = 0;
+    n.receive({ payload: "go", _timerpass: true }); // would die if filter were armed
+    const s = lastEvent(n, "started");
+    check("X3 _timerpass msg starts normally after ignored stop (filter not armed)",
+      s && s.ignored === false, s && (s.timerEvent + "/" + s.ignored));
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- X4: regression - genuine stop still arms _timerpass filter ------------
+  {
+    const n = makeNode(RED);
+    n.receive({ payload: "go" });
+    await sleep(300);
+    n.receive({ payload: "stop" }); // genuine stop -> filter armed
+    check("X4a genuine stop fires on output 2", output2(n).length === 1 && output2(n)[0].timerEvent === "stopped", output2(n).length);
+    n.sent.length = 0;
+    n.receive({ payload: "go", _timerpass: true }); // must die silently
+    check("X4b armed filter still swallows _timerpass msg (no output at all)",
+      n.sent.length === 0, n.sent.length);
+    n.receive({ payload: "stop", _timerpass: true }); // stop variant also swallowed
+    check("X4c armed filter swallows _timerpass stop too (preserved edge)",
+      n.sent.length === 0, n.sent.length);
+    n.receive({ payload: "go" }); // plain msg disarms and starts
+    check("X4d plain msg still starts normally", !!lastEvent(n, "started"));
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- X5: regression - stop stays genuine for paused and cooldown -----------
+  {
+    const n = makeNode(RED, { duration: "5" });
+    n.receive({ payload: "go" });
+    await sleep(300);
+    n.receive({ payload: "pause" });
+    n.sent.length = 0;
+    n.receive({ payload: "stop" });
+    check("X5a stop while paused is genuine (output 2)",
+      output2(n).length === 1 && lastEvent(n, "stopped").ignored === false, output2(n).length);
+    await n.close(false);
+
+    const c = makeNode(RED, { duration: "1", cooldownduration: "10" });
+    c.receive({ payload: "go" });
+    await sleep(1300); // expire into cooldown
+    c.sent.length = 0;
+    c.receive({ payload: "stop" });
+    const st = lastEvent(c, "stopped");
+    check("X5b stop during cooldown is genuine and cancels it",
+      output2(c).length === 1 && st.ignored === false && st.timerState === "stopped", st && st.timerState);
+    await c.close(false);
+  }
+
+  // -- X6: disable harmonized; blocked idle starts still count ---------------
+  {
+    const n = makeNode(RED);
+    n.receive({ payload: "disable" });  // genuine
+    n.receive({ payload: "disable" });  // redundant - no longer increments
+    n.receive({ payload: "disable" });  // redundant
+    let d = lastEvent(n, "disabled");
+    check("X6a redundant disable no longer increments (was: lone oddball)",
+      d && d.ignored === true && d.ignoredCount === 0 && d.lastIgnoredTime === null,
+      d && d.ignoredCount);
+    n.receive({ payload: "go" });       // blocked idle start - MUST still count
+    n.receive({ payload: "go" });
+    let s = lastEvent(n, "started");
+    check("X6b blocked idle starts still increment (scope: command redundancy only)",
+      s && s.ignored === true && s.ignoredCount === 2 && s.lastIgnoredTime !== null, s && s.ignoredCount);
+    n.receive({ payload: "stop" });     // stop while idle+disabled: redundant, zero touch
+    let st = lastEvent(n, "stopped");
+    check("X6c redundant stop while disabled leaves blocked-start count intact",
+      st && st.ignored === true && st.ignoredCount === 2, st && st.ignoredCount);
+    await n.close(false);
+  }
+
+  console.log(failures === 0 ? "\nALL #5 TESTS PASSED" : "\n" + failures + " FAILURE(S)");
+  process.exit(failures === 0 ? 0 : 1);
+})();