@camstack/addon-provider-bosch 0.0.0-stage → 0.1.2

package/dist/home-connect/addon.mjs

@@ -0,0 +1,3167 @@
+import { A as union, C as _enum, D as object, M as EventCategory, O as record, S as isSecretMarkerLike, T as literal, _ as DeviceType, b as defineCustomActions, c as dishwasherCapability, d as numericSensorCapability, f as powerMeterCapability, g as DeviceRole, i as binaryCapability, j as unknown, k as string, l as enumSensorCapability, n as BaseDeviceProvider, o as connectionTestCapability, s as deviceAdoptionCapability, t as BaseDevice, v as errMsg, w as array, x as isSecretMarker, y as customAction } from "../dist-BoMB3-eL.mjs";
+import { n as cascadeRemoveDevicesForIntegration, t as setIntegrationDevicesOnline } from "../account-integration-offline-l27nXZT3.mjs";
+import { createHash, randomBytes } from "node:crypto";
+import { connect } from "node:tls";
+import { inflateRawSync } from "node:zlib";
+import { lookup } from "node:dns/promises";
+//#region src/home-connect/custom-actions.ts
+var homeConnectActions = defineCustomActions({
+	beginSignIn: customAction(object({}), object({
+		authorizeUrl: string().min(1),
+		verifier: string().min(1),
+		state: string().min(1),
+		summary: string()
+	}), {
+		kind: "mutation",
+		auth: "admin"
+	}),
+	finishSignIn: customAction(object({
+		verifier: string().min(1),
+		callback: string().min(1),
+		state: string().min(1)
+	}), object({
+		token: string().min(1),
+		refresh: string().optional(),
+		appliances: string().min(1),
+		summary: string()
+	}), {
+		kind: "mutation",
+		auth: "admin"
+	})
+});
+//#endregion
+//#region src/home-connect/home-connect-device-description.ts
+/** Common Bosch Home Connect UIDs (homeconnect_websocket DESCRIPTION — live dishwasher). */
+var HOME_CONNECT_COMMON_ENTITY_FALLBACK = {
+	"5": {
+		uid: 5,
+		name: "BSH.Common.Status.BackendConnected"
+	},
+	"517": {
+		uid: 517,
+		name: "BSH.Common.Status.RemoteControlStartAllowed"
+	},
+	"523": {
+		uid: 523,
+		name: "BSH.Common.Status.RemoteControlActive"
+	},
+	"527": {
+		uid: 527,
+		name: "BSH.Common.Status.DoorState",
+		enumeration: {
+			0: "Open",
+			1: "Closed"
+		}
+	},
+	"552": {
+		uid: 552,
+		name: "BSH.Common.Status.OperationState",
+		enumeration: {
+			0: "Inactive",
+			1: "Ready",
+			2: "DelayedStart",
+			3: "Run",
+			4: "Pause",
+			5: "ActionRequired",
+			6: "Finished",
+			7: "Error",
+			8: "Aborting"
+		}
+	},
+	"539": {
+		uid: 539,
+		name: "BSH.Common.Setting.PowerState",
+		enumeration: {
+			1: "Off",
+			2: "On"
+		}
+	},
+	"542": {
+		uid: 542,
+		name: "BSH.Common.Option.ProgramProgress"
+	},
+	"544": {
+		uid: 544,
+		name: "BSH.Common.Option.RemainingProgramTime"
+	},
+	"558": {
+		uid: 558,
+		name: "BSH.Common.Option.StartInRelative"
+	},
+	"561": {
+		uid: 561,
+		name: "BSH.Common.Option.EnergyForecast"
+	},
+	"562": {
+		uid: 562,
+		name: "BSH.Common.Option.WaterForecast"
+	},
+	"256": {
+		uid: 256,
+		name: "BSH.Common.Root.ActiveProgram"
+	},
+	"257": {
+		uid: 257,
+		name: "BSH.Common.Root.SelectedProgram"
+	}
+};
+function buildCommonEntityFallbackDescription(input) {
+	return {
+		info: {
+			deviceID: input.haId,
+			deviceType: input.type,
+			model: input.name
+		},
+		program: [],
+		entities: HOME_CONNECT_COMMON_ENTITY_FALLBACK
+	};
+}
+function isDescriptionRoot(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseHexUid(raw) {
+	return Number.parseInt(raw, 16);
+}
+function parseFeatureMappingXml(xml) {
+	const features = /* @__PURE__ */ new Map();
+	for (const match of xml.matchAll(/<feature\s+refUID="([0-9A-Fa-f]+)"[^>]*>([^<]+)<\/feature>/g)) {
+		const uidHex = match[1];
+		const name = match[2]?.trim();
+		if (uidHex && name) features.set(parseHexUid(uidHex), name);
+	}
+	const enumerations = /* @__PURE__ */ new Map();
+	for (const block of xml.matchAll(/<enumDescription\s+refENID="([0-9A-Fa-f]+)"[^>]*>([\s\S]*?)<\/enumDescription>/g)) {
+		const enidHex = block[1];
+		const inner = block[2] ?? "";
+		if (!enidHex) continue;
+		const members = {};
+		for (const m of inner.matchAll(/<enumMember\s+refValue="(\d+)"[^>]*>([^<]+)<\/enumMember>/g)) {
+			const valueStr = m[1];
+			const label = m[2]?.trim();
+			if (valueStr && label) members[Number.parseInt(valueStr, 10)] = label;
+		}
+		enumerations.set(parseHexUid(enidHex), members);
+	}
+	return {
+		features,
+		enumerations
+	};
+}
+function tagAttrs(openTag) {
+	const attrs = {};
+	for (const m of openTag.matchAll(/(\w+)="([^"]*)"/g)) {
+		const key = m[1];
+		const val = m[2];
+		if (key && val !== void 0) attrs[key] = val;
+	}
+	return attrs;
+}
+var ENTITY_TAGS = [
+	"status",
+	"setting",
+	"option",
+	"command",
+	"event",
+	"program",
+	"activeProgram",
+	"selectedProgram"
+];
+function collectEntitiesFromDeviceXml(xml, features, enumerations) {
+	const out = [];
+	for (const tag of ENTITY_TAGS) {
+		const re = new RegExp(`<${tag}\\b([^>/]*)(?:\\/>|>([\\s\\S]*?)<\\/${tag}>)`, "g");
+		for (const match of xml.matchAll(re)) {
+			const attrs = tagAttrs(match[1] ?? "");
+			const uidRaw = attrs["uid"];
+			if (!uidRaw) continue;
+			const uid = parseHexUid(uidRaw);
+			const mapped = features.get(uid);
+			if (!mapped) continue;
+			const name = mapped.includes(".") ? mapped : `BSH.Common.${mapped}`;
+			let enumeration;
+			const enType = attrs["enumerationType"];
+			if (enType) enumeration = { ...enumerations.get(parseHexUid(enType)) };
+			out.push({
+				uid,
+				name,
+				enumeration
+			});
+		}
+	}
+	return out;
+}
+function infoFromDeviceXml(xml, deviceIdFallback) {
+	const type = xml.match(/<type>([^<]+)<\/type>/)?.[1] ?? "Appliance";
+	const brand = xml.match(/<brand>([^<]+)<\/brand>/)?.[1];
+	return {
+		deviceID: deviceIdFallback,
+		deviceType: type,
+		model: xml.match(/<model>([^<]+)<\/model>/)?.[1] ?? deviceIdFallback,
+		brand
+	};
+}
+function programsFromDeviceXml(xml, features) {
+	const programs = [];
+	for (const match of xml.matchAll(/<program\b([^>/]*)(?:\/>|>[\s\S]*?<\/program>)/g)) {
+		const attrs = tagAttrs(match[1] ?? "");
+		const uidRaw = attrs["uid"];
+		if (!uidRaw) continue;
+		const uid = parseHexUid(uidRaw);
+		const mapped = features.get(uid);
+		if (!mapped) continue;
+		const name = mapped.startsWith("BSH.") ? mapped : `BSH.Common.Program.${mapped}`;
+		programs.push({
+			name: name.split(".").pop() ?? name,
+			uid: name,
+			available: attrs["available"] !== "false"
+		});
+	}
+	return programs;
+}
+/** Parse IDDF XML pair into compact JSON stored on the appliance connection. */
+function parseHomeConnectIddfXml(input) {
+	const { features, enumerations } = parseFeatureMappingXml(input.featureMappingXml);
+	const entitiesList = collectEntitiesFromDeviceXml(input.deviceDescriptionXml, features, enumerations);
+	const entities = {};
+	for (const entity of entitiesList) entities[String(entity.uid)] = entity;
+	return {
+		info: infoFromDeviceXml(input.deviceDescriptionXml, input.haId),
+		program: programsFromDeviceXml(input.deviceDescriptionXml, features),
+		entities
+	};
+}
+function entityIndexFromDescription(input) {
+	const index = /* @__PURE__ */ new Map();
+	if (input === void 0 || input === null) return index;
+	try {
+		let root;
+		if (typeof input === "string") {
+			const parsed = JSON.parse(input.trim());
+			if (!isDescriptionRoot(parsed)) return index;
+			root = parsed;
+		} else if (isDescriptionRoot(input)) root = input;
+		else return index;
+		const entities = root["entities"];
+		if (!isDescriptionRoot(entities)) return index;
+		for (const [key, val] of Object.entries(entities)) {
+			if (!isDescriptionRoot(val)) continue;
+			const name = val["name"];
+			const uid = Number.parseInt(key, 10);
+			if (typeof name !== "string" || Number.isNaN(uid)) continue;
+			let enumeration;
+			const enumRaw = val["enumeration"];
+			if (isDescriptionRoot(enumRaw)) {
+				enumeration = {};
+				for (const [ek, ev] of Object.entries(enumRaw)) if (typeof ev === "string") enumeration[Number.parseInt(ek, 10)] = ev;
+			}
+			index.set(uid, {
+				uid,
+				name,
+				enumeration
+			});
+		}
+	} catch {
+		return index;
+	}
+	return index;
+}
+function decodeHomeConnectValue(uid, value, index) {
+	const entity = index.get(uid);
+	if (!entity) return null;
+	if (entity.enumeration && (typeof value === "number" || typeof value === "string" && /^\d+$/.test(value))) {
+		const num = typeof value === "number" ? value : Number.parseInt(value, 10);
+		const label = entity.enumeration[num];
+		return {
+			key: entity.name,
+			value: label ?? value
+		};
+	}
+	return {
+		key: entity.name,
+		value
+	};
+}
+function encodeHomeConnectValue(featureName, value, index) {
+	for (const entity of index.values()) {
+		if (entity.name !== featureName) continue;
+		if (entity.enumeration && typeof value === "string") {
+			for (const [num, label] of Object.entries(entity.enumeration)) if (label === value) return {
+				uid: entity.uid,
+				value: Number.parseInt(num, 10)
+			};
+		}
+		return {
+			uid: entity.uid,
+			value
+		};
+	}
+	return null;
+}
+//#endregion
+//#region src/home-connect/home-connect-iddf.ts
+function readUInt16LE(buf, offset) {
+	return buf.readUInt16LE(offset);
+}
+function readUInt32LE(buf, offset) {
+	return buf.readUInt32LE(offset);
+}
+function decodeZipPayload(method, payload) {
+	if (method === 0) return payload;
+	if (method === 8) try {
+		return inflateRawSync(payload);
+	} catch {
+		return null;
+	}
+	return null;
+}
+/** Extract file bodies from a ZIP (store + deflate). */
+function extractZipEntries(zip) {
+	const out = /* @__PURE__ */ new Map();
+	let pos = 0;
+	while (pos + 30 <= zip.length) {
+		const sig = readUInt32LE(zip, pos);
+		if (sig === 101010256) break;
+		if (sig !== 67324752) break;
+		const method = readUInt16LE(zip, pos + 8);
+		const compSize = readUInt32LE(zip, pos + 18);
+		const nameLen = readUInt16LE(zip, pos + 26);
+		const extraLen = readUInt16LE(zip, pos + 28);
+		const nameStart = pos + 30;
+		const name = zip.subarray(nameStart, nameStart + nameLen).toString("utf8");
+		const dataStart = nameStart + nameLen + extraLen;
+		const decoded = decodeZipPayload(method, zip.subarray(dataStart, dataStart + compSize));
+		if (decoded !== null) out.set(name, decoded);
+		pos = dataStart + compSize;
+	}
+	return out;
+}
+function parseIddfZipBuffer(zip, haId) {
+	const entries = extractZipEntries(zip);
+	let deviceXml;
+	let mappingXml;
+	for (const [name, body] of entries) {
+		if (name.endsWith("_DeviceDescription.xml")) deviceXml = body.toString("utf8");
+		if (name.endsWith("_FeatureMapping.xml")) mappingXml = body.toString("utf8");
+	}
+	if (!deviceXml || !mappingXml) return null;
+	return parseHomeConnectIddfXml({
+		deviceDescriptionXml: deviceXml,
+		featureMappingXml: mappingXml,
+		haId
+	});
+}
+var HOME_CONNECT_IDDF_URL = (haId) => `https://eu.services.home-connect.com/api/iddf/v1/iddf/${encodeURIComponent(haId)}`;
+//#endregion
+//#region src/home-connect/home-connect-login.ts
+/** Public OAuth client ids from the Home Connect app login (hcpy). */
+var APP_ID$1 = "9B75AC9EC512F36C84256AC47D813E2C1DD0D6520DF774B020E1E6E2EB29B1F3";
+var OAUTH_BASE = "https://api.home-connect.com/security/oauth/";
+var ASSET_BASE = "https://eu.services.home-connect.com/";
+var REDIRECT_URI = "hcauth://auth/prod";
+var AUTHORIZE_SCOPE = "Control DeleteAppliance IdentifyAppliance Images Monitor ReadAccount ReadOrigApi Settings WriteAppliance WriteOrigApi";
+var CookieJar = class {
+	#cookies = /* @__PURE__ */ new Map();
+	absorb(headers) {
+		const listed = headers.getSetCookie?.() ?? [];
+		const lines = listed.length > 0 ? listed : headerList(headers.get("set-cookie"));
+		for (const line of lines) {
+			const pair = line.split(";")[0] ?? "";
+			const eq = pair.indexOf("=");
+			if (eq <= 0) continue;
+			this.#cookies.set(pair.slice(0, eq).trim(), pair.slice(eq + 1).trim());
+		}
+	}
+	header() {
+		return [...this.#cookies.entries()].map(([name, value]) => `${name}=${value}`).join("; ");
+	}
+	get(name) {
+		return this.#cookies.get(name);
+	}
+};
+function headerList(value) {
+	return value ? [value] : [];
+}
+async function homeConnectLoginFetch(url, init) {
+	const response = await fetch(url, {
+		method: init.method,
+		headers: { ...init.headers },
+		body: init.body,
+		redirect: "manual"
+	});
+	return {
+		status: response.status,
+		headers: response.headers,
+		text: () => response.text(),
+		arrayBuffer: () => response.arrayBuffer()
+	};
+}
+function b64url(bytes) {
+	return bytes.toString("base64url");
+}
+async function exchange(fetchImpl, jar, url, method, extraHeaders, body) {
+	const headers = {
+		"user-agent": "hc-login/1.0",
+		accept: "application/json, text/html",
+		...extraHeaders
+	};
+	const cookie = jar.header();
+	if (cookie.length > 0) headers["cookie"] = cookie;
+	const csrf = jar.get("X-CSRF-FORM-TOKEN");
+	if (csrf) headers["RequestVerificationToken"] = csrf;
+	const response = await fetchImpl(url, {
+		method,
+		headers,
+		body,
+		redirect: "manual"
+	});
+	jar.absorb(response.headers);
+	return {
+		status: response.status,
+		location: response.headers.get("location"),
+		body: await response.text()
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(record, key) {
+	const value = record[key];
+	return typeof value === "string" ? value : void 0;
+}
+function tokensFromBody(body) {
+	const tokenJson = JSON.parse(body);
+	if (!isRecord(tokenJson)) throw new Error("Home Connect sign-in was rejected");
+	const token = tokenJson["access_token"];
+	const refresh = tokenJson["refresh_token"];
+	if (typeof token !== "string" || token.length === 0) throw new Error("Home Connect sign-in was rejected");
+	return {
+		token,
+		refresh: typeof refresh === "string" ? refresh : ""
+	};
+}
+function accountSummary(appliances) {
+	if (appliances.length === 0) return "Signed in. No appliances on this account yet.";
+	const names = appliances.map((app) => app.name).join(", ");
+	return `Signed in. ${appliances.length} appliance${appliances.length === 1 ? "" : "s"}: ${names}.`;
+}
+function accountIdFromAccessToken(token) {
+	const payload = token.split(".")[1];
+	if (!payload) throw new Error("Home Connect sign-in was rejected");
+	const padded = payload + "=".repeat((4 - payload.length % 4) % 4);
+	let parsed;
+	try {
+		parsed = JSON.parse(Buffer.from(padded, "base64url").toString("utf8"));
+	} catch {
+		throw new Error("Home Connect sign-in was rejected");
+	}
+	if (!isRecord(parsed) || typeof parsed["sub"] !== "string" || parsed["sub"].length === 0) throw new Error("Home Connect sign-in was rejected");
+	return parsed["sub"];
+}
+function listedFromPaired(row, encryption) {
+	if (row["isDemo"] === true) return null;
+	const haId = stringField(row, "haId");
+	if (!haId) return null;
+	const brand = (stringField(row, "brand") ?? "HomeConnect").toUpperCase();
+	const type = stringField(row, "haType") ?? stringField(row, "type") ?? "Appliance";
+	const tls = isRecord(encryption["tls"]) ? encryption["tls"] : void 0;
+	const aes = isRecord(encryption["aes"]) ? encryption["aes"] : void 0;
+	const tlsKey = tls ? stringField(tls, "key") : void 0;
+	const aesKey = aes ? stringField(aes, "key") : void 0;
+	const mode = tlsKey ? "TLS" : "AES";
+	const psk = tlsKey ?? aesKey;
+	if (!psk) return null;
+	const iv = aes ? stringField(aes, "iv") : void 0;
+	if (mode === "AES" && !iv) return null;
+	const host = mode === "TLS" ? `${brand}-${type}-${haId}` : haId;
+	return {
+		haId,
+		name: stringField(row, "vib") ?? `${brand} ${type}`,
+		type,
+		connection: {
+			host,
+			psk,
+			mode,
+			iv64: iv ?? "",
+			deviceDescription: JSON.stringify({ info: {
+				deviceID: haId,
+				deviceType: type,
+				model: `${brand} ${type}`
+			} })
+		}
+	};
+}
+async function appliancesForToken(token, fetchImpl, jar) {
+	const accountId = accountIdFromAccessToken(token);
+	const listed = await exchange(fetchImpl, jar, `${ASSET_BASE}api/account/v2/accounts/${encodeURIComponent(accountId)}/paired-appliances`, "GET", {
+		authorization: `Bearer ${token}`,
+		accept: "application/json"
+	});
+	if (listed.status >= 400) throw new Error("Home Connect sign-in was rejected");
+	let parsed;
+	try {
+		parsed = JSON.parse(listed.body);
+	} catch {
+		throw new Error("Home Connect sign-in was rejected");
+	}
+	if (!isRecord(parsed) || !Array.isArray(parsed["appliances"])) throw new Error("Home Connect sign-in was rejected");
+	const out = [];
+	for (const row of parsed["appliances"]) {
+		if (!isRecord(row)) continue;
+		const haId = stringField(row, "haId");
+		if (!haId) continue;
+		const enc = await exchange(fetchImpl, jar, `${ASSET_BASE}api/appliance/v2/appliances/${encodeURIComponent(haId)}/encryption-information`, "GET", {
+			authorization: `Bearer ${token}`,
+			accept: "application/json"
+		});
+		if (enc.status >= 400) continue;
+		let encryption;
+		try {
+			encryption = JSON.parse(enc.body);
+		} catch {
+			continue;
+		}
+		if (!isRecord(encryption)) continue;
+		const appliance = listedFromPaired(row, encryption);
+		if (!appliance) continue;
+		const iddfResponse = await fetchImpl(HOME_CONNECT_IDDF_URL(haId), {
+			method: "GET",
+			headers: {
+				authorization: `Bearer ${token}`,
+				accept: "application/zip"
+			},
+			redirect: "manual"
+		});
+		if (iddfResponse.status < 400 && iddfResponse.arrayBuffer) {
+			const compact = parseIddfZipBuffer(Buffer.from(await iddfResponse.arrayBuffer()), haId);
+			if (compact) {
+				out.push({
+					...appliance,
+					connection: {
+						...appliance.connection,
+						deviceDescription: JSON.stringify(compact)
+					}
+				});
+				continue;
+			}
+		}
+		out.push(appliance);
+	}
+	return out;
+}
+/** Load every appliance on the account. A stale access token is refreshed once when a refresh token exists. */
+async function fetchHomeConnectAccount(creds, fetchImpl = homeConnectLoginFetch) {
+	const jar = new CookieJar();
+	let token = creds.token;
+	let refresh = creds.refresh ?? "";
+	try {
+		const appliances = await appliancesForToken(token, fetchImpl, jar);
+		return {
+			token,
+			refresh,
+			appliances,
+			summary: accountSummary(appliances)
+		};
+	} catch (err) {
+		if (refresh.length === 0) throw err;
+	}
+	const refreshed = await exchange(fetchImpl, jar, `${OAUTH_BASE}token`, "POST", { "content-type": "application/x-www-form-urlencoded" }, new URLSearchParams({
+		grant_type: "refresh_token",
+		refresh_token: refresh,
+		client_id: APP_ID$1
+	}).toString());
+	if (refreshed.status >= 400) throw new Error("Home Connect sign-in was rejected");
+	const next = tokensFromBody(refreshed.body);
+	token = next.token;
+	refresh = next.refresh;
+	const appliances = await appliancesForToken(token, fetchImpl, jar);
+	return {
+		token,
+		refresh,
+		appliances,
+		summary: accountSummary(appliances)
+	};
+}
+/** Browser login link, matching Home Connect Local (`redirect_url` + the app scope). */
+function beginHomeConnectSignIn() {
+	const verifier = b64url(randomBytes(32));
+	const challenge = b64url(createHash("sha256").update(verifier).digest());
+	const state = b64url(randomBytes(16));
+	const authorize = new URL("authorize", OAUTH_BASE);
+	authorize.searchParams.set("redirect_url", REDIRECT_URI);
+	authorize.searchParams.set("client_id", APP_ID$1);
+	authorize.searchParams.set("response_type", "code");
+	authorize.searchParams.set("prompt", "login");
+	authorize.searchParams.set("code_challenge_method", "S256");
+	authorize.searchParams.set("code_challenge", challenge);
+	authorize.searchParams.set("state", state);
+	authorize.searchParams.set("nonce", b64url(randomBytes(16)));
+	authorize.searchParams.set("scope", AUTHORIZE_SCOPE);
+	return {
+		authorizeUrl: authorize.toString(),
+		verifier,
+		state
+	};
+}
+function callbackParams(callback) {
+	let url;
+	try {
+		url = new URL(callback.trim());
+	} catch {
+		throw new Error("Paste the full redirect address from the browser");
+	}
+	const code = url.searchParams.get("code") ?? url.hash.replace(/^#/, "").match(/(?:^|&)code=([^&]+)/)?.[1];
+	const state = url.searchParams.get("state") ?? "";
+	if (!code) throw new Error("Paste the full redirect address from the browser");
+	return {
+		code,
+		grantType: url.searchParams.get("grant_type") ?? "authorization_code",
+		state
+	};
+}
+/** Exchange the pasted redirect for the account token and each appliance profile. */
+async function completeHomeConnectSignIn(input, fetchImpl = homeConnectLoginFetch) {
+	const parsed = callbackParams(input.callback);
+	if (parsed.state !== input.state) throw new Error("State mismatch. Create the login link again.");
+	const { code, grantType } = parsed;
+	const token = await exchange(fetchImpl, new CookieJar(), `${OAUTH_BASE}token`, "POST", { "content-type": "application/x-www-form-urlencoded" }, new URLSearchParams({
+		grant_type: grantType,
+		client_id: APP_ID$1,
+		code,
+		code_verifier: input.verifier,
+		redirect_uri: REDIRECT_URI
+	}).toString());
+	if (token.status >= 400) throw new Error("Home Connect sign-in was rejected");
+	return fetchHomeConnectAccount(tokensFromBody(token.body), fetchImpl);
+}
+var HC_FEATURE_ACTIVE_PROGRAM = "BSH.Common.Setting.Program.Active";
+var HC_FEATURE_ROOT_ACTIVE_PROGRAM = "BSH.Common.Root.ActiveProgram";
+var HC_FEATURE_ROOT_SELECTED_PROGRAM = "BSH.Common.Root.SelectedProgram";
+var HC_FEATURE_REMAINING = "BSH.Common.Option.RemainingProgramTime";
+var HC_FEATURE_PROGRESS = "BSH.Common.Option.ProgramProgress";
+var HC_FEATURE_DOOR = "BSH.Common.Status.DoorState";
+var HC_FEATURE_REMOTE_START = "BSH.Common.Status.RemoteControlActive";
+var HC_FEATURE_POWER = "BSH.Common.Setting.PowerState";
+var HC_FEATURE_SALT = "BSH.Common.Setting.SaltLevel";
+var HC_FEATURE_RINSE = "BSH.Common.Setting.RinseAidLevel";
+var HC_FEATURE_HALF_LOAD = "BSH.Common.Option.HalfLoad";
+var HC_FEATURE_HYGIENE = "BSH.Common.Option.HygienePlus";
+var HC_FEATURE_EXTRA_DRY = "BSH.Common.Option.ExtraDry";
+var HC_FEATURE_INTENSIVE_ZONE = "BSH.Common.Option.IntensivZone";
+var HC_FEATURE_INTENSIVE_ZONE_ALT = "BSH.Common.Option.IntensiveZone";
+var HC_FEATURE_VARIO_SPEED = "BSH.Common.Option.VarioSpeed";
+var HC_FEATURE_VARIO_SPEED_PLUS = "BSH.Common.Option.VarioSpeedPlus";
+var HC_FEATURE_CHILD_LOCK = "BSH.Common.Setting.ChildLock";
+var HC_FEATURE_ENERGY_FORECAST = "BSH.Common.Option.EnergyForecast";
+var HC_FEATURE_WATER_FORECAST = "BSH.Common.Option.WaterForecast";
+var HC_FEATURE_ENERGY_CONSUMPTION = "BSH.Common.Option.EnergyConsumption";
+var HC_FEATURE_ENERGY_CONSUMPTION_STAT = "BSH.Common.Statistic.EnergyConsumption";
+var HC_FEATURE_WATER_CONSUMPTION = "BSH.Common.Option.WaterConsumption";
+var HC_FEATURE_REMOTE_CONTROL_LEVEL = "BSH.Common.Status.RemoteControlLevel";
+var HC_FEATURE_START_IN_RELATIVE = "BSH.Common.Option.StartInRelative";
+var HC_FEATURE_AMBIENT_LIGHT = "BSH.Common.Setting.AmbientLightEnabled";
+var HC_FEATURE_INTERIOR_LIGHT = "BSH.Common.Setting.InteriorLighting";
+var HC_FEATURE_BACKEND_CONNECTED = "BSH.Common.Status.BackendConnected";
+var HC_FEATURE_CLOUD_CONNECTED = "BSH.Common.Status.CloudConnected";
+var HC_FEATURE_PROGRAM_PHASE = "BSH.Common.Status.ProgramPhase";
+var HC_FEATURE_DISHWASHER_PROGRAM_PHASE = "Dishcare.Dishwasher.Status.ProgramPhase";
+var HC_PROGRAM_FEATURE_KEYS = [
+	HC_FEATURE_ACTIVE_PROGRAM,
+	HC_FEATURE_ROOT_ACTIVE_PROGRAM,
+	HC_FEATURE_ROOT_SELECTED_PROGRAM
+];
+/** Write key for intensive zone — matches the spelling the appliance exposes. */
+function intensiveZoneFeatureKeyFromFeatures(features) {
+	if (features.has("BSH.Common.Option.IntensiveZone") && !features.has("BSH.Common.Option.IntensivZone")) return HC_FEATURE_INTENSIVE_ZONE_ALT;
+	return HC_FEATURE_INTENSIVE_ZONE;
+}
+var HOME_CONNECT_SENSOR_CATALOG = [
+	{
+		stableIdSuffix: "energy-forecast",
+		kind: "energy-forecast",
+		featureKeys: [HC_FEATURE_ENERGY_FORECAST],
+		cap: "numeric-sensor",
+		defaultUnit: "%",
+		nameSuffix: "Energy forecast",
+		role: DeviceRole.EnergySensor
+	},
+	{
+		stableIdSuffix: "water-forecast",
+		kind: "water-forecast",
+		featureKeys: [HC_FEATURE_WATER_FORECAST],
+		cap: "numeric-sensor",
+		defaultUnit: "%",
+		nameSuffix: "Water forecast",
+		role: DeviceRole.NumericSensor
+	},
+	{
+		stableIdSuffix: "energy-consumed",
+		kind: "energy-consumed",
+		featureKeys: [HC_FEATURE_ENERGY_CONSUMPTION, HC_FEATURE_ENERGY_CONSUMPTION_STAT],
+		cap: "power-meter",
+		defaultUnit: "kWh",
+		nameSuffix: "Energy consumed",
+		role: DeviceRole.EnergySensor
+	},
+	{
+		stableIdSuffix: "water-consumed",
+		kind: "water-consumed",
+		featureKeys: [HC_FEATURE_WATER_CONSUMPTION],
+		cap: "numeric-sensor",
+		defaultUnit: "l",
+		nameSuffix: "Water consumed",
+		role: DeviceRole.NumericSensor
+	},
+	{
+		stableIdSuffix: "remote-control-level",
+		kind: "remote-control-level",
+		featureKeys: [HC_FEATURE_REMOTE_CONTROL_LEVEL],
+		cap: "enum-sensor",
+		nameSuffix: "Remote control level",
+		role: DeviceRole.EnumSensor
+	},
+	{
+		stableIdSuffix: "delayed-start",
+		kind: "delayed-start",
+		featureKeys: [HC_FEATURE_START_IN_RELATIVE],
+		cap: "numeric-sensor",
+		defaultUnit: "min",
+		nameSuffix: "Delayed start",
+		role: DeviceRole.NumericSensor
+	},
+	{
+		stableIdSuffix: "interior-light",
+		kind: "interior-light",
+		featureKeys: [HC_FEATURE_AMBIENT_LIGHT, HC_FEATURE_INTERIOR_LIGHT],
+		cap: "binary",
+		nameSuffix: "Interior light",
+		role: DeviceRole.BinaryHelper
+	},
+	{
+		stableIdSuffix: "connectivity",
+		kind: "connectivity",
+		featureKeys: [HC_FEATURE_BACKEND_CONNECTED, HC_FEATURE_CLOUD_CONNECTED],
+		cap: "binary",
+		nameSuffix: "Connectivity",
+		role: DeviceRole.ConnectivitySensor
+	},
+	{
+		stableIdSuffix: "program-phase",
+		kind: "program-phase",
+		featureKeys: [HC_FEATURE_PROGRAM_PHASE, HC_FEATURE_DISHWASHER_PROGRAM_PHASE],
+		cap: "enum-sensor",
+		nameSuffix: "Program phase",
+		role: DeviceRole.EnumSensor
+	}
+];
+function homeConnectSensorCatalogEntry(kind) {
+	const entry = HOME_CONNECT_SENSOR_CATALOG.find((e) => e.kind === kind);
+	if (entry === void 0) throw new Error(`home-connect: unknown sensor kind ${kind}`);
+	return entry;
+}
+var OPERATION_TO_STATE = {
+	Ready: "idle",
+	Inactive: "idle",
+	DelayedStart: "idle",
+	ActionRequired: "idle",
+	Run: "running",
+	Aborting: "running",
+	Pause: "paused",
+	Finished: "finished",
+	Error: "error"
+};
+function normalizeConsumableToken(raw) {
+	return raw.trim().toLowerCase().replace(/_/g, "");
+}
+function mapConsumable(raw) {
+	if (typeof raw !== "string" || raw.length === 0) return null;
+	const norm = normalizeConsumableToken(raw);
+	if (norm === "full" || norm === "ok") return "ok";
+	if (norm === "low" || norm === "nearlyempty") return "low";
+	if (norm === "empty") return "empty";
+	return null;
+}
+function readBool(raw) {
+	return raw === true || raw === "On" || raw === "Open" || raw === "Connected";
+}
+function readPowerOn(raw) {
+	if (raw === true || raw === "On" || raw === "OnState") return true;
+	if (raw === false || raw === "Off" || raw === "Standby") return false;
+	return false;
+}
+function readString(raw) {
+	return typeof raw === "string" && raw.length > 0 ? raw : null;
+}
+function readNumber(raw) {
+	if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+	if (typeof raw === "string") {
+		const n = Number(raw);
+		return Number.isFinite(n) ? n : null;
+	}
+	return null;
+}
+function readFeatureValue(features, keys) {
+	for (const key of keys) if (features.has(key)) return features.get(key);
+}
+/** Convert BSH remaining time raw value → whole minutes for the UI. */
+function remainingMinutesFromRaw(raw) {
+	const n = readNumber(raw);
+	if (n === null) return null;
+	if (n > 600) return Math.round(n / 60);
+	if (n > 0 && n < 48 && !Number.isInteger(n)) return Math.round(n * 60);
+	return Math.round(n);
+}
+function errorLabelFromFeatures(features, operationState, state) {
+	if (state !== "error") return null;
+	return readString(readFeatureValue(features, ["BSH.Common.Status.EventPresentState"])) ?? operationState;
+}
+/**
+* Map BSH.Common.* feature values → {@link DishwasherStatus}. Pure — the only
+* place dishwasher slice assembly happens for Home Connect local.
+*/
+function dishwasherStatusFromFeatures(input) {
+	const { features, availablePrograms, nowMs } = input;
+	const op = readString(features.get("BSH.Common.Status.OperationState")) ?? "Ready";
+	const state = OPERATION_TO_STATE[op] ?? "unavailable";
+	const program = readString(readFeatureValue(features, HC_PROGRAM_FEATURE_KEYS));
+	const remainingMinutes = remainingMinutesFromRaw(features.get(HC_FEATURE_REMAINING));
+	const progressPercent = readNumber(features.get(HC_FEATURE_PROGRESS));
+	const doorOpen = features.get(HC_FEATURE_DOOR) === "Open";
+	const remoteStartAllowed = readBool(features.get(HC_FEATURE_REMOTE_START));
+	const powerOn = readPowerOn(features.get(HC_FEATURE_POWER));
+	return {
+		state,
+		program,
+		availablePrograms: [...availablePrograms],
+		remainingMinutes,
+		progressPercent,
+		doorOpen,
+		remoteStartAllowed,
+		powerOn,
+		saltLevel: mapConsumable(features.get(HC_FEATURE_SALT)),
+		rinseAidLevel: mapConsumable(features.get(HC_FEATURE_RINSE)),
+		halfLoad: readBool(features.get(HC_FEATURE_HALF_LOAD)),
+		hygienePlus: readBool(features.get(HC_FEATURE_HYGIENE)),
+		extraDry: readBool(features.get(HC_FEATURE_EXTRA_DRY)),
+		intensiveZone: readBool(features.get("BSH.Common.Option.IntensivZone")) || readBool(features.get("BSH.Common.Option.IntensiveZone")),
+		varioSpeedPlus: readBool(readFeatureValue(features, [HC_FEATURE_VARIO_SPEED_PLUS, HC_FEATURE_VARIO_SPEED])),
+		childLock: readBool(features.get(HC_FEATURE_CHILD_LOCK)),
+		errorCode: state === "error" ? 1 : null,
+		errorLabel: errorLabelFromFeatures(features, op, state),
+		lastFetchedAt: nowMs
+	};
+}
+function homeConnectSensorSliceFromFeatures(input) {
+	const entry = homeConnectSensorCatalogEntry(input.kind);
+	const raw = readFeatureValue(input.features, entry.featureKeys);
+	const nowMs = input.nowMs;
+	if (entry.cap === "enum-sensor") return {
+		cap: "enum-sensor",
+		status: {
+			value: readString(raw) ?? "unknown",
+			lastFetchedAt: nowMs
+		}
+	};
+	if (entry.cap === "binary") return {
+		cap: "binary",
+		status: {
+			on: readBool(raw),
+			lastChangedAt: nowMs
+		}
+	};
+	if (entry.cap === "power-meter") {
+		const n = readNumber(raw);
+		return {
+			cap: "power-meter",
+			status: {
+				...n !== null ? { kwhTotal: n } : {},
+				unit: entry.defaultUnit,
+				lastFetchedAt: nowMs
+			}
+		};
+	}
+	const n = readNumber(raw);
+	let unit = entry.defaultUnit;
+	if (input.kind === "water-forecast" || input.kind === "water-consumed") {
+		if (n !== null && n >= 1e4 && unit === "l") unit = "ml";
+	}
+	if (input.kind === "delayed-start" && n !== null && n > 600) return {
+		cap: "numeric-sensor",
+		status: {
+			value: Math.round(n / 60),
+			unit: "min",
+			lastFetchedAt: nowMs
+		}
+	};
+	if (n === null) return {
+		cap: "numeric-sensor",
+		status: null
+	};
+	return {
+		cap: "numeric-sensor",
+		status: {
+			value: n,
+			...unit !== void 0 ? { unit } : {},
+			lastFetchedAt: nowMs
+		}
+	};
+}
+/** Command resource keys for WS POST-style mutations. */
+var HC_CMD_START = "BSH.Common.Command.StartProgram";
+var HC_CMD_PAUSE = "BSH.Common.Command.PauseProgram";
+var HC_CMD_STOP = "BSH.Common.Command.AbortProgram";
+var HC_CMD_SET_PROGRAM = "BSH.Common.Setting.Program.Active";
+var HC_CMD_SET_POWER = "BSH.Common.Setting.PowerState";
+//#endregion
+//#region src/home-connect/home-connect-discovery.ts
+/** Dishwasher accessory label: `Dishwasher` plus the appliance name. */
+function homeConnectDishwasherEntityName(containerName) {
+	const base = containerName.trim();
+	return base.length > 0 ? `Dishwasher ${base}` : "Dishwasher";
+}
+function buildHomeConnectApplianceChildSpecs(applianceName, haId) {
+	const label = applianceName.trim().length > 0 ? applianceName.trim() : haId;
+	return [{
+		role: "dishwasher",
+		stableIdSuffix: "dishwasher",
+		name: homeConnectDishwasherEntityName(applianceName)
+	}, ...HOME_CONNECT_SENSOR_CATALOG.map((entry) => ({
+		role: entry.kind,
+		stableIdSuffix: entry.stableIdSuffix,
+		name: `${label} — ${entry.nameSuffix}`
+	}))];
+}
+function deviceTypeForApplianceType(type) {
+	if (type.toLowerCase().includes("dishwasher")) return DeviceType.Container;
+	return null;
+}
+function sensorDiscoveryChild(haId, spec) {
+	const cap = HOME_CONNECT_SENSOR_CATALOG.find((e) => e.stableIdSuffix === spec.stableIdSuffix)?.cap ?? "numeric-sensor";
+	return {
+		childNativeId: `${haId}#${spec.stableIdSuffix}`,
+		name: spec.name,
+		type: DeviceType.Sensor,
+		status: "online",
+		metadata: { serialNumber: haId },
+		alreadyAdopted: false,
+		adoptedDeviceId: null,
+		capabilities: [cap]
+	};
+}
+function dishwasherContainerCandidate(app, adoptedId) {
+	const name = app.name.length > 0 ? app.name : app.haId;
+	const children = buildHomeConnectApplianceChildSpecs(name, app.haId).map((spec) => {
+		if (spec.role === "dishwasher") return {
+			childNativeId: `${app.haId}#dishwasher`,
+			name: spec.name,
+			type: DeviceType.Dishwasher,
+			status: "online",
+			metadata: {
+				serialNumber: app.haId,
+				model: app.type
+			},
+			alreadyAdopted: false,
+			adoptedDeviceId: null,
+			capabilities: ["dishwasher"]
+		};
+		return sensorDiscoveryChild(app.haId, spec);
+	});
+	return {
+		childNativeId: app.haId,
+		name,
+		type: DeviceType.Container,
+		status: "online",
+		metadata: {
+			serialNumber: app.haId,
+			model: app.type
+		},
+		alreadyAdopted: adoptedId !== null,
+		adoptedDeviceId: adoptedId,
+		capabilities: [],
+		children
+	};
+}
+function buildHomeConnectCandidates(input) {
+	const out = [];
+	for (const app of input.appliances) {
+		if (deviceTypeForApplianceType(app.type) === null) continue;
+		const adoptedId = input.adopted.get(app.haId) ?? null;
+		out.push(dishwasherContainerCandidate(app, adoptedId));
+	}
+	return out;
+}
+//#endregion
+//#region src/home-connect/home-connect-adoption-provider.ts
+var DEVICES_FILTER = {
+	id: "devices",
+	label: "Devices",
+	isDefault: true
+};
+async function adoptedMapForIntegration(integrationId, listAdopted) {
+	const all = await listAdopted();
+	const map = /* @__PURE__ */ new Map();
+	for (const device of all) if (device.config["system"] === "home-connect" && device.config["brokerId"] === integrationId) {
+		const haId = device.config["haId"];
+		if (typeof haId === "string") map.set(haId, device.id);
+	}
+	return map;
+}
+function buildHomeConnectAdoptionProvider(deps) {
+	const { registry, hasIntegration, listIntegrations, listAdopted, adoptDevice, removeDevice, findDeviceConfig, logger } = deps;
+	async function allCandidatesForIntegration(integrationId) {
+		return buildHomeConnectCandidates({
+			appliances: registry.appliances(integrationId),
+			adopted: await adoptedMapForIntegration(integrationId, listAdopted)
+		});
+	}
+	return {
+		listCandidateFilters: async () => ({ filters: [DEVICES_FILTER] }),
+		listCandidates: async ({ integrationId, page, pageSize }) => {
+			const cands = await allCandidatesForIntegration(integrationId);
+			const start = (page - 1) * pageSize;
+			return {
+				candidates: cands.slice(start, start + pageSize),
+				totalCount: cands.length,
+				page,
+				pageSize
+			};
+		},
+		getCandidate: async ({ integrationId, childNativeId }) => {
+			return (await allCandidatesForIntegration(integrationId)).find((c) => c.childNativeId === childNativeId) ?? null;
+		},
+		getStatus: async () => {
+			try {
+				let candidateCount = 0;
+				for (const integrationId of listIntegrations()) candidateCount += (await allCandidatesForIntegration(integrationId)).length;
+				const adoptedCount = (await listAdopted()).filter((d) => d.config["system"] === "home-connect").length;
+				return {
+					lastDiscoveryAt: Date.now(),
+					candidateCount,
+					adoptedCount,
+					lastError: null
+				};
+			} catch (err) {
+				return {
+					lastDiscoveryAt: null,
+					candidateCount: 0,
+					adoptedCount: 0,
+					lastError: errMsg(err)
+				};
+			}
+		},
+		refresh: async ({ integrationId }) => {
+			const candidateCount = (await allCandidatesForIntegration(integrationId)).length;
+			const adoptedCount = (await adoptedMapForIntegration(integrationId, listAdopted)).size;
+			return {
+				lastDiscoveryAt: Date.now(),
+				candidateCount,
+				adoptedCount,
+				lastError: null
+			};
+		},
+		adopt: async ({ integrationId, childNativeIds, perCandidate }) => {
+			if (!registry.has(integrationId)) throw new Error(`home-connect adopt: integration ${integrationId} not connected`);
+			const appliances = registry.appliances(integrationId);
+			const adopted = [];
+			let failures = 0;
+			for (const haId of childNativeIds) try {
+				const app = appliances.find((a) => a.haId === haId);
+				if (!app) {
+					failures++;
+					continue;
+				}
+				const candidate = buildHomeConnectCandidates({
+					appliances: [app],
+					adopted: /* @__PURE__ */ new Map()
+				})[0];
+				if (!candidate) {
+					failures++;
+					continue;
+				}
+				const name = perCandidate?.[haId]?.name ?? app.name;
+				const { deviceId } = await adoptDevice({
+					haId,
+					integrationId,
+					type: candidate.type,
+					name,
+					applianceType: app.type,
+					availablePrograms: app.availablePrograms
+				});
+				adopted.push({
+					childNativeId: haId,
+					parentDeviceId: deviceId
+				});
+			} catch (err) {
+				logger.warn("home-connect adopt failed", { meta: {
+					haId,
+					integrationId,
+					error: errMsg(err)
+				} });
+				failures++;
+			}
+			if (adopted.length === 0 && failures > 0) throw new Error(`home-connect adopt: all ${failures} adopt(s) failed`);
+			return { adopted: adopted.map((a) => ({
+				...a,
+				accessoryDeviceIds: []
+			})) };
+		},
+		release: async ({ camDeviceId }) => {
+			await removeDevice(camDeviceId);
+		},
+		resync: async ({ camDeviceId }) => {
+			const cfg = await findDeviceConfig(camDeviceId);
+			if (!cfg || cfg["system"] !== "home-connect") throw new Error(`home-connect resync: device ${camDeviceId} not found`);
+			const integrationId = String(cfg["brokerId"]);
+			const haId = String(cfg["haId"]);
+			if (!hasIntegration(integrationId)) throw new Error(`home-connect resync: integration ${integrationId} not connected`);
+			if (!registry.appliances(integrationId).some((a) => a.haId === haId)) throw new Error(`home-connect resync: appliance ${haId} no longer present`);
+			return {
+				changed: false,
+				rebuiltChildren: 0
+			};
+		}
+	};
+}
+var HomeConnectModeSchema = _enum(["AES", "TLS"]);
+function isPlainObject$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var homeConnectDeviceDescriptionSchema = union([string(), record(string(), unknown())]).optional();
+object({
+	host: string().min(1),
+	psk: string().min(1).meta({ secret: true }),
+	mode: HomeConnectModeSchema.default("AES"),
+	iv64: string().optional(),
+	deviceDescription: homeConnectDeviceDescriptionSchema
+});
+/** One appliance saved at sign-in, so adopt does not need another cloud call. */
+var homeConnectStoredApplianceSchema = object({
+	haId: string().min(1),
+	name: string(),
+	type: string(),
+	host: string().min(1),
+	psk: string().min(1),
+	mode: HomeConnectModeSchema,
+	iv64: string().optional(),
+	deviceDescription: homeConnectDeviceDescriptionSchema
+});
+/** The integration is the Home Connect account. Profiles are downloaded once at sign-in. */
+var homeConnectConfigSchema = object({
+	token: string().min(1).describe("Home Connect access token").meta({ secret: true }),
+	refresh: string().optional().describe("Home Connect refresh token").meta({ secret: true }),
+	appliances: array(homeConnectStoredApplianceSchema).optional()
+});
+/**
+* Before `integrations.setSettings`: keep objects as-is (serializes as `json`), parse
+* textarea JSON strings into objects so they are not re-serialized as `string` and
+* corrupted on read by `deserializeSetting(String(object))`.
+*/
+function homeConnectSettingsForPersist(settings) {
+	const next = { ...settings };
+	delete next["accountEmail"];
+	delete next["accountPassword"];
+	delete next["authorizeUrl"];
+	delete next["verifier"];
+	delete next["callback"];
+	delete next["state"];
+	if (next["refresh"] === "") delete next["refresh"];
+	const appliancesRaw = next["appliances"];
+	if (typeof appliancesRaw === "string" && appliancesRaw.trim().startsWith("[")) try {
+		const parsedAppliances = JSON.parse(appliancesRaw);
+		if (Array.isArray(parsedAppliances)) next["appliances"] = parsedAppliances;
+	} catch {}
+	const raw = next["deviceDescription"];
+	if (typeof raw !== "string") return next;
+	const trimmed = raw.trim();
+	if (trimmed.length === 0) return next;
+	if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return next;
+	try {
+		const parsed = JSON.parse(trimmed);
+		if (isPlainObject$1(parsed)) return {
+			...next,
+			deviceDescription: parsed
+		};
+	} catch {
+		return next;
+	}
+	return next;
+}
+function connectionFromSettings(settings) {
+	const parsed = homeConnectConfigSchema.safeParse(homeConnectSettingsForPersist(settings));
+	return parsed.success ? parsed.data : null;
+}
+function hasNonEmptyString(settings, key) {
+	const value = settings[key];
+	return typeof value === "string" && value.trim().length > 0;
+}
+/** Why reconcile cannot build a connection; null when `connectionFromSettings` would succeed. */
+function homeConnectSettingsGap(settings) {
+	if (connectionFromSettings(settings) !== null) return null;
+	const token = settings["token"];
+	if (isSecretMarker(token) || isSecretMarkerLike(token)) return "token-unresolved-marker";
+	if (!hasNonEmptyString(settings, "token")) return "token-missing";
+	return "schema-invalid";
+}
+/** Reconcile path: warn once per incomplete integration (never logs secret values). */
+function logHomeConnectSettingsGap(logger, integrationId, settings) {
+	const gap = homeConnectSettingsGap(settings);
+	if (gap === null) return;
+	const token = settings["token"];
+	logger.warn("Home Connect integration has incomplete account settings — skipping", { meta: {
+		integrationId,
+		gap,
+		tokenIsSecretMarker: isSecretMarker(token),
+		tokenType: typeof token,
+		hasToken: hasNonEmptyString(settings, "token"),
+		hasRefresh: hasNonEmptyString(settings, "refresh")
+	} });
+}
+function sameHomeConnectConnection(a, b) {
+	if (a === null || b === null) return false;
+	return a.token === b.token && (a.refresh ?? "") === (b.refresh ?? "") && JSON.stringify(a.appliances ?? []) === JSON.stringify(b.appliances ?? []);
+}
+/** Sentinel so the gateway fields stay filled by sign-in and stay off the form. */
+var HOME_CONNECT_PAIRED_ONLY = "__paired_only__";
+function buildHomeConnectFormSchema() {
+	const pairedOnly = {
+		field: "authorizeUrl",
+		equals: HOME_CONNECT_PAIRED_ONLY
+	};
+	return { sections: [{
+		id: "gateway",
+		title: "Home Connect",
+		description: "Create the login link and open it in the browser. After signing in, paste the full address the browser tried to open (it starts with hcauth://). The appliances are downloaded and then spoken to on the local network.",
+		columns: 1,
+		fields: [
+			{
+				type: "addon-action-button",
+				addonId: "bosch-home-connect",
+				key: "__home-connect-begin",
+				label: "Home Connect",
+				buttonLabel: "Create login link",
+				action: "beginSignIn",
+				variant: "primary",
+				assignResult: {
+					authorizeUrl: "authorizeUrl",
+					verifier: "verifier",
+					state: "state"
+				},
+				successMessage: "Open the link in Chrome and sign in."
+			},
+			{
+				type: "textarea",
+				key: "authorizeUrl",
+				label: "Login link",
+				required: false,
+				omitFromSettings: true
+			},
+			{
+				type: "text",
+				key: "callback",
+				label: "Redirect address",
+				required: false,
+				placeholder: "hcauth://auth/prod?code=…&state=…",
+				omitFromSettings: true
+			},
+			{
+				type: "password",
+				key: "state",
+				label: "Login state",
+				required: false,
+				omitFromSettings: true,
+				showWhen: pairedOnly
+			},
+			{
+				type: "password",
+				key: "verifier",
+				label: "Login verifier",
+				required: false,
+				omitFromSettings: true,
+				showWhen: pairedOnly
+			},
+			{
+				type: "addon-action-button",
+				addonId: "bosch-home-connect",
+				key: "__home-connect-finish",
+				label: "Finish",
+				buttonLabel: "Complete sign-in",
+				action: "finishSignIn",
+				variant: "primary",
+				paramsFromForm: {
+					verifier: "verifier",
+					callback: "callback",
+					state: "state"
+				},
+				assignResult: {
+					token: "token",
+					refresh: "refresh",
+					appliances: "appliances"
+				},
+				successMessage: "{summary}"
+			},
+			{
+				type: "password",
+				key: "token",
+				label: "Access token",
+				required: true,
+				showWhen: pairedOnly
+			},
+			{
+				type: "password",
+				key: "refresh",
+				label: "Refresh token",
+				required: false,
+				showWhen: pairedOnly
+			},
+			{
+				type: "textarea",
+				key: "appliances",
+				label: "Appliances",
+				required: true,
+				showWhen: pairedOnly
+			}
+		]
+	}] };
+}
+/** WebSocket URL for local Home Connect (plain WS on port 80 path /homeconnect). */
+function homeConnectWsUrl(config) {
+	return `${config.mode === "TLS" ? "wss" : "ws"}://${config.host.replace(/^https?:\/\//, "").replace(/\/$/, "")}/homeconnect`;
+}
+//#endregion
+//#region src/home-connect/home-connect-gateway.ts
+var HomeConnectConnectionResolver = class {
+	#surfaces = /* @__PURE__ */ new Map();
+	set(integrationId, surface) {
+		if (surface === null) {
+			this.#surfaces.delete(integrationId);
+			return;
+		}
+		this.#surfaces.set(integrationId, surface);
+	}
+	appliances(integrationId) {
+		return this.#surfaces.get(integrationId)?.appliances ?? [];
+	}
+	has(integrationId) {
+		return this.#surfaces.has(integrationId);
+	}
+	list() {
+		return Array.from(this.#surfaces.keys()).map((id) => ({ id }));
+	}
+	getClient(integrationId) {
+		return this.#surfaces.get(integrationId)?.client ?? null;
+	}
+	clear() {
+		this.#surfaces.clear();
+	}
+};
+var homeConnectConnections = new HomeConnectConnectionResolver();
+//#endregion
+//#region src/home-connect/home-connect-tls-wire.ts
+function decodePsk64(psk64) {
+	return Buffer.from(`${psk64}===`, "base64url");
+}
+function parseHttpHeaders(buffer) {
+	const marker = buffer.indexOf("\r\n\r\n");
+	if (marker < 0) return null;
+	return {
+		headers: buffer.subarray(0, marker + 4),
+		rest: buffer.subarray(marker + 4)
+	};
+}
+function readWsFrame(buffer) {
+	if (buffer.length < 2) return null;
+	const b0 = buffer.at(0);
+	const b1 = buffer.at(1);
+	if (b0 === void 0 || b1 === void 0) return null;
+	const opcode = b0 & 15;
+	const masked = (b1 & 128) !== 0;
+	let payloadLen = b1 & 127;
+	let offset = 2;
+	if (payloadLen === 126) {
+		if (buffer.length < 4) return null;
+		payloadLen = buffer.readUInt16BE(2);
+		offset = 4;
+	} else if (payloadLen === 127) {
+		if (buffer.length < 10) return null;
+		payloadLen = Number(buffer.readBigUInt64BE(2));
+		offset = 10;
+	}
+	const maskLen = masked ? 4 : 0;
+	if (buffer.length < offset + maskLen + payloadLen) return null;
+	let payload = buffer.subarray(offset + maskLen, offset + maskLen + payloadLen);
+	if (masked) {
+		const mask = buffer.subarray(offset, offset + 4);
+		const unmasked = Buffer.alloc(payload.length);
+		for (let i = 0; i < payload.length; i += 1) unmasked[i] = (payload.at(i) ?? 0) ^ (mask.at(i % 4) ?? 0);
+		payload = unmasked;
+	}
+	if (opcode === 8) return {
+		payload: Buffer.alloc(0),
+		consumed: offset + maskLen + payloadLen
+	};
+	return {
+		payload,
+		consumed: offset + maskLen + payloadLen
+	};
+}
+function writeWsTextFrame(text) {
+	const payload = Buffer.from(text, "utf8");
+	const mask = randomBytes(4);
+	const headerLen = payload.length < 126 ? 2 : payload.length < 65536 ? 4 : 10;
+	const frame = Buffer.alloc(headerLen + 4 + payload.length);
+	frame[0] = 129;
+	if (payload.length < 126) {
+		frame[1] = 128 | payload.length;
+		mask.copy(frame, 2);
+		for (let i = 0; i < payload.length; i += 1) {
+			const pb = payload.at(i) ?? 0;
+			const mb = mask.at(i % 4) ?? 0;
+			frame[6 + i] = pb ^ mb;
+		}
+	} else if (payload.length < 65536) {
+		frame[1] = 254;
+		frame.writeUInt16BE(payload.length, 2);
+		mask.copy(frame, 4);
+		for (let i = 0; i < payload.length; i += 1) {
+			const pb = payload.at(i) ?? 0;
+			const mb = mask.at(i % 4) ?? 0;
+			frame[8 + i] = pb ^ mb;
+		}
+	} else {
+		frame[1] = 255;
+		frame.writeBigUInt64BE(BigInt(payload.length), 2);
+		mask.copy(frame, 10);
+		for (let i = 0; i < payload.length; i += 1) {
+			const pb = payload.at(i) ?? 0;
+			const mb = mask.at(i % 4) ?? 0;
+			frame[14 + i] = pb ^ mb;
+		}
+	}
+	return frame;
+}
+function createHomeConnectTlsWire(input) {
+	let socket = null;
+	let open = false;
+	const textListeners = /* @__PURE__ */ new Set();
+	const closedListeners = /* @__PURE__ */ new Set();
+	let recvBuffer = Buffer.alloc(0);
+	let upgraded = false;
+	function emitText(text) {
+		for (const fn of textListeners) fn(text);
+	}
+	function emitClosed() {
+		open = false;
+		for (const fn of closedListeners) fn();
+	}
+	function drainFrames() {
+		while (true) {
+			const parsed = readWsFrame(recvBuffer);
+			if (!parsed) return;
+			recvBuffer = Buffer.from(recvBuffer.subarray(parsed.consumed));
+			if (parsed.payload.length === 0) continue;
+			emitText(parsed.payload.toString("utf8"));
+		}
+	}
+	return {
+		get open() {
+			return open;
+		},
+		async connect() {
+			if (open) return;
+			const psk = decodePsk64(input.psk);
+			await new Promise((resolve, reject) => {
+				socket = connect({
+					host: input.connectAddress,
+					port: 443,
+					servername: input.host,
+					ciphers: "PSK",
+					minVersion: "TLSv1.2",
+					maxVersion: "TLSv1.2",
+					rejectUnauthorized: false,
+					checkServerIdentity: () => void 0,
+					pskCallback: () => ({
+						psk,
+						identity: ""
+					})
+				}, () => {
+					const key = randomBytes(16).toString("base64");
+					const req = [
+						"GET /homeconnect HTTP/1.1",
+						`Host: ${input.host}`,
+						"Upgrade: websocket",
+						"Connection: Upgrade",
+						`Sec-WebSocket-Key: ${key}`,
+						"Sec-WebSocket-Version: 13",
+						"",
+						""
+					].join("\r\n");
+					socket?.write(req);
+				});
+				socket.on("data", (chunk) => {
+					recvBuffer = Buffer.concat([recvBuffer, chunk]);
+					if (!upgraded) {
+						const parsed = parseHttpHeaders(recvBuffer);
+						if (!parsed) return;
+						if (!(parsed.headers.toString("utf8").split("\r\n")[0] ?? "").includes("101")) {
+							reject(/* @__PURE__ */ new Error("Home Connect WebSocket upgrade failed"));
+							return;
+						}
+						upgraded = true;
+						recvBuffer = Buffer.from(parsed.rest);
+						open = true;
+						resolve();
+						drainFrames();
+						return;
+					}
+					drainFrames();
+				});
+				socket.on("error", (err) => reject(err));
+				socket.on("close", () => emitClosed());
+			});
+		},
+		send(text) {
+			if (!socket || !open) throw new Error("Home Connect TLS wire not open");
+			socket.write(writeWsTextFrame(text));
+		},
+		close() {
+			socket?.destroy();
+			socket = null;
+			emitClosed();
+		},
+		onText(listener) {
+			textListeners.add(listener);
+			return () => textListeners.delete(listener);
+		},
+		onClosed(listener) {
+			closedListeners.add(listener);
+			return () => closedListeners.delete(listener);
+		}
+	};
+}
+//#endregion
+//#region src/home-connect/home-connect-message.ts
+var HC_ACTION = {
+	GET: "GET",
+	POST: "POST",
+	RESPONSE: "RESPONSE",
+	NOTIFY: "NOTIFY"
+};
+function loadHomeConnectMessage(raw) {
+	const msg = JSON.parse(raw);
+	if (typeof msg !== "object" || msg === null) throw new Error("Invalid Home Connect message");
+	const row = msg;
+	const sID = row["sID"];
+	const msgID = row["msgID"];
+	const resource = row["resource"];
+	const version = row["version"];
+	const action = row["action"];
+	if (typeof sID !== "number" || typeof msgID !== "number" || typeof resource !== "string" || typeof version !== "number" || typeof action !== "string") throw new Error("Invalid Home Connect message fields");
+	let data;
+	const dataRaw = row["data"];
+	if (dataRaw !== void 0) data = (Array.isArray(dataRaw) ? dataRaw : [dataRaw]).filter((item) => typeof item === "object" && item !== null);
+	const code = row["code"];
+	return {
+		sID,
+		msgID,
+		resource,
+		version,
+		action,
+		data,
+		code: typeof code === "number" ? code : void 0
+	};
+}
+function dumpHomeConnectMessage(input) {
+	const msg = {
+		sID: input.sID,
+		msgID: input.msgID,
+		resource: input.resource,
+		version: input.version,
+		action: input.action
+	};
+	if (input.data !== void 0) msg["data"] = Array.isArray(input.data) ? input.data : [input.data];
+	if (input.code !== void 0) msg["code"] = input.code;
+	return JSON.stringify(msg);
+}
+function responseTo(init, data) {
+	return {
+		sID: init.sID,
+		msgID: init.msgID,
+		resource: init.resource,
+		version: init.version,
+		action: HC_ACTION.RESPONSE,
+		data: [data]
+	};
+}
+//#endregion
+//#region src/home-connect/home-connect-session.ts
+var APP_NAME = "CamStack";
+var APP_ID = "camstack-hc";
+/** Max wait for appliance `/ei/initialValues` after the socket opens. */
+var HOME_CONNECT_INIT_RESOURCE_TIMEOUT_MS = 12e3;
+var HomeConnectSession = class {
+	#wire;
+	#entityIndex;
+	#onFeature;
+	#onEmptyEntityIndex;
+	#sid = 0;
+	#warnedUndecodedUid = false;
+	#nextMsgId = 1;
+	#serviceVersions = {};
+	#pending = /* @__PURE__ */ new Map();
+	#connected = false;
+	#unsubText = null;
+	constructor(options) {
+		this.#wire = options.wire;
+		this.#entityIndex = options.entityIndex;
+		this.#onFeature = options.onFeature;
+		this.#onEmptyEntityIndex = options.onEmptyEntityIndex;
+	}
+	get connected() {
+		return this.#connected;
+	}
+	async connect() {
+		if (this.#connected) return;
+		this.#unsubText = this.#wire.onText((text) => this.#handleIncoming(text));
+		const initPromise = this.#waitForResource("/ei/initialValues");
+		await this.#wire.connect();
+		const init = loadHomeConnectMessage(await initPromise);
+		this.#sid = init.sID;
+		const edMsgId = (init.data?.[0])?.["edMsgID"];
+		if (typeof edMsgId === "number") this.#nextMsgId = edMsgId;
+		this.#wire.send(dumpHomeConnectMessage(responseTo(init, {
+			deviceType: init.version === 1 ? 2 : "Application",
+			deviceName: APP_NAME,
+			deviceID: APP_ID
+		})));
+		const services = await this.#sendGet("/ci/services", 1);
+		this.#setServiceVersions(services);
+		if (this.#serviceVersions["ei"] === 2) await this.#sendNotify("/ei/deviceReady");
+		if ("iz" in this.#serviceVersions) await this.#sendGet("/iz/info", this.#serviceVersions["iz"] ?? 1).catch(() => void 0);
+		const mandatory = await this.#sendGet("/ro/allMandatoryValues", this.#serviceVersions["ro"] ?? 1);
+		this.#applyValuePayload(mandatory.data);
+		if (this.#entityIndex.size === 0) this.#onEmptyEntityIndex?.();
+		this.#connected = true;
+	}
+	close() {
+		this.#connected = false;
+		this.#unsubText?.();
+		this.#unsubText = null;
+		for (const pending of this.#pending.values()) pending.reject(/* @__PURE__ */ new Error("Home Connect session closed"));
+		this.#pending.clear();
+		this.#wire.close();
+	}
+	async setFeatureByName(key, value) {
+		const encoded = encodeHomeConnectValue(key, value, this.#entityIndex);
+		if (!encoded) throw new Error(`Unknown Home Connect feature: ${key}`);
+		await this.#sendPost("/ro/values", this.#serviceVersions["ro"] ?? 1, [{
+			uid: encoded.uid,
+			value: encoded.value
+		}]);
+		this.#onFeature(key, value);
+	}
+	#setServiceVersions(message) {
+		const versions = {};
+		for (const row of message.data ?? []) {
+			const service = row["service"];
+			const version = row["version"];
+			if (typeof service === "string" && typeof version === "number") versions[service] = version;
+		}
+		this.#serviceVersions = versions;
+	}
+	#applyValuePayload(data) {
+		if (!data) return;
+		for (const row of data) this.#applyUidRow(row);
+	}
+	#applyUidRow(row) {
+		const uidRaw = row["uid"];
+		const value = row["value"];
+		if (typeof uidRaw !== "number") return;
+		const decoded = decodeHomeConnectValue(uidRaw, value, this.#entityIndex);
+		if (decoded) {
+			this.#onFeature(decoded.key, decoded.value);
+			return;
+		}
+		if (this.#entityIndex.size === 0 && !this.#warnedUndecodedUid) {
+			this.#warnedUndecodedUid = true;
+			this.#onEmptyEntityIndex?.();
+		}
+	}
+	#handleIncoming(text) {
+		let message;
+		try {
+			message = loadHomeConnectMessage(text);
+		} catch {
+			return;
+		}
+		if (message.action === HC_ACTION.RESPONSE) {
+			const waiter = this.#pending.get(message.msgID);
+			if (waiter) {
+				this.#pending.delete(message.msgID);
+				waiter.resolve(message);
+			}
+			return;
+		}
+		if (message.action === HC_ACTION.NOTIFY && message.resource === "/ro/values") this.#applyValuePayload(message.data);
+	}
+	#waitForResource(resource) {
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			const finish = (fn) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				unsubText();
+				unsubClosed();
+				fn();
+			};
+			const unsubText = this.#wire.onText((text) => {
+				try {
+					if (loadHomeConnectMessage(text).resource === resource) finish(() => resolve(text));
+				} catch {}
+			});
+			const unsubClosed = this.#wire.onClosed(() => {
+				finish(() => reject(/* @__PURE__ */ new Error("Home Connect wire closed before init")));
+			});
+			const timer = setTimeout(() => {
+				finish(() => reject(/* @__PURE__ */ new Error(`Home Connect init timeout waiting for ${resource}`)));
+			}, HOME_CONNECT_INIT_RESOURCE_TIMEOUT_MS);
+		});
+	}
+	async #sendGet(resource, version) {
+		return this.#sendAndWaitResponse({
+			sID: this.#sid,
+			msgID: this.#allocMsgId(),
+			resource,
+			version,
+			action: HC_ACTION.GET
+		});
+	}
+	async #sendPost(resource, version, data) {
+		return this.#sendAndWaitResponse({
+			sID: this.#sid,
+			msgID: this.#allocMsgId(),
+			resource,
+			version,
+			action: HC_ACTION.POST,
+			data
+		});
+	}
+	async #sendNotify(resource) {
+		const msg = {
+			sID: this.#sid,
+			msgID: this.#allocMsgId(),
+			resource,
+			version: this.#serviceVersions[resource.slice(1, 3)] ?? 1,
+			action: HC_ACTION.NOTIFY
+		};
+		this.#wire.send(dumpHomeConnectMessage(msg));
+	}
+	#allocMsgId() {
+		const id = this.#nextMsgId;
+		this.#nextMsgId += 1;
+		return id;
+	}
+	async #sendAndWaitResponse(outgoing) {
+		return new Promise((resolve, reject) => {
+			this.#pending.set(outgoing.msgID, {
+				resolve,
+				reject
+			});
+			this.#wire.send(dumpHomeConnectMessage(outgoing));
+			setTimeout(() => {
+				if (this.#pending.has(outgoing.msgID)) {
+					this.#pending.delete(outgoing.msgID);
+					reject(/* @__PURE__ */ new Error(`Home Connect response timeout for ${outgoing.resource}`));
+				}
+			}, 5e3);
+		});
+	}
+};
+//#endregion
+//#region src/home-connect/home-connect-ws-client.ts
+var WS_OPEN = 1;
+function programNamesFromLegacyList(programsRaw) {
+	const programs = [];
+	if (!Array.isArray(programsRaw)) return programs;
+	for (const p of programsRaw) if (typeof p === "string") programs.push(p);
+	return programs;
+}
+function programNamesFromHaDeviceDescription(programsRaw) {
+	const programs = [];
+	if (!Array.isArray(programsRaw)) return programs;
+	for (const p of programsRaw) if (typeof p === "object" && p !== null) {
+		const name = p["name"];
+		if (typeof name === "string") programs.push(name);
+	} else if (typeof p === "string") programs.push(p);
+	return programs;
+}
+function parseLegacyAppliancesList(rawList) {
+	if (!Array.isArray(rawList)) return [];
+	const appliances = [];
+	for (const item of rawList) {
+		if (typeof item !== "object" || item === null) continue;
+		const row = item;
+		const haId = row["haId"];
+		const name = row["name"];
+		const type = row["type"];
+		if (typeof haId !== "string") continue;
+		appliances.push({
+			haId,
+			name: typeof name === "string" ? name : haId,
+			type: typeof type === "string" ? type : "Dishwasher",
+			availablePrograms: programNamesFromLegacyList(row["programs"])
+		});
+	}
+	return appliances;
+}
+function parseHaDeviceDescription(record) {
+	const info = record["info"];
+	if (typeof info !== "object" || info === null) return [];
+	const infoRec = info;
+	const deviceID = infoRec["deviceID"];
+	if (typeof deviceID !== "string") return [];
+	const deviceType = infoRec["deviceType"];
+	const model = infoRec["model"];
+	return [{
+		haId: deviceID,
+		name: typeof model === "string" && model.length > 0 ? model : deviceID,
+		type: typeof deviceType === "string" ? deviceType : "Dishwasher",
+		availablePrograms: programNamesFromHaDeviceDescription(record["program"])
+	}];
+}
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseDeviceDescriptionRecord(record) {
+	const rawList = record["appliances"];
+	if (Array.isArray(rawList)) return { appliances: parseLegacyAppliancesList(rawList) };
+	const fromHa = parseHaDeviceDescription(record);
+	if (fromHa.length > 0) return { appliances: fromHa };
+	return { appliances: [] };
+}
+function parseDeviceDescription(input) {
+	if (input === void 0) return { appliances: [] };
+	if (isPlainObject(input)) return parseDeviceDescriptionRecord(input);
+	if (typeof input !== "string") return { appliances: [] };
+	const trimmed = input.trim();
+	if (trimmed.length === 0 || trimmed === "[object Object]") return { appliances: [] };
+	try {
+		const root = JSON.parse(trimmed);
+		if (!isPlainObject(root)) return { appliances: [] };
+		return parseDeviceDescriptionRecord(root);
+	} catch {
+		return { appliances: [] };
+	}
+}
+function usesProtocolStack(config, deps) {
+	if (deps.wireFactory) return true;
+	return config.mode === "TLS";
+}
+async function resolveConnectAddress(host) {
+	try {
+		const result = await lookup(host, { verbatim: true });
+		return typeof result === "string" ? result : result.address;
+	} catch {
+		return host.replace(/^https?:\/\//, "").split("/")[0] ?? host;
+	}
+}
+var defaultWireFactory = (input) => {
+	if (input.mode === "TLS") return createHomeConnectTlsWire({
+		host: input.host,
+		connectAddress: input.connectAddress,
+		psk: input.psk
+	});
+	throw new Error("Home Connect AES local socket is not implemented — use TLS pairing");
+};
+function createHomeConnectWsClient(config, deps = {}) {
+	const appliances = [...parseDeviceDescription(config.deviceDescription).appliances];
+	const entityIndex = entityIndexFromDescription(config.deviceDescription);
+	const primaryHaId = appliances[0]?.haId ?? config.host;
+	if (usesProtocolStack(config, deps)) return createProtocolHomeConnectClient({
+		config,
+		appliances,
+		entityIndex,
+		primaryHaId,
+		wireFactory: deps.wireFactory ?? defaultWireFactory,
+		onProtocolWarn: deps.onProtocolWarn
+	});
+	if (entityIndex.size > 0 && config.mode === "AES") deps.onProtocolWarn?.("aes-legacy-fallback-with-entities");
+	return createLegacySubscribeClient(config, deps, appliances);
+}
+function createProtocolHomeConnectClient(input) {
+	const featureStore = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let session = null;
+	let connected = false;
+	const haId = input.primaryHaId;
+	function ensureFeatures() {
+		let map = featureStore.get(haId);
+		if (!map) {
+			map = /* @__PURE__ */ new Map();
+			featureStore.set(haId, map);
+		}
+		return map;
+	}
+	function applyFeature(key, value) {
+		ensureFeatures().set(key, value);
+		for (const fn of listeners) fn(haId, key, value);
+	}
+	return {
+		async connect() {
+			if (connected) return;
+			const connectAddress = await resolveConnectAddress(input.config.host);
+			const wire = input.wireFactory({
+				host: input.config.host,
+				connectAddress,
+				psk: input.config.psk,
+				mode: input.config.mode,
+				iv64: input.config.iv64
+			});
+			let warnedEmptyIndex = false;
+			session = new HomeConnectSession({
+				wire,
+				entityIndex: input.entityIndex,
+				onFeature: applyFeature,
+				onEmptyEntityIndex: () => {
+					if (warnedEmptyIndex) return;
+					warnedEmptyIndex = true;
+					input.onProtocolWarn?.("empty-entity-index");
+				}
+			});
+			await session.connect();
+			connected = true;
+		},
+		close() {
+			connected = false;
+			session?.close();
+			session = null;
+		},
+		getAppliances() {
+			return input.appliances;
+		},
+		getFeatures(targetHaId) {
+			if (targetHaId !== haId && !featureStore.has(targetHaId)) return /* @__PURE__ */ new Map();
+			return featureStore.get(targetHaId) ?? ensureFeatures();
+		},
+		async setFeature(targetHaId, key, value) {
+			if (!session?.connected) throw new Error("Home Connect WebSocket not connected");
+			if (targetHaId !== haId) throw new Error(`Unknown appliance ${targetHaId}`);
+			await session.setFeatureByName(key, value);
+		},
+		onFeatureChange(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
+	};
+}
+function createLegacySubscribeClient(config, deps, appliances) {
+	const wsFactory = deps.wsFactory ?? defaultWsFactoryLegacy;
+	const url = homeConnectWsUrl(config);
+	const featureStore = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let ws = null;
+	let connected = false;
+	function ensureFeatures(haId) {
+		let map = featureStore.get(haId);
+		if (!map) {
+			map = /* @__PURE__ */ new Map();
+			featureStore.set(haId, map);
+		}
+		return map;
+	}
+	function applyFeature(haId, key, value) {
+		ensureFeatures(haId).set(key, value);
+		for (const fn of listeners) fn(haId, key, value);
+	}
+	return {
+		async connect() {
+			if (connected) return;
+			await new Promise((resolve, reject) => {
+				const socket = wsFactory(url);
+				ws = socket;
+				const onOpen = () => {
+					connected = true;
+					socket.removeEventListener("open", onOpen);
+					socket.removeEventListener("error", onError);
+					for (const app of appliances) socket.send(JSON.stringify({
+						type: "subscribe",
+						haId: app.haId
+					}));
+					resolve();
+				};
+				const onError = () => {
+					reject(/* @__PURE__ */ new Error("Home Connect WebSocket connection failed"));
+				};
+				socket.addEventListener("open", onOpen);
+				socket.addEventListener("error", onError);
+				socket.addEventListener("message", (ev) => {
+					if (!ev.data) return;
+					try {
+						const msg = JSON.parse(ev.data);
+						if (typeof msg !== "object" || msg === null) return;
+						const row = msg;
+						if (row["type"] === "feature") {
+							const msgHaId = row["haId"];
+							const key = row["key"];
+							if (typeof msgHaId === "string" && typeof key === "string") applyFeature(msgHaId, key, row["value"]);
+						}
+					} catch {}
+				});
+			});
+		},
+		close() {
+			connected = false;
+			ws?.close();
+			ws = null;
+		},
+		getAppliances() {
+			return appliances;
+		},
+		getFeatures(haId) {
+			return ensureFeatures(haId);
+		},
+		async setFeature(haId, key, value) {
+			if (!ws || ws.readyState !== WS_OPEN) throw new Error("Home Connect WebSocket not connected");
+			ws.send(JSON.stringify({
+				type: "set",
+				haId,
+				key,
+				value
+			}));
+			applyFeature(haId, key, value);
+		},
+		onFeatureChange(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
+	};
+}
+function isWsLike(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const row = value;
+	return typeof row["readyState"] === "number" && typeof row["send"] === "function" && typeof row["close"] === "function" && typeof row["addEventListener"] === "function" && typeof row["removeEventListener"] === "function";
+}
+function defaultWsFactoryLegacy(url) {
+	const WS = globalThis.WebSocket;
+	if (typeof WS !== "function") throw new Error(`WebSocket unavailable — cannot connect to ${url}`);
+	const socket = new WS(url);
+	if (!isWsLike(socket)) throw new Error(`WebSocket instance is not WsLike-compatible (${url})`);
+	return socket;
+}
+/** Default factory used by the integration manager (overridable in tests). */
+var defaultHomeConnectWsClientFactory = (config) => createHomeConnectWsClient(config);
+//#endregion
+//#region src/home-connect/home-connect-account-client.ts
+/** One account session: the token lists appliances, each appliance has its own local socket. */
+async function openHomeConnectAccount(options) {
+	return accountClient((await fetchHomeConnectAccount({
+		token: options.token,
+		refresh: options.refresh
+	}, options.fetchImpl)).appliances, options.makeGateway ?? defaultHomeConnectWsClientFactory);
+}
+function accountClient(appliances, makeGateway) {
+	const listed = appliances.map((app) => ({
+		haId: app.haId,
+		name: app.name,
+		type: app.type,
+		availablePrograms: []
+	}));
+	const children = /* @__PURE__ */ new Map();
+	for (const app of appliances) children.set(app.haId, makeGateway(app.connection));
+	const listeners = /* @__PURE__ */ new Set();
+	const unsubs = [];
+	for (const [haId, child] of children) unsubs.push(child.onFeatureChange((eventHaId, key, value) => {
+		const id = eventHaId.length > 0 ? eventHaId : haId;
+		for (const fn of listeners) fn(id, key, value);
+	}));
+	return {
+		async connect() {
+			const results = await Promise.allSettled([...children.values()].map((child) => child.connect()));
+			if (results.length > 0 && results.every((result) => result.status === "rejected")) {
+				const first = results[0];
+				if (first?.status === "rejected") throw first.reason;
+			}
+		},
+		close() {
+			for (const unsub of unsubs) unsub();
+			for (const child of children.values()) child.close();
+		},
+		getAppliances: () => listed,
+		getFeatures(haId) {
+			return children.get(haId)?.getFeatures(haId) ?? /* @__PURE__ */ new Map();
+		},
+		async setFeature(haId, key, value) {
+			const child = children.get(haId);
+			if (!child) throw new Error(`Home Connect appliance ${haId} is not on this account`);
+			await child.setFeature(haId, key, value);
+		},
+		onFeatureChange(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
+	};
+}
+//#endregion
+//#region src/home-connect/home-connect-iddf-fetch.ts
+function entityCountInStoredDescription(description) {
+	if (description === void 0) return 0;
+	return entityIndexFromDescription(description).size;
+}
+async function fetchHomeConnectIddfCompact(haId, token, fetchImpl) {
+	const response = await fetchImpl(HOME_CONNECT_IDDF_URL(haId), {
+		method: "GET",
+		headers: {
+			authorization: `Bearer ${token}`,
+			accept: "application/zip"
+		},
+		redirect: "manual"
+	});
+	if (response.status >= 400 || !response.arrayBuffer) return null;
+	const bytes = await response.arrayBuffer();
+	return parseIddfZipBuffer(Buffer.from(bytes), haId);
+}
+function compactDescriptionToStored(compact) {
+	return JSON.parse(JSON.stringify(compact));
+}
+function entityCountForCompact(compact) {
+	if (compact === null) return 0;
+	return entityIndexFromDescription(JSON.parse(JSON.stringify(compact))).size;
+}
+/** Fill missing IDDF entity maps on stored appliances (TLS first). Returns whether any row changed. */
+async function enrichHomeConnectConnection(connection, fetchImpl, hooks = {}) {
+	const appliances = connection.appliances ?? [];
+	if (appliances.length === 0) return {
+		connection,
+		changed: false
+	};
+	const token = connection.token;
+	if (isSecretMarker(token) || isSecretMarkerLike(token)) return {
+		connection,
+		changed: false
+	};
+	let changed = false;
+	const nextAppliances = [];
+	for (const row of appliances) {
+		if (!(row.mode === "TLS" && entityCountInStoredDescription(row.deviceDescription) === 0)) {
+			nextAppliances.push(row);
+			continue;
+		}
+		let descriptionToStore = await fetchHomeConnectIddfCompact(row.haId, token, fetchImpl);
+		let entityCount = entityCountForCompact(descriptionToStore);
+		if (entityCount === 0) {
+			descriptionToStore = buildCommonEntityFallbackDescription({
+				haId: row.haId,
+				type: row.type,
+				name: row.name
+			});
+			entityCount = entityCountForCompact(descriptionToStore);
+			hooks.onInfo?.("using common BSH entity fallback", { haId: row.haId });
+		}
+		if (entityCount === 0 || descriptionToStore === null) {
+			nextAppliances.push(row);
+			continue;
+		}
+		changed = true;
+		nextAppliances.push({
+			...row,
+			deviceDescription: compactDescriptionToStored(descriptionToStore)
+		});
+	}
+	if (!changed) return {
+		connection,
+		changed: false
+	};
+	return {
+		connection: {
+			...connection,
+			appliances: nextAppliances
+		},
+		changed: true
+	};
+}
+//#endregion
+//#region src/home-connect/home-connect-stored-appliance.ts
+function stubDeviceDescriptionObject(row) {
+	return { info: {
+		deviceID: row.haId,
+		deviceType: row.type,
+		model: row.name
+	} };
+}
+function stubDeviceDescription(row) {
+	return JSON.stringify(stubDeviceDescriptionObject(row));
+}
+function serializedDeviceDescription(row) {
+	if (row.deviceDescription === void 0) return stubDeviceDescription(row);
+	if (typeof row.deviceDescription === "string") return row.deviceDescription;
+	return JSON.stringify(row.deviceDescription);
+}
+function isDescriptionRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseLoginDeviceDescription(raw) {
+	const trimmed = raw.trim();
+	if (trimmed.length === 0) return {};
+	try {
+		const parsed = JSON.parse(trimmed);
+		if (isDescriptionRecord(parsed)) return { deviceDescription: parsed };
+	} catch {
+		return {};
+	}
+	return {};
+}
+function listedApplianceFromStored(row) {
+	return {
+		haId: row.haId,
+		name: row.name,
+		type: row.type,
+		connection: {
+			host: row.host,
+			psk: row.psk,
+			mode: row.mode,
+			iv64: row.iv64 ?? "",
+			deviceDescription: serializedDeviceDescription(row)
+		}
+	};
+}
+//#endregion
+//#region src/home-connect/home-connect-integration-manager.ts
+async function openStoredOrAccount(connection, deps) {
+	let working = connection;
+	const stored = working.appliances ?? [];
+	if (stored.length > 0) {
+		const token = working.token;
+		if (isSecretMarker(token) || isSecretMarkerLike(token)) deps.logger?.warn("Home Connect skipping IDDF enrich — access token not resolved yet", { meta: { tokenIsSecretMarker: isSecretMarker(token) } });
+		const enriched = isSecretMarker(token) || isSecretMarkerLike(token) ? {
+			connection: working,
+			changed: false
+		} : await enrichHomeConnectConnection(working, deps.fetchImpl ?? homeConnectLoginFetch, { onInfo: (message, meta) => {
+			deps.logger?.info(message, { meta });
+		} });
+		working = enriched.connection;
+		if (enriched.changed) deps.logger?.info("Home Connect enriched appliance IDDF from cloud", { meta: { applianceCount: working.appliances?.length ?? 0 } });
+	}
+	if (stored.length > 0) {
+		for (const row of working.appliances ?? []) if (row.mode === "TLS" && entityCountInStoredDescription(row.deviceDescription) === 0) deps.logger?.warn("Home Connect appliance has no IDDF entity map — re-sign-in or cloud IDDF fetch failed; features will not decode", { meta: {
+			haId: row.haId,
+			host: row.host
+		} });
+		const warnProtocol = (code) => {
+			deps.logger?.warn("Home Connect local protocol warning", { meta: { code } });
+		};
+		return {
+			connection: working,
+			client: accountClient(working.appliances.map(listedApplianceFromStored), (gateway) => createHomeConnectWsClient(gateway, { onProtocolWarn: warnProtocol }))
+		};
+	}
+	return {
+		connection: working,
+		client: await openHomeConnectAccount({
+			token: working.token,
+			refresh: working.refresh ?? "",
+			fetchImpl: deps.fetchImpl
+		})
+	};
+}
+var HomeConnectIntegrationManager = class {
+	#id;
+	#name;
+	#connection;
+	#logger;
+	#onConnected;
+	#onDisconnected;
+	#surfaceSink;
+	#makeClient;
+	#fetchImpl;
+	#onConnectionUpdated;
+	#client = null;
+	#status = "disconnected";
+	#lastCheckedAt = null;
+	#error = null;
+	constructor(options) {
+		this.#id = options.id;
+		this.#name = options.name;
+		this.#connection = options.connection;
+		this.#logger = options.logger;
+		this.#onConnected = options.onConnected;
+		this.#onDisconnected = options.onDisconnected;
+		this.#surfaceSink = options.surfaceSink;
+		this.#makeClient = options.makeClient ?? null;
+		this.#fetchImpl = options.fetchImpl;
+		this.#onConnectionUpdated = options.onConnectionUpdated;
+	}
+	getConnection() {
+		return this.#connection;
+	}
+	getInfo() {
+		const applianceCount = this.#client?.getAppliances().length ?? 0;
+		return {
+			id: this.#id,
+			name: this.#name,
+			kind: "home-connect",
+			status: this.#status,
+			info: { applianceCount },
+			lastCheckedAt: this.#lastCheckedAt,
+			error: this.#error
+		};
+	}
+	async start() {
+		if (this.#client !== null) return;
+		this.#status = "connecting";
+		this.#error = null;
+		const before = this.#connection;
+		let client;
+		if (this.#makeClient) client = this.#makeClient(this.#connection);
+		else {
+			const opened = await openStoredOrAccount(this.#connection, {
+				fetchImpl: this.#fetchImpl,
+				logger: this.#logger
+			});
+			client = opened.client;
+			this.#connection = opened.connection;
+			if (!sameHomeConnectConnection(before, this.#connection)) this.#onConnectionUpdated?.(this.#id, this.#connection);
+		}
+		this.#client = client;
+		const seededAppliances = client.getAppliances();
+		if (seededAppliances.length > 0) this.#surfaceSink.set(this.#id, {
+			appliances: seededAppliances,
+			client
+		});
+		try {
+			await client.connect();
+			const surface = {
+				appliances: client.getAppliances(),
+				client
+			};
+			this.#surfaceSink.set(this.#id, surface);
+			this.#status = "connected";
+			this.#lastCheckedAt = Date.now();
+			this.#onConnected(this.#id);
+		} catch (err) {
+			this.#status = "error";
+			this.#error = errMsg(err);
+			this.#lastCheckedAt = Date.now();
+			const appliances = client.getAppliances();
+			if (appliances.length > 0) {
+				this.#surfaceSink.set(this.#id, {
+					appliances,
+					client
+				});
+				this.#logger.warn("HomeConnectIntegrationManager: connect failed, keeping appliance inventory from pairing", { meta: {
+					integrationId: this.#id,
+					error: this.#error,
+					applianceCount: appliances.length
+				} });
+				return;
+			}
+			this.#surfaceSink.set(this.#id, null);
+			this.#onDisconnected(this.#id);
+			throw err;
+		}
+	}
+	async stop() {
+		const client = this.#client;
+		this.#client = null;
+		this.#status = "disconnected";
+		this.#surfaceSink.set(this.#id, null);
+		if (client) try {
+			client.close();
+		} catch (err) {
+			this.#logger.warn("HomeConnectIntegrationManager: client close failed", { meta: {
+				integrationId: this.#id,
+				error: errMsg(err)
+			} });
+		}
+		this.#onDisconnected(this.#id);
+	}
+	async applyConnection(conn) {
+		await this.stop();
+		this.#connection = conn;
+		await this.start();
+	}
+};
+//#endregion
+//#region src/home-connect/home-connect-client-registry.ts
+var HomeConnectClientRegistry = class {
+	#logger;
+	#onConnected;
+	#onDisconnected;
+	#makeManager;
+	#onConnectionUpdated;
+	#entries = /* @__PURE__ */ new Map();
+	constructor(logger, deps = {}) {
+		this.#logger = logger;
+		this.#onConnected = deps.onConnected ?? (() => void 0);
+		this.#onDisconnected = deps.onDisconnected ?? (() => void 0);
+		this.#onConnectionUpdated = deps.onConnectionUpdated;
+		const makeClient = deps.makeClient;
+		const fetchImpl = deps.fetchImpl;
+		this.#makeManager = deps.makeManager ?? ((opts) => new HomeConnectIntegrationManager({
+			id: opts.integrationId,
+			name: opts.name,
+			connection: opts.connection,
+			logger: opts.logger,
+			onConnected: opts.onConnected,
+			onDisconnected: opts.onDisconnected,
+			surfaceSink: homeConnectConnections,
+			makeClient,
+			fetchImpl,
+			onConnectionUpdated: this.#onConnectionUpdated
+		}));
+	}
+	setOnConnected(cb) {
+		this.#onConnected = cb;
+	}
+	setOnDisconnected(cb) {
+		this.#onDisconnected = cb;
+	}
+	async upsert(integrationId, name, connection) {
+		const existing = this.#entries.get(integrationId);
+		if (existing) {
+			if (sameHomeConnectConnection(existing.connection, connection)) return;
+			try {
+				await existing.manager.applyConnection(connection);
+				this.#entries.set(integrationId, {
+					manager: existing.manager,
+					connection: existing.manager.getConnection()
+				});
+			} catch (err) {
+				this.#logger.warn("HomeConnectClientRegistry: applyConnection failed", { meta: {
+					integrationId,
+					error: errMsg(err)
+				} });
+			}
+			return;
+		}
+		const manager = this.#makeManager({
+			integrationId,
+			name,
+			connection,
+			logger: this.#logger,
+			onConnected: (id) => this.#onConnected(id),
+			onDisconnected: (id) => this.#onDisconnected(id)
+		});
+		this.#entries.set(integrationId, {
+			manager,
+			connection
+		});
+		try {
+			await manager.start();
+			this.#entries.set(integrationId, {
+				manager,
+				connection: manager.getConnection()
+			});
+		} catch (err) {
+			this.#logger.warn("HomeConnectClientRegistry: manager start failed", { meta: {
+				integrationId,
+				error: errMsg(err)
+			} });
+		}
+	}
+	async remove(integrationId) {
+		const entry = this.#entries.get(integrationId);
+		if (!entry) return;
+		this.#entries.delete(integrationId);
+		try {
+			await entry.manager.stop();
+		} catch (err) {
+			this.#logger.warn("HomeConnectClientRegistry: remove stop failed", { meta: {
+				integrationId,
+				error: errMsg(err)
+			} });
+		}
+	}
+	async retain(keep) {
+		const stale = [...this.#entries.keys()].filter((id) => !keep.has(id));
+		for (const id of stale) await this.remove(id);
+	}
+	async shutdown() {
+		const ids = [...this.#entries.keys()];
+		await Promise.all(ids.map(async (id) => {
+			try {
+				await this.#entries.get(id)?.manager.stop();
+			} catch (err) {
+				this.#logger.warn("HomeConnectClientRegistry: shutdown stop failed", { meta: {
+					integrationId: id,
+					error: errMsg(err)
+				} });
+			}
+		}));
+		this.#entries.clear();
+		homeConnectConnections.clear();
+	}
+	has(integrationId) {
+		return this.#entries.has(integrationId);
+	}
+	list() {
+		return [...this.#entries.keys()];
+	}
+	getConnection(integrationId) {
+		return this.#entries.get(integrationId)?.connection ?? null;
+	}
+	getInfo(integrationId) {
+		return this.#entries.get(integrationId)?.manager.getInfo() ?? null;
+	}
+	size() {
+		return this.#entries.size;
+	}
+};
+//#endregion
+//#region src/home-connect/home-connect-connection-test.ts
+var TEST_LABEL = "Checks the Home Connect account token and lists appliances";
+function buildHomeConnectConnectionTestProvider(deps) {
+	const { logger } = deps;
+	return {
+		describeTest: async () => ({ label: TEST_LABEL }),
+		testSettings: async ({ settings }) => {
+			const normalized = homeConnectSettingsForPersist(typeof settings === "object" && settings !== null ? settings : {});
+			const parsed = homeConnectConfigSchema.safeParse(normalized);
+			if (!parsed.success) return {
+				outcome: "rejected",
+				error: `Home Connect settings incomplete: ${parsed.error.issues.map((issue) => issue.path.join(".") || "(root)").join(", ")}`
+			};
+			const saved = parsed.data.appliances ?? [];
+			if (saved.length > 0) {
+				const names = saved.map((app) => app.name).join(", ");
+				return {
+					outcome: "validated",
+					latencyMs: 0,
+					detail: names.length > 0 ? names : `${String(saved.length)} appliance(s) on this account`
+				};
+			}
+			const startedAt = Date.now();
+			try {
+				const account = await fetchHomeConnectAccount(parsed.data, deps.fetchImpl);
+				return {
+					outcome: "validated",
+					latencyMs: Date.now() - startedAt,
+					detail: account.summary
+				};
+			} catch (err) {
+				const message = errMsg(err);
+				if (message.includes("rejected")) return {
+					outcome: "rejected",
+					error: "Home Connect refused this account token. Sign in again."
+				};
+				logger.warn("Home Connect account test inconclusive", { meta: { error: message } });
+				return {
+					outcome: "inconclusive",
+					error: "Could not reach Home Connect to read this account."
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/home-connect/devices/home-connect-dishwasher-device.ts
+var homeConnectDishwasherSchema = object({
+	haId: string().min(1),
+	brokerId: string().min(1),
+	applianceType: string().optional(),
+	availablePrograms: array(string()).default([]),
+	system: literal("home-connect").optional(),
+	integrationId: string().optional()
+});
+var DISH_CAP = "dishwasher";
+var COLD_START = {
+	state: "unavailable",
+	program: null,
+	availablePrograms: [],
+	remainingMinutes: null,
+	progressPercent: null,
+	doorOpen: false,
+	remoteStartAllowed: false,
+	powerOn: false,
+	saltLevel: null,
+	rinseAidLevel: null,
+	halfLoad: false,
+	hygienePlus: false,
+	extraDry: false,
+	intensiveZone: false,
+	varioSpeedPlus: false,
+	childLock: false,
+	errorCode: null,
+	errorLabel: null,
+	lastFetchedAt: 0
+};
+var HomeConnectDishwasherDevice = class extends BaseDevice {
+	features = [];
+	#haId;
+	#brokerId;
+	#availablePrograms;
+	#featureUnsub = null;
+	#intensiveZoneWriteKey = HC_FEATURE_INTENSIVE_ZONE;
+	constructor(ctx) {
+		const persisted = homeConnectDishwasherSchema.parse(ctx.persistedConfig ?? {});
+		super(ctx, homeConnectDishwasherSchema, { type: DeviceType.Dishwasher });
+		this.#haId = persisted.haId;
+		this.#brokerId = persisted.brokerId;
+		this.#availablePrograms = persisted.availablePrograms;
+		this.online = true;
+		this.updateSourceInfo({
+			id: this.#haId,
+			system: "home-connect"
+		});
+	}
+	async onActivate() {
+		await super.onActivate();
+		this.registerDishwasherCap();
+		this.runtimeState.setCapState(DISH_CAP, COLD_START);
+		this.attachFeatureListener();
+		this.recomputeSlice();
+	}
+	async removeDevice() {
+		this.#featureUnsub?.();
+		this.#featureUnsub = null;
+		await super.removeDevice();
+	}
+	attachFeatureListener() {
+		const client = homeConnectConnections.getClient(this.#brokerId);
+		if (!client) return;
+		this.#featureUnsub = client.onFeatureChange((haId, key, _value) => {
+			if (haId !== this.#haId) return;
+			if (key === "BSH.Common.Option.IntensivZone" || key === "BSH.Common.Option.IntensiveZone") this.#intensiveZoneWriteKey = key;
+			this.recomputeSlice();
+		});
+	}
+	recomputeSlice() {
+		const client = homeConnectConnections.getClient(this.#brokerId);
+		if (!client) {
+			this.runtimeState.setCapState(DISH_CAP, {
+				...COLD_START,
+				lastFetchedAt: Date.now()
+			});
+			return;
+		}
+		const features = client.getFeatures(this.#haId);
+		this.#intensiveZoneWriteKey = intensiveZoneFeatureKeyFromFeatures(features);
+		const slice = dishwasherStatusFromFeatures({
+			features,
+			availablePrograms: this.#availablePrograms,
+			nowMs: Date.now()
+		});
+		this.runtimeState.setCapState(DISH_CAP, slice);
+	}
+	requireClient() {
+		const client = homeConnectConnections.getClient(this.#brokerId);
+		if (!client) throw new Error(`Home Connect client unavailable (haId=${this.#haId})`);
+		return client;
+	}
+	registerDishwasherCap() {
+		this.ctx.registerNativeCap(dishwasherCapability, {
+			getStatus: async () => this.runtimeState.getCapState(DISH_CAP) ?? COLD_START,
+			start: async () => {
+				await this.requireClient().setFeature(this.#haId, HC_CMD_START, {});
+			},
+			pause: async () => {
+				await this.requireClient().setFeature(this.#haId, HC_CMD_PAUSE, {});
+			},
+			stop: async () => {
+				await this.requireClient().setFeature(this.#haId, HC_CMD_STOP, {});
+			},
+			setProgram: async ({ program }) => {
+				await this.requireClient().setFeature(this.#haId, HC_CMD_SET_PROGRAM, program);
+			},
+			setPower: async ({ on }) => {
+				await this.requireClient().setFeature(this.#haId, HC_CMD_SET_POWER, on ? "On" : "Off");
+			},
+			setHalfLoad: async ({ on }) => {
+				await this.requireClient().setFeature(this.#haId, HC_FEATURE_HALF_LOAD, on);
+			},
+			setHygienePlus: async ({ on }) => {
+				await this.requireClient().setFeature(this.#haId, HC_FEATURE_HYGIENE, on);
+			},
+			setExtraDry: async ({ on }) => {
+				await this.requireClient().setFeature(this.#haId, HC_FEATURE_EXTRA_DRY, on);
+			},
+			setIntensiveZone: async ({ on }) => {
+				await this.requireClient().setFeature(this.#haId, this.#intensiveZoneWriteKey, on);
+			},
+			setVarioSpeedPlus: async ({ on }) => {
+				await this.requireClient().setFeature(this.#haId, HC_FEATURE_VARIO_SPEED_PLUS, on);
+			},
+			setChildLock: async ({ on }) => {
+				await this.requireClient().setFeature(this.#haId, HC_FEATURE_CHILD_LOCK, on);
+			},
+			setOption: async ({ key, value }) => {
+				await this.requireClient().setFeature(this.#haId, key, value);
+			}
+		});
+	}
+};
+//#endregion
+//#region src/home-connect/devices/home-connect-sensor-device.ts
+var homeConnectSensorSchema = object({
+	haId: string().min(1),
+	brokerId: string().min(1),
+	sensorKind: string().min(1),
+	system: literal("home-connect").optional(),
+	integrationId: string().optional()
+});
+var NUMERIC_COLD = {
+	value: 0,
+	lastFetchedAt: 0
+};
+var POWER_COLD = { lastFetchedAt: 0 };
+var ENUM_COLD = {
+	value: "unknown",
+	lastFetchedAt: 0
+};
+var BINARY_COLD = {
+	on: false,
+	lastChangedAt: 0
+};
+/**
+* One Home Connect read-only metric as a Sensor accessory child of the appliance
+* container (energy/water forecasts, remote-control level, delayed start, …).
+*/
+var HomeConnectSensorDevice = class extends BaseDevice {
+	features = [];
+	#haId;
+	#brokerId;
+	#sensorKind;
+	#capName;
+	#featureUnsub = null;
+	constructor(ctx) {
+		const persisted = homeConnectSensorSchema.parse(ctx.persistedConfig ?? {});
+		super(ctx, homeConnectSensorSchema, { type: ctx.deviceMeta.type });
+		this.#haId = persisted.haId;
+		this.#brokerId = persisted.brokerId;
+		this.#sensorKind = persisted.sensorKind;
+		const catalog = homeConnectSensorCatalogEntry(this.#sensorKind);
+		this.#capName = catalog.cap;
+		this.online = true;
+		this.updateSourceInfo({
+			id: `${this.#haId}:${catalog.stableIdSuffix}`,
+			system: "home-connect"
+		});
+	}
+	async onActivate() {
+		await super.onActivate();
+		this.registerCap();
+		this.seedColdStart();
+		this.attachFeatureListener();
+		this.recomputeSlice();
+	}
+	async removeDevice() {
+		this.#featureUnsub?.();
+		this.#featureUnsub = null;
+		await super.removeDevice();
+	}
+	seedColdStart() {
+		switch (this.#capName) {
+			case "numeric-sensor":
+				this.runtimeState.setCapState("numeric-sensor", NUMERIC_COLD);
+				break;
+			case "power-meter":
+				this.runtimeState.setCapState("power-meter", POWER_COLD);
+				break;
+			case "enum-sensor":
+				this.runtimeState.setCapState("enum-sensor", ENUM_COLD);
+				break;
+			case "binary":
+				this.runtimeState.setCapState("binary", BINARY_COLD);
+				break;
+			default: break;
+		}
+	}
+	attachFeatureListener() {
+		const client = homeConnectConnections.getClient(this.#brokerId);
+		if (!client) return;
+		this.#featureUnsub = client.onFeatureChange((haId) => {
+			if (haId !== this.#haId) return;
+			this.recomputeSlice();
+		});
+	}
+	recomputeSlice() {
+		const client = homeConnectConnections.getClient(this.#brokerId);
+		const nowMs = Date.now();
+		if (!client) {
+			this.seedColdStart();
+			return;
+		}
+		const parsed = homeConnectSensorSliceFromFeatures({
+			kind: this.#sensorKind,
+			features: client.getFeatures(this.#haId),
+			nowMs
+		});
+		if (parsed.cap === "numeric-sensor") {
+			if (parsed.status === null) return;
+			this.runtimeState.setCapState("numeric-sensor", parsed.status);
+			return;
+		}
+		this.runtimeState.setCapState(parsed.cap, parsed.status);
+	}
+	registerCap() {
+		if (this.#capName === "numeric-sensor") {
+			this.ctx.registerNativeCap(numericSensorCapability, { getStatus: async () => this.runtimeState.getCapState("numeric-sensor") ?? NUMERIC_COLD });
+			return;
+		}
+		if (this.#capName === "power-meter") {
+			this.ctx.registerNativeCap(powerMeterCapability, { getStatus: async () => this.runtimeState.getCapState("power-meter") ?? POWER_COLD });
+			return;
+		}
+		if (this.#capName === "enum-sensor") {
+			this.ctx.registerNativeCap(enumSensorCapability, { getStatus: async () => this.runtimeState.getCapState("enum-sensor") ?? ENUM_COLD });
+			return;
+		}
+		this.ctx.registerNativeCap(binaryCapability, { getStatus: async () => this.runtimeState.getCapState("binary") ?? BINARY_COLD });
+	}
+};
+//#endregion
+//#region src/home-connect/devices/home-connect-appliance-device.ts
+var homeConnectApplianceChildSchema = object({
+	role: string().min(1),
+	stableIdSuffix: string().min(1),
+	name: string()
+});
+var homeConnectApplianceSchema = object({
+	haId: string().min(1),
+	brokerId: string().min(1),
+	applianceType: string().optional(),
+	availablePrograms: array(string()).default([]),
+	children: array(homeConnectApplianceChildSchema).min(1),
+	system: literal("home-connect").optional(),
+	integrationId: string().optional()
+});
+/** One Home Connect appliance as a container with dishwasher + metric sensor children. */
+var HomeConnectApplianceDevice = class extends BaseDevice {
+	features = [];
+	integrationId;
+	brokerId;
+	haId;
+	applianceType;
+	availablePrograms;
+	constructor(ctx) {
+		const cfg = homeConnectApplianceSchema.parse(ctx.persistedConfig ?? {});
+		super(ctx, homeConnectApplianceSchema, { type: DeviceType.Container });
+		this.brokerId = cfg.brokerId;
+		this.haId = cfg.haId;
+		this.integrationId = cfg.integrationId;
+		this.applianceType = cfg.applianceType;
+		this.availablePrograms = cfg.availablePrograms;
+		this.online = true;
+		this.updateSourceInfo({
+			id: cfg.haId,
+			system: "home-connect"
+		});
+	}
+	getAccessoryChildren() {
+		const cfg = this.config.values;
+		const containerName = this.name;
+		const catalogSpecs = buildHomeConnectApplianceChildSpecs(containerName, this.haId);
+		const persistedBySuffix = new Map(cfg.children.map((c) => [c.stableIdSuffix, c]));
+		const childRows = catalogSpecs.map((spec) => {
+			const saved = persistedBySuffix.get(spec.stableIdSuffix);
+			if (saved !== void 0) return {
+				role: spec.role,
+				stableIdSuffix: saved.stableIdSuffix,
+				name: saved.name.length > 0 ? saved.name : spec.name
+			};
+			return {
+				role: spec.role,
+				stableIdSuffix: spec.stableIdSuffix,
+				name: spec.name
+			};
+		});
+		const out = [];
+		for (const child of childRows) {
+			if (child.role === "dishwasher") {
+				const config = {
+					haId: this.haId,
+					brokerId: this.brokerId,
+					applianceType: this.applianceType,
+					availablePrograms: [...this.availablePrograms],
+					system: "home-connect",
+					...this.integrationId !== void 0 ? { integrationId: this.integrationId } : {}
+				};
+				out.push({
+					stableIdSuffix: child.stableIdSuffix,
+					meta: {
+						type: DeviceType.Dishwasher,
+						name: child.name.length > 0 ? child.name : homeConnectDishwasherEntityName(containerName),
+						linkDeviceId: this.id,
+						...this.integrationId !== void 0 ? { integrationId: this.integrationId } : {}
+					},
+					config,
+					factory: (childCtx) => new HomeConnectDishwasherDevice(childCtx)
+				});
+				continue;
+			}
+			const sensorKind = child.role;
+			const catalog = HOME_CONNECT_SENSOR_CATALOG.find((entry) => entry.kind === sensorKind);
+			if (catalog === void 0) {
+				this.ctx.logger.warn("Home Connect appliance: skipping unknown sensor child role", { meta: {
+					haId: this.haId,
+					role: child.role,
+					stableIdSuffix: child.stableIdSuffix
+				} });
+				continue;
+			}
+			const config = {
+				haId: this.haId,
+				brokerId: this.brokerId,
+				sensorKind,
+				system: "home-connect",
+				...this.integrationId !== void 0 ? { integrationId: this.integrationId } : {}
+			};
+			out.push({
+				stableIdSuffix: child.stableIdSuffix,
+				meta: {
+					type: DeviceType.Sensor,
+					role: catalog.role,
+					name: child.name,
+					linkDeviceId: this.id,
+					...this.integrationId !== void 0 ? { integrationId: this.integrationId } : {}
+				},
+				config,
+				factory: (childCtx) => new HomeConnectSensorDevice(childCtx)
+			});
+		}
+		return out;
+	}
+};
+//#endregion
+//#region src/home-connect/addon.ts
+var BoschHomeConnectProviderAddon = class extends BaseDeviceProvider {
+	addonId = "bosch-home-connect";
+	providerName = "Bosch Home Connect";
+	deviceClasses = {
+		[DeviceType.Container]: HomeConnectApplianceDevice,
+		[DeviceType.Dishwasher]: HomeConnectDishwasherDevice,
+		[DeviceType.Sensor]: HomeConnectSensorDevice
+	};
+	clients = null;
+	constructor() {
+		super({});
+	}
+	async onInitialize() {
+		const regs = this.providerRegistrationsFromSuper(await super.onInitialize());
+		this.clients = new HomeConnectClientRegistry(this.ctx.logger, { onConnectionUpdated: (integrationId, connection) => {
+			this.persistIntegrationAppliances(integrationId, connection);
+		} });
+		this.clients.setOnConnected((integrationId) => {
+			this.setIntegrationDevicesOnline(integrationId, true);
+		});
+		this.clients.setOnDisconnected((integrationId) => {
+			this.setIntegrationDevicesOnline(integrationId, false);
+		});
+		await this.reconcileIntegrations();
+		this.subscribeIntegrationLifecycle();
+		return {
+			providers: [
+				...regs,
+				{
+					capability: deviceAdoptionCapability,
+					provider: this.buildAdoptionProvider()
+				},
+				{
+					capability: connectionTestCapability,
+					provider: this.buildConnectionTestProvider()
+				}
+			],
+			customActions: homeConnectActions,
+			actionHandlers: {
+				beginSignIn: async () => {
+					const started = beginHomeConnectSignIn();
+					return {
+						authorizeUrl: started.authorizeUrl,
+						verifier: started.verifier,
+						state: started.state,
+						summary: "Open the link in the browser and sign in."
+					};
+				},
+				finishSignIn: async (input) => {
+					const account = await completeHomeConnectSignIn({
+						verifier: input.verifier,
+						callback: input.callback,
+						state: input.state
+					});
+					const appliances = account.appliances.map((app) => ({
+						haId: app.haId,
+						name: app.name,
+						type: app.type,
+						host: app.connection.host,
+						psk: app.connection.psk,
+						mode: app.connection.mode,
+						...app.connection.iv64.length > 0 ? { iv64: app.connection.iv64 } : {},
+						...parseLoginDeviceDescription(app.connection.deviceDescription)
+					}));
+					return {
+						token: account.token,
+						...account.refresh.length > 0 ? { refresh: account.refresh } : {},
+						appliances: JSON.stringify(appliances),
+						summary: account.summary
+					};
+				}
+			}
+		};
+	}
+	async onShutdown() {
+		try {
+			await this.clients?.shutdown();
+		} catch (err) {
+			this.ctx.logger.warn("Home Connect shutdown error", { meta: { error: errMsg(err) } });
+		}
+		this.clients = null;
+		await super.onShutdown();
+	}
+	requireClients() {
+		if (!this.clients) throw new Error("Home Connect provider not initialised");
+		return this.clients;
+	}
+	generateStableId(type, config) {
+		const integrationId = config?.["brokerId"];
+		if (typeof integrationId !== "string" || integrationId.length === 0) throw new Error("home-connect generateStableId: brokerId required");
+		const haId = config?.["haId"];
+		if (typeof haId !== "string" || haId.length === 0) throw new Error("home-connect generateStableId: haId required");
+		if (type === DeviceType.Container) return `home-connect:${integrationId}:${haId}:appliance`;
+		return `home-connect:${integrationId}:${haId}`;
+	}
+	async persistIntegrationAppliances(integrationId, connection) {
+		if (!connection.appliances || connection.appliances.length === 0) return;
+		try {
+			const merged = homeConnectSettingsForPersist({
+				...await this.ctx.api.integrations.getSettings.query({ id: integrationId }),
+				appliances: connection.appliances
+			});
+			await this.ctx.api.integrations.setSettings.mutate({
+				id: integrationId,
+				settings: merged
+			});
+		} catch (err) {
+			this.ctx.logger.warn("Home Connect failed to persist enriched appliance IDDF", { meta: {
+				integrationId,
+				error: errMsg(err)
+			} });
+		}
+	}
+	async reconcileIntegrations() {
+		const reg = this.requireClients();
+		try {
+			const mine = (await this.ctx.api.integrations.list.query()).filter((i) => i.addonId === this.ctx.id && i.enabled);
+			const surviving = /* @__PURE__ */ new Set();
+			for (const integration of mine) try {
+				const settings = await this.ctx.api.integrations.getSettings.query({ id: integration.id });
+				const connection = connectionFromSettings(settings);
+				if (!connection) {
+					logHomeConnectSettingsGap(this.ctx.logger, integration.id, settings);
+					continue;
+				}
+				await reg.upsert(integration.id, integration.name, connection);
+				const brokerInfo = reg.getInfo(integration.id);
+				const applianceCount = typeof brokerInfo?.info["applianceCount"] === "number" ? brokerInfo.info["applianceCount"] : 0;
+				this.ctx.logger.info("Home Connect integration reconciled", { meta: {
+					integrationId: integration.id,
+					applianceCount
+				} });
+				surviving.add(integration.id);
+			} catch (err) {
+				this.ctx.logger.warn("Home Connect reconcile failed for integration", { meta: {
+					integrationId: integration.id,
+					error: errMsg(err)
+				} });
+			}
+			const vanished = reg.list().filter((id) => !surviving.has(id));
+			await reg.retain(surviving);
+			const deviceReg = this.ctx.kernel.deviceRegistry;
+			const deviceApi = this.ctx.kernel.devices;
+			if (deviceReg && deviceApi) for (const integrationId of vanished) await cascadeRemoveDevicesForIntegration({
+				reg: deviceReg,
+				devices: deviceApi,
+				addonId: this.addonId,
+				system: "home-connect",
+				integrationId,
+				logger: this.ctx.logger
+			});
+		} catch (err) {
+			this.ctx.logger.warn("Home Connect integration reconcile failed", { meta: { error: errMsg(err) } });
+		}
+	}
+	subscribeIntegrationLifecycle() {
+		const handler = (event) => {
+			const addonId = event.data["addonId"];
+			if (typeof addonId === "string" && addonId !== this.ctx.id) return;
+			this.reconcileIntegrations();
+		};
+		this.ctx.eventBus.subscribe({ category: EventCategory.IntegrationEnabled }, handler);
+		this.ctx.eventBus.subscribe({ category: EventCategory.IntegrationDisabled }, handler);
+		this.ctx.eventBus.subscribe({ category: EventCategory.IntegrationDeleted }, handler);
+	}
+	buildConnectionTestProvider() {
+		return buildHomeConnectConnectionTestProvider({ logger: this.ctx.logger });
+	}
+	buildAdoptionProvider() {
+		return buildHomeConnectAdoptionProvider({
+			registry: homeConnectConnections,
+			hasIntegration: (id) => this.requireClients().has(id),
+			listIntegrations: () => this.requireClients().list(),
+			listAdopted: async () => {
+				const reg = this.ctx.kernel.deviceRegistry;
+				const devices = this.ctx.kernel.devices;
+				if (!reg || !devices) return [];
+				const out = [];
+				for (const d of reg.getAllForAddon(this.addonId)) {
+					const config = await devices.loadConfig(d.id).catch(() => ({}));
+					out.push({
+						id: d.id,
+						config
+					});
+				}
+				return out;
+			},
+			adoptDevice: async ({ haId, integrationId, type, name, applianceType, availablePrograms }) => {
+				const devices = this.ctx.kernel.devices;
+				if (!devices) throw new Error("home-connect adopt: devices unavailable");
+				if (type !== DeviceType.Container) throw new Error(`home-connect adopt: expected Container, got ${type}`);
+				const children = buildHomeConnectApplianceChildSpecs(name, haId).map((child) => ({
+					role: child.role,
+					stableIdSuffix: child.stableIdSuffix,
+					name: child.name
+				}));
+				const config = {
+					haId,
+					brokerId: integrationId,
+					applianceType,
+					availablePrograms: [...availablePrograms],
+					children,
+					system: "home-connect",
+					integrationId
+				};
+				const stableId = this.generateStableId(type, config);
+				return { deviceId: (await devices.create(stableId, HomeConnectApplianceDevice, config, null, {
+					type: DeviceType.Container,
+					name,
+					integrationId
+				})).id };
+			},
+			removeDevice: async (id) => {
+				await this.ctx.kernel.devices?.remove(id);
+			},
+			findDeviceConfig: async (id) => {
+				const devices = this.ctx.kernel.devices;
+				if (!devices) return null;
+				return devices.loadConfig(id).catch(() => null);
+			},
+			logger: this.ctx.logger
+		});
+	}
+	globalSettingsSchema() {
+		return buildHomeConnectFormSchema();
+	}
+	async supportsManualCreation() {
+		return false;
+	}
+	async onGetCreationSchema(_type) {
+		return null;
+	}
+	async onCreateDevice(_type, _config) {
+		throw new Error("Home Connect devices are adopted from the gateway");
+	}
+	setIntegrationDevicesOnline(integrationId, online) {
+		const reg = this.ctx.kernel.deviceRegistry;
+		if (!reg) return;
+		setIntegrationDevicesOnline(reg.getAllForAddon(this.addonId), "home-connect", integrationId, online);
+	}
+};
+//#endregion
+export { BoschHomeConnectProviderAddon };