@camstack/addon-provider-bosch 0.1.44 → 0.1.46

package/dist/homecom/addon.mjs

@@ -1,5 +1,5 @@
-import { A as customAction, B as number, D as waterHeaterCapability, I as rowsDepsOver, J as errMsg, L as _enum, M as defineEntryKind, N as entryBody, O as RecordIntegrationInstances, R as array, U as string, V as object, Y as EventCategory, a as BaseDevice, d as climateControlCapability, i as testBoschInstance, j as defineCustomActions, n as boschRowsPorts, o as BaseDeviceProvider, p as deviceAdoptionCapability, q as DeviceType, r as keepBodyKeys, t as boschRowsMigration, y as integrationInstancesCapability, z as literal } from "../bosch-instances-C8FRjQzC.mjs";
-import { a as loginFailureForAttempt, i as createSignInAttemptStore, n as cascadeRemoveDevicesForIntegration, o as parseOAuthCallback, r as buildSignInGuideFields, s as HOMECOM_REDIRECT_URI, t as setIntegrationDevicesOnline } from "../account-integration-offline-IHodWmhD.mjs";
+import { A as RecordIntegrationInstances, B as array, F as entryBody, G as string, H as number, M as customAction, N as defineCustomActions, P as defineEntryKind, R as rowsDepsOver, U as object, V as literal, X as errMsg, Y as DeviceType, Z as EventCategory, _ as heatPumpControlCapability, a as BaseDevice, d as climateControlCapability, i as testBoschInstance, k as waterHeaterCapability, n as boschRowsPorts, o as BaseDeviceProvider, p as deviceAdoptionCapability, r as keepBodyKeys, t as boschRowsMigration, v as heatPumpStatusCapability, x as integrationInstancesCapability, z as _enum } from "../bosch-instances-DkUo6BfT.mjs";
+import { a as loginFailureForAttempt, i as createSignInAttemptStore, n as cascadeRemoveDevicesForIntegration, o as parseOAuthCallback, r as buildSignInGuideFields, s as HOMECOM_REDIRECT_URI, t as setIntegrationDevicesOnline } from "../account-integration-offline-BGH1q3tj.mjs";
 import { createHash, randomBytes } from "node:crypto";
 //#region src/homecom/config.ts
 var HOMECOM_BRANDS = ["bosch", "buderus"];
@@ -266,36 +266,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",
@@ -478,7 +448,7 @@ async function readHydronic(input) {
 	const heating = await input.get("/heatingCircuits");
 	const dhwBody = await input.get("/dhwCircuits");
 	const circuits = [];
-	for (const id of referenceKeys(heating, "hc")) circuits.push(await readCircuit(input.get, id));
+	for (const ref of circuitRefs(heating, "hc")) circuits.push(await readCircuit(input.get, ref.id, ref.name));
 	const dhwIds = referenceKeys(dhwBody, "dhw");
 	const first = dhwIds[0];
 	const dhw = first === void 0 ? null : await readDhw(input.get, first);
@@ -538,7 +508,7 @@ async function readRac(input) {
 		setpointResource: "/airConditioning/temperatureSetpoint"
 	}], null);
 }
-async function readCircuit(get, id) {
+async function readCircuit(get, id, givenName) {
 	const base = `/heatingCircuits/${id}`;
 	const loaded = await loadEnvelopes(get, [
 		`${base}/operationMode`,
@@ -561,7 +531,7 @@ async function readCircuit(get, id) {
 	const humidity = numberOf(loaded.get(`${base}/actualHumidity`) ?? null);
 	return {
 		id,
-		name: id,
+		name: heatingCircuitName(id, givenName),
 		operationMode: stringOf(operation) ?? "off",
 		setpoint: cooling ? numberOf(coolingSet) ?? numberOf(current) ?? numberOf(manual) : numberOf(current) ?? numberOf(manual),
 		currentRoomTemp: numberOf(loaded.get(`${base}/roomtemperature`) ?? null),
@@ -663,18 +633,37 @@ function pointtMode(mode) {
 		default: return mode;
 	}
 }
-function referenceKeys(body, prefix) {
+/** `hc1` → "Heating circuit 1", unless the gateway already named the circuit. */
+function heatingCircuitName(id, given) {
+	if (given !== null && given.length > 0 && given !== id) return given;
+	const n = id.replace(/^hc/, "");
+	return /^\d+$/.test(n) ? `Heating circuit ${n}` : "Heating circuit";
+}
+function circuitRefs(body, prefix) {
 	if (!isRecord$2(body) || !Array.isArray(body["references"])) return [];
 	const pattern = prefix === "hc" ? /^hc\d+$/ : /^dhw\d+$/;
 	const out = [];
 	for (const ref of body["references"]) {
 		if (!isRecord$2(ref) || typeof ref["id"] !== "string") continue;
 		const tail = ref["id"].split("/").filter((part) => part.length > 0).at(-1);
-		if (tail === void 0 || !pattern.test(tail) || out.includes(tail)) continue;
-		out.push(tail);
+		if (tail === void 0 || !pattern.test(tail) || out.some((item) => item.id === tail)) continue;
+		out.push({
+			id: tail,
+			name: refName(ref, tail)
+		});
 	}
 	return out;
 }
+function refName(ref, id) {
+	const raw = ref["name"];
+	if (typeof raw !== "string") return null;
+	const trimmed = raw.trim();
+	if (trimmed.length === 0 || trimmed === id) return null;
+	return trimmed;
+}
+function referenceKeys(body, prefix) {
+	return circuitRefs(body, prefix).map((ref) => ref.id);
+}
 function indexStandard(body) {
 	const map = /* @__PURE__ */ new Map();
 	if (!isRecord$2(body) || !Array.isArray(body["references"])) return map;
@@ -716,6 +705,527 @@ 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;
+		}
+	};
+}
+var SYSTEM_MODE_KEYS = [
+	"silent",
+	"away",
+	"additionalHeater",
+	"holiday"
+];
+var HEAT_PUMP_ONLY_READINGS = [
+	"thermalW",
+	"electricalW",
+	"compressorPct"
+];
+/**
+* True when the gateway should be offered as a system device (`hp:0`).
+*
+* A system mode counts when the gateway answered it: silent, away, the
+* additional heater, or holiday. An empty string is an answer (holiday often
+* comes back empty); a path that did not answer is not. HomeCom returns no
+* value for silent mode and the auxiliary heater on some heat-pump firmware,
+* so away and holiday alone are enough. A heat-pump-only reading counts too
+* (thermal power, electrical power, compressor modulation). Supply, return,
+* outdoor, pressure, starts and the energy meters do not: a gas boiler's heat
+* source answers flow, pressure and starts, and that is not a heat pump.
+*/
+function hasSystemDevice(reading) {
+	if (SYSTEM_MODE_KEYS.some((key) => reading[key] !== null)) return true;
+	return HEAT_PUMP_ONLY_READINGS.some((key) => reading[key] !== null);
+}
+/** Which heat-pump paths this gateway answered. One log per gateway corrects the path table. */
+function heatPumpPathCensus(reading) {
+	const rows = [
+		...systemPathRows(reading),
+		...readingPathRows(reading),
+		...reading.circuits.flatMap(circuitPathRows)
+	];
+	const answered = [];
+	const unanswered = [];
+	for (const row of rows) if (row.present) answered.push(row.path);
+	else unanswered.push(row.path);
+	return {
+		answered,
+		unanswered
+	};
+}
+function systemPathRows(reading) {
+	const s = HEAT_PUMP_PATHS.system;
+	return [
+		{
+			path: s.silent,
+			present: reading.silent !== null
+		},
+		{
+			path: s.away,
+			present: reading.away !== null
+		},
+		{
+			path: s.additionalHeater,
+			present: reading.additionalHeater !== null
+		},
+		{
+			path: s.holiday,
+			present: reading.holiday !== null
+		}
+	];
+}
+function readingPathRows(reading) {
+	const r = HEAT_PUMP_PATHS.readings;
+	return [
+		{
+			path: r.thermalW,
+			present: reading.thermalW !== null
+		},
+		{
+			path: r.electricalW,
+			present: reading.electricalW !== null
+		},
+		{
+			path: r.compressorPct,
+			present: reading.compressorPct !== null
+		},
+		{
+			path: r.supply,
+			present: reading.supply !== null
+		},
+		{
+			path: r.return,
+			present: reading.return !== null
+		},
+		{
+			path: r.outdoor,
+			present: reading.outdoor !== null
+		},
+		{
+			path: r.thermalKwh,
+			present: reading.thermalKwh !== null
+		},
+		{
+			path: r.electricalKwh,
+			present: reading.electricalKwh !== null
+		},
+		{
+			path: r.pressureBar,
+			present: reading.pressureBar !== null
+		},
+		{
+			path: r.starts,
+			present: reading.starts !== null
+		}
+	];
+}
+function circuitPathRows(circuit) {
+	if (circuit.kind === "dhw") return dhwPathRows(circuit);
+	return hcPathRows(circuit);
+}
+function hcPathRows(circuit) {
+	const base = `/heatingCircuits/${circuit.id}`;
+	const p = HEAT_PUMP_PATHS.circuit;
+	return [
+		{
+			path: `${base}/${p.operationMode}`,
+			present: circuit.operationMode !== null
+		},
+		{
+			path: `${base}/${p.heatCoolMode}`,
+			present: circuit.heatCoolMode !== null
+		},
+		{
+			path: `${base}/${p.summerWinter}`,
+			present: circuit.summerWinter !== null
+		},
+		{
+			path: `${base}/${p.comfort}`,
+			present: circuit.comfort !== null
+		},
+		{
+			path: `${base}/${p.eco}`,
+			present: circuit.eco !== null
+		},
+		{
+			path: `${base}/${p.maxFlow}`,
+			present: circuit.maxFlow !== null
+		},
+		{
+			path: `${base}/${p.current}`,
+			present: circuit.currentTemp !== null
+		},
+		{
+			path: `${base}/${p.target}`,
+			present: circuit.targetTemp !== null
+		}
+	];
+}
+function dhwPathRows(circuit) {
+	const base = `/dhwCircuits/${circuit.id}`;
+	const p = HEAT_PUMP_PATHS.dhw;
+	return [
+		{
+			path: `${base}/${p.operationMode}`,
+			present: circuit.operationMode !== null
+		},
+		{
+			path: `${base}/${p.level}`,
+			present: circuit.level !== null
+		},
+		{
+			path: `${base}/${p.chargeDuration}`,
+			present: circuit.chargeDuration !== null
+		},
+		{
+			path: `${base}/${p.charge}`,
+			present: circuit.charge !== null
+		},
+		{
+			path: `${base}/${p.current}`,
+			present: circuit.currentTemp !== null
+		},
+		{
+			path: `${base}/${p.target}`,
+			present: circuit.targetTemp !== 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);
+	return {
+		id: c.id,
+		kind,
+		label: labelOf(c),
+		icon: kind === "dhw" ? "droplets" : kind === "cooling" ? "snowflake" : "flame",
+		currentTemp: c.currentTemp,
+		targetTemp: c.targetTemp,
+		mode: modeValue(c.operationMode),
+		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 === "" ? "Heating circuit" : `Heating circuit ${n}`;
+}
+function textOf$1(s) {
+	return s !== null && typeof s.value === "string" && s.value.length > 0 ? s.value : null;
+}
+/**
+* A mode the gateway answered with an empty value is off (or "none" when the
+* gateway did not list off). A mode it did not answer at all stays null.
+*/
+function modeValue(s) {
+	if (s === null || typeof s.value !== "string") return null;
+	if (s.value.length > 0) return s.value;
+	return s.allowed.includes("off") ? "off" : "none";
+}
+function optionOf(s) {
+	if (s === null) return null;
+	return {
+		value: modeValue(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";
@@ -796,6 +1306,7 @@ function createHomeComApiClient(config, gatewayId, deps = {}) {
 	let last = null;
 	let refreshTail = Promise.resolve();
 	const dropped = /* @__PURE__ */ new Set();
+	let heatPumpPathsLogged = false;
 	const base = homeComApiBase(config.region);
 	function authHeaders() {
 		return {
@@ -929,15 +1440,56 @@ 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]
+			}
+		});
+		logHeatPumpPaths(heatPump);
+		return hasSystemDevice(heatPump) ? {
+			...snapshot,
+			heatPump
+		} : snapshot;
+	}
+	function logHeatPumpPaths(reading) {
+		if (heatPumpPathsLogged) return;
+		heatPumpPathsLogged = true;
+		const census = heatPumpPathCensus(reading);
+		logger?.info("HomeCom heat-pump paths", {
+			tags: { gatewayId },
+			meta: {
+				answered: census.answered,
+				unanswered: census.unanswered
+			}
+		});
+	}
+	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), {
@@ -991,6 +1543,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);
 		}
 	};
 }
@@ -1255,8 +1810,7 @@ function buildHomeComGatewayPersister(deps) {
 function buildHomeComCandidates(input) {
 	const out = [];
 	for (const dev of input.devices) {
-		const type = dev.kind === "heating-circuit" ? DeviceType.Climate : 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,
@@ -1271,6 +1825,22 @@ function buildHomeComCandidates(input) {
 	}
 	return out;
 }
+function shapeOf(kind) {
+	switch (kind) {
+		case "heating-circuit": return {
+			type: DeviceType.Climate,
+			caps: ["climate-control"]
+		};
+		case "dhw": return {
+			type: DeviceType.WaterHeater,
+			caps: ["water-heater"]
+		};
+		case "heat-pump": return {
+			type: DeviceType.HeatPump,
+			caps: ["heat-pump-status", "heat-pump-control"]
+		};
+	}
+}
 //#endregion
 //#region src/homecom/homecom-adoption-provider.ts
 var DEVICES_FILTER = {
@@ -1455,6 +2025,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();
@@ -1941,7 +2516,7 @@ var homeComClimateSchema = object({
 	integrationId: string().optional()
 });
 var CLIMATE_CAP = "climate-control";
-var COLD_START$1 = {
+var COLD_START$2 = {
 	mode: "off",
 	availableModes: [],
 	fanMode: "",
@@ -1976,14 +2551,14 @@ var HomeComClimateDevice = class extends 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;
@@ -1999,7 +2574,7 @@ var HomeComClimateDevice = class extends BaseDevice {
 		this.ctx.registerNativeCap(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);
@@ -2051,7 +2626,7 @@ var homeComWaterHeaterSchema = object({
 	integrationId: string().optional()
 });
 var WH_CAP = "water-heater";
-var COLD_START = {
+var COLD_START$1 = {
 	currentTemp: null,
 	targetTemp: null,
 	operationMode: null,
@@ -2077,14 +2652,14 @@ var HomeComWaterHeaterDevice = class extends 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;
@@ -2100,7 +2675,7 @@ var HomeComWaterHeaterDevice = class extends BaseDevice {
 		this.ctx.registerNativeCap(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);
@@ -2117,13 +2692,157 @@ var HomeComWaterHeaterDevice = class extends BaseDevice {
 	}
 };
 //#endregion
+//#region src/homecom/devices/homecom-heat-pump-device.ts
+var homeComHeatPumpSchema = object({
+	nativeId: string().min(1),
+	brokerId: string().min(1),
+	system: literal("homecom").optional(),
+	integrationId: 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 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(heatPumpStatusCapability, { getStatus: async () => {
+			this.refreshFromSnapshot();
+			return this.runtimeState.getCapState(STATUS_CAP) ?? COLD_START;
+		} });
+	}
+	registerControlCap() {
+		this.ctx.registerNativeCap(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 BaseDeviceProvider {
 	addonId = "bosch-homecom";
 	providerName = "Bosch HomeCom";
 	deviceClasses = {
 		[DeviceType.Climate]: HomeComClimateDevice,
-		[DeviceType.WaterHeater]: HomeComWaterHeaterDevice
+		[DeviceType.WaterHeater]: HomeComWaterHeaterDevice,
+		[DeviceType.HeatPump]: HomeComHeatPumpDevice
 	};
 	clients = null;
 	instances = null;