@marcel2215/homebridge-supla-plugin 2.1.24 → 2.1.26

package/dist/Accesories/GateAccessory.js

@@ -1,25 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GateAccessory = void 0;
+const FrontGateFsm_1 = require("./FrontGateFsm");
 class GateAccessory {
     constructor(platform, accessory, context) {
         this.platform = platform;
         this.accessory = accessory;
         this.context = context;
-        this.currentState = this.platform.Characteristic.CurrentDoorState.CLOSED;
-        this.targetState = this.platform.Characteristic.TargetDoorState.CLOSED;
-        this.connected = true;
-        this.obstructionDetected = false;
-        this.isClosedSensorActive = false;
-        this.isPartialSensorActive = false;
-        this.hasClosedSensorState = false;
-        this.hasPartialSensorState = false;
-        this.transitionTimeoutMs = 60000;
-        this.lastCommandAt = 0;
-        this.duplicateSetWindowMs = 350;
-        this.sawPartialMotionDuringPending = false;
-        this.lastClosedReleaseAt = 0;
-        this.externalDirectionHintWindowMs = 2500;
         this.accessory.getService(this.platform.Service.AccessoryInformation)
             .setCharacteristic(this.platform.Characteristic.Manufacturer, 'Supla')
             .setCharacteristic(this.platform.Characteristic.Model, 'GateController');
@@ -30,6 +17,19 @@ class GateAccessory {
         this.service = this.accessory.getService(this.platform.Service.GarageDoorOpener)
             || this.accessory.addService(this.platform.Service.GarageDoorOpener);
         this.service.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
+        this.controlBaseTopic = this.platform.normalizeTopicBase(this.context.topic);
+        this.sensorBaseTopic = this.resolveSensorBaseTopic();
+        // Remove stale persisted direction state from the previous implementation.
+        delete this.accessory.context.frontGateFsm;
+        this.fsm = new FrontGateFsm_1.FrontGateFsm({
+            pulseMotor: async (reason) => this.publishPulse(reason),
+            publishSnapshot: (snapshot) => this.applySnapshot(snapshot),
+            log: {
+                debug: (message) => this.platform.log.debug(`[FrontGate ${this.accessory.displayName}] ${message}`),
+                info: (message) => this.platform.log.info(`[FrontGate ${this.accessory.displayName}] ${message}`),
+                warn: (message) => this.platform.log.warn(`[FrontGate ${this.accessory.displayName}] ${message}`),
+            },
+        }, this.platform.getFrontGateTimings(), {});
         this.service.getCharacteristic(this.platform.Characteristic.CurrentDoorState)
             .onGet(this.handleCurrentDoorStateGet.bind(this));
         this.service.getCharacteristic(this.platform.Characteristic.TargetDoorState)
@@ -37,659 +37,284 @@ class GateAccessory {
             .onSet(this.handleTargetDoorStateSet.bind(this));
         this.service.getCharacteristic(this.platform.Characteristic.ObstructionDetected)
             .onGet(this.handleObstructionDetectedGet.bind(this));
-        this.service.setCharacteristic(this.platform.Characteristic.ObstructionDetected, false);
+        this.service.updateCharacteristic(this.platform.Characteristic.ObstructionDetected, false);
         this.platform.registerOwnerCleanup(this.accessory.UUID, () => {
-            this.clearTransitionTimer();
-            this.clearReverseToggleTimer();
-            this.clearOpenArrivalDebounceTimer();
-            this.clearPublishRetryTimer();
+            this.fsm.dispose();
         });
-        this.partialHiMode = this.platform.getGatePartialHiMode();
-        this.baseTopic = this.platform.normalizeTopicBase(this.context.topic);
-        this.reverseToggleDelayMs = this.platform.getGateReverseFollowUpDelayMs();
-        this.openArrivalDebounceMs = this.platform.getGateOpenAssumeDelayMs();
-        this.commandCooldownMs = this.platform.getGateCommandCooldownMs();
-        this.publishRetryDelayMs = this.platform.getGatePublishRetryDelayMs();
-        this.strictReverseDoublePulse = this.platform.getGateStrictReverseDoublePulse();
-        this.debugTimeline = this.platform.getGateDebugTimeline();
-        this.platform.registerMqttHandler(`${this.baseTopic}/state/hi`, (message) => {
-            const previous = this.hasClosedSensorState ? this.isClosedSensorActive : undefined;
-            const next = this.platform.parseBoolean(message.toString());
-            const changed = !this.hasClosedSensorState || next !== this.isClosedSensorActive;
-            if (previous === true && next === false) {
-                this.lastClosedReleaseAt = Date.now();
-            }
-            else if (next) {
-                this.lastClosedReleaseAt = 0;
-            }
-            this.isClosedSensorActive = next;
-            this.hasClosedSensorState = true;
-            this.updateStatesFromSensors({
-                closedPrevious: changed ? previous : undefined,
-            });
+        this.platform.registerMqttHandler(`${this.controlBaseTopic}/state/connected`, (message) => {
+            this.fsm.handleControlConnectedChange(this.platform.parseBoolean(message.toString()));
         }, this.accessory.UUID);
-        this.platform.registerMqttHandler(`${this.baseTopic}/state/partial_hi`, (message) => {
-            const previous = this.hasPartialSensorState ? this.isPartialSensorActive : undefined;
-            const next = this.platform.parseBoolean(message.toString());
-            const changed = !this.hasPartialSensorState || next !== this.isPartialSensorActive;
-            if (previous === true && next === false) {
-                this.lastClosedReleaseAt = 0;
-            }
-            this.isPartialSensorActive = next;
-            this.hasPartialSensorState = true;
-            if (this.pendingTarget !== undefined && this.isPartialSensorActive) {
-                this.sawPartialMotionDuringPending = true;
-            }
-            this.updateStatesFromSensors({
-                partialPrevious: changed ? previous : undefined,
-            });
+        this.platform.registerMqttHandler(`${this.sensorBaseTopic}/state/connected`, (message) => {
+            this.fsm.handleSensorConnectedChange(this.platform.parseBoolean(message.toString()));
         }, this.accessory.UUID);
-        this.platform.registerMqttHandler(`${this.baseTopic}/state/connected`, (message) => {
-            this.connected = this.platform.parseBoolean(message.toString());
-            this.updateStatusFault();
-            if (!this.connected) {
-                this.setPendingTarget(undefined);
-                this.clearTransitionTimer();
-                this.clearReverseToggleTimer();
-                this.clearOpenArrivalDebounceTimer();
-                this.clearPublishRetryTimer();
-            }
+        this.platform.registerMqttHandler(`${this.sensorBaseTopic}/state/hi`, (message) => {
+            this.fsm.handleClosedSensorChange(this.platform.parseBoolean(message.toString()));
         }, this.accessory.UUID);
-        this.updateStatusFault();
+        this.applySnapshot(this.fsm.getSnapshot());
     }
     async handleCurrentDoorStateGet() {
-        return this.currentState;
+        const snapshot = this.fsm.getSnapshot();
+        if (!snapshot.available || snapshot.currentDoorState === undefined) {
+            throw this.createCommunicationError();
+        }
+        return snapshot.currentDoorState;
     }
     async handleTargetDoorStateGet() {
-        return this.targetState;
+        const snapshot = this.fsm.getSnapshot();
+        if (!snapshot.available || snapshot.targetDoorState === undefined) {
+            throw this.createCommunicationError();
+        }
+        return snapshot.targetDoorState;
     }
     async handleTargetDoorStateSet(value) {
-        const requestedTarget = value;
-        const mode = this.platform.getGateControlMode();
-        const motionTarget = this.getMotionTarget();
-        const isMoving = motionTarget !== undefined;
-        let target = requestedTarget;
-        this.logGateTimeline('set-request', {
-            requested: this.describeTargetState(requestedTarget),
-            motion: this.describeTargetState(motionTarget),
-            mode,
-        });
-        if (isMoving && motionTarget !== undefined && requestedTarget === motionTarget) {
-            if (this.isLikelyDuplicateSet(requestedTarget)) {
-                this.logGateTimeline('set-ignored-duplicate', {
-                    requested: this.describeTargetState(requestedTarget),
-                });
-                return;
-            }
-            target = this.oppositeTarget(requestedTarget);
-        }
-        const previousTarget = this.targetState;
-        this.setTargetState(target);
-        this.clearReverseToggleTimer();
-        this.clearPublishRetryTimer();
-        if (!this.connected) {
-            this.platform.log.warn(`Gate ${this.accessory.displayName} is offline; ignoring command.`);
-            this.setTargetState(previousTarget);
-            this.updateStatusFault();
-            this.logGateTimeline('set-ignored-offline', {
-                requested: this.describeTargetState(requestedTarget),
-            });
-            return;
-        }
-        if (!isMoving && this.isAtTarget(target)) {
-            this.logGateTimeline('set-ignored-at-target', {
-                target: this.describeTargetState(target),
-            });
-            return;
-        }
-        if (this.pendingTarget === target) {
-            this.logGateTimeline('set-ignored-pending', {
-                target: this.describeTargetState(target),
-            });
-            return;
-        }
-        if (this.isCommandInCooldown(target, motionTarget)) {
-            this.setTargetState(previousTarget);
-            this.logGateTimeline('set-ignored-cooldown', {
-                target: this.describeTargetState(target),
-                cooldownMs: this.commandCooldownMs,
-            });
-            return;
-        }
-        let action = '';
-        if (mode === 'toggle') {
-            action = this.platform.getGateExecuteActionToggle();
-        }
-        else {
-            action = target === this.platform.Characteristic.TargetDoorState.OPEN
-                ? this.platform.getGateExecuteActionOpen()
-                : this.platform.getGateExecuteActionClose();
-        }
-        if (!action) {
-            this.platform.log.warn(`Gate action not configured for ${this.accessory.displayName}`);
-            this.setTargetState(previousTarget);
-            return;
+        const target = Number(value) === 0 /* DoorTargetState.OPEN */ ? 'open' : 'closed';
+        try {
+            await this.fsm.requestHomeKitTarget(target);
         }
-        const isReversing = motionTarget !== undefined && motionTarget !== target;
-        this.publishGateAction(action, isReversing ? 'reverse' : undefined, target);
-        if (isReversing && this.shouldScheduleReverseFollowUp(mode)) {
-            this.scheduleReverseToggle(action, target, mode);
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.platform.log.warn(`Gate ${this.accessory.displayName} command failed: ${message}`);
+            throw this.createCommunicationError();
         }
-        this.clearFaults();
-        this.setPendingTarget(target);
-        this.markCommand(target);
-        this.armTransitionTimer();
-        this.setCurrentState(this.resolveMovingState(target));
-        this.logGateTimeline('set-applied', {
-            action,
-            target: this.describeTargetState(target),
-            reversing: isReversing,
-        });
     }
     async handleObstructionDetectedGet() {
-        return this.obstructionDetected;
-    }
-    updateStatesFromSensors(context) {
-        const changed = ((context.closedPrevious !== undefined && context.closedPrevious !== this.isClosedSensorActive)
-            || (context.partialPrevious !== undefined && context.partialPrevious !== this.isPartialSensorActive));
-        if (changed) {
-            this.logGateTimeline('sensor-change', {
-                closed: this.describeSensorValue(this.hasClosedSensorState, this.isClosedSensorActive),
-                partial: this.describeSensorValue(this.hasPartialSensorState, this.isPartialSensorActive),
-            });
-        }
-        this.clearFaults();
-        if (changed) {
-            this.touchTransitionTimer();
-        }
-        if (this.isClosedSensorActive) {
-            if (this.pendingTarget === this.platform.Characteristic.TargetDoorState.OPEN) {
-                this.setTargetState(this.platform.Characteristic.TargetDoorState.OPEN);
-                this.setCurrentState(this.platform.Characteristic.CurrentDoorState.OPENING);
-                return;
-            }
-            this.setPendingTarget(undefined);
-            this.clearTransitionTimer();
-            this.clearReverseToggleTimer();
-            this.clearOpenArrivalDebounceTimer();
-            this.applyDoorState(this.platform.Characteristic.CurrentDoorState.CLOSED, this.platform.Characteristic.TargetDoorState.CLOSED);
-            return;
-        }
-        if (this.pendingTarget === this.platform.Characteristic.TargetDoorState.OPEN
-            && this.shouldDebounceOpenArrival()) {
-            this.scheduleOpenArrivalDebounce();
-            return;
-        }
-        if (this.pendingTarget === this.platform.Characteristic.TargetDoorState.OPEN
-            && this.isOpenArrivalSignal()) {
-            this.setPendingTarget(undefined);
-            this.clearTransitionTimer();
-            this.clearReverseToggleTimer();
-            this.clearOpenArrivalDebounceTimer();
-            this.applyDoorState(this.platform.Characteristic.CurrentDoorState.OPEN, this.platform.Characteristic.TargetDoorState.OPEN);
-            return;
-        }
-        if (this.pendingTarget !== undefined) {
-            this.setTargetState(this.pendingTarget);
-            this.setCurrentState(this.resolveMovingState(this.pendingTarget));
-            return;
-        }
-        if (this.shouldAssumeExternalOpeningFromClosed(context)) {
-            this.setPendingTarget(this.platform.Characteristic.TargetDoorState.OPEN);
-            this.setTargetState(this.platform.Characteristic.TargetDoorState.OPEN);
-            this.setCurrentState(this.platform.Characteristic.CurrentDoorState.OPENING);
-            this.armTransitionTimer();
-            this.scheduleOpenArrivalDebounce();
-            return;
-        }
-        const inferredExternalMotionTarget = this.resolveExternalMotionTarget(context);
-        if (inferredExternalMotionTarget !== undefined) {
-            this.clearTransitionTimer();
-            this.clearOpenArrivalDebounceTimer();
-            this.setTargetState(inferredExternalMotionTarget);
-            this.setCurrentState(this.resolveMovingState(inferredExternalMotionTarget));
-            return;
-        }
-        this.clearTransitionTimer();
-        this.clearReverseToggleTimer();
-        this.clearOpenArrivalDebounceTimer();
-        this.applyDoorState(this.platform.Characteristic.CurrentDoorState.OPEN, this.platform.Characteristic.TargetDoorState.OPEN);
-    }
-    isAtTarget(target) {
-        if (target === this.platform.Characteristic.TargetDoorState.CLOSED) {
-            if (!this.hasClosedSensorState) {
-                return false;
-            }
-            return this.isClosedSensorActive;
-        }
-        if (target === this.platform.Characteristic.TargetDoorState.OPEN) {
-            return this.isKnownNotClosed()
-                && this.currentState === this.platform.Characteristic.CurrentDoorState.OPEN;
-        }
         return false;
     }
-    applyDoorState(current, target) {
-        this.setCurrentState(current);
-        this.setTargetState(target);
-    }
-    setCurrentState(next) {
-        if (this.currentState === next) {
+    applySnapshot(snapshot) {
+        this.accessory.updateReachability(snapshot.available);
+        if (this.service.testCharacteristic(this.platform.Characteristic.StatusActive)) {
+            this.service.updateCharacteristic(this.platform.Characteristic.StatusActive, snapshot.available);
+        }
+        if (this.service.testCharacteristic(this.platform.Characteristic.StatusFault)) {
+            this.service.updateCharacteristic(this.platform.Characteristic.StatusFault, snapshot.available
+                ? this.platform.Characteristic.StatusFault.NO_FAULT
+                : this.platform.Characteristic.StatusFault.GENERAL_FAULT);
+        }
+        this.service.updateCharacteristic(this.platform.Characteristic.ObstructionDetected, false);
+        if (!snapshot.available || snapshot.currentDoorState === undefined || snapshot.targetDoorState === undefined) {
+            const error = this.createCommunicationError();
+            this.service.updateCharacteristic(this.platform.Characteristic.CurrentDoorState, error);
+            this.service.updateCharacteristic(this.platform.Characteristic.TargetDoorState, error);
             return;
         }
-        this.currentState = next;
-        this.service.updateCharacteristic(this.platform.Characteristic.CurrentDoorState, this.currentState);
+        this.service.updateCharacteristic(this.platform.Characteristic.CurrentDoorState, snapshot.currentDoorState);
+        this.service.updateCharacteristic(this.platform.Characteristic.TargetDoorState, snapshot.targetDoorState);
     }
-    setTargetState(next) {
-        if (this.targetState === next) {
-            return;
-        }
-        this.targetState = next;
-        this.service.updateCharacteristic(this.platform.Characteristic.TargetDoorState, this.targetState);
+    createCommunicationError() {
+        return new Error('Front gate controller is unavailable');
     }
-    isKnownNotClosed() {
-        if (this.hasClosedSensorState) {
-            return !this.isClosedSensorActive;
-        }
-        if (this.hasPartialSensorState && this.isPartialSensorActive) {
-            return true;
-        }
-        return this.currentState !== this.platform.Characteristic.CurrentDoorState.CLOSED;
-    }
-    updateStatusFault() {
-        const fault = !this.connected;
-        this.service.updateCharacteristic(this.platform.Characteristic.StatusFault, fault
-            ? this.platform.Characteristic.StatusFault.GENERAL_FAULT
-            : this.platform.Characteristic.StatusFault.NO_FAULT);
-    }
-    clearFaults() {
-        if (this.obstructionDetected) {
-            this.obstructionDetected = false;
-            this.service.updateCharacteristic(this.platform.Characteristic.ObstructionDetected, false);
-        }
-        this.updateStatusFault();
-    }
-    armTransitionTimer() {
-        this.clearTransitionTimer();
-        this.transitionTimer = setTimeout(() => {
-            this.transitionTimer = undefined;
-            const target = this.pendingTarget;
-            this.setPendingTarget(undefined);
-            this.clearReverseToggleTimer();
-            this.clearOpenArrivalDebounceTimer();
-            if (target === undefined) {
-                return;
-            }
-            const settled = this.resolveTerminalStateFromSensors();
-            if (settled !== undefined) {
-                this.applyDoorState(settled.current, settled.target);
-                return;
-            }
-            const assumedCurrent = target === this.platform.Characteristic.TargetDoorState.OPEN
-                ? this.platform.Characteristic.CurrentDoorState.OPEN
-                : this.platform.Characteristic.CurrentDoorState.CLOSED;
-            this.applyDoorState(assumedCurrent, target);
-            this.platform.log.warn(`Gate ${this.accessory.displayName} did not confirm target within ${this.transitionTimeoutMs}ms; assuming ` +
-                `${target === this.platform.Characteristic.TargetDoorState.OPEN ? 'open' : 'closed'}.`);
-            this.logGateTimeline('transition-timeout-assumed', {
-                assumedTarget: this.describeTargetState(target),
+    async publishPulse(reason) {
+        const action = this.platform.getFrontGatePulseAction();
+        if (!action) {
+            throw new Error('front gate pulse action is not configured');
+        }
+        this.platform.log.debug(`Publishing ${this.controlBaseTopic}/execute_action = ${action} (${reason})`);
+        return new Promise((resolve, reject) => {
+            this.platform.publishCommand(`${this.controlBaseTopic}/execute_action`, action, (error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
             });
-        }, this.transitionTimeoutMs);
-    }
-    clearTransitionTimer() {
-        if (this.transitionTimer) {
-            clearTimeout(this.transitionTimer);
-            this.transitionTimer = undefined;
-        }
-    }
-    clearReverseToggleTimer() {
-        if (this.reverseToggleTimer) {
-            clearTimeout(this.reverseToggleTimer);
-            this.reverseToggleTimer = undefined;
-        }
-    }
-    clearOpenArrivalDebounceTimer() {
-        if (this.openArrivalDebounceTimer) {
-            clearTimeout(this.openArrivalDebounceTimer);
-            this.openArrivalDebounceTimer = undefined;
-        }
-    }
-    clearPublishRetryTimer() {
-        if (this.publishRetryTimer) {
-            clearTimeout(this.publishRetryTimer);
-            this.publishRetryTimer = undefined;
-        }
-    }
-    touchTransitionTimer() {
-        if (this.pendingTarget === undefined) {
-            return;
-        }
-        this.armTransitionTimer();
-    }
-    resolveMovingState(target) {
-        if (target === this.platform.Characteristic.TargetDoorState.OPEN) {
-            return this.platform.Characteristic.CurrentDoorState.OPENING;
-        }
-        if (target === this.platform.Characteristic.TargetDoorState.CLOSED) {
-            return this.platform.Characteristic.CurrentDoorState.CLOSING;
-        }
-        return this.currentState;
+        });
     }
-    getMotionTarget() {
-        if (this.pendingTarget !== undefined) {
-            return this.pendingTarget;
-        }
-        if (this.currentState === this.platform.Characteristic.CurrentDoorState.OPENING) {
-            return this.platform.Characteristic.TargetDoorState.OPEN;
-        }
-        if (this.currentState === this.platform.Characteristic.CurrentDoorState.CLOSING) {
-            return this.platform.Characteristic.TargetDoorState.CLOSED;
+    resolveSensorBaseTopic() {
+        const explicit = this.resolveSensorOverrideFromConfig();
+        if (explicit) {
+            this.platform.log.info(`[FrontGate ${this.accessory.displayName}] using explicit front-gate sensor topic override: ${explicit}`);
+            return explicit;
+        }
+        const candidates = this.findSensorCandidates();
+        if (candidates.length === 0) {
+            this.platform.log.warn(`[FrontGate ${this.accessory.displayName}] no dedicated gate sensor channel found; falling back to ${this.controlBaseTopic}/state/hi`);
+            return this.controlBaseTopic;
+        }
+        const winner = candidates[0];
+        this.platform.log.info(`[FrontGate ${this.accessory.displayName}] resolved sensor channel ${winner.channel.channelCaption} `
+            + `(${winner.channel.deviceId}/${winner.channel.channelId}) -> ${winner.baseTopic} `
+            + `[${winner.reasons.join(', ')}]`);
+        return winner.baseTopic;
+    }
+    resolveSensorOverrideFromConfig() {
+        const config = this.platform.config;
+        if (typeof config.frontGateSensorTopic === 'string' && config.frontGateSensorTopic.trim()) {
+            return this.platform.normalizeTopicBase(config.frontGateSensorTopic);
+        }
+        const requestedDeviceId = this.normalizeOptionalId(config.frontGateSensorDeviceId);
+        const requestedChannelId = this.normalizeOptionalId(config.frontGateSensorChannelId);
+        if (!requestedDeviceId && !requestedChannelId) {
+            return undefined;
         }
-        return undefined;
-    }
-    isOpenArrivalSignal() {
-        if (this.partialHiMode === 'moving') {
-            if (!this.hasPartialSensorState) {
-                return true;
+        const channel = this.collectKnownChannels().find(candidate => {
+            if (requestedDeviceId && candidate.deviceId !== requestedDeviceId) {
+                return false;
+            }
+            if (requestedChannelId && candidate.channelId !== requestedChannelId) {
+                return false;
             }
-            return this.hasPartialSensorState
-                && this.sawPartialMotionDuringPending
-                && !this.isPartialSensorActive;
-        }
-        if (!this.hasPartialSensorState) {
-            return false;
-        }
-        if (this.partialHiMode === 'open_endstop') {
-            return this.isPartialSensorActive;
-        }
-        if (this.partialHiMode === 'pedestrian_endstop') {
-            return this.isPartialSensorActive;
-        }
-        return false;
-    }
-    shouldDebounceOpenArrival() {
-        if (this.isClosedSensorActive) {
-            return false;
-        }
-        if (this.partialHiMode === 'ignore') {
             return true;
+        });
+        if (!channel) {
+            this.platform.log.warn(`[FrontGate ${this.accessory.displayName}] configured frontGateSensorDeviceId/frontGateSensorChannelId did not match any known channel`);
+            return undefined;
         }
-        return this.partialHiMode === 'moving' && !this.hasPartialSensorState;
+        return this.platform.normalizeTopicBase(channel.topic);
     }
-    shouldAssumeExternalOpeningFromClosed(context) {
-        return context.closedPrevious === true
-            && !this.isClosedSensorActive
-            && this.shouldDebounceOpenArrival();
-    }
-    scheduleOpenArrivalDebounce() {
-        if (this.openArrivalDebounceTimer) {
-            return;
-        }
-        this.openArrivalDebounceTimer = setTimeout(() => {
-            this.openArrivalDebounceTimer = undefined;
-            if (!this.connected) {
-                return;
-            }
-            if (this.pendingTarget !== this.platform.Characteristic.TargetDoorState.OPEN) {
-                return;
+    findSensorCandidates() {
+        const channels = this.collectKnownChannels();
+        const candidates = [];
+        for (const channel of channels) {
+            if (channel.channelId === this.context.channelId && channel.deviceId === this.context.deviceId) {
+                continue;
             }
-            if (this.isClosedSensorActive) {
-                return;
+            const score = this.scoreSensorCandidate(channel);
+            if (score.score <= 0) {
+                continue;
             }
-            this.setPendingTarget(undefined);
-            this.clearTransitionTimer();
-            this.clearReverseToggleTimer();
-            this.applyDoorState(this.platform.Characteristic.CurrentDoorState.OPEN, this.platform.Characteristic.TargetDoorState.OPEN);
-            this.logGateTimeline('open-assumed-arrival', {
-                debounceMs: this.openArrivalDebounceMs,
+            candidates.push({
+                channel,
+                baseTopic: this.platform.normalizeTopicBase(channel.topic),
+                score: score.score,
+                reasons: score.reasons,
             });
-        }, this.openArrivalDebounceMs);
-    }
-    resolveTerminalStateFromSensors() {
-        if (!this.hasClosedSensorState) {
-            return undefined;
         }
-        if (this.isClosedSensorActive) {
-            return {
-                current: this.platform.Characteristic.CurrentDoorState.CLOSED,
-                target: this.platform.Characteristic.TargetDoorState.CLOSED,
-            };
-        }
-        return {
-            current: this.platform.Characteristic.CurrentDoorState.OPEN,
-            target: this.platform.Characteristic.TargetDoorState.OPEN,
-        };
-    }
-    oppositeTarget(target) {
-        return target === this.platform.Characteristic.TargetDoorState.OPEN
-            ? this.platform.Characteristic.TargetDoorState.CLOSED
-            : this.platform.Characteristic.TargetDoorState.OPEN;
-    }
-    markCommand(target) {
-        this.lastCommandTarget = target;
-        this.lastCommandAt = Date.now();
-    }
-    setPendingTarget(target) {
-        this.pendingTarget = target;
-        if (target !== this.platform.Characteristic.TargetDoorState.OPEN) {
-            this.clearOpenArrivalDebounceTimer();
+        candidates.sort((left, right) => right.score - left.score);
+        return candidates;
+    }
+    scoreSensorCandidate(channel) {
+        const reasons = [];
+        let score = 0;
+        const functionName = (channel.channelFunction || '').toUpperCase();
+        const typeName = (channel.channelType || '').toUpperCase();
+        const isGateSensorFunction = functionName === 'OPENINGSENSOR_GATE' || functionName === 'OPENINGSENSOR_GATEWAY';
+        const isGenericOpeningSensor = functionName.startsWith('OPENINGSENSOR_');
+        const isBinarySensor = typeName === 'BINARYSENSOR';
+        const sameDevice = Boolean(channel.deviceId && channel.deviceId === this.context.deviceId);
+        const captionScore = this.computeCaptionSimilarity(this.context.channelCaption || this.accessory.displayName, channel.channelCaption || '');
+        if (isGateSensorFunction) {
+            score += 100;
+            reasons.push('gate-sensor-function');
+        }
+        else if (isGenericOpeningSensor) {
+            score += 70;
+            reasons.push('opening-sensor-function');
+        }
+        else if (isBinarySensor) {
+            if (!sameDevice && captionScore === 0) {
+                return { score: 0, reasons: [] };
+            }
+            score += 20;
+            reasons.push('binary-sensor');
         }
-        if (target === undefined) {
-            this.sawPartialMotionDuringPending = false;
-            return;
+        else {
+            return { score: 0, reasons: [] };
+        }
+        if (sameDevice) {
+            score += 50;
+            reasons.push('same-device');
+        }
+        if (captionScore > 0) {
+            score += captionScore;
+            reasons.push(`caption+${captionScore}`);
+        }
+        const controlBase = this.platform.normalizeTopicBase(this.context.topic);
+        const candidateBase = this.platform.normalizeTopicBase(channel.topic);
+        if (controlBase && candidateBase && controlBase !== candidateBase) {
+            const controlPrefix = controlBase.replace(/\/channels\/[^/]+$/, '');
+            const candidatePrefix = candidateBase.replace(/\/channels\/[^/]+$/, '');
+            if (controlPrefix === candidatePrefix) {
+                score += 15;
+                reasons.push('same-device-topic-prefix');
+            }
         }
-        this.sawPartialMotionDuringPending = this.hasPartialSensorState && this.isPartialSensorActive;
+        return { score, reasons };
     }
-    isLikelyDuplicateSet(target) {
-        if (this.lastCommandTarget !== target) {
-            return false;
+    computeCaptionSimilarity(left, right) {
+        const leftTokens = this.tokenizeCaption(left);
+        const rightTokens = this.tokenizeCaption(right);
+        if (leftTokens.length === 0 || rightTokens.length === 0) {
+            return 0;
         }
-        return Date.now() - this.lastCommandAt <= this.duplicateSetWindowMs;
-    }
-    publishGateAction(action, note, expectedTarget, isRetry = false) {
-        const suffix = note ? ` (${note})` : '';
-        this.platform.log.debug(`Publishing ${this.baseTopic}/execute_action = ${action}${suffix}`);
-        this.logGateTimeline(isRetry ? 'publish-retry' : 'publish', {
-            action,
-            note: note !== null && note !== void 0 ? note : 'none',
-            expected: this.describeTargetState(expectedTarget),
-        });
-        this.platform.publishCommand(`${this.baseTopic}/execute_action`, action, (error) => {
-            if (!error) {
-                return;
+        const rightSet = new Set(rightTokens);
+        let overlap = 0;
+        for (const token of leftTokens) {
+            if (rightSet.has(token)) {
+                overlap += 1;
             }
-            this.platform.log.warn(`Gate ${this.accessory.displayName} publish failed (${action}): ${error.message}`);
-            this.logGateTimeline('publish-failed', {
-                action,
-                retry: !isRetry && this.publishRetryDelayMs > 0,
-            });
-            if (isRetry || this.publishRetryDelayMs <= 0) {
-                return;
-            }
-            this.schedulePublishRetry(action, note, expectedTarget);
-        });
+        }
+        if (overlap === 0) {
+            return 0;
+        }
+        return Math.min(40, overlap * 10);
+    }
+    tokenizeCaption(value) {
+        return value
+            .toLowerCase()
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .split(/[^a-z0-9]+/)
+            .filter(Boolean)
+            .filter(token => !new Set([
+            'gate',
+            'sensor',
+            'contact',
+            'opening',
+            'open',
+            'close',
+            'controller',
+        ]).has(token));
+    }
+    normalizeOptionalId(value) {
+        if (value === undefined || value === null) {
+            return undefined;
+        }
+        const normalized = String(value).trim();
+        return normalized || undefined;
     }
-    schedulePublishRetry(action, note, expectedTarget) {
-        this.clearPublishRetryTimer();
-        this.publishRetryTimer = setTimeout(() => {
-            this.publishRetryTimer = undefined;
-            if (!this.connected) {
+    collectKnownChannels() {
+        const byKey = new Map();
+        const push = (candidate) => {
+            var _a, _b;
+            if (!candidate || typeof candidate !== 'object') {
                 return;
             }
-            if (expectedTarget !== undefined && this.pendingTarget !== expectedTarget) {
+            const channel = candidate;
+            if (typeof channel.topic !== 'string') {
                 return;
             }
-            this.publishGateAction(action, note, expectedTarget, true);
-        }, this.publishRetryDelayMs);
-        this.logGateTimeline('publish-retry-scheduled', {
-            action,
-            retryDelayMs: this.publishRetryDelayMs,
-            expected: this.describeTargetState(expectedTarget),
-        });
-    }
-    scheduleReverseToggle(action, expectedTarget, mode) {
-        this.clearReverseToggleTimer();
-        this.reverseToggleTimer = setTimeout(() => {
-            this.reverseToggleTimer = undefined;
-            if (!this.connected) {
-                return;
+            const key = [
+                (_a = channel.deviceId) !== null && _a !== void 0 ? _a : '',
+                (_b = channel.channelId) !== null && _b !== void 0 ? _b : '',
+                this.platform.normalizeTopicBase(channel.topic),
+            ].join('|');
+            byKey.set(key, channel);
+        };
+        for (const knownAccessory of this.platform.accessories) {
+            push(knownAccessory.context.device);
+        }
+        const config = this.platform.config;
+        const rawChannels = config.channels;
+        if (Array.isArray(rawChannels)) {
+            for (const channel of rawChannels) {
+                push(channel);
             }
-            if (this.pendingTarget !== expectedTarget) {
-                return;
+        }
+        else if (typeof rawChannels === 'string' && rawChannels.trim()) {
+            try {
+                const parsed = JSON.parse(rawChannels);
+                if (Array.isArray(parsed)) {
+                    for (const channel of parsed) {
+                        push(channel);
+                    }
+                }
             }
-            if (!this.strictReverseDoublePulse
-                && mode === 'execute_action'
-                && this.isOpenCloseExecuteActionPair()
-                && !this.shouldPublishExecuteActionReverseFollowUp()) {
-                this.logGateTimeline('reverse-2-skipped', {
-                    reason: 'motion-confirmed',
-                    strict: this.strictReverseDoublePulse,
-                });
-                return;
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.platform.log.warn(`[FrontGate ${this.accessory.displayName}] failed to parse cached channels: ${message}`);
             }
-            this.publishGateAction(action, 'reverse-2', expectedTarget);
-        }, this.reverseToggleDelayMs);
-        this.logGateTimeline('reverse-2-scheduled', {
-            action,
-            mode,
-            delayMs: this.reverseToggleDelayMs,
-            expected: this.describeTargetState(expectedTarget),
-        });
-    }
-    shouldScheduleReverseFollowUp(mode) {
-        if (mode === 'toggle') {
-            return true;
-        }
-        return this.isOpenCloseExecuteActionPair() || this.isSingleExecuteActionPair();
-    }
-    isOpenCloseExecuteActionPair() {
-        return this.normalizeAction(this.platform.getGateExecuteActionOpen()) === 'open'
-            && this.normalizeAction(this.platform.getGateExecuteActionClose()) === 'close';
-    }
-    isSingleExecuteActionPair() {
-        const openAction = this.normalizeAction(this.platform.getGateExecuteActionOpen());
-        if (!openAction) {
-            return false;
-        }
-        return openAction === this.normalizeAction(this.platform.getGateExecuteActionClose());
-    }
-    normalizeAction(value) {
-        return value.trim().toLowerCase();
-    }
-    shouldPublishExecuteActionReverseFollowUp() {
-        if (this.partialHiMode !== 'moving') {
-            return true;
-        }
-        if (!this.hasPartialSensorState) {
-            return true;
-        }
-        return !this.isPartialSensorActive;
-    }
-    resolveExternalMotionTarget(context) {
-        if (this.partialHiMode !== 'moving') {
-            return undefined;
-        }
-        if (!this.hasPartialSensorState || !this.isPartialSensorActive) {
-            return undefined;
-        }
-        if (this.hasClosedSensorState && this.isClosedSensorActive) {
-            return undefined;
-        }
-        const closedJustOpened = context.closedPrevious !== undefined
-            && context.closedPrevious
-            && !this.isClosedSensorActive;
-        if (closedJustOpened) {
-            return this.platform.Characteristic.TargetDoorState.OPEN;
-        }
-        if (this.wasClosedReleasedRecently()) {
-            return this.platform.Characteristic.TargetDoorState.OPEN;
-        }
-        const existingMotionTarget = this.getMotionTarget();
-        if (existingMotionTarget !== undefined) {
-            return existingMotionTarget;
-        }
-        if (this.currentState === this.platform.Characteristic.CurrentDoorState.CLOSED) {
-            return this.platform.Characteristic.TargetDoorState.OPEN;
-        }
-        if (this.currentState === this.platform.Characteristic.CurrentDoorState.OPEN) {
-            return this.platform.Characteristic.TargetDoorState.CLOSED;
         }
-        return this.targetState === this.platform.Characteristic.TargetDoorState.OPEN
-            ? this.platform.Characteristic.TargetDoorState.CLOSED
-            : this.platform.Characteristic.TargetDoorState.OPEN;
-    }
-    wasClosedReleasedRecently() {
-        if (!this.lastClosedReleaseAt) {
-            return false;
-        }
-        return Date.now() - this.lastClosedReleaseAt <= this.externalDirectionHintWindowMs;
-    }
-    isCommandInCooldown(target, motionTarget) {
-        if (this.commandCooldownMs <= 0 || this.lastCommandAt === 0) {
-            return false;
-        }
-        if (Date.now() - this.lastCommandAt > this.commandCooldownMs) {
-            return false;
-        }
-        const isReverse = motionTarget !== undefined && motionTarget !== target;
-        return !isReverse;
-    }
-    describeTargetState(value) {
-        if (value === undefined) {
-            return 'none';
-        }
-        if (value === this.platform.Characteristic.TargetDoorState.OPEN) {
-            return 'open';
-        }
-        if (value === this.platform.Characteristic.TargetDoorState.CLOSED) {
-            return 'closed';
-        }
-        return `unknown(${value})`;
-    }
-    describeCurrentState(value) {
-        if (value === this.platform.Characteristic.CurrentDoorState.OPEN) {
-            return 'open';
-        }
-        if (value === this.platform.Characteristic.CurrentDoorState.CLOSED) {
-            return 'closed';
-        }
-        if (value === this.platform.Characteristic.CurrentDoorState.OPENING) {
-            return 'opening';
-        }
-        if (value === this.platform.Characteristic.CurrentDoorState.CLOSING) {
-            return 'closing';
-        }
-        if (value === this.platform.Characteristic.CurrentDoorState.STOPPED) {
-            return 'stopped';
-        }
-        return `unknown(${value})`;
-    }
-    describeSensorValue(hasValue, value) {
-        if (!hasValue) {
-            return 'unknown';
-        }
-        return value ? 'true' : 'false';
-    }
-    logGateTimeline(event, context) {
-        if (!this.debugTimeline) {
-            return;
-        }
-        const snapshot = {
-            event,
-            current: this.describeCurrentState(this.currentState),
-            target: this.describeTargetState(this.targetState),
-            pending: this.describeTargetState(this.pendingTarget),
-            connected: this.connected,
-            closed: this.describeSensorValue(this.hasClosedSensorState, this.isClosedSensorActive),
-            partial: this.describeSensorValue(this.hasPartialSensorState, this.isPartialSensorActive),
-        };
-        const merged = {
-            ...snapshot,
-            ...context,
-        };
-        const details = Object.entries(merged)
-            .map(([key, value]) => `${key}=${String(value)}`)
-            .join(' ');
-        this.platform.log.info(`[GateDebug ${this.accessory.displayName}] ${details}`);
+        return Array.from(byKey.values());
     }
 }
 exports.GateAccessory = GateAccessory;