node-red-contrib-timer-events 0.1.0

package/test-scripts/test-restore.js

@@ -0,0 +1,147 @@
+// Tests for fix #3: running restore is a continuation of the same run.
+// Simulates a Node-RED restart by constructing a node, running it, closing
+// it (persist file survives), sleeping to simulate downtime, then
+// reconstructing a node with the same id.
+"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 output1(node) { return node.sent.map(a => a[0]).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: "fixed-id", duration: "10", durationType: "num", units: "Second",
+    reporting: "none", reportingformat: "seconds",
+    persist: true, ignoretimerpass: false, donotresettimer: true,
+    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-t3-"));
+  const RED = makeRED(userDir);
+  require("/home/claude/timer-events.js")(RED);
+
+  // ---- Phase 1: run, accumulate ignored count, persist, "shut down" --------
+  const n1 = makeNode(RED, { reporting: "every_second" }); // persisted reporting differs from phase-2 config
+  n1.receive({ payload: "go", runTag: "original-run" });
+  await sleep(1500);
+  n1.receive({ payload: "poke1" });   // ignored (locked) -> ignoredCount 1
+  n1.receive({ payload: "poke2" });   // ignored          -> ignoredCount 2
+  n1.receive({ payload: "adjusttime", adjusttime: 0 }); // triggers writeState with current bookkeeping
+  await sleep(1500);                   // ~3s elapsed total
+  const preQ = (n1.receive({ payload: "query" }), lastEvent(n1, "query"));
+  await n1.close(false);               // persist file survives (not removed)
+
+  // ---- Phase 2: 2s of simulated Node-RED downtime, then restore ------------
+  await sleep(2000);
+  const restoreAt = Date.now();
+  const n2 = makeNode(RED, { reporting: "none" }); // freshly-deployed config differs from persisted
+  await sleep(200); // let restore-driven dispatch settle
+
+  const started = lastEvent(n2, "started");
+  check("V1a restore fires started, output 1, source internal",
+    output1(n2).length === 1 && started && started.source === "internal" && started.ignored === false,
+    output1(n2).length + "/" + (started && started.source));
+  check("V1b original timerDuration preserved: 10000 (was: remaining time)",
+    started && started.timerDuration === 10000, started && started.timerDuration);
+  check("V1c ignoredCount survives restore: 2 (was: reset to 0)",
+    started && started.ignoredCount === 2 && started.lastIgnoredTime !== null,
+    started && started.ignoredCount + "/" + started.lastIgnoredTime);
+  // ~3s original elapsed + ~2s downtime = ~5s elapsed; remaining ~5s
+  check("V1d elapsedTime reflects run + downtime (~5000ms)",
+    started && near(started.elapsedTime, 5000, 700), started && started.elapsedTime);
+  check("V1e elapsed + remaining reconciles with duration",
+    started && near(started.elapsedTime + started.remainingTime, started.timerDuration, 700),
+    started && Math.round(started.elapsedTime + started.remainingTime));
+  check("V1f remaining carried over minus downtime (~5000ms, was ~7000 pre-shutdown)",
+    started && near(started.remainingTime, 5000, 700) && near(preQ.remainingTime, 7000, 700),
+    started && Math.round(started.remainingTime) + " (pre: " + Math.round(preQ.remainingTime) + ")");
+
+  // ---- V2: fresh config wins over persisted reporting settings -------------
+  check("V2 freshly-deployed reporting config wins (was: persisted 'every_second')",
+    n2.reporting === "none", n2.reporting);
+
+  // ---- V3: restored run expires at the original wall-clock target ----------
+  await new Promise(res => {
+    const iv = setInterval(() => { if (lastEvent(n2, "expired")) { clearInterval(iv); res(); } }, 100);
+  });
+  const ranFor = Date.now() - restoreAt;
+  check("V3 restored run expires after ~remaining (~5s), not full duration",
+    near(ranFor, 5000, 800), ranFor);
+  const exp = lastEvent(n2, "expired");
+  check("V3b expired event still reports the original duration",
+    exp && exp.timerDuration === 10000, exp && exp.timerDuration);
+  await n2.close(true);
+
+  // ---- V4: regression - a normal start still resets run identity -----------
+  {
+    const n = makeNode(RED, { id: "fresh-id", persist: false });
+    n.receive({ payload: "go" });
+    await sleep(500);
+    n.receive({ payload: "poke" }); // ignored -> count 1
+    n.receive({ payload: "stop" });
+    n.receive({ payload: "unlock" });   // allow normal restart behavior
+    n.sent.length = 0;
+    n.receive({ payload: "go2" });
+    const s = lastEvent(n, "started");
+    check("V4 normal start resets ignoredCount and sets fresh duration",
+      s && s.ignoredCount === 0 && s.lastIgnoredTime === null && s.timerDuration === 10000 && s.elapsedTime <= 50,
+      s && s.ignoredCount + "/" + s.timerDuration + "/" + s.elapsedTime);
+    n.receive({ payload: "stop" });
+    await n.close(true);
+  }
+
+  console.log(failures === 0 ? "\nALL #3 TESTS PASSED" : "\n" + failures + " FAILURE(S)");
+  process.exit(failures === 0 ? 0 : 1);
+})();

package/test-scripts/test-status-flicker.js

@@ -0,0 +1,143 @@
+// Tests for the status-flicker fix: the unconditional node.status({}) at
+// the top of handleInputEvent is gone. Verifies (a) a query against a
+// running timer never emits an empty status call, and (b) every command
+// path still ends with a non-empty status of its own (the invariant that
+// replaced the blanket blank).
+"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 isBlank(s) { return !s || Object.keys(s).length === 0 || (!s.text && !s.fill && !s.shape); }
+
+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.statusCalls = [];            // record every status call
+        node.status = function(s) { node.statusCalls.push(s); };
+        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 makeNode(RED, cfg) {
+  const Ctor = RED.nodes.get("timer-events");
+  const node = {};
+  Ctor.call(node, Object.assign({
+    id: "s" + Math.random().toString(36).slice(2),
+    duration: "10", 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-flicker-"));
+  const RED = makeRED(userDir);
+  require("/home/claude/timer-events.js")(RED);
+
+  // -- F1: the flicker itself - query against a running timer ----------------
+  {
+    const n = makeNode(RED);
+    n.receive({ payload: "go" });
+    await sleep(300);
+    n.statusCalls.length = 0;
+    n.receive({ payload: "query" });
+    check("F1a query emits no blank status call (was: blank-then-repaint flicker)",
+      n.statusCalls.every(s => !isBlank(s)), JSON.stringify(n.statusCalls));
+    check("F1b query still repaints a non-empty status",
+      n.statusCalls.length >= 1 && !isBlank(n.statusCalls[n.statusCalls.length - 1]),
+      JSON.stringify(n.statusCalls[n.statusCalls.length - 1]));
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- F2: sweep - every command path ends with a non-empty status -----------
+  // Sequence chosen to hit genuine AND redundant/ignored branches of each
+  // handler, plus the gates, across running / paused / idle states.
+  {
+    const n = makeNode(RED, { donotresettimer: false });
+    const steps = [
+      { payload: "go" },                                   // start (startReporting paints)
+      { payload: "go" },                                   // restart
+      { payload: "lock" },                                 // genuine lock
+      { payload: "lock" },                                 // redundant lock
+      { payload: "poke" },                                 // lock gate (blocked restart)
+      { payload: "unlock" },                               // genuine unlock
+      { payload: "unlock" },                               // redundant unlock
+      { payload: "adjusttime", adjusttime: 1000 },         // genuine adjust
+      { payload: "adjusttime", adjusttime: "bad" },        // rejected adjust
+      { payload: "settime", settime: 5000 },               // genuine settime
+      { payload: "settime", settime: -1 },                 // rejected settime
+      { payload: "setduration", setduration: 8000 },       // genuine setduration
+      { payload: "setduration", setduration: "bad" },      // rejected setduration
+      { payload: "pause" },                                // genuine pause
+      { payload: "pause" },                                // redundant pause
+      { payload: "poke" },                                 // paused gate
+      { payload: "resume" },                               // genuine resume
+      { payload: "resume" },                               // redundant resume
+      { payload: "disable" },                              // genuine disable
+      { payload: "disable" },                              // redundant disable
+      { payload: "stop" },                                 // genuine stop
+      { payload: "stop" },                                 // redundant stop (idle)
+      { payload: "go" },                                   // blocked start (disabled gate)
+      { payload: "enable" },                               // genuine enable
+      { payload: "enable" },                               // redundant enable
+      { payload: "query" }                                 // query while idle
+    ];
+    let ok = true, failedAt = null;
+    for (const m of steps) {
+      n.statusCalls.length = 0;
+      n.receive(m);
+      const last = n.statusCalls[n.statusCalls.length - 1];
+      if (n.statusCalls.length === 0 || isBlank(last)) { ok = false; failedAt = JSON.stringify(m); break; }
+    }
+    check("F2 all 26 command paths end with a non-empty status (invariant holds)", ok, failedAt);
+    await n.close(false);
+  }
+
+  // -- F3: close handler still blanks (unrelated blank preserved) ------------
+  {
+    const n = makeNode(RED);
+    n.receive({ payload: "go" });
+    n.receive({ payload: "stop" });
+    n.statusCalls.length = 0;
+    await n.close(false);
+    check("F3 node close still blanks the status (deliberate blank preserved)",
+      n.statusCalls.length === 1 && isBlank(n.statusCalls[0]), JSON.stringify(n.statusCalls));
+  }
+
+  console.log(failures === 0 ? "\nALL FLICKER TESTS PASSED" : "\n" + failures + " FAILURE(S)");
+  process.exit(failures === 0 ? 0 : 1);
+})();

package/test-scripts/test-threshold-scope.js

@@ -0,0 +1,148 @@
+// Tests for fix #2: threshold actions scoped to an active run (running/paused).
+// U1-U3 verify the fixed idle behavior; U4-U5 verify no regression to the
+// legitimate paused-gate and lock-gate threshold paths.
+"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) { // messages that appeared on output 2 specifically
+  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: "u" + 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-t2-"));
+  const RED = makeRED(userDir);
+  require("/home/claude/timer-events.js")(RED);
+
+  // -- U1: idle + disabled + Add Time threshold must NOT start the timer -----
+  {
+    const n = makeNode(RED, { thresholdaction: "addtime", thresholdcount: "2", thresholdaddtime: "10", donotresettimer: true });
+    n.receive({ payload: "disable" });
+    for (let i = 0; i < 4; i++) n.receive({ payload: "go" }); // 4 blocked starts, threshold=2 hit twice
+    await sleep(300);
+    const q = (n.receive({ payload: "query" }), lastEvent(n, "query"));
+    check("U1a timer stays idle (was: Add Time started it)", q.timerState === "stopped", q.timerState);
+    check("U1b no timeadjusted fired from idle", events(n, "timeadjusted").length === 0, events(n, "timeadjusted").length);
+    check("U1c blocked starts still counted", q.ignoredCount === 4, q.ignoredCount);
+    const blocked = events(n, "started").filter(e => e.ignored === true);
+    check("U1d each block still observable on output 4", blocked.length === 4, blocked.length);
+    await n.close(false);
+  }
+
+  // -- U2: idle + disabled + Stop threshold -> no phantom stop on output 2 ---
+  {
+    const n = makeNode(RED, { thresholdaction: "stop", thresholdcount: "2" });
+    n.receive({ payload: "disable" });
+    for (let i = 0; i < 3; i++) n.receive({ payload: "go" });
+    check("U2 no phantom stopped on output 2", output2(n).length === 0, output2(n).length);
+    await n.close(false);
+  }
+
+  // -- U3: cooldown + Restart threshold -> still never fires (unchanged) -----
+  {
+    const n = makeNode(RED, { duration: "1", cooldownduration: "5", thresholdaction: "reset", thresholdcount: "1" });
+    n.receive({ payload: "go" });
+    await sleep(1300); // expire into cooldown
+    n.sent.length = 0;
+    for (let i = 0; i < 3; i++) n.receive({ payload: "go" }); // blocked by cooldown
+    check("U3a no restart fired during cooldown", events(n, "restarted").length === 0, events(n, "restarted").length);
+    const q = (n.receive({ payload: "query" }), lastEvent(n, "query"));
+    check("U3b still in cooldown", q.timerState === "cooldown", q.timerState);
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- U4: regression - lock gate + Add Time threshold still fires while running
+  {
+    const n = makeNode(RED, { duration: "10", donotresettimer: true, thresholdaction: "addtime", thresholdcount: "2", thresholdaddtime: "5" });
+    n.receive({ payload: "go" });
+    await sleep(500);
+    n.receive({ payload: "poke1" });
+    n.receive({ payload: "poke2" }); // hits threshold
+    const a = lastEvent(n, "timeadjusted");
+    check("U4a Add Time still fires for a running locked timer", !!a && a.source === "internal" && a.timeAdjusted === 5000, a && a.timeAdjusted);
+    check("U4b remaining reflects the added time (~14500ms)", a && Math.abs(a.remainingTime - 14500) <= 400, a && a.remainingTime);
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- U5: regression - paused gate + Restart threshold fires, stays paused --
+  {
+    const n = makeNode(RED, { duration: "10", thresholdaction: "reset", thresholdcount: "2" });
+    n.receive({ payload: "go" });
+    await sleep(2000);
+    n.receive({ payload: "pause" });
+    n.receive({ payload: "poke1" });
+    n.receive({ payload: "poke2" }); // hits threshold while paused
+    const r = events(n, "restarted").filter(e => e.ignored === false && e.source === "internal");
+    check("U5a Restart threshold still fires from the paused gate", r.length === 1, r.length);
+    const q = (n.receive({ payload: "query" }), lastEvent(n, "query"));
+    check("U5b stays paused at full duration", q.timerState === "paused" && q.remainingTime === 10000, q.timerState + "/" + q.remainingTime);
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  console.log(failures === 0 ? "\nALL #2 TESTS PASSED" : "\n" + failures + " FAILURE(S)");
+  process.exit(failures === 0 ? 0 : 1);
+})();

package/test-scripts/test-validation.js

@@ -0,0 +1,198 @@
+// Tests for fix #4: numeric validation of msg.delay, adjusttime, settime,
+// setduration. Malformed values must be rejected cleanly (ignored:true or
+// documented fallback) with zero state corruption; all previously-valid
+// inputs must behave identically, including adjusttime: 0 (accepted per
+// explicit decision) and fractional delays.
+"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 makeNode(RED, cfg) {
+  const Ctor = RED.nodes.get("timer-events");
+  const node = {};
+  Ctor.call(node, Object.assign({
+    id: "w" + Math.random().toString(36).slice(2),
+    duration: "10", 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-t4-"));
+  const RED = makeRED(userDir);
+  require("/home/claude/timer-events.js")(RED);
+
+  // -- W1: msg.delay unconvertible ("5s") -> documented fallback -------------
+  {
+    const n = makeNode(RED);
+    n.receive({ payload: "go", delay: "5s" });
+    const s = lastEvent(n, "started");
+    check("W1 delay '5s' falls back to configured 10000ms (was: NaN corruption)",
+      s && near(s.remainingTime, 10000, 50) && s.timerDuration === 10000, s && s.remainingTime);
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- W2: msg.delay negative -> documented clamp to 0 ------------------------
+  {
+    const n = makeNode(RED);
+    n.receive({ payload: "go", delay: -5 });
+    await sleep(300);
+    const e = lastEvent(n, "expired");
+    check("W2 negative delay clamps to 0 and expires immediately (was: negative remaining)",
+      !!e && e.timerDuration === 0, e && e.timerDuration);
+    await n.close(false);
+  }
+
+  // -- W3: fractional delay still works (regression) -------------------------
+  {
+    const n = makeNode(RED);
+    n.receive({ payload: "go", delay: 2.5, units: "seconds" });
+    const s = lastEvent(n, "started");
+    check("W3 fractional delay 2.5s -> 2500ms preserved", s && s.remainingTime === 2500, s && s.remainingTime);
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- W4: msg.delay empty string -> fallback, not zero -----------------------
+  {
+    const n = makeNode(RED);
+    n.receive({ payload: "go", delay: "" });
+    const s = lastEvent(n, "started");
+    check("W4 empty-string delay falls back to configured (Number('') is 0 trap)",
+      s && s.remainingTime === 10000, s && s.remainingTime);
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- W5: adjusttime missing / non-numeric -> ignored, timer unharmed --------
+  {
+    const n = makeNode(RED);
+    n.receive({ payload: "go" });
+    await sleep(1000);
+    n.receive({ payload: "adjusttime" });                    // property missing entirely
+    let a1 = lastEvent(n, "timeadjusted");
+    check("W5a missing adjusttime -> ignored:true, null attempted value",
+      a1 && a1.ignored === true && a1.timeAdjusted === null, a1 && (a1.ignored + "/" + a1.timeAdjusted));
+    n.receive({ payload: "adjusttime", adjusttime: "abc" }); // non-numeric
+    let a2 = lastEvent(n, "timeadjusted");
+    check("W5b non-numeric adjusttime -> ignored:true, raw value attached",
+      a2 && a2.ignored === true && a2.timeAdjusted === "abc", a2 && a2.timeAdjusted);
+    n.receive({ payload: "query" });
+    const q = lastEvent(n, "query");
+    check("W5c remaining time unharmed (~9000ms, was: NaN)",
+      q && near(q.remainingTime, 9000, 300), q && q.remainingTime);
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- W6: settime NaN passes-as-valid hole closed; valid settime unchanged ---
+  {
+    const n = makeNode(RED);
+    n.receive({ payload: "go" });
+    await sleep(500);
+    n.receive({ payload: "settime", settime: "abc" });
+    let t1 = lastEvent(n, "timeset");
+    check("W6a non-numeric settime -> ignored:true (NaN<=0 hole closed)",
+      t1 && t1.ignored === true && t1.timeSet === "abc", t1 && t1.timeSet);
+    n.receive({ payload: "settime", settime: 4000 });        // regression: valid still works
+    let t2 = lastEvent(n, "timeset");
+    check("W6b valid settime 4000 still applies",
+      t2 && t2.ignored === false && near(t2.remainingTime, 4000, 50), t2 && t2.remainingTime);
+    n.receive({ payload: "settime", settime: -1 });          // regression: <=0 still rejected
+    let t3 = lastEvent(n, "timeset");
+    check("W6c settime <= 0 still rejected, attempted value attached (ms default)",
+      t3 && t3.ignored === true && t3.timeSet === -1, t3 && t3.timeSet);
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- W7: setduration NaN can no longer poison the next run ------------------
+  {
+    const n = makeNode(RED);
+    n.receive({ payload: "setduration", setduration: "abc" });
+    let d1 = lastEvent(n, "durationset");
+    check("W7a non-numeric setduration -> ignored:true",
+      d1 && d1.ignored === true && d1.durationSet === "abc", d1 && d1.durationSet);
+    n.receive({ payload: "go" });
+    let s1 = lastEvent(n, "started");
+    check("W7b next run unpoisoned: starts at configured 10000ms (was: NaN)",
+      s1 && near(s1.remainingTime, 10000, 50), s1 && s1.remainingTime);
+    n.receive({ payload: "stop" });
+    n.receive({ payload: "setduration", setduration: 3, setdurationunits: "seconds" }); // regression
+    n.receive({ payload: "go2" });
+    let s2 = lastEvent(n, "started");
+    check("W7c valid setduration still applies to next run (3000ms)",
+      s2 && near(s2.remainingTime, 3000, 50), s2 && s2.remainingTime);
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  // -- W8: adjusttime 0 is processed, NOT flagged ignored (explicit decision) -
+  {
+    const n = makeNode(RED);
+    n.receive({ payload: "go" });
+    await sleep(500);
+    n.receive({ payload: "adjusttime", adjusttime: 0 });
+    const a = lastEvent(n, "timeadjusted");
+    check("W8 adjusttime 0 accepted as successful no-op",
+      a && a.ignored === false && a.timeAdjusted === 0 && near(a.remainingTime, 9500, 300),
+      a && (a.ignored + "/" + a.timeAdjusted + "/" + Math.round(a.remainingTime)));
+    n.receive({ payload: "stop" });
+    await n.close(false);
+  }
+
+  console.log(failures === 0 ? "\nALL #4 TESTS PASSED" : "\n" + failures + " FAILURE(S)");
+  process.exit(failures === 0 ? 0 : 1);
+})();