@bldgblocks/node-red-contrib-control 0.2.2 → 0.2.3

package/nodes/alarm-collector.html

@@ -131,7 +131,7 @@
             priority: { value: "high" },
             topic: { value: "Alarms_Default" },
             title: { value: "Alarm" },
-            message: { value: "Condition triggered" },
+            message: { value: "Condition active" },
             messageType: { value: "str" },
             tags: { value: "" },
             units: { value: "°F" }
@@ -206,7 +206,7 @@
                     "msg"
                 ],
                 typeField: "#node-input-messageType"
-            }).typedInput("type", node.messageType || "str").typedInput("value", node.message || "Condition triggered");
+            }).typedInput("type", node.messageType || "str").typedInput("value", node.message || "Condition active");
 
             // Show/hide sections based on inputMode
             const updateDisplay = () => {

package/nodes/alarm-collector.js

@@ -19,7 +19,7 @@ module.exports = function(RED) {
         node.priority = config.priority || "normal";
         node.topic = config.topic || "Alarms_Default";
         node.title = config.title || "Alarm";
-        node.message = config.message || "Condition triggered";
+        node.message = config.message || "Condition active";
         node.messageType = config.messageType || "str";
         node.tags = config.tags || "";
         node.units = config.units || "";
@@ -66,84 +66,65 @@ module.exports = function(RED) {
         // Helper: Evaluate alarm condition and emit event if state changed
         // ====================================================================
         function evaluateAndEmit(inputValue) {
-            // Evaluate alarm condition based on input mode
             let conditionNowMet = false;
             let numericValue = null;
 
             if (node.inputMode === "boolean") {
-                // Boolean mode: compare directly with alarmWhenTrue
                 conditionNowMet = (inputValue === node.alarmWhenTrue);
                 node.currentValue = inputValue;
             } else {
-                // Value mode: parse as numeric and check thresholds
                 numericValue = inputValue;
                 if (typeof inputValue === 'object' && inputValue !== null && inputValue.value !== undefined) {
                     numericValue = inputValue.value;
                 }
                 numericValue = parseFloat(numericValue);
-                
+
                 if (isNaN(numericValue)) {
                     utils.setStatusError(node, "Invalid numeric input");
                     return;
                 }
-                
+
                 node.currentValue = numericValue;
 
-                // Check thresholds
+                // Schmitt-trigger thresholds: when alarm is already active, use
+                // the magnitude-adjusted band so the value must move decisively
+                // past the threshold before the alarm will consider clearing.
+                const effectiveHigh = node.alarmState
+                    ? (node.highThreshold - node.hysteresisMagnitude)
+                    : node.highThreshold;
+                const effectiveLow = node.alarmState
+                    ? (node.lowThreshold + node.hysteresisMagnitude)
+                    : node.lowThreshold;
+
                 if (node.compareMode === "either") {
-                    conditionNowMet = (numericValue > node.highThreshold) || (numericValue < node.lowThreshold);
+                    conditionNowMet = (numericValue > effectiveHigh) || (numericValue < effectiveLow);
                 } else if (node.compareMode === "high-only") {
-                    conditionNowMet = (numericValue > node.highThreshold);
+                    conditionNowMet = numericValue > effectiveHigh;
                 } else if (node.compareMode === "low-only") {
-                    conditionNowMet = (numericValue < node.lowThreshold);
+                    conditionNowMet = numericValue < effectiveLow;
                 }
             }
 
-            // Time-based hysteresis logic
-            if (conditionNowMet && !node.conditionMet) {
-                // Condition just became true - start hysteresis timer
-                node.conditionMet = true;
-                
-                if (node.hysteresisTimer) clearTimeout(node.hysteresisTimer);
+            // Single debounce timer: when the condition transitions, wait
+            // hysteresisTime before committing the change to alarmState.
+            // This filters noise in both the activation and clearing directions.
+            if (conditionNowMet !== node.conditionMet) {
+                node.conditionMet = conditionNowMet;
 
-                node.hysteresisTimer = setTimeout(() => {
-                    if (node.conditionMet && node.alarmState === false) {
-                        // Condition stayed true for hysteresisTime ms
-                        node.alarmState = true;
-                        emitAlarmEvent("false → true");
-                    }
-                    node.hysteresisTimer = null;
-                }, node.hysteresisTime);
-
-            } else if (!conditionNowMet && node.conditionMet) {
-                // Condition just became false - cancel pending timer
-                node.conditionMet = false;
-                
                 if (node.hysteresisTimer) {
                     clearTimeout(node.hysteresisTimer);
                     node.hysteresisTimer = null;
                 }
 
-                // Check magnitude hysteresis before clearing
-                let shouldClear = true;
-                if (node.inputMode === "value" && node.alarmState === true) {
-                    if (node.compareMode === "either" || node.compareMode === "high-only") {
-                        const clearThreshold = node.highThreshold - node.hysteresisMagnitude;
-                        if (numericValue > clearThreshold) {
-                            shouldClear = false;
-                        }
-                    }
-                    if (node.compareMode === "either" || node.compareMode === "low-only") {
-                        const clearThreshold = node.lowThreshold + node.hysteresisMagnitude;
-                        if (numericValue < clearThreshold) {
-                            shouldClear = false;
+                // Start timer only when condition disagrees with alarm state
+                if (conditionNowMet !== node.alarmState) {
+                    node.hysteresisTimer = setTimeout(() => {
+                        if (node.conditionMet !== node.alarmState) {
+                            node.alarmState = node.conditionMet;
+                            emitAlarmEvent(node.alarmState ? "false → true" : "true → false");
                         }
-                    }
-                }
-
-                if (shouldClear && node.alarmState === true) {
-                    node.alarmState = false;
-                    emitAlarmEvent("true → false");
+                        node.hysteresisTimer = null;
+                    }, node.hysteresisTime);
                 }
             }
 
@@ -155,9 +136,11 @@ module.exports = function(RED) {
                 statusText = `${numericValue.toFixed(2)} ${node.units}`;
             }
 
-            if (node.alarmState) {
+            if (node.alarmState && node.hysteresisTimer) {
+                utils.setStatusWarn(node, statusText + " [ALARM clearing...]");
+            } else if (node.alarmState) {
                 utils.setStatusError(node, statusText + " [ALARM]");
-            } else if (node.conditionMet) {
+            } else if (node.hysteresisTimer) {
                 utils.setStatusWarn(node, statusText + " (hysteresis)");
             } else {
                 utils.setStatusOK(node, statusText);

package/nodes/alarm-service.js

@@ -49,7 +49,7 @@ module.exports = function(RED) {
                 // Send alarm message with status
                 const msg = {
                     alarm: eventData,
-                    status: { state: "triggered", transition: eventData.transition },
+                    status: { state: "active", transition: eventData.transition },
                     activeAlarmCount: activeCount,
                     alarmKey: key
                 };

package/nodes/boolean-to-number-block.html

@@ -38,13 +38,14 @@
 
 <!-- Help Section -->
 <script type="text/markdown" data-help-name="boolean-to-number-block">
-Converts a boolean or null input from a configured property to a numeric output.
+Converts between boolean and numeric representations. Booleans are converted to `0`/`1`;
+numeric `0`/`1` values are converted back to `false`/`true`. Also handles `null`.
 
 ### Inputs
-: input-property (boolean | null) : Value to convert, read from the configured Input Property.
+: input-property (boolean | number | null) : Value to convert, read from the configured Input Property.
 
 ### Outputs
-: payload (number) : Converted value: `null` to `0` (if `nullToZero` is true) or `-1`, `false` to `0`, `true` to `1`.
+: payload (number | boolean) : Converted value — booleans become `0`/`1`, numbers `0`/`1` become `false`/`true`, `null` becomes `0` or `-1`.
 
 ### Properties
 : name (string) : Display name in editor.
@@ -52,9 +53,17 @@ Converts a boolean or null input from a configured property to a numeric output.
 : nullToZero (boolean) : When checked, `null` maps to `0`; when unchecked, `null` maps to `-1`.
 
 ### Details
-Converts boolean or null input (read from the configured **Input Property**, default: `msg.payload`) to a number:
+Automatically converts in both directions (read from the configured **Input Property**, default: `msg.payload`):
+
+**Boolean → Number:**
 - `true` → `1`
 - `false` → `0`
+
+**Number → Boolean:**
+- `1` → `true`
+- `0` → `false`
+
+**Null handling:**
 - `null` → `0` (if **Null Mapping** is checked) or `-1` (if unchecked)
 
 Output is always written to `msg.payload`. All other input message properties are passed through unchanged.

package/nodes/boolean-to-number-block.js

@@ -31,11 +31,15 @@ module.exports = function(RED) {
             const inputDisplay = inputValue === null ? "null" : String(inputValue);
             if (inputValue === null) {
                 msg.payload = node.nullToZero ? 0 : -1;
-                utils.setStatusChanged(node, `in: ${inputDisplay}, out: ${msg.payload}`);
+                utils.setStatusChanged(node, `${inputDisplay} -> ${msg.payload}`);
                 send(msg);
             } else if (typeof inputValue === "boolean") {
                 msg.payload = inputValue ? 1 : 0;
-                utils.setStatusChanged(node, `in: ${inputDisplay}, out: ${msg.payload}`);
+                utils.setStatusChanged(node, `${inputDisplay} -> ${msg.payload}`);
+                send(msg);
+            } else if (typeof inputValue === "number" && (inputValue === 0 || inputValue === 1)) {
+                msg.payload = inputValue === 1;
+                utils.setStatusChanged(node, `${inputDisplay} -> ${msg.payload}`);
                 send(msg);
             } else {
                 utils.setStatusError(node, "invalid input type");

package/nodes/call-status-block.js

@@ -267,9 +267,17 @@ module.exports = function(RED) {
                 }
             } else {
                 // === Call deactivated ===
+                // Clear run-related timers and alarms — they are no longer
+                // relevant once the call is off.
                 if (node.initialStatusTimer) { clearTimeout(node.initialStatusTimer); node.initialStatusTimer = null; }
                 if (node.heartbeatTimer) { clearTimeout(node.heartbeatTimer); node.heartbeatTimer = null; }
                 if (node.statusLostTimer) { clearTimeout(node.statusLostTimer); node.statusLostTimer = null; }
+                if (node.debounceTimer) { clearTimeout(node.debounceTimer); node.debounceTimer = null; }
+
+                // Clear any "during run" alarm (e.g. status lost) — no longer
+                // meaningful now that the call itself is off.
+                node.alarm = false;
+                node.alarmMessage = "";
 
                 // Monitor that status goes inactive
                 if (node.actualState) {
@@ -318,16 +326,33 @@ module.exports = function(RED) {
             }
 
             // If call active and status went false → status lost alarm
-            if (node.requestedState && !newStatus && node.config.runLostStatus) {
+            // CRITICAL: Only alarm if we've already received at least one status=true
+            // response. And use the configured heartbeat/status timeout as the delay —
+            // a brief status dropout should NOT alarm faster than the configured
+            // tolerance window. If heartbeat was running, cancel it (we know status
+            // is false now) and let the statusLostTimer take over with the same delay.
+            if (node.requestedState && !newStatus && node.config.runLostStatus && !node.neverReceivedStatus) {
+                // Cancel heartbeat — status is explicitly false, no point monitoring freshness
+                if (node.heartbeatTimer) {
+                    clearTimeout(node.heartbeatTimer);
+                    node.heartbeatTimer = null;
+                }
+
+                // Use heartbeatTimeout as the delay if configured, otherwise statusTimeout.
+                // These are the user's configured tolerance windows for status gaps.
+                const lostDelay = node.config.heartbeatTimeout > 0
+                    ? node.config.heartbeatTimeout * 1000
+                    : (node.config.statusTimeout > 0 ? node.config.statusTimeout * 1000 : 5000);
+
                 node.statusLostTimer = setTimeout(() => {
                     node.statusLostTimer = null;
-                    if (node.requestedState && !node.actualState) {
+                    if (node.requestedState && !node.actualState && !node.neverReceivedStatus) {
                         node.alarm = true;
                         node.alarmMessage = node.config.runLostStatusMessage;
                         send(buildOutput());
                         updateNodeStatus();
                     }
-                }, 100);  // 100ms hysteresis
+                }, lostDelay);
             }
 
             // If call inactive and status goes false → all clear
@@ -341,6 +366,7 @@ module.exports = function(RED) {
             }
 
             // If status active without call and no clearTimer running → unexpected
+            // Skip if clearTimer is active — we're still in grace period after call deactivated
             if (!node.requestedState && newStatus && !node.clearTimer && node.config.statusWithoutCall) {
                 node.statusLostTimer = setTimeout(() => {
                     node.statusLostTimer = null;

package/nodes/changeover-block.html

@@ -9,12 +9,12 @@
     </div>
     <div class="form-row">
         <label for="node-input-algorithm" title="Control algorithm type"><i class="fa fa-cog"></i> Algorithm</label>
-        <input type="text" id="node-input-algorithm" class="node-input-typed" placeholder="single">
+        <input type="text" id="node-input-algorithm" placeholder="single">
         <input type="hidden" id="node-input-algorithmType">
     </div>
     <div class="form-row single-only">
         <label for="node-input-setpoint" title="Target temperature setpoint (number from num, msg, flow, or global)"><i class="fa fa-thermometer-half"></i> Setpoint</label>
-        <input type="text" id="node-input-setpoint" class="node-input-typed" placeholder="70">
+        <input type="text" id="node-input-setpoint" placeholder="70">
         <input type="hidden" id="node-input-setpointType">
     </div>
     <div class="form-row single-only">
@@ -29,12 +29,12 @@
     </div>
     <div class="form-row split-only" style="display: none;">
         <label for="node-input-heatingSetpoint" title="Heating setpoint for split algorithm (number from num, msg, flow, or global)"><i class="fa fa-thermometer-empty"></i> Heating Setpoint</label>
-        <input type="text" id="node-input-heatingSetpoint" class="node-input-typed" placeholder="68">
+        <input type="text" id="node-input-heatingSetpoint" placeholder="68">
         <input type="hidden" id="node-input-heatingSetpointType">
     </div>
     <div class="form-row split-only" style="display: none;">
         <label for="node-input-coolingSetpoint" title="Cooling setpoint for split algorithm (number from num, msg, flow, or global)"><i class="fa fa-thermometer-full"></i> Cooling Setpoint</label>
-        <input type="text" id="node-input-coolingSetpoint" class="node-input-typed" placeholder="74">
+        <input type="text" id="node-input-coolingSetpoint" placeholder="74">
         <input type="hidden" id="node-input-coolingSetpointType">
     </div>
     <div class="form-row split-only" style="display: none;">
@@ -66,7 +66,7 @@
 
     <div class="form-row">
         <label for="node-input-swapTime" title="Minimum time before mode change (seconds, minimum 60, from num, msg, flow, or global)"><i class="fa fa-clock-o"></i> Swap Time</label>
-        <input type="text" id="node-input-swapTime" class="node-input-typed" placeholder="300">
+        <input type="text" id="node-input-swapTime" placeholder="300">
         <input type="hidden" id="node-input-swapTimeType">
     </div>
     <div class="form-row">
@@ -107,6 +107,7 @@
             setpoint: { value: "70" },
             setpointType: { value: "num" },
             deadband: { value: "2" },
+            deadbandType: { value: "num" },
             heatingSetpoint: { value: "68" },
             heatingSetpointType: { value: "num" },
             coolingSetpoint: { value: "74" },
@@ -116,6 +117,7 @@
             heatingOn: { value: "66" },
             heatingOnType: { value: "num" },
             extent: { value: "1" },
+            extentType: { value: "num" },
             swapTime: { value: "300" },
             swapTimeType: { value: "num" },
             minTempSetpoint: { value: "55" },
@@ -156,7 +158,7 @@
                         ]
                     }, "msg", "flow", "global"],
                     typeField: "#node-input-operationModeType"
-                }).typedInput("type", node.operationModeType).typedInput("value", node.operationMode);
+                });
                 
                 $("#node-input-algorithm").typedInput({
                     default: "dropdown",
@@ -169,87 +171,91 @@
                         ]
                     }, "msg", "flow", "global"],
                     typeField: "#node-input-algorithmType"
-                }).typedInput("type", node.algorithmType).typedInput("value", node.algorithm);
+                });
 
                 $("#node-input-setpoint").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
                     typeField: "#node-input-setpointType"
-                }).typedInput("type", node.setpointType || "num").typedInput("value", node.setpoint);
+                });
 
                 $("#node-input-heatingSetpoint").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
                     typeField: "#node-input-heatingSetpointType"
-                }).typedInput("type", node.heatingSetpointType || "num").typedInput("value", node.heatingSetpoint);
+                });
 
                 $("#node-input-coolingSetpoint").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
                     typeField: "#node-input-coolingSetpointType"
-                }).typedInput("type", node.coolingSetpointType || "num").typedInput("value", node.coolingSetpoint);
+                });
 
                 $("#node-input-heatingOn").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
                     typeField: "#node-input-heatingOnType"
-                }).typedInput("type", node.heatingOnType || "num").typedInput("value", node.heatingOn);
+                });
 
                 $("#node-input-coolingOn").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
                     typeField: "#node-input-coolingOnType"
-                }).typedInput("type", node.coolingOnType || "num").typedInput("value", node.coolingOn);
+                });
 
                 $("#node-input-swapTime").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
                     typeField: "#node-input-swapTimeType"
-                }).typedInput("type", node.swapTimeType || "num").typedInput("value", node.swapTime);
+                });
 
                 $("#node-input-deadband").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
                     typeField: "#node-input-deadbandType"
-                }).typedInput("type", node.deadbandType || "num").typedInput("value", node.deadband);
+                });
 
                 $("#node-input-extent").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
                     typeField: "#node-input-extentType"
-                }).typedInput("type", node.extentType || "num").typedInput("value", node.extent);
+                });
 
                 $("#node-input-minTempSetpoint").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
                     typeField: "#node-input-minTempSetpointType"
-                }).typedInput("type", node.minTempSetpointType || "num").typedInput("value", node.minTempSetpoint);
+                });
 
                 $("#node-input-maxTempSetpoint").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
                     typeField: "#node-input-maxTempSetpointType"
-                }).typedInput("type", node.maxTempSetpointType || "num").typedInput("value", node.maxTempSetpoint);
+                });
 
                 // Toggle fields based on algorithm
                 function toggleFields() {
-                    if ($algorithm.val() === "single") {
+                    const type = $("#node-input-algorithm").typedInput("type");
+                    if (type !== "dropdown") {
+                        // Dynamic source — hide all, resolved at runtime
+                        $singleFields.hide();
+                        $splitFields.hide();
+                        $specifiedFields.hide();
+                        return;
+                    }
+                    const algorithm = $("#node-input-algorithm").typedInput("value");
+                    if (algorithm === "single") {
                         $singleFields.show();
                         $splitFields.hide();
                         $specifiedFields.hide();
-                    } else if ($algorithm.val() === "split") {
+                    } else if (algorithm === "split") {
                         $singleFields.hide();
                         $splitFields.show();
                         $specifiedFields.hide();
-                    } else if ($algorithm.val() === "specified") {
+                    } else if (algorithm === "specified") {
                         $singleFields.hide();
                         $splitFields.hide();
                         $specifiedFields.show();
-                    } else {
-                        $algorithm.val("single");
-                        $singleFields.show();
-                        $splitFields.hide();
-                        $specifiedFields.hide();
                     }
                 }
 

package/nodes/changeover-block.js

@@ -328,6 +328,7 @@ module.exports = function(RED) {
             msg.status = {
                 mode: node.currentMode,
                 operationMode: node.operationMode,
+                algorithm: node.algorithm,
                 isHeating,
                 heatingSetpoint: effectiveHeating,
                 coolingSetpoint: effectiveCooling,
@@ -352,13 +353,31 @@ module.exports = function(RED) {
 
             const temp = node.lastTemperature !== null ? node.lastTemperature.toFixed(1) : "?";
             const { heating, cooling } = getThresholds();
-            // Show the threshold that explains the current mode:
-            //   heating → show cooling threshold (we're heating because temp < cooling threshold)
-            //   cooling → show heating threshold (we're cooling because temp > heating threshold)
-            const threshold = isHeating
-                ? `<${cooling.toFixed(1)}`
-                : `>${heating.toFixed(1)}`;
-            let text = `${temp}° ${threshold} [${node.operationMode}] ${node.currentMode}`;
+            let thresholdText, hysteresisText;
+            if (isHeating) {
+                thresholdText = `<${cooling.toFixed(1)}`;
+                if (node.lastTemperature !== null && node.lastTemperature < cooling) {
+                    hysteresisText = " (on)";
+                } else if (node.lastTemperature !== null && node.lastTemperature >= heating && node.lastTemperature < cooling) {
+                    hysteresisText = ` (holding, swap at >${heating.toFixed(1)})`;
+                } else if (node.lastTemperature !== null && node.lastTemperature >= cooling) {
+                    hysteresisText = " (off)";
+                } else {
+                    hysteresisText = "";
+                }
+            } else {
+                thresholdText = `>${heating.toFixed(1)}`;
+                if (node.lastTemperature !== null && node.lastTemperature > heating) {
+                    hysteresisText = " (on)";
+                } else if (node.lastTemperature !== null && node.lastTemperature <= cooling && node.lastTemperature > heating) {
+                    hysteresisText = ` (holding, swap at <${cooling.toFixed(1)})`;
+                } else if (node.lastTemperature !== null && node.lastTemperature <= heating) {
+                    hysteresisText = " (off)";
+                } else {
+                    hysteresisText = "";
+                }
+            }
+            let text = `${temp}° ${thresholdText} [${node.operationMode}] ${node.currentMode}${hysteresisText}`;
 
             if (pendingMode && conditionStartTime) {
                 const remaining = Math.max(0, node.swapTime - (now - conditionStartTime));

package/nodes/comment-block.html

@@ -12,9 +12,15 @@
         <select id="node-input-statusDisplay">
             <option value="default">Comment to status (Default)</option>
             <option value="name">Name to status</option>
+            <option value="property">Message property to status</option>
             <option value="none">No status</option>
         </select>
     </div>
+    <div class="form-row" id="row-statusProperty" style="display:none;">
+        <label for="node-input-statusProperty" title="Message property or JSONata expression to display in status"><i class="fa fa-code"></i> Property</label>
+        <input type="text" id="node-input-statusProperty" placeholder="payload" style="width:70%;">
+        <input type="hidden" id="node-input-statusPropertyType">
+    </div>
 </script>
 
 <script type="text/javascript">
@@ -24,7 +30,9 @@
         defaults: {
             name: { value: "comment" },
             comment: { value: "No comment", validate: function(v) { return v.length < 100 } },
-            statusDisplay: { value: "default" }
+            statusDisplay: { value: "default" },
+            statusProperty: { value: "payload" },
+            statusPropertyType: { value: "msg" }
         },
         inputs: 1,
         outputs: 1,
@@ -35,9 +43,31 @@
         label: function() {
             return this.name || this.comment || "comment";
         },
+        oneditprepare: function() {
+            var node = this;
+
+            $("#node-input-statusProperty").typedInput({
+                default: "msg",
+                types: ["msg", "jsonata"],
+                typeField: "#node-input-statusPropertyType"
+            }).typedInput("type", node.statusPropertyType || "msg")
+              .typedInput("value", node.statusProperty || "payload");
+
+            function togglePropertyRow() {
+                if ($("#node-input-statusDisplay").val() === "property") {
+                    $("#row-statusProperty").show();
+                } else {
+                    $("#row-statusProperty").hide();
+                }
+            }
+
+            $("#node-input-statusDisplay").on("change", togglePropertyRow);
+            togglePropertyRow();
+        },
         oneditsave: function() {
             // Update status immediately
             const node = RED.nodes.getNode(this.id);
+            if (!node) return;
             let status = {};
             switch (node.statusDisplay) {
                 case "default":
@@ -46,18 +76,20 @@
                 case "name":
                     status = { fill: "green", shape: "dot", text: node.name || "comment" };
                     break;
+                case "property":
+                    status = { fill: "green", shape: "dot", text: "waiting for input" };
+                    break;
                 case "none":
                     break;
                 default:
             }
-
             node.status(status);
         }
     });
 </script>
 
 <script type="text/markdown" data-help-name="comment-block">
-Displays a configurable comment, node name, or no status persistently and on input.
+Displays a configurable comment, node name, message property, or no status persistently and on input.
 
 ### Inputs
 : payload (any) : Passthrough.
@@ -66,16 +98,23 @@ Displays a configurable comment, node name, or no status persistently and on inp
 : payload (any) : Passthrough.
 
 ### Details
-Displays a status (comment, node name, or none) on node creation, editor saves, and input messages.
+Displays a status (comment, node name, message property, or none) on node creation, editor saves, and input messages.
+
+Wire this node inline to observe values flowing through without interrupting the message chain.
+
+**Status Display modes:**
+- **Comment to status (Default)**: Shows the configured comment text.
+- **Name to status**: Shows the node's name.
+- **Message property to status**: Evaluates a `msg` property path (e.g., `payload`, `value`, `activePriority`) or a JSONata expression on each input and displays the result.
+- **No status**: Hides the status indicator.
 
-Used for flow annotations or debugging without requiring input to trigger status.
+When using **Message property** mode, the status updates on every input message. If the property is not found, a yellow warning is shown.
 
 ### Status
-- Green (dot): Configuration update
-- Blue (dot): State changed
-- Blue (ring): State unchanged
+- Green (dot): Static display (comment/name)
+- Blue (dot): Property value displayed
+- Yellow (ring): Property not found
 - Red (ring): Error
-- Yellow (ring): Warning
 
 ### References
 - [Node-RED Documentation](https://nodered.org/docs/)