homebridge-navilink 0.1.0

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

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview The space-heating thermostat.
+ *
+ * ## This is a boiler control, not a room thermostat
+ *
+ * The number on this tile is the temperature of the **water** the appliance
+ * sends to the radiators or the underfloor loop, not the temperature of a
+ * room. Setting it to 60 °C does not make the house 60 °C; it makes the flow
+ * hotter, so the house reaches whatever the room thermostat is asking for
+ * sooner and less efficiently.
+ *
+ * HomeKit has no accessory type for "boiler flow temperature", and a
+ * Thermostat is the closest thing it offers. Anyone building an automation on
+ * this tile should know which quantity they are automating, which is why the
+ * README says so and why this accessory is opt-in rather than created by
+ * default.
+ *
+ * ## Off means off
+ *
+ * Unlike the hot water tile, this one's off is wired to the appliance's
+ * space-heating enable, which is exactly the thing being asked about. Turning
+ * it off stops the radiators and leaves the hot water alone, so there is no
+ * reason to hesitate over it.
+ */
+import type { ChannelObservation, RefreshReason } from '../types';
+import { ThermostatAccessory, type SetpointLimits } from './thermostat-accessory';
+/** Space-heating flow temperature, as a HomeKit thermostat. */
+export declare class SpaceHeatingAccessory extends ThermostatAccessory {
+    private hasWarnedNoLoop;
+    protected readSetpoint(observation: ChannelObservation): number | undefined;
+    /**
+     * Say once when this appliance turns out to have no heating loop.
+     *
+     * Only knowable from a live `channelinfo` frame, which arrives after the
+     * accessory is registered, so it can be configured on hardware that cannot
+     * do it.
+     */
+    protected updateFromObservation(observation: ChannelObservation, reason: RefreshReason): void;
+    private warnNoLoop;
+    /** The flow probe: the water going out to the loop. */
+    protected readTemperature(observation: ChannelObservation): number | undefined;
+    protected readLimits(observation: ChannelObservation): SetpointLimits | undefined;
+    protected readEnabled(observation: ChannelObservation): boolean;
+    protected isCommandable(observation: ChannelObservation): boolean;
+    protected sendSetpoint(native: number): Promise<void>;
+    protected sendEnabled(on: boolean): Promise<boolean>;
+    /**
+     * True when this appliance has a loop worth commanding.
+     *
+     * Reads and writes both go through this: a water heater answers the same
+     * frames as a combi and fills the heating fields with placeholders, so a
+     * HomeKit write that reached the cloud would be a command to hardware that
+     * has no radiators attached to it.
+     */
+    private hasHeatingLoop;
+    private requireHeatingLoop;
+    protected optimisticSetpointPatch(native: number): Partial<ChannelObservation>;
+}

package/dist/devices/heating-accessory.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview The space-heating thermostat.
+ *
+ * ## This is a boiler control, not a room thermostat
+ *
+ * The number on this tile is the temperature of the **water** the appliance
+ * sends to the radiators or the underfloor loop, not the temperature of a
+ * room. Setting it to 60 °C does not make the house 60 °C; it makes the flow
+ * hotter, so the house reaches whatever the room thermostat is asking for
+ * sooner and less efficiently.
+ *
+ * HomeKit has no accessory type for "boiler flow temperature", and a
+ * Thermostat is the closest thing it offers. Anyone building an automation on
+ * this tile should know which quantity they are automating, which is why the
+ * README says so and why this accessory is opt-in rather than created by
+ * default.
+ *
+ * ## Off means off
+ *
+ * Unlike the hot water tile, this one's off is wired to the appliance's
+ * space-heating enable, which is exactly the thing being asked about. Turning
+ * it off stops the radiators and leaves the hot water alone, so there is no
+ * reason to hesitate over it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpaceHeatingAccessory = void 0;
+const utils_1 = require("../utils");
+const thermostat_accessory_1 = require("./thermostat-accessory");
+/** Space-heating flow temperature, as a HomeKit thermostat. */
+class SpaceHeatingAccessory extends thermostat_accessory_1.ThermostatAccessory {
+    hasWarnedNoLoop = false;
+    readSetpoint(observation) {
+        // Nothing to report on an appliance with no loop. The fields are present
+        // on a water heater too, filled with placeholders, so returning them
+        // would put a working-looking thermostat on hardware that has no
+        // radiators attached to it.
+        return observation.heatingSupported ? observation.heatSetpoint : undefined;
+    }
+    /**
+     * Say once when this appliance turns out to have no heating loop.
+     *
+     * Only knowable from a live `channelinfo` frame, which arrives after the
+     * accessory is registered, so it can be configured on hardware that cannot
+     * do it.
+     */
+    updateFromObservation(observation, reason) {
+        if (!observation.heatingSupported) {
+            this.warnNoLoop();
+            this.markUnavailable();
+            return;
+        }
+        super.updateFromObservation(observation, reason);
+    }
+    warnNoLoop() {
+        if (this.hasWarnedNoLoop) {
+            return;
+        }
+        this.hasWarnedNoLoop = true;
+        this.host.log.warn(`${(0, utils_1.forLog)(this.displayName)}: this appliance reports no space-heating loop `
+            + '(heatControl is off, or the installer setpoint range is empty). Turn the heating '
+            + 'accessory off in the plugin settings.');
+    }
+    /** The flow probe: the water going out to the loop. */
+    readTemperature(observation) {
+        return observation.heatSupply;
+    }
+    readLimits(observation) {
+        if (!observation.heatingSupported) {
+            return undefined;
+        }
+        const { heatMin, heatMax } = observation;
+        return heatMin === undefined || heatMax === undefined
+            ? undefined
+            : { min: heatMin, max: heatMax };
+    }
+    readEnabled(observation) {
+        return observation.heatingSupported && observation.heating;
+    }
+    isCommandable(observation) {
+        return observation.heatingSupported;
+    }
+    async sendSetpoint(native) {
+        this.requireHeatingLoop();
+        await this.host.control(this.deviceId).setHeatingSetpoint(native);
+    }
+    async sendEnabled(on) {
+        if (!this.hasHeatingLoop()) {
+            this.warnNoLoop();
+            return false;
+        }
+        try {
+            await this.host.control(this.deviceId).setHeating(on);
+            return true;
+        }
+        catch (error) {
+            this.host.log.warn(`${(0, utils_1.forLog)(this.displayName)}: could not ${on ? 'enable' : 'disable'} heating: `
+                + (0, utils_1.describeError)(error));
+            return false;
+        }
+    }
+    /**
+     * True when this appliance has a loop worth commanding.
+     *
+     * Reads and writes both go through this: a water heater answers the same
+     * frames as a combi and fills the heating fields with placeholders, so a
+     * HomeKit write that reached the cloud would be a command to hardware that
+     * has no radiators attached to it.
+     */
+    hasHeatingLoop() {
+        return this.host.observationFor(this.deviceId)?.heatingSupported === true;
+    }
+    requireHeatingLoop() {
+        if (!this.hasHeatingLoop()) {
+            this.warnNoLoop();
+            throw new utils_1.ControlRejectedError('this appliance reports no space-heating loop, so a heating command was not sent');
+        }
+    }
+    optimisticSetpointPatch(native) {
+        return { heatSetpoint: native };
+    }
+}
+exports.SpaceHeatingAccessory = SpaceHeatingAccessory;

package/dist/devices/host.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview The contract between an accessory and the platform.
+ *
+ * An explicit interface rather than a reference to the platform class, for two
+ * reasons. It breaks the import cycle that would otherwise exist between the
+ * platform and the accessories it creates. And it is the whole surface an
+ * accessory is allowed to reach, so a test can supply a dozen-line stand-in
+ * instead of standing up a platform, a cloud session and a socket.
+ *
+ * Note what an accessory cannot do through this interface: it cannot reach the
+ * MQTT connection, build a frame, or see the account. Every write goes through
+ * one of the named intents below, so the rules that govern writes (read-only
+ * mode, the power-off guard, rate limiting) are enforced in one place, not in
+ * each accessory that might forget. Setpoint coalescing is thermostat-only
+ * and lives on {@link ThermostatAccessory}.
+ */
+import type { API, HAP, PlatformAccessory } from 'homebridge';
+import type { ChannelObservation, PluginLogger, ResolvedDevice } from '../types';
+/** What an accessory may ask the appliance to do. */
+export interface ControlIntent {
+    /** Switch the appliance on or off. Subject to the power-off guard. */
+    setPower(on: boolean): Promise<void>;
+    /** Enable or disable space heating. */
+    setHeating(on: boolean): Promise<void>;
+    /** Set the domestic hot water setpoint, in the appliance's native scale. */
+    setDomesticHotWaterSetpoint(native: number): Promise<void>;
+    /** Set the space-heating water setpoint, in the appliance's native scale. */
+    setHeatingSetpoint(native: number): Promise<void>;
+    /** Start or stop the recirculation pump. */
+    setRecirculation(on: boolean): Promise<void>;
+}
+/** Everything an accessory needs from the platform that owns it. */
+export interface AccessoryHost {
+    readonly api: API;
+    readonly hap: HAP;
+    readonly log: PluginLogger;
+    /** This plugin's version, published as FirmwareRevision. */
+    readonly pluginVersion: string;
+    /** True when configuration forbids every write. */
+    readonly isReadOnly: boolean;
+    /** The configured device an accessory belongs to, or undefined if removed. */
+    deviceFor(deviceId: string): ResolvedDevice | undefined;
+    /**
+     * The most recent observation for a device.
+     *
+     * Undefined before the first status frame, and undefined again once the
+     * session has been failing long enough that the last reading should no
+     * longer be presented as current. Accessories treat both the same way: they
+     * report No Response rather than inventing a value.
+     */
+    observationFor(deviceId: string): ChannelObservation | undefined;
+    /** Send a command to an appliance. */
+    control(deviceId: string): ControlIntent;
+    /**
+     * Adopt the result of a write immediately.
+     *
+     * A control command is acknowledged long before a status frame reflects it,
+     * and a tile that springs back to its old value for a second looks like a
+     * write that failed. This lets an accessory publish what it just asked for,
+     * which the next real observation then confirms or corrects.
+     */
+    noteOptimisticWrite(deviceId: string, patch: Partial<ChannelObservation>): void;
+}
+/** What an accessory is handed when it is constructed. */
+export interface AccessoryInit {
+    host: AccessoryHost;
+    accessory: PlatformAccessory;
+    deviceId: string;
+    displayName: string;
+    model: string;
+    serialNumber: string;
+}

package/dist/devices/host.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview The contract between an accessory and the platform.
+ *
+ * An explicit interface rather than a reference to the platform class, for two
+ * reasons. It breaks the import cycle that would otherwise exist between the
+ * platform and the accessories it creates. And it is the whole surface an
+ * accessory is allowed to reach, so a test can supply a dozen-line stand-in
+ * instead of standing up a platform, a cloud session and a socket.
+ *
+ * Note what an accessory cannot do through this interface: it cannot reach the
+ * MQTT connection, build a frame, or see the account. Every write goes through
+ * one of the named intents below, so the rules that govern writes (read-only
+ * mode, the power-off guard, rate limiting) are enforced in one place, not in
+ * each accessory that might forget. Setpoint coalescing is thermostat-only
+ * and lives on {@link ThermostatAccessory}.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/devices/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview Devices barrel.
+ */
+export * from './base-accessory';
+export * from './dhw-accessory';
+export * from './fault-accessory';
+export * from './heating-accessory';
+export * from './host';
+export * from './power-accessory';
+export * from './probe-accessory';
+export * from './recirculation-accessory';
+export * from './thermostat-accessory';

package/dist/devices/index.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview Devices barrel.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base-accessory"), exports);
+__exportStar(require("./dhw-accessory"), exports);
+__exportStar(require("./fault-accessory"), exports);
+__exportStar(require("./heating-accessory"), exports);
+__exportStar(require("./host"), exports);
+__exportStar(require("./power-accessory"), exports);
+__exportStar(require("./probe-accessory"), exports);
+__exportStar(require("./recirculation-accessory"), exports);
+__exportStar(require("./thermostat-accessory"), exports);

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

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview The appliance's power switch.
+ *
+ * Deliberately a separate, opt-in accessory rather than something folded into
+ * a thermostat. Powering a combi appliance down stops the hot water *and* the
+ * central heating, so it deserves a tile that says what it is instead of
+ * hiding behind "off" on a tile labelled Hot Water.
+ *
+ * Turning it off still requires `options.allowPowerOff`. Asking for the switch
+ * is asking to see the state and to be able to switch the appliance back on;
+ * it is not, on its own, a decision that a scene should be able to shut the
+ * heating down. The two are separated because one of them is recoverable from
+ * a phone and the other is recoverable from a cold house.
+ */
+import type { ChannelObservation, RefreshReason } from '../types';
+import { BaseAccessory } from './base-accessory';
+import type { AccessoryInit } from './host';
+/** Appliance power, as a HomeKit switch. */
+export declare class PowerAccessory extends BaseAccessory {
+    private readonly service;
+    private hasExplainedGuard;
+    constructor(init: AccessoryInit);
+    private writeOn;
+    protected updateFromObservation(observation: ChannelObservation, _reason: RefreshReason): void;
+    private restore;
+    private explainGuard;
+}

package/dist/devices/power-accessory.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview The appliance's power switch.
+ *
+ * Deliberately a separate, opt-in accessory rather than something folded into
+ * a thermostat. Powering a combi appliance down stops the hot water *and* the
+ * central heating, so it deserves a tile that says what it is instead of
+ * hiding behind "off" on a tile labelled Hot Water.
+ *
+ * Turning it off still requires `options.allowPowerOff`. Asking for the switch
+ * is asking to see the state and to be able to switch the appliance back on;
+ * it is not, on its own, a decision that a scene should be able to shut the
+ * heating down. The two are separated because one of them is recoverable from
+ * a phone and the other is recoverable from a cold house.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PowerAccessory = void 0;
+const utils_1 = require("../utils");
+const base_accessory_1 = require("./base-accessory");
+/** Appliance power, as a HomeKit switch. */
+class PowerAccessory extends base_accessory_1.BaseAccessory {
+    service;
+    hasExplainedGuard = false;
+    constructor(init) {
+        super(init);
+        const { Characteristic, Service: HapService } = this.host.hap;
+        this.service = this.requireService(HapService.Switch);
+        this.service.setCharacteristic(Characteristic.Name, this.displayName);
+        this.service
+            .getCharacteristic(Characteristic.On)
+            .onGet(() => this.requireObservedState().power)
+            .onSet(async (value) => this.writeOn(value));
+    }
+    async writeOn(value) {
+        const wantOn = value === true;
+        if (this.declineIfReadOnly('change the power')) {
+            this.restore();
+            return;
+        }
+        const observation = this.host.observationFor(this.deviceId);
+        if (observation !== undefined && observation.power === wantOn) {
+            this.host.log.debug(`${(0, utils_1.forLog)(this.displayName)}: already ${wantOn ? 'on' : 'off'}; nothing sent`);
+            return;
+        }
+        await this.completeWithinBudget('power change', async () => {
+            try {
+                await this.host.control(this.deviceId).setPower(wantOn);
+                this.host.noteOptimisticWrite(this.deviceId, { power: wantOn });
+                this.logAction(wantOn ? 'POWER ON' : 'POWER OFF');
+            }
+            catch (error) {
+                if (error instanceof utils_1.ControlRejectedError) {
+                    this.explainGuard(error);
+                }
+                else {
+                    this.host.log.warn(`${(0, utils_1.forLog)(this.displayName)}: could not change power: ${(0, utils_1.describeError)(error)}`);
+                }
+                this.restore();
+            }
+        });
+    }
+    updateFromObservation(observation, _reason) {
+        this.publish(this.service, this.host.hap.Characteristic.On, observation.power);
+    }
+    restore() {
+        const observation = this.host.observationFor(this.deviceId);
+        if (observation === undefined) {
+            return;
+        }
+        this.service.updateCharacteristic(this.host.hap.Characteristic.On, observation.power);
+    }
+    explainGuard(error) {
+        if (this.hasExplainedGuard) {
+            this.host.log.debug(`${(0, utils_1.forLog)(this.displayName)}: ${error.message}`);
+            return;
+        }
+        this.hasExplainedGuard = true;
+        this.host.log.info(`${(0, utils_1.forLog)(this.displayName)}: ${error.message}`);
+    }
+}
+exports.PowerAccessory = PowerAccessory;

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

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview One of the appliance's temperature probes, as a HomeKit sensor.
+ *
+ * Five of them share this implementation, differing only in which field they
+ * read: the hot water inlet and outlet, the heating flow and return, and the
+ * outdoor sensor where one is fitted. They are read-only, and useful mainly
+ * for graphs and for automations that want to know whether the appliance is
+ * doing anything.
+ *
+ * The flow and return pair is the interesting one. The difference between them
+ * is what the appliance is putting into the house, so a HomeKit automation can
+ * notice heating running when nobody asked it to.
+ *
+ * ## Probes that are not fitted
+ *
+ * Whether a probe exists is only knowable from a live status frame, and the
+ * frames arrive after accessories are registered. So a sensor can be created
+ * for something that does not exist. When that turns out to be the case it
+ * says so once and reports No Response. It does not publish the zero the
+ * appliance sends for an absent probe, which would be -17.8 °C on the tile
+ * and could be acted on by an automation.
+ */
+import type { ChannelObservation, ProbeKind, RefreshReason } from '../types';
+import { BaseAccessory } from './base-accessory';
+import type { AccessoryInit } from './host';
+/** What an appliance probe is created with. */
+export interface ProbeAccessoryInit extends AccessoryInit {
+    kind: ProbeKind;
+}
+/** One appliance temperature probe, as a HomeKit sensor. */
+export declare class ProbeAccessory extends BaseAccessory {
+    private readonly service;
+    private readonly kind;
+    private hasWarnedAbsent;
+    constructor(init: ProbeAccessoryInit);
+    private readNative;
+    private readCelsius;
+    protected updateFromObservation(observation: ChannelObservation, _reason: RefreshReason): void;
+    private warnAbsent;
+}

package/dist/devices/probe-accessory.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview One of the appliance's temperature probes, as a HomeKit sensor.
+ *
+ * Five of them share this implementation, differing only in which field they
+ * read: the hot water inlet and outlet, the heating flow and return, and the
+ * outdoor sensor where one is fitted. They are read-only, and useful mainly
+ * for graphs and for automations that want to know whether the appliance is
+ * doing anything.
+ *
+ * The flow and return pair is the interesting one. The difference between them
+ * is what the appliance is putting into the house, so a HomeKit automation can
+ * notice heating running when nobody asked it to.
+ *
+ * ## Probes that are not fitted
+ *
+ * Whether a probe exists is only knowable from a live status frame, and the
+ * frames arrive after accessories are registered. So a sensor can be created
+ * for something that does not exist. When that turns out to be the case it
+ * says so once and reports No Response. It does not publish the zero the
+ * appliance sends for an absent probe, which would be -17.8 °C on the tile
+ * and could be acted on by an automation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProbeAccessory = void 0;
+const utils_1 = require("../utils");
+const base_accessory_1 = require("./base-accessory");
+/** Which observation field each probe accessory reports. */
+const FIELD_BY_KIND = {
+    dhwOutlet: 'dhwOutlet',
+    dhwInlet: 'dhwInlet',
+    heatSupply: 'heatSupply',
+    heatReturn: 'heatReturn',
+    outdoor: 'outdoor',
+};
+/** What to say when a probe turns out not to exist. */
+const ABSENCE_HINT = {
+    dhwOutlet: 'the appliance is not reporting a hot water outlet temperature',
+    dhwInlet: 'the appliance is not reporting a hot water inlet temperature',
+    heatSupply: 'the appliance is not reporting a heating flow temperature',
+    heatReturn: 'the appliance is not reporting a heating return temperature',
+    outdoor: 'no outdoor sensor is fitted, so there is nothing to report',
+};
+/** One appliance temperature probe, as a HomeKit sensor. */
+class ProbeAccessory extends base_accessory_1.BaseAccessory {
+    service;
+    kind;
+    hasWarnedAbsent = false;
+    constructor(init) {
+        super(init);
+        this.kind = init.kind;
+        const { Characteristic, Service: HapService } = this.host.hap;
+        this.service = this.requireService(HapService.TemperatureSensor);
+        this.service.setCharacteristic(Characteristic.Name, this.displayName);
+        this.service
+            .getCharacteristic(Characteristic.CurrentTemperature)
+            .onGet(() => this.readCelsius());
+        // Published so a controller that honours it can grey the sensor out
+        // rather than showing a stale reading for a probe that has gone away.
+        this.service
+            .getCharacteristic(Characteristic.StatusActive)
+            .onGet(() => this.readNative() !== undefined);
+    }
+    readNative() {
+        const observation = this.host.observationFor(this.deviceId);
+        if (observation === undefined) {
+            return undefined;
+        }
+        const value = observation[FIELD_BY_KIND[this.kind]];
+        return typeof value === 'number' ? value : undefined;
+    }
+    readCelsius() {
+        const observation = this.requireObservedState();
+        const native = this.readNative();
+        if (native === undefined) {
+            throw this.communicationFailure();
+        }
+        return (0, utils_1.nativeToCelsius)(native, observation.scale);
+    }
+    updateFromObservation(observation, _reason) {
+        const { Characteristic } = this.host.hap;
+        const value = observation[FIELD_BY_KIND[this.kind]];
+        const native = typeof value === 'number' ? value : undefined;
+        this.publish(this.service, Characteristic.StatusActive, native !== undefined);
+        if (native === undefined) {
+            this.warnAbsent();
+            this.markUnavailable();
+            // StatusActive is the honest "nothing here" flag; keep it after the
+            // temperature characteristic has been greyed.
+            this.publish(this.service, Characteristic.StatusActive, false);
+            return;
+        }
+        this.publish(this.service, Characteristic.CurrentTemperature, (0, utils_1.nativeToCelsius)(native, observation.scale));
+    }
+    warnAbsent() {
+        if (this.hasWarnedAbsent) {
+            return;
+        }
+        this.hasWarnedAbsent = true;
+        this.host.log.warn(`${(0, utils_1.forLog)(this.displayName)}: ${ABSENCE_HINT[this.kind]}`);
+    }
+}
+exports.ProbeAccessory = ProbeAccessory;

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

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2026 tbaur
+ *
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for full license text
+ *
+ * @fileoverview The hot water recirculation switch.
+ *
+ * On an installation with a recirculation pump (Navien's "HotButton" or
+ * on-demand feature) this starts it, so the water at a distant tap is hot by
+ * the time someone gets there. It is the one accessory here with an obvious
+ * and genuinely useful Siri phrase: "turn on the hot water" before walking to
+ * the shower.
+ *
+ * ## It switches itself off, and that is correct
+ *
+ * The appliance runs the pump for a fixed period and then stops. The tile
+ * follows, because it reports what the appliance says, not what was asked
+ * for. A user who has not met this feature before will read the tile
+ * turning itself off as a bug, which is why the README explains it.
+ *
+ * ## It disables itself on hardware that has no pump
+ *
+ * Whether a pump is fitted is only knowable from a live `channelinfo` frame,
+ * which arrives after accessories are registered. So the accessory can be
+ * configured on an appliance that cannot do it, and when that turns out to be
+ * the case it says so once and reports No Response from then on. Silently
+ * accepting presses that do nothing would be worse.
+ */
+import type { ChannelObservation, RefreshReason } from '../types';
+import { BaseAccessory } from './base-accessory';
+import type { AccessoryInit } from './host';
+/** Hot water recirculation, as a HomeKit switch. */
+export declare class RecirculationAccessory extends BaseAccessory {
+    private readonly service;
+    /** Undefined until the first frame says whether a pump is fitted. */
+    private isEquipped;
+    private hasWarnedNotEquipped;
+    constructor(init: AccessoryInit);
+    private readOn;
+    private writeOn;
+    protected updateFromObservation(observation: ChannelObservation, _reason: RefreshReason): void;
+    /** Fitted state from a live frame, or from the last observation if none yet. */
+    private equippedState;
+    private restore;
+    private warnNotEquipped;
+}