homebridge-tsvesync 1.4.7 → 1.4.9

package/dist/accessories/humidifier.accessory.js

@@ -5,6 +5,10 @@ const base_accessory_1 = require("./base.accessory");
 class HumidifierAccessory extends base_accessory_1.BaseAccessory {
     constructor(platform, accessory, device) {
         super(platform, accessory, device);
+        // Tracks the last mode we commanded, to protect against stale API responses.
+        // Expires after 30s so out-of-band changes (VeSync app) are not masked.
+        this._lastCommandedMode = null;
+        this._lastCommandedModeTime = 0;
         this.device = device;
         // Initialize capabilities with default values to prevent undefined
         this.capabilities = {
@@ -18,13 +22,17 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
             hasChildLock: true,
             hasSwingMode: false,
         };
-        // Detect device type
+        // Detect device type — order matters: specific types first
+        this.isHumidDual200S = this.detectHumidDual200S();
         this.isHumid200S = this.detectHumid200S();
         this.isHumid200300S = this.detectHumid200300S();
         this.isHumid1000S = this.detectHumid1000S();
         this.isSuperior6000S = this.detectSuperior6000S();
         // Log detected device type
-        if (this.isHumid200S) {
+        if (this.isHumidDual200S) {
+            this.platform.log.debug(`Detected Dual200S device: ${this.device.deviceName}`);
+        }
+        else if (this.isHumid200S) {
             this.platform.log.debug(`Detected Humid200S device: ${this.device.deviceName}`);
         }
         else if (this.isHumid200300S) {
@@ -40,6 +48,13 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
             this.platform.log.debug(`Unknown humidifier type: ${this.device.deviceName}, using default implementation`);
         }
     }
+    /**
+     * Detect if the device is a HumidDual200S (or regional variant LUH-D301S)
+     */
+    detectHumidDual200S() {
+        const deviceType = this.device.deviceType.toUpperCase();
+        return deviceType.includes('DUAL200S') || deviceType.includes('LUH-D301S');
+    }
     /**
      * Detect if the device is a Humid200S
      */
@@ -49,7 +64,11 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
         if (deviceType.includes('CLASSIC200S')) {
             return true;
         }
-        // Check for mist level range 1-3 which is specific to Humid200S
+        // Check for mist level range 1-3 which is specific to Humid200S,
+        // but exclude Dual200S which also has low mist levels
+        if (this.isHumidDual200S) {
+            return false;
+        }
         const extendedDevice = this.device;
         if (extendedDevice.mistLevel !== undefined && extendedDevice.mistLevel <= 3) {
             return true;
@@ -68,7 +87,7 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
         }
         // Check device type for Classic300S or Dual200S
         const deviceType = this.device.deviceType.toUpperCase();
-        if (deviceType.includes('CLASSIC300S') || deviceType.includes('DUAL200S')) {
+        if (deviceType.includes('CLASSIC300S') || this.isHumidDual200S) {
             return true;
         }
         // Check for LUH-A601S, LUH-A602S, LUH-O451S, LUH-O601S series
@@ -123,17 +142,63 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
         }
         return false;
     }
+    /**
+     * Convert a VeSync mode string to a HomeKit TargetHumidifierDehumidifierState value.
+     *
+     * For Dual200S the mapping is swapped so that VeSync "auto" (which needs a
+     * humidity target) lands on HomeKit state 1 (HUMIDIFIER / "Humidity" in the
+     * Home app) where Apple shows the humidity slider, and VeSync "manual"
+     * (fixed mist, no target) lands on state 0 ("Auto", no slider).
+     */
+    modeToTargetState(mode) {
+        // Prefer last commanded mode to protect against stale API responses.
+        // Clear the override once the device reports the same mode (caught up).
+        let effectiveMode = mode;
+        if (this._lastCommandedMode !== null) {
+            const elapsed = Date.now() - this._lastCommandedModeTime;
+            if (mode === this._lastCommandedMode || elapsed > 30000) {
+                this._lastCommandedMode = null;
+            }
+            else {
+                this.platform.log.debug(`Using commanded mode '${this._lastCommandedMode}' instead of device-reported '${mode}'`);
+                effectiveMode = this._lastCommandedMode;
+            }
+        }
+        if (this.isHumidDual200S) {
+            return effectiveMode === 'auto' ? 1 : 0;
+        }
+        return effectiveMode === 'auto' ? 0 : 1;
+    }
+    /**
+     * Convert a HomeKit TargetHumidifierDehumidifierState value to a VeSync mode.
+     * Inverse of modeToTargetState.
+     */
+    targetStateToMode(value) {
+        if (this.isHumidDual200S) {
+            return value === 1 ? 'auto' : 'manual';
+        }
+        return value === 0 ? 'auto' : 'manual';
+    }
     setupService() {
         // No need to check for capabilities initialization since we set defaults in constructor
         // Get or create the humidifier service
         this.service = this.accessory.getService(this.platform.Service.HumidifierDehumidifier) ||
             this.accessory.addService(this.platform.Service.HumidifierDehumidifier);
-        // Initialize all characteristics with explicit values
+        // Initialize characteristics
         this.service.updateCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity, 40);
         this.service.updateCharacteristic(this.platform.Characteristic.RelativeHumidityHumidifierThreshold, 60);
         this.service.updateCharacteristic(this.platform.Characteristic.CurrentHumidifierDehumidifierState, 1);
         this.service.updateCharacteristic(this.platform.Characteristic.TargetHumidifierDehumidifierState, 1);
-        this.platform.log.debug('Initialized humidifier characteristics with explicit values');
+        // Register humidity handlers IMMEDIATELY after updateCharacteristic — no separation.
+        // The updateCharacteristic creates the instance; onGet/onSet must be on that same instance.
+        this.service
+            .getCharacteristic(this.platform.Characteristic.RelativeHumidityHumidifierThreshold)
+            .setProps({ minValue: 30, maxValue: 80, minStep: 1 })
+            .onGet(this.getTargetHumidity.bind(this))
+            .onSet(async (value) => {
+            this.platform.log.info(`Setting target humidity to ${value}% for ${this.device.deviceName}`);
+            await this.setTargetHumidity(value);
+        });
         // Set up required characteristics
         this.setupCharacteristic(this.platform.Characteristic.Active, this.getActive.bind(this), this.setActive.bind(this));
         // Set up target state characteristic for mode mapping
@@ -149,38 +214,28 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
         targetStateChar.setProps({
             validValues: supportsAutoMode ? [0, 1] : [1]
         });
-        this.setupCharacteristic(this.platform.Characteristic.TargetHumidifierDehumidifierState, async () => extendedDevice.mode === 'auto' ? 0 : 1, this.setTargetState.bind(this));
+        this.setupCharacteristic(this.platform.Characteristic.TargetHumidifierDehumidifierState, async () => this.modeToTargetState(extendedDevice.mode), this.setTargetState.bind(this));
         // Set up rotation speed characteristic
         this.setupCharacteristic(this.platform.Characteristic.RotationSpeed, this.getRotationSpeed.bind(this), this.handleSetRotationSpeed.bind(this));
+        // Constrain rotation speed to 2 steps for Dual200S (Low=50%, High=100%)
+        if (this.isHumidDual200S) {
+            const rotationSpeedChar = this.service.getCharacteristic(this.platform.Characteristic.RotationSpeed);
+            rotationSpeedChar.setProps({
+                minValue: 0,
+                maxValue: 100,
+                minStep: 50,
+            });
+        }
         // Add Name characteristic
         this.setupCharacteristic(this.platform.Characteristic.Name, async () => this.device.deviceName);
-        // Add Current Relative Humidity if supported
+        // CurrentRelativeHumidity getter
         if (this.capabilities && this.capabilities.hasHumidity) {
-            if (!this.service.testCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity)) {
-                this.service.addCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity);
-            }
-            // Add Target Relative Humidity characteristic
-            if (!this.service.testCharacteristic(this.platform.Characteristic.RelativeHumidityHumidifierThreshold)) {
-                this.service.addCharacteristic(this.platform.Characteristic.RelativeHumidityHumidifierThreshold);
-            }
-            // Configure the target humidity characteristic with proper properties
-            const targetHumidityChar = this.service.getCharacteristic(this.platform.Characteristic.RelativeHumidityHumidifierThreshold);
-            targetHumidityChar.setProps({
-                minValue: 30,
-                maxValue: 80,
-                minStep: 1
-            });
-            // Set an initial value to ensure the characteristic is not blank
-            targetHumidityChar.updateValue(45);
-            this.platform.log.debug(`Configured RelativeHumidityHumidifierThreshold characteristic with initial value 45%`);
-            // Set up handlers for target humidity
-            this.setupCharacteristic(this.platform.Characteristic.RelativeHumidityHumidifierThreshold, this.getTargetHumidity.bind(this), this.setTargetHumidity.bind(this));
-            // Immediately get and set the actual target humidity to ensure it's displayed correctly
-            this.getTargetHumidity().then(targetHumidity => {
-                this.platform.log.debug(`Initial target humidity value: ${targetHumidity}%`);
-                targetHumidityChar.updateValue(targetHumidity);
-            }).catch(error => {
-                this.platform.log.warn(`Failed to get initial target humidity: ${error}`);
+            this.service
+                .getCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity)
+                .onGet(async () => {
+                var _a, _b, _c;
+                const extDev = this.device;
+                return (_c = (_a = extDev.currentHumidity) !== null && _a !== void 0 ? _a : (_b = extDev.details) === null || _b === void 0 ? void 0 : _b.current_humidity) !== null && _c !== void 0 ? _c : 0;
             });
         }
         // Add Water Level characteristic if supported (mapping inferred from water_lacks/water_tank_lifted)
@@ -346,7 +401,6 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
      * Update device states based on the latest details
      */
     async updateDeviceSpecificStates(details) {
-        var _a, _b, _c, _d, _e, _f;
         // Log the relevant details for debugging without using JSON.stringify on the entire object
         this.platform.log.debug(`Updating device states for ${this.device.deviceName}`);
         // Cast to extended device type
@@ -374,65 +428,49 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
         catch (error) {
             this.platform.log.warn(`Failed to refresh device details: ${error}`);
         }
-        // Ensure we're using the most up-to-date status
-        // According to the API documentation, deviceStatus should be 'on' or 'off'
+        this.applyDeviceStatesToHomeKit(details);
+    }
+    applyDeviceStatesToHomeKit(details) {
+        var _a, _b, _c, _d, _e, _f;
+        const extendedDevice = this.device;
         const isActive = this.device.deviceStatus === 'on';
         this.platform.log.debug(`Device ${this.device.deviceName} active state: ${isActive}, Status: ${this.device.deviceStatus}`);
-        // Update active state - this is critical for HomeKit to show the correct state
         this.service.updateCharacteristic(this.platform.Characteristic.Active, isActive ? 1 : 0);
-        // Update current state based on API mapping
-        // HomeKit states: 0 = INACTIVE, 1 = IDLE, 2 = HUMIDIFYING, 3 = DEHUMIDIFYING
-        // Mapping: 
-        // - If not active -> INACTIVE (0)
-        // - If active and mode is 'manual' -> HUMIDIFYING (2)
-        // - If active and mode is 'auto' or 'sleep' -> Check if we need to be humidifying
-        let currentState = 0; // Default to INACTIVE
+        let currentState = 0;
         if (isActive) {
             if (extendedDevice.mode === 'manual') {
-                currentState = 2; // HUMIDIFYING - will show "Rising to X%"
+                currentState = 2;
             }
             else if (extendedDevice.mode === 'auto' || extendedDevice.mode === 'sleep') {
-                // Get current humidity reading (actual humidity in the room)
                 const currentHumidity = extendedDevice.currentHumidity !== undefined ?
                     extendedDevice.currentHumidity :
                     ((_a = extendedDevice.details) === null || _a === void 0 ? void 0 : _a.current_humidity) ||
                         0;
-                // Get target humidity (humidity setting)
                 const targetHumidity = extendedDevice.humidity ||
                     ((_b = extendedDevice.configuration) === null || _b === void 0 ? void 0 : _b.auto_target_humidity) ||
                     ((_c = extendedDevice.details) === null || _c === void 0 ? void 0 : _c.target_humidity) ||
-                    45; // Default to 45% if not available
-                // In auto mode, check if we need to be humidifying
+                    45;
                 if (currentHumidity < targetHumidity) {
-                    currentState = 2; // HUMIDIFYING - will show "Rising to X%"
+                    currentState = 2;
                     this.platform.log.debug(`Auto mode: Current humidity ${currentHumidity}% is below target ${targetHumidity}%, setting state to HUMIDIFYING`);
                 }
                 else {
-                    currentState = 1; // IDLE - will show "Set to X%"
+                    currentState = 1;
                     this.platform.log.debug(`Auto mode: Current humidity ${currentHumidity}% has reached target ${targetHumidity}%, setting state to IDLE`);
                 }
             }
         }
         this.service.updateCharacteristic(this.platform.Characteristic.CurrentHumidifierDehumidifierState, currentState);
-        // Update target state based on device mode
-        // HomeKit Target State: 0 = HUMIDIFIER_OR_DEHUMIDIFIER (Auto), 1 = HUMIDIFIER, 2 = DEHUMIDIFIER
-        // Mapping:
-        // - 'auto' -> HUMIDIFIER_OR_DEHUMIDIFIER (0)
-        // - 'manual' -> HUMIDIFIER (1)
-        // - 'sleep' -> HUMIDIFIER (1) (no direct mapping, default to HUMIDIFIER)
-        let targetState = 1; // Default to HUMIDIFIER
-        if (extendedDevice.mode === 'auto') {
-            targetState = 0; // HUMIDIFIER_OR_DEHUMIDIFIER
-        }
-        this.service.updateCharacteristic(this.platform.Characteristic.TargetHumidifierDehumidifierState, targetState);
-        // Update rotation speed - convert device speed (1-9) to HomeKit percentage (0-100)
+        this.service.updateCharacteristic(this.platform.Characteristic.TargetHumidifierDehumidifierState, this.modeToTargetState(extendedDevice.mode));
         let rotationSpeed = 0;
-        // For Humid200300S devices, use mistLevel if available
         if (isActive) {
-            if (this.isHumid200300S && extendedDevice.mistLevel !== undefined) {
+            if (this.isHumidDual200S && extendedDevice.mistLevel !== undefined) {
+                // Dual200S has 2 levels: 1 (Low) = 50%, 2 (High) = 100%
+                rotationSpeed = extendedDevice.mistLevel === 1 ? 50 : 100;
+            }
+            else if (this.isHumid200300S && extendedDevice.mistLevel !== undefined) {
                 const mistLevel = extendedDevice.mistLevel;
                 this.platform.log.debug(`Device ${this.device.deviceName} mist level: ${mistLevel}`);
-                // Convert mist level (1-9) to HomeKit percentage (0-100)
                 switch (mistLevel) {
                     case 1:
                         rotationSpeed = 11;
@@ -464,7 +502,6 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
                 }
             }
             else if (this.device.speed !== undefined) {
-                // Use speed for other humidifier types
                 this.platform.log.debug(`Device ${this.device.deviceName} speed: ${this.device.speed}`);
                 switch (this.device.speed) {
                     case 1:
@@ -499,67 +536,51 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
         }
         this.platform.log.debug(`Setting rotation speed to ${rotationSpeed}% for device: ${this.device.deviceName}`);
         this.service.updateCharacteristic(this.platform.Characteristic.RotationSpeed, rotationSpeed);
-        // Update relative humidity if supported
         if (this.capabilities && this.capabilities.hasHumidity) {
-            // Get current humidity reading (actual humidity in the room)
             const currentHumidity = extendedDevice.currentHumidity !== undefined ?
                 extendedDevice.currentHumidity :
                 ((_d = extendedDevice.details) === null || _d === void 0 ? void 0 : _d.current_humidity) ||
                     0;
-            // Update current humidity characteristic if we have a valid reading
             if (currentHumidity > 0) {
                 this.service.updateCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity, currentHumidity);
             }
-            // Get target humidity (humidity setting)
-            // According to API docs, humidifier.humidity returns auto_target_humidity from configuration
             const targetHumidity = extendedDevice.humidity ||
                 ((_e = extendedDevice.configuration) === null || _e === void 0 ? void 0 : _e.auto_target_humidity) ||
                 ((_f = extendedDevice.details) === null || _f === void 0 ? void 0 : _f.target_humidity) ||
-                45; // Default to 45% if not available
+                45;
             if (this.service.testCharacteristic(this.platform.Characteristic.RelativeHumidityHumidifierThreshold)) {
                 this.service.updateCharacteristic(this.platform.Characteristic.RelativeHumidityHumidifierThreshold, targetHumidity);
             }
         }
-        // Update water level if supported (inferred from water_lacks/water_tank_lifted)
         if (this.capabilities && this.capabilities.hasWaterLevel) {
-            // Check for water_lacks or water_tank_lifted in details or device.details
             const waterLacks = (details === null || details === void 0 ? void 0 : details.water_lacks) ||
                 (extendedDevice.details && extendedDevice.details.water_lacks);
             const waterTankLifted = (details === null || details === void 0 ? void 0 : details.water_tank_lifted) ||
                 (extendedDevice.details && extendedDevice.details.water_tank_lifted);
             const waterLow = waterLacks || waterTankLifted;
-            // Note: VeSync devices only support a boolean water_lacks property, not a percentage water level
-            // We map this to 0% or 100% for HomeKit's WaterLevel characteristic
             if (this.service.getCharacteristic(this.platform.Characteristic.WaterLevel)) {
-                // Map water level as 0 for low water, 100 for sufficient water
                 this.service.updateCharacteristic(this.platform.Characteristic.WaterLevel, waterLow ? 0 : 100);
                 this.platform.log.debug(`Water level for ${this.device.deviceName}: ${waterLow ? 'Low (0%)' : 'OK (100%)'}`);
             }
         }
-        // Update night light characteristics for devices that support it
         if ((this.isHumid200300S || this.isHumid1000S) && this.lightService) {
             const brightness = extendedDevice.nightLightBrightness ||
                 (extendedDevice.details && extendedDevice.details.night_light_brightness) || 0;
-            // Update on/off state
             this.lightService.updateCharacteristic(this.platform.Characteristic.On, brightness > 0);
-            // Update brightness
             this.lightService.updateCharacteristic(this.platform.Characteristic.Brightness, brightness);
         }
-        // Update temperature for Superior6000S
         if (this.isSuperior6000S && this.temperatureService) {
             const temperature = extendedDevice.temperature ||
                 (extendedDevice.details && extendedDevice.details.temperature) ||
-                20; // Default to 20°C if not available
+                20;
             this.temperatureService.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, temperature);
         }
-        // Update filter life for Superior6000S
         if (this.isSuperior6000S && this.filterService) {
             const filterLife = extendedDevice.filterLifePercentage ||
                 (extendedDevice.details && extendedDevice.details.filter_life) ||
-                100; // Default to 100% if not available
+                100;
             this.filterService.updateCharacteristic(this.platform.Characteristic.FilterLifeLevel, filterLife);
-            this.filterService.updateCharacteristic(this.platform.Characteristic.FilterChangeIndication, filterLife < 10 ? 1 : 0 // 1 = CHANGE_FILTER, 0 = FILTER_OK
-            );
+            this.filterService.updateCharacteristic(this.platform.Characteristic.FilterChangeIndication, filterLife < 10 ? 1 : 0);
         }
     }
     getDeviceCapabilities() {
@@ -600,7 +621,6 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
         return isActive ? 1 : 0;
     }
     async setActive(value) {
-        var _a, _b, _c;
         try {
             const isOn = value === 1;
             this.platform.log.debug(`Setting device ${this.device.deviceName} to ${isOn ? 'on' : 'off'}`);
@@ -662,63 +682,24 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
                 success = await this.device.turnOff();
             }
             if (!success) {
-                this.platform.log.warn(`API call to turn ${isOn ? 'on' : 'off'} device returned false`);
-            }
-            // Refresh device details to get the latest state
-            if (typeof extendedDevice.getDetails === 'function') {
-                await extendedDevice.getDetails();
-                this.platform.log.debug(`Device ${this.device.deviceName} status after setting: ` +
-                    `Status: ${this.device.deviceStatus}, ` +
-                    `Mode: ${extendedDevice.mode}, ` +
-                    `Speed: ${this.device.speed}, ` +
-                    `MistLevel: ${extendedDevice.mistLevel}`);
-            }
-            // Verify the device is actually in the desired state
-            const actuallyOn = this.device.deviceStatus === 'on';
-            if (actuallyOn !== isOn) {
-                this.platform.log.warn(`Device ${this.device.deviceName} did not change to desired state. ` +
-                    `Wanted: ${isOn ? 'on' : 'off'}, Actual: ${actuallyOn ? 'on' : 'off'}`);
+                throw new Error(`Failed to turn ${isOn ? 'on' : 'off'} device`);
             }
-            // Always update HomeKit with the actual device state, not the requested state
-            this.service.updateCharacteristic(this.platform.Characteristic.Active, actuallyOn ? 1 : 0);
-            // Update current state based on the actual state and mode
-            let currentState = 0; // Default to INACTIVE
-            if (actuallyOn) {
-                if (extendedDevice.mode === 'manual') {
-                    currentState = 2; // HUMIDIFYING - will show "Rising to X%"
-                }
-                else if (extendedDevice.mode === 'auto' || extendedDevice.mode === 'sleep') {
-                    // Get current humidity reading (actual humidity in the room)
-                    const currentHumidity = extendedDevice.currentHumidity !== undefined ?
-                        extendedDevice.currentHumidity :
-                        ((_a = extendedDevice.details) === null || _a === void 0 ? void 0 : _a.current_humidity) ||
-                            0;
-                    // Get target humidity (humidity setting)
-                    const targetHumidity = extendedDevice.humidity ||
-                        ((_b = extendedDevice.configuration) === null || _b === void 0 ? void 0 : _b.auto_target_humidity) ||
-                        ((_c = extendedDevice.details) === null || _c === void 0 ? void 0 : _c.target_humidity) ||
-                        45; // Default to 45% if not available
-                    // In auto mode, check if we need to be humidifying
-                    if (currentHumidity < targetHumidity) {
-                        currentState = 2; // HUMIDIFYING - will show "Rising to X%"
-                        this.platform.log.debug(`Auto mode: Current humidity ${currentHumidity}% is below target ${targetHumidity}%, setting state to HUMIDIFYING`);
-                    }
-                    else {
-                        currentState = 1; // IDLE - will show "Set to X%"
-                        this.platform.log.debug(`Auto mode: Current humidity ${currentHumidity}% has reached target ${targetHumidity}%, setting state to IDLE`);
-                    }
-                }
-            }
-            this.service.updateCharacteristic(this.platform.Characteristic.CurrentHumidifierDehumidifierState, currentState);
-            // Update device state and characteristics
-            await this.updateDeviceSpecificStates(this.device);
-            await this.persistDeviceState('deviceStatus', actuallyOn ? 'on' : 'off');
+            this.applyDeviceStatesToHomeKit(this.device);
+            await this.persistDeviceState('deviceStatus', isOn ? 'on' : 'off');
         }
         catch (error) {
             this.handleDeviceError('set active state', error);
         }
     }
     async getRotationSpeed() {
+        const extendedDevice = this.device;
+        if (this.isHumidDual200S) {
+            const level = extendedDevice.mistLevel;
+            if (level === undefined || level === null || level === 0) {
+                return 0;
+            }
+            return level === 1 ? 50 : 100;
+        }
         if (this.device.speed === undefined || this.device.speed === null) {
             return 0;
         }
@@ -738,7 +719,6 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
         }
     }
     async setTargetState(value) {
-        var _a, _b, _c;
         try {
             // HomeKit Target State: 0 = HUMIDIFIER_OR_DEHUMIDIFIER (Auto), 1 = HUMIDIFIER, 2 = DEHUMIDIFIER
             this.platform.log.debug(`Setting target state to ${value} for device: ${this.device.deviceName}`);
@@ -750,34 +730,24 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
                 if (!turnOnSuccess) {
                     throw new Error('Failed to turn on device before changing mode');
                 }
-                // Refresh device details after turning on
-                if (typeof device.getDetails === 'function') {
-                    await device.getDetails();
-                    this.platform.log.debug(`Device status after turning on: ${this.device.deviceStatus}`);
-                }
             }
-            // Map HomeKit target states to device modes
-            let mode = 'manual'; // Default to manual mode
-            switch (value) {
-                case 0: // Auto
-                    mode = 'auto';
-                    break;
-                case 1: // Humidifier
-                    mode = 'manual';
-                    break;
-                case 2: // Dehumidifier (not supported, but we'll handle it gracefully)
-                    this.platform.log.warn(`Dehumidifier mode not supported for device: ${this.device.deviceName}, using manual mode instead`);
-                    mode = 'manual';
-                    break;
-                default:
-                    this.platform.log.warn(`Unknown target state value: ${value}, using manual mode as default`);
-                    mode = 'manual';
+            let mode;
+            if (value === 2) {
+                this.platform.log.warn(`Dehumidifier mode not supported for device: ${this.device.deviceName}, using manual mode instead`);
+                mode = 'manual';
+            }
+            else if (value === 0 || value === 1) {
+                mode = this.targetStateToMode(value);
+            }
+            else {
+                this.platform.log.warn(`Unknown target state value: ${value}, using manual mode as default`);
+                mode = 'manual';
             }
             // Check current mode first
             if (device.mode === mode) {
                 this.platform.log.debug(`Device ${this.device.deviceName} is already in ${mode} mode, skipping API call`);
                 // Update target state to reflect the current mode
-                const targetState = mode === 'auto' ? 0 : 1;
+                const targetState = this.modeToTargetState(mode);
                 this.updateCharacteristicValue(this.platform.Characteristic.TargetHumidifierDehumidifierState, targetState);
                 return;
             }
@@ -821,51 +791,10 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
             if (!success) {
                 throw new Error(`Failed to set device mode to ${mode}`);
             }
-            // Refresh device details to get the latest state
-            if (typeof device.getDetails === 'function') {
-                await device.getDetails();
-                this.platform.log.debug(`Device ${this.device.deviceName} mode after setting: ${device.mode}`);
-            }
-            // Verify the device is actually in the desired mode
-            const actualMode = device.mode;
-            if (actualMode !== mode) {
-                this.platform.log.warn(`Device ${this.device.deviceName} did not change to desired mode. ` +
-                    `Wanted: ${mode}, Actual: ${actualMode}`);
-            }
-            // Update the target state based on the actual mode
-            const targetState = actualMode === 'auto' ? 0 : 1;
-            this.updateCharacteristicValue(this.platform.Characteristic.TargetHumidifierDehumidifierState, targetState);
-            // Update current state based on the active state and mode
-            let currentState = 0; // Default to INACTIVE
-            if (this.device.deviceStatus === 'on') {
-                if (actualMode === 'manual') {
-                    currentState = 2; // HUMIDIFYING - will show "Rising to X%"
-                }
-                else if (actualMode === 'auto' || actualMode === 'sleep') {
-                    // Get current humidity reading (actual humidity in the room)
-                    const currentHumidity = device.currentHumidity !== undefined ?
-                        device.currentHumidity :
-                        ((_a = device.details) === null || _a === void 0 ? void 0 : _a.current_humidity) ||
-                            0;
-                    // Get target humidity (humidity setting)
-                    const targetHumidity = device.humidity ||
-                        ((_b = device.configuration) === null || _b === void 0 ? void 0 : _b.auto_target_humidity) ||
-                        ((_c = device.details) === null || _c === void 0 ? void 0 : _c.target_humidity) ||
-                        45; // Default to 45% if not available
-                    // In auto mode, check if we need to be humidifying
-                    if (currentHumidity < targetHumidity) {
-                        currentState = 2; // HUMIDIFYING - will show "Rising to X%"
-                        this.platform.log.debug(`Auto mode: Current humidity ${currentHumidity}% is below target ${targetHumidity}%, setting state to HUMIDIFYING`);
-                    }
-                    else {
-                        currentState = 1; // IDLE - will show "Set to X%"
-                        this.platform.log.debug(`Auto mode: Current humidity ${currentHumidity}% has reached target ${targetHumidity}%, setting state to IDLE`);
-                    }
-                }
-            }
-            this.updateCharacteristicValue(this.platform.Characteristic.CurrentHumidifierDehumidifierState, currentState);
-            // Update device state and characteristics
-            await this.updateDeviceSpecificStates(this.device);
+            // Track commanded mode so stale getDetails() responses don't revert HomeKit
+            this._lastCommandedMode = mode;
+            this._lastCommandedModeTime = Date.now();
+            this.applyDeviceStatesToHomeKit(this.device);
         }
         catch (error) {
             this.handleDeviceError('set target state', error);
@@ -884,9 +813,13 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
                 }
                 return;
             }
-            // Convert HomeKit percentage (0-100) to device speed (1-9)
+            // Convert percentage to mist level based on device type
             let speed;
-            if (percentage <= 11) {
+            if (this.isHumidDual200S) {
+                // Dual200S: 2 levels — 1-50% = Low (1), 51-100% = High (2)
+                speed = percentage <= 50 ? 1 : 2;
+            }
+            else if (percentage <= 11) {
                 speed = 1;
             }
             else if (percentage <= 22) {
@@ -916,6 +849,18 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
             // Adjust speed based on device type
             const extendedDevice = this.device;
             let success = false;
+            // Dual200S: adjusting speed while in auto mode implies the user wants manual control
+            if (this.isHumidDual200S && extendedDevice.mode === 'auto') {
+                this.platform.log.debug(`Switching Dual200S to manual mode before setting mist level: ${this.device.deviceName}`);
+                if (typeof extendedDevice.setManualMode === 'function') {
+                    await extendedDevice.setManualMode();
+                }
+                else if (typeof extendedDevice.setMode === 'function') {
+                    await extendedDevice.setMode('manual');
+                }
+                this._lastCommandedMode = 'manual';
+                this._lastCommandedModeTime = Date.now();
+            }
             // For Humid200S devices, limit mist level to 1-3
             if (this.isHumid200S) {
                 // Limit speed to 1-3 for Humid200S devices
@@ -982,7 +927,6 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
      * Set target humidity level
      */
     async setTargetHumidity(value) {
-        var _a;
         try {
             const targetHumidity = value;
             this.platform.log.debug(`Setting target humidity to ${targetHumidity}% for device: ${this.device.deviceName}`);
@@ -994,6 +938,8 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
                 if (!turnOnSuccess) {
                     throw new Error('Failed to turn on device before setting humidity');
                 }
+                // Sync Active state immediately so HomeKit tile reflects power-on
+                this.service.updateCharacteristic(this.platform.Characteristic.Active, 1);
             }
             let success = false;
             // Try to set humidity using the appropriate method
@@ -1013,18 +959,16 @@ class HumidifierAccessory extends base_accessory_1.BaseAccessory {
             if (!success) {
                 throw new Error(`Failed to set target humidity to ${targetHumidity}%`);
             }
-            // Refresh device details to get the latest state
-            if (typeof extendedDevice.getDetails === 'function') {
-                await extendedDevice.getDetails();
-                // Log the target humidity after setting
-                const currentTarget = ((_a = extendedDevice.details) === null || _a === void 0 ? void 0 : _a.target_humidity) || extendedDevice.targetHumidity;
-                this.platform.log.debug(`Device ${this.device.deviceName} target humidity after setting: ${currentTarget}%`);
+            // Push the commanded value to HomeKit and update in-memory state.
+            // Do NOT call getDetails/updateDeviceSpecificStates here — the API
+            // returns stale target humidity, causing the slider to snap back.
+            // The next polling cycle will eventually sync the actual value.
+            if (extendedDevice.details) {
+                extendedDevice.details.target_humidity = targetHumidity;
+                // Humid200300S's humidity getter reads auto_target_humidity
+                extendedDevice.details.auto_target_humidity = targetHumidity;
             }
-            // Update the target humidity characteristic
             this.service.updateCharacteristic(this.platform.Characteristic.RelativeHumidityHumidifierThreshold, targetHumidity);
-            // Update device state and characteristics
-            await this.updateDeviceSpecificStates(this.device);
-            // Persist the target humidity
             await this.persistDeviceState('targetHumidity', targetHumidity);
         }
         catch (error) {