node-red-contrib-knx-ultimate 4.1.34 → 4.2.1

package/CHANGELOG.md

@@ -6,6 +6,18 @@
 
 # CHANGELOG
 
+**Version 4.2.1** - March 2026<br/>
+
+- FIX: **KNX Hue Light** brightness writes are now applied even when the Hue light is OFF, without forcing the light to switch on.<br/>
+- FIX: **KNX Hue Light** grouped light handling: when a `grouped_light` is OFF and receives a brightness write, the node now presets supported member `light` resources first, so the brightness is ready when the group is turned on later.<br/>
+- TEST: extended **KNX Hue Light** coverage for brightness writes on OFF lights and OFF grouped lights.<br/>
+- UPDATE: KNXUltimate engine bumped to 5.4.0<br/>
+
+**Version 4.1.35** - March 2026<br/>
+
+- NEW: **KNX AI** anomalies output now always emits dedicated bus connection events when the KNX gateway connection is lost and when it is restored.<br/>
+- NEW: **KNX AI Web Dashboard** added a bus connection persistence section with a green/red time bar showing connected/disconnected periods over the history window.<br/>
+
 **Version 4.1.34** - March 2026<br/>
 
 - FIX: **KNX Hue Light** grouped light handling: when a `grouped_light` is OFF and receives color / color temperature / gradient commands, the node now presets supported member `light` resources first and only then turns the group ON, so all lamps can inherit the requested state more reliably.<br/>

package/nodes/knxUltimateAI.js

@@ -1106,6 +1106,7 @@ module.exports = function (RED) {
     node.setNodeStatus = ({ fill, shape, text, payload, GA, dpt, devicename }) => {
       try {
         if (node.serverKNX === null) { updateStatus({ fill: 'red', shape: 'dot', text: '[NO GATEWAY SELECTED]' }); return }
+        trackBusConnectionStatus({ text })
         const dDate = new Date()
         const ts = (node.serverKNX && typeof node.serverKNX.formatStatusTimestamp === 'function')
           ? node.serverKNX.formatStatusTimestamp(dDate)
@@ -1139,6 +1140,18 @@ module.exports = function (RED) {
     node._anomalyLifecycle = new Map()
     node._gaRateSeries = new Map()
     node._gaLabelCsvCache = { ref: null, map: {} }
+    node._busConnectionWatchTimer = null
+    node._busConnectionState = (node.serverKNX && typeof node.serverKNX.linkStatus === 'string')
+      ? String(node.serverKNX.linkStatus).toLowerCase()
+      : 'unknown'
+    node._busConnectionHadConnected = node._busConnectionState === 'connected'
+    node._busConnectionPendingRestore = false
+    node._busConnectionTimeline = [{
+      state: node._busConnectionState === 'connected' ? 'connected' : 'disconnected',
+      startedAtMs: nowMs(),
+      endedAtMs: 0
+    }]
+    node._busConnectionWindowSec = 12 * 60 * 60
 
     // Register runtime instance for sidebar visibility
     aiRuntimeNodes.set(node.id, node)
@@ -1509,12 +1522,12 @@ module.exports = function (RED) {
     const buildGARateSeries = ({ now, topGAs = [], patterns = [], anomalyLifecycle = [] } = {}) => {
       pruneGARateSeries(now)
       const candidates = new Set()
-      ;(topGAs || []).forEach(x => { if (x && x.ga) candidates.add(String(x.ga)) })
-      ;(patterns || []).forEach(p => {
-        if (p && p.from) candidates.add(String(p.from))
-        if (p && p.to) candidates.add(String(p.to))
-      })
-      ;(anomalyLifecycle || []).forEach(a => { if (a && a.ga) candidates.add(String(a.ga)) })
+        ; (topGAs || []).forEach(x => { if (x && x.ga) candidates.add(String(x.ga)) })
+        ; (patterns || []).forEach(p => {
+          if (p && p.from) candidates.add(String(p.from))
+          if (p && p.to) candidates.add(String(p.to))
+        })
+        ; (anomalyLifecycle || []).forEach(a => { if (a && a.ga) candidates.add(String(a.ga)) })
 
       if (!candidates.size) {
         const recent = Array.from(node._gaRateSeries.values())
@@ -1651,6 +1664,7 @@ module.exports = function (RED) {
         if (!ga) return
         anomalyByGA[ga] = (anomalyByGA[ga] || 0) + Math.max(1, Number(a && a.count ? a.count : 1))
       })
+      const busConnection = buildBusConnectionSummary(now)
       const graphTelemetry = buildGraphTelemetry({ now, patterns, flowKnownGASet })
       const gaRateSeries = buildGARateSeries({
         now,
@@ -2116,6 +2130,7 @@ module.exports = function (RED) {
         edgeByEvent: graphTelemetry.edgeByEvent,
         hotEdgesDelta: graphTelemetry.hotEdgesDelta,
         flowMapTopology,
+        busConnection,
         anomalyLifecycle,
         gaRateSeries,
         graph: {
@@ -2297,6 +2312,165 @@ module.exports = function (RED) {
       } catch (error) { /* empty */ }
     }
 
+    const appendBusConnectionTimeline = ({ state, atMs }) => {
+      const nextState = state === 'connected' ? 'connected' : 'disconnected'
+      const ts = Number.isFinite(Number(atMs)) && Number(atMs) > 0 ? Number(atMs) : nowMs()
+      const keepMs = Math.max(12 * 60 * 60, Number(node._busConnectionWindowSec || 0)) * 2000
+      if (!Array.isArray(node._busConnectionTimeline) || node._busConnectionTimeline.length === 0) {
+        node._busConnectionTimeline = [{ state: nextState, startedAtMs: ts, endedAtMs: 0 }]
+        return
+      }
+
+      const timeline = node._busConnectionTimeline
+      const lastIdx = timeline.length - 1
+      const last = timeline[lastIdx] || null
+      if (last && last.state === nextState) {
+        if (last.endedAtMs && last.endedAtMs >= ts) last.endedAtMs = 0
+        timeline[lastIdx] = last
+      } else {
+        if (last) {
+          last.endedAtMs = ts
+          timeline[lastIdx] = last
+        }
+        timeline.push({ state: nextState, startedAtMs: ts, endedAtMs: 0 })
+      }
+
+      while (timeline.length > 1) {
+        const first = timeline[0]
+        const firstEnd = Number(first && first.endedAtMs ? first.endedAtMs : 0)
+        if (!firstEnd || (ts - firstEnd) <= keepMs) break
+        timeline.shift()
+      }
+
+      if (timeline.length > 240) {
+        node._busConnectionTimeline = timeline.slice(timeline.length - 240)
+      } else {
+        node._busConnectionTimeline = timeline
+      }
+    }
+
+    const buildBusConnectionSummary = (now) => {
+      const windowSec = Math.max(12 * 60 * 60, Number(node._busConnectionWindowSec || 0))
+      const windowMs = windowSec * 1000
+      const windowStartMs = now - windowMs
+      const timeline = Array.isArray(node._busConnectionTimeline) ? node._busConnectionTimeline : []
+      const segments = []
+      let connectedMs = 0
+      let disconnectedMs = 0
+
+      for (let i = 0; i < timeline.length; i++) {
+        const item = timeline[i] || {}
+        const state = item.state === 'connected' ? 'connected' : 'disconnected'
+        const startedAtMs = Number(item.startedAtMs || 0)
+        const endedAtMs = Number(item.endedAtMs || 0) > 0 ? Number(item.endedAtMs) : now
+        if (!Number.isFinite(startedAtMs) || startedAtMs <= 0) continue
+        const effectiveStartMs = Math.max(startedAtMs, windowStartMs)
+        const effectiveEndMs = Math.min(endedAtMs, now)
+        if (effectiveEndMs <= effectiveStartMs) continue
+        const durationMs = effectiveEndMs - effectiveStartMs
+        if (state === 'connected') connectedMs += durationMs
+        else disconnectedMs += durationMs
+        segments.push({
+          state,
+          startedAt: new Date(effectiveStartMs).toISOString(),
+          endedAt: new Date(effectiveEndMs).toISOString(),
+          durationSec: roundTo(durationMs / 1000, 1),
+          ratioStart: roundTo((effectiveStartMs - windowStartMs) / windowMs, 4),
+          ratioWidth: roundTo(durationMs / windowMs, 4),
+          active: Number(item.endedAtMs || 0) <= 0
+        })
+      }
+
+      const knownMs = connectedMs + disconnectedMs
+      return {
+        currentState: node._busConnectionState === 'connected' ? 'connected' : 'disconnected',
+        windowSec,
+        windowStartAt: new Date(windowStartMs).toISOString(),
+        windowEndAt: new Date(now).toISOString(),
+        connectedSec: roundTo(connectedMs / 1000, 1),
+        disconnectedSec: roundTo(disconnectedMs / 1000, 1),
+        connectedPct: roundTo((connectedMs / windowMs) * 100, 2),
+        disconnectedPct: roundTo((disconnectedMs / windowMs) * 100, 2),
+        knownCoveragePct: roundTo((knownMs / windowMs) * 100, 2),
+        segments
+      }
+    }
+
+    const emitBusConnectionEvent = ({ type, previousState, currentState, statusText }) => {
+      const payload = {
+        type,
+        event: currentState,
+        previousState: previousState || 'unknown',
+        currentState,
+        gatewayId: node.serverKNX ? node.serverKNX.id : '',
+        gatewayName: (node.serverKNX && node.serverKNX.name) ? node.serverKNX.name : '',
+        statusText: String(statusText || '').trim(),
+        at: new Date().toISOString()
+      }
+      recordAnomaly(payload)
+      node.send([null, {
+        topic: node.outputtopic,
+        payload,
+        knxAi: {
+          type: 'anomaly',
+          event: type,
+          gatewayId: payload.gatewayId,
+          gatewayName: payload.gatewayName
+        }
+      }, null])
+    }
+
+    const trackBusConnectionStatus = ({ text }) => {
+      const statusText = String(text || '').trim()
+      let nextState = ''
+      if (/^Connected\./i.test(statusText)) nextState = 'connected'
+      if (/^Disconnected\b/i.test(statusText)) nextState = 'disconnected'
+      if (nextState === '') return
+      applyBusConnectionStateChange({ nextState, statusText })
+    }
+
+    const applyBusConnectionStateChange = ({ nextState, statusText }) => {
+      const previousState = node._busConnectionState || 'unknown'
+      if (previousState === nextState) return
+      node._busConnectionState = nextState
+      appendBusConnectionTimeline({ state: nextState, atMs: nowMs() })
+
+      if (nextState === 'connected') {
+        if (node._busConnectionPendingRestore) {
+          emitBusConnectionEvent({
+            type: 'bus_connection_restored',
+            previousState,
+            currentState: nextState,
+            statusText
+          })
+          node._busConnectionPendingRestore = false
+        }
+        node._busConnectionHadConnected = true
+        return
+      }
+
+      if (node._busConnectionHadConnected) {
+        emitBusConnectionEvent({
+          type: 'bus_connection_lost',
+          previousState,
+          currentState: nextState,
+          statusText
+        })
+        node._busConnectionPendingRestore = true
+      }
+    }
+
+    const pollBusConnectionStatus = () => {
+      try {
+        const raw = String((node.serverKNX && node.serverKNX.linkStatus) ? node.serverKNX.linkStatus : '').trim().toLowerCase()
+        if (raw !== 'connected' && raw !== 'disconnected') return
+        applyBusConnectionStateChange({
+          nextState: raw,
+          statusText: `Polled gateway state: ${raw}`
+        })
+      } catch (error) { /* ignore */ }
+    }
+
     const maybeEmitOverallAnomaly = (now) => {
       const windowMs = Math.max(2, node.rateWindowSec) * 1000
       const cutoff = now - windowMs
@@ -2419,6 +2593,11 @@ module.exports = function (RED) {
           node._transitionRecent = []
           node._anomalyLifecycle = new Map()
           node._gaRateSeries = new Map()
+          node._busConnectionTimeline = [{
+            state: node._busConnectionState === 'connected' ? 'connected' : 'disconnected',
+            startedAtMs: nowMs(),
+            endedAtMs: 0
+          }]
           node._lastSummary = null
           node._lastSummaryAt = 0
           if (node._summaryRebuildTimer) {
@@ -2543,6 +2722,7 @@ module.exports = function (RED) {
     node.on('close', function (done) {
       try {
         if (node._timerEmit) clearInterval(node._timerEmit)
+        if (node._busConnectionWatchTimer) clearInterval(node._busConnectionWatchTimer)
         if (node._summaryRebuildTimer) {
           clearTimeout(node._summaryRebuildTimer)
           node._summaryRebuildTimer = null
@@ -2568,6 +2748,12 @@ module.exports = function (RED) {
       }, Math.max(5, node.emitIntervalSec) * 1000)
     }
 
+    if (node._busConnectionWatchTimer) clearInterval(node._busConnectionWatchTimer)
+    node._busConnectionWatchTimer = setInterval(() => {
+      pollBusConnectionStatus()
+    }, 1000)
+    pollBusConnectionStatus()
+
     updateStatus({ fill: 'grey', shape: 'dot', text: 'AI ready' })
   }
 

package/nodes/knxUltimateHueLight.js

@@ -160,7 +160,7 @@ module.exports = function (RED) {
       const defaultOperation = node.isGrouped_light === false ? "setLight" : "setGroupedLight";
       const isGroupedLightOff = node.isGrouped_light === true && node.currentHUEDevice?.on?.on === false;
       const stateKeys = _state && typeof _state === "object" ? Object.keys(_state) : [];
-      const presetKeys = ["color", "color_temperature", "gradient"];
+      const presetKeys = ["dimming", "color", "color_temperature", "gradient"];
       const actionableKeys = ["dimming", ...presetKeys];
       const hasActionablePayload = stateKeys.some((key) => actionableKeys.includes(key));
       const mustPresetGroupedLightChildren = isGroupedLightOff
@@ -534,14 +534,12 @@ module.exports = function (RED) {
               break;
             case config.GALightBrightness:
               msg.payload = dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(config.dptLightBrightness));
+              if (typeof msg.payload !== "number" || Number.isNaN(msg.payload)) throw new Error("Invalid KNX brightness payload");
               state = { dimming: { brightness: msg.payload } };
-              if (node.currentHUEDevice === undefined) {
-                // Grouped light
-                state.on = { on: msg.payload > 0 };
-              } else {
-                // Light
-                if (node.currentHUEDevice.on.on === false && msg.payload > 0) state.on = { on: true };
-                if (node.currentHUEDevice.on.on === true && msg.payload === 0) state.on = { on: false };
+              if (msg.payload === 0) {
+                state.on = { on: false };
+              } else if (node.currentHUEDevice !== undefined && node.currentHUEDevice.on?.on === true) {
+                state.on = { on: true };
               }
               node.syncCurrentHUEDeviceFromKNXState(state); // Starting from v 4.1.31
               node.writeHueState(state);

package/nodes/plugins/knxUltimateAI-web-page.html

@@ -196,6 +196,10 @@
             background: var(--knx-ai-soft);
         }
 
+        .panel-wide {
+            grid-column: 1 / -1;
+        }
+
         #summary {
             margin: 0;
             padding: 12px;
@@ -243,6 +247,131 @@
             font-size: 12px;
         }
 
+        #bus-connection {
+            padding: 12px;
+            background: #ffffff;
+        }
+
+        .bus-conn-empty {
+            min-height: 96px;
+            display: flex;
+            align-items: center;
+            color: var(--muted);
+            font-size: 13px;
+            font-weight: 600;
+        }
+
+        .bus-conn-header {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            gap: 10px;
+            flex-wrap: wrap;
+            margin-bottom: 10px;
+        }
+
+        .bus-conn-title {
+            font-size: 13px;
+            font-weight: 800;
+            color: #38315d;
+        }
+
+        .bus-conn-badges {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 6px;
+        }
+
+        .bus-conn-pill {
+            display: inline-flex;
+            align-items: center;
+            gap: 5px;
+            padding: 4px 8px;
+            border-radius: 999px;
+            border: 1px solid var(--line);
+            background: #f7f4ff;
+            color: #463e6d;
+            font-size: 11px;
+            font-weight: 800;
+            letter-spacing: .01em;
+        }
+
+        .bus-conn-pill-connected {
+            background: var(--ok-bg);
+            border-color: var(--ok-border);
+            color: #2e7d46;
+        }
+
+        .bus-conn-pill-disconnected {
+            background: var(--err-bg);
+            border-color: var(--err-border);
+            color: #b13d46;
+        }
+
+        .bus-conn-pill-muted {
+            background: #f7f4ff;
+            border-color: #d7cffa;
+            color: #655f80;
+        }
+
+        .bus-conn-track {
+            position: relative;
+            height: 18px;
+            border-radius: 999px;
+            overflow: hidden;
+            border: 1px solid #ddd7f2;
+            background: linear-gradient(180deg, #f6f3ff 0%, #efebfb 100%);
+        }
+
+        .bus-conn-track::after {
+            content: "";
+            position: absolute;
+            inset: 0;
+            border-radius: inherit;
+            box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.8);
+            pointer-events: none;
+        }
+
+        .bus-conn-segment {
+            position: absolute;
+            top: 0;
+            bottom: 0;
+            min-width: 2px;
+        }
+
+        .bus-conn-segment-connected {
+            background: linear-gradient(90deg, #4ad06d 0%, #38c45f 100%);
+        }
+
+        .bus-conn-segment-disconnected {
+            background: linear-gradient(90deg, #eb6a74 0%, #d94b55 100%);
+        }
+
+        .bus-conn-scale {
+            display: grid;
+            grid-template-columns: 1fr 1fr 1fr;
+            gap: 8px;
+            margin-top: 8px;
+            color: var(--muted);
+            font-size: 12px;
+            font-weight: 700;
+        }
+
+        .bus-conn-scale span:nth-child(2) {
+            text-align: center;
+        }
+
+        .bus-conn-scale span:nth-child(3) {
+            text-align: right;
+        }
+
+        .bus-conn-note {
+            margin-top: 9px;
+            color: #6a6386;
+            font-size: 12px;
+            line-height: 1.35;
+        }
+
         #chat-wrap {
             margin: 10px;
             border: 1px solid var(--line);
@@ -525,17 +654,36 @@
 
         #flow-wrap {
             position: relative;
-            min-height: 420px;
+            min-height: 280px;
+            height: 420px;
+            max-height: 1400px;
             padding: 12px;
             background: #ffffff;
+            overflow: auto;
+            resize: vertical;
         }
 
         #flow-svg {
             width: 100%;
+            min-height: 420px;
             height: 420px;
             display: block;
         }
 
+        .flow-resize-tip {
+            margin-left: auto;
+            color: #766f95;
+            font-size: 11px;
+            font-weight: 700;
+        }
+
+        @media (max-width: 900px) {
+            .flow-resize-tip {
+                width: 100%;
+                margin-left: 0;
+            }
+        }
+
         .viz-empty {
             position: absolute;
             inset: 0;
@@ -1049,6 +1197,8 @@
                         </label>
                         <button type="button" id="flow-clear-ga">Clear</button>
                         <button type="button" id="flow-reset-layout">Reset Layout</button>
+                        <button type="button" id="flow-reset-size">Reset Height</button>
+                        <span class="flow-resize-tip">Resize from the bottom-right corner</span>
                     </div>
                     <div class="flow-legend" id="flow-color-legend">
                         <span class="flow-legend-item"><span
@@ -1129,6 +1279,10 @@
                 <h3>Anomalies</h3>
                 <div id="anomalies"></div>
             </div>
+            <div class="panel panel-wide">
+                <h3>Bus Connection Persistence</h3>
+                <div id="bus-connection"></div>
+            </div>
         </div>
         <div class="panel" id="ask-panel">
             <h3>Ask</h3>
@@ -1178,6 +1332,7 @@
             const $themeBtns = Array.from(document.querySelectorAll('.knx-ai-theme-btn'));
             const $summary = document.getElementById('summary');
             const $anomalies = document.getElementById('anomalies');
+            const $busConnection = document.getElementById('bus-connection');
             const $flowSvg = document.getElementById('flow-svg');
             const $flowWrap = document.getElementById('flow-wrap');
             const $flowEmpty = document.getElementById('flow-empty');
@@ -1187,6 +1342,7 @@
             const $flowGaSelect = document.getElementById('flow-ga-select');
             const $flowClearGa = document.getElementById('flow-clear-ga');
             const $flowResetLayout = document.getElementById('flow-reset-layout');
+            const $flowResetSize = document.getElementById('flow-reset-size');
             const $eventPieSvg = document.getElementById('event-pie-svg');
             const $eventPieLegend = document.getElementById('event-pie-legend');
             const $anomalyPieSvg = document.getElementById('anomaly-pie-svg');
@@ -1205,16 +1361,19 @@
             let stateRequestInFlight = false;
             let lastDashboardRawData = null;
             let resizeHandle = null;
+            let flowResizeObserver = null;
             const flowFilterKey = 'knxUltimateAI:flowMapFilters';
             let flowEdgeCache = new Map();
             let flowNodeCache = new Map();
 
             // Normalize persisted filter payloads to a safe, bounded shape.
             const parseFlowFilters = (raw) => {
-                const defaults = { maxGa: 14, selectedGa: [], gaOrder: [], layoutOrder: [], edgeOrder: [] };
+                const defaults = { maxGa: 14, selectedGa: [], gaOrder: [], layoutOrder: [], edgeOrder: [], flowHeight: 420 };
                 if (!raw || typeof raw !== 'object') return defaults;
                 const maxGaNum = Number(raw.maxGa);
                 const maxGa = Number.isFinite(maxGaNum) ? Math.max(4, Math.min(60, Math.round(maxGaNum))) : defaults.maxGa;
+                const flowHeightNum = Number(raw.flowHeight);
+                const flowHeight = Number.isFinite(flowHeightNum) ? Math.max(280, Math.min(1400, Math.round(flowHeightNum))) : defaults.flowHeight;
                 const selectedGa = Array.isArray(raw.selectedGa)
                     ? Array.from(new Set(raw.selectedGa.map(x => String(x || '').trim()).filter(Boolean))).slice(0, 200)
                     : [];
@@ -1227,7 +1386,7 @@
                 const edgeOrder = Array.isArray(raw.edgeOrder)
                     ? Array.from(new Set(raw.edgeOrder.map(x => String(x || '').trim()).filter(Boolean))).slice(0, 4000)
                     : [];
-                return { maxGa, selectedGa, gaOrder, layoutOrder, edgeOrder };
+                return { maxGa, selectedGa, gaOrder, layoutOrder, edgeOrder, flowHeight };
             };
 
             // Read flow filter settings from local storage.
@@ -1252,6 +1411,23 @@
 
             let flowFilters = loadFlowFilters();
 
+            const applyFlowWrapHeight = () => {
+                if (!$flowWrap) return;
+                const desiredHeight = Number(flowFilters && flowFilters.flowHeight ? flowFilters.flowHeight : 420);
+                const nextHeight = Number.isFinite(desiredHeight) ? Math.max(280, Math.min(1400, Math.round(desiredHeight))) : 420;
+                $flowWrap.style.height = `${nextHeight}px`;
+            };
+
+            const storeFlowWrapHeight = () => {
+                if (!$flowWrap) return;
+                const measuredHeight = Math.round(Number($flowWrap.clientHeight || 0));
+                if (!Number.isFinite(measuredHeight) || measuredHeight <= 0) return;
+                const nextHeight = Math.max(280, Math.min(1400, measuredHeight));
+                if (Number(flowFilters.flowHeight || 0) === nextHeight) return;
+                flowFilters.flowHeight = nextHeight;
+                saveFlowFilters(flowFilters);
+            };
+
             // Restore the last selected KNX AI node.
             const loadStoredNode = () => {
                 try {
@@ -1727,6 +1903,10 @@
                 const win = (s.meta && s.meta.analysisWindowSec) ? s.meta.analysisWindowSec : '';
                 lines.push('Analysis window: ' + win + 's');
                 lines.push('Telegrams: ' + (c.telegrams || 0) + ' | Rate: ' + (c.overallRatePerSec || 0) + '/s | Echoed: ' + (c.echoed || 0) + ' | Repeat: ' + (c.repeated || 0) + ' | Unknown DPT: ' + (c.unknownDpt || 0));
+                if (s.busConnection && typeof s.busConnection === 'object') {
+                    const bus = s.busConnection;
+                    lines.push('Bus connection: ' + String(bus.currentState || 'unknown') + ' | Connected: ' + Number(bus.connectedPct || 0) + '% | Disconnected: ' + Number(bus.disconnectedPct || 0) + '% over last ' + formatDurationCompact(bus.windowSec || 0));
+                }
 
                 if (Array.isArray(s.topGAs) && s.topGAs.length) {
                     lines.push('');
@@ -1755,6 +1935,122 @@
                 return lines.join('\n');
             };
 
+            const clamp01 = (value) => {
+                const n = Number(value);
+                if (!Number.isFinite(n)) return 0;
+                if (n <= 0) return 0;
+                if (n >= 1) return 1;
+                return n;
+            };
+
+            const formatClockLabel = (value) => {
+                const ts = Number(value);
+                if (!Number.isFinite(ts) || ts <= 0) return '--:--';
+                const date = new Date(ts);
+                if (Number.isNaN(date.getTime())) return '--:--';
+                return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+            };
+
+            const formatDurationCompact = (seconds) => {
+                const totalSec = Math.max(0, Math.round(Number(seconds) || 0));
+                const days = Math.floor(totalSec / 86400);
+                const hours = Math.floor((totalSec % 86400) / 3600);
+                const mins = Math.floor((totalSec % 3600) / 60);
+                const secs = totalSec % 60;
+                const parts = [];
+                if (days > 0) parts.push(days + 'd');
+                if (hours > 0) parts.push(hours + 'h');
+                if (mins > 0) parts.push(mins + 'm');
+                if (secs > 0 || parts.length === 0) parts.push(secs + 's');
+                return parts.slice(0, 2).join(' ');
+            };
+
+            const renderBusConnection = (data) => {
+                $busConnection.innerHTML = '';
+                const summary = data && data.summary ? data.summary : {};
+                const bus = summary && summary.busConnection && typeof summary.busConnection === 'object'
+                    ? summary.busConnection
+                    : null;
+
+                if (!bus || !Array.isArray(bus.segments) || bus.segments.length === 0) {
+                    const empty = document.createElement('div');
+                    empty.className = 'bus-conn-empty';
+                    empty.textContent = 'Waiting for connection persistence data...';
+                    $busConnection.appendChild(empty);
+                    return;
+                }
+
+                const windowStartMs = new Date(String(bus.windowStartAt || '')).getTime();
+                const windowEndMs = new Date(String(bus.windowEndAt || '')).getTime();
+                const windowMs = Math.max(1, windowEndMs - windowStartMs);
+                const midMs = windowStartMs + Math.round(windowMs / 2);
+
+                const header = document.createElement('div');
+                header.className = 'bus-conn-header';
+
+                const title = document.createElement('div');
+                title.className = 'bus-conn-title';
+                title.textContent = 'Last ' + formatDurationCompact(bus.windowSec || 0) + ' of KNX bus availability';
+                header.appendChild(title);
+
+                const badges = document.createElement('div');
+                badges.className = 'bus-conn-badges';
+
+                const makePill = (label, value, cls) => {
+                    const pill = document.createElement('span');
+                    pill.className = 'bus-conn-pill ' + cls;
+                    pill.textContent = label + ': ' + value;
+                    return pill;
+                };
+
+                badges.appendChild(makePill('Current', String(bus.currentState || 'unknown'), bus.currentState === 'connected' ? 'bus-conn-pill-connected' : 'bus-conn-pill-disconnected'));
+                badges.appendChild(makePill('Connected', formatDurationCompact(bus.connectedSec || 0), 'bus-conn-pill-connected'));
+                badges.appendChild(makePill('Disconnected', formatDurationCompact(bus.disconnectedSec || 0), 'bus-conn-pill-disconnected'));
+                badges.appendChild(makePill('Coverage', Number(bus.knownCoveragePct || 0) + '%', 'bus-conn-pill-muted'));
+                header.appendChild(badges);
+                $busConnection.appendChild(header);
+
+                const track = document.createElement('div');
+                track.className = 'bus-conn-track';
+
+                bus.segments.forEach((segment) => {
+                    const startRatio = clamp01(segment && segment.ratioStart);
+                    const widthRatio = clamp01(segment && segment.ratioWidth);
+                    if (widthRatio <= 0) return;
+                    const bar = document.createElement('div');
+                    bar.className = 'bus-conn-segment ' + (segment && segment.state === 'connected'
+                        ? 'bus-conn-segment-connected'
+                        : 'bus-conn-segment-disconnected');
+                    bar.style.left = (startRatio * 100).toFixed(3) + '%';
+                    bar.style.width = Math.max(widthRatio * 100, 0.4).toFixed(3) + '%';
+                    bar.title = (segment.state === 'connected' ? 'Connected' : 'Disconnected')
+                        + ' | ' + formatClockLabel(new Date(String(segment.startedAt || '')).getTime())
+                        + ' -> ' + formatClockLabel(new Date(String(segment.endedAt || '')).getTime())
+                        + ' | ' + formatDurationCompact(segment.durationSec || 0);
+                    track.appendChild(bar);
+                });
+
+                $busConnection.appendChild(track);
+
+                const scale = document.createElement('div');
+                scale.className = 'bus-conn-scale';
+                const left = document.createElement('span');
+                left.textContent = formatClockLabel(windowStartMs);
+                const mid = document.createElement('span');
+                mid.textContent = formatClockLabel(midMs);
+                const right = document.createElement('span');
+                right.textContent = 'Now';
+                scale.appendChild(left);
+                scale.appendChild(mid);
+                scale.appendChild(right);
+                $busConnection.appendChild(scale);
+
+                const note = document.createElement('div');
+                note.className = 'bus-conn-note';
+                note.textContent = 'Green shows time connected to the KNX bus. Red shows downtime inside the selected history window.';
+                $busConnection.appendChild(note);
+            };
+
             const buildAnalysisActivityContext = (rawData, dashboardData) => {
                 const summary = rawData && rawData.summary ? rawData.summary : {};
                 const telemetryWindowSec = Number(
@@ -3041,7 +3337,6 @@
                 const height = Math.max(baseHeight, requiredHeight);
                 $flowSvg.setAttribute('viewBox', '0 0 ' + width + ' ' + height);
                 $flowSvg.style.height = `${height}px`;
-                if ($flowWrap) $flowWrap.style.minHeight = `${height + 24}px`;
                 const usableW = Math.max(40, width - (padX * 2));
                 const usableH = Math.max(40, height - (padY * 2));
                 const stepX = cols > 1 ? (usableW / (cols - 1)) : 0;
@@ -3317,6 +3612,7 @@
                 const dashboard = buildDashboardData(data || {});
                 const activityContext = buildAnalysisActivityContext(data || {}, dashboard);
                 updateFlowGaOptions(dashboard.nodes || []);
+                renderBusConnection(data || {});
                 const flowGraph = applyFlowFilters(dashboard);
                 renderFlowMap(flowGraph);
                 renderPie($eventPieSvg, $eventPieLegend, dashboard.eventEntries, 'Event');
@@ -3449,8 +3745,10 @@
 
             // Hard reset for Flow Map: clear all local caches/ordering and rebuild from fresh backend data.
             const resetFlowMapHard = async () => {
-                flowFilters = parseFlowFilters(null);
+                const preservedHeight = Number(flowFilters && flowFilters.flowHeight ? flowFilters.flowHeight : 420);
+                flowFilters = parseFlowFilters({ flowHeight: preservedHeight });
                 saveFlowFilters(flowFilters);
+                applyFlowWrapHeight();
                 flowEdgeCache = new Map();
                 flowNodeCache = new Map();
                 lastDashboardRawData = null;
@@ -3539,6 +3837,21 @@
                     }
                 });
             }
+            if ($flowResetSize) {
+                $flowResetSize.addEventListener('click', () => {
+                    flowFilters.flowHeight = 420;
+                    saveFlowFilters(flowFilters);
+                    applyFlowWrapHeight();
+                    storeFlowWrapHeight();
+                    if (lastDashboardRawData) renderDashboard(lastDashboardRawData);
+                });
+            }
+            if ($flowWrap && typeof window.ResizeObserver === 'function') {
+                flowResizeObserver = new window.ResizeObserver(() => {
+                    storeFlowWrapHeight();
+                });
+                flowResizeObserver.observe($flowWrap);
+            }
             if ($chatPresetBtns.length) {
                 $chatPresetBtns.forEach((btn) => {
                     btn.addEventListener('click', () => {
@@ -3559,6 +3872,7 @@
 
             // Bootstrap page state and start background polling.
             applyTheme(currentTheme, { rerender: false });
+            applyFlowWrapHeight();
             $auto.checked = loadAuto();
             fetchNodes(queryNodeId || loadStoredNode())
                 .then(() => resetFlowMapHard())

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=20.18.1"
   },
-  "version": "4.1.34",
+  "version": "4.2.1",
   "description": "Control your KNX and KNX Secure intallation via Node-Red! A bunch of KNX nodes, with integrated Philips HUE control, ETS group address importer, and KNX routing between interfaces. Easy to use and highly configurable.",
   "files": [
     "nodes/",
@@ -18,7 +18,7 @@
   "dependencies": {
     "dns-sync": "0.2.1",
     "js-yaml": "4.1.1",
-    "knxultimate": "5.2.11",
+    "knxultimate": "5.4.0",
     "lodash": "4.17.21",
     "node-color-log": "12.0.1",
     "ping": "0.4.4",
@@ -104,4 +104,4 @@
     "mocha": "^10.4.0",
     "marked": "^14.1.0"
   }
-}
+}