@bldgblocks/node-red-contrib-control 0.1.36 → 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
@@ -33,7 +34,8 @@ module.exports = function(RED) {
         let liveBuffer = [];                    // Accumulate points since last commit to BUFFER_FILE
         let commitTimer = null;
         let pruneTimer = null;
-        let messageCount = 0;
+        let messageCount = 0;                   // Total messages received
+        let activeBufferCount = 0;              // Messages in current buffer file (resets on rotate)
         let cachedChunkCount = 0;               // Cached count of historical files
         let isInitializing = true;              // Flag: initialization in progress
         let queuedMessages = [];                // Queue messages during initialization
@@ -121,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);
@@ -135,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);
                 }
 
@@ -146,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
@@ -156,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 [];
@@ -249,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
@@ -335,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.
@@ -355,12 +361,13 @@ 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);
                 await fs.promises.rename(BUFFER_FILE, newName);
                 cachedChunkCount++;
+                activeBufferCount = 0;  // Reset active buffer count after rotation
             } catch (err) {
                 // BUFFER_FILE doesn't exist - no data to rotate
             }
@@ -421,9 +428,10 @@ module.exports = function(RED) {
             });
 
             messageCount++;
+            activeBufferCount++;  // Increment count of messages in current buffer file
             
             // Status update (throttled internally to 1s)
-            updateStatus(`${messageCount} msgs, ${cachedChunkCount} chunks, buf: ${liveBuffer.length}`, messageCount === 1);
+            updateStatus(`${messageCount} processed, ${activeBufferCount} active, ${cachedChunkCount} chunks`, messageCount === 1);
 
             if (done) done();
         });

package/nodes/history-collector.js

@@ -106,6 +106,15 @@ module.exports = function(RED) {
             // Set initial status
             utils.setStatusOK(node, "configuration received");
 
+            // Emit event for history-service relay (InfluxDB batch format)
+            const eventName = `bldgblocks:history:${node.historyConfig.id}`;
+            RED.events.emit(eventName, {
+                measurement: escapedMeasurementName,
+                fields: { value: formattedValue },
+                tags: tagsObj,
+                timestamp: timestamp
+            });
+
             // Handle storage type
             if (node.storageType === 'memory') {
                 const contextKey = `history_data_${node.historyConfig.name}`;
@@ -125,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 = {
@@ -135,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;
@@ -146,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,
@@ -157,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/history-service.js

@@ -15,6 +15,18 @@ module.exports = function(RED) {
         // Generate matching event name based on history-config ID
         const eventName = `bldgblocks:history:${node.historyConfig.id}`;
 
+        // Status throttling - prevent rapid status updates from fast-streaming histories
+        let lastRelayedName = null;
+        let statusDirty = false;
+        let statusInterval = null;
+
+        statusInterval = setInterval(() => {
+            if (statusDirty && lastRelayedName) {
+                utils.setStatusChanged(node, `relayed: ${lastRelayedName}`);
+                statusDirty = false;
+            }
+        }, 2000);
+
         // Listen for events from history-collector nodes with this config
         const eventListener = (eventData) => {
             // Guard against invalid event data
@@ -24,17 +36,14 @@ module.exports = function(RED) {
                 return;
             }
 
-            // Create output message with the event data as payload
-            // Preserve topic if it exists in the event data
+            // Send event data directly as payload (already in InfluxDB batch format)
             const msg = { 
-                payload: eventData,
-                topic: eventData.topic
+                payload: eventData
             };
             
             node.send(msg);
-            
-            // Update status
-            utils.setStatusChanged(node, `relayed: ${eventData.seriesName || 'data'}`);
+            lastRelayedName = eventData.measurement || 'data';
+            statusDirty = true;
         };
 
         // Subscribe to events
@@ -42,6 +51,11 @@ module.exports = function(RED) {
         utils.setStatusOK(node, `listening on ${node.historyConfig.name}`);
 
         node.on("close", function(done) {
+            // Clear status interval
+            if (statusInterval) {
+                clearInterval(statusInterval);
+                statusInterval = null;
+            }
             // Unsubscribe from events on close
             RED.events.off(eventName, eventListener);
             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