homebridge-tuya-plus 3.14.0-dev.5 → 3.14.0-dev.52

package/lib/IrrigationSystemAccessory.js

@@ -4,8 +4,8 @@ const BaseAccessory = require('./BaseAccessory');
  * IrrigationSystemAccessory
  *
  * A fully-fledged HomeKit irrigation controller for Tuya multi-valve devices
- * (e.g. the 4-zone faucet/valve timers that expose `switch_1..switch_n`, a
- * `battery_percentage` and a `rain_sensor_state`).
+ * (e.g. the 4-zone faucet/valve timers that expose `switch_1..switch_n` and a
+ * `battery_percentage`).
  *
  * HomeKit modelling (one bridged accessory, category SPRINKLER):
  *
@@ -13,8 +13,9 @@ const BaseAccessory = require('./BaseAccessory');
  *     ├─ Valve  "Zone A"   (linked, ValveType=IRRIGATION, ServiceLabelIndex 1)
  *     ├─ Valve  "Zone B"   (linked, ServiceLabelIndex 2)
  *     ├─ ...
+ *   ServiceLabel       (labels the multi-valve collection so the Home app nests
+ *                       the zones under the system tile; added when >1 valve)
  *   Battery            (BatteryLevel + StatusLowBattery)
- *   ContactSensor      (rain — or LeakSensor, configurable)
  *
  * Each Valve carries its own SetDuration/RemainingDuration so the Home app shows
  * the familiar per-zone "Duration" picker and a live countdown. A zone whose
@@ -23,6 +24,30 @@ const BaseAccessory = require('./BaseAccessory');
  * command (the device is a laggy, battery-powered Wi-Fi unit), so turning the
  * whole system on/off — or running a scene that toggles several zones at once —
  * results in one network round-trip rather than a burst of them.
+ *
+ * Auto-shutoff is enforced two ways. HomeKit always gets a live software
+ * countdown (RemainingDuration) and a local timer that closes the zone when it
+ * expires. On top of that, when the device exposes Tuya's per-zone countdown
+ * data-points (countdown_1..n, DP 17.. by default), switching a zone ON also
+ * sends the run length (whole minutes, in the SAME command as the switch) to the
+ * device's own countdown, so the valve still closes on schedule even if
+ * Homebridge or the network drops out mid-run. The two mechanisms are
+ * complementary: the software timer drives the UI and the precise (sub-minute)
+ * close while connected; the hardware countdown is the offline safety net.
+ *
+ * IMPORTANT: on these controllers the countdown dp is NOT a passive "duration"
+ * setting — writing it STARTS a run and switches the zone ON. It is therefore
+ * written only together with a switch-on, or to re-base/repair a zone that is
+ * already running; never while a zone is off, on connect, or merely because the
+ * Duration was edited. (An earlier version wrote it on connect to "fix" zones
+ * reading 0 and opened every valve at once — see the regression tests.)
+ *
+ * The countdown is (re)written on EVERY switch-on, in the SAME command as the
+ * switch — we do not rely on the device persisting it (it appears to reset once a
+ * run finishes), so each run carries its own fresh countdown matching the zone's
+ * current Duration (0 = indefinite). A zone opened at the device instead
+ * (physical button / Tuya app) is caught by the change handler, which gives it a
+ * countdown too when it comes up without a usable one.
  */
 class IrrigationSystemAccessory extends BaseAccessory {
     static getCategory(Categories) {
@@ -45,23 +70,25 @@ class IrrigationSystemAccessory extends BaseAccessory {
         // Self-contained (no reliance on instance state) so it is safe to call
         // both during early service reconciliation and later when wiring
         // characteristics.
-        const cloud = this._isCloud();
         const defaultDuration = isFinite(this.device.context.defaultDuration) ? parseInt(this.device.context.defaultDuration) : 600;
 
         if (Array.isArray(this.device.context.valves) && this.device.context.valves.length) {
             return this.device.context.valves.map((valve, i) => {
-                // A data-point may be a numeric LAN id (1, 2, …) or a Tuya Cloud
-                // code (e.g. "switch_1"). Accept either; only an empty value is
-                // invalid.
+                // A data-point may be a numeric id (1, 2, …) or a Tuya code
+                // (e.g. "switch_1"); both resolve over either transport. Only an
+                // empty value is invalid.
                 const dp = (valve && valve.dp !== undefined && valve.dp !== null) ? ('' + valve.dp).trim() : '';
                 if (!dp) {
                     throw new Error(`The valve definition #${i + 1} is missing a 'dp': ${JSON.stringify(valve)}`);
                 }
+                const dpCountdownExplicit = (valve && valve.dpCountdown !== undefined && valve.dpCountdown !== null) ? ('' + valve.dpCountdown).trim() : '';
                 return {
                     dp,
                     name: (('' + (valve.name || '')).trim()) || ('Zone ' + (i + 1)),
                     index: i + 1,
-                    duration: isFinite(valve.defaultDuration) ? parseInt(valve.defaultDuration) : defaultDuration
+                    duration: isFinite(valve.defaultDuration) ? parseInt(valve.defaultDuration) : defaultDuration,
+                    dpCountdown: dpCountdownExplicit || this._defaultCountdownDP(dp),
+                    countdownConfigured: dpCountdownExplicit !== ''
                 };
             });
         }
@@ -70,45 +97,42 @@ class IrrigationSystemAccessory extends BaseAccessory {
         const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
         const configs = [];
         for (let i = 0; i < count; i++) {
+            const dp = String(i + 1);
             configs.push({
-                // Cloud devices address valves by code (switch_1, switch_2, …);
-                // LAN devices by numeric data-point id (1, 2, …).
-                dp: cloud ? ('switch_' + (i + 1)) : String(i + 1),
+                dp,
                 name: 'Valve ' + (letters[i] || (i + 1)),
                 index: i + 1,
-                duration: defaultDuration
+                duration: defaultDuration,
+                dpCountdown: this._defaultCountdownDP(dp),
+                countdownConfigured: false
             });
         }
         return configs;
     }
 
-    // True when this device is reached over the Tuya Cloud (data-points keyed by
-    // string code) rather than the LAN (numeric data-point ids).
-    _isCloud() {
-        return this._coerceBoolean(this.device.context.cloud, false);
+    // Default countdown data-point for a zone. On these devices the per-zone
+    // countdown timers sit 16 ids above the switches (switch_1=DP 1 → countdown_1
+    // =DP 17, … switch_4=DP 4 → countdown_4=DP 20), so derive it from a numeric
+    // switch dp. A code-addressed switch (e.g. "switch_1") has no derivable
+    // numeric neighbour — the user must set `dpCountdown` explicitly for those —
+    // so return '' (native countdown stays off for that zone unless configured).
+    _defaultCountdownDP(switchDp) {
+        const trimmed = ('' + switchDp).trim();
+        const n = parseInt(trimmed, 10);
+        return (isFinite(n) && String(n) === trimmed) ? String(n + 16) : '';
     }
 
-    // Resolve a configurable data-point that may be given as a numeric LAN id or
-    // a Tuya Cloud code, falling back to a sensible default for the active
-    // transport.
-    _resolveDP(value, cloudDefault, lanDefault) {
+    // Resolve a configurable data-point (a numeric id or a Tuya code), trimming and
+    // falling back to a default when it isn't set.
+    _resolveDP(value, fallback) {
         const v = (value === undefined || value === null) ? '' : ('' + value).trim();
-        if (v !== '') return v;
-        return this._isCloud() ? cloudDefault : lanDefault;
+        return v !== '' ? v : fallback;
     }
 
     _hasBattery() {
         return !this._coerceBoolean(this.device.context.noBattery, false);
     }
 
-    _hasRainSensor() {
-        return !this._coerceBoolean(this.device.context.noRainSensor, false);
-    }
-
-    _usesLeakSensor() {
-        return ('' + (this.device.context.rainSensorType || 'contact')).trim().toLowerCase() === 'leak';
-    }
-
     /* ------------------------------------------------------------------ *
      *  Service registration / cache reconciliation
      * ------------------------------------------------------------------ */
@@ -149,6 +173,25 @@ class IrrigationSystemAccessory extends BaseAccessory {
             irrigation.addLinkedService(valve);
         });
 
+        // --- Service Label (required when the accessory exposes a *collection*
+        //     of same-type services, i.e. more than one Valve) ---
+        // HAP's Service Label profile says an accessory holding several services
+        // of the same type must carry a Service Label service, with each member
+        // service tagged by a ServiceLabelIndex. We already set the indices; the
+        // anchoring Service Label service was missing. Without it the stricter
+        // Home app clients (notably iOS) scatter the zones as separate tiles
+        // rather than nesting them under the irrigation system — macOS happens to
+        // render leniently either way. The namespace is set in
+        // _registerCharacteristics. A single-valve system is not a collection, so
+        // it needs no label.
+        const multiValve = valveConfigs.length > 1;
+        const existingLabel = this.accessory.getService(Service.ServiceLabel);
+        if (multiValve && !existingLabel) {
+            this.accessory.addService(Service.ServiceLabel, this.device.context.name);
+        } else if (!multiValve && existingLabel) {
+            this.accessory.removeService(existingLabel);
+        }
+
         // --- Battery (optional) ---
         if (this._hasBattery()) {
             if (!this.accessory.getService(Service.Battery)) {
@@ -156,23 +199,11 @@ class IrrigationSystemAccessory extends BaseAccessory {
             }
         }
 
-        // --- Rain sensor (optional): Contact (default) or Leak ---
-        if (this._hasRainSensor()) {
-            const WantedSensor = this._usesLeakSensor() ? Service.LeakSensor : Service.ContactSensor;
-            const UnwantedSensor = this._usesLeakSensor() ? Service.ContactSensor : Service.LeakSensor;
-            // Drop the other sensor type if the user switched `rainSensorType`.
-            const stale = this.accessory.getService(UnwantedSensor);
-            if (stale) this.accessory.removeService(stale);
-            if (!this.accessory.getService(WantedSensor)) {
-                this.accessory.addService(WantedSensor, this.device.context.name + ' Rain');
-            }
-        }
-
         // --- Remove services that no longer belong (config changed) ---
         this.accessory.services
             .filter(service => service.UUID === Service.Valve.UUID && !validValveSubtypes.includes(service.subtype))
             .forEach(service => {
-                this.log.info('Removing stale valve service %s', service.displayName);
+                this.log.debug('Removing stale valve service %s', service.displayName);
                 this.accessory.removeService(service);
             });
 
@@ -180,12 +211,19 @@ class IrrigationSystemAccessory extends BaseAccessory {
             const battery = this.accessory.getService(Service.Battery);
             if (battery) this.accessory.removeService(battery);
         }
-        if (!this._hasRainSensor()) {
-            [Service.ContactSensor, Service.LeakSensor].forEach(S => {
-                const svc = this.accessory.getService(S);
-                if (svc) this.accessory.removeService(svc);
-            });
-        }
+
+        // Rain/leak sensors are no longer supported: they never reported
+        // reliably on these devices, and bundling a sensor in the same accessory
+        // forced the Home app to fragment the sprinkler into "sub-accessories"
+        // (blocking control from the main tile). Drop any left over from an older
+        // version so the accessory stays a clean, single-category sprinkler tile.
+        [Service.ContactSensor, Service.LeakSensor].forEach(S => {
+            const svc = this.accessory.getService(S);
+            if (svc) {
+                this.log.debug('Removing rain sensor service %s (no longer supported)', svc.displayName);
+                this.accessory.removeService(svc);
+            }
+        });
     }
 
     /* ------------------------------------------------------------------ *
@@ -208,13 +246,25 @@ class IrrigationSystemAccessory extends BaseAccessory {
         this._cascadeOn = this._coerceBoolean(this.device.context.masterTurnsOnAllZones, true);
         this._cascadeOff = this._coerceBoolean(this.device.context.masterTurnsOffAllZones, true);
 
-        // Data-points accept a numeric LAN id or a Tuya Cloud code; defaults
-        // differ per transport (cloud uses the standard Tuya codes).
-        this.dpBattery = this._resolveDP(this.device.context.dpBattery, 'battery_percentage', '46');
-        this.dpCharging = this._resolveDP(this.device.context.dpCharging, 'charge_state', '101');
-        this.dpRain = this._resolveDP(this.device.context.dpRain, 'rain_sensor_state', '49');
-        this._rainOnValue = ('' + (this.device.context.rainOnValue || 'rain')).trim();
-        this._rainInverted = this._coerceBoolean(this.device.context.rainInverted, false);
+        // Native (hardware) per-zone countdown. On by default, but only ever used
+        // for a zone whose countdown data-point the device actually reports (see
+        // _isCountdownSupported); set nativeCountdown:false to force the legacy
+        // software-timer-only behaviour even on a device that supports it.
+        this._nativeCountdown = this._coerceBoolean(this.device.context.nativeCountdown, true);
+        // Tuya's per-zone countdown is an integer number of minutes, hardware-
+        // capped at 120 (0 = no limit). The largest countdown we treat as valid is
+        // also bounded by what HomeKit's SetDuration can represent (its advertised
+        // maxValue, _maxDuration seconds), so the two views never disagree. With
+        // the default 7200s (=120min) max this is the full 120; lower maxDuration
+        // to e.g. 3600 to have the device's longer/over-cap countdowns corrected
+        // down to 60min on connect.
+        this._maxCountdownMinutes = 120;
+        this._representableCountdownMinutes = Math.max(1, Math.min(this._maxCountdownMinutes, Math.floor(this._maxDuration / 60)));
+
+        // Data-points default to this device's numeric ids; a Tuya code may be
+        // configured instead and works over either transport.
+        this.dpBattery = this._resolveDP(this.device.context.dpBattery, '46');
+        this.dpCharging = this._resolveDP(this.device.context.dpCharging, '101');
 
         // Per-zone runtime state
         this._valves = this._getValveConfigs();
@@ -234,7 +284,7 @@ class IrrigationSystemAccessory extends BaseAccessory {
 
         this._systemActiveChar = irrigation.getCharacteristic(Characteristic.Active)
             .updateValue(this._anyValveOn() ? Characteristic.Active.ACTIVE : Characteristic.Active.INACTIVE)
-            .onGet(() => this._anyValveOn() ? Characteristic.Active.ACTIVE : Characteristic.Active.INACTIVE)
+            .onGet(() => this._reportCached(this._systemActiveChar))
             .onSet(value => this._setSystemActive(value));
 
         this._systemInUseChar = irrigation.getCharacteristic(Characteristic.InUse)
@@ -277,19 +327,42 @@ class IrrigationSystemAccessory extends BaseAccessory {
                 .updateValue(0)
                 .onGet(() => this._valveRemaining(cfg));
 
-            valve.getCharacteristic(Characteristic.Active)
+            const activeChar = valve.getCharacteristic(Characteristic.Active)
                 .updateValue(on ? Characteristic.Active.ACTIVE : Characteristic.Active.INACTIVE)
-                .onGet(() => (this.getStateAsync(cfg.dp) ? 1 : 0))
                 .onSet(value => this._setValveActive(cfg, value));
+            activeChar.onGet(() => this._reportCached(activeChar));
 
             valve.getCharacteristic(Characteristic.InUse)
                 .updateValue(on ? Characteristic.InUse.IN_USE : Characteristic.InUse.NOT_IN_USE);
 
+            // Whether this zone can use the device's hardware countdown. Detection
+            // only gates the write paths; nothing is written on connect — writing
+            // the countdown dp starts a run and would open the zone.
+            cfg.countdownSupported = this._isCountdownSupported(cfg, dps);
+
             // Reflect any zone already running at startup (e.g. turned on at the
-            // device, or Homebridge restarted mid-run) and (re)arm its timer.
-            if (on) this._reflectValve(cfg, true);
+            // device, or Homebridge restarted mid-run) and (re)arm its timer. A
+            // zone that is genuinely running can safely be given a countdown, so
+            // repair an unbounded/invalid one here too — closed zones are skipped.
+            if (on) {
+                this._reflectValve(cfg, true);
+                this._ensureRunningCountdown(cfg);
+            }
         });
 
+        // --- Service Label namespace ---
+        // Anchors the per-valve ServiceLabelIndex so the Home app groups the
+        // zones under the irrigation tile (see _verifyCachedPlatformAccessory).
+        // Arabic numerals: zones are labelled 1, 2, 3… — the user-set zone names
+        // (ConfiguredName) still take precedence in the Home app.
+        if (this._valves.length > 1) {
+            const serviceLabel = this.accessory.getService(Service.ServiceLabel);
+            if (serviceLabel) {
+                serviceLabel.getCharacteristic(Characteristic.ServiceLabelNamespace)
+                    .updateValue(Characteristic.ServiceLabelNamespace.ARABIC_NUMERALS);
+            }
+        }
+
         // --- Battery ---
         if (this._hasBattery()) {
             const battery = this.accessory.getService(Service.Battery);
@@ -308,25 +381,10 @@ class IrrigationSystemAccessory extends BaseAccessory {
                 .onGet(() => this._chargingState(this.getStateAsync(this.dpCharging)));
         }
 
-        // --- Rain sensor ---
-        if (this._hasRainSensor()) {
-            if (this._usesLeakSensor()) {
-                const leak = this.accessory.getService(Service.LeakSensor);
-                leak.getCharacteristic(Characteristic.LeakDetected)
-                    .updateValue(this._rainDetected(dps[this.dpRain]) ? Characteristic.LeakDetected.LEAK_DETECTED : Characteristic.LeakDetected.LEAK_NOT_DETECTED)
-                    .onGet(() => this._rainDetected(this.getStateAsync(this.dpRain)) ? 1 : 0);
-            } else {
-                const contact = this.accessory.getService(Service.ContactSensor);
-                contact.getCharacteristic(Characteristic.ContactSensorState)
-                    .updateValue(this._contactState(dps[this.dpRain]))
-                    .onGet(() => this._contactState(this.getStateAsync(this.dpRain)));
-            }
-        }
-
         this._syncAggregate();
 
         // --- React to device-side changes (physical buttons, our own writes
-        //     being confirmed, battery/rain telemetry) ---
+        //     being confirmed, battery telemetry) ---
         this.device.on('change', (changes) => this._onDeviceChange(changes));
     }
 
@@ -339,9 +397,17 @@ class IrrigationSystemAccessory extends BaseAccessory {
 
         let valveChanged = false;
         this._valves.forEach(cfg => {
-            if (!changes.hasOwnProperty(cfg.dp)) return;
-            valveChanged = true;
-            this._reflectValve(cfg, !!changes[cfg.dp]);
+            if (changes.hasOwnProperty(cfg.dp)) {
+                valveChanged = true;
+                this._reflectValve(cfg, !!changes[cfg.dp]);
+            }
+            // A zone switched on at the device (or already on) that's left without a
+            // usable countdown gets one so it still auto-closes, offline included.
+            // _ensureRunningCountdown only writes while the zone is on, so this can
+            // never open a closed zone.
+            if (cfg.countdownSupported && (changes.hasOwnProperty(cfg.dp) || changes.hasOwnProperty(cfg.dpCountdown))) {
+                this._ensureRunningCountdown(cfg);
+            }
         });
 
         if (changes.hasOwnProperty(this.dpBattery) && this._hasBattery()) {
@@ -359,21 +425,22 @@ class IrrigationSystemAccessory extends BaseAccessory {
                 .updateValue(this._chargingState(changes[this.dpCharging]));
         }
 
-        if (changes.hasOwnProperty(this.dpRain) && this._hasRainSensor()) {
-            if (this._usesLeakSensor()) {
-                const leak = this.accessory.getService(Service.LeakSensor);
-                if (leak) leak.getCharacteristic(Characteristic.LeakDetected)
-                    .updateValue(this._rainDetected(changes[this.dpRain]) ? 1 : 0);
-            } else {
-                const contact = this.accessory.getService(Service.ContactSensor);
-                if (contact) contact.getCharacteristic(Characteristic.ContactSensorState)
-                    .updateValue(this._contactState(changes[this.dpRain]));
-            }
-        }
-
         if (valveChanged) this._syncAggregate();
     }
 
+    // onGet handler for the system / valve Active characteristics. Returns the
+    // value HomeKit already shows — the optimistic value written on press and
+    // then confirmed (or corrected) by device-side change events — rather than
+    // the raw `device.state`. Cloud devices don't advance `device.state` until
+    // the realtime stream echoes the write back, so reading it here returned the
+    // pre-press value for a moment and made the Home app toggle visibly flicker
+    // back to the old state before settling. Throwing while disconnected keeps
+    // the HomeKit "No Response" behaviour.
+    _reportCached(char) {
+        if (!this.device.connected) throw this._commError();
+        return char.value;
+    }
+
     /* ------------------------------------------------------------------ *
      *  Valve activation + timer logic
      * ------------------------------------------------------------------ */
@@ -392,6 +459,7 @@ class IrrigationSystemAccessory extends BaseAccessory {
         }
 
         this._queueWrite(cfg.dp, on);
+        if (on) this._queueCountdownWrite(cfg);
         this._reflectValve(cfg, on);
         this._syncAggregate();
     }
@@ -464,6 +532,7 @@ class IrrigationSystemAccessory extends BaseAccessory {
             const currentlyOn = !!(service && service.getCharacteristic(Characteristic.Active).value);
             if (currentlyOn === on) return;
             this._queueWrite(cfg.dp, on);
+            if (on) this._queueCountdownWrite(cfg);
             this._reflectValve(cfg, on);
         });
         this._syncAggregate();
@@ -484,10 +553,16 @@ class IrrigationSystemAccessory extends BaseAccessory {
         this.accessory.context.durations[cfg.dp] = seconds;
         this.log.info('%s: zone "%s" duration set to %s', this.device.context.name, cfg.name, seconds ? (seconds + 's') : 'indefinite');
 
-        // If the zone is running, re-base its countdown on the new duration.
+        // If the zone is running, re-base its countdown on the new duration — both
+        // the software timer and (safely, since the zone is already on) the device's
+        // hardware countdown. We deliberately do NOT write the hardware countdown
+        // while the zone is off: writing it starts a run and would open the valve.
+        // An off zone's new duration is applied the next time it is switched on
+        // (and the device persists it from there).
         const service = this._valveService(cfg);
         if (service && service.getCharacteristic(Characteristic.InUse).value === Characteristic.InUse.IN_USE) {
             this._clearTimer(cfg.dp);
+            this._queueCountdownWrite(cfg);
             const remainingChar = service.getCharacteristic(Characteristic.RemainingDuration);
             if (seconds > 0) {
                 this._endTimes[cfg.dp] = Date.now() + seconds * 1000;
@@ -521,6 +596,84 @@ class IrrigationSystemAccessory extends BaseAccessory {
         return max;
     }
 
+    /* ------------------------------------------------------------------ *
+     *  Native (hardware) countdown
+     *
+     *  Lets the device close a zone by itself after N minutes, so a run still
+     *  ends even if Homebridge or the network drops out. The catch: writing the
+     *  countdown dp STARTS a run and switches the zone ON, so it is only ever
+     *  written as part of a switch-on, or to a zone that is already on — never
+     *  while a zone is off and never on connect. It is re-sent on every switch-on
+     *  (the device doesn't reliably keep it between runs), and the software timer
+     *  is the second line of defence if the hardware countdown ever misbehaves.
+     * ------------------------------------------------------------------ */
+
+    // A zone can use the hardware countdown when the feature isn't disabled, the
+    // zone has a countdown data-point, and either the user mapped that dp
+    // explicitly or the device actually reports a plausible value there — so we
+    // never write a countdown to a device (or a dp) that isn't really one.
+    _isCountdownSupported(cfg, state) {
+        if (!this._nativeCountdown || !cfg.dpCountdown) return false;
+        if (cfg.countdownConfigured) return true;
+        return this._looksLikeCountdown(state[cfg.dpCountdown]);
+    }
+
+    _looksLikeCountdown(value) {
+        const n = this._parseCountdown(value);
+        return n !== null && n >= 0 && n <= this._maxCountdownMinutes;
+    }
+
+    _parseCountdown(value) {
+        if (value === undefined || value === null || value === '') return null;
+        const n = parseInt(value, 10);
+        return isFinite(n) ? n : null;
+    }
+
+    // SetDuration (seconds) -> hardware countdown (whole minutes). 0 stays 0 (both
+    // sides mean "no limit"); any other value is forced to at least 1 minute so a
+    // sub-minute duration can never round down to 0 and silently make the run
+    // unbounded, and is capped at what both the hardware and HomeKit allow.
+    _durationToCountdownMinutes(seconds) {
+        const s = Math.max(0, parseInt(seconds) || 0);
+        if (s === 0) return 0;
+        return Math.min(this._representableCountdownMinutes, Math.max(1, Math.round(s / 60)));
+    }
+
+    // Queue this zone's current HomeKit duration to its hardware countdown dp,
+    // coalesced with whatever else is in flight (the switch-ON it accompanies, so
+    // both data-points are written in one command). MUST only be used as part of
+    // switching the zone on, or for a zone already on — writing the countdown
+    // starts a run. Sent on every switch-on (we don't rely on the device
+    // persisting it) so each run carries the current Duration; 0 = indefinite.
+    _queueCountdownWrite(cfg) {
+        if (!cfg.countdownSupported) return;
+        this._queueWrite(cfg.dpCountdown, this._durationToCountdownMinutes(this._getDuration(cfg)));
+    }
+
+    // For a zone that is RUNNING, make sure the device has a usable countdown so it
+    // still auto-closes (offline included). Used when a zone is switched on at the
+    // device, or was already on at startup. Only ever writes while the zone is on,
+    // so it can never open a closed one. A countdown the device already holds at a
+    // valid value (e.g. a duration the device or Tuya app set for this run) is
+    // respected; only an unbounded (0) or out-of-range one is replaced with the
+    // zone's HomeKit duration. Does nothing for an indefinite (0) HomeKit
+    // duration — there's no finite run to enforce.
+    _ensureRunningCountdown(cfg) {
+        if (!cfg.countdownSupported || !this._valveInUse(cfg)) return;
+        const minutes = this._durationToCountdownMinutes(this._getDuration(cfg));
+        if (minutes <= 0) return;
+        const cd = this._parseCountdown(this.device.state[cfg.dpCountdown]);
+        if (cd === null || (cd >= 1 && cd <= this._representableCountdownMinutes)) return;
+        this.log.debug('%s: zone "%s" is running with countdown %s; setting it to %s min', this.device.context.name, cfg.name, cd === 0 ? 'unbounded' : cd, minutes);
+        this._queueWrite(cfg.dpCountdown, minutes);
+    }
+
+    _valveInUse(cfg) {
+        const {Characteristic} = this.hap;
+        const service = this._valveService(cfg);
+        return !!(service && service.getCharacteristic(Characteristic.InUse).value === Characteristic.InUse.IN_USE);
+    }
+
     /* ------------------------------------------------------------------ *
      *  Aggregation: roll zone state up to the IrrigationSystem service
      * ------------------------------------------------------------------ */
@@ -550,7 +703,7 @@ class IrrigationSystemAccessory extends BaseAccessory {
     }
 
     /* ------------------------------------------------------------------ *
-     *  Battery + rain mapping
+     *  Battery mapping
      * ------------------------------------------------------------------ */
 
     _batteryLevel(value) {
@@ -576,22 +729,6 @@ class IrrigationSystemAccessory extends BaseAccessory {
             : Characteristic.ChargingState.NOT_CHARGING;
     }
 
-    // True when the device reports rain.
-    _rainDetected(value) {
-        let raining;
-        if (typeof value === 'boolean') raining = value;
-        else raining = ('' + value).trim().toLowerCase() === this._rainOnValue.toLowerCase();
-        return this._rainInverted ? !raining : raining;
-    }
-
-    _contactState(value) {
-        const {Characteristic} = this.hap;
-        // "Rain" is treated as the triggered/abnormal state → CONTACT_NOT_DETECTED.
-        return this._rainDetected(value)
-            ? Characteristic.ContactSensorState.CONTACT_NOT_DETECTED
-            : Characteristic.ContactSensorState.CONTACT_DETECTED;
-    }
-
     /* ------------------------------------------------------------------ *
      *  Batched writes — coalesce DP updates into a single Tuya command
      * ------------------------------------------------------------------ */
@@ -614,16 +751,19 @@ class IrrigationSystemAccessory extends BaseAccessory {
             return;
         }
 
-        const dps = {};
-        let count = 0;
-        Object.keys(pending.dps).forEach(dp => {
-            if (pending.dps[dp] !== this.device.state[dp]) {
-                dps[dp] = pending.dps[dp];
-                count++;
-            }
-        });
-
-        if (count) this.device.update(dps);
+        // Send exactly what was queued. We deliberately do NOT drop data-points
+        // that appear to already match `device.state`: cloud devices never
+        // optimistically advance `state` (it only moves when the realtime/refresh
+        // stream confirms the device), so comparing against it would silently
+        // swallow a genuine command. The most visible symptom was a valve that
+        // could be turned on but never off — the "off" matched the stale "off"
+        // still in `state` (the "on" hadn't been echoed back yet) and was
+        // discarded, so HomeKit showed the zone closed while it kept running.
+        // Callers (_setValveActive, _setSystemActive, the auto-shutoff timers)
+        // already queue only real changes, judged against the HomeKit state the
+        // user sees, so there is nothing left to de-dupe here.
+        const dps = pending.dps;
+        if (Object.keys(dps).length) this.device.update(dps);
     }
 
     _valveService(cfg) {

package/lib/MultiOutletAccessory.js

@@ -34,7 +34,7 @@ class MultiOutletAccessory extends BaseAccessory {
         this.accessory.services
             .filter(service => service.UUID === Service.Outlet.UUID && !_validServices.includes(service))
             .forEach(service => {
-                this.log.info('Removing', service.displayName);
+                this.log.debug('Removing', service.displayName);
                 this.accessory.removeService(service);
             });
     }
@@ -69,6 +69,7 @@ class MultiOutletAccessory extends BaseAccessory {
     }
 
     setPower(dp, value) {
+        if (!this.device.connected) throw this._commError();
         if (!this._pendingPower) {
             this._pendingPower = {props: {}, resolvers: []};
         }
@@ -82,7 +83,7 @@ class MultiOutletAccessory extends BaseAccessory {
             this._pendingPower.timer = setTimeout(() => {
                 const {props, resolvers} = this._pendingPower;
                 this._pendingPower = null;
-                this.setMultiStateAsync(props);
+                this.setMultiStateInBackground(props);
                 resolvers.forEach(r => r());
             }, 500);
         });

package/lib/OilDiffuserAccessory.js

@@ -203,8 +203,8 @@ class OilDiffuserAccessory extends BaseAccessory {
     }
 
     getBrightness() {
-        if (this.device.state[this.dpMode] === this.cmdWhite) return this.convertBrightnessFromTuyaToHomeKit(this.device.state[this.dpColor]).b;
-        return this.convertColorFromTuyaToHomeKit(this.device.state[this.dpColor]).b;
+        if (this.getStateAsync(this.dpMode) === this.cmdWhite) return this.convertBrightnessFromTuyaToHomeKit(this.getStateAsync(this.dpColor)).b;
+        return this.convertColorFromTuyaToHomeKit(this.getStateAsync(this.dpColor)).b;
     }
 
     setBrightness(value) {
@@ -218,8 +218,8 @@ class OilDiffuserAccessory extends BaseAccessory {
     }
 
     getColorTemperature() {
-        if (this.device.state[this.dpMode] !== this.cmdWhite) return 0;
-        return this.convertColorTemperatureFromTuyaToHomeKit(this.device.state[this.dpColorTemperature]);
+        if (this.getStateAsync(this.dpMode) !== this.cmdWhite) return 0;
+        return this.convertColorTemperatureFromTuyaToHomeKit(this.getStateAsync(this.dpColorTemperature));
     }
 
     setColorTemperature(value) {
@@ -234,8 +234,8 @@ class OilDiffuserAccessory extends BaseAccessory {
     }
 
     getHue() {
-        if (this.device.state[this.dpMode] === this.cmdWhite) return 0;
-        return this.convertColorFromTuyaToHomeKit(this.device.state[this.dpColor]).h;
+        if (this.getStateAsync(this.dpMode) === this.cmdWhite) return 0;
+        return this.convertColorFromTuyaToHomeKit(this.getStateAsync(this.dpColor)).h;
     }
 
     setHue(value) {
@@ -243,7 +243,7 @@ class OilDiffuserAccessory extends BaseAccessory {
     }
 
     getSaturation() {
-        return this.convertColorFromTuyaToHomeKit(this.device.state[this.dpColor]).s;
+        return this.convertColorFromTuyaToHomeKit(this.getStateAsync(this.dpColor)).s;
     }
 
     setSaturation(value) {
@@ -251,6 +251,8 @@ class OilDiffuserAccessory extends BaseAccessory {
     }
 
     _setHueSaturation(prop) {
+        if (!this.device.connected) throw this._commError();
+
         if (!this._pendingHueSaturation) {
             this._pendingHueSaturation = {props: {}, resolvers: []};
         }
@@ -266,7 +268,7 @@ class OilDiffuserAccessory extends BaseAccessory {
                 this._pendingHueSaturation = null;
 
                 const newValue = this.convertColorFromHomeKitToTuya(props);
-                this.setMultiStateAsync({[this.dpMode]: this.cmdColor, [this.dpColor]: newValue});
+                this.setMultiStateInBackground({[this.dpMode]: this.cmdColor, [this.dpColor]: newValue});
 
                 resolvers.forEach(r => r());
             }, 500);