homebridge-navilink 0.1.0

package/dist/devices/base-accessory.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview What every accessory in this plugin has in common.
+ *
+ * Three rules are enforced here rather than trusted to each subclass, because
+ * each of them is the kind of thing that is obvious in review and forgotten in
+ * code.
+ *
+ * **Never invent a reading.** If the appliance has not been heard from, a read
+ * throws `SERVICE_COMMUNICATION_FAILURE` and the tile shows No Response. It is
+ * tempting to return the last value, or a plausible default, so the Home app
+ * looks tidy. Both are worse than a grey tile: an automation cannot tell a
+ * remembered 49 °C from a current one, and this plugin drives a gas appliance.
+ * {@link requireObservedState} is the only way a subclass gets state, and it
+ * is the only place that decision is made.
+ *
+ * **Answer HomeKit inside its budget.** HAP abandons a write after nine
+ * seconds and warns at three. A cloud round trip can legitimately take longer
+ * than either, so {@link completeWithinBudget} answers on time and lets the
+ * work finish behind it. Without that, a slow cloud turns every setpoint
+ * change into an error in the Home app even when it worked.
+ *
+ * **Keep identity stable.** Accessory information is written once here, from
+ * values the platform resolved, so no subclass can key an accessory on
+ * something that changes and silently take a user's rooms and automations with
+ * it.
+ */
+import type { Characteristic, CharacteristicValue, PlatformAccessory, Service, WithUUID } from 'homebridge';
+import type { ChannelObservation, RefreshReason } from '../types';
+import type { AccessoryHost, AccessoryInit } from './host';
+/** A concrete HAP service class, such as `Service.Thermostat`. */
+export type ServiceConstructor = {
+    UUID: string;
+    new (displayName?: string, subtype?: string): Service;
+};
+/** A concrete HAP characteristic class, such as `Characteristic.On`. */
+export type CharacteristicConstructor = WithUUID<new () => Characteristic>;
+/** Shared behaviour for every accessory this plugin exposes. */
+export declare abstract class BaseAccessory {
+    protected readonly host: AccessoryHost;
+    protected readonly accessory: PlatformAccessory;
+    readonly deviceId: string;
+    readonly displayName: string;
+    /** True once the platform has torn this accessory down. */
+    private stopped;
+    /** Said once rather than on every write, so a scene cannot flood the log. */
+    private hasExplainedReadOnly;
+    constructor(init: AccessoryInit);
+    /** Apply a fresh observation. Called by the platform, never by a subclass. */
+    applyObservation(observation: ChannelObservation, reason: RefreshReason): void;
+    /** Report that the appliance can no longer be heard from. */
+    noteUnreachable(error: unknown): void;
+    /** Release anything held. After this the accessory ignores every update. */
+    stop(): void;
+    /**
+     * The current observation, or a HAP communication failure.
+     *
+     * The single place an accessory is allowed to obtain state, so the decision
+     * to report No Response rather than a remembered value is made once. See the
+     * file header.
+     */
+    protected requireObservedState(): ChannelObservation;
+    /** The HAP error that makes a tile show No Response. */
+    protected communicationFailure(): Error;
+    /**
+     * Run a write, answering HomeKit within its budget.
+     *
+     * On time, the caller's promise decides the outcome. Over budget, HomeKit is
+     * told the write succeeded and the work carries on; the next observation is
+     * what corrects the tile if it did not. That is the honest trade: HAP has
+     * already stopped listening by then, so the alternative is not a truthful
+     * error but a `OPERATION_TIMED_OUT` for a command that is still in flight
+     * and will probably land.
+     */
+    protected completeWithinBudget(label: string, work: () => Promise<void>): Promise<void>;
+    /**
+     * Fetch or create a service, so a restart reuses the cached one.
+     *
+     * Matched by UUID against the restored service list rather than through
+     * `getService`, whose generic signature does not admit a concrete service
+     * subclass without a cast. Reusing the restored service is what preserves
+     * the user's room assignment, custom name and automations across a restart.
+     */
+    protected requireService(type: ServiceConstructor): Service;
+    /** Remove a service this accessory no longer exposes. */
+    protected dropService(type: ServiceConstructor): void;
+    /** Publish a characteristic only when the value has actually changed. */
+    protected publish(service: Service, characteristic: CharacteristicConstructor, value: CharacteristicValue): void;
+    /** One line per accepted command, at info level, with no secrets in it. */
+    protected logAction(action: string, detail?: string): void;
+    /**
+     * True when the write must not happen, having said so at most once.
+     *
+     * Shared so a thermostat, a power switch and recirculation all use the same
+     * sentence when `options.readOnly` is on.
+     */
+    protected declineIfReadOnly(what: string): boolean;
+    /** Update Accessory Information once the appliance has named itself. */
+    updateIdentity(input: {
+        model: string;
+        firmware?: string;
+    }): void;
+    /**
+     * Write the Accessory Information service.
+     *
+     * SerialNumber is the opaque generated value, never the gateway MAC: the
+     * Home app shows it, so it ends up in screenshots and bug reports, and the
+     * MAC is the appliance's address in every MQTT topic.
+     */
+    private configureAccessoryInformation;
+    /** Apply an observation to this accessory's characteristics. */
+    protected abstract updateFromObservation(observation: ChannelObservation, reason: RefreshReason): void;
+    /**
+     * Report No Response immediately.
+     *
+     * HAP only greys a tile when a read throws or a characteristic is updated
+     * with {@link HapStatusError}. The session has already dropped the
+     * observation, so the next GET would fail; this makes the tile follow now.
+     */
+    protected markUnavailable(): void;
+    /** Keep the last observed scale so a restart can honour display units. */
+    private persistScale;
+}

package/dist/devices/base-accessory.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview What every accessory in this plugin has in common.
+ *
+ * Three rules are enforced here rather than trusted to each subclass, because
+ * each of them is the kind of thing that is obvious in review and forgotten in
+ * code.
+ *
+ * **Never invent a reading.** If the appliance has not been heard from, a read
+ * throws `SERVICE_COMMUNICATION_FAILURE` and the tile shows No Response. It is
+ * tempting to return the last value, or a plausible default, so the Home app
+ * looks tidy. Both are worse than a grey tile: an automation cannot tell a
+ * remembered 49 °C from a current one, and this plugin drives a gas appliance.
+ * {@link requireObservedState} is the only way a subclass gets state, and it
+ * is the only place that decision is made.
+ *
+ * **Answer HomeKit inside its budget.** HAP abandons a write after nine
+ * seconds and warns at three. A cloud round trip can legitimately take longer
+ * than either, so {@link completeWithinBudget} answers on time and lets the
+ * work finish behind it. Without that, a slow cloud turns every setpoint
+ * change into an error in the Home app even when it worked.
+ *
+ * **Keep identity stable.** Accessory information is written once here, from
+ * values the platform resolved, so no subclass can key an accessory on
+ * something that changes and silently take a user's rooms and automations with
+ * it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAccessory = void 0;
+const settings_1 = require("../settings");
+const utils_1 = require("../utils");
+/** Shared behaviour for every accessory this plugin exposes. */
+class BaseAccessory {
+    host;
+    accessory;
+    deviceId;
+    displayName;
+    /** True once the platform has torn this accessory down. */
+    stopped = false;
+    /** Said once rather than on every write, so a scene cannot flood the log. */
+    hasExplainedReadOnly = false;
+    constructor(init) {
+        this.host = init.host;
+        this.accessory = init.accessory;
+        this.deviceId = init.deviceId;
+        this.displayName = init.displayName;
+        this.configureAccessoryInformation(init);
+    }
+    /** Apply a fresh observation. Called by the platform, never by a subclass. */
+    applyObservation(observation, reason) {
+        if (this.stopped) {
+            return;
+        }
+        this.persistScale(observation.scale);
+        try {
+            this.updateFromObservation(observation, reason);
+        }
+        catch (error) {
+            // A subclass fault must not stop the other accessories being updated
+            // from the same frame.
+            this.host.log.debug(`${(0, utils_1.forLog)(this.displayName)}: could not apply an observation: ${(0, utils_1.describeError)(error)}`);
+        }
+    }
+    /** Report that the appliance can no longer be heard from. */
+    noteUnreachable(error) {
+        if (this.stopped) {
+            return;
+        }
+        this.host.log.debug(`${(0, utils_1.forLog)(this.displayName)}: unreachable: ${(0, utils_1.describeError)(error)}`);
+        this.markUnavailable();
+    }
+    /** Release anything held. After this the accessory ignores every update. */
+    stop() {
+        this.stopped = true;
+    }
+    /**
+     * The current observation, or a HAP communication failure.
+     *
+     * The single place an accessory is allowed to obtain state, so the decision
+     * to report No Response rather than a remembered value is made once. See the
+     * file header.
+     */
+    requireObservedState() {
+        const observation = this.host.observationFor(this.deviceId);
+        if (observation === undefined) {
+            throw this.communicationFailure();
+        }
+        return observation;
+    }
+    /** The HAP error that makes a tile show No Response. */
+    communicationFailure() {
+        return new this.host.api.hap.HapStatusError(-70402 /* this.host.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+    }
+    /**
+     * Run a write, answering HomeKit within its budget.
+     *
+     * On time, the caller's promise decides the outcome. Over budget, HomeKit is
+     * told the write succeeded and the work carries on; the next observation is
+     * what corrects the tile if it did not. That is the honest trade: HAP has
+     * already stopped listening by then, so the alternative is not a truthful
+     * error but a `OPERATION_TIMED_OUT` for a command that is still in flight
+     * and will probably land.
+     */
+    async completeWithinBudget(label, work) {
+        const started = work();
+        // Attached before the race so a later rejection cannot become an unhandled
+        // rejection once the race has moved on without it.
+        const settled = started.catch((error) => {
+            this.host.log.warn(`${(0, utils_1.forLog)(this.displayName)}: ${label} failed: ${(0, utils_1.describeError)(error)}`);
+        });
+        const outcome = await (0, utils_1.raceTimeout)(started, settings_1.HOMEKIT_WRITE_BUDGET_MS);
+        if (outcome === utils_1.TIMED_OUT) {
+            this.host.log.debug(`${(0, utils_1.forLog)(this.displayName)}: ${label} is taking longer than `
+                + `${settings_1.HOMEKIT_WRITE_BUDGET_MS}ms; answering HomeKit and finishing in the background`);
+            void settled;
+        }
+    }
+    /**
+     * Fetch or create a service, so a restart reuses the cached one.
+     *
+     * Matched by UUID against the restored service list rather than through
+     * `getService`, whose generic signature does not admit a concrete service
+     * subclass without a cast. Reusing the restored service is what preserves
+     * the user's room assignment, custom name and automations across a restart.
+     */
+    requireService(type) {
+        const existing = this.accessory.services.find((service) => service.UUID === type.UUID);
+        return existing ?? this.accessory.addService(new type(this.displayName));
+    }
+    /** Remove a service this accessory no longer exposes. */
+    dropService(type) {
+        const stale = this.accessory.services.find((service) => service.UUID === type.UUID);
+        if (stale !== undefined) {
+            this.accessory.removeService(stale);
+        }
+    }
+    /** Publish a characteristic only when the value has actually changed. */
+    publish(service, characteristic, value) {
+        const current = service.getCharacteristic(characteristic).value;
+        if (current === value) {
+            return;
+        }
+        service.updateCharacteristic(characteristic, value);
+    }
+    /** One line per accepted command, at info level, with no secrets in it. */
+    logAction(action, detail) {
+        this.host.log.info(`${(0, utils_1.forLog)(this.displayName)}: ${action}${detail === undefined ? '' : ` ${detail}`}`);
+    }
+    /**
+     * True when the write must not happen, having said so at most once.
+     *
+     * Shared so a thermostat, a power switch and recirculation all use the same
+     * sentence when `options.readOnly` is on.
+     */
+    declineIfReadOnly(what) {
+        if (!this.host.isReadOnly) {
+            return false;
+        }
+        if (!this.hasExplainedReadOnly) {
+            this.hasExplainedReadOnly = true;
+            this.host.log.info(`${(0, utils_1.forLog)(this.displayName)}: ignoring a request to ${what}; `
+                + 'options.readOnly is on in the plugin settings');
+        }
+        return true;
+    }
+    /** Update Accessory Information once the appliance has named itself. */
+    updateIdentity(input) {
+        const { Characteristic, Service: HapService } = this.host.hap;
+        const service = this.accessory.getService(HapService.AccessoryInformation);
+        if (service === undefined) {
+            return;
+        }
+        this.publish(service, Characteristic.Model, input.model);
+        if (input.firmware !== undefined && Characteristic.HardwareRevision !== undefined) {
+            this.publish(service, Characteristic.HardwareRevision, input.firmware);
+        }
+        const context = this.accessory.context;
+        context.model = input.model;
+    }
+    /**
+     * Write the Accessory Information service.
+     *
+     * SerialNumber is the opaque generated value, never the gateway MAC: the
+     * Home app shows it, so it ends up in screenshots and bug reports, and the
+     * MAC is the appliance's address in every MQTT topic.
+     */
+    configureAccessoryInformation(init) {
+        const { Characteristic, Service: HapService } = this.host.hap;
+        const service = this.accessory.getService(HapService.AccessoryInformation)
+            ?? this.accessory.addService(HapService.AccessoryInformation);
+        service
+            .setCharacteristic(Characteristic.Manufacturer, settings_1.MANUFACTURER)
+            .setCharacteristic(Characteristic.Model, init.model)
+            .setCharacteristic(Characteristic.SerialNumber, init.serialNumber)
+            .setCharacteristic(Characteristic.FirmwareRevision, this.host.pluginVersion)
+            .setCharacteristic(Characteristic.Name, this.displayName);
+    }
+    /**
+     * Report No Response immediately.
+     *
+     * HAP only greys a tile when a read throws or a characteristic is updated
+     * with {@link HapStatusError}. The session has already dropped the
+     * observation, so the next GET would fail; this makes the tile follow now.
+     */
+    markUnavailable() {
+        const { HapStatusError, HAPStatus } = this.host.api.hap;
+        const error = new HapStatusError(-70402 /* HAPStatus.SERVICE_COMMUNICATION_FAILURE */);
+        const infoUuid = this.host.hap.Service.AccessoryInformation.UUID;
+        for (const service of this.accessory.services) {
+            if (service.UUID === infoUuid) {
+                continue;
+            }
+            for (const characteristic of service.characteristics) {
+                characteristic.updateValue(error);
+            }
+        }
+    }
+    /** Keep the last observed scale so a restart can honour display units. */
+    persistScale(scale) {
+        const context = this.accessory.context;
+        if (context.scale === scale) {
+            return;
+        }
+        context.scale = scale;
+    }
+}
+exports.BaseAccessory = BaseAccessory;

package/dist/devices/dhw-accessory.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview The domestic hot water thermostat.
+ *
+ * The accessory most people install this plugin for: the temperature of the
+ * water at the taps, as a tile, a scene value and a Siri phrase.
+ *
+ * ## Why "off" does not normally turn anything off
+ *
+ * A combi appliance has no separate switch for hot water. There is one power
+ * state, and it governs the space-heating loop as well. So the only thing
+ * `TargetHeatingCoolingState.OFF` could be wired to is the appliance's power,
+ * and that makes "Hey Siri, turn off the hot water", or a bedtime scene that
+ * sweeps every switch off, or a HomeKit "turn everything off", into a command
+ * that also stops the central heating. In a house that is empty in February,
+ * that is a burst pipe.
+ *
+ * So by default this tile declines an off. It says why, once, and springs
+ * back. Someone who genuinely wants HomeKit to be able to shut the appliance
+ * down turns on `options.allowPowerOff`, and at that point off means off.
+ *
+ * This is a departure from the usual rule that an accessory does what HomeKit
+ * asks. It is made deliberately and in one direction only: the plugin will
+ * always heat when asked, and hesitates only about stopping.
+ */
+import type { ChannelObservation } from '../types';
+import type { AccessoryInit } from './host';
+import { ThermostatAccessory, type SetpointLimits } from './thermostat-accessory';
+/** Hot water temperature, as a HomeKit thermostat. */
+export declare class DomesticHotWaterAccessory extends ThermostatAccessory {
+    /** Said once per session rather than once per press. */
+    private hasExplainedPowerGuard;
+    constructor(init: AccessoryInit);
+    protected readSetpoint(observation: ChannelObservation): number | undefined;
+    /**
+     * The outlet probe: the water actually leaving the appliance.
+     *
+     * Not the setpoint, and not the inlet. Between draws this reads well below
+     * the setpoint, which is correct and occasionally surprising. The
+     * appliance is not keeping a tank hot, it heats on demand. Reporting the
+     * setpoint here instead would make the tile look tidy and mean nothing.
+     */
+    protected readTemperature(observation: ChannelObservation): number | undefined;
+    protected readLimits(observation: ChannelObservation): SetpointLimits | undefined;
+    /**
+     * Hot water is available whenever the appliance is on.
+     *
+     * There is no per-demand enable for hot water on the families this plugin
+     * supports, so the honest answer is that it is on when the appliance is on.
+     * The base class already requires `power`, so this is unconditional rather
+     * than reading a flag that does not exist.
+     */
+    protected readEnabled(_observation: ChannelObservation): boolean;
+    protected sendSetpoint(native: number): Promise<void>;
+    protected sendEnabled(on: boolean): Promise<boolean>;
+    protected optimisticSetpointPatch(native: number): Partial<ChannelObservation>;
+    private explainPowerGuard;
+}

package/dist/devices/dhw-accessory.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview The domestic hot water thermostat.
+ *
+ * The accessory most people install this plugin for: the temperature of the
+ * water at the taps, as a tile, a scene value and a Siri phrase.
+ *
+ * ## Why "off" does not normally turn anything off
+ *
+ * A combi appliance has no separate switch for hot water. There is one power
+ * state, and it governs the space-heating loop as well. So the only thing
+ * `TargetHeatingCoolingState.OFF` could be wired to is the appliance's power,
+ * and that makes "Hey Siri, turn off the hot water", or a bedtime scene that
+ * sweeps every switch off, or a HomeKit "turn everything off", into a command
+ * that also stops the central heating. In a house that is empty in February,
+ * that is a burst pipe.
+ *
+ * So by default this tile declines an off. It says why, once, and springs
+ * back. Someone who genuinely wants HomeKit to be able to shut the appliance
+ * down turns on `options.allowPowerOff`, and at that point off means off.
+ *
+ * This is a departure from the usual rule that an accessory does what HomeKit
+ * asks. It is made deliberately and in one direction only: the plugin will
+ * always heat when asked, and hesitates only about stopping.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomesticHotWaterAccessory = void 0;
+const utils_1 = require("../utils");
+const thermostat_accessory_1 = require("./thermostat-accessory");
+/** Hot water temperature, as a HomeKit thermostat. */
+class DomesticHotWaterAccessory extends thermostat_accessory_1.ThermostatAccessory {
+    /** Said once per session rather than once per press. */
+    hasExplainedPowerGuard = false;
+    constructor(init) {
+        super(init);
+    }
+    readSetpoint(observation) {
+        return observation.dhwSetpoint;
+    }
+    /**
+     * The outlet probe: the water actually leaving the appliance.
+     *
+     * Not the setpoint, and not the inlet. Between draws this reads well below
+     * the setpoint, which is correct and occasionally surprising. The
+     * appliance is not keeping a tank hot, it heats on demand. Reporting the
+     * setpoint here instead would make the tile look tidy and mean nothing.
+     */
+    readTemperature(observation) {
+        return observation.dhwOutlet;
+    }
+    readLimits(observation) {
+        const { dhwMin, dhwMax } = observation;
+        return dhwMin === undefined || dhwMax === undefined ? undefined : { min: dhwMin, max: dhwMax };
+    }
+    /**
+     * Hot water is available whenever the appliance is on.
+     *
+     * There is no per-demand enable for hot water on the families this plugin
+     * supports, so the honest answer is that it is on when the appliance is on.
+     * The base class already requires `power`, so this is unconditional rather
+     * than reading a flag that does not exist.
+     */
+    readEnabled(_observation) {
+        return true;
+    }
+    async sendSetpoint(native) {
+        await this.host.control(this.deviceId).setDomesticHotWaterSetpoint(native);
+    }
+    async sendEnabled(on) {
+        try {
+            await this.host.control(this.deviceId).setPower(on);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof utils_1.ControlRejectedError) {
+                this.explainPowerGuard(error);
+                return false;
+            }
+            this.host.log.warn(`${(0, utils_1.forLog)(this.displayName)}: could not change the power state: ${(0, utils_1.describeError)(error)}`);
+            return false;
+        }
+    }
+    optimisticSetpointPatch(native) {
+        return { dhwSetpoint: native };
+    }
+    explainPowerGuard(error) {
+        if (this.hasExplainedPowerGuard) {
+            this.host.log.debug(`${(0, utils_1.forLog)(this.displayName)}: ${error.message}`);
+            return;
+        }
+        this.hasExplainedPowerGuard = true;
+        this.host.log.info(`${(0, utils_1.forLog)(this.displayName)}: ${error.message}`);
+    }
+}
+exports.DomesticHotWaterAccessory = DomesticHotWaterAccessory;

package/dist/devices/fault-accessory.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview A contact sensor that opens when the appliance reports a fault.
+ *
+ * A contact sensor rather than anything cleverer, because HomeKit will send a
+ * push notification when one opens and will trigger an automation from it.
+ * That is the entire point: a combi appliance that has locked out in January
+ * is worth knowing about before the shower is cold, and the NaviLink app's own
+ * notifications are easy to miss.
+ *
+ * The error code is not published as a value. HomeKit has nowhere to show a
+ * number. It is logged, with its sub-code, so the log says what to look
+ * up in the manual, not only that something is wrong.
+ */
+import type { ChannelObservation, RefreshReason } from '../types';
+import { BaseAccessory } from './base-accessory';
+import type { AccessoryInit } from './host';
+/** Appliance fault state, as a HomeKit contact sensor. */
+export declare class FaultAccessory extends BaseAccessory {
+    private readonly service;
+    /** The code last logged, so a standing fault is reported once, not hourly. */
+    private lastLoggedCode;
+    constructor(init: AccessoryInit);
+    private readState;
+    protected updateFromObservation(observation: ChannelObservation, _reason: RefreshReason): void;
+    private logCodeChange;
+}

package/dist/devices/fault-accessory.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview A contact sensor that opens when the appliance reports a fault.
+ *
+ * A contact sensor rather than anything cleverer, because HomeKit will send a
+ * push notification when one opens and will trigger an automation from it.
+ * That is the entire point: a combi appliance that has locked out in January
+ * is worth knowing about before the shower is cold, and the NaviLink app's own
+ * notifications are easy to miss.
+ *
+ * The error code is not published as a value. HomeKit has nowhere to show a
+ * number. It is logged, with its sub-code, so the log says what to look
+ * up in the manual, not only that something is wrong.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FaultAccessory = void 0;
+const utils_1 = require("../utils");
+const base_accessory_1 = require("./base-accessory");
+/** Appliance fault state, as a HomeKit contact sensor. */
+class FaultAccessory extends base_accessory_1.BaseAccessory {
+    service;
+    /** The code last logged, so a standing fault is reported once, not hourly. */
+    lastLoggedCode;
+    constructor(init) {
+        super(init);
+        const { Characteristic, Service: HapService } = this.host.hap;
+        this.service = this.requireService(HapService.ContactSensor);
+        this.service.setCharacteristic(Characteristic.Name, this.displayName);
+        this.service
+            .getCharacteristic(Characteristic.ContactSensorState)
+            .onGet(() => this.readState());
+    }
+    readState() {
+        const { ContactSensorState } = this.host.hap.Characteristic;
+        const observation = this.requireObservedState();
+        // "Detected" is HomeKit's word for a closed contact, which is the resting
+        // state. A fault opens it, which is what raises a notification.
+        return observation.readings.errorCode === 0
+            ? ContactSensorState.CONTACT_DETECTED
+            : ContactSensorState.CONTACT_NOT_DETECTED;
+    }
+    updateFromObservation(observation, _reason) {
+        const { ContactSensorState } = this.host.hap.Characteristic;
+        const { errorCode, subErrorCode } = observation.readings;
+        this.publish(this.service, this.host.hap.Characteristic.ContactSensorState, errorCode === 0
+            ? ContactSensorState.CONTACT_DETECTED
+            : ContactSensorState.CONTACT_NOT_DETECTED);
+        this.logCodeChange(errorCode, subErrorCode);
+    }
+    logCodeChange(errorCode, subErrorCode) {
+        if (errorCode === this.lastLoggedCode) {
+            return;
+        }
+        const previous = this.lastLoggedCode;
+        this.lastLoggedCode = errorCode;
+        if (errorCode === 0) {
+            // First healthy frame is the resting state, not a transition.
+            if (previous !== undefined) {
+                this.host.log.info(`${(0, utils_1.forLog)(this.displayName)}: the fault has cleared`);
+            }
+            return;
+        }
+        this.host.log.warn(`${(0, utils_1.forLog)(this.displayName)}: the appliance reports error ${errorCode}`
+            + `${subErrorCode === 0 ? '' : `.${subErrorCode}`}; `
+            + 'look the code up in the installation manual');
+    }
+}
+exports.FaultAccessory = FaultAccessory;