homebridge-tsvesync 1.6.1 → 1.7.0

package/.github/workflows/ci.yml

@@ -28,11 +28,34 @@ jobs:
         uses: actions/setup-node@v6
         with:
           node-version: ${{ matrix.node-version }}
+      - name: Check out companion library
+        uses: actions/checkout@v6
+        with:
+          repository: mickgiles/tsvesync
+          path: .companion-tsvesync
+      - name: Build matching companion package
+        working-directory: .companion-tsvesync
+        env:
+          COMPANION_BRANCH: ${{ github.head_ref || github.ref_name }}
+        run: |
+          if git ls-remote --exit-code --heads origin "$COMPANION_BRANCH" >/dev/null; then
+            git fetch --depth=1 origin "$COMPANION_BRANCH"
+            git checkout --detach FETCH_HEAD
+          fi
+          npm install
+          npm run build
+          npm run test:tower-fan
+          npm pack --pack-destination "$RUNNER_TEMP"
       - name: Install dependencies
-        run: npm install
+        run: |
+          version=$(node -p 'require("./package.json").dependencies.tsvesync')
+          test "$(node -p 'require("./.companion-tsvesync/package.json").version')" = "$version"
+          npm install --no-save --package-lock=false "$RUNNER_TEMP/tsvesync-$version.tgz"
       - name: Lint
         run: npm run lint
       - name: Build
         run: npm run build
       - name: Test
         run: npm test -- --runInBand
+      - name: Offline Homebridge smoke test
+        run: npm run test:fan-smoke

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 1.7.0 (2026-11-05)
+
+### Fixed
+- **Tower Fan Oscillation And Display** ([#5](https://github.com/mickgiles/homebridge-tsvesync/issues/5)): Correct the cloud requests through tsvesync 1.7.0, synchronize native Swing Mode and the legacy direction control, and use HomeKit's actual direction constants. Replace stale display Lightbulb controls with a binary Display switch.
+- **Tower Fan Mode Controls**: Reuse the existing Fan Mode service as a boolean Turbo Mode switch and add separate Auto Mode and Sleep Mode switches. Disabling the active mode returns to Normal. Polling and successful commands update every mode switch without invoking setters.
+- **Fan Speed And Power**: Round-trip all 12 levels correctly, power on for nonzero speeds or enabled modes, return manual slider changes to Normal, and coalesce scene writes so a zero-speed value does not undo an explicit power-on or mode. Explicit power-off wins.
+- **Failures Reach HomeKit**: Reject failed power, speed, mode, oscillation, display, child-lock, and timer writes instead of acknowledging them as successful.
+
+### Added
+- **Tower Fan Temperature Sensor**: Report Celsius through HomeKit's temperature service, converting the device's Fahrenheit-times-ten value. Missing readings report unavailable rather than a fabricated zero.
+- **Working Timer Switch**: Turning Timer on schedules a power change in one hour (off when running, on when stopped); turning it off cancels the actual timer ID. Controllers supporting Set Duration can select 60–43200 seconds, and Remaining Duration reports the countdown.
+- **Real HomeKit Regression Coverage**: Exercise actual HAP services and the real tsvesync request builder with an offline transport, including cached-accessory upgrades, scene batches, polling, and rejected device commands.
+
+### Dependencies
+- **tsvesync**: Pin to 1.7.0; both packages remain on the same version.
+
 ## 1.6.1 (2026-07-27)
 
 ### Fixed

package/README.md

@@ -107,7 +107,15 @@ All outlets are exposed as HomeKit outlets with the following features:
   * On/Off control
   * Fan speed control (1-12)
   * Mode selection (Normal, Auto, Sleep, Turbo)
-  * Oscillation control
+  * Oscillation control (native Swing Mode and legacy direction control)
+  * Display on/off switch (no brightness slider)
+  * Room temperature sensor (automatically converted to Celsius; Home shows your preferred unit)
+  * Timer switch: defaults to one hour, schedules off while running or on while stopped
+  * Timer duration (60–43200 seconds) and countdown in controllers supporting Set Duration / Remaining Duration
+
+The existing Fan Mode switch becomes Turbo Mode and keeps its service identity. Auto Mode and Sleep Mode have separate switches. Turning off the active mode returns to Normal; moving the speed slider also selects Normal. Existing display brightness tiles are replaced with the Display switch on upgrade. LTF-F422S fans do not support a night light or child lock.
+
+Tower-fan API behavior is checked against pyvesync and offline request fixtures. Physical fan validation is still needed for firmware-specific behavior; a Homebridge installation without a tower fan cannot establish that hardware validation.
 
 ### Wall Switches
 - ESWL01

package/dist/accessories/fan.accessory.d.ts

@@ -4,30 +4,30 @@ import { TSVESyncPlatform } from '../platform';
 import { DeviceCapabilities, VeSyncFan } from '../types/device.types';
 export declare class FanAccessory extends BaseAccessory {
     protected readonly device: VeSyncFan;
-    private readonly capabilities;
-    private readonly speedLevels;
+    private writeChain;
+    private pendingWrite;
+    private pendingPromise;
     constructor(platform: TSVESyncPlatform, accessory: PlatformAccessory, device: VeSyncFan);
+    private get maxSpeed();
+    private get currentMode();
+    private get oscillationEnabled();
+    private supports;
+    private supportsMode;
+    private findSwitch;
+    private setupSwitch;
     protected setupService(): void;
-    /**
-     * Update device states based on the latest details
-     */
-    protected updateDeviceSpecificStates(details: any): Promise<void>;
+    private get timerDuration();
+    private get currentTemperature();
+    private get rotationSpeed();
+    protected updateDeviceSpecificStates(_details: any): Promise<void>;
     protected getDeviceCapabilities(): DeviceCapabilities;
-    private getActive;
-    private setActive;
-    private handleSetRotationSpeed;
-    private getRotationSpeed;
-    private getRotationDirection;
-    private setRotationDirection;
-    private getSwingMode;
-    private setSwingMode;
+    private requireSuccess;
+    private enqueue;
+    /** Coalesce scene writes so an explicit mode/on is not undone by a 0% slider. */
+    private queueWrite;
+    private applyWrite;
+    private setOscillation;
     private supportsChildLock;
     private setupChildLock;
-    private getLockPhysicalControls;
-    private setLockPhysicalControls;
-    private getModeValue;
-    private getModeString;
-    private getMode;
-    private setMode;
 }
 //# sourceMappingURL=fan.accessory.d.ts.map

package/dist/accessories/fan.accessory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fan.accessory.d.ts","sourceRoot":"","sources":["../../src/accessories/fan.accessory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAqCtE,qBAAa,YAAa,SAAQ,aAAa;IAC7C,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IACrC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAW;gBAGrC,QAAQ,EAAE,gBAAgB,EAC1B,SAAS,EAAE,iBAAiB,EAC5B,MAAM,EAAE,SAAS;IAQnB,SAAS,CAAC,YAAY,IAAI,IAAI;IAsD9B;;OAEG;cACa,0BAA0B,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAsDvE,SAAS,CAAC,qBAAqB,IAAI,kBAAkB;YAcvC,SAAS;YAIT,SAAS;YAiBT,sBAAsB;YAkBtB,gBAAgB;YAiBhB,oBAAoB;YAMpB,oBAAoB;YAmBpB,YAAY;YAIZ,YAAY;IAmB1B,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,cAAc;YAmBR,uBAAuB;YAIvB,uBAAuB;IAmBrC,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,aAAa;YASP,OAAO;YAIP,OAAO;CActB"}
+{"version":3,"file":"fan.accessory.d.ts","sourceRoot":"","sources":["../../src/accessories/fan.accessory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,iBAAiB,EAAW,MAAM,YAAY,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAetE,qBAAa,YAAa,SAAQ,aAAa;IAC7C,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IACrC,OAAO,CAAC,UAAU,CAAoC;IACtD,OAAO,CAAC,YAAY,CAAyB;IAC7C,OAAO,CAAC,cAAc,CAA8B;gBAExC,QAAQ,EAAE,gBAAgB,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,EAAE,SAAS;IAKvF,OAAO,KAAK,QAAQ,GAEnB;IAED,OAAO,KAAK,WAAW,GAEtB;IAED,OAAO,KAAK,kBAAkB,GAE7B;IAED,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,WAAW;IAQnB,SAAS,CAAC,YAAY,IAAI,IAAI;IAgE9B,OAAO,KAAK,aAAa,GAGxB;IAED,OAAO,KAAK,kBAAkB,GAG7B;IAED,OAAO,KAAK,aAAa,GAExB;cAEe,0BAA0B,CAAC,QAAQ,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBxE,SAAS,CAAC,qBAAqB,IAAI,kBAAkB;IAKrD,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,OAAO;IAgBf,iFAAiF;IACjF,OAAO,CAAC,UAAU;YAoBJ,UAAU;IAiBxB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,cAAc;CAUvB"}

package/dist/accessories/fan.accessory.js

@@ -2,273 +2,223 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FanAccessory = void 0;
 const base_accessory_1 = require("./base.accessory");
-// Constants for fan direction
-const CLOCKWISE = 1;
-const COUNTER_CLOCKWISE = 0;
-// Constants for fan modes
-const MODE_NORMAL = 0;
-const MODE_AUTO = 1;
-const MODE_SLEEP = 2;
-const MODE_TURBO = 3;
-// Fan speed levels for different device types
-const FAN_SPEED_LEVELS = {
-    'LTF-F422S-KEU': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
-    'LTF-F422S-WUSR': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
-    'LTF-F422_WJP': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
-    'LTF-F422S-WUS': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
-    'Core200S': [1, 2, 3],
-    'Core300S': [1, 2, 3, 4],
-    'Core400S': [1, 2, 3, 4],
-    'Core600S': [1, 2, 3, 4],
-    'LAP-C201S-AUSR': [1, 2, 3],
-    'LAP-C202S-WUSR': [1, 2, 3],
-    'LAP-C301S-WJP': [1, 2, 3, 4],
-    'LAP-C302S-WUSB': [1, 2, 3, 4],
-    'LAP-C301S-WAAA': [1, 2, 3, 4],
-    'LAP-C401S-WJP': [1, 2, 3, 4],
-    'LAP-C401S-WUSR': [1, 2, 3, 4],
-    'LAP-C401S-WAAA': [1, 2, 3, 4],
-    'LAP-C601S-WUS': [1, 2, 3, 4],
-    'LAP-C601S-WUSR': [1, 2, 3, 4],
-    'LAP-C601S-WEU': [1, 2, 3, 4],
-    'LV-PUR131S': [1, 2, 3],
-    'LV-RH131S': [1, 2, 3]
-};
+const MODES = [
+    // Reuse the old Fan Mode service identity so existing automations survive.
+    { mode: 'turbo', name: 'Turbo Mode', subtype: 'fan-mode' },
+    { mode: 'auto', name: 'Auto Mode', subtype: 'auto-mode' },
+    { mode: 'sleep', name: 'Sleep Mode', subtype: 'sleep-mode' },
+];
 class FanAccessory extends base_accessory_1.BaseAccessory {
     constructor(platform, accessory, device) {
         super(platform, accessory, device);
+        this.writeChain = Promise.resolve();
+        this.pendingWrite = null;
+        this.pendingPromise = null;
         this.device = device;
-        this.capabilities = this.getDeviceCapabilities();
-        this.speedLevels = FAN_SPEED_LEVELS[this.device.deviceType] || [1, 2, 3, 4];
     }
-    setupService() {
-        // Get or create the fan service
-        this.service = this.accessory.getService(this.platform.Service.Fanv2) ||
-            this.accessory.addService(this.platform.Service.Fanv2);
-        // Set up required characteristics
-        this.setupCharacteristic(this.platform.Characteristic.Active, this.getActive.bind(this), this.setActive.bind(this));
-        // Set up speed control
-        this.setupCharacteristic(this.platform.Characteristic.RotationSpeed, this.getRotationSpeed.bind(this), this.handleSetRotationSpeed.bind(this));
-        // Set up mode control
-        this.setupCharacteristic(this.platform.Characteristic.SwingMode, this.getSwingMode.bind(this), this.setSwingMode.bind(this));
-        // Set up rotation direction
-        this.setupCharacteristic(this.platform.Characteristic.RotationDirection, this.getRotationDirection.bind(this), this.setRotationDirection.bind(this));
-        // Set up child lock for devices that support it. LTF tower fans do not -
-        // their API neither reports nor accepts child lock, so the profile no
-        // longer advertises the feature.
-        this.setupChildLock();
-        // Add mode control service
-        const modeService = this.accessory.getService('Fan Mode') ||
-            this.accessory.addService(this.platform.Service.Switch, 'Fan Mode', 'fan-mode');
-        // Set up mode characteristics
-        modeService.getCharacteristic(this.platform.Characteristic.On)
-            .onGet(() => this.getMode())
-            .onSet((value) => this.setMode(value));
-        // Add Name characteristic
-        this.setupCharacteristic(this.platform.Characteristic.Name, async () => this.sanitizedDeviceName);
+    get maxSpeed() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.device).getMaxFanSpeed) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : (this.device.deviceType.startsWith('LTF-F422') ? 12 : 4);
     }
-    /**
-     * Update device states based on the latest details
-     */
-    async updateDeviceSpecificStates(details) {
-        const fanDetails = details;
-        // Update active state
-        const isActive = fanDetails.deviceStatus === 'on';
-        this.updateCharacteristicValue(this.platform.Characteristic.Active, isActive ? 1 : 0);
-        // Update current state (INACTIVE = 0, IDLE = 1, BLOWING_AIR = 2)
-        this.updateCharacteristicValue(this.platform.Characteristic.CurrentFanState, isActive ? 2 : 0);
-        // Update rotation speed
-        let rotationSpeed = 0;
-        if (isActive && fanDetails.speed !== undefined) {
-            const speedIndex = this.speedLevels.indexOf(fanDetails.speed);
-            if (speedIndex !== -1) {
-                const maxLevel = this.speedLevels.length;
-                const levelSize = 100 / maxLevel;
-                rotationSpeed = Math.round((speedIndex + 1) * levelSize);
-            }
-        }
-        this.updateCharacteristicValue(this.platform.Characteristic.RotationSpeed, rotationSpeed);
-        // Update oscillation status
-        if ('oscillationState' in fanDetails) {
-            this.updateCharacteristicValue(this.platform.Characteristic.SwingMode, fanDetails.oscillationState ? 1 : 0);
-        }
-        // Update mode
-        const modeService = this.accessory.getService('Fan Mode');
-        if (modeService && fanDetails.mode) {
-            modeService.setCharacteristic(this.platform.Characteristic.On, this.getModeValue(fanDetails.mode));
-        }
+    get currentMode() {
+        return this.device.mode === 'advancedSleep' ? 'sleep' : this.device.mode || 'normal';
     }
-    getDeviceCapabilities() {
-        return {
-            hasBrightness: false,
-            hasColorTemp: false,
-            hasColor: false,
-            hasSpeed: true,
-            hasHumidity: false,
-            hasAirQuality: false,
-            hasWaterLevel: false,
-            hasChildLock: true,
-            hasSwingMode: true,
-        };
+    get oscillationEnabled() {
+        var _a;
+        return (_a = this.device.oscillationEnabled) !== null && _a !== void 0 ? _a : this.device.oscillationState;
     }
-    async getActive() {
-        return this.device.deviceStatus === 'on' ? 1 : 0;
+    supports(feature) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.device).hasFeature) === null || _b === void 0 ? void 0 : _b.call(_a, feature)) !== null && _c !== void 0 ? _c : this.device.deviceType.startsWith('LTF-F422');
     }
-    async setActive(value) {
-        try {
-            const isOn = value === 1;
-            const success = isOn ? await this.device.turnOn() : await this.device.turnOff();
-            if (!success) {
-                throw new Error(`Failed to turn ${isOn ? 'on' : 'off'} device`);
-            }
-            // Update device state and characteristics
-            await this.updateDeviceSpecificStates(this.device);
-            await this.persistDeviceState('deviceStatus', isOn ? 'on' : 'off');
-        }
-        catch (error) {
-            this.handleDeviceError('set active state', error);
-        }
+    supportsMode(mode) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.device).getSupportedModes) === null || _b === void 0 ? void 0 : _b.call(_a).includes(mode)) !== null && _c !== void 0 ? _c : true;
     }
-    async handleSetRotationSpeed(value) {
-        const percentage = value;
-        if (percentage === 0) {
-            // Turn off the device instead of setting speed to 0
-            await this.device.turnOff();
-            return;
-        }
-        // Convert HomeKit percentage to device speed level
-        const maxLevel = this.speedLevels.length;
-        const levelSize = 100 / maxLevel;
-        const levelIndex = Math.min(Math.floor(percentage / levelSize), maxLevel - 1);
-        const speed = this.speedLevels[levelIndex];
-        await this.device.changeFanSpeed(speed);
-    }
-    async getRotationSpeed() {
-        if (this.device.speed === undefined || this.device.speed === null) {
-            return 0;
-        }
-        // Convert device speed to HomeKit percentage
-        const currentSpeed = this.device.speed;
-        const speedIndex = this.speedLevels.indexOf(currentSpeed);
-        if (speedIndex === -1) {
-            return 0;
-        }
-        const maxLevel = this.speedLevels.length;
-        const levelSize = 100 / maxLevel;
-        return Math.round((speedIndex + 1) * levelSize);
+    findSwitch(name, subtype) {
+        return this.accessory.getServiceById(this.platform.Service.Switch, subtype) ||
+            this.accessory.getService(name) ||
+            (subtype === 'fan-mode' ? this.accessory.getService('Fan Mode') : undefined);
     }
-    async getRotationDirection() {
-        return 'oscillation' in this.device && this.device.oscillation
-            ? CLOCKWISE
-            : COUNTER_CLOCKWISE;
+    setupSwitch(name, subtype, get, set) {
+        const service = this.findSwitch(name, subtype) || this.accessory.addService(this.platform.Service.Switch, name, subtype);
+        service.displayName = name;
+        service.setCharacteristic(this.platform.Characteristic.Name, name);
+        this.setupCharacteristic(this.platform.Characteristic.On, get, set, undefined, service);
+        return service;
     }
-    async setRotationDirection(value) {
-        try {
-            if (!('setOscillation' in this.device)) {
-                throw new Error('Device does not support oscillation');
-            }
-            // Map CLOCKWISE to oscillation ON, COUNTER_CLOCKWISE to oscillation OFF
-            const shouldOscillate = value === CLOCKWISE;
-            const success = await this.device.setOscillation(shouldOscillate);
-            if (!success) {
-                throw new Error(`Failed to ${shouldOscillate ? 'enable' : 'disable'} oscillation`);
+    setupService() {
+        this.service = this.accessory.getService(this.platform.Service.Fanv2) || this.accessory.addService(this.platform.Service.Fanv2);
+        this.setupCharacteristic(this.platform.Characteristic.Active, async () => this.device.deviceStatus === 'on' ? 1 : 0, value => this.queueWrite('active', Number(value)));
+        this.setupCharacteristic(this.platform.Characteristic.RotationSpeed, async () => this.rotationSpeed, value => this.queueWrite('speed', Number(value)), { minValue: 0, maxValue: 100, minStep: 1 });
+        this.setupCharacteristic(this.platform.Characteristic.SwingMode, async () => Number(this.oscillationEnabled), value => this.setOscillation(Number(value) === 1));
+        // Legacy clients used direction to toggle oscillation. Keep both controls in sync.
+        this.setupCharacteristic(this.platform.Characteristic.RotationDirection, async () => this.oscillationEnabled ? this.platform.Characteristic.RotationDirection.CLOCKWISE : this.platform.Characteristic.RotationDirection.COUNTER_CLOCKWISE, value => this.setOscillation(value === this.platform.Characteristic.RotationDirection.CLOCKWISE));
+        this.setupCharacteristic(this.platform.Characteristic.Name, async () => this.sanitizedDeviceName);
+        this.setupChildLock();
+        for (const { mode, name, subtype } of MODES) {
+            if (!this.supportsMode(mode))
+                continue;
+            this.setupSwitch(name, subtype, async () => this.device.deviceStatus === 'on' && this.currentMode === mode, value => this.queueWrite('modes', { [mode]: Boolean(value) }));
+        }
+        if (this.supports('display') && this.device.setDisplay) {
+            // Old cached Lightbulb/brightness controls cannot represent a binary display.
+            for (const service of [...this.accessory.services]) {
+                if (service.UUID === this.platform.Service.Lightbulb.UUID &&
+                    (service.subtype === 'display' || /^(display|night light)$/i.test(service.displayName))) {
+                    this.accessory.removeService(service);
+                }
             }
-        }
-        catch (error) {
-            this.handleDeviceError('set rotation direction', error);
-            throw error;
+            this.setupSwitch('Display', 'display', async () => Boolean(this.device.displayEnabled), value => this.enqueue(async () => {
+                this.requireSuccess(await this.device.setDisplay(Boolean(value)), 'set display');
+            }));
+        }
+        if (this.supports('timer') && this.device.setTimer && this.device.clearTimer) {
+            const timer = this.setupSwitch('Timer', 'timer', async () => { var _a; return ((_a = this.device.timerRemaining) !== null && _a !== void 0 ? _a : 0) > 0; }, value => this.enqueue(async () => {
+                this.requireSuccess(value ? await this.device.setTimer(this.timerDuration / 3600) : await this.device.clearTimer(), 'set timer');
+            }));
+            timer.addOptionalCharacteristic(this.platform.Characteristic.SetDuration);
+            timer.addOptionalCharacteristic(this.platform.Characteristic.RemainingDuration);
+            timer.getCharacteristic(this.platform.Characteristic.SetDuration).updateValue(this.timerDuration);
+            // Home shows the on/off switch; controllers such as Eve can also set the duration.
+            this.setupCharacteristic(this.platform.Characteristic.SetDuration, async () => this.timerDuration, value => this.enqueue(async () => {
+                var _a;
+                const seconds = Number(value);
+                if (!Number.isInteger(seconds) || seconds < 60 || seconds > 43200)
+                    throw new Error('Timer duration must be 60–43200 seconds');
+                if (((_a = this.device.timerRemaining) !== null && _a !== void 0 ? _a : 0) > 0)
+                    this.requireSuccess(await this.device.setTimer(seconds / 3600), 'set timer duration');
+                this.accessory.context.fanTimerDuration = seconds;
+            }), { minValue: 60, maxValue: 43200, minStep: 1 }, timer);
+            this.setupCharacteristic(this.platform.Characteristic.RemainingDuration, async () => { var _a; return (_a = this.device.timerRemaining) !== null && _a !== void 0 ? _a : 0; }, undefined, { minValue: 0, maxValue: 43200, minStep: 1 }, timer);
+        }
+        if (this.supports('temperature') && 'temperatureCelsius' in this.device) {
+            const temperature = this.accessory.getService(this.platform.Service.TemperatureSensor) ||
+                this.accessory.addService(this.platform.Service.TemperatureSensor, 'Temperature', 'temperature');
+            this.setupCharacteristic(this.platform.Characteristic.CurrentTemperature, async () => {
+                const value = this.currentTemperature;
+                if (value === undefined)
+                    throw new Error('Temperature is not available');
+                return value;
+            }, undefined, { minValue: -50, maxValue: 100, minStep: 0.1 }, temperature);
+        }
+    }
+    get timerDuration() {
+        const value = this.accessory.context.fanTimerDuration;
+        return Number.isInteger(value) && value >= 60 && value <= 43200 ? value : 3600;
+    }
+    get currentTemperature() {
+        const value = this.device.temperatureCelsius;
+        return value !== undefined && Number.isFinite(value) && value >= -50 && value <= 100 ? value : undefined;
+    }
+    get rotationSpeed() {
+        var _a;
+        return this.device.deviceStatus === 'on' ? Math.round(Math.max(0, Math.min(this.maxSpeed, (_a = this.device.speed) !== null && _a !== void 0 ? _a : 0)) / this.maxSpeed * 100) : 0;
+    }
+    async updateDeviceSpecificStates(_details) {
+        var _a, _b, _c, _d, _e;
+        const c = this.platform.Characteristic;
+        this.updateCharacteristicValue(c.Active, this.device.deviceStatus === 'on' ? 1 : 0);
+        this.updateCharacteristicValue(c.CurrentFanState, this.device.deviceStatus === 'on' ? 2 : 0);
+        this.updateCharacteristicValue(c.RotationSpeed, this.rotationSpeed);
+        this.updateCharacteristicValue(c.SwingMode, Number(this.oscillationEnabled));
+        this.updateCharacteristicValue(c.RotationDirection, this.oscillationEnabled ? c.RotationDirection.CLOCKWISE : c.RotationDirection.COUNTER_CLOCKWISE);
+        if (this.supportsChildLock())
+            this.updateCharacteristicValue(c.LockPhysicalControls, this.device.childLock ? 1 : 0);
+        for (const { mode, name, subtype } of MODES) {
+            (_a = this.findSwitch(name, subtype)) === null || _a === void 0 ? void 0 : _a.updateCharacteristic(c.On, this.device.deviceStatus === 'on' && this.currentMode === mode);
+        }
+        (_b = this.findSwitch('Display', 'display')) === null || _b === void 0 ? void 0 : _b.updateCharacteristic(c.On, Boolean(this.device.displayEnabled));
+        const timer = this.findSwitch('Timer', 'timer');
+        timer === null || timer === void 0 ? void 0 : timer.updateCharacteristic(c.On, ((_c = this.device.timerRemaining) !== null && _c !== void 0 ? _c : 0) > 0);
+        timer === null || timer === void 0 ? void 0 : timer.updateCharacteristic(c.RemainingDuration, (_d = this.device.timerRemaining) !== null && _d !== void 0 ? _d : 0);
+        const temperature = this.currentTemperature;
+        if (temperature !== undefined) {
+            (_e = this.accessory.getService(this.platform.Service.TemperatureSensor)) === null || _e === void 0 ? void 0 : _e.updateCharacteristic(c.CurrentTemperature, temperature);
         }
     }
-    async getSwingMode() {
-        return this.device.oscillationState ? 1 : 0;
-    }
-    async setSwingMode(value) {
-        try {
-            if (!this.device.setOscillation) {
-                throw new Error('Device does not support oscillation');
+    getDeviceCapabilities() {
+        return { hasBrightness: false, hasColorTemp: false, hasColor: false, hasSpeed: true, hasHumidity: false,
+            hasAirQuality: false, hasWaterLevel: false, hasChildLock: this.supportsChildLock(), hasSwingMode: true };
+    }
+    requireSuccess(success, action) {
+        if (!success)
+            throw new Error(`Failed to ${action}`);
+    }
+    enqueue(action) {
+        const write = this.writeChain.catch(() => undefined).then(async () => {
+            try {
+                await action();
+                await this.updateDeviceSpecificStates(this.device);
+                this.cacheDeviceDetails(this.device);
+                await this.persistDeviceState('mode', this.currentMode);
             }
-            const enabled = value === 1;
-            const success = await this.device.setOscillation(enabled);
-            if (!success) {
-                throw new Error(`Failed to ${enabled ? 'enable' : 'disable'} oscillation`);
+            catch (error) {
+                await this.handleDeviceError('set fan state', error);
+                throw error;
             }
-            await this.persistDeviceState('oscillationState', enabled);
+        });
+        this.writeChain = write;
+        return write;
+    }
+    /** Coalesce scene writes so an explicit mode/on is not undone by a 0% slider. */
+    queueWrite(key, value) {
+        if (!this.pendingWrite)
+            this.pendingWrite = {};
+        if (key === 'modes') {
+            this.pendingWrite.modes = { ...this.pendingWrite.modes, ...value };
+        }
+        else {
+            this.pendingWrite[key] = value;
+        }
+        if (!this.pendingPromise) {
+            this.pendingPromise = new Promise((resolve, reject) => {
+                setTimeout(() => {
+                    var _a;
+                    const batch = (_a = this.pendingWrite) !== null && _a !== void 0 ? _a : {};
+                    this.pendingWrite = null;
+                    this.pendingPromise = null;
+                    this.enqueue(() => this.applyWrite(batch)).then(resolve, reject);
+                }, 50);
+            });
+        }
+        return this.pendingPromise;
+    }
+    async applyWrite({ active, speed, modes }) {
+        var _a;
+        const enabledMode = Object.keys(modes !== null && modes !== void 0 ? modes : {}).reverse().find(mode => modes[mode]);
+        if (active === 0 || (speed === 0 && active !== 1 && !enabledMode)) {
+            this.requireSuccess(await this.device.turnOff(), 'turn off fan');
+            return;
         }
-        catch (error) {
-            this.handleDeviceError('set oscillation', error);
+        const selectedMode = (_a = enabledMode !== null && enabledMode !== void 0 ? enabledMode : ((modes === null || modes === void 0 ? void 0 : modes[this.currentMode]) === false ? 'normal' : undefined)) !== null && _a !== void 0 ? _a : (speed !== undefined && speed > 0 ? 'normal' : undefined);
+        const shouldPowerOn = active === 1 || enabledMode !== undefined || (speed !== undefined && speed > 0);
+        if (shouldPowerOn && this.device.deviceStatus !== 'on')
+            this.requireSuccess(await this.device.turnOn(), 'turn on fan');
+        if (selectedMode && selectedMode !== this.currentMode)
+            this.requireSuccess(await this.device.setMode(selectedMode), `set ${selectedMode} mode`);
+        if (speed !== undefined && speed > 0 && !enabledMode) {
+            const level = Math.max(1, Math.min(this.maxSpeed, Math.round(speed / 100 * this.maxSpeed)));
+            this.requireSuccess(await this.device.changeFanSpeed(level), 'set fan speed');
         }
     }
+    setOscillation(enabled) {
+        return this.enqueue(async () => this.requireSuccess(await this.device.setOscillation(enabled), 'set oscillation'));
+    }
     supportsChildLock() {
-        const device = this.device;
-        if (typeof device.setChildLock !== 'function') {
-            return false;
-        }
-        // Older tsvesync versions have no hasFeature; fall back to the setter
-        return typeof device.hasFeature === 'function' ? device.hasFeature('child_lock') : true;
+        var _a, _b, _c;
+        return typeof this.device.setChildLock === 'function' && ((_c = (_b = (_a = this.device).hasFeature) === null || _b === void 0 ? void 0 : _b.call(_a, 'child_lock')) !== null && _c !== void 0 ? _c : true);
     }
     setupChildLock() {
-        const lockCharacteristic = this.platform.Characteristic.LockPhysicalControls;
+        const characteristic = this.platform.Characteristic.LockPhysicalControls;
         if (!this.supportsChildLock()) {
-            // Drop a stale characteristic left behind by an older cached accessory
-            if (typeof this.service.testCharacteristic === 'function' &&
-                this.service.testCharacteristic(lockCharacteristic)) {
-                this.service.removeCharacteristic(this.service.getCharacteristic(lockCharacteristic));
-            }
+            if (this.service.testCharacteristic(characteristic))
+                this.service.removeCharacteristic(this.service.getCharacteristic(characteristic));
             return;
         }
-        this.setupCharacteristic(lockCharacteristic, this.getLockPhysicalControls.bind(this), this.setLockPhysicalControls.bind(this));
-    }
-    async getLockPhysicalControls() {
-        return this.device.childLock ? 1 : 0;
-    }
-    async setLockPhysicalControls(value) {
-        try {
-            if (!this.device.setChildLock) {
-                throw new Error('Device does not support child lock');
-            }
-            const enabled = value === 1;
-            const success = await this.device.setChildLock(enabled);
-            if (!success) {
-                throw new Error(`Failed to ${enabled ? 'enable' : 'disable'} child lock`);
-            }
-            await this.persistDeviceState('child_lock', enabled);
-        }
-        catch (error) {
-            this.handleDeviceError('set child lock', error);
-        }
-    }
-    getModeValue(mode) {
-        switch (mode) {
-            case 'normal': return MODE_NORMAL;
-            case 'auto': return MODE_AUTO;
-            case 'sleep': return MODE_SLEEP;
-            case 'turbo': return MODE_TURBO;
-            default: return MODE_NORMAL;
-        }
-    }
-    getModeString(value) {
-        switch (value) {
-            case MODE_AUTO: return 'auto';
-            case MODE_SLEEP: return 'sleep';
-            case MODE_TURBO: return 'turbo';
-            default: return 'normal';
-        }
-    }
-    async getMode() {
-        return this.getModeValue(this.device.mode || 'normal');
-    }
-    async setMode(value) {
-        try {
-            const mode = this.getModeString(value);
-            const success = await this.device.setMode(mode);
-            if (!success) {
-                throw new Error(`Failed to set mode to ${mode}`);
-            }
-            await this.persistDeviceState('mode', mode);
-        }
-        catch (error) {
-            this.handleDeviceError('set mode', error);
-        }
+        this.setupCharacteristic(characteristic, async () => this.device.childLock ? 1 : 0, value => this.enqueue(async () => {
+            this.requireSuccess(await this.device.setChildLock(Number(value) === 1), 'set child lock');
+        }));
     }
 }
 exports.FanAccessory = FanAccessory;