node-red-contrib-knx-ultimate 6.0.10 → 6.0.11

package/CHANGELOG.md

@@ -6,6 +6,12 @@
 
 # CHANGELOG
 
+**Version 6.0.11** - July 2026<br/>
+
+- **Matter Bridge — editor tab orientation**: the device editor now uses the same left-hand vertical tab layout as Matter Controller, keeping Mappings and Advanced options visually consistent without changing saved configuration.<br/>
+- **Control Matter from KNX — dedicated controller profiles**: Window Covering (`0x0102`), Thermostat (`0x0201`), Fan Control (`0x0202`) and Switch (`0x003B`) endpoints are now selected into explicit capability-driven profiles instead of the anonymous mapped fallback. They share the guarded mapping lifecycle while enforcing their native input/event cluster boundary and presenting semantic canvas status; Switch initial/long/multi-press events are filtered to the selected endpoint and exposed on the optional flow output. Simple actuators and sensors remain on the generic mapped profile.<br/>
+- **Control Matter from KNX — flow attribute reads and persistent Door Lock status**: mapped endpoints now use an unambiguous top-level flow contract: `msg.clusterId` plus `msg.attribute` reads an attribute, `msg.value` makes it an attribute write, and `msg.command` plus `msg.args` invokes a command. Reads return the value in `msg.payload`, may force a remote request with `msg.requestFromRemote = true`, and accept numeric attribute ID `0`. Door Lock nodes now retain their last `locked`/`unlocked` canvas status when generic Matter or KNX notifications arrive.<br/>
+
 **Version 6.0.10** - July 2026<br/>
 
 - **Matter nodes — crash containment**: asynchronous bridge state updates, controller client callbacks, engine errors, startup/watchdog timers and the controller command queue are now guarded so rejected promises and EventEmitter errors are reported instead of becoming uncaught exceptions or unhandled rejections capable of stopping Node-RED.<br/>

package/nodes/knxUltimateMatterBridge.html

@@ -109,8 +109,71 @@
         try { RED.sidebar.show('help'); } catch (error) { /* empty */ }
         const node = this;
 
-        // Use the same jQuery UI tab structure as the main KNXUltimate node.
-        $('#mb-tabs').tabs();
+        // Keep the same left-hand vertical tab orientation as Matter Controller.
+        if ($('#knxUltimateMatterControllerDeviceVerticalTabs').length === 0) {
+          $('head').append(`
+            <style id="knxUltimateMatterControllerDeviceVerticalTabs">
+              .hue-vertical-tabs.ui-tabs.ui-widget.ui-widget-content.ui-corner-all {
+                display: flex;
+                border: none;
+                padding: 0;
+              }
+              .hue-vertical-tabs > ul.ui-tabs-nav {
+                flex: 0 0 180px;
+                border-right: 1px solid #ccc;
+                border-left: none;
+                border-top: none;
+                border-bottom: none;
+                padding: 0.5em 0.3em;
+              }
+              .hue-vertical-tabs > ul.ui-tabs-nav li {
+                float: none;
+                width: 100%;
+                margin: 0 0 2px 0;
+              }
+              .hue-vertical-tabs > ul.ui-tabs-nav li a {
+                display: block;
+                width: 100%;
+                white-space: normal;
+                position: relative;
+                border-bottom: none !important;
+              }
+              .hue-vertical-tabs > ul.ui-tabs-nav li.ui-tabs-active {
+                border-bottom: none !important;
+              }
+              .hue-vertical-tabs > ul.ui-tabs-nav li.ui-tabs-active a::after {
+                content: "";
+                position: absolute;
+                left: 0;
+                bottom: 0;
+                width: 50%;
+                height: 3px;
+                background: currentColor;
+              }
+              .hue-vertical-tabs .ui-tabs-panel {
+                flex: 1;
+                padding: 0.8em 1em;
+                box-sizing: border-box;
+                border: none;
+                background: transparent;
+              }
+              .hue-vertical-tabs .form-row > dt {
+                flex: 1 1 auto;
+                margin: 0;
+              }
+              .hue-vertical-tabs hr {
+                width: 100%;
+                border: 0;
+                border-top: 1px solid #ccc;
+                margin: 8px 0;
+              }
+            </style>`);
+        }
+        const $tabs = $('#mb-tabs');
+        $tabs.addClass('hue-vertical-tabs');
+        $tabs.tabs();
+        $tabs.find('ul').addClass('ui-tabs-nav');
+        $tabs.find('li').removeClass('ui-corner-top').addClass('ui-corner-left');
 
         // Resolves the KNX gateway at query time: the selected one, or - as a
         // fallback - the first knxUltimate-config available, so the GA list works
@@ -441,6 +504,8 @@ Exposes **one KNX device as a Matter device**. This node is in **BETA**.
 
 Point it to a **Matter Bridge** configuration node (the actual bridge, paired once by Alexa/Google Home/Apple Home), pick the device type, give it the name the assistant will use, and fill the group addresses.
 
+The **Mappings** and **Advanced** tabs are arranged vertically on the left, matching the Matter Controller editor.
+
 - **Matter → KNX**: commands from the voice assistant write to the *command* group addresses.
 - **KNX → Matter**: telegrams on the *status* group addresses update the Matter attribute (and the app UI).
 

package/nodes/knxUltimateMatterControllerDevice.html

@@ -554,6 +554,11 @@
             }
             const isMatterLight = deviceTypes.some((type) => /(?:onoff|dimmable|colortemperature|extendedcolor)light/.test(type));
             if (!isMatterLight) {
+              const specializedProfile = getMatterCluster(ep, 258) ? 'windowCovering'
+                : getMatterCluster(ep, 513) ? 'thermostat'
+                  : getMatterCluster(ep, 514) ? 'fan'
+                    : getMatterCluster(ep, 59) ? 'switch'
+                      : 'mapped';
               const mappedTargets = [];
               const addCommand = (clusterId, target, label, dpt) => {
                 const cluster = getMatterCluster(ep, clusterId);
@@ -584,7 +589,7 @@
               addAttribute(47, 'batPercentRemaining', 'battery', '5.001', false);
               addAttribute(144, 'activePower', 'active_power', '14.056', false);
               addAttribute(145, 'cumulativeEnergyImported', 'imported_energy', '13.013', false);
-              return { known: true, profile: 'mapped', deviceTypeDisplay, onOff: false, level: false, colorTemperature: false, color: false, mappedTargets };
+              return { known: true, profile: specializedProfile, deviceTypeDisplay, onOff: false, level: false, colorTemperature: false, color: false, mappedTargets };
             }
             const hasColorTemperatureType = /colortemperature|extendedcolor/.test(typeText);
             const hasColorType = /extendedcolor/.test(typeText);
@@ -995,7 +1000,7 @@
             const supportsColor = hasHueDevice && caps.color === true;
             const hasRichBehaviour = supportsDim && (supportsTemperature || supportsColor);
             const isDoorLock = caps.profile === 'doorLock';
-            const isMapped = caps.profile === 'mapped';
+            const isMapped = ['mapped', 'windowCovering', 'thermostat', 'fan', 'switch'].includes(caps.profile);
             const deviceTypeDisplay = String(caps.deviceTypeDisplay || '').trim();
 
             setMatterTabVisible('tabs-1', supportsSwitch);
@@ -2150,7 +2155,9 @@
 
 The editor detects the selected endpoint capabilities and exposes only the corresponding
 Matter functions. Bridged Matter devices are expanded into their individual endpoints in
-the device picker.
+the device picker. Door Lock, Window Covering, Thermostat, Fan and Switch endpoints use
+dedicated profiles. Switch press, long-press and multi-press events are emitted on the
+optional flow output; simpler endpoints continue through the generic mapped fallback.
 
 |Property|Description|
 |--|--|
@@ -2235,6 +2242,7 @@ _Basic Matter effects_
 | Read status at startup | Read the Matter endpoint status at Node-RED startup or full deploy and send it to the KNX bus. |
 | KNX Brightness Status | Updates the KNX brightness status whenever the Matter light switches ON/OFF. It can send 0% while OFF and restore the previous value when ON, or leave the brightness status unchanged. |
 | Update local cached Matter state from KNX bus writes | When enabled, KNX writes immediately update the local Matter-state cache without waiting for the endpoint report. Disable it if the cache should follow only real Matter reports. |
+| Node Input/Output PINs | For mapped endpoints, all Matter selectors belong directly to `msg`. Read an attribute with `msg.clusterId` and `msg.attribute`; add `msg.requestFromRemote = true` to force a device read instead of using the subscribed value. The result is emitted as `msg.payload`. Add `msg.value` to write an attribute, or use `msg.clusterId`, `msg.command` and `msg.args` to invoke a command. Attribute IDs such as `0` are accepted. Door Lock input accepts `msg.payload = true` to lock and `false` to unlock. |
 | Switch on behaviour | It sets the behaviour of your lights when switched on. You can choose from differents behaviours.<br/> **Select color: ** the light will be switched on with the color of your choice. To change color, just CLICK on the color selector (under the _Select color_ control).<br/>**Select temperature and brightness: ** the light will be switched on with the temperature (Kelvin) and brightness (0-100) of your choice.<br/>**None:** the light will retain its last status. In case you've enable the night lighting, after the night time ends, the lamp will resume the color/temperature/brightness state set at day time. |
 | Night Lighting | It allows to set a particular light color/brightness at nighttime. The options are the same as the daytime. You could select either a temperature/brightness or color. A cozy temperature of 2700 Kelvin, with a brightness of 10% or 20%, is a good choice for bathroom's night light.|
 | Day/Night | Select the group address used to set the day/night behaviour. The group address value is _true_ if daytime, _false_ if nighttime. |

package/nodes/utils/matterControllerProfiles/doorLock.js

@@ -52,6 +52,7 @@ const setupDoorLockProfile = (RED, node, config) => {
   node.inputRBE = 'false'
   node.passthrough = 'no'
   node.currentLockState = undefined
+  node.matterConnectionStatus = ''
   node.knxUltimateAcceptedGAs = [config.GALightSwitch, config.GALightState]
     .map((ga) => String(ga || '').trim())
     .filter((ga) => ga !== '')
@@ -60,7 +61,15 @@ const setupDoorLockProfile = (RED, node, config) => {
   // knxUltimate-config invokes this synchronously from addClient(). Profiles return
   // early from the main light constructor, so they must expose the callback before
   // registering with the shared KNX configuration node.
-  node.setNodeStatus = ({ fill = 'grey', shape = 'ring', text = '' } = {}) => setStatus(fill, shape, text)
+  node.setNodeStatus = ({ fill = 'grey', shape = 'ring', text = '' } = {}) => {
+    if (node.currentLockState !== undefined) {
+      const state = lockStateToBoolean(node.currentLockState)
+      const knxText = text ? ` | KNX: ${text}` : ''
+      setStatus(state === undefined ? 'yellow' : 'blue', state === undefined ? 'ring' : 'dot', `Matter: ${lockStateName(node.currentLockState)}${knxText}`)
+      return
+    }
+    setStatus(fill, shape, text)
+  }
 
   const commandArgs = () => {
     // Matter represents the remote credential as bytes. Keep the PIN in Node-RED's
@@ -181,7 +190,15 @@ const setupDoorLockProfile = (RED, node, config) => {
     }
   }
   node.setNodeStatusMatter = (status) => {
-    if (status && status.text) setStatus(status.fill || 'grey', status.shape || 'ring', status.text)
+    if (!status || !status.text) return
+    node.matterConnectionStatus = status.text
+    const isAvailable = /^(connected|ready|controller ready)$/i.test(status.text)
+    if (isAvailable && node.currentLockState !== undefined) {
+      const state = lockStateToBoolean(node.currentLockState)
+      setStatus(state === undefined ? 'yellow' : 'blue', state === undefined ? 'ring' : 'dot', `Matter: ${lockStateName(node.currentLockState)}`)
+      return
+    }
+    setStatus(status.fill || 'grey', status.shape || 'ring', status.text)
   }
 
   if (node.serverKNX) {

package/nodes/utils/matterControllerProfiles/fan.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { setupMappedEndpointProfile } = require('./mappedEndpoint')
+
+const FAN_CONTROL_CLUSTER_ID = 0x0202
+
+const setupFanProfile = (RED, node, config) => setupMappedEndpointProfile(RED, node, config, {
+  profileName: 'fan',
+  inputClusterId: FAN_CONTROL_CLUSTER_ID,
+  eventClusterId: FAN_CONTROL_CLUSTER_ID,
+  formatAttributeStatus: (event) => {
+    if (['percentCurrent', 'percentSetting'].includes(event.attributeName) && event.value !== null && event.value !== undefined) {
+      return `Matter fan: ${Math.round(Number(event.value))}%`
+    }
+    if (event.attributeName === 'fanMode') return `Matter fan mode: ${event.value}`
+    return ''
+  }
+})
+
+module.exports = { FAN_CONTROL_CLUSTER_ID, setupFanProfile }

package/nodes/utils/matterControllerProfiles/index.js

@@ -2,12 +2,20 @@
 
 const { setupDoorLockProfile } = require('./doorLock')
 const { setupMappedEndpointProfile } = require('./mappedEndpoint')
+const { setupWindowCoveringProfile } = require('./windowCovering')
+const { setupThermostatProfile } = require('./thermostat')
+const { setupFanProfile } = require('./fan')
+const { setupSwitchProfile } = require('./switch')
 
 // Controller-side Matter device profiles live behind this registry.  Keep profile
 // selection capability-driven: the editor records the profile only after inspecting
 // the endpoint's actual device types, clusters, attributes and supported commands.
 const PROFILE_SETUPS = Object.freeze({
   doorLock: setupDoorLockProfile,
+  windowCovering: setupWindowCoveringProfile,
+  thermostat: setupThermostatProfile,
+  fan: setupFanProfile,
+  switch: setupSwitchProfile,
   mapped: setupMappedEndpointProfile
 })
 

package/nodes/utils/matterControllerProfiles/mappedEndpoint.js

@@ -24,7 +24,7 @@ const parseMappings = (value) => {
   }
 }
 
-const setupMappedEndpointProfile = (RED, node, config) => {
+const setupMappedEndpointProfile = (RED, node, config, options = {}) => {
   node.name = config.name || node.matterDeviceName || 'Control Matter from KNX'
   node.topic = node.name
   node.mappings = parseMappings(config.matterMappings)
@@ -40,6 +40,7 @@ const setupMappedEndpointProfile = (RED, node, config) => {
   node.outputRBE = 'false'
   node.inputRBE = 'false'
   node.passthrough = 'no'
+  node.matterProfile = options.profileName || 'mapped'
   const enablePins = config.enableNodePINS === 'yes'
   let lastInitialReadTs = 0
 
@@ -111,7 +112,8 @@ const setupMappedEndpointProfile = (RED, node, config) => {
         sendKnx(mapping, matterToKnx(event.clusterId, event.attributeName, event.value))
       })
       if (enablePins) node.send({ topic: `${event.clusterId}.${event.attributeName}`, payload: event.value, matter: event })
-      status('blue', 'dot', `Matter→KNX: ${event.attributeName}`)
+      const profileStatus = typeof options.formatAttributeStatus === 'function' ? options.formatAttributeStatus(event) : ''
+      status('blue', 'dot', profileStatus || `Matter→KNX: ${event.attributeName}`)
     } catch (error) {
       RED.log.error(`knxUltimateMatterControllerDevice mapped Matter: ${error.message}`)
       status('red', 'ring', error.message)
@@ -120,8 +122,11 @@ const setupMappedEndpointProfile = (RED, node, config) => {
   node.handleMatterClusterEvent = (event) => {
     // Cluster events have no implicit KNX mapping. They are exposed as raw flow output
     // only when the user explicitly enables the node pins.
-    if (enablePins && String(event?.nodeId) === String(node.matterNodeId) && Number(event?.endpointId) === Number(node.matterEndpointId)) {
+    const clusterAccepted = options.eventClusterId === undefined || Number(event?.clusterId) === Number(options.eventClusterId)
+    if (enablePins && clusterAccepted && String(event?.nodeId) === String(node.matterNodeId) && Number(event?.endpointId) === Number(node.matterEndpointId)) {
       node.send({ topic: `${event.clusterId}.${event.eventName}`, payload: event.events, matter: event })
+      const profileStatus = typeof options.formatEventStatus === 'function' ? options.formatEventStatus(event) : ''
+      if (profileStatus) status('blue', 'dot', profileStatus)
     }
   }
   node.handleMatterNodeInitialized = () => {
@@ -137,20 +142,53 @@ const setupMappedEndpointProfile = (RED, node, config) => {
   if (node.serverKNX) { node.serverKNX.removeClient(node); node.serverKNX.addClient(node) } else status('yellow', 'ring', 'No KNX gateway selected')
   if (node.serverMatter) { node.serverMatter.removeClient(node); node.serverMatter.addClient(node) }
   node.on('input', (msg, send, done) => {
-    try {
-      const payload = msg.payload || {}
+    const complete = typeof done === 'function' ? done : () => {}
+    const output = typeof send === 'function' ? send : node.send.bind(node)
+    Promise.resolve().then(async () => {
       const mapping = {
-        endpointId: payload.endpointId ?? node.matterEndpointId,
-        clusterId: payload.clusterId,
-        targetKind: payload.command !== undefined ? 'command' : 'attribute',
-        target: payload.command ?? payload.attribute
+        endpointId: msg.endpointId ?? node.matterEndpointId,
+        clusterId: msg.clusterId,
+        targetKind: msg.command !== undefined ? 'command' : 'attribute',
+        target: msg.command ?? msg.attribute
       }
-      if (!mapping.target || mapping.clusterId === undefined) throw new Error('Matter input requires clusterId and command or attribute')
-      enqueue(mapping, payload.args ?? payload.value)
-      if (done) done()
-    } catch (error) {
-      if (done) done(error); else node.error(error, msg)
-    }
+      if (mapping.target === undefined || mapping.target === null || mapping.target === '' || mapping.clusterId === undefined || mapping.clusterId === null) {
+        throw new Error('Matter input requires clusterId and command or attribute')
+      }
+      if (options.inputClusterId !== undefined && Number(mapping.clusterId) !== Number(options.inputClusterId)) {
+        throw new Error(`${node.matterProfile} input requires clusterId ${options.inputClusterId}`)
+      }
+      const isAttributeRead = mapping.targetKind === 'attribute' && msg.value === undefined
+      if (isAttributeRead) {
+        const currentManager = manager()
+        if (!currentManager) throw new Error('Matter controller not ready')
+        const value = await currentManager.readAttribute(
+          node.matterNodeId,
+          mapping.endpointId,
+          mapping.clusterId,
+          mapping.target,
+          msg.requestFromRemote === true
+        )
+        output({
+          ...msg,
+          payload: value,
+          matter: {
+            source: 'inputRead',
+            nodeId: node.matterNodeId,
+            endpointId: mapping.endpointId,
+            clusterId: mapping.clusterId,
+            attribute: mapping.target
+          }
+        })
+        status('blue', 'dot', `Matter read: ${mapping.target}`)
+        complete()
+        return
+      }
+      enqueue(mapping, mapping.targetKind === 'command' ? msg.args : msg.value)
+      complete()
+    }).catch((error) => {
+      status('red', 'ring', error.message)
+      if (typeof done === 'function') done(error); else node.error(error, msg)
+    })
   })
   node.on('close', (done) => {
     try { if (node.serverKNX) node.serverKNX.removeClient(node) } catch (error) { /* empty */ }

package/nodes/utils/matterControllerProfiles/switch.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const { setupMappedEndpointProfile } = require('./mappedEndpoint')
+
+const SWITCH_CLUSTER_ID = 0x003b
+
+const setupSwitchProfile = (RED, node, config) => setupMappedEndpointProfile(RED, node, config, {
+  profileName: 'switch',
+  inputClusterId: SWITCH_CLUSTER_ID,
+  eventClusterId: SWITCH_CLUSTER_ID,
+  formatEventStatus: (event) => `Matter switch: ${event.eventName}`
+})
+
+module.exports = { SWITCH_CLUSTER_ID, setupSwitchProfile }

package/nodes/utils/matterControllerProfiles/thermostat.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { setupMappedEndpointProfile } = require('./mappedEndpoint')
+
+const THERMOSTAT_CLUSTER_ID = 0x0201
+
+const setupThermostatProfile = (RED, node, config) => setupMappedEndpointProfile(RED, node, config, {
+  profileName: 'thermostat',
+  inputClusterId: THERMOSTAT_CLUSTER_ID,
+  eventClusterId: THERMOSTAT_CLUSTER_ID,
+  formatAttributeStatus: (event) => {
+    if (['localTemperature', 'occupiedHeatingSetpoint', 'occupiedCoolingSetpoint'].includes(event.attributeName) && event.value !== null && event.value !== undefined) {
+      return `Matter thermostat: ${(Number(event.value) / 100).toFixed(1)} °C`
+    }
+    if (event.attributeName === 'systemMode') return `Matter thermostat mode: ${event.value}`
+    return ''
+  }
+})
+
+module.exports = { THERMOSTAT_CLUSTER_ID, setupThermostatProfile }

package/nodes/utils/matterControllerProfiles/windowCovering.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { setupMappedEndpointProfile } = require('./mappedEndpoint')
+
+const WINDOW_COVERING_CLUSTER_ID = 0x0102
+
+const setupWindowCoveringProfile = (RED, node, config) => setupMappedEndpointProfile(RED, node, config, {
+  profileName: 'windowCovering',
+  inputClusterId: WINDOW_COVERING_CLUSTER_ID,
+  eventClusterId: WINDOW_COVERING_CLUSTER_ID,
+  formatAttributeStatus: (event) => {
+    if (event.attributeName === 'currentPositionLiftPercent100ths' && event.value !== null && event.value !== undefined) {
+      return `Matter cover: ${Math.round(Number(event.value) / 100)}%`
+    }
+    if (event.attributeName === 'operationalStatus') return 'Matter cover: operational status updated'
+    return ''
+  }
+})
+
+module.exports = { WINDOW_COVERING_CLUSTER_ID, setupWindowCoveringProfile }

package/nodes/utils/matterEngine.mjs

@@ -470,6 +470,14 @@ class classMatter extends EventEmitter {
     }
   }
 
+  _findAttribute = (clusterClient, attributeNameOrId) => {
+    if (clusterClient === undefined || attributeNameOrId === undefined || attributeNameOrId === null) return undefined
+    if (typeof attributeNameOrId === 'string' && clusterClient.attributes[attributeNameOrId] !== undefined) {
+      return clusterClient.attributes[attributeNameOrId]
+    }
+    return Object.values(clusterClient.attributes).find((attribute) => Number(attribute?.id) === Number(attributeNameOrId))
+  }
+
   // Returns the full structure of a commissioned node: endpoints, clusters, attributes (with cached values) and commands.
   // Used by the editor UI to let the user pick the mapping targets.
   getNodeStructure = (_nodeIdString) => {
@@ -551,7 +559,7 @@ class classMatter extends EventEmitter {
     if (node === undefined) throw new Error(`Matter node ${_nodeIdString} unknown or not yet connected`)
     const clusterClient = this._findClusterClient(node, _endpointId, _clusterId)
     if (clusterClient === undefined) throw new Error(`Cluster ${_clusterId} not found on endpoint ${_endpointId}`)
-    const attribute = clusterClient.attributes[_attributeName]
+    const attribute = this._findAttribute(clusterClient, _attributeName)
     if (attribute === undefined) throw new Error(`Attribute ${_attributeName} not found in cluster ${clusterClient.name}`)
     return attribute.get(_requestFromRemote)
   }
@@ -563,7 +571,7 @@ class classMatter extends EventEmitter {
       if (node === undefined) return undefined
       const clusterClient = this._findClusterClient(node, _endpointId, _clusterId)
       if (clusterClient === undefined) return undefined
-      const attribute = clusterClient.attributes[_attributeName]
+      const attribute = this._findAttribute(clusterClient, _attributeName)
       if (attribute === undefined) return undefined
       return attribute.getLocal()
     } catch (error) {

package/package.json

@@ -3,8 +3,8 @@
   "engines": {
     "node": ">=20.18.1"
   },
-  "version": "6.0.10",
-  "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, KNX AI for diagnosticsand KNX routing between interfaces. Easy to use and highly configurable.",
+  "version": "6.0.11",
+  "description": "KNX Ultimate is the most advanced KNX integration for Node-RED, providing secure KNX/IP communication, routing, ETS project import, Philips Hue, Matter Controller and Matter Bridge (control matter device via KNX and expose KNX GA via Matter), MQTT, diagnostics with AI, virtual devices, and powerful automation nodes. Build professional, reliable, and scalable smart home and building automation projects with minimal effort.",
   "files": [
     "nodes/",
     "resources/",
@@ -145,4 +145,4 @@
     "vite": "^7.1.3",
     "vue": "^3.5.21"
   }
-}
+}