homebridge-tuya-plus 3.13.0 → 3.13.1-dev.2

package/test/SimpleGarageDoorAccessory.test.js

@@ -5,10 +5,10 @@ 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;
-const SETTLE_MS = 1000;
+// Raw status DP values reported by the controller (DP 105).
+const STATE_STOPPED = 11;
+const STATE_OPENING_OR_OPEN = 12;
+const STATE_CLOSING_OR_CLOSED = 13;
 
 // Give the device's `on`/`removeListener` mocks real subscription semantics
 // so the accessory can wait for `change` events the way it does in production.
@@ -44,32 +44,28 @@ function makeSimpleGarage(initialContext = {}) {
     // call it directly because the mock service shares a single mock
     // characteristic across calls — wiring each role manually keeps the
     // assertions untangled.
-    instance.dpOpen = '1';
-    instance.dpStop = '2';
-    instance.dpClose = '3';
+    instance.dpOpen = '101';
+    instance.dpClose = '102';
+    instance.dpStop = '103';
+    instance.dpState = '105';
     instance.partialOpenMs = 0;
-    instance.currentDoorState = CDS.OPEN;
-    instance.desiredTarget = TDS.OPEN;
-    instance.worker = null;
-    instance.scheduleTimer = null;
+    instance.stopBeforeCloseMs = 1500;
     instance.partialStopTimer = null;
-    instance.partialOpenId = 0;
-    instance._partialPending = false;
-    instance._currentChangePending = null;
-    instance._currentChangeResolve = null;
+    instance.pendingCloseTimer = null;
+    instance.currentDoorState = CDS.CLOSED;
     instance.characteristicCurrentDoorState = {
-        value: CDS.OPEN,
+        value: CDS.CLOSED,
         updateValue: jest.fn().mockImplementation(function(v) { this.value = v; return this; }),
     };
     instance.characteristicTargetDoorState = {
-        value: TDS.OPEN,
+        value: TDS.CLOSED,
         updateValue: jest.fn().mockImplementation(function(v) { this.value = v; return this; }),
     };
     instance.characteristicPartialOpen = {
-        value: true,
+        value: false,
         updateValue: jest.fn().mockImplementation(function(v) { this.value = v; return this; }),
     };
-    accessory.context.cachedTargetDoorState = TDS.OPEN;
+    accessory.context.cachedTargetDoorState = TDS.CLOSED;
 
     // Mirror the persistent change listener registered in production.
     device.on('change', changes => instance._onDeviceChange(changes));
@@ -77,318 +73,299 @@ function makeSimpleGarage(initialContext = {}) {
     return { instance, device, accessory, platform };
 }
 
-// Simulate the device echoing a DP back to false (its "command consumed"
-// signal). Drives both the worker's per-step listener and the persistent
-// CurrentDoorState listener.
-function emitReset(device, dp) {
-    device.emit('change', { [dp]: false }, { [dp]: false });
+// Simulate the controller reporting a new value on its status DP.
+function emitState(device, value) {
+    device.emit('change', { '105': value });
 }
 
 // ---------------------------------------------------------------------------
-// _onDeviceChange — the persistent listener that drives CurrentDoorState
+// State DP -> door state mapping
 // ---------------------------------------------------------------------------
 describe('SimpleGarageDoorAccessory._onDeviceChange', () => {
-    test('Open DP resetting to false sets CurrentDoorState to OPEN', () => {
-        const { instance } = makeSimpleGarage();
+    test('State 12 (opening/open) drives Current and Target to OPEN', () => {
+        const { instance, accessory } = makeSimpleGarage();
         instance.currentDoorState = CDS.CLOSED;
         instance.characteristicCurrentDoorState.value = CDS.CLOSED;
+        accessory.context.cachedTargetDoorState = TDS.CLOSED;
 
-        instance._onDeviceChange({ '1': false });
+        instance._onDeviceChange({ '105': STATE_OPENING_OR_OPEN });
 
         expect(instance.currentDoorState).toBe(CDS.OPEN);
         expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
+        expect(instance.characteristicTargetDoorState.value).toBe(TDS.OPEN);
+        expect(accessory.context.cachedTargetDoorState).toBe(TDS.OPEN);
     });
 
-    test('Close DP resetting to false sets CurrentDoorState to CLOSED', () => {
+    test('State 11 (stopped) is treated as OPEN', () => {
         const { instance } = makeSimpleGarage();
+        instance.currentDoorState = CDS.CLOSED;
+        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
+
+        instance._onDeviceChange({ '105': STATE_STOPPED });
+
+        expect(instance.currentDoorState).toBe(CDS.OPEN);
+        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
+    });
+
+    test('State 13 (closing/closed) drives Current and Target to CLOSED', () => {
+        const { instance, accessory } = makeSimpleGarage();
         instance.currentDoorState = CDS.OPEN;
         instance.characteristicCurrentDoorState.value = CDS.OPEN;
+        instance.characteristicTargetDoorState.value = TDS.OPEN;
+        accessory.context.cachedTargetDoorState = TDS.OPEN;
 
-        instance._onDeviceChange({ '3': false });
+        instance._onDeviceChange({ '105': STATE_CLOSING_OR_CLOSED });
 
         expect(instance.currentDoorState).toBe(CDS.CLOSED);
         expect(instance.characteristicCurrentDoorState.value).toBe(CDS.CLOSED);
+        expect(instance.characteristicTargetDoorState.value).toBe(TDS.CLOSED);
+        expect(accessory.context.cachedTargetDoorState).toBe(TDS.CLOSED);
+    });
+
+    test('String DP values are coerced', () => {
+        const { instance } = makeSimpleGarage();
+        instance.currentDoorState = CDS.CLOSED;
+
+        instance._onDeviceChange({ '105': '12' });
+
+        expect(instance.currentDoorState).toBe(CDS.OPEN);
     });
 
-    test('Open DP echoing back to true does not change CurrentDoorState', () => {
+    test('Unknown DP values are ignored', () => {
         const { instance } = makeSimpleGarage();
         instance.currentDoorState = CDS.CLOSED;
 
-        instance._onDeviceChange({ '1': true });
+        instance._onDeviceChange({ '105': 99 });
 
         expect(instance.currentDoorState).toBe(CDS.CLOSED);
+        expect(instance.characteristicCurrentDoorState.updateValue).not.toHaveBeenCalled();
     });
 
-    test('Stop DP resets do not change CurrentDoorState', () => {
+    test('Changes that do not include the state DP are ignored', () => {
         const { instance } = makeSimpleGarage();
         instance.currentDoorState = CDS.CLOSED;
 
-        instance._onDeviceChange({ '2': false });
+        // The action DPs echoing back are irrelevant — only the state DP matters.
+        instance._onDeviceChange({ '101': false });
+        instance._onDeviceChange({ '103': true });
 
         expect(instance.currentDoorState).toBe(CDS.CLOSED);
+        expect(instance.characteristicCurrentDoorState.updateValue).not.toHaveBeenCalled();
     });
 
-    test('No characteristic write when CurrentDoorState already matches', () => {
+    test('No characteristic write when the state already matches', () => {
         const { instance } = makeSimpleGarage();
         instance.currentDoorState = CDS.OPEN;
+        instance.characteristicCurrentDoorState.value = CDS.OPEN;
+        instance.accessory.context.cachedTargetDoorState = TDS.OPEN;
 
-        instance._onDeviceChange({ '1': false });
+        instance._onDeviceChange({ '105': STATE_OPENING_OR_OPEN });
 
         expect(instance.characteristicCurrentDoorState.updateValue).not.toHaveBeenCalled();
+        expect(instance.characteristicTargetDoorState.updateValue).not.toHaveBeenCalled();
     });
 });
 
 // ---------------------------------------------------------------------------
-// setTargetDoorState — single command (target differs from current)
+// Open — always fired directly, even mid-motion
 // ---------------------------------------------------------------------------
-describe('SimpleGarageDoorAccessory.setTargetDoorState — single command', () => {
-    beforeEach(() => jest.useFakeTimers());
-    afterEach(() => jest.useRealTimers());
-
-    test('OPEN debounces for SETTLE_MS then sends stop, waits for reset+500ms, then sends open', async () => {
+describe('SimpleGarageDoorAccessory.setTargetDoorState — open', () => {
+    test('OPEN fires the open action immediately, even while the gate is closing', () => {
         const { instance, device } = makeSimpleGarage();
-        instance.currentDoorState = CDS.CLOSED;
-        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
+        device.state['105'] = STATE_CLOSING_OR_CLOSED;
 
         instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(SETTLE_MS - 1);
-        expect(device.update).not.toHaveBeenCalled();
 
-        await jest.advanceTimersByTimeAsync(1);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
-
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '1': true });
-
-        emitReset(device, '1');
-        await jest.advanceTimersByTimeAsync(0);
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
-        expect(instance.worker).toBeNull();
-        expect(instance.scheduleTimer).toBeNull();
+        expect(device.update).toHaveBeenCalledTimes(1);
+        expect(device.update).toHaveBeenCalledWith({ '101': true });
     });
 
-    test('CLOSE debounces then sends stop, waits, then sends close; CurrentDoorState flips on close reset', async () => {
+    test('OPEN never fires a stop first', () => {
         const { instance, device } = makeSimpleGarage();
-        instance.currentDoorState = CDS.OPEN;
-        instance.characteristicCurrentDoorState.value = CDS.OPEN;
-
-        instance.setTargetDoorState(TDS.CLOSED);
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
+        device.state['105'] = STATE_OPENING_OR_OPEN;
 
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '3': true });
+        instance.setTargetDoorState(TDS.OPEN);
 
-        emitReset(device, '3');
-        await jest.advanceTimersByTimeAsync(0);
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.CLOSED);
-        expect(instance.worker).toBeNull();
+        expect(device.update).not.toHaveBeenCalledWith({ '103': true });
+        expect(device.update).toHaveBeenCalledWith({ '101': true });
     });
 
-    test('Target matching current produces no commands', async () => {
-        const { instance, device } = makeSimpleGarage();
-        instance.currentDoorState = CDS.OPEN;
-        instance.desiredTarget = TDS.OPEN;
+    test('Target + persistence update optimistically; Current waits for the DP', () => {
+        const { instance, device, accessory } = makeSimpleGarage();
+        instance.currentDoorState = CDS.CLOSED;
+        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
 
         instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(
-            SETTLE_MS + STOP_RESET_TIMEOUT_MS + POST_RESET_DELAY_MS + DIRECTION_RESET_TIMEOUT_MS
-        );
+        expect(accessory.context.cachedTargetDoorState).toBe(TDS.OPEN);
+        expect(instance.characteristicTargetDoorState.value).toBe(TDS.OPEN);
+        expect(instance.characteristicCurrentDoorState.updateValue).not.toHaveBeenCalled();
+        expect(instance.currentDoorState).toBe(CDS.CLOSED);
 
-        expect(device.update).not.toHaveBeenCalled();
-        expect(instance.worker).toBeNull();
+        // ~1s later the controller reports it is opening.
+        emitState(device, STATE_OPENING_OR_OPEN);
+        expect(instance.currentDoorState).toBe(CDS.OPEN);
+        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
     });
 
-    test('Custom DPs are respected', async () => {
+    test('Custom open DP is respected', () => {
         const { instance, device } = makeSimpleGarage();
-        instance.dpOpen = '101';
-        instance.dpStop = '102';
-        instance.dpClose = '103';
-        instance.currentDoorState = CDS.CLOSED;
+        instance.dpOpen = '1';
 
         instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '102': true });
 
-        emitReset(device, '102');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '101': true });
-
-        emitReset(device, '101');
-        await jest.advanceTimersByTimeAsync(0);
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
+        expect(device.update).toHaveBeenCalledWith({ '1': true });
     });
 });
 
 // ---------------------------------------------------------------------------
-// Spam / debounce
+// Close — direct only when already stopped (state 11), otherwise stop-first
 // ---------------------------------------------------------------------------
-describe('SimpleGarageDoorAccessory.setTargetDoorState — spam debounce', () => {
+describe('SimpleGarageDoorAccessory.setTargetDoorState — close (stop-before-close)', () => {
     beforeEach(() => jest.useFakeTimers());
     afterEach(() => jest.useRealTimers());
 
-    test('Rapid presses within the debounce window coalesce into one cycle on the final target', async () => {
-        const { instance, device } = makeSimpleGarage();
-        instance.currentDoorState = CDS.OPEN;
+    test('CLOSE fires immediately when the gate is already stopped (state 11)', () => {
+        const { instance, device, accessory } = makeSimpleGarage();
+        device.state['105'] = STATE_STOPPED;
 
-        // 5 presses across ~800ms, all within SETTLE_MS of each other.
-        instance.setTargetDoorState(TDS.CLOSED);
-        await jest.advanceTimersByTimeAsync(200);
-        instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(200);
         instance.setTargetDoorState(TDS.CLOSED);
-        await jest.advanceTimersByTimeAsync(200);
-        instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(200);
+
+        expect(device.update).toHaveBeenCalledTimes(1);
+        expect(device.update).toHaveBeenCalledWith({ '102': true });
+        expect(instance.pendingCloseTimer).toBeNull();
+        expect(accessory.context.cachedTargetDoorState).toBe(TDS.CLOSED);
+        expect(instance.characteristicTargetDoorState.value).toBe(TDS.CLOSED);
+    });
+
+    test('CLOSE while opening (state 12) fires stop, then close after stopBeforeCloseMs', () => {
+        const { instance, device } = makeSimpleGarage();
+        instance.stopBeforeCloseMs = 1500;
+        device.state['105'] = STATE_OPENING_OR_OPEN;
+
         instance.setTargetDoorState(TDS.CLOSED);
 
-        // Nothing should have fired yet — debounce keeps resetting.
-        expect(device.update).not.toHaveBeenCalled();
+        // Stop goes out immediately, close is deferred.
+        expect(device.update).toHaveBeenCalledTimes(1);
+        expect(device.update).toHaveBeenNthCalledWith(1, { '103': true });
 
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
+        jest.advanceTimersByTime(1500 - 1);
+        expect(device.update).toHaveBeenCalledTimes(1);
 
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '3': true });
+        jest.advanceTimersByTime(1);
         expect(device.update).toHaveBeenCalledTimes(2);
-
-        emitReset(device, '3');
-        await jest.advanceTimersByTimeAsync(0);
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.CLOSED);
-        expect(instance.worker).toBeNull();
+        expect(device.update).toHaveBeenNthCalledWith(2, { '102': true });
+        expect(instance.pendingCloseTimer).toBeNull();
     });
 
-    test('Presses that settle on the current state produce no commands at all', async () => {
+    test('CLOSE while closing (state 13) also uses stop-before-close', () => {
         const { instance, device } = makeSimpleGarage();
-        instance.currentDoorState = CDS.OPEN;
+        instance.stopBeforeCloseMs = 1500;
+        device.state['105'] = STATE_CLOSING_OR_CLOSED;
 
         instance.setTargetDoorState(TDS.CLOSED);
-        await jest.advanceTimersByTimeAsync(200);
-        instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(200);
-        instance.setTargetDoorState(TDS.CLOSED);
-        await jest.advanceTimersByTimeAsync(200);
-        instance.setTargetDoorState(TDS.OPEN);
+        expect(device.update).toHaveBeenNthCalledWith(1, { '103': true });
 
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        // Final target matches current — no work to do.
-        expect(device.update).not.toHaveBeenCalled();
-        expect(instance.worker).toBeNull();
+        jest.advanceTimersByTime(1500);
+        expect(device.update).toHaveBeenNthCalledWith(2, { '102': true });
     });
 
-    test('Reverting to current while a worker is running suppresses the direction command', async () => {
+    test('CLOSE with no reported state yet uses stop-before-close', () => {
         const { instance, device } = makeSimpleGarage();
-        instance.currentDoorState = CDS.OPEN;
+        instance.stopBeforeCloseMs = 1500;
+        // device.state['105'] intentionally left undefined
 
         instance.setTargetDoorState(TDS.CLOSED);
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
+        expect(device.update).toHaveBeenNthCalledWith(1, { '103': true });
 
-        // User reverts mid-stop.
-        instance.setTargetDoorState(TDS.OPEN);
-
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        // Only stop went out — no direction, because target reverted to OPEN.
-        expect(device.update).toHaveBeenCalledTimes(1);
-        expect(instance.worker).toBeNull();
-        expect(instance.scheduleTimer).toBeNull();
+        jest.advanceTimersByTime(1500);
+        expect(device.update).toHaveBeenNthCalledWith(2, { '102': true });
     });
 
-    test('Pressing the opposite during the direction wait triggers a follow-up cycle after the debounce', async () => {
+    test('A duplicate CLOSE during the wait does not restart or double-fire', () => {
         const { instance, device } = makeSimpleGarage();
-        instance.currentDoorState = CDS.OPEN;
-        instance.characteristicCurrentDoorState.value = CDS.OPEN;
+        instance.stopBeforeCloseMs = 1500;
+        device.state['105'] = STATE_OPENING_OR_OPEN;
 
         instance.setTargetDoorState(TDS.CLOSED);
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '3': true });
+        expect(device.update).toHaveBeenCalledTimes(1); // stop
 
-        // User reverses while close is in flight.
-        instance.setTargetDoorState(TDS.OPEN);
-        emitReset(device, '3');
-        await jest.advanceTimersByTimeAsync(0);
-        // Close reset flipped UI to CLOSED. Worker exited, finally queued
-        // another cycle behind the debounce.
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.CLOSED);
+        jest.advanceTimersByTime(1000);
+        instance.setTargetDoorState(TDS.CLOSED); // retransmit / second tap
+        expect(device.update).toHaveBeenCalledTimes(1); // no extra stop, timer not pushed out
+
+        jest.advanceTimersByTime(500);
         expect(device.update).toHaveBeenCalledTimes(2);
+        expect(device.update).toHaveBeenNthCalledWith(2, { '102': true });
+    });
 
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        expect(device.update).toHaveBeenNthCalledWith(3, { '2': true });
+    test('OPEN during the wait cancels the pending close and opens instead', () => {
+        const { instance, device } = makeSimpleGarage();
+        instance.stopBeforeCloseMs = 1500;
+        device.state['105'] = STATE_OPENING_OR_OPEN;
 
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(4, { '1': true });
+        instance.setTargetDoorState(TDS.CLOSED);
+        expect(device.update).toHaveBeenNthCalledWith(1, { '103': true }); // stop
 
-        emitReset(device, '1');
-        await jest.advanceTimersByTimeAsync(0);
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
-        expect(instance.worker).toBeNull();
+        jest.advanceTimersByTime(500);
+        instance.setTargetDoorState(TDS.OPEN);
+        expect(instance.pendingCloseTimer).toBeNull();
+        expect(device.update).toHaveBeenNthCalledWith(2, { '101': true }); // open
+
+        // The trailing close must never fire.
+        jest.advanceTimersByTime(5000);
+        expect(device.update).toHaveBeenCalledTimes(2);
     });
 
-    test('Only one worker is active at a time across rapid toggles', async () => {
-        const { instance, device } = makeSimpleGarage();
+    test('Status reports are ignored during the stop-before-close window', () => {
+        const { instance, device, accessory } = makeSimpleGarage();
+        instance.stopBeforeCloseMs = 1500;
+        device.state['105'] = STATE_OPENING_OR_OPEN;
         instance.currentDoorState = CDS.OPEN;
+        instance.characteristicCurrentDoorState.value = CDS.OPEN;
 
         instance.setTargetDoorState(TDS.CLOSED);
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        const workerA = instance.worker;
-        expect(workerA).not.toBeNull();
+        expect(accessory.context.cachedTargetDoorState).toBe(TDS.CLOSED);
 
-        instance.setTargetDoorState(TDS.OPEN);
-        instance.setTargetDoorState(TDS.CLOSED);
-        expect(instance.worker).toBe(workerA);
+        // The stop makes the controller momentarily report 11 (=OPEN). That
+        // must be ignored, or it would bounce Target back to OPEN mid-close.
+        emitState(device, STATE_STOPPED);
+        expect(accessory.context.cachedTargetDoorState).toBe(TDS.CLOSED);
+        expect(instance.currentDoorState).toBe(CDS.OPEN);
 
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        emitReset(device, '3');
-        await jest.advanceTimersByTimeAsync(0);
-        expect(instance.worker).toBeNull();
+        // Close fires, then the controller reports 13 and we resume mirroring.
+        jest.advanceTimersByTime(1500);
+        expect(device.update).toHaveBeenNthCalledWith(2, { '102': true });
+        emitState(device, STATE_CLOSING_OR_CLOSED);
+        expect(instance.currentDoorState).toBe(CDS.CLOSED);
+        expect(accessory.context.cachedTargetDoorState).toBe(TDS.CLOSED);
     });
-});
-
-// ---------------------------------------------------------------------------
-// Timeout fallbacks
-// ---------------------------------------------------------------------------
-describe('SimpleGarageDoorAccessory — timeout fallbacks', () => {
-    beforeEach(() => jest.useFakeTimers());
-    afterEach(() => jest.useRealTimers());
 
-    test('Falls back to sending the direction after STOP_RESET_TIMEOUT_MS if no echo arrives', async () => {
+    test('stopBeforeCloseMs is configurable', () => {
         const { instance, device } = makeSimpleGarage();
-        instance.currentDoorState = CDS.CLOSED;
-
-        instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        expect(device.update).toHaveBeenCalledTimes(1);
+        instance.stopBeforeCloseMs = 300;
+        device.state['105'] = STATE_OPENING_OR_OPEN;
 
-        await jest.advanceTimersByTimeAsync(STOP_RESET_TIMEOUT_MS + POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '1': true });
+        instance.setTargetDoorState(TDS.CLOSED);
+        expect(device.update).toHaveBeenNthCalledWith(1, { '103': true });
 
-        emitReset(device, '1');
-        await jest.advanceTimersByTimeAsync(0);
-        expect(instance.worker).toBeNull();
+        jest.advanceTimersByTime(299);
+        expect(device.update).toHaveBeenCalledTimes(1);
+        jest.advanceTimersByTime(1);
+        expect(device.update).toHaveBeenNthCalledWith(2, { '102': true });
     });
 
-    test('Worker exits and force-flips CurrentDoorState after DIRECTION_RESET_TIMEOUT_MS when the echo is missed', async () => {
+    test('Custom stop/close DPs are respected in the stop-before-close path', () => {
         const { instance, device } = makeSimpleGarage();
-        instance.currentDoorState = CDS.CLOSED;
-        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
+        instance.dpClose = '2';
+        instance.dpStop = '4';
+        instance.stopBeforeCloseMs = 1000;
+        device.state['105'] = STATE_OPENING_OR_OPEN;
 
-        instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '1': true });
+        instance.setTargetDoorState(TDS.CLOSED);
+        expect(device.update).toHaveBeenNthCalledWith(1, { '4': true });
 
-        await jest.advanceTimersByTimeAsync(DIRECTION_RESET_TIMEOUT_MS);
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
-        expect(instance.worker).toBeNull();
+        jest.advanceTimersByTime(1000);
+        expect(device.update).toHaveBeenNthCalledWith(2, { '2': true });
     });
 });
 
@@ -396,18 +373,12 @@ describe('SimpleGarageDoorAccessory — timeout fallbacks', () => {
 // Disconnect handling
 // ---------------------------------------------------------------------------
 describe('SimpleGarageDoorAccessory — disconnected', () => {
-    beforeEach(() => jest.useFakeTimers());
-    afterEach(() => jest.useRealTimers());
-
-    test('Skips writes when the device is disconnected', async () => {
+    test('Skips writes when the device is disconnected', () => {
         const { instance, device } = makeSimpleGarage();
         device.connected = false;
-        instance.currentDoorState = CDS.CLOSED;
 
         instance.setTargetDoorState(TDS.OPEN);
-        await jest.advanceTimersByTimeAsync(
-            SETTLE_MS + STOP_RESET_TIMEOUT_MS + POST_RESET_DELAY_MS + DIRECTION_RESET_TIMEOUT_MS
-        );
+
         expect(device.update).not.toHaveBeenCalled();
     });
 });
@@ -416,400 +387,149 @@ describe('SimpleGarageDoorAccessory — disconnected', () => {
 // Persistence
 // ---------------------------------------------------------------------------
 describe('SimpleGarageDoorAccessory persistence', () => {
-    beforeEach(() => jest.useFakeTimers());
-    afterEach(() => jest.useRealTimers());
-
-    test('Stores the latest target on the accessory context', async () => {
+    test('Stores the latest target on the accessory context', () => {
         const { instance, device, accessory } = makeSimpleGarage();
-        instance.currentDoorState = CDS.OPEN;
-
-        instance.setTargetDoorState(TDS.CLOSED);
-        expect(accessory.context.cachedTargetDoorState).toBe(TDS.CLOSED);
+        // Already stopped, so the close fires immediately (no dangling timer).
+        device.state['105'] = STATE_STOPPED;
 
         instance.setTargetDoorState(TDS.OPEN);
         expect(accessory.context.cachedTargetDoorState).toBe(TDS.OPEN);
 
-        // Drain so any spawned worker resolves cleanly.
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        if (device.update.mock.calls.length > 0) {
-            emitReset(device, '2');
-            await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        }
+        instance.setTargetDoorState(TDS.CLOSED);
+        expect(accessory.context.cachedTargetDoorState).toBe(TDS.CLOSED);
     });
 });
 
 // ---------------------------------------------------------------------------
-// Partial-open switch
+// Partial open
 // ---------------------------------------------------------------------------
 describe('SimpleGarageDoorAccessory._handlePartialOpen', () => {
     beforeEach(() => jest.useFakeTimers());
     afterEach(() => jest.useRealTimers());
 
-    test('Opens the gate, waits partialOpenMs after current=OPEN, then sends a raw STOP', async () => {
+    test('Fires open, then fires stop after partialOpenMs', () => {
         const { instance, device } = makeSimpleGarage();
         instance.partialOpenMs = 2000;
-        instance.currentDoorState = CDS.CLOSED;
-        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
-        instance.desiredTarget = TDS.CLOSED;
 
         instance._handlePartialOpen();
 
-        // Open cycle is queued through the regular debounce + worker.
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '1': true });
-
-        // Until the open echo lands the stop timer is not scheduled.
-        // (Stay short of DIRECTION_RESET_TIMEOUT_MS so the belt-and-braces
-        // current-state flip doesn't run yet.)
-        await jest.advanceTimersByTimeAsync(1000);
-        expect(device.update).toHaveBeenCalledTimes(2);
+        // Open goes out immediately.
+        expect(device.update).toHaveBeenCalledTimes(1);
+        expect(device.update).toHaveBeenNthCalledWith(1, { '101': true });
+        expect(instance.characteristicTargetDoorState.value).toBe(TDS.OPEN);
 
-        // Open echo flips CurrentDoorState, partial-open flow then starts
-        // its 2 s timer.
-        emitReset(device, '1');
-        await jest.advanceTimersByTimeAsync(0);
-        expect(instance.currentDoorState).toBe(CDS.OPEN);
+        // Nothing happens until the timer elapses.
+        jest.advanceTimersByTime(2000 - 1);
+        expect(device.update).toHaveBeenCalledTimes(1);
 
-        await jest.advanceTimersByTimeAsync(2000 - 1);
+        // Then a single stop is fired.
+        jest.advanceTimersByTime(1);
         expect(device.update).toHaveBeenCalledTimes(2);
+        expect(device.update).toHaveBeenNthCalledWith(2, { '103': true });
 
-        // Timer fires: raw STOP write goes straight to the device, no queue,
-        // no debounce, no follow-up direction. The stop is re-sent a few
-        // times spread over ~1.2 s to defend against dropped writes.
-        await jest.advanceTimersByTimeAsync(1);
-        expect(device.update).toHaveBeenCalledTimes(3);
-        expect(device.update).toHaveBeenNthCalledWith(3, { '2': true });
-
-        await jest.advanceTimersByTimeAsync(1200);
-        expect(device.update).toHaveBeenCalledTimes(6);
-        expect(device.update).toHaveBeenNthCalledWith(4, { '2': true });
-        expect(device.update).toHaveBeenNthCalledWith(5, { '2': true });
-        expect(device.update).toHaveBeenNthCalledWith(6, { '2': true });
-
-        await jest.advanceTimersByTimeAsync(10_000);
-        expect(device.update).toHaveBeenCalledTimes(6);
-        // Gate is now partially open — CurrentDoorState stays OPEN.
-        expect(instance.currentDoorState).toBe(CDS.OPEN);
+        // And nothing more after that.
+        jest.advanceTimersByTime(10_000);
+        expect(device.update).toHaveBeenCalledTimes(2);
+        expect(instance.partialStopTimer).toBeNull();
     });
 
-    test('Sends only the raw STOP if the gate is already OPEN', async () => {
+    test('Re-entrant press while armed is ignored (idempotent)', () => {
         const { instance, device } = makeSimpleGarage();
         instance.partialOpenMs = 2000;
-        instance.currentDoorState = CDS.OPEN;
 
         instance._handlePartialOpen();
-
-        await jest.advanceTimersByTimeAsync(0);
-        // No open cycle needed — desiredTarget==current already.
-        expect(device.update).not.toHaveBeenCalled();
-
-        await jest.advanceTimersByTimeAsync(2000);
-        // Four stop sends spread over ~1.2 s; first one fires immediately at
-        // partialOpenMs.
         expect(device.update).toHaveBeenCalledTimes(1);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
-        await jest.advanceTimersByTimeAsync(1200);
-        expect(device.update).toHaveBeenCalledTimes(4);
-    });
-
-    test('Pressing partial again while the stop timer is armed is ignored (idempotent)', async () => {
-        // HomeKit/iOS retransmit a WRITE if the 204 response is delayed or
-        // dropped, which fires onSet again. The retry must not cancel the
-        // armed stop and push it out — otherwise repeated retries can
-        // delay the auto-stop indefinitely and the gate runs all the way
-        // open. The retry should be ignored; the original timer fires at
-        // its original deadline.
-        const { instance, device } = makeSimpleGarage();
-        instance.partialOpenMs = 2000;
-        instance.currentDoorState = CDS.OPEN;
-
-        instance._handlePartialOpen();
-        await jest.advanceTimersByTimeAsync(0);
-
-        await jest.advanceTimersByTimeAsync(1500);
-        // 1.5 s in, retry — should be ignored.
-        instance._handlePartialOpen();
-        await jest.advanceTimersByTimeAsync(0);
-        expect(device.update).not.toHaveBeenCalled();
-
-        // Original timer fires at the original 2000 ms deadline.
-        await jest.advanceTimersByTimeAsync(499);
-        expect(device.update).not.toHaveBeenCalled();
-
-        await jest.advanceTimersByTimeAsync(1);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
-    });
-
-    test('Pressing partial again while the open wait is pending is ignored (idempotent)', async () => {
-        const { instance, device } = makeSimpleGarage();
-        instance.partialOpenMs = 2000;
-        instance.currentDoorState = CDS.CLOSED;
-        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
-        instance.desiredTarget = TDS.CLOSED;
-
-        instance._handlePartialOpen();
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
-
-        // Retry lands while we're still waiting for the stop reset / open
-        // echo. The retry should not bump the generation token or restart
-        // anything — the original flow should complete normally.
-        const idBefore = instance.partialOpenId;
-        instance._handlePartialOpen();
-        expect(instance.partialOpenId).toBe(idBefore);
-
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        emitReset(device, '1');
-        await jest.advanceTimersByTimeAsync(0);
-
-        await jest.advanceTimersByTimeAsync(2000);
-        expect(device.update).toHaveBeenNthCalledWith(3, { '2': true });
-    });
-
-    test('A same-value setTargetDoorState while the partial stop is armed does not cancel it', async () => {
-        // HomeKit / iOS Home may write TargetDoorState=OPEN back to the
-        // accessory after observing CurrentDoorState flip to OPEN (a
-        // resync). desiredTarget is already OPEN from the partial flow's
-        // own _setTarget, so this is a no-op write — but the public
-        // setTargetDoorState path would still cancel the armed partial
-        // stop and the auto-stop would never fire, leaving the gate to
-        // run all the way open. The no-op write should be ignored.
-        const { instance, device } = makeSimpleGarage();
-        instance.partialOpenMs = 2000;
-        instance.currentDoorState = CDS.CLOSED;
-        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
-        instance.desiredTarget = TDS.CLOSED;
-
-        instance._handlePartialOpen();
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        emitReset(device, '1');
-        await jest.advanceTimersByTimeAsync(0);
-        expect(instance.partialStopTimer).not.toBeNull();
-
-        // Simulate the HomeKit-side resync write.
-        instance.setTargetDoorState(TDS.OPEN);
-        expect(instance.partialStopTimer).not.toBeNull();
-
-        await jest.advanceTimersByTimeAsync(2000);
-        expect(device.update).toHaveBeenNthCalledWith(3, { '2': true });
-    });
-
-    test('A same-value setTargetDoorState during the open wait does not supersede the partial flow', async () => {
-        const { instance, device } = makeSimpleGarage();
-        instance.partialOpenMs = 2000;
-        instance.currentDoorState = CDS.CLOSED;
-        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
-        instance.desiredTarget = TDS.CLOSED;
 
+        // A retransmit 1.5s in must not re-open or push the stop out.
+        jest.advanceTimersByTime(1500);
         instance._handlePartialOpen();
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
-
-        // HomeKit pushes a TargetDoorState=OPEN write mid-cycle. The partial
-        // flow's _setTarget already set desiredTarget=OPEN, so this is
-        // redundant — it should not disturb the in-flight partial.
-        const idBefore = instance.partialOpenId;
-        instance.setTargetDoorState(TDS.OPEN);
-        expect(instance.partialOpenId).toBe(idBefore);
-        expect(instance._partialPending).toBe(true);
-
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        emitReset(device, '1');
-        await jest.advanceTimersByTimeAsync(0);
+        expect(device.update).toHaveBeenCalledTimes(1);
 
-        await jest.advanceTimersByTimeAsync(2000);
-        expect(device.update).toHaveBeenNthCalledWith(3, { '2': true });
+        // Original timer still fires at its original 2000ms deadline.
+        jest.advanceTimersByTime(499);
+        expect(device.update).toHaveBeenCalledTimes(1);
+        jest.advanceTimersByTime(1);
+        expect(device.update).toHaveBeenNthCalledWith(2, { '103': true });
     });
 
-    test('External setTargetDoorState with a different target cancels the armed auto-stop', async () => {
+    test('A direct close cancels the partial auto-stop and runs stop-before-close', () => {
         const { instance, device } = makeSimpleGarage();
         instance.partialOpenMs = 2000;
-        instance.currentDoorState = CDS.CLOSED;
-        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
-        instance.desiredTarget = TDS.CLOSED;
+        instance.stopBeforeCloseMs = 1500;
+        device.state['105'] = STATE_OPENING_OR_OPEN; // gate is moving during the partial
 
         instance._handlePartialOpen();
-
-        // Run the open cycle.
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        emitReset(device, '1');
-        await jest.advanceTimersByTimeAsync(0);
-        expect(instance.currentDoorState).toBe(CDS.OPEN);
         expect(instance.partialStopTimer).not.toBeNull();
+        expect(device.update).toHaveBeenNthCalledWith(1, { '101': true }); // open
 
-        // Stop timer is now armed (fires in 2 s). User toggles to a real
-        // different target (CLOSED) — auto-stop should be cancelled.
-        await jest.advanceTimersByTimeAsync(500);
+        // User closes before the partial auto-stop fires.
+        jest.advanceTimersByTime(500);
         instance.setTargetDoorState(TDS.CLOSED);
-        expect(instance.partialStopTimer).toBeNull();
-    });
+        expect(instance.partialStopTimer).toBeNull(); // partial auto-stop cancelled
+        expect(device.update).toHaveBeenNthCalledWith(2, { '103': true }); // stop-before-close stop
 
-    test('External setTargetDoorState with a different target during the open wait supersedes the partial flow', async () => {
-        const { instance, device } = makeSimpleGarage();
-        instance.partialOpenMs = 2000;
-        instance.currentDoorState = CDS.CLOSED;
-        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
-        instance.desiredTarget = TDS.CLOSED;
+        jest.advanceTimersByTime(1500);
+        expect(device.update).toHaveBeenNthCalledWith(3, { '102': true }); // close
 
-        instance._handlePartialOpen();
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        emitReset(device, '1');
-        // Before the loop notices and arms the stop timer, the user toggles
-        // to a real different target (CLOSED — the partial intended OPEN).
-        instance.setTargetDoorState(TDS.CLOSED);
-        await jest.advanceTimersByTimeAsync(0);
-
-        // partialOpenId got bumped — the partial flow's wait returns silently.
-        expect(instance.partialStopTimer).toBeNull();
+        // The cancelled partial stop never fires a stray write.
+        jest.advanceTimersByTime(5000);
+        expect(device.update).toHaveBeenCalledTimes(3);
     });
 
-    test('Does nothing when partialOpenMs is not configured', async () => {
+    test('Does nothing when partialOpenMs is not configured', () => {
         const { instance, device } = makeSimpleGarage();
         instance.partialOpenMs = 0;
-        instance.currentDoorState = CDS.OPEN;
 
         instance._handlePartialOpen();
-        await jest.advanceTimersByTimeAsync(10_000);
+        jest.advanceTimersByTime(10_000);
 
         expect(device.update).not.toHaveBeenCalled();
         expect(instance.partialStopTimer).toBeNull();
     });
 });
 
-// ---------------------------------------------------------------------------
-// Force open/close switches (just verify they route through setTargetDoorState
-// — the queue/debounce behaviour is already covered by the earlier suites)
-// ---------------------------------------------------------------------------
-describe('SimpleGarageDoorAccessory — force switches', () => {
-    beforeEach(() => jest.useFakeTimers());
-    afterEach(() => jest.useRealTimers());
-
-    test('Force Open routes through the public setTargetDoorState path', async () => {
-        const { instance, device, accessory } = makeSimpleGarage();
-        instance.currentDoorState = CDS.CLOSED;
-        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
-        instance.desiredTarget = TDS.CLOSED;
-
-        instance.setTargetDoorState(TDS.OPEN);
-        expect(accessory.context.cachedTargetDoorState).toBe(TDS.OPEN);
-        expect(instance.desiredTarget).toBe(TDS.OPEN);
-
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '1': true });
-        emitReset(device, '1');
-        await jest.advanceTimersByTimeAsync(0);
-        expect(instance.currentDoorState).toBe(CDS.OPEN);
-    });
-
-    test('Force Close routes through the public setTargetDoorState path', async () => {
-        const { instance, device, accessory } = makeSimpleGarage();
-        instance.currentDoorState = CDS.OPEN;
-
-        instance.setTargetDoorState(TDS.CLOSED);
-        expect(accessory.context.cachedTargetDoorState).toBe(TDS.CLOSED);
-
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '3': true });
-        emitReset(device, '3');
-        await jest.advanceTimersByTimeAsync(0);
-        expect(instance.currentDoorState).toBe(CDS.CLOSED);
-    });
-
-    test('A force action with a different target cancels the in-flight partial', async () => {
-        const { instance, device } = makeSimpleGarage();
-        instance.partialOpenMs = 2000;
-        instance.currentDoorState = CDS.OPEN;
-        instance.characteristicCurrentDoorState.value = CDS.OPEN;
-
-        // Partial press while already open: just schedules the stop timer.
-        instance._handlePartialOpen();
-        await jest.advanceTimersByTimeAsync(0);
-        expect(instance.partialStopTimer).not.toBeNull();
-
-        // Force Close pressed before the auto-stop fires. The different
-        // target indicates a real user override — cancel the partial.
-        instance.setTargetDoorState(TDS.CLOSED);
-        expect(instance.partialStopTimer).toBeNull();
-
-        // The new target (CLOSED) is acted on through the regular queue.
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
-    });
-});
-
 // ---------------------------------------------------------------------------
 // Partial-open switch is stateful: mirrors CurrentDoorState (ON when the gate
-// is open) and toggling it OFF triggers a standard close cycle.
+// is open) via the status DP.
 // ---------------------------------------------------------------------------
 describe('SimpleGarageDoorAccessory — partial-open switch state', () => {
-    beforeEach(() => jest.useFakeTimers());
-    afterEach(() => jest.useRealTimers());
-
-    test('_setCurrentDoorState mirrors OPEN/CLOSED to the switch', () => {
+    test('Reported OPEN/CLOSED is mirrored onto the switch', () => {
         const { instance } = makeSimpleGarage();
         instance.partialOpenMs = 2000;
-        instance.currentDoorState = CDS.CLOSED;
         instance.characteristicPartialOpen.value = false;
 
-        instance._setCurrentDoorState(CDS.OPEN);
+        instance._onDeviceChange({ '105': STATE_OPENING_OR_OPEN });
         expect(instance.characteristicPartialOpen.value).toBe(true);
 
-        instance._setCurrentDoorState(CDS.CLOSED);
+        instance._onDeviceChange({ '105': STATE_CLOSING_OR_CLOSED });
         expect(instance.characteristicPartialOpen.value).toBe(false);
+
+        // A stop mid-travel (state 11) leaves the gate parked open.
+        instance._onDeviceChange({ '105': STATE_STOPPED });
+        expect(instance.characteristicPartialOpen.value).toBe(true);
     });
+});
 
-    test('After the partial open cycle the switch reads ON', async () => {
-        const { instance, device } = makeSimpleGarage();
-        instance.partialOpenMs = 2000;
-        instance.currentDoorState = CDS.CLOSED;
-        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
-        instance.characteristicPartialOpen.value = false;
-        instance.desiredTarget = TDS.CLOSED;
+// ---------------------------------------------------------------------------
+// Force open/close switches route through setTargetDoorState
+// ---------------------------------------------------------------------------
+describe('SimpleGarageDoorAccessory — force switches', () => {
+    test('Force Open fires the open action', () => {
+        const { instance, device, accessory } = makeSimpleGarage();
 
-        instance._handlePartialOpen();
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        emitReset(device, '1');
-        await jest.advanceTimersByTimeAsync(0);
+        instance.setTargetDoorState(TDS.OPEN);
 
-        expect(instance.currentDoorState).toBe(CDS.OPEN);
-        expect(instance.characteristicPartialOpen.value).toBe(true);
+        expect(device.update).toHaveBeenCalledWith({ '101': true });
+        expect(accessory.context.cachedTargetDoorState).toBe(TDS.OPEN);
     });
 
-    test('A subsequent close cycle flips the switch back to OFF', async () => {
-        const { instance, device } = makeSimpleGarage();
-        instance.partialOpenMs = 2000;
-        instance.currentDoorState = CDS.OPEN;
-        instance.characteristicCurrentDoorState.value = CDS.OPEN;
-        instance.characteristicPartialOpen.value = true;
+    test('Force Close fires the close action (immediately when already stopped)', () => {
+        const { instance, device, accessory } = makeSimpleGarage();
+        device.state['105'] = STATE_STOPPED;
 
-        // Simulate the user tapping the switch OFF — close cycle queued.
         instance.setTargetDoorState(TDS.CLOSED);
-        await jest.advanceTimersByTimeAsync(SETTLE_MS);
-        emitReset(device, '2');
-        await jest.advanceTimersByTimeAsync(POST_RESET_DELAY_MS);
-        expect(device.update).toHaveBeenNthCalledWith(2, { '3': true });
-        emitReset(device, '3');
-        await jest.advanceTimersByTimeAsync(0);
 
-        expect(instance.currentDoorState).toBe(CDS.CLOSED);
-        expect(instance.characteristicPartialOpen.value).toBe(false);
+        expect(device.update).toHaveBeenCalledWith({ '102': true });
+        expect(accessory.context.cachedTargetDoorState).toBe(TDS.CLOSED);
     });
 });