homebridge-tuya-plus 3.11.3-beta.3 → 3.12.0

package/config.schema.json

@@ -82,10 +82,6 @@
                   "title": "Garage Door",
                   "enum": ["GarageDoor"]
                 },
-                {
-                  "title": "Simple Garage Door (Open/Stop/Close)",
-                  "enum": ["SimpleGarageDoor"]
-                },
                 {
                   "title": "Simple Blinds",
                   "enum": ["SimpleBlinds"]
@@ -497,27 +493,6 @@
                 "functionBody": "return model.devices && model.devices[arrayIndices] && ['GarageDoor'].includes(model.devices[arrayIndices].type);"
               }
             },
-            "dpOpen": {
-              "type": "integer",
-              "placeholder": "1",
-              "condition": {
-                "functionBody": "return model.devices && model.devices[arrayIndices] && ['SimpleGarageDoor'].includes(model.devices[arrayIndices].type);"
-              }
-            },
-            "dpStop": {
-              "type": "integer",
-              "placeholder": "2",
-              "condition": {
-                "functionBody": "return model.devices && model.devices[arrayIndices] && ['SimpleGarageDoor'].includes(model.devices[arrayIndices].type);"
-              }
-            },
-            "dpClose": {
-              "type": "integer",
-              "placeholder": "3",
-              "condition": {
-                "functionBody": "return model.devices && model.devices[arrayIndices] && ['SimpleGarageDoor'].includes(model.devices[arrayIndices].type);"
-              }
-            },
             "flipState": {
               "type": "boolean",
               "condition": {

package/index.js

@@ -13,7 +13,6 @@ const AirPurifierAccessory = require('./lib/AirPurifierAccessory');
 const DehumidifierAccessory = require('./lib/DehumidifierAccessory');
 const ConvectorAccessory = require('./lib/ConvectorAccessory');
 const GarageDoorAccessory = require('./lib/GarageDoorAccessory');
-const SimpleGarageDoorAccessory = require('./lib/SimpleGarageDoorAccessory');
 const SimpleDimmerAccessory = require('./lib/SimpleDimmerAccessory');
 const SimpleDimmer2Accessory = require('./lib/SimpleDimmer2Accessory');
 const SimpleBlindsAccessory = require('./lib/SimpleBlindsAccessory');
@@ -48,7 +47,6 @@ const CLASS_DEF = {
     dehumidifier: DehumidifierAccessory,
     convector: ConvectorAccessory,
     garagedoor: GarageDoorAccessory,
-    simplegaragedoor: SimpleGarageDoorAccessory,
     simpledimmer: SimpleDimmerAccessory,
     simpledimmer2: SimpleDimmer2Accessory,
     simpleblinds: SimpleBlindsAccessory,

package/lib/AirConditionerAccessory.js

@@ -60,6 +60,17 @@ class AirConditionerAccessory extends BaseAccessory {
         this.dpTempUnits = this._getCustomDP(this.device.context.dpTempUnits) || '19';
         this.dpSwingMode = this._getCustomDP(this.device.context.dpSwingMode) || '104';
 
+        // temperatureDivisor is a default for both current and threshold reads.
+        // Some Tuya AC firmwares report temperatures scaled by 10 (e.g.
+        // temp_set = 170 means 17.0 °C). Use temperatureDivisor: 10 for those.
+        // currentTemperatureDivisor / thresholdTemperatureDivisor override
+        // the default per side, since the two DPs are not always scaled the
+        // same way (it's common for current temp to be unscaled while the
+        // setpoint is in tenths of a degree).
+        const baseDivisor = parseInt(this.device.context.temperatureDivisor) || 1;
+        this.currentTemperatureDivisor = parseInt(this.device.context.currentTemperatureDivisor) || baseDivisor;
+        this.thresholdTemperatureDivisor = parseInt(this.device.context.thresholdTemperatureDivisor) || baseDivisor;
+
         const characteristicActive = service.getCharacteristic(Characteristic.Active)
             .updateValue(this._getActive(dps[this.dpActive]))
             .onGet(() => this.getActive())
@@ -81,8 +92,8 @@ class AirConditionerAccessory extends BaseAccessory {
             .onSet(value => this.setTargetHeaterCoolerState(value));
 
         const characteristicCurrentTemperature = service.getCharacteristic(Characteristic.CurrentTemperature)
-            .updateValue(dps[this.dpCurrentTemperature])
-            .onGet(() => this.getStateAsync(this.dpCurrentTemperature));
+            .updateValue(this._scaleCurrent(dps[this.dpCurrentTemperature]))
+            .onGet(() => this._scaleCurrent(this.getStateAsync(this.dpCurrentTemperature)));
 
         let characteristicSwingMode;
         if (!this.device.context.noSwing) {
@@ -108,8 +119,8 @@ class AirConditionerAccessory extends BaseAccessory {
                     maxValue: this.device.context.maxTemperature || 35,
                     minStep: this.device.context.minTemperatureSteps || 1
                 })
-                .updateValue(dps[this.dpThreshold])
-                .onGet(() => this.getStateAsync(this.dpThreshold))
+                .updateValue(this._scaleThreshold(dps[this.dpThreshold]))
+                .onGet(() => this._scaleThreshold(this.getStateAsync(this.dpThreshold)))
                 .onSet(value => this.setTargetThresholdTemperature('cool', value));
         } else this._removeCharacteristic(service, Characteristic.CoolingThresholdTemperature);
 
@@ -121,8 +132,8 @@ class AirConditionerAccessory extends BaseAccessory {
                     maxValue: this.device.context.maxTemperature || 35,
                     minStep: this.device.context.minTemperatureSteps || 1
                 })
-                .updateValue(dps[this.dpThreshold])
-                .onGet(() => this.getStateAsync(this.dpThreshold))
+                .updateValue(this._scaleThreshold(dps[this.dpThreshold]))
+                .onGet(() => this._scaleThreshold(this.getStateAsync(this.dpThreshold)))
                 .onSet(value => this.setTargetThresholdTemperature('heat', value));
         } else this._removeCharacteristic(service, Characteristic.HeatingThresholdTemperature);
 
@@ -158,14 +169,18 @@ class AirConditionerAccessory extends BaseAccessory {
             }
 
             if (changes.hasOwnProperty(this.dpThreshold)) {
-                if (!this.device.context.noCool && characteristicCoolingThresholdTemperature && characteristicCoolingThresholdTemperature.value !== changes[this.dpThreshold])
-                    characteristicCoolingThresholdTemperature.updateValue(changes[this.dpThreshold]);
-                if (!this.device.context.noHeat && characteristicHeatingThresholdTemperature && characteristicHeatingThresholdTemperature.value !== changes[this.dpThreshold])
-                    characteristicHeatingThresholdTemperature.updateValue(changes[this.dpThreshold]);
+                const scaled = this._scaleThreshold(changes[this.dpThreshold]);
+                if (!this.device.context.noCool && characteristicCoolingThresholdTemperature && characteristicCoolingThresholdTemperature.value !== scaled)
+                    characteristicCoolingThresholdTemperature.updateValue(scaled);
+                if (!this.device.context.noHeat && characteristicHeatingThresholdTemperature && characteristicHeatingThresholdTemperature.value !== scaled)
+                    characteristicHeatingThresholdTemperature.updateValue(scaled);
             }
 
-            if (changes.hasOwnProperty(this.dpCurrentTemperature) && characteristicCurrentTemperature.value !== changes[this.dpCurrentTemperature])
-                characteristicCurrentTemperature.updateValue(changes[this.dpCurrentTemperature]);
+            if (changes.hasOwnProperty(this.dpCurrentTemperature)) {
+                const scaled = this._scaleCurrent(changes[this.dpCurrentTemperature]);
+                if (characteristicCurrentTemperature.value !== scaled)
+                    characteristicCurrentTemperature.updateValue(scaled);
+            }
 
             if (changes.hasOwnProperty(this.dpMode)) {
                 const newTargetHeaterCoolerState = this._getTargetHeaterCoolerState(changes[this.dpMode]);
@@ -304,7 +319,8 @@ class AirConditionerAccessory extends BaseAccessory {
     }
 
     async setTargetThresholdTemperature(mode, value) {
-        await this.setMultiStateLegacyAsync({[this.dpActive]: true, [this.dpThreshold]: value});
+        const raw = Math.round(value * this.thresholdTemperatureDivisor);
+        await this.setMultiStateLegacyAsync({[this.dpActive]: true, [this.dpThreshold]: raw});
         if (mode === 'cool' && !this.device.context.noHeat && this.characteristicHeatingThresholdTemperature) {
             this.characteristicHeatingThresholdTemperature.updateValue(value);
         } else if (mode === 'heat' && !this.device.context.noCool && this.characteristicCoolingThresholdTemperature) {
@@ -312,6 +328,18 @@ class AirConditionerAccessory extends BaseAccessory {
         }
     }
 
+    _scaleCurrent(raw) {
+        const v = parseFloat(raw);
+        if (!isFinite(v)) return 0;
+        return v / this.currentTemperatureDivisor;
+    }
+
+    _scaleThreshold(raw) {
+        const v = parseFloat(raw);
+        if (!isFinite(v)) return 0;
+        return v / this.thresholdTemperatureDivisor;
+    }
+
     getTemperatureDisplayUnits() {
         return this._getTemperatureDisplayUnits(this.getStateAsync(this.dpTempUnits));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-tuya-plus",
-  "version": "3.11.3-beta.3",
+  "version": "3.12.0",
   "description": "A community-maintained Homebridge plugin for controlling Tuya devices locally over LAN. Includes new features, fixes, and updated device support.",
   "main": "index.js",
   "scripts": {

package/wiki/Supported-Device-Types.md

@@ -18,7 +18,6 @@ If you are looking for verified configurations for your specific device, please
 |Simple Dimmer|`SimpleDimmer`<sup>[8](#simple-dimmers)</sup>|Dimmer switches with power control <small>([instructions](#simple-dimmers))</small>|
 |Simple Heater|`SimpleHeater`<sup>[9](#simple-heaters)</sup>|Heating solutions with only temperature control <small>([instructions](#simple-heaters))</small>|
 |Garage Door|`GarageDoor`<sup>[10](#garage-doors)</sup>|Smart garage doors or garage door openers <small>([instructions](#garage-doors))</small>|
-|Simple Garage Door|`SimpleGarageDoor`<sup>[10](#simple-garage-doors)</sup>|Garage doors and sliding gate openers that expose only three momentary action DPs: open, stop, close <small>([instructions](#simple-garage-doors))</small>|
 |Simple Blinds|`SimpleBlinds`<sup>[11](#simple-blinds)</sup>|Smart blinds and smart switches that control blinds <small>([instructions](#simple-blinds))</small>|
 |Simple Blinds2|`SimpleBlinds2`<sup>[11](#simple-blinds)</sup>|Smart blinds and smart switches that control blinds(Use if simple Blinds (1) doesn't work for you. <small>([instructions](#simple-blinds))</small>|
 |Vertical Blinds with Tilt|`VerticalBlindsWithTilt`<sup>[11](#vertical-blinds-with-tilt)</sup>|Smart vertical blinds with open/close and panel rotation <small>([instructions](#vertical-blinds-with-tilt))</small>|
@@ -403,31 +402,6 @@ While still in early testing, you can use this to open and close the garage door
 }
 ```
 
-### Simple Garage Doors
-For very basic garage door openers and sliding gate controllers that expose only three momentary action DPs — one to open, one to stop, one to close — with no position or status feedback. The plugin tracks the target state locally and persists it across restarts, so HomeKit always reflects whatever was last requested. Triggering a change sends the stop command first (so reversing direction mid-motion works; it is a no-op when the gate is idle) and then the open or close command. There is no obstruction detection.
-
-```json5
-{
-    "name": "My Sliding Gate",
-    "type": "SimpleGarageDoor",
-    "manufacturer": "Generic",
-    "model": "Generic Sliding Gate Controller",
-    "id": "032000123456789abcde",
-    "key": "0123456789abcdef",
-
-    /* Additional parameters to override defaults only if needed */
-
-    /* Override the default datapoint identifier for the open action */
-    "dpOpen": 1,
-
-    /* Override the default datapoint identifier for the stop action */
-    "dpStop": 2,
-
-    /* Override the default datapoint identifier for the close action */
-    "dpClose": 3
-}
-```
-
 ### Simple Blinds
 Normally the blinds don't report their position. This plugin attempts to time the movements to guesstimate the positions. You can adjust a few parameters to make it really close for you.
 

package/lib/SimpleGarageDoorAccessory.js

@@ -1,158 +0,0 @@
-const BaseAccessory = require('./BaseAccessory');
-
-// Delay between the stop command and the open/close command.
-//
-// Sending the opposite direction command while the gate is already moving
-// has no effect, so stop needs to be called every time before calling open or close.
-//
-// Without the delay between the stop and open/close command some controllers
-// drop the direction command because it arrives before they have
-// finished processing the stop.
-const STOP_TO_DIRECTION_DELAY_MS = 500;
-
-// Fallback if the device never echoes the stop DP back to false (e.g. when
-// the stop was a no-op because the gate was already idle, or the echo is
-// dropped). Picked to comfortably exceed the ~1s reset we observe in
-// practice.
-const STOP_RESET_TIMEOUT_MS = 3000;
-
-// Fallback for the direction DP echo. The CurrentDoorState flips when the
-// direction DP resets to false — the device's natural "command consumed"
-// signal — so this only matters if that echo is missed.
-const DIRECTION_RESET_TIMEOUT_MS = 3000;
-
-const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
-
-class SimpleGarageDoorAccessory extends BaseAccessory {
-    static getCategory(Categories) {
-        return Categories.GARAGE_DOOR_OPENER;
-    }
-
-    constructor(...props) {
-        super(...props);
-    }
-
-    _registerPlatformAccessory() {
-        const {Service} = this.hap;
-
-        this.accessory.addService(Service.GarageDoorOpener, this.device.context.name);
-
-        super._registerPlatformAccessory();
-    }
-
-    _registerCharacteristics() {
-        const {Service, Characteristic} = this.hap;
-        const service = this.accessory.getService(Service.GarageDoorOpener);
-        this._checkServiceName(service, this.device.context.name);
-
-        this.dpOpen = this._getCustomDP(this.device.context.dpOpen) || '1';
-        this.dpStop = this._getCustomDP(this.device.context.dpStop) || '2';
-        this.dpClose = this._getCustomDP(this.device.context.dpClose) || '3';
-
-        // The device only exposes momentary action DPs, so the target state is
-        // tracked locally and persisted via the homebridge accessory context.
-        if (this.accessory.context.cachedTargetDoorState !== Characteristic.TargetDoorState.OPEN &&
-            this.accessory.context.cachedTargetDoorState !== Characteristic.TargetDoorState.CLOSED) {
-            this.accessory.context.cachedTargetDoorState = Characteristic.TargetDoorState.OPEN;
-        }
-        const initialTarget = this.accessory.context.cachedTargetDoorState;
-        this.currentDoorState = initialTarget === Characteristic.TargetDoorState.OPEN
-            ? Characteristic.CurrentDoorState.OPEN
-            : Characteristic.CurrentDoorState.CLOSED;
-
-        // Each setTargetDoorState invocation bumps this token; an older
-        // in-flight chain bails out at its next await when the token changes.
-        this.opToken = 0;
-
-        this.characteristicTargetDoorState = service.getCharacteristic(Characteristic.TargetDoorState)
-            .updateValue(initialTarget)
-            .onGet(() => this.accessory.context.cachedTargetDoorState)
-            .onSet(value => this.setTargetDoorState(value));
-
-        this.characteristicCurrentDoorState = service.getCharacteristic(Characteristic.CurrentDoorState)
-            .updateValue(this.currentDoorState)
-            .onGet(() => this.currentDoorState);
-
-        service.getCharacteristic(Characteristic.ObstructionDetected)
-            .updateValue(false)
-            .onGet(() => false);
-    }
-
-    // Wraps the synchronous Tuya write so the caller can await it. The Tuya
-    // transport is fire-and-forget at the JS level — the data has been handed
-    // to the kernel by the time setMultiStateLegacyAsync returns — but using
-    // an awaited call keeps the command sequence in one readable async chain.
-    async _sendDps(dps) {
-        this.setMultiStateLegacyAsync(dps);
-    }
-
-    // Resolves when the device echoes the given DP back to false, signalling
-    // the momentary action has completed. Resolves anyway after timeoutMs so
-    // a missing echo can't wedge the chain.
-    _waitForDpReset(dp, timeoutMs) {
-        return new Promise(resolve => {
-            const cleanup = () => {
-                this.device.removeListener('change', onChange);
-                clearTimeout(timer);
-            };
-            const onChange = changes => {
-                if (changes && changes[dp] === false) {
-                    cleanup();
-                    resolve();
-                }
-            };
-            const timer = setTimeout(() => {
-                cleanup();
-                resolve();
-            }, timeoutMs);
-            this.device.on('change', onChange);
-        });
-    }
-
-    async setTargetDoorState(value) {
-        const {Characteristic} = this.hap;
-
-        this.accessory.context.cachedTargetDoorState = value;
-
-        const opToken = ++this.opToken;
-
-        // Subscribe before writing so we don't miss the reset echo.
-        const stopReset = this._waitForDpReset(this.dpStop, STOP_RESET_TIMEOUT_MS);
-
-        // Send stop first so reversing direction mid-motion works; if the gate
-        // is already idle, the stop is a no-op on the device side.
-        await this._sendDps({[this.dpStop]: true});
-        if (opToken !== this.opToken) return;
-
-        // The stop DP holds at true for ~1s on the controller and then resets
-        // to false. Sending the direction command before the device finishes
-        // processing the stop causes some controllers to drop it, so wait for
-        // the reset and then a short buffer.
-        await stopReset;
-        if (opToken !== this.opToken) return;
-        await sleep(STOP_TO_DIRECTION_DELAY_MS);
-        if (opToken !== this.opToken) return;
-
-        const directionDp = value === Characteristic.TargetDoorState.OPEN
-            ? this.dpOpen
-            : this.dpClose;
-
-        // Subscribe before writing so we don't miss the reset echo.
-        const directionReset = this._waitForDpReset(directionDp, DIRECTION_RESET_TIMEOUT_MS);
-        await this._sendDps({[directionDp]: true});
-        if (opToken !== this.opToken) return;
-
-        // Flip CurrentDoorState once the direction DP resets — that's the
-        // device's natural "command consumed" signal. The gate itself keeps
-        // moving for longer, but we have no position feedback to track that.
-        await directionReset;
-        if (opToken !== this.opToken) return;
-
-        this.currentDoorState = value === Characteristic.TargetDoorState.OPEN
-            ? Characteristic.CurrentDoorState.OPEN
-            : Characteristic.CurrentDoorState.CLOSED;
-        this.characteristicCurrentDoorState.updateValue(this.currentDoorState);
-    }
-}
-
-module.exports = SimpleGarageDoorAccessory;

package/test/SimpleGarageDoorAccessory.test.js

@@ -1,308 +0,0 @@
-'use strict';
-
-const SimpleGarageDoorAccessory = require('../lib/SimpleGarageDoorAccessory');
-const { HAP, makeInstance } = require('./support/mocks');
-
-const { CurrentDoorState: CDS, TargetDoorState: TDS } = HAP.Characteristic;
-
-const POST_RESET_DELAY_MS = 500;
-const STOP_RESET_TIMEOUT_MS = 3000;
-const DIRECTION_RESET_TIMEOUT_MS = 3000;
-
-// Give the device's `on`/`removeListener` mocks real subscription semantics
-// so the accessory can wait for `change` events the way it does in production.
-function installRealEvents(device) {
-    const handlers = new Map();
-    device.on = jest.fn((event, handler) => {
-        if (!handlers.has(event)) handlers.set(event, []);
-        handlers.get(event).push(handler);
-    });
-    device.removeListener = jest.fn((event, handler) => {
-        const list = handlers.get(event);
-        if (!list) return;
-        const idx = list.indexOf(handler);
-        if (idx >= 0) list.splice(idx, 1);
-    });
-    device.emit = (event, ...args) => {
-        const list = handlers.get(event);
-        if (list) list.slice().forEach(h => h(...args));
-    };
-    device.listenerCount = (event) => (handlers.get(event) || []).length;
-}
-
-function makeSimpleGarage(contextOverrides = {}) {
-    const { instance, device, accessory, platform } = makeInstance(
-        SimpleGarageDoorAccessory,
-        {},
-        { manufacturer: 'Generic', ...contextOverrides }
-    );
-
-    installRealEvents(device);
-
-    // Replicate what _registerCharacteristics would set up.
-    instance.dpOpen = '1';
-    instance.dpStop = '2';
-    instance.dpClose = '3';
-    instance.opToken = 0;
-    instance.currentDoorState = CDS.OPEN;
-    instance.characteristicCurrentDoorState = {
-        value: CDS.OPEN,
-        updateValue: jest.fn().mockImplementation(function(v) { this.value = v; return this; }),
-    };
-
-    return { instance, device, accessory, platform };
-}
-
-// ---------------------------------------------------------------------------
-// setTargetDoorState — device commands
-// ---------------------------------------------------------------------------
-describe('SimpleGarageDoorAccessory.setTargetDoorState — device commands', () => {
-    beforeEach(() => jest.useFakeTimers());
-    afterEach(() => jest.useRealTimers());
-
-    test('OPEN sends stop=true, waits for stop reset, then sends open=true 500ms later', async () => {
-        const { instance, device } = makeSimpleGarage();
-        const op = instance.setTargetDoorState(TDS.OPEN);
-
-        await jest.advanceTimersByTimeAsync(0);
-        expect(device.update).toHaveBeenCalledTimes(1);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
-
-        // Even after a full second the open should not have been sent yet —
-        // we're still waiting on the reset echo.
-        await jest.advanceTimersByTimeAsync(1000);
-        expect(device.update).toHaveBeenCalledTimes(1);
-
-        // Device echoes the stop DP back to false (it auto-resets).
-        device.emit('change', { '2': false }, { '2': false });
-
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS - 1);
-        expect(device.update).toHaveBeenCalledTimes(1);
-
-        await jest.advanceTimersByTimeAsync(1);
-        expect(device.update).toHaveBeenCalledTimes(2);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '1': true });
-
-        // Direction reset closes out the chain.
-        device.emit('change', { '1': false }, { '1': false });
-        await op;
-    });
-
-    test('CLOSED waits for stop reset, then sends close=true', async () => {
-        const { instance, device } = makeSimpleGarage();
-        const op = instance.setTargetDoorState(TDS.CLOSED);
-
-        await jest.advanceTimersByTimeAsync(0);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
-
-        device.emit('change', { '2': false }, { '2': false });
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '3': true });
-
-        device.emit('change', { '3': false }, { '3': false });
-        await op;
-    });
-
-    test('A {dp: true} echo does not satisfy the reset wait', async () => {
-        const { instance, device } = makeSimpleGarage();
-        const op = instance.setTargetDoorState(TDS.OPEN);
-
-        await jest.advanceTimersByTimeAsync(0);
-        expect(device.update).toHaveBeenCalledTimes(1);
-
-        // Device first echoes the stop DP back to true (acknowledging our write).
-        // This should NOT be treated as the reset.
-        device.emit('change', { '2': true }, { '2': true });
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenCalledTimes(1);
-
-        // Then the device resets it to false.
-        device.emit('change', { '2': false }, { '2': false });
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '1': true });
-
-        device.emit('change', { '1': false }, { '1': false });
-        await op;
-    });
-
-    test('Falls back to sending the direction after STOP_RESET_TIMEOUT_MS if no echo arrives', async () => {
-        const { instance, device } = makeSimpleGarage();
-        const op = instance.setTargetDoorState(TDS.OPEN);
-
-        await jest.advanceTimersByTimeAsync(0);
-        expect(device.update).toHaveBeenCalledTimes(1);
-
-        await jest.advanceTimersByTimeAsync(STOP_RESET_TIMEOUT_MS - 1);
-        expect(device.update).toHaveBeenCalledTimes(1);
-
-        await jest.advanceTimersByTimeAsync(1 + POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '1': true });
-
-        device.emit('change', { '1': false }, { '1': false });
-        await op;
-    });
-
-    test('Cleans up the change listener once the wait resolves', async () => {
-        const { instance, device } = makeSimpleGarage();
-        const op = instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(0);
-        expect(device.listenerCount('change')).toBe(1);
-
-        device.emit('change', { '2': false }, { '2': false });
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        // Direction listener should now be attached.
-        expect(device.listenerCount('change')).toBe(1);
-
-        device.emit('change', { '1': false }, { '1': false });
-        await op;
-        expect(device.listenerCount('change')).toBe(0);
-    });
-
-    test('Custom DPs are respected', async () => {
-        const { instance, device } = makeSimpleGarage();
-        instance.dpOpen = '101';
-        instance.dpStop = '102';
-        instance.dpClose = '103';
-        const op = instance.setTargetDoorState(TDS.OPEN);
-
-        await jest.advanceTimersByTimeAsync(0);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '102': true });
-
-        device.emit('change', { '102': false }, { '102': false });
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '101': true });
-
-        device.emit('change', { '101': false }, { '101': false });
-        await op;
-    });
-
-    test('Skips writes when the device is disconnected', async () => {
-        const { instance, device } = makeSimpleGarage();
-        device.connected = false;
-        const op = instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(
-            STOP_RESET_TIMEOUT_MS + POST_RESET_DELAY_MS + DIRECTION_RESET_TIMEOUT_MS
-        );
-        await op;
-        expect(device.update).not.toHaveBeenCalled();
-    });
-
-    test('Reversing during the stop->direction wait cancels the pending direction command', async () => {
-        const { instance, device } = makeSimpleGarage();
-        const op1 = instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(0);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
-
-        const op2 = instance.setTargetDoorState(TDS.CLOSED);
-        await jest.advanceTimersByTimeAsync(0);
-
-        // A second stop is sent; the originally-pending open must not fire.
-        expect(device.update).toHaveBeenCalledTimes(2);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '2': true });
-
-        device.emit('change', { '2': false }, { '2': false });
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenCalledTimes(3);
-        expect(device.update).toHaveBeenNthCalledWith(3, { '3': true });
-
-        device.emit('change', { '3': false }, { '3': false });
-        await op1;
-        await op2;
-    });
-});
-
-// ---------------------------------------------------------------------------
-// CurrentDoorState transition
-// ---------------------------------------------------------------------------
-describe('SimpleGarageDoorAccessory.setTargetDoorState — CurrentDoorState transition', () => {
-    beforeEach(() => jest.useFakeTimers());
-    afterEach(() => jest.useRealTimers());
-
-    test('CurrentDoorState flips when the direction DP echoes back to false', async () => {
-        const { instance, device } = makeSimpleGarage();
-        instance.currentDoorState = CDS.CLOSED;
-        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
-
-        const op = instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(0);
-        device.emit('change', { '2': false }, { '2': false });
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-
-        // Direction has been sent but not yet acknowledged — UI still old.
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.CLOSED);
-
-        device.emit('change', { '1': false }, { '1': false });
-        await op;
-        expect(instance.currentDoorState).toBe(CDS.OPEN);
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
-    });
-
-    test('CurrentDoorState falls back to DIRECTION_RESET_TIMEOUT_MS if the device never resets the direction DP', async () => {
-        const { instance, device } = makeSimpleGarage();
-        instance.currentDoorState = CDS.OPEN;
-        instance.characteristicCurrentDoorState.value = CDS.OPEN;
-
-        const op = instance.setTargetDoorState(TDS.CLOSED);
-        await jest.advanceTimersByTimeAsync(0);
-        device.emit('change', { '2': false }, { '2': false });
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
-
-        await jest.advanceTimersByTimeAsync(DIRECTION_RESET_TIMEOUT_MS - 1);
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
-
-        await jest.advanceTimersByTimeAsync(1);
-        await op;
-        expect(instance.currentDoorState).toBe(CDS.CLOSED);
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.CLOSED);
-    });
-
-    test('Reversing direction mid-transition cancels the stale CurrentDoorState update', async () => {
-        const { instance, device } = makeSimpleGarage();
-        instance.currentDoorState = CDS.OPEN;
-        instance.characteristicCurrentDoorState.value = CDS.OPEN;
-
-        const op1 = instance.setTargetDoorState(TDS.CLOSED);
-        await jest.advanceTimersByTimeAsync(0);
-        device.emit('change', { '2': false }, { '2': false });
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-
-        // Close has been sent; before its echo arrives, user reverses.
-        const op2 = instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(0);
-
-        // The stale close-reset echo arriving now must not flip UI to CLOSED.
-        device.emit('change', { '3': false }, { '3': false });
-        device.emit('change', { '2': false }, { '2': false });
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        device.emit('change', { '1': false }, { '1': false });
-
-        await op1;
-        await op2;
-        expect(instance.currentDoorState).toBe(CDS.OPEN);
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
-    });
-});
-
-// ---------------------------------------------------------------------------
-// Persistence
-// ---------------------------------------------------------------------------
-describe('SimpleGarageDoorAccessory persistence', () => {
-    beforeEach(() => jest.useFakeTimers());
-    afterEach(() => jest.useRealTimers());
-
-    test('Stores the latest target on the accessory context', async () => {
-        const { instance, device, accessory } = makeSimpleGarage();
-        const op1 = instance.setTargetDoorState(TDS.CLOSED);
-        expect(accessory.context.cachedTargetDoorState).toBe(TDS.CLOSED);
-        const op2 = instance.setTargetDoorState(TDS.OPEN);
-        expect(accessory.context.cachedTargetDoorState).toBe(TDS.OPEN);
-
-        await jest.advanceTimersByTimeAsync(0);
-        device.emit('change', { '2': false }, { '2': false });
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        device.emit('change', { '1': false }, { '1': false });
-        await op1;
-        await op2;
-    });
-});