node-red-contrib-knx-ultimate 7.1.4 → 8.0.2

package/nodes/utils/matterBridgeEngine.mjs

@@ -1,297 +0,0 @@
-/* eslint-disable max-len */
-import { EventEmitter } from 'events'
-
-// Wrapper around a matter.js ServerNode acting as a Matter BRIDGE (Aggregator):
-// external Matter controllers (Alexa, Google Home, Apple Home...) commission it once
-// and see every configured KNX virtual device as a bridged Matter device.
-// Mirrors the contract of matterEngine.mjs: an EventEmitter with
-// 'online', 'offline', 'commissioned', 'decommissioned', 'fabricsChanged' and
-// 'command' ({ deviceId, fn, value }) events.
-class classMatterBridge extends EventEmitter {
-  constructor (_storagePath, _instanceId, _sysLogger, _options = {}) {
-    super()
-    this.storagePath = _storagePath
-    this.instanceId = _instanceId
-    this.sysLogger = _sysLogger
-    this.options = {
-      port: Number(_options.port) || 5540,
-      deviceName: (_options.deviceName || 'KNX-Ultimate Bridge').toString().slice(0, 32)
-    }
-    this.server = null
-    this.aggregator = null
-    this.endpoints = new Map() // deviceId -> Endpoint
-    this.deviceDefs = new Map() // deviceId -> definition
-    this.bridgeStatus = 'stopped' // stopped | running
-    this._api = null
-    this._factory = null
-    this._logThrottle = new Map()
-  }
-
-  _log = (level, message) => {
-    try {
-      const logger = this.sysLogger
-      if (logger && typeof logger[level] === 'function') return logger[level](message)
-      if (logger && typeof logger.log === 'function') return logger.log(message)
-    } catch (error) { /* empty */ }
-    if (level === 'error') console.error(message)
-    else if (level === 'warn') console.warn(message)
-    else console.log(message)
-  }
-
-  _logThrottled = (level, throttleKey, message, intervalMs = 30000) => {
-    const now = Date.now()
-    const entry = this._logThrottle.get(throttleKey) || { last: 0, suppressed: 0 }
-    if (this._logThrottle.size > 1000) this._logThrottle.clear()
-    if (entry.last === 0 || (now - entry.last) >= intervalMs) {
-      const suffix = entry.suppressed > 0 ? ` (suppressed ${entry.suppressed} similar)` : ''
-      entry.last = now
-      entry.suppressed = 0
-      this._logThrottle.set(throttleKey, entry)
-      this._log(level, `${message}${suffix}`)
-      return
-    }
-    entry.suppressed += 1
-    this._logThrottle.set(throttleKey, entry)
-  }
-
-  _loadApi = async () => {
-    if (this._api !== null) return this._api
-    const { Environment, ServerNode, Endpoint, Logger, LogLevel, VendorId } = await import('@matter/main')
-    const { AggregatorEndpoint } = await import('@matter/main/endpoints/aggregator')
-    const { QrCode } = await import('@matter/main/types')
-    this._factory = await import('./matterBridgeDeviceFactory.mjs')
-    this._api = { Environment, ServerNode, Endpoint, Logger, LogLevel, VendorId, AggregatorEndpoint, QrCode }
-    return this._api
-  }
-
-  // Starts the bridge and exposes the given virtual devices.
-  // _deviceDefs: [{ id, type, name }]
-  start = async (_deviceDefs = []) => {
-    const api = await this._loadApi()
-    try {
-      api.Logger.level = api.LogLevel.ERROR
-    } catch (error) { /* empty */ }
-    const { withEnvironmentLock } = await import('./matterEnvironmentLock.mjs')
-    // Environment.default (and its 'storage.path' var) is a process-wide singleton shared
-    // with the Matter Controller engine: serialize the set+create critical section so a
-    // concurrent startup can never observe another engine's storage path mid-flight.
-    this.server = await withEnvironmentLock(async () => {
-      const environment = api.Environment.default
-      environment.vars.set('storage.path', this.storagePath)
-      return api.ServerNode.create({
-        id: this.instanceId,
-        network: { port: this.options.port },
-        productDescription: {
-          name: this.options.deviceName,
-          deviceType: api.AggregatorEndpoint.deviceType
-        },
-        basicInformation: {
-          vendorName: 'KNX-Ultimate',
-          vendorId: api.VendorId(0xFFF1), // Test vendor ID
-          nodeLabel: this.options.deviceName,
-          productName: this.options.deviceName,
-          productLabel: this.options.deviceName,
-          productId: 0x8000,
-          serialNumber: `knxu-${this.instanceId}`.slice(0, 32),
-          uniqueId: this.instanceId.slice(-32)
-        }
-      })
-    })
-
-    this.aggregator = new api.Endpoint(api.AggregatorEndpoint, { id: 'aggregator' })
-    await this.server.add(this.aggregator)
-
-    for (let index = 0; index < _deviceDefs.length; index++) {
-      const def = _deviceDefs[index]
-      try {
-        await this._addDeviceEndpoint(def)
-      } catch (error) {
-        this._log('error', `classMatterBridge: cannot add device "${def?.name}" (${def?.type}): ${error.message}`)
-      }
-    }
-
-    // Commissioning lifecycle events
-    try {
-      this.server.events.commissioning.commissioned.on(() => {
-        try { this.emit('commissioned') } catch (error) { /* empty */ }
-      })
-      this.server.events.commissioning.decommissioned.on(() => {
-        try { this.emit('decommissioned') } catch (error) { /* empty */ }
-      })
-      this.server.events.commissioning.fabricsChanged.on((fabricIndex, action) => {
-        try { this.emit('fabricsChanged', Number(fabricIndex), action) } catch (error) { /* empty */ }
-      })
-    } catch (error) {
-      this._log('warn', `classMatterBridge: cannot hook commissioning events: ${error.message}`)
-    }
-
-    await this.server.start()
-    this.bridgeStatus = 'running'
-    this.emit('online')
-    this._log('info', `classMatterBridge: bridge "${this.options.deviceName}" started on port ${this.options.port} with ${this.endpoints.size} device(s)`)
-  }
-
-  _addDeviceEndpoint = async (def) => {
-    if (!def || !def.id || !def.type) throw new Error('Invalid device definition')
-    const endpoint = this._factory.createBridgedEndpoint(def, `knxu-${this.instanceId.slice(-8)}`, (command) => {
-      try {
-        this.emit('command', command)
-      } catch (error) {
-        this._logThrottled('error', 'bridge:command', `classMatterBridge: command handler error: ${error.message}`)
-      }
-    })
-    await this.aggregator.add(endpoint)
-    this.endpoints.set(def.id, endpoint)
-    this.deviceDefs.set(def.id, def)
-    return endpoint
-  }
-
-  // Removes a bridged device endpoint from the running server.
-  removeDeviceEndpoint = async (_deviceId) => {
-    const endpoint = this.endpoints.get(_deviceId)
-    if (endpoint === undefined) return false
-    try {
-      await endpoint.close()
-    } catch (error) {
-      this._log('warn', `classMatterBridge: removeDeviceEndpoint ${_deviceId}: ${error.message}`)
-    }
-    this.endpoints.delete(_deviceId)
-    this.deviceDefs.delete(_deviceId)
-    return true
-  }
-
-  // Reconciles the exposed devices with a new definition list WITHOUT restarting the server:
-  // paired controllers receive the endpoint changes live (PartsList subscription reports),
-  // while a full restart would resume the session without re-reading the structure.
-  reconcileDevices = async (_deviceDefs = []) => {
-    if (this.server === null) throw new Error('Matter bridge not started')
-    const newById = new Map(_deviceDefs.filter((d) => d && d.id).map((d) => [d.id, d]))
-    // Remove deleted devices; recreate the ones whose type/behavior changed
-    const currentIds = Array.from(this.endpoints.keys())
-    for (let index = 0; index < currentIds.length; index++) {
-      const id = currentIds[index]
-      const newDef = newById.get(id)
-      const oldDef = this.deviceDefs.get(id)
-      const needsRecreate = newDef !== undefined && oldDef !== undefined &&
-        (newDef.type !== oldDef.type ||
-          (newDef.invertPosition === true) !== (oldDef.invertPosition === true) ||
-          (newDef.hasHeatingSetpoint !== false) !== (oldDef.hasHeatingSetpoint !== false) ||
-          (newDef.hasCoolingSetpoint === true) !== (oldDef.hasCoolingSetpoint === true))
-      if (newDef === undefined || needsRecreate) {
-        await this.removeDeviceEndpoint(id)
-      }
-    }
-    // Add new devices and apply renames on the existing ones
-    for (const def of newById.values()) {
-      if (!this.endpoints.has(def.id)) {
-        try {
-          await this._addDeviceEndpoint(def)
-        } catch (error) {
-          this._log('error', `classMatterBridge: reconcile cannot add "${def.name}" (${def.type}): ${error.message}`)
-        }
-      } else {
-        const oldDef = this.deviceDefs.get(def.id)
-        if ((oldDef.name || '') !== (def.name || '')) {
-          const name = (def.name || def.type).toString().slice(0, 32)
-          try {
-            await this.endpoints.get(def.id).set({
-              bridgedDeviceBasicInformation: { nodeLabel: name, productName: name, productLabel: name }
-            })
-          } catch (error) {
-            this._log('warn', `classMatterBridge: reconcile rename ${def.id}: ${error.message}`)
-          }
-        }
-        this.deviceDefs.set(def.id, def)
-      }
-    }
-    this._log('info', `classMatterBridge: devices reconciled, now exposing ${this.endpoints.size} device(s)`)
-  }
-
-  // KNX -> Matter: applies a KNX status value to the Matter attribute of a virtual device.
-  setDeviceState = async (_deviceId, _fn, _knxValue) => {
-    try {
-      const endpoint = this.endpoints.get(_deviceId)
-      const def = this.deviceDefs.get(_deviceId)
-      if (endpoint === undefined || def === undefined) return false
-      const patch = this._factory.knxValueToMatterPatch(def, _fn, _knxValue)
-      if (patch === undefined) return false
-      await endpoint.set(patch)
-      return true
-    } catch (error) {
-      this._logThrottled('warn', `bridge:set:${_deviceId}:${_fn}`, `classMatterBridge: setDeviceState ${_deviceId}/${_fn}: ${error.message}`)
-      return false
-    }
-  }
-
-  // Marks a device as reachable/unreachable on the Matter side
-  setDeviceReachable = async (_deviceId, _reachable) => {
-    try {
-      const endpoint = this.endpoints.get(_deviceId)
-      if (endpoint === undefined) return false
-      await endpoint.set({ bridgedDeviceBasicInformation: { reachable: _reachable === true } })
-      return true
-    } catch (error) {
-      return false
-    }
-  }
-
-  // Pairing info for the editor: QR code (text + ASCII art), manual code, commissioned fabrics.
-  getPairingInfo = () => {
-    if (this.server === null) return { running: false }
-    try {
-      const commissioningState = this.server.state.commissioning
-      const fabrics = []
-      try {
-        Object.values(commissioningState.fabrics || {}).forEach((fabric) => {
-          fabrics.push({
-            label: fabric.label || '',
-            vendorId: Number(fabric.rootVendorId !== undefined ? fabric.rootVendorId : (fabric.vendorId || 0)),
-            fabricIndex: Number(fabric.fabricIndex || 0)
-          })
-        })
-      } catch (error) { /* empty */ }
-      const info = {
-        running: this.bridgeStatus === 'running',
-        commissioned: commissioningState.commissioned === true,
-        fabrics,
-        deviceCount: this.endpoints.size,
-        port: this.options.port
-      }
-      if (commissioningState.commissioned !== true && commissioningState.pairingCodes !== undefined) {
-        info.manualPairingCode = commissioningState.pairingCodes.manualPairingCode
-        info.qrPairingCode = commissioningState.pairingCodes.qrPairingCode
-        try {
-          info.qrAscii = this._api.QrCode.get(commissioningState.pairingCodes.qrPairingCode)
-        } catch (error) { /* empty */ }
-      }
-      return info
-    } catch (error) {
-      this._log('warn', `classMatterBridge: getPairingInfo: ${error.message}`)
-      return { running: this.bridgeStatus === 'running', error: error.message }
-    }
-  }
-
-  // Factory reset: removes all fabrics and commissioning data. The bridge restarts advertising for pairing.
-  factoryReset = async () => {
-    if (this.server === null) throw new Error('Matter bridge not started')
-    await this.server.erase()
-    this.emit('decommissioned')
-  }
-
-  close = async () => {
-    this.bridgeStatus = 'stopped'
-    this._logThrottle.clear()
-    try {
-      if (this.server !== null) await this.server.close()
-    } catch (error) {
-      this._log('warn', `classMatterBridge: close: ${error.message}`)
-    }
-    this.server = null
-    this.aggregator = null
-    this.endpoints.clear()
-    this.deviceDefs.clear()
-    this.emit('offline')
-  }
-}
-
-export { classMatterBridge }

package/nodes/utils/matterControllerCommandGate.js

@@ -1,47 +0,0 @@
-'use strict'
-
-const COMMAND_TIMER_KEYS = [
-  'timerBlink',
-  'timerColorCycle',
-  'timerStepDim',
-  'timerStepDimHSV_H',
-  'timerStepDimHSV_S',
-  'timerStepDimTunableWhite'
-]
-
-const setupMatterControllerCommandGate = (node) => {
-  node.matterCommandBlocked = false
-  node.matterCommandBlockReason = ''
-
-  node.isMatterCommandBlocked = () => node.matterCommandBlocked === true
-
-  node.blockMatterCommands = (reason = 'Matter device unavailable') => {
-    node.matterCommandBlocked = true
-    node.matterCommandBlockReason = String(reason || 'Matter device unavailable')
-    COMMAND_TIMER_KEYS.forEach((key) => {
-      if (node[key] !== undefined && node[key] !== null) clearInterval(node[key])
-      node[key] = undefined
-    })
-    node.status({
-      fill: 'red',
-      shape: 'ring',
-      text: node.matterCommandBlockReason
-    })
-  }
-
-  node.clearMatterCommandBlock = (source = 'editor') => {
-    if (node.matterCommandBlocked !== true) return false
-    node.matterCommandBlocked = false
-    node.matterCommandBlockReason = ''
-    node.status({
-      fill: source === 'connected' ? 'green' : 'yellow',
-      shape: 'ring',
-      text: source === 'connected' ? 'Matter device reconnected' : 'Matter retry enabled'
-    })
-    return true
-  }
-
-  return node
-}
-
-module.exports = { setupMatterControllerCommandGate }

package/nodes/utils/matterControllerProfiles/doorLock.js

@@ -1,258 +0,0 @@
-'use strict'
-
-const dptlib = require('knxultimate').dptlib
-const { semanticPayload } = require('../matterControllerSemanticInput')
-
-const DOOR_LOCK_CLUSTER_ID = 0x0101
-const LOCK_STATE = {
-  NOT_FULLY_LOCKED: 0,
-  LOCKED: 1,
-  UNLOCKED: 2,
-  UNLATCHED: 3
-}
-
-const decodeKnxBoolean = (msg, dpt) => {
-  if (msg && msg.knx && Buffer.isBuffer(msg.knx.rawValue)) {
-    return !!dptlib.fromBuffer(msg.knx.rawValue, dptlib.resolve(dpt || '1.001'))
-  }
-  return !!(msg && msg.payload)
-}
-
-const lockStateName = (value) => {
-  switch (Number(value)) {
-    case LOCK_STATE.LOCKED: return 'locked'
-    case LOCK_STATE.UNLOCKED: return 'unlocked'
-    case LOCK_STATE.NOT_FULLY_LOCKED: return 'notFullyLocked'
-    case LOCK_STATE.UNLATCHED: return 'unlatched'
-    default: return 'unknown'
-  }
-}
-
-const lockStateToBoolean = (value) => {
-  // KNX DPT 1 can represent only two states. Do not collapse transitional or
-  // ambiguous Matter lock states into a potentially unsafe locked/unlocked value.
-  if (Number(value) === LOCK_STATE.LOCKED) return true
-  if (Number(value) === LOCK_STATE.UNLOCKED) return false
-  return undefined
-}
-
-const setupDoorLockProfile = (RED, node, config) => {
-  // Profiles initialize the same flags consumed by knxUltimate-config as ordinary
-  // KNX nodes. In particular, listenallga must remain enabled for handleSend calls.
-  node.name = config.name || node.matterDeviceName || 'Control Matter door lock from KNX'
-  node.topic = node.name
-  node.notifyreadrequest = true
-  node.notifyreadrequestalsorespondtobus = 'false'
-  node.notifyreadrequestalsorespondtobusdefaultvalueifnotinitialized = ''
-  node.notifyresponse = false
-  node.notifywrite = true
-  node.initialread = true
-  node.listenallga = true
-  node.outputtype = 'write'
-  node.outputRBE = 'false'
-  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 !== '')
-
-  const setStatus = (fill, shape, text) => {
-    if (node.matterCommandBlocked === true) return
-    node.status({ fill, shape, text })
-  }
-  // 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 = '' } = {}) => {
-    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
-    // credential store and materialize the Buffer only for the outgoing command.
-    const pin = String(node.credentials?.doorLockPin || '')
-    return pin === '' ? {} : { pinCode: Buffer.from(pin, 'utf8') }
-  }
-
-  const sendFlow = (source, state, rawState) => {
-    if (config.enableNodePINS !== 'yes') return
-    node.send({
-      topic: node.topic,
-      payload: state,
-      matter: {
-        source,
-        nodeId: node.matterNodeId,
-        endpointId: node.matterEndpointId,
-        clusterId: DOOR_LOCK_CLUSTER_ID,
-        lockState: rawState,
-        lockStateName: rawState === undefined ? (state ? 'locked' : 'unlocked') : lockStateName(rawState)
-      }
-    })
-  }
-
-  const writeKnxState = (state, outputtype = 'write') => {
-    const ga = String(config.GALightState || '').trim()
-    if (ga === '' || !node.serverKNX) return
-    node.serverKNX.sendKNXTelegramToKNXEngine({
-      grpaddr: ga,
-      payload: state,
-      dpt: config.dptLightState || '1.001',
-      outputtype,
-      nodecallerid: node.id
-    })
-  }
-
-  const publishMatterState = (rawState, source = 'matter') => {
-    node.currentLockState = Number(rawState)
-    const state = lockStateToBoolean(rawState)
-    const name = lockStateName(rawState)
-    // Attribute reports update KNX state only; they never enqueue a Matter command.
-    // This one-way path is the primary feedback-loop guard for Door Lock endpoints.
-    if (state !== undefined) writeKnxState(state)
-    sendFlow(source, state, rawState)
-    setStatus(state === undefined ? 'yellow' : 'blue', state === undefined ? 'ring' : 'dot', `Matter: ${name}`)
-  }
-
-  const queueCommand = (locked, source = 'knx') => {
-    if (node.matterCommandBlocked === true) return false
-    const manager = node.serverMatter?.matterManager
-    if (!manager) throw new Error('Matter controller not ready')
-    const capabilities = (() => {
-      try { return JSON.parse(config.matterDeviceCapabilities || '{}') } catch (error) { return {} }
-    })()
-    // Never invent optional operations: the editor persists the commands actually
-    // advertised by this endpoint and runtime validation enforces that snapshot.
-    if (locked && capabilities.lockDoor === false) throw new Error('The Matter endpoint does not expose lockDoor')
-    if (!locked && capabilities.unlockDoor === false) throw new Error('The Matter endpoint does not expose unlockDoor')
-    const queued = manager.writeMatterQueueAdd({
-      nodeId: node.matterNodeId,
-      endpointId: node.matterEndpointId,
-      clusterId: DOOR_LOCK_CLUSTER_ID,
-      kind: 'command',
-      name: locked ? 'lockDoor' : 'unlockDoor',
-      args: commandArgs()
-    })
-    if (queued && typeof queued.catch === 'function') {
-      queued.catch((error) => {
-        RED.log.error(`knxUltimateMatterControllerDevice DoorLock command: ${error.message}`)
-        setStatus('red', 'ring', error.message)
-      })
-    }
-    sendFlow(source, locked)
-    setStatus('green', 'dot', `KNX→Matter: ${locked ? 'lock' : 'unlock'}`)
-    return true
-  }
-
-  node.handleSend = (msg) => {
-    try {
-      if (!msg?.knx || !node.knxUltimateAcceptedGAs.includes(String(msg.knx.destination || '').trim())) return
-      if (node.matterCommandBlocked === true) return
-      if (msg.knx.event === 'GroupValue_Read') {
-        if (String(msg.knx.destination) === String(config.GALightState)) {
-          const state = lockStateToBoolean(node.currentLockState)
-          if (state !== undefined) writeKnxState(state, 'response')
-        }
-        return
-      }
-      if (String(msg.knx.destination) !== String(config.GALightSwitch)) return
-      queueCommand(decodeKnxBoolean(msg, config.dptLightSwitch), 'knx')
-    } catch (error) {
-      RED.log.error(`knxUltimateMatterControllerDevice DoorLock KNX: ${error.message}`)
-      setStatus('red', 'ring', error.message)
-    }
-  }
-
-  node.handleSendMatter = (event) => {
-    try {
-      if (String(event?.nodeId) !== String(node.matterNodeId)) return
-      if (Number(event?.endpointId) !== Number(node.matterEndpointId)) return
-      if (Number(event?.clusterId) !== DOOR_LOCK_CLUSTER_ID || event.attributeName !== 'lockState') return
-      publishMatterState(event.value)
-    } catch (error) {
-      RED.log.error(`knxUltimateMatterControllerDevice DoorLock Matter: ${error.message}`)
-    }
-  }
-  node.handleMatterClusterEvent = () => {}
-  node.handleMatterNodeInitialized = () => {
-    try {
-      // The controller engine already caches the initial attribute read. Reusing that
-      // value avoids an extra request and publishes startup state through the same path.
-      const value = node.serverMatter?.matterManager?.getCachedAttribute(
-        node.matterNodeId,
-        node.matterEndpointId,
-        DOOR_LOCK_CLUSTER_ID,
-        'lockState'
-      )
-      if (value !== undefined && value !== null) publishMatterState(value, 'initial')
-    } catch (error) {
-      RED.log.error(`knxUltimateMatterControllerDevice DoorLock initial state: ${error.message}`)
-    }
-  }
-  node.setNodeStatusMatter = (status) => {
-    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) {
-    node.serverKNX.removeClient(node)
-    node.serverKNX.addClient(node)
-  } else {
-    setStatus('yellow', 'ring', 'No KNX gateway selected')
-  }
-  if (node.serverMatter) {
-    node.serverMatter.removeClient(node)
-    node.serverMatter.addClient(node)
-  }
-
-  node.on('input', (msg, send, done) => {
-    try {
-      if (node.matterCommandBlocked === true) throw new Error(node.matterCommandBlockReason || 'Matter device unavailable')
-      const semantic = semanticPayload(msg)
-      let value
-      if (semantic) {
-        if (!['lock', 'locked'].includes(semantic.functionName)) throw new Error(`Unsupported Matter function "${semantic.functionName}". Supported: lock`)
-        value = semantic.value
-      } else {
-        value = typeof msg.payload === 'object' && msg.payload !== null && msg.payload.locked !== undefined
-          ? msg.payload.locked
-          : msg.payload
-      }
-      if (typeof value !== 'boolean') throw new Error('Door Lock input requires msg.payload boolean or { locked: boolean }')
-      queueCommand(value, 'flow')
-      if (done) done()
-    } catch (error) {
-      setStatus('red', 'ring', error.message)
-      if (done) done(error)
-      else node.error(error, msg)
-    }
-  })
-
-  node.on('close', (done) => {
-    try { if (node.serverKNX) node.serverKNX.removeClient(node) } catch (error) { /* empty */ }
-    try { if (node.serverMatter) node.serverMatter.removeClient(node) } catch (error) { /* empty */ }
-    done()
-  })
-}
-
-module.exports = {
-  DOOR_LOCK_CLUSTER_ID,
-  LOCK_STATE,
-  lockStateName,
-  lockStateToBoolean,
-  setupDoorLockProfile
-}

package/nodes/utils/matterControllerProfiles/fan.js

@@ -1,19 +0,0 @@
-'use strict'
-
-const { setupMappedEndpointProfile } = require('./mappedEndpoint')
-
-const FAN_CONTROL_CLUSTER_ID = 0x0202
-
-const setupFanProfile = (RED, node, config) => setupMappedEndpointProfile(RED, node, config, {
-  profileName: 'fan',
-  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

@@ -1,34 +0,0 @@
-'use strict'
-
-const { setupDoorLockProfile } = require('./doorLock')
-const { setupMappedEndpointProfile } = require('./mappedEndpoint')
-const { setupWindowCoveringProfile } = require('./windowCovering')
-const { setupThermostatProfile } = require('./thermostat')
-const { setupFanProfile } = require('./fan')
-const { setupSwitchProfile } = require('./switch')
-const { setupUniversalProfile } = require('./universal')
-
-// 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,
-  universal: setupUniversalProfile
-})
-
-const setupMatterControllerProfile = (profile, RED, node, config) => {
-  const setup = PROFILE_SETUPS[profile]
-  // Returning false is significant: the caller must continue through the unchanged
-  // Matter-light implementation when no specialized profile claims the endpoint.
-  if (typeof setup !== 'function') return false
-  // A profile that returns successfully owns input, close, KNX and Matter handlers.
-  setup(RED, node, config)
-  return true
-}
-
-module.exports = { PROFILE_SETUPS, setupMatterControllerProfile }