node-red-contrib-energymeterplus 0.3.4 → 0.3.6

package/README.md

@@ -1,224 +1,139 @@
-#### **EnergyMeterPlus Node Version 0.3.0**
+##### **EnergyMeterPlus** Node Version 1.0.1
+@ arcfrankye 26-06-26
 
 
 
-##### **Overview:**
+###### Overview
+**EnergyMeterPlus** node converts instantaneous power readings into accumulated energy totals and cost, with robust baseline handling and safer editor UX. **EnergyMeterPlus** integrates power over time, applies one-time baseline offsets, prevents accidental double application, handles rollovers, persists state, and writes snapshots to disk.
 
+Version numbers indicate the quality of the build. Main numbers are used for stable and tested builds; sub numbers are used for test editions still undergoing debugging. Use **EnergyMeterPlus** at your own risk.
 
 
-EnergyMeterPlus is a custom Node‑RED function node designed to convert instantaneous power readings (Watts) into accumulated energy values (kWh) over time. It integrates power based on elapsed time between samples, applies baseline corrections, calculates costs, and persists totals across restarts.
+###### Key Features
+* **Time integration** of power (W or kW) into energy (kWh).
+* **Daily, weekly, monthly, yearly** energy totals.
+* **Cost calculations** using a configurable unit cost and currency symbol.
+* **One-time baseline offsets**: editor lets you apply offsets once; runtime applies only the delta and stores what was applied.
+* **Editor UX improvements**: inputs show saved values, an **Apply** button greys inputs and marks them applied, and a **Reset** button re-enables inputs.
+* **Safe deploy behavior**: editor changes are saved to node config; runtime applies offsets on Deploy only when flagged applied.
+* **Runtime messages for immediate control**: `applyBaseline` and `resetEditorApplied`.
+* **Rollover handling** for day, week, month, year, with yearly archiving.
+* **Persistence**: counters and timestamps in Node-RED context; snapshots written to JSON file; directories auto-created.
+* **Defensive parsing and logging**: numeric guards, error handling, and clear log messages for deploy and runtime actions.
 
 
+###### Configuration Options
 
+**Unit Cost**:
+* Cost per kWh (e.g., `0.15` for $0.15/kWh).
 
+**Currency**:
+* Choose USD, EUR, or NGN. The node uses a symbol for display, no currency conversion.
 
-##### **Features:**
+**File Path**:
+* Path to write snapshots (default: `/config/node\\\\\\\_red/solargen\\\\\\\_data.json`). Directories are created automatically.
 
+**Input Unit**:
+* "W" (Watts) or "kW" (kilowatts). If using Watts, the node converts to kW internally.
 
 
-* Converts power (W) into energy (kWh) using time integration.
+**Baseline Offsets**
+* Baseline Daily, Weekly, Monthly, Yearly: enter offsets in the editor.
 
 
+**Apply Workflow**: 
+* Click **Apply** in the editor to mark offsets as applied (inputs grey out). Click **Done,** then **Deploy** to persist and have the runtime apply the offsets once.
 
-* Tracks daily, weekly, monthly, and yearly energy totals.
 
+**Reset**: 
+* Click **Reset** in the editor to re-enable inputs; on the next **Deploy,** the runtime will allow reapply. You can also send a runtime reset message to clear memory immediately.
 
 
-* Calculates costs based on a configurable unit cost.
+**Runtime Messages:**
+* Immediate apply without **Deploy**. Send a message to the node: json { "topic": "applyBaseline", "payload": { "daily": 2, "weekly": 0, "monthly": 0, "yearly": 0 } }. This applies the provided offsets immediately (additive).
 
 
+**Clear Remembered Editor Application**:  
+* Send a message to the node: json { "topic": "resetEditorApplied" }.  This clears the runtime `lastAppliedEditor` so the same editor values can be applied again on the next **Deploy**.
 
-* Unit cost configurable in 3 different currencies
 
+###### Output Payload
+The node outputs a `msg.payload` object with rounded values (two decimals): 
 
+ "energyDaily": 4.53,
 
-* Supports baseline corrections to start counters from existing values.
+ "energyWeekly": 32.18,
 
+ "energyMonthly": 128.74,
 
+ "energyYearly": 1024.56,
 
-* Handles rollover at day, week, month, and year boundaries.
+ "daily\\\\\\\_cost": 0.68,
 
+ "weekly\\\\\\\_cost": 4.83,
 
+ "monthly\\\\\\\_cost": 19.31,
 
-* Persists counters and timestamps in Node‑RED context and writes snapshots to file.
+ "yearly\\\\\\\_cost": 153.68,
 
+ "currency": "?"   
 
+Note: field names are `energyDaily`, `energyWeekly`, `energyMonthly`, `energyYearly` in the runtime implementation.
 
-* Outputs clean values rounded to two decimal places for dashboards.
 
+###### Rollover Rules
+* **Daily** resets at midnight (local time).
+* **Weekly** resets when the week boundary is reached (implementation assumes the week starts on Mondays).
+* **Monthly** resets on the month change.
+* **Yearly** resets on year change and archives the previous year's total to `yearly\_archive.json`.
 
 
+###### Persistence and Safety
+* **Context storage**: baseline, accumulated totals, last check timestamp, and `lastAppliedEditor` are stored in Node-RED context.
+* **File snapshots**: written to the configured JSON file on each output.
+* **Robustness**: numeric parsing guards, try/catch around file I/O, and logs for deploy/runtime actions to help debugging.
 
 
-##### **Configuration:**
+###### Editor UX Behavior
+* **Inputs** show saved values when opening the editor, so you can see what was last applied.
+* **Apply** button greys inputs and sets an `applied` flag; click \*\*Done\*\* then \*\***Deploy**\*\* to have runtime apply offsets once.
+* **Reset** button re-enables inputs and clears the `applied` flag; \*\*Deploy\*\* will then allow reapply.
+* **One-time semantics**: runtime computes `delta = editor - lastAppliedEditor` and applies only non-zero delta. Repeated \*\*Deploy\*\*s with identical editor values do not reapply offsets.
 
 
+###### Troubleshooting Tips
+* If baseline edits do not mark the flow dirty, ensure the editor `oneditsave` saves values to `this.baseline` and `this.applied`.
+* Use **Full Deploy** when testing editor/runtime changes to ensure constructors run.
+* Check Node-RED logs for messages like `Editor baseline applied on deploy (delta)` or `Comms applyBaseline: no delta to apply`.
+* If you need immediate effect without **Deploy**, use the `applyBaseline` inject message shown above.
 
-Unit Cost: Cost per kWh (e.g., 0.15 for $0.15/kWh).
 
+###### Examples
+* **Apply** 5 kWh daily offset via editor: enter `5` in Baseline Daily, click **Apply**, **Done**, then **Deploy**. Runtime will add the delta once.
+* **Immediate runtime apply**: inject `{ topic: "applyBaseline", payload: { "daily": 2 } }` to add 2 kWh immediately.
 
 
-Currency: Choose USD, EUR, or NGN (fixed values, not convertible)
+###### Changelog
+**v1.0.1**
+* Major UI and runtime overhaul. Editor shows saved values, adds Apply and Reset controls, greys inputs after Apply, and persists an `applied` flag. Runtime applies editor offsets exactly once using delta logic and stores `lastAppliedEditor`. Added safer rollover and logging.
 
+**v0.2.5**
+* Fixed internal counter bug.
 
+**v0.2.4**
+* Fixed incremental counter update bug. Added payload validation. Baselines captured once and survive UI clearing.
 
-File Path: Path to store snapshots (default: /config/node\_red/solargen\_data.json).
+**v0.2.3**
+* Fixed baseline visibility bug after applying. Fixed rollover double-counting. Baselines are applied once and stored in context. Counters updated continuously.
 
+**v0.0.3**
+* Initial release: integrates power to energy, cost calc, rollovers, persistence, and basic baseline support.
 
 
-Input Unit: "W" for Watts (default) or "kW" if your source already provides kilowatts.
 
 
 
-Baselines: Initial values for daily, weekly, monthly, and yearly counters. Can also be used to correct baseline values or left blank if not needed. Baseline values are applied once at startup or upon a config change and are cleared from the UI. New values can be entered as needed, and the cycle repeats.
 
 
 
 
-
-###### **Output:**
-
-
-
-The node outputs a payload object:
-
-
-
-json
-
-{
-
-  "daily\_kWh": 4.53,
-
-  "weekly\_kWh": 32.18,
-
-  "monthly\_kWh": 128.74,
-
-  "yearly\_kWh": 1024.56,
-
-  "daily\_cost": 0.68,
-
-  "weekly\_cost": 4.83,
-
-  "monthly\_cost": 19.31,
-
-  "yearly\_cost": 153.68
-
-}
-
-All values are rounded to two decimal places.
-
-
-
-
-
-###### **Rollover Logic:**
-
-
-
-* Daily resets at midnight.
-* 
-* Weekly resets on Sunday.
-* 
-* Monthly resets on the first of the month.
-* 
-* Yearly resets on January 1st and archives the previous year’s totals.
-
-
-
-
-
-###### **Persistence:**
-
-
-
-Counters and timestamps are stored in Node‑RED context.
-
-
-
-Snapshots are written to the configured JSON file.
-
-
-
-Directories are auto‑created if missing, ensuring no ENOENT errors.
-
-
-
-
-
-##### **Example:**
-
-
-
-If your solar system outputs \~4526 W continuously:
-
-
-
-After 1 hour → \~4.53 kWh added to daily total.
-
-
-
-After 24 hours → \~108.6 kWh added to daily total.
-
-
-
-Costs scale automatically with your configured unit cost.
-
-
-
-
-
-##### **Updates:**
-
-
-
-###### **v2.3:**
-
-
-
-Cleared bug where baseline values remain visible after applying the values
-
-
-
-Cleared the rollover logic to eliminate double-counting.
-
-
-
-Baselines now applied once and stored in context.
-
-
-
-updated counters to continuous absorption, no transfer at rollover
-
-
-
-###### **v2.4**
-
-
-
-Fixed a bug where the internal counters were not updating incrementally.
-
-
-
-Added payload validation
-
-
-
-Fixed Baselines bug: Baselines captured once, stored in context, and survive after UI clears
-
-
-
-###### **v2.5**
-
-
-
-Fixed internal counter bug
-
-
-
-###### **v3.0**
-
-
-
-**Major overhaul of UI and internal logic programming to fix bugs in counters and baseline corrections**
-

package/energyMeterPlus.html

@@ -1,67 +1,134 @@
+/*
+* energyMeterPlus Editor UX  #arcfrankye - 27/06/2026
+*/
 
 <script type="text/javascript">
-    RED.nodes.registerType('energyMeterPlus', {
-        category: 'energy',
-        color: '#f3a108fe', //-- Dutch Orange --
-        defaults: {
-            name: {value:""},
-            baselineDaily: {value:0, required:false},
-            baselineWeekly: {value:0, required:false},
-            baselineMonthly: {value:0, required:false},
-            baselineYearly: {value:0, required:false},
-            unitCost: {value:0.15, required:true},
-            currency: {value:"USD", required:true},
-            filePath: {value:"/config/node_red/solargen_data.json", required:false},
-            inputUnit: {value:"W", required:true}
-        },
-        inputs:1,
-        outputs:1,
-        icon: "sun.png",
-        label: function() {
-            return this.name || "energyMeterPlus";
-        },
-        oneditprepare: function() {
-            // Nothing special here yet
-        },
-        oneditsave: function() {
-            // Collect baseline values
-            var daily   = Number($("#node-input-baselineDaily").val()) || 0;
-            var weekly  = Number($("#node-input-baselineWeekly").val()) || 0;
-            var monthly = Number($("#node-input-baselineMonthly").val()) || 0;
-            var yearly  = Number($("#node-input-baselineYearly").val()) || 0;
-
-            var baselineMsg = {
-                nodeId: this.id,
-                payload: { daily, weekly, monthly, yearly }
-            };
-
-            // Feedback logic
-            if (daily === 0 && weekly === 0 && monthly === 0 && yearly === 0) {
-                RED.notify("⚠️ Baseline values are all zero — nothing applied", {type:"warning", timeout:3000});
-            } else if (isNaN(daily) || isNaN(weekly) || isNaN(monthly) || isNaN(yearly)) {
-                RED.notify("❌ Baseline values invalid — please enter numbers", {type:"error", timeout:4000});
+RED.nodes.registerType('energyMeterPlus', {
+    category: 'energy',
+    color: '#f3a108fe',
+    defaults: {
+        name: {value:""},
+        baselineDaily: {value:0, required:false},
+        baselineWeekly: {value:0, required:false},
+        baselineMonthly: {value:0, required:false},
+        baselineYearly: {value:0, required:false},
+        applied: {value:false, required:false},   // NEW: whether editor values have been applied
+        unitCost: {value:0.15, required:true},
+        currency: {value:"USD", required:true},
+        filePath: {value:"/config/node_red/solargen_data.json", required:false},
+        inputUnit: {value:"W", required:true}
+    }, 
+    inputs:1,
+    outputs:1,
+    icon: "sun.png",
+    label: function() { return this.name || "energyMeterPlus"; },
+
+    oneditprepare: function() {
+        // show saved values in inputs
+        $("#node-input-baselineDaily").val(this.baselineDaily);
+        $("#node-input-baselineWeekly").val(this.baselineWeekly);
+        $("#node-input-baselineMonthly").val(this.baselineMonthly);
+        $("#node-input-baselineYearly").val(this.baselineYearly);
+
+        // reflect applied state visually
+        function setAppliedUI(isApplied) {
+            if (isApplied) {
+                $("#node-input-baselineDaily").prop("disabled", true).addClass("nr-disabled");
+                $("#node-input-baselineWeekly").prop("disabled", true).addClass("nr-disabled");
+                $("#node-input-baselineMonthly").prop("disabled", true).addClass("nr-disabled");
+                $("#node-input-baselineYearly").prop("disabled", true).addClass("nr-disabled");
+                $("#energy-applied-badge").text("Applied").show();
             } else {
-                RED.comms.send("energyMeterPlus/applyBaseline", baselineMsg);
-                RED.notify("✅ Baseline offset applied successfully", {type:"success", timeout:2000});
-                console.log("Baseline offset applied:", baselineMsg.payload);
+                $("#node-input-baselineDaily").prop("disabled", false).removeClass("nr-disabled");
+                $("#node-input-baselineWeekly").prop("disabled", false).removeClass("nr-disabled");
+                $("#node-input-baselineMonthly").prop("disabled", false).removeClass("nr-disabled");
+                $("#node-input-baselineYearly").prop("disabled", false).removeClass("nr-disabled");
+                $("#energy-applied-badge").hide();
             }
+        }
+
+        // initial UI state from saved flag
+        setAppliedUI(Boolean(this.applied));
+
+        // Apply button handler (immediate visual feedback)
+        $("#energy-apply-btn").on("click", function(e) {
+            e.preventDefault();
+            // read values
+            var d = Number($("#node-input-baselineDaily").val()) || 0;
+            var w = Number($("#node-input-baselineWeekly").val()) || 0;
+            var m = Number($("#node-input-baselineMonthly").val()) || 0;
+            var y = Number($("#node-input-baselineYearly").val()) || 0;
+
+            if (!d && !w && !m && !y) {
+                RED.notify("Baseline values are all zero — nothing to apply", {type:"warning", timeout:3000});
+                return;
+            }
+
+            // disable inputs and show badge immediately
+            setAppliedUI(true);
+
+            // store a local flag so oneditsave persists it
+            $("#node-input-applied").val("true");
+
+            RED.notify("Baseline marked as applied in editor. Click Done to save and Deploy to apply runtime delta.", {type:"info", timeout:3000});
+        });
+
+        // Reset button handler (re-enable inputs)
+        $("#energy-reset-applied").on("click", function(e) {
+            e.preventDefault();
+            setAppliedUI(false);
+            $("#node-input-applied").val("false");
+            RED.notify("Editor: baseline marked for reapply on next Deploy. Click Done then Deploy.", {type:"info", timeout:3000});
+        });
 
-            // Clear fields after save
-            $("#node-input-baselineDaily").val("");
-            $("#node-input-baselineWeekly").val("");
-            $("#node-input-baselineMonthly").val("");
-            $("#node-input-baselineYearly").val("");
+        // small trimming on input
+        ["baselineDaily","baselineWeekly","baselineMonthly","baselineYearly"].forEach(function(id){
+            $("#node-input-"+id).on("input", function(){ $(this).val($(this).val().trim()); });
+        });
+    },
+
+    oneditsave: function() {
+        // Save all fields so Node-RED marks node as changed
+        this.unitCost = $("#node-input-unitCost").val();
+        this.currency = $("#node-input-currency").val();
+        this.inputUnit = $("#node-input-inputUnit").val();
+        this.filePath = $("#node-input-filePath").val();
+
+        // Save baseline fields into the node config (do not clear inputs)
+        this.baselineDaily   = $("#node-input-baselineDaily").val();
+        this.baselineWeekly  = $("#node-input-baselineWeekly").val();
+        this.baselineMonthly = $("#node-input-baselineMonthly").val();
+        this.baselineYearly  = $("#node-input-baselineYearly").val();
+
+        // Persist applied flag (string "true"/"false" from hidden input)
+        var appliedVal = $("#node-input-applied").val();
+        this.applied = (appliedVal === "true");
+
+        // Optionally request immediate runtime apply; runtime delta logic will ignore zero-delta
+        function toNum(v){ var n = Number(v); return isNaN(n) ? 0 : n; }
+        var editor = {
+            daily:   toNum(this.baselineDaily),
+            weekly:  toNum(this.baselineWeekly),
+            monthly: toNum(this.baselineMonthly),
+            yearly:  toNum(this.baselineYearly)
+        };
+
+        if (this.applied && (editor.daily || editor.weekly || editor.monthly || editor.yearly)) {
+            // request runtime apply; runtime will only apply non-zero delta
+            RED.comms.send("energyMeterPlus/applyBaseline", { nodeId: this.id, payload: editor });
+            RED.notify("Baseline apply requested to runtime", {type:"success", timeout:2000});
         }
-    });
+    }
+});
 </script>
 
+<!-- Template -->
 <script type="text/x-red" data-template-name="energyMeterPlus">
     <div class="form-row">
         <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
         <input type="text" id="node-input-name">
     </div>
 
-    <!-- Baseline offsets -->
     <div class="form-row">
         <label for="node-input-baselineDaily"><i class="fa fa-calendar-day"></i> Baseline Daily Offset</label>
         <input type="number" id="node-input-baselineDaily" placeholder="Daily offset">
@@ -79,7 +146,19 @@
         <input type="number" id="node-input-baselineYearly" placeholder="Yearly offset">
     </div>
 
-    <!-- Other settings -->
+    <!-- Hidden applied flag persisted on save -->
+    <input type="hidden" id="node-input-applied" value="false">
+
+    <!-- Apply and Reset controls -->
+    <div class="form-row">
+        <button id="energy-apply-btn" class="editor-button">Apply</button>
+        <button id="energy-reset-applied" class="editor-button">Reset</button>
+        <span id="energy-applied-badge" style="display:none;margin-left:8px;padding:2px 6px;background:#ddd;border-radius:4px;color:#333;font-size:0.9em;">Applied</span>
+        <div class="help">Click Apply to mark these offsets as used. Click Reset to allow reapply.</div>
+    </div>
+
+    <hr/>
+
     <div class="form-row">
         <label for="node-input-unitCost"><i class="fa fa-money"></i> Cost per Unit</label>
         <input type="number" id="node-input-unitCost" step="0.01">
@@ -103,11 +182,10 @@
             <option value="W">W</option>
         </select>
     </div>
-</script>
 
-<script type="text/x-red" data-help-name="energyMeterPlus">
-    <p><b>Energy Meter Plus</b> tracks energy consumption and cost.</p>
-    <p>Outputs <code>energyDaily</code>, <code>energyWeekly</code>, <code>energyMonthly</code>, and <code>energyYearly</code> values, plus cost calculations.</p>
-    <p>You can set baseline offsets (daily, weekly, monthly, yearly) to adjust counters. These offsets are additive and applied on top of live increments.</p>
-    <p>Rollover logic resets counters at midnight (daily), Sunday midnight (weekly), first day of month (monthly), and Dec 31 midnight (yearly, with archive).</p>
+    <style>
+        /* subtle greyed-out look for disabled baseline inputs */
+        .nr-disabled { background:#f3f3f3 !important; color:#666 !important; }
+        .editor-button { margin-right:6px; }
+    </style>
 </script>

package/energyMeterPlus.js

@@ -1,168 +1,279 @@
+/**
+ * energyMeterPlus runtime
+ * - Applies editor baseline offsets exactly once when editor sets `applied` and you Deploy.
+ * - Uses lastAppliedEditor in node context to avoid double application.
+ * - Supports runtime messages:
+ *     - msg.topic === "applyBaseline" with msg.payload = { daily, weekly, monthly, yearly }  (immediate apply)
+ *     - msg.topic === "resetEditorApplied"  (clears lastAppliedEditor so same editor values can be applied again on next Deploy)
+ */
+
 const fs = require("fs");
 const path = require("path");
 
 module.exports = function(RED) {
     function EnergyMeterPlus(config) {
         RED.nodes.createNode(this, config);
-        var node = this;
-
-        let unitCost = Number(config.unitCost) || 0;
-        let filePath = config.filePath || "/config/node_red/solargen_data.json";
-        let inputUnit = config.inputUnit || "W";
-        let currencyCode = config.currency || "USD";
-
-        // --- Editor-config delta apply (run on every deploy)
-        function toNum(v) { const n = Number(v); return isNaN(n) ? 0 : n; }
-
-        // read stored "last applied editor values" (so we can compute deltas)
-        let lastApplied = node.context().get("lastAppliedEditor") || { daily:0, weekly:0, monthly:0, yearly:0 };
-
-        // current editor values (always read from config)
-        let editor = {
-            daily:   toNum(config.baselineDaily),
-            weekly:  toNum(config.baselineWeekly),
-            monthly: toNum(config.baselineMonthly),
-            yearly:  toNum(config.baselineYearly)
-        };
-
-        // compute delta = editor - lastApplied
-        let delta = {
-            daily:   editor.daily   - (toNum(lastApplied.daily)   || 0),
-            weekly:  editor.weekly  - (toNum(lastApplied.weekly)  || 0),
-            monthly: editor.monthly - (toNum(lastApplied.monthly) || 0),
-            yearly:  editor.yearly  - (toNum(lastApplied.yearly)  || 0)
-        };
-
-        // ensure baseline exists
-        let baseline = node.context().get("baseline") || { daily:0, weekly:0, monthly:0, yearly:0 };
+        const node = this;
+
+        // Config values (from editor)
+        const unitCost = Number(config.unitCost) || 0;
+        const filePath = config.filePath || "/config/node_red/solargen_data.json";
+        const inputUnit = config.inputUnit || "W";
+        const currencyCode = config.currency || "USD";
 
-        // apply delta (this adds positive or negative changes)
-        baseline.daily   += delta.daily;
-        baseline.weekly  += delta.weekly;
-        baseline.monthly += delta.monthly;
-        baseline.yearly  += delta.yearly;
+        // Helper: safe number parse
+        function toNum(v) {
+            const n = Number(v);
+            return isNaN(n) ? 0 : n;
+        }
+
+        // Helper: rounding
+        function round2(val) {
+            if (val === null || val === undefined || isNaN(val)) return 0;
+            return Number(val.toFixed(2));
+        }
+
+        // Helper: currency symbol
+        function currencySymbol(code) {
+            switch (code) {
+                case "USD": return "$";
+                case "EUR": return "€";
+                case "NGN": return "₦";
+                default: return code;
+            }
+        }
 
-        // persist baseline and remember the editor values we just applied
+        // Ensure baseline exists in context
+        let baseline = node.context().get("baseline") || { daily:0, weekly:0, monthly:0, yearly:0 };
         node.context().set("baseline", baseline);
-        node.context().set("lastAppliedEditor", editor);
-        // -------------------------------------------------------------------------------
 
-        // Accumulated values
+        // Ensure accumulated exists in context
         let accumulated = node.context().get("accumulated") || { daily:0, weekly:0, monthly:0, yearly:0 };
+        node.context().set("accumulated", accumulated);
 
-        // Last check timestamp
+        // Ensure lastCheck exists and is a Date
         let lastCheck = node.context().get("lastCheck");
         if (!(lastCheck instanceof Date)) {
             lastCheck = new Date(lastCheck || Date.now());
+            node.context().set("lastCheck", lastCheck);
         }
 
-        // 1. Input handler: baseline updates + power increments
-        node.on('input', function(msg) {
-            let now = new Date();
-            let durationHours = (now - lastCheck) / (1000 * 3600);
-
-            // Handle baseline updates via message (runtime applyBaseline)
-            if (msg.topic === "applyBaseline" && msg.payload) {
-                baseline.daily   += Number(msg.payload.daily)   || 0;
-                baseline.weekly  += Number(msg.payload.weekly)  || 0;
-                baseline.monthly += Number(msg.payload.monthly) || 0;
-                baseline.yearly  += Number(msg.payload.yearly)  || 0;
-                node.context().set("baseline", baseline);
-            }
+        // Ensure lastAppliedEditor exists
+        let lastAppliedEditor = node.context().get("lastAppliedEditor") || { daily:0, weekly:0, monthly:0, yearly:0 };
+        node.context().set("lastAppliedEditor", lastAppliedEditor);
 
-            // Handle power input
-            let power = Number(msg.payload);
-            if (!isNaN(power) && durationHours > 0) {
-                let power_kW = (inputUnit === "W") ? power / 1000 : power;
-                let energyIncrement = power_kW * durationHours;
+        // --- Apply editor baseline on deploy if editor flagged applied === true ---
+        try {
+            const editor = {
+                daily:   toNum(config.baselineDaily),
+                weekly:  toNum(config.baselineWeekly),
+                monthly: toNum(config.baselineMonthly),
+                yearly:  toNum(config.baselineYearly)
+            };
 
-                accumulated.daily   += energyIncrement;
-                accumulated.weekly  += energyIncrement;
-                accumulated.monthly += energyIncrement;
-                accumulated.yearly  += energyIncrement;
-            }
+            const appliedFlag = Boolean(config.applied);
 
-            lastCheck = now;
-            node.context().set("lastCheck", lastCheck);
-            node.context().set("accumulated", accumulated);
-
-            // 3. Output payload
-            msg.payload = {
-                energyDaily:   round2(baseline.daily   + accumulated.daily),
-                energyWeekly:  round2(baseline.weekly  + accumulated.weekly),
-                energyMonthly: round2(baseline.monthly + accumulated.monthly),
-                energyYearly:  round2(baseline.yearly  + accumulated.yearly),
-                daily_cost:   round2((baseline.daily   + accumulated.daily)   * unitCost),
-                weekly_cost:  round2((baseline.weekly  + accumulated.weekly)  * unitCost),
-                monthly_cost: round2((baseline.monthly + accumulated.monthly) * unitCost),
-                yearly_cost:  round2((baseline.yearly  + accumulated.yearly)  * unitCost),
-                currency: currencySymbol(currencyCode)
-            };
+            if (appliedFlag) {
+                const last = node.context().get("lastAppliedEditor") || { daily:0, weekly:0, monthly:0, yearly:0 };
+                const delta = {
+                    daily:   editor.daily   - toNum(last.daily),
+                    weekly:  editor.weekly  - toNum(last.weekly),
+                    monthly: editor.monthly - toNum(last.monthly),
+                    yearly:  editor.yearly  - toNum(last.yearly)
+                };
 
-            // 4. Persist to file
-            const dir = path.dirname(filePath);
-            if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-            try { fs.writeFileSync(filePath, JSON.stringify(msg.payload, null, 2)); }
-            catch (err) { node.error("Failed to write to file: " + err); }
+                if (delta.daily || delta.weekly || delta.monthly || delta.yearly) {
+                    baseline = node.context().get("baseline") || { daily:0, weekly:0, monthly:0, yearly:0 };
 
-            node.send(msg);
-        });
+                    baseline.daily   += delta.daily;
+                    baseline.weekly  += delta.weekly;
+                    baseline.monthly += delta.monthly;
+                    baseline.yearly  += delta.yearly;
 
-        // 5. Rollover logic
-        function checkRollover() {
-            let now = new Date();
+                    node.context().set("baseline", baseline);
+                    node.context().set("lastAppliedEditor", editor);
 
-            if (!(lastCheck instanceof Date)) {
-                lastCheck = new Date(lastCheck || Date.now());
+                    node.log(`Editor baseline applied on deploy (delta): ${JSON.stringify(delta)}`);
+                } else {
+                    node.log("Editor baseline flagged applied on deploy but no delta to apply (values match lastAppliedEditor).");
+                }
+            } else {
+                node.log("Editor baseline not flagged applied on deploy; no editor delta applied.");
             }
+        } catch (err) {
+            node.error("Error applying editor baseline on deploy: " + err);
+        }
 
-            if (now.getDate() !== lastCheck.getDate()) {
-                accumulated.daily = 0; baseline.daily = 0;
-            }
-            if (now.getDay() === 1 && lastCheck.getDay() !== 1) {
-                accumulated.weekly = 0; baseline.weekly = 0;
-            }
-            if (now.getMonth() !== lastCheck.getMonth()) {
-                accumulated.monthly = 0; baseline.monthly = 0;
-            }
-            if (now.getFullYear() !== lastCheck.getFullYear()) {
-                archiveYearly(baseline.yearly + accumulated.yearly, lastCheck.getFullYear());
-                accumulated.yearly = 0; baseline.yearly = 0;
-            }
+        // --- Rollover logic ---
+        function checkRollover() {
+            try {
+                const now = new Date();
 
-            lastCheck = now;
-            node.context().set("lastCheck", lastCheck);
-            node.context().set("accumulated", accumulated);
-            node.context().set("baseline", baseline);
-        }
-        setInterval(checkRollover, 60000);
+                if (!(lastCheck instanceof Date)) {
+                    lastCheck = new Date(lastCheck || Date.now());
+                }
 
-        // 6. Helpers
-        function currencySymbol(code) {
-            switch (code) {
-                case "USD": return "$";
-                case "EUR": return "€";
-                case "NGN": return "₦";
-                default: return code;
+                // daily rollover (date change)
+                if (now.getDate() !== lastCheck.getDate() || now.toDateString() !== lastCheck.toDateString()) {
+                    accumulated.daily = 0;
+                    baseline = node.context().get("baseline") || baseline;
+                    baseline.daily = 0;
+                    node.context().set("baseline", baseline);
+                    node.log("Daily rollover executed.");
+                }
+
+                // weekly rollover (assume week starts Monday)
+                // If lastCheck was not Monday and now is Monday, reset weekly
+                if (now.getDay() === 1 && lastCheck.getDay() !== 1) {
+                    accumulated.weekly = 0;
+                    baseline = node.context().get("baseline") || baseline;
+                    baseline.weekly = 0;
+                    node.context().set("baseline", baseline);
+                    node.log("Weekly rollover executed.");
+                }
+
+                // monthly rollover
+                if (now.getMonth() !== lastCheck.getMonth()) {
+                    accumulated.monthly = 0;
+                    baseline = node.context().get("baseline") || baseline;
+                    baseline.monthly = 0;
+                    node.context().set("baseline", baseline);
+                    node.log("Monthly rollover executed.");
+                }
+
+                // yearly rollover
+                if (now.getFullYear() !== lastCheck.getFullYear()) {
+                    baseline = node.context().get("baseline") || baseline;
+                    archiveYearly(baseline.yearly + accumulated.yearly, lastCheck.getFullYear());
+                    accumulated.yearly = 0;
+                    baseline.yearly = 0;
+                    node.context().set("baseline", baseline);
+                    node.log("Yearly rollover executed and archived.");
+                }
+
+                lastCheck = now;
+                node.context().set("lastCheck", lastCheck);
+                node.context().set("accumulated", accumulated);
+            } catch (err) {
+                node.error("Rollover error: " + err);
             }
         }
-        function round2(val) {
-            if (val === null || val === undefined || isNaN(val)) return 0;
-            return Number(val.toFixed(2));
-        }
+
+        const rolloverInterval = setInterval(checkRollover, 60000);
+
+        // --- Archive helper ---
         function archiveYearly(total, year) {
             try {
                 const archivePath = path.join(path.dirname(filePath), "yearly_archive.json");
                 let archive = [];
                 if (fs.existsSync(archivePath)) {
-                    archive = JSON.parse(fs.readFileSync(archivePath));
+                    try {
+                        archive = JSON.parse(fs.readFileSync(archivePath));
+                    } catch (e) {
+                        node.warn("Failed to parse existing yearly archive, starting fresh.");
+                        archive = [];
+                    }
                 }
                 archive.push({ year, total, timestamp: new Date().toISOString() });
                 fs.writeFileSync(archivePath, JSON.stringify(archive, null, 2));
+                node.log(`Archived yearly total for ${year}: ${total}`);
             } catch (err) {
                 node.error("Failed to archive yearly total: " + err);
             }
         }
+
+        // --- Main input handler ---
+        node.on('input', function(msg) {
+            try {
+                // Rehydrate baseline/accumulated/lastCheck from context
+                baseline = node.context().get("baseline") || baseline;
+                accumulated = node.context().get("accumulated") || accumulated;
+                lastCheck = node.context().get("lastCheck") || lastCheck;
+                if (!(lastCheck instanceof Date)) lastCheck = new Date(lastCheck || Date.now());
+
+                // Reset command: clear lastAppliedEditor so same editor values can be applied again on next Deploy
+                if (msg && msg.topic === "resetEditorApplied") {
+                    node.context().set("lastAppliedEditor", { daily:0, weekly:0, monthly:0, yearly:0 });
+                    node.log("Runtime: lastAppliedEditor cleared by reset message.");
+                    return;
+                }
+
+                // Runtime applyBaseline via injected JSON (immediate apply without Deploy)
+                if (msg && msg.topic === "applyBaseline" && msg.payload && typeof msg.payload === "object") {
+                    const dDaily = toNum(msg.payload.daily);
+                    const dWeekly = toNum(msg.payload.weekly);
+                    const dMonthly = toNum(msg.payload.monthly);
+                    const dYearly = toNum(msg.payload.yearly);
+
+                    baseline = node.context().get("baseline") || baseline;
+                    baseline.daily   += dDaily;
+                    baseline.weekly  += dWeekly;
+                    baseline.monthly += dMonthly;
+                    baseline.yearly  += dYearly;
+                    node.context().set("baseline", baseline);
+
+                    node.log(`Runtime applyBaseline message applied: daily ${dDaily}, weekly ${dWeekly}, monthly ${dMonthly}, yearly ${dYearly}`);
+                    return;
+                }
+
+                // Otherwise treat payload as power reading (numeric)
+                const now = new Date();
+                const durationHours = (now - lastCheck) / (1000 * 3600);
+
+                const power = Number(msg.payload);
+                if (!isNaN(power) && durationHours > 0) {
+                    const power_kW = (inputUnit === "W") ? power / 1000 : power;
+                    const energyIncrement = power_kW * durationHours;
+
+                    accumulated.daily   += energyIncrement;
+                    accumulated.weekly  += energyIncrement;
+                    accumulated.monthly += energyIncrement;
+                    accumulated.yearly  += energyIncrement;
+
+                    node.log(`Power input processed: ${power} ${inputUnit} -> +${energyIncrement.toFixed(6)} kWh over ${durationHours.toFixed(6)} h`);
+                }
+
+                // Update timestamps and persist context
+                lastCheck = now;
+                node.context().set("lastCheck", lastCheck);
+                node.context().set("accumulated", accumulated);
+                node.context().set("baseline", baseline);
+
+                // Build output payload
+                const payload = {
+                    energyDaily:   round2(baseline.daily   + accumulated.daily),
+                    energyWeekly:  round2(baseline.weekly  + accumulated.weekly),
+                    energyMonthly: round2(baseline.monthly + accumulated.monthly),
+                    energyYearly:  round2(baseline.yearly  + accumulated.yearly),
+                    daily_cost:   round2((baseline.daily   + accumulated.daily)   * unitCost),
+                    weekly_cost:  round2((baseline.weekly  + accumulated.weekly)  * unitCost),
+                    monthly_cost: round2((baseline.monthly + accumulated.monthly) * unitCost),
+                    yearly_cost:  round2((baseline.yearly  + accumulated.yearly)  * unitCost),
+                    currency: currencySymbol(currencyCode)
+                };
+
+                // Persist to file (best-effort)
+                try {
+                    const dir = path.dirname(filePath);
+                    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+                    fs.writeFileSync(filePath, JSON.stringify(payload, null, 2));
+                } catch (err) {
+                    node.error("Failed to write to file: " + err);
+                }
+
+                // Send output
+                msg.payload = payload;
+                node.send(msg);
+            } catch (err) {
+                node.error("Input handler error: " + err);
+            }
+        });
+
+        // Clean up on close
+        node.on('close', function(removed, done) {
+            if (rolloverInterval) clearInterval(rolloverInterval);
+            done();
+        });
     }
 
     RED.nodes.registerType("energyMeterPlus", EnergyMeterPlus, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-energymeterplus",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "A custom Node-RED node that integrates power readings into energy totals with persistence and cost calculation.",
   "author": "Arcfrankye",
   "license": "MIT",