@camstack/addon-provider-bosch 0.1.45 → 0.1.47

package/dist/homecom/addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_bosch_instances = require("../bosch-instances-DdklwoKS.js");
-const require_account_integration_offline = require("../account-integration-offline-BiXbzZsg.js");
+const require_bosch_instances = require("../bosch-instances-D0eF-Jjy.js");
+const require_account_integration_offline = require("../account-integration-offline-C6tzFB-H.js");
 let node_crypto = require("node:crypto");
 //#region src/homecom/config.ts
 var HOMECOM_BRANDS = ["bosch", "buderus"];
@@ -449,7 +449,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);
@@ -509,7 +509,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`,
@@ -532,7 +532,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),
@@ -634,18 +634,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;
@@ -793,19 +812,186 @@ function safeGet(get, onFailure) {
 		}
 	};
 }
+var SYSTEM_MODE_KEYS = [
+	"silent",
+	"away",
+	"additionalHeater",
+	"holiday"
+];
+var HEAT_PUMP_ONLY_READINGS = [
+	"thermalW",
+	"electricalW",
+	"compressorPct"
+];
 /**
-* 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.
+* 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 hasHeatSource(reading) {
+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 [
-		reading.silent,
-		reading.additionalHeater,
-		reading.thermalW,
-		reading.electricalW,
-		reading.compressorPct
-	].some((v) => v !== null);
+		{
+			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}`;
@@ -910,7 +1096,6 @@ function heatPumpStatusFrom(reading, now) {
 }
 function circuitOf(c) {
 	const kind = kindOf(c);
-	const mode = textOf$1(c.operationMode);
 	return {
 		id: c.id,
 		kind,
@@ -918,7 +1103,7 @@ function circuitOf(c) {
 		icon: kind === "dhw" ? "droplets" : kind === "cooling" ? "snowflake" : "flame",
 		currentTemp: c.currentTemp,
 		targetTemp: c.targetTemp,
-		mode,
+		mode: modeValue(c.operationMode),
 		active: null,
 		operationMode: optionOf(c.operationMode),
 		heatCoolMode: optionOf(c.heatCoolMode),
@@ -938,15 +1123,24 @@ function kindOf(c) {
 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}`;
+	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: textOf$1(s),
+		value: modeValue(s),
 		allowed: [...s.allowed]
 	};
 }
@@ -1113,6 +1307,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 {
@@ -1267,11 +1462,24 @@ function createHomeComApiClient(config, gatewayId, deps = {}) {
 				dhw: dhwId === void 0 ? [] : [dhwId]
 			}
 		});
-		return hasHeatSource(heatPump) ? {
+		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;
@@ -1599,6 +1807,129 @@ function buildHomeComGatewayPersister(deps) {
 	return (integrationId, gatewayId) => patch(integrationId, { gatewayId });
 }
 //#endregion
+//#region src/homecom/homecom-gateway.ts
+/** Stable id of one HomeCom device. Adoption matches an existing row on this. */
+function homeComStableId(integrationId, nativeId) {
+	return `homecom:${integrationId}:${nativeId}`;
+}
+/** The hot-water child of a heat pump. A boiler's own row keeps its longer name. */
+var HOMECOM_HOT_WATER_CHILD_NAME = "Hot water";
+var HomeComConnectionResolver = class {
+	#surfaces = /* @__PURE__ */ new Map();
+	set(integrationId, surface) {
+		if (surface === null) {
+			this.#surfaces.delete(integrationId);
+			return;
+		}
+		this.#surfaces.set(integrationId, surface);
+	}
+	has(integrationId) {
+		return this.#surfaces.has(integrationId);
+	}
+	list() {
+		return Array.from(this.#surfaces.keys()).map((id) => ({ id }));
+	}
+	discoverables(integrationId) {
+		return this.#surfaces.get(integrationId)?.discoverables ?? [];
+	}
+	getClient(integrationId) {
+		return this.#surfaces.get(integrationId)?.client ?? null;
+	}
+	getSnapshot(integrationId) {
+		return this.#surfaces.get(integrationId)?.snapshot ?? null;
+	}
+	updateSnapshot(integrationId, snapshot) {
+		const existing = this.#surfaces.get(integrationId);
+		if (!existing) return;
+		this.#surfaces.set(integrationId, {
+			...existing,
+			snapshot,
+			discoverables: buildDiscoverables(snapshot)
+		});
+	}
+	clear() {
+		this.#surfaces.clear();
+	}
+};
+var BOILER_DHW_NAME = "Domestic hot water";
+function circuitDiscoverable(circuit) {
+	return {
+		nativeId: `hc:${circuit.id}`,
+		name: circuit.name,
+		kind: "heating-circuit",
+		circuitId: circuit.id
+	};
+}
+function dhwDiscoverable(name) {
+	return {
+		nativeId: "dhw:0",
+		name,
+		kind: "dhw"
+	};
+}
+/**
+* A gateway with a heat pump is one pick. A boiler still offers each circuit
+* and the hot-water row on its own.
+*/
+function buildDiscoverables(snapshot) {
+	const circuits = snapshot.circuits.map(circuitDiscoverable);
+	if (snapshot.heatPump !== void 0) return [{
+		nativeId: "hp:0",
+		name: "Heat pump",
+		kind: "heat-pump",
+		children: [...circuits, ...snapshot.dhw === null ? [] : [dhwDiscoverable(HOMECOM_HOT_WATER_CHILD_NAME)]]
+	}];
+	return [...circuits, ...snapshot.dhw === null ? [] : [dhwDiscoverable(BOILER_DHW_NAME)]];
+}
+var homeComConnections = new HomeComConnectionResolver();
+//#endregion
+//#region src/homecom/homecom-adoption-plan.ts
+function createOf(device, parentNativeId) {
+	return {
+		nativeId: device.nativeId,
+		name: device.name,
+		kind: device.kind,
+		circuitId: device.circuitId,
+		parentNativeId
+	};
+}
+/**
+* The devices one pick creates. A heat pump also creates its children, except
+* a circuit or hot-water row that already exists: a top-level one is reported
+* so the caller can log why it stayed there, and any existing row is not
+* created again.
+*/
+function planHomeComAdoption(device, integrationId, adopted) {
+	const root = createOf(device, null);
+	if (device.kind !== "heat-pump") return {
+		create: [root],
+		stayedTopLevel: [],
+		alreadyPresent: []
+	};
+	const byStableId = new Map(adopted.map((row) => [row.stableId, row]));
+	const create = [root];
+	const stayedTopLevel = [];
+	const alreadyPresent = [];
+	for (const child of device.children ?? []) {
+		const existing = byStableId.get(homeComStableId(integrationId, child.nativeId));
+		if (existing === void 0) {
+			create.push(createOf(child, device.nativeId));
+			continue;
+		}
+		const skip = {
+			nativeId: child.nativeId,
+			deviceId: existing.id
+		};
+		if (existing.parentDeviceId === null) stayedTopLevel.push(skip);
+		else alreadyPresent.push(skip);
+	}
+	return {
+		create,
+		stayedTopLevel,
+		alreadyPresent
+	};
+}
+//#endregion
 //#region src/homecom/homecom-discovery.ts
 function buildHomeComCandidates(input) {
 	const out = [];
@@ -1618,6 +1949,9 @@ function buildHomeComCandidates(input) {
 	}
 	return out;
 }
+function homeComDeviceType(kind) {
+	return shapeOf(kind).type;
+}
 function shapeOf(kind) {
 	switch (kind) {
 		case "heating-circuit": return {
@@ -1641,6 +1975,62 @@ var DEVICES_FILTER = {
 	label: "Devices",
 	isDefault: true
 };
+var STAYED_TOP_LEVEL = "HomeCom device stayed top-level: it was already adopted, so it was not created again under the heat pump";
+var ALREADY_PRESENT = "HomeCom device was not created again: a device with this stable id already exists";
+async function adoptOne(input) {
+	const { dev, integrationId, name, known, adoptDevice, logger, logOnce } = input;
+	const plan = planHomeComAdoption(dev, integrationId, known);
+	for (const skip of plan.stayedTopLevel) logOnce(skip.deviceId, STAYED_TOP_LEVEL);
+	for (const skip of plan.alreadyPresent) logOnce(skip.deviceId, ALREADY_PRESENT);
+	const root = plan.create[0];
+	if (root === void 0) return { ok: false };
+	let parentDeviceId;
+	try {
+		parentDeviceId = (await adoptDevice({
+			nativeId: root.nativeId,
+			integrationId,
+			type: homeComDeviceType(root.kind),
+			name,
+			kind: root.kind,
+			...root.circuitId === void 0 ? {} : { circuitId: root.circuitId },
+			parentDeviceId: null
+		})).deviceId;
+	} catch (err) {
+		logger.warn("homecom adopt failed", { meta: {
+			nativeId: root.nativeId,
+			integrationId,
+			error: require_bosch_instances.errMsg(err)
+		} });
+		return { ok: false };
+	}
+	const accessoryDeviceIds = [];
+	for (const child of plan.create.slice(1)) try {
+		const created = await adoptDevice({
+			nativeId: child.nativeId,
+			integrationId,
+			type: homeComDeviceType(child.kind),
+			name: child.name,
+			kind: child.kind,
+			...child.circuitId === void 0 ? {} : { circuitId: child.circuitId },
+			parentDeviceId
+		});
+		accessoryDeviceIds.push(created.deviceId);
+	} catch (err) {
+		logger.warn("homecom adopt child failed", {
+			tags: { deviceId: parentDeviceId },
+			meta: {
+				nativeId: child.nativeId,
+				integrationId,
+				error: require_bosch_instances.errMsg(err)
+			}
+		});
+	}
+	return {
+		ok: true,
+		parentDeviceId,
+		accessoryDeviceIds
+	};
+}
 async function adoptedMapForIntegration(integrationId, listAdopted) {
 	const all = await listAdopted();
 	const map = /* @__PURE__ */ new Map();
@@ -1652,6 +2042,12 @@ async function adoptedMapForIntegration(integrationId, listAdopted) {
 }
 function buildHomeComAdoptionProvider(deps) {
 	const { registry, hasIntegration, listIntegrations, listAdopted, adoptDevice, removeDevice, findDeviceConfig, logger } = deps;
+	const logged = /* @__PURE__ */ new Set();
+	const logOnce = (deviceId, message) => {
+		if (logged.has(deviceId)) return;
+		logged.add(deviceId);
+		logger.info(message, { tags: { deviceId } });
+	};
 	async function allCandidatesForIntegration(integrationId) {
 		return buildHomeComCandidates({
 			devices: registry.discoverables(integrationId),
@@ -1706,48 +2102,36 @@ function buildHomeComAdoptionProvider(deps) {
 		adopt: async ({ integrationId, childNativeIds, perCandidate }) => {
 			if (!registry.has(integrationId)) throw new Error(`homecom adopt: integration ${integrationId} not connected`);
 			const devices = registry.discoverables(integrationId);
+			const known = await listAdopted();
 			const adopted = [];
 			let failures = 0;
-			for (const nativeId of childNativeIds) try {
+			for (const nativeId of childNativeIds) {
 				const dev = devices.find((d) => d.nativeId === nativeId);
 				if (!dev) {
 					failures++;
 					continue;
 				}
-				const candidate = buildHomeComCandidates({
-					devices: [dev],
-					adopted: /* @__PURE__ */ new Map()
-				})[0];
-				if (!candidate) {
+				const outcome = await adoptOne({
+					dev,
+					integrationId,
+					name: perCandidate?.[nativeId]?.name ?? dev.name,
+					known,
+					adoptDevice,
+					logger,
+					logOnce
+				});
+				if (!outcome.ok) {
 					failures++;
 					continue;
 				}
-				const name = perCandidate?.[nativeId]?.name ?? dev.name;
-				const { deviceId } = await adoptDevice({
-					nativeId,
-					integrationId,
-					type: candidate.type,
-					name,
-					kind: dev.kind,
-					circuitId: dev.circuitId
-				});
 				adopted.push({
 					childNativeId: nativeId,
-					parentDeviceId: deviceId
+					parentDeviceId: outcome.parentDeviceId,
+					accessoryDeviceIds: outcome.accessoryDeviceIds
 				});
-			} catch (err) {
-				logger.warn("homecom adopt failed", { meta: {
-					nativeId,
-					integrationId,
-					error: require_bosch_instances.errMsg(err)
-				} });
-				failures++;
 			}
 			if (adopted.length === 0 && failures > 0) throw new Error(`homecom adopt: all ${failures} adopt(s) failed`);
-			return { adopted: adopted.map((a) => ({
-				...a,
-				accessoryDeviceIds: []
-			})) };
+			return { adopted };
 		},
 		release: async ({ camDeviceId }) => {
 			await removeDevice(camDeviceId);
@@ -1767,66 +2151,6 @@ function buildHomeComAdoptionProvider(deps) {
 	};
 }
 //#endregion
-//#region src/homecom/homecom-gateway.ts
-var HomeComConnectionResolver = class {
-	#surfaces = /* @__PURE__ */ new Map();
-	set(integrationId, surface) {
-		if (surface === null) {
-			this.#surfaces.delete(integrationId);
-			return;
-		}
-		this.#surfaces.set(integrationId, surface);
-	}
-	has(integrationId) {
-		return this.#surfaces.has(integrationId);
-	}
-	list() {
-		return Array.from(this.#surfaces.keys()).map((id) => ({ id }));
-	}
-	discoverables(integrationId) {
-		return this.#surfaces.get(integrationId)?.discoverables ?? [];
-	}
-	getClient(integrationId) {
-		return this.#surfaces.get(integrationId)?.client ?? null;
-	}
-	getSnapshot(integrationId) {
-		return this.#surfaces.get(integrationId)?.snapshot ?? null;
-	}
-	updateSnapshot(integrationId, snapshot) {
-		const existing = this.#surfaces.get(integrationId);
-		if (!existing) return;
-		this.#surfaces.set(integrationId, {
-			...existing,
-			snapshot,
-			discoverables: buildDiscoverables(snapshot)
-		});
-	}
-	clear() {
-		this.#surfaces.clear();
-	}
-};
-function buildDiscoverables(snapshot) {
-	const out = [];
-	for (const circuit of snapshot.circuits) out.push({
-		nativeId: `hc:${circuit.id}`,
-		name: circuit.name,
-		kind: "heating-circuit",
-		circuitId: circuit.id
-	});
-	if (snapshot.dhw) out.push({
-		nativeId: "dhw:0",
-		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();
-//#endregion
 //#region src/homecom/homecom-integration-manager.ts
 var HomeComIntegrationManager = class {
 	#id;
@@ -2725,7 +3049,7 @@ var BoschHomeComProviderAddon = class extends require_bosch_instances.BaseDevice
 		if (typeof integrationId !== "string" || integrationId.length === 0) throw new Error("homecom generateStableId: brokerId required");
 		const nativeId = config?.["nativeId"];
 		if (typeof nativeId !== "string" || nativeId.length === 0) throw new Error("homecom generateStableId: nativeId required");
-		return `homecom:${integrationId}:${nativeId}`;
+		return homeComStableId(integrationId, nativeId);
 	}
 	async reconcileIntegrations() {
 		const reg = this.requireClients();
@@ -2787,12 +3111,14 @@ var BoschHomeComProviderAddon = class extends require_bosch_instances.BaseDevice
 					const config = await devices.loadConfig(d.id).catch(() => ({}));
 					out.push({
 						id: d.id,
+						stableId: d.stableId,
+						parentDeviceId: d.parentDeviceId,
 						config
 					});
 				}
 				return out;
 			},
-			adoptDevice: async ({ nativeId, integrationId, type, name, kind, circuitId }) => {
+			adoptDevice: async ({ nativeId, integrationId, type, name, kind, circuitId, parentDeviceId }) => {
 				const devices = this.ctx.kernel.devices;
 				if (!devices) throw new Error("homecom adopt: devices unavailable");
 				const config = {
@@ -2806,7 +3132,7 @@ var BoschHomeComProviderAddon = class extends require_bosch_instances.BaseDevice
 				const stableId = this.generateStableId(type, config);
 				const DeviceClass = this.deviceClasses[type];
 				if (!DeviceClass) throw new Error(`homecom adopt: unsupported type ${type}`);
-				return { deviceId: (await devices.create(stableId, DeviceClass, config, null, {
+				return { deviceId: (await devices.create(stableId, DeviceClass, config, parentDeviceId, {
 					type,
 					name,
 					integrationId