node-red-contrib-knx-ultimate 6.0.4 → 6.0.5

package/nodes/locales/it/knxUltimateMatterBridge.json

@@ -17,24 +17,25 @@
       "name_placeholder": "es. Luce cucina",
       "invert": "Inverti posizione %"
     },
-  "advanced": {
+    "advanced": {
       "title": "Compatibilità avanzata",
       "help": " Usa queste opzioni solo quando un controller Matter o un attuatore KNX richiede una gestione speciale.",
+      "alexa_dedup_ms": "Finestra anti-duplicati Alexa (ms, 0 = off)",
       "turn_on_behavior": "Comportamento all'accensione",
       "turn_on_ignore_level": "Ignora luminosità inviata subito dopo On",
       "turn_on_forward_all": "Inoltra ogni comando luminosità",
-    "ignore_level_ms": "Ignora luminosità dopo On (ms)",
-    "cover_expose_as_light": "Esponi tapparella come luce dimmerabile (workaround Alexa)",
-    "cover_expose_as_light_help": "Usa questa opzione solo se Alexa non imposta la percentuale della tapparella. La luminosità indica quanto è aperta; gli indirizzi di gruppo KNX non cambiano.",
+      "ignore_level_ms": "Ignora luminosità dopo On (ms)",
+      "cover_swap_open_close": "Scambia Apri / Chiudi tapparella",
+      "cover_slider_debounce": "Debounce slider tapparella (ms, 0 = adattivo)",
       "cover_update_mode": "Aggiornamento stato tapparella",
       "cover_optimistic": "Aggiorna ottimisticamente la posizione Matter",
       "cover_wait_status": "Attendi solo lo stato KNX",
-    "cover_status_timeout": "Timeout stato tapparella (ms)"
-  },
-  "tabs": {
-    "mappings": "Mappature KNX",
-    "advanced": "Opzioni avanzate"
-  },
+      "cover_status_timeout": "Timeout stato tapparella (ms)"
+    },
+    "tabs": {
+      "mappings": "Mappature KNX",
+      "advanced": "Opzioni avanzate"
+    },
     "functions": {
       "fn_onoff_cmd": "GA comando On/Off",
       "fn_onoff_status": "GA stato On/Off",
@@ -48,6 +49,8 @@
       "fn_currenttemp": "GA temperatura attuale",
       "fn_setpoint_cmd": "GA comando setpoint",
       "fn_setpoint_status": "GA stato setpoint",
+      "fn_coolingsetpoint_cmd": "GA comando setpoint raffrescamento",
+      "fn_coolingsetpoint_status": "GA stato setpoint raffrescamento",
       "fn_rgb_cmd": "GA comando colore RGB (DPT 232.600)",
       "fn_rgb_status": "GA stato colore RGB (DPT 232.600)",
       "fn_ct_cmd": "GA comando temperatura colore (Kelvin)",

package/nodes/locales/zh-CN/knxUltimateMatterBridge.html

@@ -28,7 +28,7 @@
 | RGB 彩色灯 | + RGB 颜色命令/状态 GA (DPT 232.600)。Matter 颜色（hue/saturation 或 XY，来自 App 的色轮）与 KNX RGB 三元组相互转换 |
 | 色温灯 | + 色温命令/状态 GA，开尔文 (DPT 7.600) |
 | 窗帘/卷帘 | 上/下 (DPT 1.008)、停止 (DPT 1.017)、位置 % 命令/状态 (DPT 5.001)、可选位置反转 |
-| 温控器（采暖） | 当前温度 GA、设定点命令/状态 GA (DPT 9.001) |
+| 温控器（采暖和/或制冷） | 当前温度 GA、设定点命令/状态 GA (DPT 9.001)。如再配置制冷设定点命令/状态 GA，则同时提供 Cool 模式（双设定点） |
 | 风扇/新风 | 速度 % 命令/状态 GA (DPT 5.001) |
 | 传感器（温度、湿度、光照、人体、门磁） | 各一个状态 GA |
 | 烟雾/CO 报警器 | 烟雾报警状态 GA + 可选 CO 报警状态 GA (DPT 1.005)：手机上的紧急通知 |
@@ -41,7 +41,7 @@
 
 ## 高级兼容性
 
-这些选项只会在适用于所选类型时显示。调光设备可以忽略某些控制器在 `On` 后立即发送的亮度命令。窗帘可以在命令后乐观更新 Matter 位置，并在 KNX 状态 GA 报告真实位置时再修正。
+这些选项只会在适用于所选类型时显示。调光设备可以忽略某些控制器在 `On` 后立即发送的亮度命令。对于窗帘，**交换打开 / 关闭**会同时反转 KNX 二进制命令和百分比方向。**窗帘滑块防抖**会在写入 KNX 前合并快速的中间目标：`0` 使用自适应窗口（首个命令 400 ms，后续命令 150 ms）；`1`–`5000` 使用固定窗口。窗帘还可先乐观更新 Matter 位置，再由 KNX 状态 GA 修正。
 
 ## 节点引脚
 

package/nodes/locales/zh-CN/knxUltimateMatterBridge.json

@@ -17,24 +17,25 @@
       "name_placeholder": "例如 厨房灯",
       "invert": "反转位置 %"
     },
-  "advanced": {
+    "advanced": {
       "title": "高级兼容性",
       "help": " 仅当 Matter 控制器或 KNX 执行器需要特殊处理时使用这些选项。",
+      "alexa_dedup_ms": "Alexa 去重窗口 (毫秒, 0 = 关闭)",
       "turn_on_behavior": "开灯行为",
       "turn_on_ignore_level": "忽略 On 后立即发送的亮度",
       "turn_on_forward_all": "转发每个亮度命令",
-    "ignore_level_ms": "On 后忽略亮度时间 (ms)",
-    "cover_expose_as_light": "将窗帘显示为可调光灯（Alexa 兼容方案）",
-    "cover_expose_as_light_help": "仅当 Alexa 无法设置窗帘百分比时使用。亮度表示窗帘开启程度；KNX 组地址保持不变。",
+      "ignore_level_ms": "On 后忽略亮度时间 (ms)",
+      "cover_swap_open_close": "交换窗帘打开 / 关闭",
+      "cover_slider_debounce": "窗帘滑块防抖（毫秒，0 = 自适应）",
       "cover_update_mode": "窗帘状态更新",
       "cover_optimistic": "乐观更新 Matter 位置",
       "cover_wait_status": "仅等待 KNX 状态",
-    "cover_status_timeout": "窗帘状态超时 (ms)"
-  },
-  "tabs": {
-    "mappings": "KNX 映射",
-    "advanced": "高级选项"
-  },
+      "cover_status_timeout": "窗帘状态超时 (ms)"
+    },
+    "tabs": {
+      "mappings": "KNX 映射",
+      "advanced": "高级选项"
+    },
     "functions": {
       "fn_onoff_cmd": "开/关 命令 GA",
       "fn_onoff_status": "开/关 状态 GA",
@@ -48,6 +49,8 @@
       "fn_currenttemp": "当前温度 GA",
       "fn_setpoint_cmd": "设定点 命令 GA",
       "fn_setpoint_status": "设定点 状态 GA",
+      "fn_coolingsetpoint_cmd": "制冷设定点 命令 GA",
+      "fn_coolingsetpoint_status": "制冷设定点 状态 GA",
       "fn_rgb_cmd": "RGB 颜色命令 GA (DPT 232.600)",
       "fn_rgb_status": "RGB 颜色状态 GA (DPT 232.600)",
       "fn_ct_cmd": "色温命令 GA（开尔文）",

package/nodes/utils/matterBridgeDeviceFactory.mjs

@@ -52,7 +52,7 @@ const BRIDGE_TYPES = {
   contactsensor: { device: ContactSensorDevice, functions: ['contact'], commandFunctions: [] },
   // Custom construction (dedicated server behaviors), handled in createBridgedEndpoint
   windowcovering: { device: null, functions: ['position'], commandFunctions: [] },
-  thermostat: { device: null, functions: ['currenttemp', 'setpoint'], commandFunctions: [] },
+  thermostat: { device: null, functions: ['currenttemp', 'setpoint', 'coolingsetpoint'], commandFunctions: [] },
   rgblight: { device: null, functions: ['onoff', 'level', 'rgb'], commandFunctions: ['onoff', 'level'] },
   colortemperaturelight: { device: null, functions: ['onoff', 'level', 'colortemp'], commandFunctions: ['onoff', 'level'] },
   smokecoalarm: { device: null, functions: ['smoke', 'co'], commandFunctions: [] },
@@ -83,16 +83,8 @@ function knxValueToMatterPatch (def, fn, value) {
       // Matter lift percent100ths: 0 = open, 10000 = closed.
       let percent = Number(value)
       if (Number.isNaN(percent)) return undefined
-      if (def.invertPosition === true) percent = 100 - percent
-      if (def.type === 'windowcovering' && def.coverExposeAsDimmableLight === true) {
-        // Alexa compatibility mode: light brightness represents how open the cover is.
-        // Keep the KNX convention at this boundary and invert only the Matter view.
-        const openness = clamp(100 - percent, 0, 100)
-        return {
-          onOff: { onOff: openness > 0 },
-          levelControl: { currentLevel: clamp(Math.round(openness * 254 / 100), 1, 254) }
-        }
-      }
+      const invert = (def.invertPosition === true) !== (def.coverSwapOpenClose === true)
+      if (invert) percent = 100 - percent
       return { windowCovering: { currentPositionLiftPercent100ths: clamp(Math.round(percent * 100), 0, 10000) } }
     }
     case 'rgb': {
@@ -123,7 +115,12 @@ function knxValueToMatterPatch (def, fn, value) {
     case 'setpoint': {
       const t = Number(value)
       if (Number.isNaN(t)) return undefined
-      return { thermostat: { occupiedHeatingSetpoint: clamp(Math.round(t * 100), 700, 3000) } }
+      return { thermostat: { occupiedHeatingSetpoint: clamp(Math.round(t * 100), 700, 3000) } } // 7-30°C
+    }
+    case 'coolingsetpoint': {
+      const t = Number(value)
+      if (Number.isNaN(t)) return undefined
+      return { thermostat: { occupiedCoolingSetpoint: clamp(Math.round(t * 100), 1600, 3200) } } // 16-32°C
     }
     case 'onoff':
       return { onOff: { onOff: truthy(value) } }
@@ -196,14 +193,25 @@ function knxValueToMatterPatch (def, fn, value) {
   }
 }
 
-// Wires the ColorControl events of an RGB light and coalesces them into a single
-// KNX RGB command. Controllers set the color as hue+saturation OR as X+Y (two separate
-// attribute reports each): a short debounce merges them before computing the RGB value.
-function attachColorTracker (endpoint, def, onCommand) {
+// Builds a ColorControlServer that captures color commands AT THE COMMAND BOUNDARY
+// (like RawOnOffServer/RawLevelControlServer), instead of listening for attribute
+// changes: repeated commands (e.g. "set to red" twice) are still forwarded every time,
+// not just the first. This is possible for color because Matter controllers always
+// change color via cluster COMMANDS (MoveToHue, MoveToSaturation, MoveToHueAndSaturation,
+// MoveToColor) - unlike e.g. Thermostat/FanControl, where absolute values are set via a
+// plain ATTRIBUTE WRITE with no command-level hook to intercept (verified against
+// @matter/node's ThermostatServer/FanControlServer: only relative Move/Step-style
+// commands exist there, not the absolute "set to X" interaction voice assistants use).
+//
+// Controllers set the color as hue+saturation OR as X+Y, sometimes as two separate
+// commands (MoveToHue then MoveToSaturation): a short debounce merges those two into a
+// single KNX RGB command. A combined MoveToHueAndSaturation/MoveToColor command already
+// carries both values, so it flushes immediately with no debounce.
+function createRawColorControlServer (def, onCommand) {
   const tracker = { hue: 0, sat: 0, x: undefined, y: undefined, mode: 0, level: 254, timer: null }
 
   const flush = () => {
-    tracker.timer = null
+    if (tracker.timer !== null) { clearTimeout(tracker.timer); tracker.timer = null }
     try {
       const v01 = clamp((tracker.level === null || tracker.level === undefined ? 254 : Number(tracker.level)) / 254, 0, 1)
       let rgb
@@ -228,48 +236,49 @@ function attachColorTracker (endpoint, def, onCommand) {
     tracker.timer = setTimeout(flush, 250)
   }
 
-  endpoint.events.colorControl.currentHue$Changed.on((value, oldValue, context) => {
-    try {
-      if (value === null || value === undefined) return
-      tracker.hue = Number(value)
-      if (context?.offline === true) return
+  class RawColorControlServer extends ColorControlServer.with('HueSaturation', 'Xy') {
+    async moveToHue (request) {
+      await super.moveToHue(request)
+      tracker.hue = Number(request.hue)
       tracker.mode = 0
       schedule()
-    } catch (error) { /* empty */ }
-  })
-  endpoint.events.colorControl.currentSaturation$Changed.on((value, oldValue, context) => {
-    try {
-      if (value === null || value === undefined) return
-      tracker.sat = Number(value)
-      if (context?.offline === true) return
+    }
+
+    async moveToSaturation (request) {
+      await super.moveToSaturation(request)
+      tracker.sat = Number(request.saturation)
       tracker.mode = 0
       schedule()
-    } catch (error) { /* empty */ }
-  })
-  endpoint.events.colorControl.currentX$Changed.on((value, oldValue, context) => {
-    try {
-      if (value === null || value === undefined) return
-      tracker.x = Number(value)
-      if (context?.offline === true) return
-      tracker.mode = 1
-      schedule()
-    } catch (error) { /* empty */ }
-  })
-  endpoint.events.colorControl.currentY$Changed.on((value, oldValue, context) => {
-    try {
-      if (value === null || value === undefined) return
-      tracker.y = Number(value)
-      if (context?.offline === true) return
+    }
+
+    async moveToHueAndSaturation (request) {
+      await super.moveToHueAndSaturation(request)
+      tracker.hue = Number(request.hue)
+      tracker.sat = Number(request.saturation)
+      tracker.mode = 0
+      flush() // atomic: both values already known, no need to wait for a second command
+    }
+
+    async moveToColor (request) {
+      await super.moveToColor(request)
+      tracker.x = Number(request.colorX)
+      tracker.y = Number(request.colorY)
       tracker.mode = 1
-      schedule()
-    } catch (error) { /* empty */ }
-  })
-  // Track the brightness (for the RGB computation only: the level command has its own GA)
-  endpoint.events.levelControl.currentLevel$Changed.on((value) => {
-    try {
-      if (value !== null && value !== undefined) tracker.level = Number(value)
-    } catch (error) { /* empty */ }
-  })
+      flush()
+    }
+  }
+
+  // Track the brightness (for the RGB computation only: the level command has its own GA).
+  // Passive bookkeeping, not a command to forward raw, so an attribute listener is fine here.
+  const attachLevelTracker = (endpoint) => {
+    endpoint.events.levelControl.currentLevel$Changed.on((value) => {
+      try {
+        if (value !== null && value !== undefined) tracker.level = Number(value)
+      } catch (error) { /* empty */ }
+    })
+  }
+
+  return { RawColorControlServer, attachLevelTracker }
 }
 
 /**
@@ -285,13 +294,18 @@ function createBridgedEndpoint (def, serialPrefix, onCommand) {
   if (typeInfo === undefined) throw new Error(`Unsupported Matter bridge device type: ${def.type}`)
   const name = (def.name || def.type).toString().slice(0, 32)
 
+  const stableSerial = `${serialPrefix}-${def.id}`.slice(0, 32)
   const initialState = {
     id: `knx-${def.id}`.slice(0, 32),
     bridgedDeviceBasicInformation: {
       nodeLabel: name, // This is the name Alexa/Google/Apple show and use
       productName: name,
       productLabel: name,
-      serialNumber: `${serialPrefix}-${def.id}`.slice(0, 32),
+      serialNumber: stableSerial,
+      // Optional but recommended: some controllers (notably Apple Home) use UniqueID,
+      // rather than the endpoint number alone, as the stable cross-reset device identity.
+      // It never changes for a given def.id, matching the endpoint's own persisted 'id'.
+      uniqueId: stableSerial,
       reachable: true
     }
   }
@@ -301,7 +315,7 @@ function createBridgedEndpoint (def, serialPrefix, onCommand) {
   // Although Matter permits an unknown (null) position, some controllers (including
   // Alexa) then expose only Open/Close instead of percentage positioning. Start with
   // a valid position; KNX or flow feedback replaces it as soon as it is available.
-  if (def.type === 'windowcovering' && def.coverExposeAsDimmableLight !== true) {
+  if (def.type === 'windowcovering') {
     initialState.windowCovering = {
       currentPositionLiftPercent100ths: 0,
       targetPositionLiftPercent100ths: 0
@@ -311,17 +325,45 @@ function createBridgedEndpoint (def, serialPrefix, onCommand) {
   let endpoint
 
   // Emit controller commands at the command boundary instead of observing attribute
-  // changes. This makes the node output truly raw: repeated commands (for example
-  // Off while already off) are still forwarded exactly once.
+  // changes. This makes the node output raw: a controller re-sending a command (for
+  // example Off while already off) is still forwarded, unlike attribute-change tracking
+  // which would swallow the no-op.
+  //
+  // The one exception is a DUPLICATE burst from a single request. Just like the
+  // WindowCovering RangeController quirk handled below, Alexa maps lights to its generic
+  // Alexa.PowerController / Alexa.BrightnessController and a single "turn on" / "set to
+  // 50%" voice request can arrive here as up to two IDENTICAL cluster commands (two On, or
+  // moveToLevelWithOnOff + moveToLevel with the same level) instead of one - which made the
+  // node emit duplicate raw msgs, discussions/516. A short leading-edge dedup collapses
+  // that: the FIRST command is forwarded immediately (no added latency, unlike the cover's
+  // trailing debounce - lights must react instantly), and a command identical to the one
+  // just emitted for the same function is dropped only if it lands within the window. Any
+  // change of value (a real On->Off, or a different brightness) always passes through at
+  // once, so this suppresses only the spurious duplicate, never a genuine command.
+  // Configurable per device via the editor's Advanced tab (def.commandDedupMs): 0 disables
+  // it entirely (every command forwarded raw), a missing value uses the 1200ms default.
+  const rawDedupMs = Number(def.commandDedupMs)
+  const COMMAND_DEDUP_MS = Number.isFinite(rawDedupMs) && rawDedupMs >= 0 ? rawDedupMs : 1200
+  const lastEmittedCommand = new Map() // fn -> { value, at }
+  const isDuplicateCommand = (fn, value) => {
+    const now = Date.now()
+    const prev = lastEmittedCommand.get(fn)
+    if (prev !== undefined && prev.value === value && (now - prev.at) < COMMAND_DEDUP_MS) return true
+    lastEmittedCommand.set(fn, { value, at: now })
+    return false
+  }
+
   const RawOnOffBase = def.type === 'onoffplug' ? OnOffServer : OnOffServer.with('Lighting')
   class RawOnOffServer extends RawOnOffBase {
     async on () {
       await super.on()
+      if (isDuplicateCommand('onoff', true)) return
       onCommand({ deviceId: def.id, fn: 'onoff', value: true, matterCommand: { cluster: 'OnOff', command: 'on' } })
     }
 
     async off () {
       await super.off()
+      if (isDuplicateCommand('onoff', false)) return
       onCommand({ deviceId: def.id, fn: 'onoff', value: false, matterCommand: { cluster: 'OnOff', command: 'off' } })
     }
   }
@@ -330,63 +372,75 @@ function createBridgedEndpoint (def, serialPrefix, onCommand) {
     async moveToLevel (request) {
       await super.moveToLevel(request)
       const value = clamp(Math.round(Number(request.level) * 100 / 254), 0, 100)
+      if (isDuplicateCommand('level', value)) return
       onCommand({ deviceId: def.id, fn: 'level', value, matterCommand: { cluster: 'LevelControl', command: 'moveToLevel', request } })
     }
 
     async moveToLevelWithOnOff (request) {
       await super.moveToLevelWithOnOff(request)
       const value = clamp(Math.round(Number(request.level) * 100 / 254), 0, 100)
+      if (isDuplicateCommand('level', value)) return
       onCommand({ deviceId: def.id, fn: 'level', value, matterCommand: { cluster: 'LevelControl', command: 'moveToLevelWithOnOff', request } })
     }
   }
 
-  if (def.type === 'windowcovering' && def.coverExposeAsDimmableLight === true) {
-    const invert = def.invertPosition === true
-    const emitPosition = (matterPosition, command, request) => {
-      let position = clamp(Math.round(matterPosition), 0, 100)
-      if (invert) position = 100 - position
-      onCommand({
-        deviceId: def.id,
-        fn: 'position',
-        value: position,
-        matterCommand: { cluster: command === 'on' || command === 'off' ? 'OnOff' : 'LevelControl', command, request },
-        matterDiagnostic: { handler: 'coverAsDimmableLight', command }
-      })
-    }
-
-    class CoverAsLightOnOffServer extends OnOffServer.with('Lighting') {
-      async on () {
-        await super.on()
-        emitPosition(0, 'on')
-      }
-
-      async off () {
-        await super.off()
-        emitPosition(100, 'off')
-      }
-    }
-
-    class CoverAsLightLevelServer extends LevelControlServer.with('Lighting', 'OnOff') {
-      async moveToLevel (request) {
-        await super.moveToLevel(request)
-        emitPosition(100 - clamp(Number(request.level) * 100 / 254, 0, 100), 'moveToLevel', request)
-      }
-
-      async moveToLevelWithOnOff (request) {
-        await super.moveToLevelWithOnOff(request)
-        emitPosition(100 - clamp(Number(request.level) * 100 / 254, 0, 100), 'moveToLevelWithOnOff', request)
-      }
-    }
-
-    endpoint = new Endpoint(DimmableLightDevice.with(CoverAsLightOnOffServer, CoverAsLightLevelServer, BridgedDeviceBasicInformationServer), initialState)
-    return endpoint
-  }
-
   if (def.type === 'windowcovering') {
     // The WindowCoveringServer requires the movement logic: we forward it to the KNX bus.
     // Position feedback comes back from the KNX status GA, so we do NOT call the default
     // implementation (which would fake the movement by jumping to the target).
-    const invert = def.invertPosition === true
+    // KNX DPT 5.001 already follows Matter's cover convention. `invertPosition`
+    // provides the Home Assistant/Alexa-friendly opposite percentage convention;
+    // swapping Open/Close also reverses percentage commands and reports, symmetrically.
+    const swapOpenClose = def.coverSwapOpenClose === true
+    const invert = (def.invertPosition === true) !== swapOpenClose
+
+    // Alexa DOES support the Matter WindowCovering device type - per Amazon's own docs
+    // (developer.amazon.com/.../supported-matter-device-categories.html, Closure category) -
+    // but maps it to its generic Alexa.RangeController interface, not a dedicated cover
+    // controller (unlike lights, which get Alexa.ColorController, or locks, which get
+    // Alexa.LockController). RangeController's generic "set/adjust range value" directive
+    // model plausibly explains why a single "open/close the blind" voice request can arrive
+    // here as a BURST of several GoToLiftPercentage commands stepping toward the final target,
+    // instead of one UpOrOpen/DownOrClose/GoToLiftPercentage(final) call. Forwarding every
+    // step to KNX makes the physical cover move in jerky stop-start motion. A short debounce -
+    // the same coalescing technique already used for RGB colors elsewhere in this file, and
+    // the fix independently validated in production by a very similar bridge - collapses a
+    // burst into one KNX command using only the LAST target. This adds an imperceptible delay
+    // for a single legitimate command (covers take many seconds to physically travel), and
+    // StopMotion always bypasses it below.
+    // https://github.com/Luligu/matterbridge-hass/issues/196
+    // Match Home Assistant Matter Hub's cover slider handling: the first command in a
+    // sequence waits 400 ms and subsequent rapid updates wait 150 ms. A per-node value
+    // above zero replaces both windows. `movementDebounceMs` remains as a test/backward
+    // compatibility alias for definitions created outside the Node-RED editor.
+    const configuredDebounce = Number(def.coverSliderDebounceMs) > 0
+      ? Number(def.coverSliderDebounceMs)
+      : Number(def.movementDebounceMs) > 0 ? Number(def.movementDebounceMs) : 0
+    const DEBOUNCE_INITIAL_MS = 400
+    const DEBOUNCE_SUBSEQUENT_MS = 150
+    const COMMAND_SEQUENCE_THRESHOLD_MS = 600
+    let lastMovementCommandAt = 0
+    let movementTimer = null
+    let pendingMovementCommand = null
+    const flushMovement = () => {
+      movementTimer = null
+      if (pendingMovementCommand === null) return
+      const command = pendingMovementCommand
+      pendingMovementCommand = null
+      onCommand(command)
+    }
+    const scheduleMovement = (command) => {
+      const now = Date.now()
+      const firstInSequence = now - lastMovementCommandAt > COMMAND_SEQUENCE_THRESHOLD_MS
+      lastMovementCommandAt = now
+      const debounceMs = configuredDebounce > 0
+        ? configuredDebounce
+        : firstInSequence ? DEBOUNCE_INITIAL_MS : DEBOUNCE_SUBSEQUENT_MS
+      pendingMovementCommand = command
+      if (movementTimer !== null) clearTimeout(movementTimer)
+      movementTimer = setTimeout(flushMovement, debounceMs)
+    }
+
     class KnxCoverServer extends WindowCoveringServer.with('Lift', 'PositionAwareLift') {
       async handleMovement (type, reversed, direction, targetPercent100ths) {
         try {
@@ -401,19 +455,38 @@ function createBridgedEndpoint (def, serialPrefix, onCommand) {
               : direction === MovementDirection.Open ? 'Open' : direction === MovementDirection.Close ? 'Close' : 'Unknown',
             targetPercent100ths: targetPercent100ths ?? null
           }
-          if (direction === MovementDirection.DefinedByPosition && targetPercent100ths !== undefined && targetPercent100ths !== null) {
-            let percent = Math.round(Number(targetPercent100ths) / 100)
+          if (targetPercent100ths === undefined || targetPercent100ths === null) return
+          // NOTE: 'direction' is NOT a usable signal here. matter.js's WindowCoveringServer
+          // resolves MovementDirection.DefinedByPosition (the direction goToLiftPercentage()
+          // actually passes) into a concrete Open/Close BEFORE calling handleMovement,
+          // by comparing targetPercent100ths against the current position (see
+          // #prepareMovement in @matter/node's WindowCoveringServer.ts). Since this bridge
+          // always starts with a known (non-null) position, handleMovement never receives
+          // DefinedByPosition in practice - every percentage command looked exactly like a
+          // plain Open/Close command. targetPercent100ths, on the other hand, is always
+          // populated when PositionAwareLift is supported (0/10000 for plain Up/Down too),
+          // so classify on that instead. Credit: till69, github.com/Supergiovane/
+          // node-red-contrib-knx-ultimate/discussions/516#discussioncomment-17633430
+          const target = Number(targetPercent100ths)
+          if (target <= 0 || target >= 10000) {
+            // Full travel: KNX DPT 1.008 (0 = up/open, 1 = down/close). Not affected by
+            // invertPosition, which only rescales the percentage GA convention.
+            const downOrClose = target >= 10000
+            scheduleMovement({ deviceId: def.id, fn: 'updown', value: swapOpenClose ? !downOrClose : downOrClose, matterDiagnostic })
+          } else {
+            let percent = Math.round(target / 100)
             if (invert) percent = 100 - percent
-            onCommand({ deviceId: def.id, fn: 'position', value: clamp(percent, 0, 100), matterDiagnostic })
-          } else if (direction === MovementDirection.Open || direction === MovementDirection.Close) {
-            // KNX DPT 1.008: 0 = up/open, 1 = down/close
-            onCommand({ deviceId: def.id, fn: 'updown', value: direction === MovementDirection.Close, matterDiagnostic })
+            scheduleMovement({ deviceId: def.id, fn: 'position', value: clamp(percent, 0, 100), matterDiagnostic })
           }
         } catch (error) { /* empty */ }
       }
 
       async handleStopMovement () {
         try {
+          // Stop is always immediate: drop any pending debounced movement so a stale queued
+          // command from before the stop cannot fire afterwards.
+          if (movementTimer !== null) { clearTimeout(movementTimer); movementTimer = null }
+          pendingMovementCommand = null
           onCommand({
             deviceId: def.id,
             fn: 'stop',
@@ -429,21 +502,57 @@ function createBridgedEndpoint (def, serialPrefix, onCommand) {
   }
 
   if (def.type === 'thermostat') {
+    // Heating/Cooling capability is auto-detected from which setpoint GA(s) the KNX node
+    // has configured (see knxUltimateMatterBridge.js#getMatterDef). Leaving both flags
+    // unset keeps the original heating-only behavior, so existing flows are unaffected.
+    const hasCooling = def.hasCoolingSetpoint === true
+    const hasHeating = def.hasHeatingSetpoint !== false
+    const features = []
+    if (hasHeating) features.push('Heating')
+    if (hasCooling) features.push('Cooling')
+    if (features.length === 0) features.push('Heating') // never build a thermostat with neither mode
+
     initialState.thermostat = {
       localTemperature: null,
-      occupiedHeatingSetpoint: 2000, // 20°C
-      controlSequenceOfOperation: 2, // HeatingOnly
-      systemMode: 4 // Heat
+      // CoolingOnly=0, HeatingOnly=2, CoolingAndHeating=4 (Matter ControlSequenceOfOperation enum)
+      controlSequenceOfOperation: hasHeating && hasCooling ? 4 : (hasCooling ? 0 : 2),
+      // Cool=3, Heat=4 (Matter SystemMode enum). Dual-mode starts in Heat; the controller can
+      // switch it, same as any physical dual thermostat without an auto/deadband mode.
+      systemMode: hasCooling && !hasHeating ? 3 : 4
+    }
+    if (hasHeating) initialState.thermostat.occupiedHeatingSetpoint = 2000 // 20°C
+    if (hasCooling) initialState.thermostat.occupiedCoolingSetpoint = 2400 // 24°C
+
+    endpoint = new Endpoint(ThermostatDevice.with(ThermostatServer.with(...features), BridgedDeviceBasicInformationServer), initialState)
+
+    // Setpoint changes from a Matter controller. Unlike OnOff/LevelControl/WindowCovering/
+    // ColorControl, an absolute setpoint has no cluster COMMAND to intercept - Thermostat
+    // only exposes SetpointRaiseLower (a *relative* command) and SetActivePresetRequest;
+    // controllers set an absolute target via a plain attribute write. matter.js only fires
+    // $Changing/$Changed when the value actually differs (verified in @matter/node's
+    // Datasource#preCommit), so a duplicate setpoint (same value sent twice) cannot be
+    // forwarded raw here - there is no lower-level hook to capture it at.
+    if (hasHeating) {
+      endpoint.events.thermostat.occupiedHeatingSetpoint$Changed.on((value, oldValue, context) => {
+        try {
+          if (context?.offline === true) return
+          if (value === null || value === undefined) return
+          onCommand({ deviceId: def.id, fn: 'setpoint', value: Math.round(Number(value)) / 100 }) // centi-°C -> °C
+        } catch (error) { /* empty */ }
+      })
     }
-    endpoint = new Endpoint(ThermostatDevice.with(ThermostatServer.with('Heating'), BridgedDeviceBasicInformationServer), initialState)
-    // Setpoint changes from a Matter controller (attribute write or setpointRaiseLower command)
-    endpoint.events.thermostat.occupiedHeatingSetpoint$Changed.on((value, oldValue, context) => {
-      try {
-        if (context?.offline === true) return
-        if (value === null || value === undefined) return
-        onCommand({ deviceId: def.id, fn: 'setpoint', value: Math.round(Number(value)) / 100 }) // centi-°C -> °C
-      } catch (error) { /* empty */ }
-    })
+    if (hasCooling) {
+      endpoint.events.thermostat.occupiedCoolingSetpoint$Changed.on((value, oldValue, context) => {
+        try {
+          if (context?.offline === true) return
+          if (value === null || value === undefined) return
+          onCommand({ deviceId: def.id, fn: 'coolingsetpoint', value: Math.round(Number(value)) / 100 }) // centi-°C -> °C
+        } catch (error) { /* empty */ }
+      })
+    }
+    // NOTE: SystemMode (Heat/Cool/Off/Auto) changes from a controller are accepted by the
+    // cluster but not forwarded to KNX yet: there is no single KNX DPT for HVAC mode that
+    // fits every actuator. Track it via the node's optional input PIN if you need it today.
     return endpoint
   }
 
@@ -460,8 +569,9 @@ function createBridgedEndpoint (def, serialPrefix, onCommand) {
       currentX: Math.round(0.31 * 65536),
       currentY: Math.round(0.33 * 65536)
     }
-    endpoint = new Endpoint(ExtendedColorLightDevice.with(RawOnOffServer, RawLevelControlServer, ColorControlServer.with('HueSaturation', 'Xy'), BridgedDeviceBasicInformationServer), initialState)
-    attachColorTracker(endpoint, def, onCommand)
+    const { RawColorControlServer, attachLevelTracker } = createRawColorControlServer(def, onCommand)
+    endpoint = new Endpoint(ExtendedColorLightDevice.with(RawOnOffServer, RawLevelControlServer, RawColorControlServer, BridgedDeviceBasicInformationServer), initialState)
+    attachLevelTracker(endpoint)
   } else if (def.type === 'colortemperaturelight') {
     initialState.colorControl = {
       colorMode: 2, // ColorTemperatureMireds
@@ -472,14 +582,15 @@ function createBridgedEndpoint (def, serialPrefix, onCommand) {
       startUpColorTemperatureMireds: 250,
       coupleColorTempToLevelMinMireds: 153
     }
-    endpoint = new Endpoint(ColorTemperatureLightDevice.with(RawOnOffServer, RawLevelControlServer, ColorControlServer.with('ColorTemperature'), BridgedDeviceBasicInformationServer), initialState)
-    endpoint.events.colorControl.colorTemperatureMireds$Changed.on((value, oldValue, context) => {
-      try {
-        if (context?.offline === true) return
-        if (value === null || value === undefined || Number(value) <= 0) return
-        onCommand({ deviceId: def.id, fn: 'colortemp', value: Math.round(1000000 / Number(value)) }) // mireds -> Kelvin
-      } catch (error) { /* empty */ }
-    })
+    class RawColorTemperatureServer extends ColorControlServer.with('ColorTemperature') {
+      async moveToColorTemperature (request) {
+        await super.moveToColorTemperature(request)
+        const mireds = Number(request.colorTemperatureMireds)
+        if (Number.isNaN(mireds) || mireds <= 0) return
+        onCommand({ deviceId: def.id, fn: 'colortemp', value: Math.round(1000000 / mireds) }) // mireds -> Kelvin
+      }
+    }
+    endpoint = new Endpoint(ColorTemperatureLightDevice.with(RawOnOffServer, RawLevelControlServer, RawColorTemperatureServer, BridgedDeviceBasicInformationServer), initialState)
   } else if (def.type === 'smokecoalarm') {
     initialState.smokeCoAlarm = {
       expressedState: 0, // Normal
@@ -516,7 +627,10 @@ function createBridgedEndpoint (def, serialPrefix, onCommand) {
       percentCurrent: 0
     }
     endpoint = new Endpoint(FanDevice.with(BridgedDeviceBasicInformationServer), initialState)
-    // Speed changes from the controller (percent write or fan mode change)
+    // Speed changes from the controller (percent write or fan mode change). Like the
+    // Thermostat setpoints above, FanControlServer exposes no command to intercept for
+    // percentSetting (@matter/node's FanControlServer overrides nothing beyond
+    // initialize()) - it is attribute-write only, so this cannot be made "raw" either.
     endpoint.events.fanControl.percentSetting$Changed.on((value, oldValue, context) => {
       try {
         if (context?.offline === true) return