@marcel2215/homebridge-supla-plugin 2.1.24 → 2.1.25

package/.codex/environments/environment.toml

@@ -0,0 +1,31 @@
+# THIS IS AUTOGENERATED. DO NOT EDIT MANUALLY
+version = 1
+name = "homebridge-supla-plugin"
+
+[setup]
+script = ""
+
+[[actions]]
+name = "Bump Major"
+icon = "tool"
+command = "npm run version:bump:major"
+
+[[actions]]
+name = "Bump Minor"
+icon = "tool"
+command = "npm run version:bump:minor"
+
+[[actions]]
+name = "Bump Revision"
+icon = "tool"
+command = "npm run version:bump:revision"
+
+[[actions]]
+name = "Publish"
+icon = "tool"
+command = "npm run publish:plugin"
+
+[[actions]]
+name = "Login"
+icon = "tool"
+command = "npm login"

package/config.schema.json

@@ -123,6 +123,31 @@
       "type": "boolean",
       "default": false
     },
+    "frontGateFullTravelMs": {
+      "title": "Front Gate Full Travel (ms)",
+      "type": "number",
+      "default": 25000
+    },
+    "frontGateReversePauseMs": {
+      "title": "Front Gate Reverse Pause (ms)",
+      "type": "number",
+      "default": 900
+    },
+    "frontGateWrongDirectionRunMs": {
+      "title": "Front Gate Wrong Direction Run (ms)",
+      "type": "number",
+      "default": 700
+    },
+    "frontGateMinimumPulseGapMs": {
+      "title": "Front Gate Minimum Pulse Gap (ms)",
+      "type": "number",
+      "default": 400
+    },
+    "frontGateCloseRetryLimit": {
+      "title": "Front Gate Close Retry Limit",
+      "type": "number",
+      "default": 1
+    },
     "gateLockControlMode": {
       "title": "Gate Lock Control Mode",
       "type": "string",

package/dist/Accesories/FrontGateFsm.d.ts

@@ -0,0 +1,123 @@
+export type GateTarget = 'open' | 'closed';
+export type MotionDirection = 'opening' | 'closing';
+export type MotionCertainty = 'known' | 'goalOnly';
+export type MotionSource = 'homekit' | 'external' | 'recovery';
+export declare const enum DoorCurrentState {
+    OPEN = 0,
+    CLOSED = 1,
+    OPENING = 2,
+    CLOSING = 3,
+    STOPPED = 4
+}
+export declare const enum DoorTargetState {
+    OPEN = 0,
+    CLOSED = 1
+}
+export interface FrontGateTimingConfig {
+    fullTravelMs: number;
+    reversePauseMs: number;
+    wrongDirectionRunMs: number;
+    minimumPulseGapMs: number;
+    closeRetryLimit: number;
+}
+export declare const DEFAULT_FRONT_GATE_TIMINGS: FrontGateTimingConfig;
+export interface PersistedFrontGateState {
+}
+export interface FrontGateSnapshot {
+    available: boolean;
+    controlConnected: boolean | null;
+    sensorConnected: boolean | null;
+    closedSensor: boolean | null;
+    sensorFreshSinceOnline: boolean;
+    currentDoorState?: DoorCurrentState;
+    targetDoorState?: DoorTargetState;
+    requestedTarget: GateTarget | null;
+    motionDirection: MotionDirection | 'none';
+    motionCertainty: MotionCertainty | 'none';
+    planKind: Plan['kind'];
+    note: string;
+}
+export interface FrontGateLogger {
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+}
+export interface FrontGateIo {
+    pulseMotor(reason: string): Promise<void>;
+    publishSnapshot(snapshot: FrontGateSnapshot): void;
+    log: FrontGateLogger;
+}
+type Plan = {
+    kind: 'idle';
+} | {
+    kind: 'moving';
+    direction: MotionDirection;
+    certainty: MotionCertainty;
+    source: MotionSource;
+    attempt: number;
+    startedAt: number;
+    deadlineAt: number;
+} | {
+    kind: 'waitingSecondPulse';
+    finalDirection: MotionDirection;
+    source: MotionSource;
+    attempt: number;
+    dueAt: number;
+    deadlineAt: number;
+    reason: 'reverseToOpen' | 'reverseToClose';
+};
+export declare class FrontGateFsm {
+    private readonly io;
+    private readonly travelMs;
+    private readonly pulseGapMs;
+    private readonly closeRetryLimit;
+    private facts;
+    private sensorFreshSinceOnline;
+    private requestedTarget;
+    private plan;
+    private lastPulseLikeActivityAt;
+    private movementTimer?;
+    private movementTimerToken;
+    private phaseTimer?;
+    private phaseTimerToken;
+    private sequence;
+    private disposed;
+    constructor(io: FrontGateIo, timings?: FrontGateTimingConfig, _persisted?: PersistedFrontGateState);
+    dispose(): void;
+    handleConnectedChange(connected: boolean): void;
+    handleControlConnectedChange(connected: boolean): void;
+    handleSensorConnectedChange(connected: boolean): void;
+    handleClosedSensorChange(closed: boolean): void;
+    requestHomeKitTarget(target: GateTarget): Promise<void>;
+    getSnapshot(): FrontGateSnapshot;
+    private enqueue;
+    private applyControlConnectedChange;
+    private applySensorConnectedChange;
+    private applyClosedSensorChange;
+    private applyHomeKitTarget;
+    private handleOpenRequest;
+    private handleCloseRequest;
+    private startOpeningFromClosed;
+    private startCloseSeek;
+    private reverseKnownMotion;
+    private startOpeningMotion;
+    private startClosingMotion;
+    private scheduleMovementTimer;
+    private schedulePhaseTimer;
+    private clearMovementTimer;
+    private clearPhaseTimer;
+    private clearTimers;
+    private handlePhaseTimer;
+    private handleMovementTimeout;
+    private enterUnavailable;
+    private isAvailableForHomeKit;
+    private pulseMotor;
+    private emitSnapshot;
+    private buildSnapshot;
+    private getMotionDirection;
+    private getMotionCertainty;
+    private computeCurrentDoorState;
+    private computeTargetDoorState;
+}
+export {};
+//# sourceMappingURL=FrontGateFsm.d.ts.map

package/dist/Accesories/FrontGateFsm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrontGateFsm.d.ts","sourceRoot":"","sources":["../../src/Accesories/FrontGateFsm.ts"],"names":[],"mappings":"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"}

package/dist/Accesories/FrontGateFsm.js

@@ -0,0 +1,496 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrontGateFsm = exports.DEFAULT_FRONT_GATE_TIMINGS = void 0;
+exports.DEFAULT_FRONT_GATE_TIMINGS = {
+    fullTravelMs: 25000,
+    reversePauseMs: 3000,
+    wrongDirectionRunMs: 0,
+    minimumPulseGapMs: 3000,
+    closeRetryLimit: 1,
+};
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function clampInt(value, min, max) {
+    if (!Number.isFinite(value)) {
+        return min;
+    }
+    return Math.min(max, Math.max(min, Math.round(value)));
+}
+class FrontGateFsm {
+    constructor(io, timings = exports.DEFAULT_FRONT_GATE_TIMINGS, _persisted = {}) {
+        this.io = io;
+        this.facts = {
+            controlConnected: null,
+            sensorConnected: null,
+            closedSensor: null,
+        };
+        this.sensorFreshSinceOnline = false;
+        this.requestedTarget = null;
+        this.plan = { kind: 'idle' };
+        this.lastPulseLikeActivityAt = 0;
+        this.movementTimerToken = 0;
+        this.phaseTimerToken = 0;
+        this.sequence = Promise.resolve(undefined);
+        this.disposed = false;
+        this.travelMs = clampInt(timings.fullTravelMs || exports.DEFAULT_FRONT_GATE_TIMINGS.fullTravelMs, 5000, 120000);
+        this.pulseGapMs = Math.max(3000, clampInt(timings.minimumPulseGapMs || exports.DEFAULT_FRONT_GATE_TIMINGS.minimumPulseGapMs, 0, 15000), clampInt(timings.reversePauseMs || exports.DEFAULT_FRONT_GATE_TIMINGS.reversePauseMs, 0, 15000));
+        this.closeRetryLimit = clampInt(timings.closeRetryLimit || exports.DEFAULT_FRONT_GATE_TIMINGS.closeRetryLimit, 0, 3);
+        this.emitSnapshot('fsm-initialized');
+    }
+    dispose() {
+        this.disposed = true;
+        this.clearTimers();
+    }
+    handleConnectedChange(connected) {
+        this.handleControlConnectedChange(connected);
+    }
+    handleControlConnectedChange(connected) {
+        void this.enqueue(`control-connected=${connected}`, () => {
+            this.applyControlConnectedChange(connected);
+        });
+    }
+    handleSensorConnectedChange(connected) {
+        void this.enqueue(`sensor-connected=${connected}`, () => {
+            this.applySensorConnectedChange(connected);
+        });
+    }
+    handleClosedSensorChange(closed) {
+        void this.enqueue(`closed-sensor=${closed}`, () => {
+            this.applyClosedSensorChange(closed);
+        });
+    }
+    async requestHomeKitTarget(target) {
+        return this.enqueue(`homekit-target=${target}`, async () => {
+            await this.applyHomeKitTarget(target);
+        });
+    }
+    getSnapshot() {
+        return this.buildSnapshot('snapshot-requested');
+    }
+    enqueue(label, task) {
+        if (this.disposed) {
+            return Promise.resolve();
+        }
+        const run = this.sequence.then(async () => {
+            if (this.disposed) {
+                return;
+            }
+            await task();
+        });
+        this.sequence = run.catch(error => {
+            const message = error instanceof Error ? error.message : String(error);
+            this.io.log.warn(`front-gate sequence '${label}' failed: ${message}`);
+        });
+        return run;
+    }
+    applyControlConnectedChange(connected) {
+        if (this.facts.controlConnected === connected) {
+            return;
+        }
+        this.facts.controlConnected = connected;
+        if (!connected) {
+            this.io.log.warn('front gate control channel went offline');
+            this.enterUnavailable('control-offline');
+            return;
+        }
+        this.io.log.info('front gate control channel connected');
+        this.clearTimers();
+        this.plan = { kind: 'idle' };
+        this.sensorFreshSinceOnline = false;
+        this.emitSnapshot('control-online-awaiting-fresh-sensor');
+    }
+    applySensorConnectedChange(connected) {
+        if (this.facts.sensorConnected === connected) {
+            return;
+        }
+        this.facts.sensorConnected = connected;
+        if (!connected) {
+            this.io.log.warn('front gate sensor channel went offline');
+            this.enterUnavailable('sensor-offline');
+            return;
+        }
+        this.io.log.info('front gate sensor channel connected');
+        this.clearTimers();
+        this.plan = { kind: 'idle' };
+        this.sensorFreshSinceOnline = false;
+        this.emitSnapshot('sensor-online-awaiting-fresh-state');
+    }
+    applyClosedSensorChange(closed) {
+        const previous = this.facts.closedSensor;
+        const wasFresh = this.sensorFreshSinceOnline;
+        this.facts.closedSensor = closed;
+        if (this.facts.controlConnected === true && this.facts.sensorConnected === true) {
+            this.sensorFreshSinceOnline = true;
+        }
+        const becameFresh = !wasFresh && this.sensorFreshSinceOnline;
+        if (previous === closed && !becameFresh) {
+            return;
+        }
+        if (closed) {
+            this.io.log.info('closed sensor is TRUE -> gate is fully closed');
+            this.clearTimers();
+            this.plan = { kind: 'idle' };
+            if (this.requestedTarget === 'open' && this.isAvailableForHomeKit()) {
+                this.emitSnapshot('closed-sensor-true-but-open-still-requested');
+                void this.enqueue('auto-open-after-closed', async () => {
+                    await this.startOpeningFromClosed('auto-open-after-closed');
+                });
+                return;
+            }
+            this.requestedTarget = null;
+            this.emitSnapshot('closed-sensor-true');
+            return;
+        }
+        this.io.log.info('closed sensor is FALSE -> gate is not fully closed');
+        if (previous === true) {
+            // The gate just left the closed end-stop. This is the one fully reliable
+            // direction signal we have: motion is opening.
+            this.lastPulseLikeActivityAt = Date.now();
+            this.startOpeningMotion(this.requestedTarget === 'open' ? 'homekit' : 'external', 'closed-sensor-fell-from-true-to-false');
+            return;
+        }
+        if (this.requestedTarget === 'open'
+            && !(this.plan.kind === 'moving' && this.plan.direction === 'closing')
+            && !(this.plan.kind === 'waitingSecondPulse' && this.plan.finalDirection === 'closing')) {
+            this.requestedTarget = null;
+        }
+        this.emitSnapshot('closed-sensor-false');
+    }
+    async applyHomeKitTarget(target) {
+        if (!this.isAvailableForHomeKit()) {
+            throw new Error('front gate controller is not available');
+        }
+        this.requestedTarget = target;
+        if (target === 'open') {
+            await this.handleOpenRequest();
+            return;
+        }
+        await this.handleCloseRequest();
+    }
+    async handleOpenRequest() {
+        if (this.facts.closedSensor === true) {
+            if (this.plan.kind === 'moving' && this.plan.direction === 'opening') {
+                this.emitSnapshot('open-request-already-opening-from-closed');
+                return;
+            }
+            if (this.plan.kind === 'waitingSecondPulse' && this.plan.finalDirection === 'opening') {
+                this.emitSnapshot('open-request-already-reversing-to-open');
+                return;
+            }
+            await this.startOpeningFromClosed('homekit-open-from-closed');
+            return;
+        }
+        if (this.plan.kind === 'moving' && this.plan.direction === 'closing' && this.plan.certainty === 'known') {
+            await this.reverseKnownMotion('opening', 'homekit-reverse-known-closing-to-open');
+            return;
+        }
+        if (this.plan.kind === 'waitingSecondPulse' && this.plan.finalDirection === 'closing') {
+            this.io.log.info('open requested while waiting to restart towards close; cancelling close restart');
+            this.clearPhaseTimer();
+            this.plan = { kind: 'idle' };
+            this.emitSnapshot('cancelled-pending-close-restart');
+            return;
+        }
+        if (this.plan.kind === 'moving' && this.plan.direction === 'closing' && this.plan.certainty === 'goalOnly') {
+            // We do not actually know whether the gate is currently closing or whether a
+            // previous close-seek pulse accidentally caused opening. In this ambiguous
+            // state, the safest action is to cancel further close retries and hold the
+            // gate in the generic open-ish state.
+            this.io.log.warn('open requested during ambiguous close-seek; cancelling close retries instead of sending more pulses');
+            this.clearTimers();
+            this.plan = { kind: 'idle' };
+            this.requestedTarget = null;
+            this.emitSnapshot('cancelled-ambiguous-close-seek');
+            return;
+        }
+        this.requestedTarget = null;
+        this.emitSnapshot('open-request-already-satisfied-openish');
+    }
+    async handleCloseRequest() {
+        if (this.facts.closedSensor === true) {
+            if (this.plan.kind === 'moving' && this.plan.direction === 'opening') {
+                // A very early cancel while we are still on the closed end-stop can be
+                // satisfied by one pulse: stop the opening attempt and remain closed.
+                await this.pulseMotor('cancel-opening-while-still-closed');
+                this.clearTimers();
+                this.plan = { kind: 'idle' };
+                this.requestedTarget = null;
+                this.emitSnapshot('opening-cancelled-before-leaving-closed');
+                return;
+            }
+            this.requestedTarget = null;
+            this.emitSnapshot('close-request-already-satisfied');
+            return;
+        }
+        if (this.plan.kind === 'moving' && this.plan.direction === 'opening' && this.plan.certainty === 'known') {
+            await this.reverseKnownMotion('closing', 'homekit-reverse-known-opening-to-close');
+            return;
+        }
+        if (this.plan.kind === 'waitingSecondPulse' && this.plan.finalDirection === 'opening') {
+            this.io.log.info('close requested while waiting to restart towards open; cancelling open restart');
+            this.clearPhaseTimer();
+            this.plan = { kind: 'idle' };
+            await this.startCloseSeek(0, 'close-after-cancelled-open-restart');
+            return;
+        }
+        if (this.plan.kind === 'waitingSecondPulse' && this.plan.finalDirection === 'closing') {
+            this.emitSnapshot('close-request-already-reversing-to-close');
+            return;
+        }
+        if (this.plan.kind === 'moving' && this.plan.direction === 'closing') {
+            this.emitSnapshot('close-request-already-closing');
+            return;
+        }
+        await this.startCloseSeek(0, 'homekit-close-from-openish');
+    }
+    async startOpeningFromClosed(reason) {
+        if (this.facts.closedSensor !== true) {
+            this.requestedTarget = null;
+            this.emitSnapshot(`${reason}-already-openish`);
+            return;
+        }
+        await this.pulseMotor(reason);
+        this.startOpeningMotion('homekit', `${reason}-pulse-sent`);
+    }
+    async startCloseSeek(attempt, reason) {
+        if (this.facts.closedSensor === true) {
+            this.requestedTarget = null;
+            this.emitSnapshot(`${reason}-already-closed`);
+            return;
+        }
+        await this.pulseMotor(`${reason}-attempt-${attempt + 1}`);
+        this.startClosingMotion('goalOnly', attempt === 0 ? 'homekit' : 'recovery', attempt, `${reason}-pulse-sent`);
+    }
+    async reverseKnownMotion(finalDirection, reason) {
+        await this.pulseMotor(`${reason}-stop-current-motion`);
+        const deadlineAt = Date.now() + this.pulseGapMs + this.travelMs;
+        this.clearMovementTimer();
+        this.plan = {
+            kind: 'waitingSecondPulse',
+            finalDirection,
+            source: 'homekit',
+            attempt: 0,
+            dueAt: Date.now() + this.pulseGapMs,
+            deadlineAt,
+            reason: finalDirection === 'opening' ? 'reverseToOpen' : 'reverseToClose',
+        };
+        this.schedulePhaseTimer(this.plan.dueAt);
+        this.emitSnapshot(`${reason}-waiting-second-pulse`);
+    }
+    startOpeningMotion(source, note) {
+        this.clearPhaseTimer();
+        this.plan = {
+            kind: 'moving',
+            direction: 'opening',
+            certainty: 'known',
+            source,
+            attempt: 0,
+            startedAt: Date.now(),
+            deadlineAt: Date.now() + this.travelMs,
+        };
+        this.scheduleMovementTimer(this.plan.deadlineAt);
+        this.emitSnapshot(note);
+    }
+    startClosingMotion(certainty, source, attempt, note) {
+        this.clearPhaseTimer();
+        this.plan = {
+            kind: 'moving',
+            direction: 'closing',
+            certainty,
+            source,
+            attempt,
+            startedAt: Date.now(),
+            deadlineAt: Date.now() + this.travelMs,
+        };
+        this.scheduleMovementTimer(this.plan.deadlineAt);
+        this.emitSnapshot(note);
+    }
+    scheduleMovementTimer(deadlineAt) {
+        this.clearMovementTimer();
+        const delayMs = Math.max(0, deadlineAt - Date.now());
+        const token = ++this.movementTimerToken;
+        this.movementTimer = setTimeout(() => {
+            void this.enqueue(`movement-timeout-${token}`, async () => {
+                if (token !== this.movementTimerToken) {
+                    return;
+                }
+                await this.handleMovementTimeout();
+            });
+        }, delayMs);
+    }
+    schedulePhaseTimer(dueAt) {
+        this.clearPhaseTimer();
+        const delayMs = Math.max(0, dueAt - Date.now());
+        const token = ++this.phaseTimerToken;
+        this.phaseTimer = setTimeout(() => {
+            void this.enqueue(`phase-timer-${token}`, async () => {
+                if (token !== this.phaseTimerToken) {
+                    return;
+                }
+                await this.handlePhaseTimer();
+            });
+        }, delayMs);
+    }
+    clearMovementTimer() {
+        if (this.movementTimer) {
+            clearTimeout(this.movementTimer);
+            this.movementTimer = undefined;
+        }
+        this.movementTimerToken += 1;
+    }
+    clearPhaseTimer() {
+        if (this.phaseTimer) {
+            clearTimeout(this.phaseTimer);
+            this.phaseTimer = undefined;
+        }
+        this.phaseTimerToken += 1;
+    }
+    clearTimers() {
+        this.clearMovementTimer();
+        this.clearPhaseTimer();
+    }
+    async handlePhaseTimer() {
+        if (this.plan.kind !== 'waitingSecondPulse') {
+            return;
+        }
+        const finalDirection = this.plan.finalDirection;
+        const source = this.plan.source;
+        const attempt = this.plan.attempt;
+        const deadlineAt = this.plan.deadlineAt;
+        await this.pulseMotor(`second-pulse-${finalDirection}`);
+        this.clearPhaseTimer();
+        this.plan = {
+            kind: 'moving',
+            direction: finalDirection,
+            certainty: 'known',
+            source,
+            attempt,
+            startedAt: Date.now(),
+            deadlineAt,
+        };
+        this.scheduleMovementTimer(deadlineAt);
+        this.emitSnapshot(`second-pulse-fired-${finalDirection}`);
+    }
+    async handleMovementTimeout() {
+        if (this.plan.kind !== 'moving') {
+            return;
+        }
+        if (this.facts.closedSensor === true) {
+            this.clearTimers();
+            this.plan = { kind: 'idle' };
+            this.requestedTarget = null;
+            this.emitSnapshot('movement-timeout-but-already-closed');
+            return;
+        }
+        if (this.plan.direction === 'opening') {
+            // Fully-open and partially-open look the same to us. When the opening
+            // window expires we intentionally collapse to the generic open-ish state,
+            // which the Home app will still display as "Opening" per the requested UX.
+            this.clearTimers();
+            this.plan = { kind: 'idle' };
+            this.requestedTarget = null;
+            this.emitSnapshot('opening-window-elapsed-openish');
+            return;
+        }
+        if (this.requestedTarget === 'closed' && this.plan.attempt < this.closeRetryLimit) {
+            const nextAttempt = this.plan.attempt + 1;
+            this.io.log.warn('close window elapsed without a closed-sensor hit; retrying close seek from the generic open-ish state');
+            this.clearTimers();
+            this.plan = { kind: 'idle' };
+            await this.startCloseSeek(nextAttempt, 'close-timeout-retry');
+            return;
+        }
+        this.io.log.warn('close window elapsed without reaching the closed sensor; leaving gate in open-ish state');
+        this.clearTimers();
+        this.plan = { kind: 'idle' };
+        this.requestedTarget = null;
+        this.emitSnapshot('closing-window-elapsed-openish');
+    }
+    enterUnavailable(note) {
+        this.clearTimers();
+        this.plan = { kind: 'idle' };
+        this.requestedTarget = null;
+        this.sensorFreshSinceOnline = false;
+        this.emitSnapshot(note);
+    }
+    isAvailableForHomeKit() {
+        return this.facts.controlConnected === true
+            && this.facts.sensorConnected === true
+            && this.sensorFreshSinceOnline
+            && this.facts.closedSensor !== null;
+    }
+    async pulseMotor(reason) {
+        const elapsed = Date.now() - this.lastPulseLikeActivityAt;
+        if (elapsed < this.pulseGapMs) {
+            await delay(this.pulseGapMs - elapsed);
+        }
+        this.io.log.info(`motor pulse -> ${reason}`);
+        await this.io.pulseMotor(reason);
+        this.lastPulseLikeActivityAt = Date.now();
+    }
+    emitSnapshot(note) {
+        if (this.disposed) {
+            return;
+        }
+        this.io.publishSnapshot(this.buildSnapshot(note));
+    }
+    buildSnapshot(note) {
+        const available = this.isAvailableForHomeKit();
+        return {
+            available,
+            controlConnected: this.facts.controlConnected,
+            sensorConnected: this.facts.sensorConnected,
+            closedSensor: this.facts.closedSensor,
+            sensorFreshSinceOnline: this.sensorFreshSinceOnline,
+            currentDoorState: available ? this.computeCurrentDoorState() : undefined,
+            targetDoorState: available ? this.computeTargetDoorState() : undefined,
+            requestedTarget: this.requestedTarget,
+            motionDirection: this.getMotionDirection(),
+            motionCertainty: this.getMotionCertainty(),
+            planKind: this.plan.kind,
+            note,
+        };
+    }
+    getMotionDirection() {
+        if (this.plan.kind === 'moving') {
+            return this.plan.direction;
+        }
+        if (this.plan.kind === 'waitingSecondPulse') {
+            return this.plan.finalDirection;
+        }
+        return 'none';
+    }
+    getMotionCertainty() {
+        if (this.plan.kind === 'moving') {
+            return this.plan.certainty;
+        }
+        if (this.plan.kind === 'waitingSecondPulse') {
+            return 'known';
+        }
+        return 'none';
+    }
+    computeCurrentDoorState() {
+        if (this.plan.kind === 'moving') {
+            return this.plan.direction === 'closing' ? 3 /* DoorCurrentState.CLOSING */ : 2 /* DoorCurrentState.OPENING */;
+        }
+        if (this.plan.kind === 'waitingSecondPulse') {
+            return this.plan.finalDirection === 'closing' ? 3 /* DoorCurrentState.CLOSING */ : 2 /* DoorCurrentState.OPENING */;
+        }
+        return this.facts.closedSensor ? 1 /* DoorCurrentState.CLOSED */ : 2 /* DoorCurrentState.OPENING */;
+    }
+    computeTargetDoorState() {
+        if (this.requestedTarget) {
+            return this.requestedTarget === 'closed' ? 1 /* DoorTargetState.CLOSED */ : 0 /* DoorTargetState.OPEN */;
+        }
+        if (this.plan.kind === 'moving') {
+            return this.plan.direction === 'closing' ? 1 /* DoorTargetState.CLOSED */ : 0 /* DoorTargetState.OPEN */;
+        }
+        if (this.plan.kind === 'waitingSecondPulse') {
+            return this.plan.finalDirection === 'closing' ? 1 /* DoorTargetState.CLOSED */ : 0 /* DoorTargetState.OPEN */;
+        }
+        return this.facts.closedSensor ? 1 /* DoorTargetState.CLOSED */ : 0 /* DoorTargetState.OPEN */;
+    }
+}
+exports.FrontGateFsm = FrontGateFsm;
+//# sourceMappingURL=FrontGateFsm.js.map