@camstack/addon-provider-bosch 0.1.44 → 0.1.45

package/dist/homecom/addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_bosch_instances = require("../bosch-instances-CXMUquuA.js");
-const require_account_integration_offline = require("../account-integration-offline-CFyuKmsG.js");
+const require_bosch_instances = require("../bosch-instances-DdklwoKS.js");
+const require_account_integration_offline = require("../account-integration-offline-BiXbzZsg.js");
 let node_crypto = require("node:crypto");
 //#region src/homecom/config.ts
 var HOMECOM_BRANDS = ["bosch", "buderus"];
@@ -267,36 +267,6 @@ function unsupportedDeviceTypeMessage(deviceType) {
 	return new HomeComUnknownDeviceTypeError(deviceType ?? "(missing)").message;
 }
 //#endregion
-//#region src/homecom/homecom-oauth.ts
-/**
-* Public OAuth client of the HomeCom Easy app, signed in through SingleKey ID.
-*
-* A PKCE client has no secret. The values are the ones SingleKey accepts for this client id
-* today: the same authorize query the MIT-licensed `homecom_alt` client records
-* (`OAUTH_LOGIN_PARAMS` — parameters, not copied code) and that the Home Assistant integration
-* opens. `pointt.gateway.resource.dopair` is not a scope this client may request; SingleKey
-* answers `misconfigured-application` and never shows the login page. The scope it does accept
-* names `pointt.gateway.resource.dashapp`, and the Bosch app sends `style_id=tt_bsch`.
-*/
-var HOMECOM_CLIENT_ID = "762162C0-FA2D-4540-AE66-6489F189FADC";
-var HOMECOM_AUTHORIZE_URL = "https://singlekey-id.com/auth/connect/authorize";
-var HOMECOM_TOKEN_URL = "https://singlekey-id.com/auth/connect/token";
-var HOMECOM_STYLE_ID = "tt_bsch";
-var HOMECOM_SCOPE = [
-	"openid",
-	"email",
-	"profile",
-	"offline_access",
-	"pointt.gateway.claiming",
-	"pointt.gateway.removal",
-	"pointt.gateway.list",
-	"pointt.gateway.users",
-	"pointt.gateway.resource.dashapp",
-	"pointt.castt.flow.token-exchange",
-	"bacon",
-	"hcc.tariff.read"
-].join(" ");
-//#endregion
 //#region src/homecom/homecom-domain-mapping.ts
 var MODE_MAP = {
 	Off: "off",
@@ -717,6 +687,352 @@ function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
+//#region src/homecom/homecom-heat-pump.ts
+/**
+* Heat-pump resources of a hydronic gateway (D1026).
+*
+* UNVERIFIED: the paths below come from the layout of the public HomeCom Easy
+* tree as the MIT `homecom_alt` library lists it, and were not checked against a
+* live heat pump. They live in this one table so a wrong path is a one-line
+* fix, and a resource the gateway does not answer reads as `null` (never 0),
+* which the hero then simply does not draw.
+*/
+var HEAT_PUMP_PATHS = {
+	system: {
+		silent: "/heatSources/hs1/silentMode",
+		away: "/system/awayMode",
+		additionalHeater: "/heatSources/hs1/additionalHeaterMode",
+		holiday: "/system/holidayMode"
+	},
+	readings: {
+		thermalW: "/heatSources/hs1/heatPumpPower",
+		electricalW: "/heatSources/hs1/electricalPower",
+		compressorPct: "/heatSources/hs1/compressorModulation",
+		supply: "/heatSources/hs1/supplyTemperature",
+		return: "/heatSources/hs1/returnTemperature",
+		outdoor: "/system/sensors/temperatures/outdoor_t1",
+		thermalKwh: "/recordings/heatSources/total/thermalEnergy",
+		electricalKwh: "/recordings/heatSources/total/electricalEnergy",
+		pressureBar: "/heatSources/hs1/waterPressure",
+		starts: "/heatSources/hs1/numberOfStarts"
+	},
+	circuit: {
+		operationMode: "operationMode",
+		heatCoolMode: "heatCoolMode",
+		summerWinter: "suWiSwitchMode",
+		comfort: "temperatureLevels/comfort2",
+		eco: "temperatureLevels/eco",
+		maxFlow: "maxSupplyTemperature",
+		current: "roomtemperature",
+		target: "currentRoomSetpoint"
+	},
+	dhw: {
+		operationMode: "operationMode",
+		level: "currentTemperatureLevel",
+		chargeDuration: "charge/duration",
+		charge: "charge",
+		current: "actualTemp",
+		target: "currentSetpoint"
+	}
+};
+/** A write the gateway would refuse, caught before it is sent. */
+var HomeComHeatPumpRefusalError = class extends Error {
+	name = "HomeComHeatPumpRefusalError";
+};
+async function readHeatPump(input) {
+	const get = safeGet(input.get, input.onFailure);
+	const circuits = await Promise.all([...input.circuitIds.hc.map((id) => readHc(get, id)), ...input.circuitIds.dhw.map((id) => readDhwCircuit(get, id))]);
+	const r = HEAT_PUMP_PATHS.readings;
+	const s = HEAT_PUMP_PATHS.system;
+	const [silent, away, additionalHeater, holiday] = await Promise.all([
+		setting(get, s.silent),
+		setting(get, s.away),
+		setting(get, s.additionalHeater),
+		setting(get, s.holiday)
+	]);
+	const [thermalW, electricalW, compressorPct, supply, ret, outdoor] = await Promise.all([
+		num(get, r.thermalW),
+		num(get, r.electricalW),
+		num(get, r.compressorPct),
+		num(get, r.supply),
+		num(get, r.return),
+		num(get, r.outdoor)
+	]);
+	const [thermalKwh, electricalKwh, pressureBar, starts] = await Promise.all([
+		num(get, r.thermalKwh),
+		num(get, r.electricalKwh),
+		num(get, r.pressureBar),
+		num(get, r.starts)
+	]);
+	return {
+		circuits,
+		silent,
+		away,
+		additionalHeater,
+		holiday,
+		thermalW,
+		electricalW,
+		compressorPct,
+		supply,
+		return: ret,
+		outdoor,
+		thermalKwh,
+		electricalKwh,
+		pressureBar,
+		starts
+	};
+}
+/** Any failure of a heat-pump read (HTTP 4xx/5xx, a throw) is "not answered", never an error. */
+function safeGet(get, onFailure) {
+	return async (path) => {
+		try {
+			return await get(path);
+		} catch (error) {
+			onFailure?.(path, error);
+			return null;
+		}
+	};
+}
+/**
+* True when a HEAT PUMP answered: silent mode, the auxiliary heater, heat-pump
+* power or compressor modulation. Flow temperatures, pressure and starts are left
+* out on purpose: a gas boiler's heat source answers those too, and it is no heat pump.
+*/
+function hasHeatSource(reading) {
+	return [
+		reading.silent,
+		reading.additionalHeater,
+		reading.thermalW,
+		reading.electricalW,
+		reading.compressorPct
+	].some((v) => v !== null);
+}
+async function readHc(get, id) {
+	const base = `/heatingCircuits/${id}`;
+	const p = HEAT_PUMP_PATHS.circuit;
+	const [operationMode, heatCoolMode, summerWinter, comfort, eco, maxFlow, current, target] = await Promise.all([
+		setting(get, `${base}/${p.operationMode}`),
+		setting(get, `${base}/${p.heatCoolMode}`),
+		setting(get, `${base}/${p.summerWinter}`),
+		setting(get, `${base}/${p.comfort}`),
+		setting(get, `${base}/${p.eco}`),
+		setting(get, `${base}/${p.maxFlow}`),
+		num(get, `${base}/${p.current}`),
+		num(get, `${base}/${p.target}`)
+	]);
+	return {
+		id,
+		kind: "hc",
+		currentTemp: current,
+		targetTemp: target,
+		operationMode,
+		heatCoolMode,
+		summerWinter,
+		comfort,
+		eco,
+		maxFlow,
+		level: null,
+		chargeDuration: null,
+		charge: null
+	};
+}
+async function readDhwCircuit(get, id) {
+	const base = `/dhwCircuits/${id}`;
+	const p = HEAT_PUMP_PATHS.dhw;
+	const [operationMode, level, chargeDuration, charge, current, target] = await Promise.all([
+		setting(get, `${base}/${p.operationMode}`),
+		setting(get, `${base}/${p.level}`),
+		setting(get, `${base}/${p.chargeDuration}`),
+		setting(get, `${base}/${p.charge}`),
+		num(get, `${base}/${p.current}`),
+		num(get, `${base}/${p.target}`)
+	]);
+	return {
+		id,
+		kind: "dhw",
+		currentTemp: current,
+		targetTemp: target,
+		operationMode,
+		heatCoolMode: null,
+		summerWinter: null,
+		comfort: null,
+		eco: null,
+		maxFlow: null,
+		level,
+		chargeDuration,
+		charge
+	};
+}
+async function setting(get, path) {
+	const envelope = readEnvelope(await get(path));
+	return envelope === null ? null : settingOf(path, envelope);
+}
+async function num(get, path) {
+	const envelope = readEnvelope(await get(path));
+	return envelope !== null && typeof envelope.value === "number" && Number.isFinite(envelope.value) ? envelope.value : null;
+}
+function settingOf(path, envelope) {
+	return {
+		path,
+		value: envelope.value,
+		min: envelope.min,
+		max: envelope.max,
+		allowed: envelope.allowed
+	};
+}
+function heatPumpStatusFrom(reading, now) {
+	return {
+		circuits: reading.circuits.map(circuitOf),
+		system: {
+			silent: optionOf(reading.silent),
+			away: optionOf(reading.away),
+			additionalHeater: optionOf(reading.additionalHeater),
+			holiday: optionOf(reading.holiday)
+		},
+		power: {
+			thermalW: reading.thermalW,
+			electricalW: reading.electricalW,
+			compressorPct: reading.compressorPct
+		},
+		temperatures: {
+			supply: reading.supply,
+			return: reading.return,
+			outdoor: reading.outdoor
+		},
+		energy: {
+			thermalKwh: reading.thermalKwh,
+			electricalKwh: reading.electricalKwh
+		},
+		waterPressureBar: reading.pressureBar,
+		starts: reading.starts,
+		lastFetchedAt: now
+	};
+}
+function circuitOf(c) {
+	const kind = kindOf(c);
+	const mode = textOf$1(c.operationMode);
+	return {
+		id: c.id,
+		kind,
+		label: labelOf(c),
+		icon: kind === "dhw" ? "droplets" : kind === "cooling" ? "snowflake" : "flame",
+		currentTemp: c.currentTemp,
+		targetTemp: c.targetTemp,
+		mode,
+		active: null,
+		operationMode: optionOf(c.operationMode),
+		heatCoolMode: optionOf(c.heatCoolMode),
+		summerWinter: optionOf(c.summerWinter),
+		comfortSetpoint: rangeOf(c.comfort),
+		ecoSetpoint: rangeOf(c.eco),
+		maxFlowTemp: rangeOf(c.maxFlow),
+		temperatureLevel: optionOf(c.level),
+		chargeDuration: rangeOf(c.chargeDuration),
+		extraHotWater: c.charge === null ? null : textOf$1(c.charge) === "start"
+	};
+}
+function kindOf(c) {
+	if (c.kind === "dhw") return "dhw";
+	return textOf$1(c.heatCoolMode) === "cooling" ? "cooling" : "heating";
+}
+function labelOf(c) {
+	const n = c.id.replace(/^\D+/, "");
+	if (c.kind === "dhw") return n === "1" || n === "" ? "Hot water" : `Hot water ${n}`;
+	return n === "" ? "Circuit" : `Circuit ${n}`;
+}
+function textOf$1(s) {
+	return s !== null && typeof s.value === "string" && s.value.length > 0 ? s.value : null;
+}
+function optionOf(s) {
+	if (s === null) return null;
+	return {
+		value: textOf$1(s),
+		allowed: [...s.allowed]
+	};
+}
+function rangeOf(s) {
+	if (s === null) return null;
+	return {
+		value: typeof s.value === "number" && Number.isFinite(s.value) ? s.value : null,
+		min: s.min,
+		max: s.max,
+		step: null
+	};
+}
+function requireCircuit(reading, circuitId, want) {
+	const found = reading.circuits.find((c) => c.id === circuitId && c.kind === want);
+	if (found === void 0) throw new HomeComHeatPumpRefusalError(`HomeCom heat pump has no ${want} circuit ${circuitId}`);
+	return found;
+}
+function optionWrite(s, what, mode) {
+	if (s === null) throw new HomeComHeatPumpRefusalError(`HomeCom heat pump: ${what} is not available`);
+	if (s.allowed.length === 0) throw new HomeComHeatPumpRefusalError(`HomeCom heat pump: ${what} is read-only on this gateway`);
+	if (!s.allowed.includes(mode)) throw new HomeComHeatPumpRefusalError(`HomeCom heat pump: "${mode}" is not an accepted value of ${what} (${s.allowed.join(", ")})`);
+	return {
+		path: s.path,
+		value: mode
+	};
+}
+function rangeWrite(s, what, value) {
+	if (s === null) throw new HomeComHeatPumpRefusalError(`HomeCom heat pump: ${what} is not available`);
+	if (!Number.isFinite(value)) throw new HomeComHeatPumpRefusalError(`HomeCom heat pump: ${what} needs a finite number`);
+	if (s.min === null || s.max === null) throw new HomeComHeatPumpRefusalError(`HomeCom heat pump: ${what} has no limits from the gateway`);
+	if (value < s.min || value > s.max) throw new HomeComHeatPumpRefusalError(`HomeCom heat pump: ${value} is outside ${what} limits ${s.min}..${s.max}`);
+	return {
+		path: s.path,
+		value
+	};
+}
+function systemModeWrite(reading, which, mode) {
+	return optionWrite(reading[which], `${which} mode`, mode);
+}
+function circuitOptionWrite(reading, circuitId, which, mode) {
+	return optionWrite(requireCircuit(reading, circuitId, "hc")[which], `${circuitId} ${which}`, mode);
+}
+function dhwOptionWrite(reading, circuitId, which, mode) {
+	return optionWrite(requireCircuit(reading, circuitId, "dhw")[which], `${circuitId} ${which}`, mode);
+}
+function circuitRangeWrite(reading, circuitId, which, value) {
+	return rangeWrite(requireCircuit(reading, circuitId, "hc")[which], `${circuitId} ${which}`, value);
+}
+function dhwChargeDurationWrite(reading, circuitId, minutes) {
+	return rangeWrite(requireCircuit(reading, circuitId, "dhw").chargeDuration, `${circuitId} charge duration`, minutes);
+}
+function extraHotWaterWrite(reading, circuitId) {
+	const charge = requireCircuit(reading, circuitId, "dhw").charge;
+	return optionWrite(charge, `${circuitId} extra hot water`, "start");
+}
+//#endregion
+//#region src/homecom/homecom-oauth.ts
+/**
+* Public OAuth client of the HomeCom Easy app, signed in through SingleKey ID.
+*
+* A PKCE client has no secret. The values are the ones SingleKey accepts for this client id
+* today: the same authorize query the MIT-licensed `homecom_alt` client records
+* (`OAUTH_LOGIN_PARAMS` — parameters, not copied code) and that the Home Assistant integration
+* opens. `pointt.gateway.resource.dopair` is not a scope this client may request; SingleKey
+* answers `misconfigured-application` and never shows the login page. The scope it does accept
+* names `pointt.gateway.resource.dashapp`, and the Bosch app sends `style_id=tt_bsch`.
+*/
+var HOMECOM_CLIENT_ID = "762162C0-FA2D-4540-AE66-6489F189FADC";
+var HOMECOM_AUTHORIZE_URL = "https://singlekey-id.com/auth/connect/authorize";
+var HOMECOM_TOKEN_URL = "https://singlekey-id.com/auth/connect/token";
+var HOMECOM_STYLE_ID = "tt_bsch";
+var HOMECOM_SCOPE = [
+	"openid",
+	"email",
+	"profile",
+	"offline_access",
+	"pointt.gateway.claiming",
+	"pointt.gateway.removal",
+	"pointt.gateway.list",
+	"pointt.gateway.users",
+	"pointt.gateway.resource.dashapp",
+	"pointt.castt.flow.token-exchange",
+	"bacon",
+	"hcc.tariff.read"
+].join(" ");
+//#endregion
 //#region src/homecom/homecom-api-client.ts
 var HomeComAuthError = class extends Error {
 	name = "HomeComAuthError";
@@ -930,15 +1246,43 @@ function createHomeComApiClient(config, gatewayId, deps = {}) {
 	}
 	async function fetchSystem() {
 		const resolved = await resolveDeviceType();
-		const snapshot = await readPointtSnapshot({
+		const withHeatPump = await attachHeatPump(await readPointtSnapshot({
 			deviceType: resolved.deviceType,
 			family: resolved.family,
 			gatewayId,
 			get: getResource,
 			logDrop
+		}));
+		last = withHeatPump;
+		return withHeatPump;
+	}
+	async function attachHeatPump(snapshot) {
+		if (snapshot.family !== "hydronic" || snapshot.deviceType === "rrc2") return snapshot;
+		const dhwId = snapshot.dhw?.circuitId;
+		const heatPump = await readHeatPump({
+			get: getResource,
+			onFailure: logHeatPumpFailure,
+			circuitIds: {
+				hc: snapshot.circuits.map((circuit) => circuit.id),
+				dhw: dhwId === void 0 ? [] : [dhwId]
+			}
+		});
+		return hasHeatSource(heatPump) ? {
+			...snapshot,
+			heatPump
+		} : snapshot;
+	}
+	function logHeatPumpFailure(path, error) {
+		const key = `heat-pump-read:${path}`;
+		if (dropped.has(key)) return;
+		dropped.add(key);
+		logger?.warn("HomeCom heat-pump resource could not be read; it is skipped", {
+			tags: { gatewayId },
+			meta: {
+				path,
+				error: error instanceof Error ? error.message : String(error)
+			}
 		});
-		last = snapshot;
-		return snapshot;
 	}
 	async function probePath(path) {
 		const res = await authed(homeComResourceUrl(gatewayId, path), {
@@ -992,6 +1336,9 @@ function createHomeComApiClient(config, gatewayId, deps = {}) {
 			const snapshot = await requireSnapshot();
 			if (snapshot.family !== "rac") logDrop("swing is not a resource on this device type");
 			await putWrite(swingWrite(snapshot, "horizontal", on));
+		},
+		async writeHeatPump(writes) {
+			for (const write of writes) await putWrite(write);
 		}
 	};
 }
@@ -1256,8 +1603,7 @@ function buildHomeComGatewayPersister(deps) {
 function buildHomeComCandidates(input) {
 	const out = [];
 	for (const dev of input.devices) {
-		const type = dev.kind === "heating-circuit" ? require_bosch_instances.DeviceType.Climate : require_bosch_instances.DeviceType.WaterHeater;
-		const caps = dev.kind === "heating-circuit" ? ["climate-control"] : ["water-heater"];
+		const { type, caps } = shapeOf(dev.kind);
 		const adoptedId = input.adopted.get(dev.nativeId) ?? null;
 		out.push({
 			childNativeId: dev.nativeId,
@@ -1272,6 +1618,22 @@ function buildHomeComCandidates(input) {
 	}
 	return out;
 }
+function shapeOf(kind) {
+	switch (kind) {
+		case "heating-circuit": return {
+			type: require_bosch_instances.DeviceType.Climate,
+			caps: ["climate-control"]
+		};
+		case "dhw": return {
+			type: require_bosch_instances.DeviceType.WaterHeater,
+			caps: ["water-heater"]
+		};
+		case "heat-pump": return {
+			type: require_bosch_instances.DeviceType.HeatPump,
+			caps: ["heat-pump-status", "heat-pump-control"]
+		};
+	}
+}
 //#endregion
 //#region src/homecom/homecom-adoption-provider.ts
 var DEVICES_FILTER = {
@@ -1456,6 +1818,11 @@ function buildDiscoverables(snapshot) {
 		name: "Domestic hot water",
 		kind: "dhw"
 	});
+	if (snapshot.heatPump !== void 0) out.push({
+		nativeId: "hp:0",
+		name: "Heat pump",
+		kind: "heat-pump"
+	});
 	return out;
 }
 var homeComConnections = new HomeComConnectionResolver();
@@ -1942,7 +2309,7 @@ var homeComClimateSchema = require_bosch_instances.object({
 	integrationId: require_bosch_instances.string().optional()
 });
 var CLIMATE_CAP = "climate-control";
-var COLD_START$1 = {
+var COLD_START$2 = {
 	mode: "off",
 	availableModes: [],
 	fanMode: "",
@@ -1977,14 +2344,14 @@ var HomeComClimateDevice = class extends require_bosch_instances.BaseDevice {
 	async onActivate() {
 		await super.onActivate();
 		this.registerClimateCap();
-		this.runtimeState.setCapState(CLIMATE_CAP, COLD_START$1);
+		this.runtimeState.setCapState(CLIMATE_CAP, COLD_START$2);
 		this.refreshFromSnapshot();
 	}
 	refreshFromSnapshot() {
 		const circuit = homeComConnections.getSnapshot(this.#brokerId)?.circuits.find((c) => c.id === this.#circuitId);
 		if (!circuit) {
 			this.runtimeState.setCapState(CLIMATE_CAP, {
-				...COLD_START$1,
+				...COLD_START$2,
 				lastFetchedAt: Date.now()
 			});
 			return;
@@ -2000,7 +2367,7 @@ var HomeComClimateDevice = class extends require_bosch_instances.BaseDevice {
 		this.ctx.registerNativeCap(require_bosch_instances.climateControlCapability, {
 			getStatus: async () => {
 				this.refreshFromSnapshot();
-				return this.runtimeState.getCapState(CLIMATE_CAP) ?? COLD_START$1;
+				return this.runtimeState.getCapState(CLIMATE_CAP) ?? COLD_START$2;
 			},
 			setMode: async ({ mode }) => {
 				const apiMode = hvacModeToHomeCom(mode);
@@ -2052,7 +2419,7 @@ var homeComWaterHeaterSchema = require_bosch_instances.object({
 	integrationId: require_bosch_instances.string().optional()
 });
 var WH_CAP = "water-heater";
-var COLD_START = {
+var COLD_START$1 = {
 	currentTemp: null,
 	targetTemp: null,
 	operationMode: null,
@@ -2078,14 +2445,14 @@ var HomeComWaterHeaterDevice = class extends require_bosch_instances.BaseDevice
 	async onActivate() {
 		await super.onActivate();
 		this.registerWaterHeaterCap();
-		this.runtimeState.setCapState(WH_CAP, COLD_START);
+		this.runtimeState.setCapState(WH_CAP, COLD_START$1);
 		this.refreshFromSnapshot();
 	}
 	refreshFromSnapshot() {
 		const dhw = homeComConnections.getSnapshot(this.#brokerId)?.dhw;
 		if (!dhw) {
 			this.runtimeState.setCapState(WH_CAP, {
-				...COLD_START,
+				...COLD_START$1,
 				lastChangedAt: Date.now()
 			});
 			return;
@@ -2101,7 +2468,7 @@ var HomeComWaterHeaterDevice = class extends require_bosch_instances.BaseDevice
 		this.ctx.registerNativeCap(require_bosch_instances.waterHeaterCapability, {
 			getStatus: async () => {
 				this.refreshFromSnapshot();
-				return this.runtimeState.getCapState(WH_CAP) ?? COLD_START;
+				return this.runtimeState.getCapState(WH_CAP) ?? COLD_START$1;
 			},
 			setTargetTemp: async ({ temp }) => {
 				await this.requireClient().setDhwTarget(temp);
@@ -2118,13 +2485,157 @@ var HomeComWaterHeaterDevice = class extends require_bosch_instances.BaseDevice
 	}
 };
 //#endregion
+//#region src/homecom/devices/homecom-heat-pump-device.ts
+var homeComHeatPumpSchema = require_bosch_instances.object({
+	nativeId: require_bosch_instances.string().min(1),
+	brokerId: require_bosch_instances.string().min(1),
+	system: require_bosch_instances.literal("homecom").optional(),
+	integrationId: require_bosch_instances.string().optional()
+});
+var STATUS_CAP = "heat-pump-status";
+var COLD_START = {
+	circuits: [],
+	system: {
+		silent: null,
+		away: null,
+		additionalHeater: null,
+		holiday: null
+	},
+	power: {
+		thermalW: null,
+		electricalW: null,
+		compressorPct: null
+	},
+	temperatures: {
+		supply: null,
+		return: null,
+		outdoor: null
+	},
+	energy: {
+		thermalKwh: null,
+		electricalKwh: null
+	},
+	waterPressureBar: null,
+	starts: null,
+	lastFetchedAt: 0
+};
+/**
+* A heat pump on a hydronic HomeCom gateway (D1026). The slice and every limit
+* come from the gateway reading the integration poll already holds; a write is
+* checked against those limits first and the reading is refreshed after it.
+*/
+var HomeComHeatPumpDevice = class extends require_bosch_instances.BaseDevice {
+	features = [];
+	#brokerId;
+	/** True while the gateway has no heat-pump reading, so the log marks the transitions only. */
+	#noReading = false;
+	constructor(ctx) {
+		const persisted = homeComHeatPumpSchema.parse(ctx.persistedConfig ?? {});
+		super(ctx, homeComHeatPumpSchema, { type: ctx.deviceMeta.type });
+		this.#brokerId = persisted.brokerId;
+		this.online = true;
+		this.updateSourceInfo({
+			id: persisted.nativeId,
+			system: "homecom"
+		});
+	}
+	async onActivate() {
+		await super.onActivate();
+		this.registerStatusCap();
+		this.registerControlCap();
+		this.runtimeState.setCapState(STATUS_CAP, COLD_START);
+		this.refreshFromSnapshot();
+	}
+	reading() {
+		return homeComConnections.getSnapshot(this.#brokerId)?.heatPump ?? null;
+	}
+	refreshFromSnapshot() {
+		const reading = this.reading();
+		if (reading === null) {
+			if (!this.#noReading) {
+				this.#noReading = true;
+				this.ctx.logger.warn("HomeCom heat pump: the gateway returned no heat-pump reading", { tags: { deviceId: this.ctx.id } });
+			}
+			this.runtimeState.setCapState(STATUS_CAP, {
+				...COLD_START,
+				lastFetchedAt: Date.now()
+			});
+			return;
+		}
+		if (this.#noReading) {
+			this.#noReading = false;
+			this.ctx.logger.info("HomeCom heat pump: the gateway answers with a heat-pump reading again", { tags: { deviceId: this.ctx.id } });
+		}
+		this.runtimeState.setCapState(STATUS_CAP, heatPumpStatusFrom(reading, Date.now()));
+	}
+	requireClient() {
+		const client = homeComConnections.getClient(this.#brokerId);
+		if (!client) throw new Error("HomeCom client unavailable (heat pump)");
+		return client;
+	}
+	requireReading() {
+		const reading = this.reading();
+		if (reading === null) throw new Error("HomeCom heat pump: no reading from the gateway yet");
+		return reading;
+	}
+	/** Validate against the reading, send, then re-read so the slice shows what the gateway holds. */
+	async apply(build) {
+		const write = build(this.requireReading());
+		const client = this.requireClient();
+		await client.writeHeatPump([write]);
+		this.ctx.logger.info("HomeCom heat pump: value written", {
+			tags: { deviceId: this.ctx.id },
+			meta: { path: write.path }
+		});
+		try {
+			const snapshot = await client.fetchSystem();
+			homeComConnections.updateSnapshot(this.#brokerId, snapshot);
+		} catch (error) {
+			this.ctx.logger.warn("HomeCom heat pump: value written, the refresh failed", {
+				tags: { deviceId: this.ctx.id },
+				meta: {
+					path: write.path,
+					error: error instanceof Error ? error.message : String(error)
+				}
+			});
+			return;
+		}
+		this.refreshFromSnapshot();
+	}
+	registerStatusCap() {
+		this.ctx.registerNativeCap(require_bosch_instances.heatPumpStatusCapability, { getStatus: async () => {
+			this.refreshFromSnapshot();
+			return this.runtimeState.getCapState(STATUS_CAP) ?? COLD_START;
+		} });
+	}
+	registerControlCap() {
+		this.ctx.registerNativeCap(require_bosch_instances.heatPumpControlCapability, {
+			setSilentMode: ({ mode }) => this.apply((r) => systemModeWrite(r, "silent", mode)),
+			setAwayMode: ({ mode }) => this.apply((r) => systemModeWrite(r, "away", mode)),
+			setAdditionalHeaterMode: ({ mode }) => this.apply((r) => systemModeWrite(r, "additionalHeater", mode)),
+			setHolidayMode: ({ mode }) => this.apply((r) => systemModeWrite(r, "holiday", mode)),
+			setCircuitOperationMode: ({ circuitId, mode }) => this.apply((r) => circuitOptionWrite(r, circuitId, "operationMode", mode)),
+			setCircuitHeatCoolMode: ({ circuitId, mode }) => this.apply((r) => circuitOptionWrite(r, circuitId, "heatCoolMode", mode)),
+			setCircuitSummerWinter: ({ circuitId, mode }) => this.apply((r) => circuitOptionWrite(r, circuitId, "summerWinter", mode)),
+			setCircuitComfortSetpoint: ({ circuitId, temp }) => this.apply((r) => circuitRangeWrite(r, circuitId, "comfort", temp)),
+			setCircuitEcoSetpoint: ({ circuitId, temp }) => this.apply((r) => circuitRangeWrite(r, circuitId, "eco", temp)),
+			setCircuitMaxFlowTemp: ({ circuitId, temp }) => this.apply((r) => circuitRangeWrite(r, circuitId, "maxFlow", temp)),
+			setDhwOperationMode: ({ circuitId, mode }) => this.apply((r) => dhwOptionWrite(r, circuitId, "operationMode", mode)),
+			setDhwTemperatureLevel: ({ circuitId, level }) => this.apply((r) => dhwOptionWrite(r, circuitId, "level", level)),
+			setDhwChargeDuration: ({ circuitId, minutes }) => this.apply((r) => dhwChargeDurationWrite(r, circuitId, minutes)),
+			startExtraHotWater: ({ circuitId }) => this.apply((r) => extraHotWaterWrite(r, circuitId))
+		});
+	}
+};
+//#endregion
 //#region src/homecom/addon.ts
 var BoschHomeComProviderAddon = class extends require_bosch_instances.BaseDeviceProvider {
 	addonId = "bosch-homecom";
 	providerName = "Bosch HomeCom";
 	deviceClasses = {
 		[require_bosch_instances.DeviceType.Climate]: HomeComClimateDevice,
-		[require_bosch_instances.DeviceType.WaterHeater]: HomeComWaterHeaterDevice
+		[require_bosch_instances.DeviceType.WaterHeater]: HomeComWaterHeaterDevice,
+		[require_bosch_instances.DeviceType.HeatPump]: HomeComHeatPumpDevice
 	};
 	clients = null;
 	instances = null;