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

package/nodes/comment-block.js

@@ -9,14 +9,26 @@ module.exports = function(RED) {
         node.name = config.name;
         node.comment = config.comment || "";
         node.statusDisplay = config.statusDisplay;
+        node.statusProperty = config.statusProperty || "";
+        node.statusPropertyType = config.statusPropertyType || "msg";
+
+        // Pre-compile JSONata expression if configured
+        let jsonataExpr = null;
+        if (node.statusPropertyType === "jsonata" && node.statusProperty) {
+            try {
+                jsonataExpr = RED.util.prepareJSONataExpression(node.statusProperty, node);
+            } catch (err) {
+                node.error(`Invalid JSONata expression: ${err.message}`);
+            }
+        }
 
         // Ensure comment is within 100 characters
         if (node.comment && node.comment.length > 100) {
             node.comment = node.comment.substring(0, 100);
         }
         
-        // Update status based on configuration
-        const updateStatus = function() {
+        // Update status based on configuration (static — no msg available)
+        const updateStaticStatus = function() {
             switch (node.statusDisplay) {
                 case "default":
                     utils.setStatusOK(node, node.comment || "No comment set");
@@ -24,16 +36,54 @@ module.exports = function(RED) {
                 case "name":
                     utils.setStatusOK(node, node.name || "comment");
                     break;
+                case "property":
+                    // Can't resolve msg properties without a message — show placeholder
+                    utils.setStatusOK(node, "waiting for input");
+                    break;
                 case "none":
                 default:
-                    // No status for "none"
                     break;
             }
         };
 
-        updateStatus();
+        // Resolve and display the configured status property from a message
+        function resolveStatusProperty(msg) {
+            return new Promise(function(resolve) {
+                if (node.statusPropertyType === "jsonata" && jsonataExpr) {
+                    RED.util.evaluateJSONataExpression(jsonataExpr, msg, function(err, result) {
+                        if (err) {
+                            resolve(undefined);
+                        } else {
+                            resolve(result);
+                        }
+                    });
+                } else {
+                    // msg type — use getMessageProperty
+                    try {
+                        resolve(RED.util.getMessageProperty(msg, node.statusProperty));
+                    } catch (err) {
+                        resolve(undefined);
+                    }
+                }
+            });
+        }
+
+        function formatValue(val) {
+            if (val === undefined) return "undefined";
+            if (val === null) return "null";
+            if (typeof val === "number") return val % 1 === 0 ? String(val) : val.toFixed(2);
+            if (typeof val === "boolean") return String(val);
+            if (typeof val === "string") return val.length > 40 ? val.substring(0, 40) + "…" : val;
+            if (typeof val === "object") {
+                const s = JSON.stringify(val);
+                return s.length > 40 ? s.substring(0, 40) + "…" : s;
+            }
+            return String(val);
+        }
 
-        node.on("input", function(msg, send, done) {
+        updateStaticStatus();
+
+        node.on("input", async function(msg, send, done) {
             send = send || function() { node.send.apply(node, arguments); };
 
             // Guard against invalid msg
@@ -43,7 +93,16 @@ module.exports = function(RED) {
                 return;
             }
 
-            updateStatus();
+            if (node.statusDisplay === "property" && node.statusProperty) {
+                const val = await resolveStatusProperty(msg);
+                if (val === undefined) {
+                    utils.setStatusWarn(node, `${node.statusPropertyType === "jsonata" ? "expr" : node.statusProperty}: not found`);
+                } else {
+                    utils.setStatusChanged(node, formatValue(val));
+                }
+            } else {
+                updateStaticStatus();
+            }
 
             send(msg);
             if (done) done();

package/nodes/contextual-label-block.js

@@ -6,6 +6,7 @@ module.exports = function(RED) {
         const node = this;
 
         node.contextPropertyName = config.contextPropertyName || "in1";
+        node.inputProperty = config.inputProperty || "payload";
         node.removeLabel = config.removeLabel || false;
 
         utils.setStatusOK(node, node.removeLabel ? "remove" : `set -> ${node.contextPropertyName}`);
@@ -23,10 +24,10 @@ module.exports = function(RED) {
             // Set or remove context property
             if (node.removeLabel) {
                 delete msg.context;
-                utils.setStatusChanged(node, `${msg.payload} -> removed`);
+                utils.setStatusChanged(node, `${msg[node.inputProperty]} -> removed`);
             } else {
                 msg.context = node.contextPropertyName;
-                utils.setStatusChanged(node, `${msg.payload} -> ${node.contextPropertyName}`);
+                utils.setStatusChanged(node, `${msg[node.inputProperty]} -> ${node.contextPropertyName}`);
             }
 
             send(msg);

package/nodes/convert-block.js

@@ -287,7 +287,7 @@ module.exports = function(RED) {
             const outDisplay = output % 1 === 0 ? output : output.toFixed(2);
 
             // Update status and send output
-            utils.setStatusOK(node, `${inDisplay} ${inUnit} → ${outDisplay} ${outUnit}`);
+            utils.setStatusOK(node, `${outDisplay} ${outUnit}`);
 
             msg.payload = output;
             send(msg);

package/nodes/edge-block.html

@@ -31,7 +31,7 @@
         outputs: 1,
         inputLabels: ["input"],
         outputLabels: ["transition"],
-        icon: "font-awesome/fa-exchange",
+        icon: "font-awesome/fa-bolt",
         paletteLabel: "edge",
         label: function() {
             return this.name || "edge";
@@ -49,7 +49,9 @@ Detects boolean state transitions (true-to-false or false-to-true).
 : payload (string | boolean) : Transition type (`"true-to-false"`, `"false-to-true"`) for `"algorithm"`, true for `"reset"`.
 
 ### Outputs
-: payload (boolean) : `true` when the specified transition occurs; `false` otherwise.
+: *entire message* : The original input message is forwarded **only** when the specified transition occurs. No output otherwise.
+: edge (boolean) : `true` is added to the message to flag that a transition was detected.
+: payload : Preserved from the input message (unchanged).
 
 ### Properties
 : name (string) : Display name in editor.
@@ -58,8 +60,9 @@ Detects boolean state transitions (true-to-false or false-to-true).
 
 ### Details
 Detects transitions in boolean input (read from the configured **Input Property**, default: `msg.payload`) based on the configured `algorithm`.
-Outputs `msg.payload` as true only when the specified transition occurs (true-to-false or false-to-true).
+Forwards the **entire original message** only when the specified transition occurs (true-to-false or false-to-true), with `msg.edge = true` added.
 No output on first input after reset, if no transition occurs, or for non-boolean inputs.
+Because the full message passes through, this node can be used inline to conditionally gate messages based on boolean state changes while preserving all upstream properties.
 
 Configuration via `msg.context`:
 - `"algorithm"`: Sets transition type, no output.

package/nodes/edge-block.js

@@ -103,10 +103,11 @@ module.exports = function(RED) {
             }
 
             if (isTransition) {
-                utils.setStatusChanged(node, `in: ${currentValue}, out: true`);
-                send({ payload: true });
+                utils.setStatusChanged(node, `true`);
+                msg.edge = true;
+                send(msg);
             } else {
-                utils.setStatusUnchanged(node, `in: ${currentValue}, out: none`);
+                utils.setStatusUnchanged(node, `none`);
             }
 
             node.lastValue = currentValue;

package/nodes/enum-switch-block.html

@@ -54,7 +54,7 @@
                 return "";
             }
         },
-        icon: "font-awesome/fa-exchange",
+        icon: "font-awesome/fa-list-ol",
         paletteLabel: "enum switch",
         label: function() {
             const rules = JSON.parse(this.rules || "[]");

package/nodes/global-setter.html

@@ -12,8 +12,8 @@
         <input type="text" id="node-input-property" style="width:70%;">
     </div>
     <div class="form-row">
-        <label for="node-input-writePriority" title="Priority is evaluated for final value when using global-setter/getter nodes."><i class="fa fa-sort-numeric-asc"></i> Priority</label>
-        <input type="text" id="node-input-writePriority" placeholder="single">
+        <label for="node-input-writePriority" title="Network priority slot (1-16) for this message. Network writes from external control systems use these slots."><i class="fa fa-sort-numeric-asc"></i> Network Priority</label>
+        <input type="text" id="node-input-writePriority" placeholder="16">
         <input type="hidden" id="node-input-writePriorityType">
     </div>
     
@@ -29,13 +29,13 @@
 
     <div class="form-row">
         <label>&nbsp;</label>
-        <button type="button" id="node-btn-clear-priorities" class="editor-button" style="width: calc(70% - 3px);" title="Clear all 16 priority slots on the live node (does not affect the default value)">
-            <i class="fa fa-eraser"></i> Clear All Priorities
+        <button type="button" id="node-btn-clear-priorities" class="editor-button" style="width: calc(70% - 3px);" title="Clear all 16 network priority slots on the live node (does not affect the default or fallback values)">
+            <i class="fa fa-eraser"></i> Clear Network Priorities
         </button>
     </div>
 
     <div class="form-tips">
-        <b>Note:</b> This node writes to the selected <b>Priority</b>, manually, by msg or flow. The actual Global Variable value will be the highest active priority.
+        <b>Note:</b> This node writes to the <b>Network Priority</b> slot (1-16), manually, by msg or flow. The actual value is determined by the highest active source: Priorities 1-16 → Fallback → Default.
     </div>
 </script>
 
@@ -49,7 +49,7 @@
             property: { value: "payload", required: true },
             defaultValue: { value: "", required: true },
             defaultValueType: { value: "num", required: true },
-            writePriority: { value: "default", required: true },
+            writePriority: { value: "fallback", required: true },
             writePriorityType: { value: "dropdown" }
         },
         inputs: 1,
@@ -101,7 +101,7 @@
                         { value: "14", label: "14"},
                         { value: "15", label: "15"},
                         { value: "16", label: "16 (Network Logic)"},
-                        { value: "default", label: "default (fallback)"},
+                        { value: "fallback", label: "fallback (Internal Logic)"},
                     ]
                 }, "msg", "flow"],
                 typeField: "#node-input-writePriorityType"
@@ -141,12 +141,12 @@ Manage a global variable in a repeatable way.
 ### Inputs 
 : payload (any) : Input payload is passed through unchanged.
 : property (string) : The input property where the value is taken from.
-: priority (number|string) : _Optional_. Overrides the configured Priority at runtime. Accepts `1`–`16` or `"default"`. For example, `msg.priority = 8` writes to priority slot 8.
-: context (string) : _Optional_. Tagged-input priority routing (matches priority-block conventions). Accepts `"priority1"`–`"priority16"`, `"default"`, or `"reload"`. When both `msg.priority` and `msg.context` are present, `msg.priority` takes precedence.
+: priority (number|string) : _Optional_. Overrides the configured Network Priority at runtime. Accepts `1`–`16`. For example, `msg.priority = 8` writes to priority slot 8.
+: context (string) : _Optional_. Tagged-input routing. Accepts `"fallback"` (writes to the fallback slot) or `"priority1"`–`"priority16"` (writes to network priority slots), or `"reload"` (reload state without writing). When both `msg.priority` and `msg.context` are present, `msg.priority` takes precedence.
 : units (string) : The units associated with the value, if any. Also supports nested units at `msg.<inputProperty>.units`.
 
 ### Outputs
-: payload (any) : Original payload.
+: payload (any) : Original payload plus full state object (value, activePriority, all priority slots, fallback, metadata).
 
 ### Details
 Global variables are meant to be retrieved in other places, this necessarily means managing the same string in multiple places. 
@@ -155,7 +155,12 @@ This node allows you to set a global variable in one place, and retrieve it else
 
 When this node is deleted or the flow is redeployed, it will automatically remove (prune) the variable from the selected Context Store.
 
-**Clear All Priorities** button (in editor): Resets all 16 priority slots to `null` on the live running node. The default value is preserved. The active value recalculates to the highest remaining priority (or falls back to default). The node must be deployed first.
+**Priority Hierarchy**: The active value is determined by the highest active source:
+1. **Network Priorities (1-16)**: Used by external automation systems (e.g., BACnet, network service). Priority 16 is typical for network logic, 1 for life safety.
+2. **Fallback**: A dynamic input slot updated via `{context: "fallback", payload: value}`. Useful for internal logic to write a secondary value (e.g., persistent context setpoints).
+3. **Default**: A static configuration value. Always used as the ultimate fallback when all other sources are null/empty.
+
+**Clear Network Priorities** button (in editor): Resets all 16 priority slots to `null` on the live running node. The fallback and default values are preserved. The active value recalculates based on the hierarchy. The node must be deployed first.
 
 ### Status
 - Green (dot): Configuration update
@@ -164,6 +169,8 @@ When this node is deleted or the flow is redeployed, it will automatically remov
 - Red (ring): Error
 - Yellow (ring): Warning
 
+Status prefix: Empty = default active, `F` = fallback active, `P` = network priority active (e.g., `P3` = priority 3).
+
 ### References
 - [Node-RED Documentation](https://nodered.org/docs/)  
 - [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)

package/nodes/global-setter.js

@@ -24,6 +24,7 @@ module.exports = function(RED) {
                 value: node.defaultValue,
                 defaultValue: node.defaultValue,
                 activePriority: "default",
+                fallback: null,
                 units: null,
                 priority: { 1: null, 2: null, 3: null, 4: null, 5: null, 6: null, 7: null, 8: null, 9: null, 10: null, 11: null, 12: null, 13: null, 14: null, 15: null, 16: null },
                 metadata: {
@@ -93,44 +94,63 @@ module.exports = function(RED) {
                 node.isBusy = true;
 
                 // Resolve write priority — three sources, in order of precedence:
-                //   1. msg.priority (number 1-16 or "default") — explicit per-message override
-                //   2. msg.context  ("priority1"–"priority16" or "default") — tagged-input pattern (matches priority-block)
+                //   1. msg.priority (number 1-16) — explicit per-message override
+                //   2. msg.context  ("priority1"–"priority16", "fallback", "reload") — tagged-input pattern
                 //   3. Configured writePriority (dropdown / msg / flow typed-input)
                 // Use local variable — never mutate node.writePriority so the config default is preserved across messages
                 let activePrioritySlot = null;
+                let isFallbackWrite = false;
+                
                 try {
-                    if (msg.hasOwnProperty("priority") && (typeof msg.priority === "number" || typeof msg.priority === "string")) {
-                        // Source 1: msg.priority (direct number or "default") — skip objects (e.g. priority array from state)
-                        const mp = msg.priority;
-                        if (mp === "default") {
-                            activePrioritySlot = "default";
+                    if (msg.hasOwnProperty("context") && typeof msg.context === "string") {
+                        // Check for special contexts first
+                        const ctx = msg.context;
+                        if (ctx === "fallback") {
+                            isFallbackWrite = true;
+                        } else if (ctx === "reload") {
+                            // Handled separately below
+                            activePrioritySlot = "reload";
                         } else {
-                            const p = parseInt(mp, 10);
-                            if (isNaN(p) || p < 1 || p > 16) {
-                                node.isBusy = false;
-                                return utils.sendError(node, msg, done, `Invalid msg.priority: ${mp}`);
+                            // Check for priority context
+                            const priorityMatch = /^priority([1-9]|1[0-6])$/.exec(ctx);
+                            if (priorityMatch) {
+                                activePrioritySlot = priorityMatch[1];
                             }
-                            activePrioritySlot = String(p);
+                            // Unknown contexts leave activePrioritySlot null → falls to config
                         }
-                    } else if (msg.hasOwnProperty("context") && typeof msg.context === "string") {
-                        // Source 2: msg.context tagged-input ("priority8", "default", etc.)
-                        // "reload" is handled separately below — skip it here
-                        const ctx = msg.context;
-                        const priorityMatch = /^priority([1-9]|1[0-6])$/.exec(ctx);
-                        if (priorityMatch) {
-                            activePrioritySlot = priorityMatch[1];
-                        } else if (ctx === "default") {
-                            activePrioritySlot = "default";
+                    }
+                    
+                    if (msg.hasOwnProperty("priority") && (typeof msg.priority === "number" || typeof msg.priority === "string")) {
+                        // Source 1: msg.priority (direct number 1-16) — skip objects (e.g. priority array from state)
+                        const mp = msg.priority;
+                        const p = parseInt(mp, 10);
+                        if (isNaN(p) || p < 1 || p > 16) {
+                            node.isBusy = false;
+                            return utils.sendError(node, msg, done, `Invalid msg.priority: ${mp} (must be 1-16)`);
                         }
-                        // Other contexts (e.g. "reload") leave activePrioritySlot null → falls to config
+                        activePrioritySlot = String(p);
+                        isFallbackWrite = false; // msg.priority overrides fallback context
                     }
 
-                    // Source 3: Fall back to configured typed-input when no message override matched
-                    if (activePrioritySlot === null) {
+                    // Source 3: Fall back to configured writePriority only if no message override matched
+                    if (!isFallbackWrite && activePrioritySlot === null) {
+                        let configuredSlot;
                         if (utils.requiresEvaluation(config.writePriorityType)) {
-                            activePrioritySlot = await utils.evaluateNodeProperty(config.writePriority, config.writePriorityType, node, msg);
+                            configuredSlot = await utils.evaluateNodeProperty(config.writePriority, config.writePriorityType, node, msg);
+                        } else {
+                            configuredSlot = config.writePriority;
+                        }
+                        // Allow "fallback" as a configured value
+                        if (configuredSlot === "fallback") {
+                            isFallbackWrite = true;
                         } else {
-                            activePrioritySlot = config.writePriority;
+                            // Validate configured priority (must be 1-16)
+                            const cp = parseInt(configuredSlot, 10);
+                            if (isNaN(cp) || cp < 1 || cp > 16) {
+                                node.isBusy = false;
+                                return utils.sendError(node, msg, done, `Invalid configured writePriority: ${configuredSlot} (must be 1-16 or fallback)`);
+                            }
+                            activePrioritySlot = String(cp);
                         }
                     }
                 } catch (err) {
@@ -147,12 +167,12 @@ module.exports = function(RED) {
                 }
 
                 // Handle Reload
-                if (msg.context === "reload") {
+                if (activePrioritySlot === "reload") {
                     RED.events.emit("bldgblocks:global:value-changed", { key: node.varName, store: node.storeName, data: state });
                     await utils.setGlobalState(node, node.varName, node.storeName, state);
                     
-                    prefix = state.activePriority === 'default' ? '' : 'P';
-                    const statusText = `reload: ${prefix}${state.activePriority}:${state.value}${state.units || ''}`;
+                    const activeLabel = state.activePriority === 'default' ? 'default' : (state.activePriority === 'fallback' ? 'fallback' : `P${state.activePriority}`);
+                    const statusText = `reload: ${activeLabel}:${state.value}${state.units || ''}`;
                     
                     return utils.sendSuccess(node, { ...state }, done, statusText, null, "dot");
                 }
@@ -168,9 +188,9 @@ module.exports = function(RED) {
                     return utils.sendError(node, msg, done, `msg.${node.inputProperty} not found or invalid property path`);
                 }
 
-                // Update State
-                if (activePrioritySlot === 'default') {
-                    state.defaultValue = inputValue === null || inputValue === "null" ? node.defaultValue : inputValue;
+                // Update State: either fallback or priority slot
+                if (isFallbackWrite) {
+                    state.fallback = inputValue === null || inputValue === "null" ? null : inputValue;
                 } else {
                     const priority = parseInt(activePrioritySlot, 10);
                     if (isNaN(priority) || priority < 1 || priority > 16) {
@@ -180,26 +200,22 @@ module.exports = function(RED) {
                         state.priority[activePrioritySlot] = inputValue;
                     }
                 }
-                
-                if (state.defaultValue === null || state.defaultValue === "null" || state.defaultValue === undefined) {
-                    state.defaultValue = node.defaultValue;
-                }
 
-                // Calculate Winner
+                // Calculate Winner (includes priorities 1-16, then fallback, then default)
                 const { value, priority } = utils.getHighestPriority(state);
 
                 // Check for change
                 if (value === state.value && priority === state.activePriority) {
                     // Ensure payload stays in sync with value
                     state.payload = state.value;
-                    // Persist even when output unchanged — the priority array itself changed
+                    // Persist even when output unchanged — the priority/fallback array itself changed
                     await utils.setGlobalState(node, node.varName, node.storeName, state);
                     if (node.storeName !== 'default') {
                         await utils.setGlobalState(node, node.varName, 'default', state);
                     }
-                    prefix = `${activePrioritySlot === 'default' ? '' : 'P'}`;
-                    const statePrefix = `${state.activePriority === 'default' ? '' : 'P'}`;
-                    const noChangeText = `no change: ${prefix}${activePrioritySlot}:${inputValue} > active: ${statePrefix}${state.activePriority}:${state.value}${state.units || ''}`;
+                    const writeSlotLabel = isFallbackWrite ? 'fallback' : `P${activePrioritySlot}`;
+                    const activeLabel = state.activePriority === 'default' ? 'default' : (state.activePriority === 'fallback' ? 'fallback' : `P${state.activePriority}`);
+                    const noChangeText = `no change: ${writeSlotLabel}:${inputValue} > active: ${activeLabel}:${state.value}${state.units || ''}`;
                     utils.setStatusUnchanged(node, noChangeText);
                     // Pass message through even if no context change
                     send({ ...state });
@@ -237,9 +253,9 @@ module.exports = function(RED) {
                     await utils.setGlobalState(node, node.varName, 'default', state);
                 }
 
-                prefix = `${activePrioritySlot === 'default' ? '' : 'P'}`;
-                const statePrefix = `${state.activePriority === 'default' ? '' : 'P'}`;
-                const statusText = `write: ${prefix}${activePrioritySlot}:${inputValue}${state.units || ''} > active: ${statePrefix}${state.activePriority}:${state.value}${state.units || ''}`;
+                const writeSlotLabel = isFallbackWrite ? 'fallback' : `P${activePrioritySlot}`;
+                const activeLabel = state.activePriority === 'default' ? 'default' : (state.activePriority === 'fallback' ? 'fallback' : `P${state.activePriority}`);
+                const statusText = `write: ${writeSlotLabel}:${inputValue}${state.units || ''} > active: ${activeLabel}:${state.value}${state.units || ''}`;
 
                 RED.events.emit("bldgblocks:global:value-changed", {
                     key: node.varName,
@@ -302,7 +318,8 @@ module.exports = function(RED) {
                 store: targetNode.storeName,
                 data: state
             });
-            utils.setStatusOK(targetNode, `cleared: default:${state.value}`);
+            const activeLabel = state.activePriority === 'default' ? 'default' : (state.activePriority === 'fallback' ? 'fallback' : `P${state.activePriority}`);
+            utils.setStatusOK(targetNode, `cleared: active: ${activeLabel}:${state.value}`);
             targetNode.send({ ...state });
 
             res.status(200).json({ message: "Priorities cleared", value: state.value, activePriority: state.activePriority });

package/nodes/hysteresis-block.js

@@ -180,7 +180,7 @@ module.exports = function(RED) {
                 { payload: newState === "below" }
             ];
 
-            utils.setStatusChanged(node, `in: ${inputValue.toFixed(2)}, state: ${newState}`);
+            utils.setStatusChanged(node, `${inputValue.toFixed(2)} -> ${newState}`);
 
             node.state = newState;
             send(output);

package/nodes/interpolate-block.js

@@ -110,8 +110,8 @@ module.exports = function(RED) {
             // Check if output value has changed
             const isUnchanged = outputValue === node.lastOutput;
             const statusShape = isUnchanged ? "ring" : "dot";
-            utils.setStatusOK(node, `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`);
-            if (statusShape === "ring") utils.setStatusUnchanged(node, `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`);
+            utils.setStatusOK(node, `${outputValue.toFixed(2)}`);
+            if (statusShape === "ring") utils.setStatusUnchanged(node, `${outputValue.toFixed(2)}`);
 
             if (!isUnchanged) {
                 node.lastOutput = outputValue;

package/nodes/negate-block.js

@@ -44,10 +44,10 @@ module.exports = function(RED) {
                     return;
                 }
                 outputValue = -inputValue;
-                statusText = `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`;
+                statusText = `${inputValue.toFixed(2)} -> ${outputValue.toFixed(2)}`;
             } else if (typeof inputValue === "boolean") {
                 outputValue = !inputValue;
-                statusText = `in: ${inputValue}, out: ${outputValue}`;
+                statusText = `${inputValue} -> ${outputValue}`;
             } else {
                 utils.setStatusError(node, "Unsupported type");
                 if (done) done();

package/nodes/network-point-register.js

@@ -104,8 +104,17 @@ module.exports = function(RED) {
                 RED.events.emit("bldgblocks:network:point-update", pointUpdateData);
 
                 // Passthrough
-                const prefix = msg.activePriority === 'default' ? '' : 'P';
-                const statusText = `Passthrough: ${prefix}${msg.activePriority}:${msg.value}${msg.units === null ? "" : ` ${msg.units}`}`;
+                let statusLabel;
+                if (msg.activePriority === 'default') {
+                    statusLabel = 'default';
+                } else if (msg.activePriority === 'fallback') {
+                    statusLabel = 'fallback';
+                } else if (typeof msg.activePriority === 'number' || /^\d+$/.test(msg.activePriority)) {
+                    statusLabel = `P:${msg.activePriority}`;
+                } else {
+                    statusLabel = String(msg.activePriority);
+                }
+                const statusText = `Passthrough: ${statusLabel}:${msg.value}${msg.units === null ? "" : ` ${msg.units}`}`;
                 utils.sendSuccess(node, msg, done, statusText, node.pointId, "ring");
 
             } catch (err) {

package/nodes/network-service-write.js

@@ -43,16 +43,12 @@ module.exports = function(RED) {
                     }
                 }
 
-                // Update Priority Logic
-                if (msg.priority === 'default') {
-                    state.defaultValue = newValue ?? state.defaultValue;
-                } else {
-                    const priority = parseInt(msg.priority, 10);
-                    if (isNaN(priority) || priority < 1 || priority > 16) {
-                        return utils.sendError(node, msg, done, `Invalid Priority: ${msg.priority}`, msg.pointId);
-                    }
-                    state.priority[msg.priority] = newValue;
+                // Update Priority Logic (only allow priorities 1-16, no default)
+                const priority = parseInt(msg.priority, 10);
+                if (isNaN(priority) || priority < 1 || priority > 16) {
+                    return utils.sendError(node, msg, done, `Invalid Priority: ${msg.priority} (must be 1-16)`, msg.pointId);
                 }
+                state.priority[msg.priority] = newValue;
 
                 // Calculate Winner
                 const result = utils.getHighestPriority(state);
@@ -63,8 +59,8 @@ module.exports = function(RED) {
                 // Save (Async) & Emit
                 await utils.setGlobalState(node, path, store, state);
 
-                const prefixReq = msg.priority === 'default' ? '' : 'P';
-                const prefixAct = state.activePriority === 'default' ? '' : 'P';
+                const prefixReq = 'P';
+                const prefixAct = state.activePriority === 'default' ? '' : (state.activePriority === 'fallback' ? 'F' : 'P');
                 const statusMsg = `Wrote: ${prefixReq}${msg.priority}:${newValue} > Active: ${prefixAct}${state.activePriority}:${state.value}`;
 
                 msg = { ...state, status: null }; 

package/nodes/on-change-block.js

@@ -90,14 +90,7 @@ module.exports = function(RED) {
                 // Ignore unknown context
             }
 
-            // Validate input payload
-            if (!msg.hasOwnProperty("payload")) {
-                utils.setStatusError(node, "missing payload");
-                send(msg);
-                if (done) done();
-                return;
-            }
-
+            // Get input value from configured property
             let inputValue;
             try {
                 inputValue = RED.util.getMessageProperty(msg, node.inputProperty);

package/nodes/priority-block.js

@@ -199,16 +199,16 @@ module.exports = function(RED) {
                     }
                 }
 
-                // Fall back to default or fallback
+                // Fall through to fallback, then default (matching global-setter hierarchy)
                 if (selectedValue === null) {
-                    if (defaultValue !== null) {
-                        selectedValue = defaultValue;
-                        activePriority = "default";
-                        selectedMessage = messages.default;
-                    } else if (fallbackValue !== null) {
+                    if (fallbackValue !== null) {
                         selectedValue = fallbackValue;
                         activePriority = "fallback";
                         selectedMessage = messages.fallback;
+                    } else if (defaultValue !== null) {
+                        selectedValue = defaultValue;
+                        activePriority = "default";
+                        selectedMessage = messages.default;
                     }
                 }