@bldgblocks/node-red-contrib-control 0.1.37 → 0.1.38

package/nodes/contextual-label-block.js

@@ -8,7 +8,7 @@ module.exports = function(RED) {
         node.contextPropertyName = config.contextPropertyName || "in1";
         node.removeLabel = config.removeLabel || false;
 
-        utils.setStatusOK(node, `mode: ${node.removeLabel ? "remove" : "set"}, property: ${node.contextPropertyName}`);
+        utils.setStatusOK(node, node.removeLabel ? "remove" : `set -> ${node.contextPropertyName}`);
 
         node.on("input", function(msg, send, done) {
             send = send || function() { node.send.apply(node, arguments); };
@@ -23,10 +23,10 @@ module.exports = function(RED) {
             // Set or remove context property
             if (node.removeLabel) {
                 delete msg.context;
-                utils.setStatusChanged(node, `in: ${msg.payload}, out: removed context`);
+                utils.setStatusChanged(node, `${msg.payload} -> removed`);
             } else {
                 msg.context = node.contextPropertyName;
-                utils.setStatusChanged(node, `in: ${msg.payload}, out: ${node.contextPropertyName}`);
+                utils.setStatusChanged(node, `${msg.payload} -> ${node.contextPropertyName}`);
             }
 
             send(msg);

package/nodes/delay-block.js

@@ -5,14 +5,19 @@ module.exports = function(RED) {
         RED.nodes.createNode(this, config);
         const node = this;
 
+        // Unit multipliers (constant, computed once)
+        const delayOnMultiplier = config.delayOnUnits === "seconds" ? 1000 : config.delayOnUnits === "minutes" ? 60000 : 1;
+        const delayOffMultiplier = config.delayOffUnits === "seconds" ? 1000 : config.delayOffUnits === "minutes" ? 60000 : 1;
+
         // Initialize state
         node.name = config.name;
         node.state = false;
         node.desired = false;
-        node.delayOn = parseFloat(config.delayOn) * (config.delayOnUnits === "seconds" ? 1000 : config.delayOnUnits === "minutes" ? 60000 : 1);
-        node.delayOff = parseFloat(config.delayOff) * (config.delayOffUnits === "seconds" ? 1000 : config.delayOffUnits === "minutes" ? 60000 : 1);
+        node.delayOn = parseFloat(config.delayOn) * delayOnMultiplier;
+        node.delayOff = parseFloat(config.delayOff) * delayOffMultiplier;
 
         let timeoutId = null;
+        let pendingDone = null;   // Track deferred done() for in-flight timers
         node.isBusy = false;
 
         node.on("input", async function(msg, send, done) {
@@ -46,21 +51,21 @@ module.exports = function(RED) {
                     utils.requiresEvaluation(config.delayOnType) 
                         ? utils.evaluateNodeProperty(config.delayOn, config.delayOnType, node, msg)
                             .then(val => parseFloat(val))
-                        : Promise.resolve(node.delayOn),
+                        : Promise.resolve(parseFloat(config.delayOn)),
                 );
                 
                 evaluations.push(
                     utils.requiresEvaluation(config.delayOffType) 
                         ? utils.evaluateNodeProperty(config.delayOff, config.delayOffType, node, msg)
                             .then(val => parseFloat(val))
-                        : Promise.resolve(node.delayOff),
+                        : Promise.resolve(parseFloat(config.delayOff)),
                 );
 
                 const results = await Promise.all(evaluations);   
 
-                // Update runtime with evaluated values
-                if (!isNaN(results[0])) node.delayOn = results[0] * (config.delayOnUnits === "seconds" ? 1000 : config.delayOnUnits === "minutes" ? 60000 : 1);
-                if (!isNaN(results[1])) node.delayOff = results[1] * (config.delayOffUnits === "seconds" ? 1000 : config.delayOffUnits === "minutes" ? 60000 : 1);         
+                // Update runtime with evaluated values (apply unit multiplier to raw config value)
+                if (!isNaN(results[0])) node.delayOn = results[0] * delayOnMultiplier;
+                if (!isNaN(results[1])) node.delayOff = results[1] * delayOffMultiplier;         
             } catch (err) {
                 node.error(`Error evaluating properties: ${err.message}`);
                 if (done) done();
@@ -98,7 +103,13 @@ module.exports = function(RED) {
                             clearTimeout(timeoutId);
                             timeoutId = null;
                         }
+                        // Complete any deferred done from a cancelled timer
+                        if (pendingDone) {
+                            pendingDone();
+                            pendingDone = null;
+                        }
                         node.state = false;
+                        node.desired = false;
                         utils.setStatusOK(node, "reset");
                     }
                     if (done) done();
@@ -160,44 +171,89 @@ module.exports = function(RED) {
 
             if (!node.state && inputValue === true) {
                 if (node.desired) {
+                    // Already awaiting true, ignore duplicate
                     if (done) done();
                     return;
                 }
                 if (timeoutId) {
                     clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                // Complete any prior deferred done before starting new timer
+                if (pendingDone) {
+                    pendingDone();
+                    pendingDone = null;
                 }
                 utils.setStatusUnchanged(node, "awaiting true");
                 node.desired = true;
+
+                // Clone msg for the timer callback so we don't hold the original
+                const delayedMsg = RED.util.cloneMessage(msg);
+                // Defer done — this message isn't complete until the timer fires or is cancelled
+                pendingDone = done;
+
                 timeoutId = setTimeout(() => {
                     node.state = true;
-                    msg.payload = true;
-                    delete msg.context;
+                    delayedMsg.payload = true;
+                    delete delayedMsg.context;
                     utils.setStatusChanged(node, "in: true, out: true");
-                    send(msg);
+                    send(delayedMsg);
                     timeoutId = null;
+                    if (pendingDone) {
+                        pendingDone();
+                        pendingDone = null;
+                    }
                 }, node.delayOn);
+
+                // Don't call done() here — it's deferred to the timer callback
+                return;
             } else if (node.state && inputValue === false) {
                 if (node.desired === false) {
+                    // Already awaiting false, ignore duplicate
                     if (done) done();
                     return;
                 }
                 if (timeoutId) {
                     clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                // Complete any prior deferred done before starting new timer
+                if (pendingDone) {
+                    pendingDone();
+                    pendingDone = null;
                 }
                 utils.setStatusUnchanged(node, "awaiting false");
                 node.desired = false;
+
+                // Clone msg for the timer callback so we don't hold the original
+                const delayedMsg = RED.util.cloneMessage(msg);
+                // Defer done — this message isn't complete until the timer fires or is cancelled
+                pendingDone = done;
+
                 timeoutId = setTimeout(() => {
                     node.state = false;
-                    msg.payload = false;
-                    delete msg.context;
+                    delayedMsg.payload = false;
+                    delete delayedMsg.context;
                     utils.setStatusChanged(node, "in: false, out: false");
-                    send(msg);
+                    send(delayedMsg);
                     timeoutId = null;
+                    if (pendingDone) {
+                        pendingDone();
+                        pendingDone = null;
+                    }
                 }, node.delayOff);
+
+                // Don't call done() here — it's deferred to the timer callback
+                return;
             } else {
                 if (timeoutId) {
                     clearTimeout(timeoutId);
                     timeoutId = null;
+                    // Complete deferred done from the cancelled timer's message
+                    if (pendingDone) {
+                        pendingDone();
+                        pendingDone = null;
+                    }
                     utils.setStatusUnchanged(node, `canceled awaiting ${node.state}`);
                 } else {
                     utils.setStatusUnchanged(node, "no change");
@@ -217,6 +273,11 @@ module.exports = function(RED) {
                 clearTimeout(timeoutId);
                 timeoutId = null;
             }
+            // Complete any deferred done on shutdown
+            if (pendingDone) {
+                pendingDone();
+                pendingDone = null;
+            }
             done();
         });
     }

package/nodes/global-getter.js

@@ -10,10 +10,11 @@ module.exports = function(RED) {
         node.detail = config.detail;
         
         let setterNode = null;
-        let retryAction = null;
-        let healthCheckAction = null;
+        let retryTimeout = null;
+        let healthCheckTimeout = null;
         let updateListener = null;
         let retryCount = 0;
+        let closed = false;
         const retryDelays = [0, 100, 500, 1000, 2000, 4000, 8000, 16000];
         const maxRetries = retryDelays.length - 1;
         
@@ -85,9 +86,9 @@ module.exports = function(RED) {
                 
                 RED.events.on("bldgblocks:global:value-changed", updateListener);
                 
-                if (retryAction) {
-                    clearInterval(retryAction);
-                    retryAction = null;
+                if (retryTimeout) {
+                    clearTimeout(retryTimeout);
+                    retryTimeout = null;
                 }
                 
                 utils.setStatusOK(node, "Connected");
@@ -98,6 +99,11 @@ module.exports = function(RED) {
 
         function startHealthCheck() {
             const check = () => {
+                if (closed) return;
+                if (!updateListener) {
+                    healthCheckTimeout = setTimeout(check, 30000);
+                    return;
+                }
                 const listeners = RED.events.listeners("bldgblocks:global:value-changed");
                 const hasOurListener = listeners.includes(updateListener);
                 if (!hasOurListener) {
@@ -106,13 +112,14 @@ module.exports = function(RED) {
                         utils.setStatusOK(node, "Reconnected");
                     }
                 }
-                setTimeout(check, 30000);
+                healthCheckTimeout = setTimeout(check, 30000);
             };
-            setTimeout(check, 30000);
+            healthCheckTimeout = setTimeout(check, 30000);
         }
 
         function subscribeWithRetry() {
-            retryAction = () => {
+            function attempt() {
+                if (closed) return;
                 if (retryCount >= maxRetries) {
                     utils.sendError(node, null, null, "Connection failed");
                     return;
@@ -122,9 +129,9 @@ module.exports = function(RED) {
                     return; 
                 }
                 retryCount++;
-                setTimeout(retryAction, retryDelays[Math.min(retryCount, maxRetries - 1)]);
-            };
-            setTimeout(retryAction, retryDelays[0]);
+                retryTimeout = setTimeout(attempt, retryDelays[Math.min(retryCount, maxRetries - 1)]);
+            }
+            retryTimeout = setTimeout(attempt, retryDelays[0]);
         }
 
         // --- INPUT HANDLER ---
@@ -160,10 +167,18 @@ module.exports = function(RED) {
         }
 
         node.on('close', function(removed, done) {
-            if (healthCheckAction) clearInterval(healthCheckAction);
-            if (retryAction) clearInterval(retryAction);
-            if (removed && updateListener) {
+            closed = true;
+            if (healthCheckTimeout) {
+                clearTimeout(healthCheckTimeout);
+                healthCheckTimeout = null;
+            }
+            if (retryTimeout) {
+                clearTimeout(retryTimeout);
+                retryTimeout = null;
+            }
+            if (updateListener) {
                 RED.events.removeListener("bldgblocks:global:value-changed", updateListener);
+                updateListener = null;
             }
             done();
         });

package/nodes/global-setter.js

@@ -59,7 +59,8 @@ module.exports = function(RED) {
                 // Send properly formed state object downstream after full initialization
                 // Allows network-register and other downstream nodes to register on startup
                 // Use setTimeout with delay to allow getter nodes time to establish their event listeners
-                setTimeout(() => {
+                initTimer = setTimeout(() => {
+                    initTimer = null;
                     // Emit event so getter nodes with 'always' update mode receive initial value
                     RED.events.emit("bldgblocks:global:value-changed", {
                         key: node.varName,
@@ -120,7 +121,7 @@ module.exports = function(RED) {
                     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 statusText = `reload: ${prefix}${state.activePriority}:${state.value}${state.units || ''}`;
                     
                     return utils.sendSuccess(node, { ...state }, done, statusText, null, "dot");
                 }
@@ -158,8 +159,10 @@ module.exports = function(RED) {
 
                 // Check for change
                 if (value === state.value && priority === state.activePriority) {
+                    // Ensure payload stays in sync with value
+                    state.payload = state.value;
                     prefix = `${node.writePriority === 'default' ? '' : 'P'}`;
-                    const noChangeText = `no change: ${prefix}${node.writePriority}:${state.value}${state.units}`;
+                    const noChangeText = `no change: ${prefix}${node.writePriority}:${state.value}${state.units || ''}`;
                     utils.setStatusUnchanged(node, noChangeText);
                     // Pass message through even if no context change
                     send({ ...state });
@@ -199,7 +202,7 @@ module.exports = function(RED) {
 
                 prefix = `${node.writePriority === 'default' ? '' : 'P'}`;
                 const statePrefix = `${state.activePriority === 'default' ? '' : 'P'}`;
-                const statusText = `write: ${prefix}${node.writePriority}:${inputValue}${state.units} > active: ${statePrefix}${state.activePriority}:${state.value}${state.units}`;
+                const statusText = `write: ${prefix}${node.writePriority}:${inputValue}${state.units || ''} > active: ${statePrefix}${state.activePriority}:${state.value}${state.units || ''}`;
 
                 RED.events.emit("bldgblocks:global:value-changed", {
                     key: node.varName,
@@ -216,8 +219,8 @@ module.exports = function(RED) {
         });
 
         node.on('close', function(removed, done) {
+            if (initTimer) { clearTimeout(initTimer); initTimer = null; }
             if (removed && node.varName) {
-                RED.events.removeAllListeners("bldgblocks:global:value-changed");
                 // Callback style safe for close
                 node.context().global.set(node.varName, undefined, node.storeName, function() {
                     done();

package/nodes/history-buffer.js

@@ -20,9 +20,10 @@ module.exports = function(RED) {
         // Constants
         const TRENDS_DIR = getTrendsDirPath();
         // Use node ID in filename to prevent collisions between multiple history nodes
-        const BUFFER_FILE = path.join(TRENDS_DIR, `buffer_${node.id}.json`);
-        // Legacy file path for migration
+        const BUFFER_FILE = path.join(TRENDS_DIR, `buffer_${node.id}.jsonl`);
+        // Legacy file paths for migration
         const LEGACY_BUFFER_FILE = path.join(TRENDS_DIR, 'buffer_current.json');
+        const LEGACY_BUFFER_FILE_JSON = path.join(TRENDS_DIR, `buffer_${node.id}.json`);
         
         const COMMIT_INTERVAL_MS = 30 * 1000;  // 30 seconds
         const PRUNE_INTERVAL_MS = 60 * 1000;   // 60 seconds
@@ -122,6 +123,26 @@ module.exports = function(RED) {
             const now = new Date();
             const currentTimestamp = Math.floor(now.getTime() / 1000);
 
+            // Migrate old .json buffer to .jsonl if it exists
+            try {
+                await fs.promises.access(LEGACY_BUFFER_FILE_JSON);
+                // If the new .jsonl doesn't exist, rename; otherwise append and delete
+                try {
+                    await fs.promises.access(BUFFER_FILE);
+                    // Both exist: append old into new, then remove old
+                    const oldData = await fs.promises.readFile(LEGACY_BUFFER_FILE_JSON);
+                    if (oldData.length > 0) {
+                        await fs.promises.appendFile(BUFFER_FILE, oldData);
+                    }
+                    await fs.promises.unlink(LEGACY_BUFFER_FILE_JSON);
+                } catch (e) {
+                    // New .jsonl doesn't exist, just rename
+                    await fs.promises.rename(LEGACY_BUFFER_FILE_JSON, BUFFER_FILE);
+                }
+            } catch (err) {
+                // No legacy .json buffer, nothing to migrate
+            }
+
             // Check for this node's specific buffer
             try {
                 const stats = await fs.promises.stat(BUFFER_FILE);
@@ -136,7 +157,7 @@ module.exports = function(RED) {
 
                 if (isStale) {
                     const fileTs = Math.floor(stats.mtimeMs / 1000);
-                    const newName = path.join(TRENDS_DIR, `trend_${fileTs}_${node.id}.json`);
+                    const newName = path.join(TRENDS_DIR, `trend_${fileTs}_${node.id}.jsonl`);
                     await fs.promises.rename(BUFFER_FILE, newName);
                 }
 
@@ -147,7 +168,7 @@ module.exports = function(RED) {
             // Check for legacy buffer (migration)
             try {
                 await fs.promises.access(LEGACY_BUFFER_FILE);
-                const legacyName = path.join(TRENDS_DIR, `trend_${currentTimestamp}_legacy.json`);
+                const legacyName = path.join(TRENDS_DIR, `trend_${currentTimestamp}_legacy.jsonl`);
                 await fs.promises.rename(LEGACY_BUFFER_FILE, legacyName);
             } catch (err) {
                 // Ignore
@@ -157,9 +178,9 @@ module.exports = function(RED) {
         async function getHistoricalFiles() {
             try {
                 const files = await fs.promises.readdir(TRENDS_DIR);
-                // Filter for our files: trend_TIMESTAMP_*.json
+                // Filter for our files: trend_TIMESTAMP_*.json or .jsonl
                 return files
-                    .filter(f => f.startsWith('trend_') && f.endsWith('.json'))
+                    .filter(f => f.startsWith('trend_') && (f.endsWith('.json') || f.endsWith('.jsonl')))
                     .sort(); // String sort works for fixed-length timestamps usually, but numeric would be safer
             } catch (err) {
                 return [];
@@ -250,20 +271,10 @@ module.exports = function(RED) {
                 // Reset live buffer immediately so new messages go into next batch
                 liveBuffer = [];
                 
-                const lines = pointsToCommit.map(p => JSON.stringify(p)).join('\n');
+                const lines = pointsToCommit.map(p => JSON.stringify(p)).join('\n') + '\n';
                 
                 try {
-                    // Only add prefix newline if file exists and has content (simplified check)
-                    // We'll let the next append handle its own newline or just ensure we join efficiently.
-                    // Actually, safest is to append WITH a preceding newline if file exists.
-                    
-                    let prefix = '';
-                    try {
-                        const stats = await fs.promises.stat(BUFFER_FILE);
-                        if (stats.size > 0) prefix = '\n';
-                    } catch(e) { /* File doesn't exist, no prefix needed */ }
-
-                    await fs.promises.appendFile(BUFFER_FILE, prefix + lines);
+                    await fs.promises.appendFile(BUFFER_FILE, lines);
                 } catch (err) {
                     node.warn(`Buffer commit failed: ${err.message}`);
                     // Put points back at the start of buffer if write failed
@@ -336,15 +347,9 @@ module.exports = function(RED) {
             if (liveBuffer.length > 0) {
                 const pointsToCommit = liveBuffer;
                 liveBuffer = []; // Clear memory
-                const lines = pointsToCommit.map(p => JSON.stringify(p)).join('\n');
+                const lines = pointsToCommit.map(p => JSON.stringify(p)).join('\n') + '\n';
                 try {
-                    let prefix = '';
-                    try {
-                        const stats = await fs.promises.stat(BUFFER_FILE);
-                        if (stats.size > 0) prefix = '\n';
-                    } catch(e) { /* File doesn't exist */ }
-
-                    await fs.promises.appendFile(BUFFER_FILE, prefix + lines);
+                    await fs.promises.appendFile(BUFFER_FILE, lines);
                 } catch (err) {
                     // If append fails, we might lose these points during rotation, 
                     // put them back and abort rotation. Use concat for safety.
@@ -356,7 +361,7 @@ module.exports = function(RED) {
 
             // Perform Rotation (Rename)
             const timestamp = Math.floor(Date.now() / 1000);
-            const newName = path.join(TRENDS_DIR, `trend_${timestamp}_${node.id}.json`);
+            const newName = path.join(TRENDS_DIR, `trend_${timestamp}_${node.id}.jsonl`);
 
             try {
                 await fs.promises.access(BUFFER_FILE);

package/nodes/history-collector.js

@@ -134,7 +134,7 @@ module.exports = function(RED) {
                 msg.measurement = escapedMeasurementName;
                 msg.payload = line;
                 node.send(msg);
-                utils.setStatusChanged(node, `sent: ${valueString}`);
+                utils.setStatusChanged(node, `stored: ${valueString}`);
             } else if (node.storageType === 'object') {
                 msg.measurement = escapedMeasurementName;
                 msg.payload = {
@@ -144,7 +144,7 @@ module.exports = function(RED) {
                     timestamp: timestamp
                 };
                 node.send(msg);
-                utils.setStatusChanged(node, `sent: ${valueString}`);
+                utils.setStatusChanged(node, `stored: ${valueString}`);
             } else if (node.storageType === 'objectArray') {
                 msg.measurement = escapedMeasurementName;
                 msg.timestamp = timestamp;
@@ -155,7 +155,7 @@ module.exports = function(RED) {
                     tagsObj
                 ]
                 node.send(msg);
-                utils.setStatusChanged(node, `sent: ${valueString}`);
+                utils.setStatusChanged(node, `stored: ${valueString}`);
             } else if (node.storageType === 'batchObject') {
                 msg.payload = {
                     measurement: escapedMeasurementName,
@@ -166,7 +166,7 @@ module.exports = function(RED) {
                     tags: tagsObj
                 }
                 node.send(msg);
-                utils.setStatusChanged(node, `sent: ${valueString}`);
+                utils.setStatusChanged(node, `stored: ${valueString}`);
             }
 
             if (done) done();

package/nodes/network-point-read.js

@@ -147,6 +147,11 @@ module.exports = function(RED) {
             
             // Check for error response
             if (data.error) {
+                // During startup phase, suppress error display (network still coming online)
+                if (data.isStartupPhase) {
+                    // Keep stale value, don't show error - just stay in waiting state
+                    return;
+                }
                 const errorText = `Read failed for point #${node.pointId}: ${data.errorMessage || "Unknown error"}`;
                 utils.setStatusError(node, `Error: ${data.errorMessage || "Unknown error"}`);
                 node.error(errorText);  // Show in debug panel

package/nodes/network-service-bridge.js

@@ -112,10 +112,18 @@ module.exports = function(RED) {
                     const pending = node.pendingRequests[data.requestId];
                     delete node.pendingRequests[data.requestId];
                     
-                    // Suppress error notification during startup phase
-                    // (allows network to come online without nuisance errors)
                     if (pending.isStartupPhase) {
-                        // Silently drop timeout during startup
+                        // During startup: still notify point-read to reset isPollPending,
+                        // but suppress error logging (network may still be coming online)
+                        RED.events.emit('pointReference:response', {
+                            sourceNodeId: data.sourceNodeId,
+                            pointId: data.pointId,
+                            value: null,
+                            error: true,
+                            errorMessage: "Startup timeout",
+                            requestId: data.requestId,
+                            isStartupPhase: true
+                        });
                         return;
                     }
                     
@@ -195,10 +203,16 @@ module.exports = function(RED) {
                     const pending = node.pendingRequests[data.requestId];
                     delete node.pendingRequests[data.requestId];
                     
-                    // Suppress error notification during startup phase
-                    // (allows network to come online without nuisance errors)
                     if (pending.isStartupPhase) {
-                        // Silently drop timeout during startup
+                        // During startup: still notify point-write to reset pending state,
+                        // but suppress error logging
+                        RED.events.emit('pointWrite:response', {
+                            sourceNodeId: pending.sourceNodeId,
+                            pointId: data.pointId,
+                            error: "Startup timeout",
+                            requestId: data.requestId,
+                            isStartupPhase: true
+                        });
                         return;
                     }
                     
@@ -240,14 +254,16 @@ module.exports = function(RED) {
             // ================================================================
             
             // Check if this looks like a point response (has network.pointId or status.pointId)
-            const responsePointId = msg.network?.pointId ?? msg.status?.pointId ?? msg.pointId;
+            const rawPointId = msg.network?.pointId ?? msg.status?.pointId ?? msg.pointId;
+            // Normalize to number - point-read stores pointId as int, but WebSocket responses may return strings
+            const responsePointId = rawPointId !== undefined && rawPointId !== null ? parseInt(rawPointId, 10) : undefined;
             const responseValue = msg.value ?? msg.payload;
             const statusCode = msg.status?.code;
             const statusMessage = msg.status?.message || "";
             const isError = statusCode === "error";
             
-            // Valid response if we have a pointId (value can be null/undefined on error)
-            const isValidResponse = responsePointId !== undefined;
+            // Valid response if we have a valid numeric pointId
+            const isValidResponse = responsePointId !== undefined && !isNaN(responsePointId);
             
             if (isValidResponse) {
                 // Find ALL matching pending requests by pointId
@@ -313,8 +329,10 @@ module.exports = function(RED) {
                         updateStatus();
                     }
                 } else {
-                    // Response without matching request - could be stale or unsolicited
-                    utils.setStatusWarn(node, `Unmatched response for point #${responsePointId}`);
+                    // Response without matching request - duplicate, stale, or already timed-out
+                    // This is normal when remote has multiple WebSocket nodes or response arrives after timeout cleanup
+                    // Don't change node status - just log at trace level
+                    node.trace(`Ignoring duplicate/stale response for point #${responsePointId}`);
                 }
 
                 if (done) done();
@@ -358,6 +376,11 @@ module.exports = function(RED) {
         // Node lifecycle
         // ====================================================================
         node.on("close", function(done) {
+            // Clear startup timer
+            if (node.startupTimer) {
+                clearTimeout(node.startupTimer);
+                node.startupTimer = null;
+            }
             // Clear pending requests on close
             node.pendingRequests = {};
             // Remove event listeners
@@ -369,6 +392,15 @@ module.exports = function(RED) {
         // ====================================================================
         // Initialize
         // ====================================================================
+        // One-shot timer to guarantee startup delay completes even if no messages arrive
+        node.startupTimer = setTimeout(() => {
+            if (!node.startupComplete) {
+                node.startupComplete = true;
+                updateStatus();
+            }
+            node.startupTimer = null;
+        }, node.startupDelay * 1000);
+
         updateStatus();
     }
 

package/nodes/or-block.js

@@ -48,7 +48,7 @@ module.exports = function(RED) {
                     node.inputs[slotVal.index - 1] = Boolean(msg.payload);
                     const result = node.inputs.some(v => v === true);
                     const isUnchanged = result === lastResult && node.inputs.every((v, i) => v === lastInputs[i]);
-                    const statusText = `in: [${node.inputs.join(", ")}], out: ${result}`;
+                    const statusText = `[${node.inputs.join(", ")}] -> ${result}`;
                     
                     // ================================================================
                     // Debounce: Suppress consecutive same outputs within 500ms

package/nodes/priority-block.js

@@ -174,7 +174,7 @@ module.exports = function(RED) {
             send(currentOutput);
             const inDisplay = typeof msg.payload === "number" ? msg.payload.toFixed(2) : typeof msg.payload === "object" ? JSON.stringify(msg.payload).slice(0, 20) : msg.payload;
             const outDisplay = currentOutput.payload === null ? "null" : typeof currentOutput.payload === "number" ? currentOutput.payload.toFixed(2) : currentOutput.payload;
-            const statusText = `in: ${inDisplay}, out: ${outDisplay}, slot: ${currentOutput.diagnostics.activePriority || "none"}`;
+            const statusText = `out: ${outDisplay}, slot: ${currentOutput.diagnostics.activePriority || "none"}`;
             utils.setStatusChanged(node, statusText);
 
             if (done) done();